diff --git a/.gitattributes b/.gitattributes
index b39d7370623649d53d1a6e65701fe35a51c7f2ec..deea3b31efc725f501994000bbb402ffee67834a 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -32,3 +32,13 @@ client/public/fonts/Poppins-Regular.ttf filter=lfs diff=lfs merge=lfs -text
 client/public/fonts/Poppins-SemiBold.ttf filter=lfs diff=lfs merge=lfs -text
 client/public/icons/trek-loading-dark.gif filter=lfs diff=lfs merge=lfs -text
 client/public/icons/trek-loading-light.gif filter=lfs diff=lfs merge=lfs -text
+docs/TREK-Generated-by-MCP.pdf filter=lfs diff=lfs merge=lfs -text
+docs/logo-trek-dark.gif filter=lfs diff=lfs merge=lfs -text
+docs/logo-trek-light.gif filter=lfs diff=lfs merge=lfs -text
+docs/screenshots/atlas.png filter=lfs diff=lfs merge=lfs -text
+docs/screenshots/budget.png filter=lfs diff=lfs merge=lfs -text
+docs/screenshots/dashboard.png filter=lfs diff=lfs merge=lfs -text
+docs/screenshots/journey.png filter=lfs diff=lfs merge=lfs -text
+docs/screenshots/trip-iceland.png filter=lfs diff=lfs merge=lfs -text
+docs/screenshots/trip-planner.png filter=lfs diff=lfs merge=lfs -text
+docs/screenshots/vacay.png filter=lfs diff=lfs merge=lfs -text
diff --git a/client/tests/environment/jsdom-native-abort.ts b/client/tests/environment/jsdom-native-abort.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1413dd8ae1b40fc1e027e468cee5aaa82fe2d737
--- /dev/null
+++ b/client/tests/environment/jsdom-native-abort.ts
@@ -0,0 +1,38 @@
+/**
+ * Custom Vitest environment that extends jsdom but preserves the native
+ * Node.js AbortController and AbortSignal.
+ *
+ * Problem: jsdom replaces globalThis.AbortController and AbortSignal with its
+ * own implementations. Node.js's undici-based fetch validates signals via
+ * `signal instanceof AbortSignal` against its own native class reference.
+ * jsdom's AbortSignal instances fail this check, causing fetch to throw:
+ *   TypeError: RequestInit: Expected signal ("AbortSignal {}") to be an
+ *   instance of AbortSignal.
+ *
+ * Fix: after jsdom installs its globals, restore the native AbortController
+ * and AbortSignal so fetch works correctly in tests.
+ */
+
+import { builtinEnvironments } from 'vitest/environments';
+
+const jsdomEnv = builtinEnvironments.jsdom;
+
+export default {
+  name: 'jsdom-native-abort',
+  transformMode: 'web' as const,
+
+  async setup(global: typeof globalThis, options: Record<string, unknown>) {
+    // Capture native AbortController/AbortSignal BEFORE jsdom patches them
+    const NativeAbortController = global.AbortController;
+    const NativeAbortSignal = global.AbortSignal;
+
+    // Run standard jsdom setup (installs jsdom globals, including its own AbortController)
+    const env = await jsdomEnv.setup(global, options as Parameters<typeof jsdomEnv.setup>[1]);
+
+    // Restore native AbortController so Node.js fetch (undici) accepts the signals
+    global.AbortController = NativeAbortController;
+    global.AbortSignal = NativeAbortSignal;
+
+    return env;
+  },
+};
diff --git a/client/tests/helpers/factories.ts b/client/tests/helpers/factories.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fec8f1a42813773cf9a6a12da81dcdfdd794e954
--- /dev/null
+++ b/client/tests/helpers/factories.ts
@@ -0,0 +1,304 @@
+/**
+ * Pure data builder functions for frontend tests.
+ * These return typed objects matching interfaces in src/types.ts.
+ * They do NOT touch a database.
+ */
+
+import type {
+  User,
+  Trip,
+  Day,
+  Place,
+  Assignment,
+  DayNote,
+  PackingItem,
+  TodoItem,
+  BudgetItem,
+  Reservation,
+  TripFile,
+  Tag,
+  Category,
+  Settings,
+  AppConfig,
+} from '../../src/types';
+
+// ── Counters ──────────────────────────────────────────────────────────────────
+
+let _seq = 0;
+function next(): number {
+  return ++_seq;
+}
+
+// ── InAppNotification (local interface, not in types.ts) ──────────────────────
+
+export interface InAppNotification {
+  id: number;
+  type: string;
+  message: string;
+  read: boolean;
+  created_at: string;
+  trip_id?: number | null;
+}
+
+// ── Builders ──────────────────────────────────────────────────────────────────
+
+export function buildUser(overrides: Partial<User> = {}): User {
+  const id = next();
+  return {
+    id,
+    username: `user${id}`,
+    email: `user${id}@example.com`,
+    role: 'user',
+    avatar_url: null,
+    maps_api_key: null,
+    created_at: '2025-01-01T00:00:00.000Z',
+    mfa_enabled: false,
+    must_change_password: false,
+    ...overrides,
+  };
+}
+
+export function buildAdmin(overrides: Partial<User> = {}): User {
+  return buildUser({ role: 'admin', ...overrides });
+}
+
+export function buildTrip(overrides: Partial<Trip> = {}): Trip {
+  const id = next();
+  return {
+    id,
+    user_id: 1,
+    title: `Trip ${id}`,
+    description: null,
+    start_date: '2025-06-01',
+    end_date: '2025-06-05',
+    currency: 'EUR',
+    cover_image: null,
+    is_archived: 0,
+    reminder_days: 7,
+    created_at: '2025-01-01T00:00:00.000Z',
+    updated_at: '2025-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+export function buildDay(overrides: Partial<Day> = {}): Day {
+  const id = next();
+  return {
+    id,
+    trip_id: 1,
+    date: '2025-06-01',
+    title: null,
+    notes: null,
+    assignments: [],
+    notes_items: [],
+    ...overrides,
+  };
+}
+
+export function buildPlace(overrides: Partial<Place> = {}): Place {
+  const id = next();
+  return {
+    id,
+    trip_id: 1,
+    name: `Place ${id}`,
+    description: null,
+    lat: 48.8566,
+    lng: 2.3522,
+    address: null,
+    category_id: null,
+    price: null,
+    currency: null,
+    image_url: null,
+    google_place_id: null,
+    osm_id: null,
+    route_geometry: null,
+    place_time: null,
+    end_time: null,
+    duration_minutes: 60,
+    notes: null,
+    transport_mode: 'walking',
+    website: null,
+    phone: null,
+    created_at: '2025-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+export function buildAssignment(overrides: Partial<Assignment> = {}): Assignment {
+  const id = next();
+  const place = overrides.place ?? buildPlace();
+  return {
+    id,
+    day_id: 1,
+    place_id: place.id,
+    order_index: 0,
+    notes: null,
+    place,
+    ...overrides,
+  };
+}
+
+export function buildDayNote(overrides: Partial<DayNote> = {}): DayNote {
+  const id = next();
+  return {
+    id,
+    day_id: 1,
+    text: 'Test note',
+    time: null,
+    icon: null,
+    sort_order: 0,
+    created_at: '2025-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+export function buildPackingItem(overrides: Partial<PackingItem> = {}): PackingItem {
+  const id = next();
+  return {
+    id,
+    trip_id: 1,
+    name: `Packing item ${id}`,
+    category: null,
+    checked: 0,
+    sort_order: 0,
+    quantity: 1,
+    ...overrides,
+  };
+}
+
+export function buildTodoItem(overrides: Partial<TodoItem> = {}): TodoItem {
+  const id = next();
+  return {
+    id,
+    trip_id: 1,
+    name: `Todo ${id}`,
+    category: null,
+    checked: 0,
+    sort_order: 0,
+    due_date: null,
+    description: null,
+    assigned_user_id: null,
+    priority: 0,
+    ...overrides,
+  };
+}
+
+export function buildBudgetItem(overrides: Partial<BudgetItem> = {}): BudgetItem {
+  const id = next();
+  return {
+    id,
+    trip_id: 1,
+    category: 'Other',
+    name: `Budget item ${id}`,
+    total_price: 100,
+    persons: 1,
+    days: null,
+    note: null,
+    sort_order: 0,
+    members: [],
+    expense_date: null,
+    created_at: '2025-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+export function buildReservation(overrides: Partial<Reservation> = {}): Reservation {
+  const id = next();
+  return {
+    id,
+    trip_id: 1,
+    title: `Reservation ${id}`,
+    type: 'restaurant',
+    status: 'confirmed',
+    reservation_time: null,
+    reservation_end_time: null,
+    location: null,
+    confirmation_number: null,
+    notes: null,
+    created_at: '2025-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+export function buildTripFile(overrides: Partial<TripFile> = {}): TripFile {
+  const id = next();
+  return {
+    id,
+    trip_id: 1,
+    filename: 'test.pdf',
+    original_name: 'test.pdf',
+    mime_type: 'application/pdf',
+    url: `/api/trips/1/files/${id}/download`,
+    created_at: '2025-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+export function buildTag(overrides: Partial<Tag> = {}): Tag {
+  const id = next();
+  return {
+    id,
+    name: `Tag ${id}`,
+    color: '#ff0000',
+    user_id: 1,
+    ...overrides,
+  };
+}
+
+export function buildCategory(overrides: Partial<Category> = {}): Category {
+  const id = next();
+  return {
+    id,
+    name: `Category ${id}`,
+    color: '#6366f1',
+    icon: 'restaurant',
+    user_id: 1,
+    ...overrides,
+  };
+}
+
+export function buildSettings(overrides: Partial<Settings> = {}): Settings {
+  return {
+    map_tile_url: '',
+    default_lat: 48.8566,
+    default_lng: 2.3522,
+    default_zoom: 10,
+    dark_mode: false,
+    default_currency: 'USD',
+    language: 'en',
+    temperature_unit: 'fahrenheit',
+    time_format: '12h',
+    show_place_description: false,
+    blur_booking_codes: false,
+    ...overrides,
+  };
+}
+
+export function buildInAppNotification(overrides: Partial<InAppNotification> = {}): InAppNotification {
+  const id = next();
+  return {
+    id,
+    type: 'trip_invite',
+    message: `Notification ${id}`,
+    read: false,
+    created_at: '2025-01-01T00:00:00.000Z',
+    trip_id: null,
+    ...overrides,
+  };
+}
+
+export function buildAppConfig(overrides: Partial<AppConfig> = {}): AppConfig {
+  return {
+    has_users: true,
+    allow_registration: true,
+    demo_mode: false,
+    oidc_configured: false,
+    oidc_only_mode: false,
+    password_login: true,
+    password_registration: true,
+    oidc_login: true,
+    oidc_registration: true,
+    env_override_oidc_only: false,
+    ...overrides,
+  };
+}
diff --git a/client/tests/helpers/msw/handlers/addons.ts b/client/tests/helpers/msw/handlers/addons.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8e2f84687aa5f0da9d641e5570206144b61b5b43
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/addons.ts
@@ -0,0 +1,13 @@
+import { http, HttpResponse } from 'msw';
+
+export const addonHandlers = [
+  http.get('/api/addons', () => {
+    return HttpResponse.json({
+      bagTracking: false,
+      addons: [
+        { id: 'vacay', name: 'Vacay', type: 'feature', icon: 'calendar', enabled: true },
+        { id: 'atlas', name: 'Atlas', type: 'feature', icon: 'map', enabled: true },
+      ],
+    });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/admin.ts b/client/tests/helpers/msw/handlers/admin.ts
new file mode 100644
index 0000000000000000000000000000000000000000..35d245c67b9fe33fb2a09f2a1ebba7964d62fcfb
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/admin.ts
@@ -0,0 +1,137 @@
+import { http, HttpResponse } from 'msw';
+import { buildUser, buildAdmin } from '../../factories';
+
+export const adminHandlers = [
+  http.get('/api/admin/users', () => {
+    const user1 = buildUser({ username: 'alice', email: 'alice@example.com' });
+    const admin1 = buildAdmin({ username: 'admin', email: 'admin@example.com' });
+    return HttpResponse.json({ users: [admin1, user1] });
+  }),
+
+  http.post('/api/admin/users', async ({ request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const user = buildUser({ ...body });
+    return HttpResponse.json({ user });
+  }),
+
+  http.put('/api/admin/users/:id', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const user = buildUser({ id: Number(params.id), ...body });
+    return HttpResponse.json({ user });
+  }),
+
+  http.delete('/api/admin/users/:id', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.get('/api/admin/stats', () => {
+    return HttpResponse.json({
+      totalUsers: 2,
+      totalTrips: 5,
+      totalPlaces: 42,
+      totalFiles: 8,
+    });
+  }),
+
+  http.get('/api/admin/invites', () => {
+    return HttpResponse.json({ invites: [] });
+  }),
+
+  http.post('/api/admin/invites', async ({ request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    return HttpResponse.json({ invite: { id: 1, token: 'test-invite-token', ...body } });
+  }),
+
+  http.delete('/api/admin/invites/:id', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.get('/api/admin/oidc', () => {
+    return HttpResponse.json({
+      issuer: '',
+      client_id: '',
+      client_secret: '',
+      client_secret_set: false,
+      display_name: '',
+      oidc_only: false,
+      discovery_url: '',
+    });
+  }),
+
+  http.put('/api/admin/oidc', async ({ request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    return HttpResponse.json({ ...body });
+  }),
+
+  http.get('/api/admin/version-check', () => {
+    return HttpResponse.json({ update_available: false, latest: '1.0.0', current: '1.0.0' });
+  }),
+
+  http.get('/api/admin/bag-tracking', () => {
+    return HttpResponse.json({ enabled: false });
+  }),
+
+  http.put('/api/admin/bag-tracking', async ({ request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    return HttpResponse.json({ enabled: body.enabled });
+  }),
+
+  http.get('/api/admin/addons', () => {
+    return HttpResponse.json({ addons: [] });
+  }),
+
+  http.get('/api/admin/packing-templates', () => {
+    return HttpResponse.json({ templates: [] });
+  }),
+
+  http.get('/api/admin/audit-log', () => {
+    return HttpResponse.json({ logs: [], total: 0 });
+  }),
+
+  http.get('/api/admin/mcp-tokens', () => {
+    return HttpResponse.json({ tokens: [] });
+  }),
+
+  http.get('/api/admin/oauth-sessions', () => {
+    return HttpResponse.json({ sessions: [] });
+  }),
+
+  http.delete('/api/admin/oauth-sessions/:id', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.delete('/api/admin/mcp-tokens/:id', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.get('/api/admin/permissions', () => {
+    return HttpResponse.json({ permissions: {} });
+  }),
+
+  http.get('/api/admin/notification-preferences', () => {
+    return HttpResponse.json({
+      event_types: [],
+      available_channels: {},
+      implemented_combos: {},
+      preferences: {},
+    });
+  }),
+
+  // Auth settings endpoints used by AdminPage
+  http.get('/api/auth/app-settings', () => {
+    return HttpResponse.json({});
+  }),
+
+  http.put('/api/auth/app-settings', async ({ request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    return HttpResponse.json({ ...body });
+  }),
+
+  http.get('/api/auth/me/settings', () => {
+    return HttpResponse.json({ settings: { maps_api_key: '', openweather_api_key: '' } });
+  }),
+
+  http.get('/api/auth/validate-keys', () => {
+    return HttpResponse.json({ maps: true, weather: true });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/assignments.ts b/client/tests/helpers/msw/handlers/assignments.ts
new file mode 100644
index 0000000000000000000000000000000000000000..62065badc0a3016d0a3fa2e99e46d908acee60ea
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/assignments.ts
@@ -0,0 +1,28 @@
+import { http, HttpResponse } from 'msw';
+import { buildAssignment, buildPlace } from '../../factories';
+
+export const assignmentsHandlers = [
+  http.post('/api/trips/:id/days/:dayId/assignments', async ({ params, request }) => {
+    const body = await request.json() as { place_id: number };
+    const place = buildPlace({ id: body.place_id, trip_id: Number(params.id) });
+    const assignment = buildAssignment({
+      day_id: Number(params.dayId),
+      place_id: body.place_id,
+      place,
+      order_index: 0,
+    });
+    return HttpResponse.json({ assignment });
+  }),
+
+  http.delete('/api/trips/:id/days/:dayId/assignments/:assignmentId', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.put('/api/trips/:id/days/:dayId/assignments/reorder', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.put('/api/trips/:id/assignments/:assignmentId/move', () => {
+    return HttpResponse.json({ success: true });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/auth.ts b/client/tests/helpers/msw/handlers/auth.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cb23efaef90fe0c69840a4c0e38ec2ca902d29e7
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/auth.ts
@@ -0,0 +1,31 @@
+import { http, HttpResponse } from 'msw';
+import { buildUser, buildAppConfig } from '../../factories';
+
+export const authHandlers = [
+  http.post('/api/auth/login', () => {
+    const user = buildUser();
+    return HttpResponse.json({ user, token: 'mock-token' });
+  }),
+
+  http.get('/api/auth/me', () => {
+    const user = buildUser();
+    return HttpResponse.json({ user });
+  }),
+
+  http.post('/api/auth/register', () => {
+    const user = buildUser();
+    return HttpResponse.json({ user, token: 'mock-token' });
+  }),
+
+  http.get('/api/auth/app-config', () => {
+    return HttpResponse.json(buildAppConfig());
+  }),
+
+  http.post('/api/auth/ws-token', () => {
+    return HttpResponse.json({ token: 'mock-ws-token' });
+  }),
+
+  http.post('/api/auth/logout', () => {
+    return HttpResponse.json({ success: true });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/budget.ts b/client/tests/helpers/msw/handlers/budget.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7b01d37ab7b85b759fd28b95424fe0905b6bad33
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/budget.ts
@@ -0,0 +1,38 @@
+import { http, HttpResponse } from 'msw';
+import { buildBudgetItem } from '../../factories';
+
+export const budgetHandlers = [
+  http.get('/api/trips/:id/budget', ({ params }) => {
+    return HttpResponse.json({
+      items: [buildBudgetItem({ trip_id: Number(params.id) })],
+    });
+  }),
+
+  http.post('/api/trips/:id/budget', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const item = buildBudgetItem({ trip_id: Number(params.id), ...body });
+    return HttpResponse.json({ item });
+  }),
+
+  http.put('/api/trips/:id/budget/:itemId', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const item = buildBudgetItem({ id: Number(params.itemId), trip_id: Number(params.id), ...body });
+    return HttpResponse.json({ item });
+  }),
+
+  http.delete('/api/trips/:id/budget/:itemId', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.put('/api/trips/:id/budget/:itemId/members', async ({ params, request }) => {
+    const body = await request.json() as { user_ids: number[] };
+    const members = body.user_ids.map(uid => ({ user_id: uid, paid: 0, username: `user${uid}` }));
+    const item = buildBudgetItem({ id: Number(params.itemId), trip_id: Number(params.id), persons: body.user_ids.length, members });
+    return HttpResponse.json({ members, item });
+  }),
+
+  http.put('/api/trips/:id/budget/:itemId/members/:userId/paid', async ({ params, request }) => {
+    const body = await request.json() as { paid: boolean };
+    return HttpResponse.json({ success: true, paid: body.paid });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/dayNotes.ts b/client/tests/helpers/msw/handlers/dayNotes.ts
new file mode 100644
index 0000000000000000000000000000000000000000..13a142769a33a8b374e2cc5ed02a14585c00b25e
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/dayNotes.ts
@@ -0,0 +1,31 @@
+import { http, HttpResponse } from 'msw';
+import { buildDayNote } from '../../factories';
+
+export const dayNotesHandlers = [
+  http.get('/api/trips/:id/days/:dayId/notes', ({ params }) => {
+    return HttpResponse.json({
+      notes: [buildDayNote({ day_id: Number(params.dayId) })],
+    });
+  }),
+
+  http.post('/api/trips/:id/days/:dayId/notes', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const note = buildDayNote({ day_id: Number(params.dayId), ...body });
+    return HttpResponse.json({ note });
+  }),
+
+  http.put('/api/trips/:id/days/:dayId/notes/:noteId', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const note = buildDayNote({ id: Number(params.noteId), day_id: Number(params.dayId), ...body });
+    return HttpResponse.json({ note });
+  }),
+
+  http.delete('/api/trips/:id/days/:dayId/notes/:noteId', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.put('/api/trips/:id/days/:dayId', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    return HttpResponse.json({ day: { id: Number(params.dayId), trip_id: Number(params.id), ...body } });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/files.ts b/client/tests/helpers/msw/handlers/files.ts
new file mode 100644
index 0000000000000000000000000000000000000000..eb03d5fe17d7f9dfe9cf58e3a7456d6e7c5c85c5
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/files.ts
@@ -0,0 +1,19 @@
+import { http, HttpResponse } from 'msw';
+import { buildTripFile } from '../../factories';
+
+export const filesHandlers = [
+  http.get('/api/trips/:id/files', ({ params }) => {
+    return HttpResponse.json({
+      files: [buildTripFile({ trip_id: Number(params.id) })],
+    });
+  }),
+
+  http.post('/api/trips/:id/files', ({ params }) => {
+    const file = buildTripFile({ trip_id: Number(params.id) });
+    return HttpResponse.json({ file });
+  }),
+
+  http.delete('/api/trips/:id/files/:fileId', () => {
+    return HttpResponse.json({ success: true });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/index.ts b/client/tests/helpers/msw/handlers/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3459b3b26c2ad93dcc5fb314b93ffbb619474639
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/index.ts
@@ -0,0 +1,37 @@
+import { authHandlers } from './auth';
+import { settingsHandlers } from './settings';
+import { addonHandlers } from './addons';
+import { notificationHandlers } from './notifications';
+import { vacayHandlers } from './vacay';
+import { tripsHandlers } from './trips';
+import { placesHandlers } from './places';
+import { assignmentsHandlers } from './assignments';
+import { packingHandlers } from './packing';
+import { todoHandlers } from './todo';
+import { budgetHandlers } from './budget';
+import { reservationsHandlers } from './reservations';
+import { filesHandlers } from './files';
+import { tagsHandlers } from './tags';
+import { dayNotesHandlers } from './dayNotes';
+import { adminHandlers } from './admin';
+import { sharedHandlers } from './shared';
+
+export const defaultHandlers = [
+  ...authHandlers,
+  ...settingsHandlers,
+  ...addonHandlers,
+  ...notificationHandlers,
+  ...vacayHandlers,
+  ...tripsHandlers,
+  ...placesHandlers,
+  ...assignmentsHandlers,
+  ...packingHandlers,
+  ...todoHandlers,
+  ...budgetHandlers,
+  ...reservationsHandlers,
+  ...filesHandlers,
+  ...tagsHandlers,
+  ...dayNotesHandlers,
+  ...adminHandlers,
+  ...sharedHandlers,
+];
diff --git a/client/tests/helpers/msw/handlers/notifications.ts b/client/tests/helpers/msw/handlers/notifications.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f009cee0f7603805e931d32cb9d39c6d391b8554
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/notifications.ts
@@ -0,0 +1,94 @@
+import { http, HttpResponse } from 'msw';
+
+export const notificationHandlers = [
+  http.get('/api/notifications/in-app', ({ request }) => {
+    const url = new URL(request.url);
+    const offset = parseInt(url.searchParams.get('offset') || '0', 10);
+    const limit = parseInt(url.searchParams.get('limit') || '20', 10);
+
+    const allNotifications = Array.from({ length: 25 }, (_, i) => ({
+      id: i + 1,
+      type: 'simple',
+      scope: 'trip',
+      target: 1,
+      sender_id: 2,
+      sender_username: 'alice',
+      sender_avatar: null,
+      recipient_id: 1,
+      title_key: 'notif.title',
+      title_params: '{}',
+      text_key: 'notif.text',
+      text_params: '{}',
+      positive_text_key: null,
+      negative_text_key: null,
+      response: null,
+      navigate_text_key: null,
+      navigate_target: null,
+      is_read: i < 5 ? 0 : 1,
+      created_at: '2025-01-01T00:00:00.000Z',
+    }));
+
+    const page = allNotifications.slice(offset, offset + limit);
+
+    return HttpResponse.json({
+      notifications: page,
+      total: allNotifications.length,
+      unread_count: 5,
+    });
+  }),
+
+  http.get('/api/notifications/in-app/unread-count', () => {
+    return HttpResponse.json({ count: 5 });
+  }),
+
+  http.put('/api/notifications/in-app/:id/read', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.put('/api/notifications/in-app/:id/unread', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.put('/api/notifications/in-app/read-all', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.delete('/api/notifications/in-app/:id', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.delete('/api/notifications/in-app/all', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.post('/api/notifications/test-ntfy', async () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.post('/api/notifications/in-app/:id/respond', async ({ request, params }) => {
+    const body = await request.json() as { response: string };
+    return HttpResponse.json({
+      notification: {
+        id: Number(params.id),
+        type: 'boolean',
+        scope: 'trip',
+        target: 1,
+        sender_id: 2,
+        sender_username: 'alice',
+        sender_avatar: null,
+        recipient_id: 1,
+        title_key: 'notif.title',
+        title_params: '{}',
+        text_key: 'notif.text',
+        text_params: '{}',
+        positive_text_key: 'accept',
+        negative_text_key: 'decline',
+        response: body.response,
+        navigate_text_key: null,
+        navigate_target: null,
+        is_read: 1,
+        created_at: '2025-01-01T00:00:00.000Z',
+      },
+    });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/packing.ts b/client/tests/helpers/msw/handlers/packing.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c3b0ed621d492c6c93ca0f3554d6e493bbfe1d53
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/packing.ts
@@ -0,0 +1,26 @@
+import { http, HttpResponse } from 'msw';
+import { buildPackingItem } from '../../factories';
+
+export const packingHandlers = [
+  http.get('/api/trips/:id/packing', ({ params }) => {
+    return HttpResponse.json({
+      items: [buildPackingItem({ trip_id: Number(params.id) })],
+    });
+  }),
+
+  http.post('/api/trips/:id/packing', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const item = buildPackingItem({ trip_id: Number(params.id), ...body });
+    return HttpResponse.json({ item });
+  }),
+
+  http.put('/api/trips/:id/packing/:itemId', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const item = buildPackingItem({ id: Number(params.itemId), trip_id: Number(params.id), ...body });
+    return HttpResponse.json({ item });
+  }),
+
+  http.delete('/api/trips/:id/packing/:itemId', () => {
+    return HttpResponse.json({ success: true });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/places.ts b/client/tests/helpers/msw/handlers/places.ts
new file mode 100644
index 0000000000000000000000000000000000000000..45f65a124783ecf9092ef46cb5a28b45884fad65
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/places.ts
@@ -0,0 +1,25 @@
+import { http, HttpResponse } from 'msw';
+import { buildPlace } from '../../factories';
+
+export const placesHandlers = [
+  http.get('/api/trips/:id/places', ({ params }) => {
+    const tripId = Number(params.id);
+    return HttpResponse.json({ places: [buildPlace({ trip_id: tripId }), buildPlace({ trip_id: tripId })] });
+  }),
+
+  http.post('/api/trips/:id/places', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const place = buildPlace({ trip_id: Number(params.id), ...body });
+    return HttpResponse.json({ place });
+  }),
+
+  http.put('/api/trips/:id/places/:placeId', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const place = buildPlace({ id: Number(params.placeId), trip_id: Number(params.id), ...body });
+    return HttpResponse.json({ place });
+  }),
+
+  http.delete('/api/trips/:id/places/:placeId', () => {
+    return HttpResponse.json({ success: true });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/reservations.ts b/client/tests/helpers/msw/handlers/reservations.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d99a883449dd6447739e5b5c372fea12c8106b20
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/reservations.ts
@@ -0,0 +1,30 @@
+import { http, HttpResponse } from 'msw';
+import { buildReservation } from '../../factories';
+
+export const reservationsHandlers = [
+  http.get('/api/trips/:id/reservations', ({ params }) => {
+    return HttpResponse.json({
+      reservations: [buildReservation({ trip_id: Number(params.id) })],
+    });
+  }),
+
+  http.post('/api/trips/:id/reservations', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const reservation = buildReservation({ trip_id: Number(params.id), ...body });
+    return HttpResponse.json({ reservation });
+  }),
+
+  http.put('/api/trips/:id/reservations/:reservationId', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const reservation = buildReservation({
+      id: Number(params.reservationId),
+      trip_id: Number(params.id),
+      ...body,
+    });
+    return HttpResponse.json({ reservation });
+  }),
+
+  http.delete('/api/trips/:id/reservations/:reservationId', () => {
+    return HttpResponse.json({ success: true });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/settings.ts b/client/tests/helpers/msw/handlers/settings.ts
new file mode 100644
index 0000000000000000000000000000000000000000..99c027168105fa6436478e2920a84bcc31152fb7
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/settings.ts
@@ -0,0 +1,16 @@
+import { http, HttpResponse } from 'msw';
+import { buildSettings } from '../../factories';
+
+export const settingsHandlers = [
+  http.get('/api/settings', () => {
+    return HttpResponse.json({ settings: buildSettings() });
+  }),
+
+  http.put('/api/settings', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.post('/api/settings/bulk', () => {
+    return HttpResponse.json({ success: true });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/shared.ts b/client/tests/helpers/msw/handlers/shared.ts
new file mode 100644
index 0000000000000000000000000000000000000000..891f6ebbf8be8b82b32e7ea3c5269a06f9415d31
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/shared.ts
@@ -0,0 +1,36 @@
+import { http, HttpResponse } from 'msw';
+import { buildTrip, buildDay, buildPlace } from '../../factories';
+
+export const sharedHandlers = [
+  http.get('/api/shared/:token', ({ params }) => {
+    const { token } = params;
+
+    if (token === 'invalid-token' || token === 'expired-token') {
+      return new HttpResponse(null, { status: 404 });
+    }
+
+    const trip = { ...buildTrip({ start_date: '2026-07-01', end_date: '2026-07-05' }), title: 'Shared Paris Trip' };
+    const day1 = buildDay({ trip_id: trip.id, date: '2026-07-01' });
+    const place1 = buildPlace({ trip_id: trip.id, name: 'Eiffel Tower', lat: 48.8584, lng: 2.2945 });
+
+    return HttpResponse.json({
+      trip,
+      days: [day1],
+      assignments: {},
+      dayNotes: {},
+      places: [place1],
+      reservations: [],
+      accommodations: [],
+      packing: [],
+      budget: [],
+      categories: [],
+      permissions: {
+        share_bookings: true,
+        share_packing: false,
+        share_budget: false,
+        share_collab: false,
+      },
+      collab: [],
+    });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/tags.ts b/client/tests/helpers/msw/handlers/tags.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ab8aa9419fa51f486456d35237dfa40536e1f65e
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/tags.ts
@@ -0,0 +1,24 @@
+import { http, HttpResponse } from 'msw';
+import { buildTag, buildCategory } from '../../factories';
+
+export const tagsHandlers = [
+  http.get('/api/tags', () => {
+    return HttpResponse.json({ tags: [buildTag(), buildTag()] });
+  }),
+
+  http.post('/api/tags', async ({ request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const tag = buildTag(body);
+    return HttpResponse.json({ tag });
+  }),
+
+  http.get('/api/categories', () => {
+    return HttpResponse.json({ categories: [buildCategory(), buildCategory()] });
+  }),
+
+  http.post('/api/categories', async ({ request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const category = buildCategory(body);
+    return HttpResponse.json({ category });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/todo.ts b/client/tests/helpers/msw/handlers/todo.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e9ad6f0307998d2b3d1390ec2fe0dbf37601be36
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/todo.ts
@@ -0,0 +1,26 @@
+import { http, HttpResponse } from 'msw';
+import { buildTodoItem } from '../../factories';
+
+export const todoHandlers = [
+  http.get('/api/trips/:id/todo', ({ params }) => {
+    return HttpResponse.json({
+      items: [buildTodoItem({ trip_id: Number(params.id) })],
+    });
+  }),
+
+  http.post('/api/trips/:id/todo', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const item = buildTodoItem({ trip_id: Number(params.id), ...body });
+    return HttpResponse.json({ item });
+  }),
+
+  http.put('/api/trips/:id/todo/:itemId', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const item = buildTodoItem({ id: Number(params.itemId), trip_id: Number(params.id), ...body });
+    return HttpResponse.json({ item });
+  }),
+
+  http.delete('/api/trips/:id/todo/:itemId', () => {
+    return HttpResponse.json({ success: true });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/trips.ts b/client/tests/helpers/msw/handlers/trips.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9ffde4797c9841fee3cb5c8709d7953506804007
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/trips.ts
@@ -0,0 +1,75 @@
+import { http, HttpResponse } from 'msw';
+import { buildTrip, buildDay, buildUser, buildPlace, buildPackingItem, buildTodoItem, buildBudgetItem, buildReservation, buildTripFile } from '../../factories';
+
+export const tripsHandlers = [
+  // List all trips (active or archived)
+  http.get('/api/trips', ({ request }) => {
+    const url = new URL(request.url);
+    const archived = url.searchParams.get('archived');
+    if (archived) {
+      return HttpResponse.json({ trips: [] });
+    }
+    const trip1 = buildTrip({ title: 'Paris Adventure', start_date: '2026-07-01', end_date: '2026-07-10' });
+    const trip2 = buildTrip({ title: 'Tokyo Trip', start_date: '2026-09-01', end_date: '2026-09-15' });
+    return HttpResponse.json({ trips: [trip1, trip2] });
+  }),
+
+  http.get('/api/trips/:id', ({ params }) => {
+    const trip = buildTrip({ id: Number(params.id) });
+    return HttpResponse.json({ trip });
+  }),
+
+  http.get('/api/trips/:id/days', ({ params }) => {
+    const tripId = Number(params.id);
+    const day1 = buildDay({ trip_id: tripId, assignments: [], notes_items: [] });
+    const day2 = buildDay({ trip_id: tripId, assignments: [], notes_items: [] });
+    return HttpResponse.json({ days: [day1, day2] });
+  }),
+
+  http.put('/api/trips/:id', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const trip = buildTrip({ id: Number(params.id), ...body });
+    return HttpResponse.json({ trip });
+  }),
+
+  http.post('/api/trips', async ({ request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const trip = buildTrip({ ...body });
+    return HttpResponse.json({ trip });
+  }),
+
+  http.get('/api/trips/:id/members', ({ params }) => {
+    const owner = buildUser();
+    return HttpResponse.json({ owner, members: [] });
+  }),
+
+  http.get('/api/trips/:id/accommodations', () => {
+    return HttpResponse.json({ accommodations: [] });
+  }),
+
+  http.get('/api/trips/:id/bundle', ({ params }) => {
+    const tripId = Number(params.id);
+    const trip = buildTrip({ id: tripId });
+    const day = buildDay({ trip_id: tripId, assignments: [], notes_items: [] });
+    return HttpResponse.json({
+      trip,
+      days: [day],
+      places: [buildPlace({ trip_id: tripId })],
+      packingItems: [buildPackingItem({ trip_id: tripId })],
+      todoItems: [buildTodoItem({ trip_id: tripId })],
+      budgetItems: [buildBudgetItem({ trip_id: tripId })],
+      reservations: [buildReservation({ trip_id: tripId })],
+      files: [buildTripFile({ trip_id: tripId })],
+    });
+  }),
+
+  http.delete('/api/trips/:id', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.post('/api/trips/:id/copy', async ({ params, request }) => {
+    const body = await request.json() as Record<string, unknown>;
+    const trip = buildTrip({ id: Number(params.id) + 1000, ...body });
+    return HttpResponse.json({ trip });
+  }),
+];
diff --git a/client/tests/helpers/msw/handlers/vacay.ts b/client/tests/helpers/msw/handlers/vacay.ts
new file mode 100644
index 0000000000000000000000000000000000000000..70506526e79981c86c5f6b7c27fd5523b1ddd5cb
--- /dev/null
+++ b/client/tests/helpers/msw/handlers/vacay.ts
@@ -0,0 +1,127 @@
+import { http, HttpResponse } from 'msw';
+
+export const vacayHandlers = [
+  http.get('/api/addons/vacay/plan', () => {
+    return HttpResponse.json({
+      plan: {
+        id: 1,
+        holidays_enabled: false,
+        holidays_region: null,
+        holiday_calendars: [],
+        block_weekends: true,
+        carry_over_enabled: false,
+        company_holidays_enabled: false,
+      },
+      users: [{ id: 1, username: 'user1', color: '#3b82f6' }],
+      pendingInvites: [],
+      incomingInvites: [],
+      isOwner: true,
+      isFused: false,
+    });
+  }),
+
+  http.put('/api/addons/vacay/plan', () => {
+    return HttpResponse.json({
+      plan: {
+        id: 1,
+        holidays_enabled: true,
+        holidays_region: null,
+        holiday_calendars: [],
+        block_weekends: true,
+        carry_over_enabled: false,
+        company_holidays_enabled: false,
+      },
+    });
+  }),
+
+  http.get('/api/addons/vacay/years', () => {
+    return HttpResponse.json({ years: [2025, 2026] });
+  }),
+
+  http.post('/api/addons/vacay/years', () => {
+    return HttpResponse.json({ years: [2025, 2026, 2027] });
+  }),
+
+  http.delete('/api/addons/vacay/years/:year', () => {
+    return HttpResponse.json({ years: [2025] });
+  }),
+
+  http.get('/api/addons/vacay/entries/:year', () => {
+    return HttpResponse.json({
+      entries: [
+        { date: '2025-06-15', user_id: 1 },
+        { date: '2025-06-16', user_id: 1 },
+      ],
+      companyHolidays: [],
+    });
+  }),
+
+  http.post('/api/addons/vacay/entries/toggle', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.post('/api/addons/vacay/entries/company-holiday', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.get('/api/addons/vacay/stats/:year', () => {
+    return HttpResponse.json({
+      stats: [{ user_id: 1, vacation_days: 30, used: 2 }],
+    });
+  }),
+
+  http.put('/api/addons/vacay/stats/:year', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.get('/api/addons/vacay/holidays/countries', () => {
+    return HttpResponse.json({ countries: ['DE', 'US', 'FR'] });
+  }),
+
+  http.get('/api/addons/vacay/holidays/:year/:country', () => {
+    return HttpResponse.json([
+      { date: '2025-12-25', name: 'Christmas', localName: 'Weihnachten', global: true, counties: null },
+      { date: '2025-01-01', name: 'New Year', localName: 'Neujahr', global: true, counties: null },
+    ]);
+  }),
+
+  http.put('/api/addons/vacay/color', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.post('/api/addons/vacay/invite', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.post('/api/addons/vacay/invite/accept', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.post('/api/addons/vacay/invite/decline', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.post('/api/addons/vacay/invite/cancel', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.post('/api/addons/vacay/dissolve', () => {
+    return HttpResponse.json({ success: true });
+  }),
+
+  http.post('/api/addons/vacay/plan/holiday-calendars', () => {
+    return HttpResponse.json({
+      calendar: { id: 1, plan_id: 1, region: 'DE', label: null, color: '#ef4444', sort_order: 0 },
+    });
+  }),
+
+  http.put('/api/addons/vacay/plan/holiday-calendars/:id', () => {
+    return HttpResponse.json({
+      calendar: { id: 1, plan_id: 1, region: 'US', label: 'US Holidays', color: '#3b82f6', sort_order: 0 },
+    });
+  }),
+
+  http.delete('/api/addons/vacay/plan/holiday-calendars/:id', () => {
+    return HttpResponse.json({ success: true });
+  }),
+];
diff --git a/client/tests/helpers/msw/server.ts b/client/tests/helpers/msw/server.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6d0f50bd100adaddbc2922b91d64e4c1443b17af
--- /dev/null
+++ b/client/tests/helpers/msw/server.ts
@@ -0,0 +1,4 @@
+import { setupServer } from 'msw/node';
+import { defaultHandlers } from './handlers';
+
+export const server = setupServer(...defaultHandlers);
diff --git a/client/tests/helpers/render.tsx b/client/tests/helpers/render.tsx
new file mode 100644
index 0000000000000000000000000000000000000000..b62cdefb53b6d3896093b4e974e0aaa559425251
--- /dev/null
+++ b/client/tests/helpers/render.tsx
@@ -0,0 +1,26 @@
+import React from 'react';
+import { render, type RenderOptions } from '@testing-library/react';
+import { MemoryRouter, type MemoryRouterProps } from 'react-router-dom';
+import { TranslationProvider } from '../../src/i18n/TranslationContext';
+
+interface RenderWithProvidersOptions extends Omit<RenderOptions, 'wrapper'> {
+  initialEntries?: MemoryRouterProps['initialEntries'];
+}
+
+function renderWithProviders(
+  ui: React.ReactElement,
+  { initialEntries = ['/'], ...options }: RenderWithProvidersOptions = {},
+) {
+  function Wrapper({ children }: { children: React.ReactNode }) {
+    return (
+      <MemoryRouter initialEntries={initialEntries}>
+        <TranslationProvider>{children}</TranslationProvider>
+      </MemoryRouter>
+    );
+  }
+
+  return render(ui, { wrapper: Wrapper, ...options });
+}
+
+export * from '@testing-library/react';
+export { renderWithProviders as render };
diff --git a/client/tests/helpers/store.ts b/client/tests/helpers/store.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9df8a5dd2c0843d36e77a68bfe14b759aa965be4
--- /dev/null
+++ b/client/tests/helpers/store.ts
@@ -0,0 +1,41 @@
+import { useAuthStore } from '../../src/store/authStore';
+import { useTripStore } from '../../src/store/tripStore';
+import { useSettingsStore } from '../../src/store/settingsStore';
+import { useVacayStore } from '../../src/store/vacayStore';
+import { useAddonStore } from '../../src/store/addonStore';
+import { useInAppNotificationStore } from '../../src/store/inAppNotificationStore';
+import { usePermissionsStore } from '../../src/store/permissionsStore';
+// Journey store is reset individually in journey tests to avoid circular import issues
+
+// Capture initial states at import time (before any test modifies them)
+const initialAuthState = useAuthStore.getState();
+const initialTripState = useTripStore.getState();
+const initialSettingsState = useSettingsStore.getState();
+const initialVacayState = useVacayStore.getState();
+const initialAddonState = useAddonStore.getState();
+const initialNotifState = useInAppNotificationStore.getState();
+const initialPermsState = usePermissionsStore.getState();
+export function resetAllStores(): void {
+  useAuthStore.setState(initialAuthState, true);
+  useTripStore.setState(initialTripState, true);
+  useSettingsStore.setState(initialSettingsState, true);
+  useVacayStore.setState(initialVacayState, true);
+  useAddonStore.setState(initialAddonState, true);
+  useInAppNotificationStore.setState(initialNotifState, true);
+  usePermissionsStore.setState(initialPermsState, true);
+}
+
+/**
+ * Tests routinely seed a store with a partially-populated slice of state,
+ * including partial nested objects (e.g. only `settings.time_format`). The
+ * store's own setState wants the exact field types, so seeding accepts a
+ * deep-partial view and casts at the boundary.
+ */
+type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
+
+export function seedStore<T extends object>(
+  store: { setState: (partial: Partial<T>, replace?: boolean) => void },
+  state: DeepPartial<T>,
+): void {
+  store.setState(state as Partial<T>);
+}
diff --git a/client/tests/integration/api/client.test.ts b/client/tests/integration/api/client.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0a6ecd05c418bbbc779f1b6736171a3c52e98b68
--- /dev/null
+++ b/client/tests/integration/api/client.test.ts
@@ -0,0 +1,974 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../helpers/msw/server';
+import { buildUser } from '../../helpers/factories';
+
+// The global setup.ts mocks websocket with getSocketId returning null.
+// We need to be able to control what getSocketId returns per-test.
+// Re-mock here to get full control.
+vi.mock('../../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => 'mock-socket-id'),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+}));
+
+const wsMock = await import('../../../src/api/websocket');
+
+// Import the API client AFTER the mock is set up so it picks up our getSocketId mock
+const {
+  apiClient,
+  authApi,
+  tripsApi,
+  placesApi,
+  packingApi,
+  inAppNotificationsApi,
+  shareApi,
+  backupApi,
+  daysApi,
+  assignmentsApi,
+  tagsApi,
+  categoriesApi,
+  adminApi,
+  addonsApi,
+  mapsApi,
+  budgetApi,
+  filesApi,
+  reservationsApi,
+  weatherApi,
+  settingsApi,
+  accommodationsApi,
+  dayNotesApi,
+  collabApi,
+  notificationsApi,
+} = await import('../../../src/api/client');
+
+describe('API client interceptors', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Default: socket ID available
+    (wsMock.getSocketId as ReturnType<typeof vi.fn>).mockReturnValue('mock-socket-id');
+  });
+
+  afterEach(() => {
+    // Reset window.location to a neutral path
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { href: 'http://localhost/', pathname: '/', search: '', hash: '' },
+    });
+  });
+
+  it('FE-API-001: requests include X-Socket-Id header when getSocketId returns a value', async () => {
+    let receivedSocketId: string | null = null;
+
+    server.use(
+      http.get('/api/auth/me', ({ request }) => {
+        receivedSocketId = request.headers.get('X-Socket-Id');
+        return HttpResponse.json({ user: buildUser() });
+      })
+    );
+
+    await authApi.me();
+
+    expect(receivedSocketId).toBe('mock-socket-id');
+  });
+
+  it('FE-API-002: X-Socket-Id header is absent when getSocketId returns null', async () => {
+    (wsMock.getSocketId as ReturnType<typeof vi.fn>).mockReturnValue(null);
+    let receivedSocketId: string | null = 'sentinel';
+
+    server.use(
+      http.get('/api/auth/me', ({ request }) => {
+        receivedSocketId = request.headers.get('X-Socket-Id');
+        return HttpResponse.json({ user: buildUser() });
+      })
+    );
+
+    await authApi.me();
+
+    expect(receivedSocketId).toBeNull();
+  });
+
+  it('FE-API-003: 401 with AUTH_REQUIRED → redirects to /login with redirect param', async () => {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { href: 'http://localhost/', pathname: '/dashboard', search: '', hash: '' },
+    });
+
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ code: 'AUTH_REQUIRED' }, { status: 401 });
+      })
+    );
+
+    try {
+      await authApi.me();
+    } catch {
+      // Expected to reject
+    }
+
+    expect(window.location.href).toBe('/login?redirect=%2Fdashboard');
+  });
+
+  it('FE-API-003b: 401 without AUTH_REQUIRED code does not redirect', async () => {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { href: 'http://localhost/dashboard', pathname: '/dashboard', search: '' },
+    });
+
+    const originalHref = window.location.href;
+
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ error: 'Unauthorized' }, { status: 401 });
+      })
+    );
+
+    try {
+      await authApi.me();
+    } catch {
+      // Expected to reject
+    }
+
+    expect(window.location.href).toBe(originalHref);
+  });
+
+  it('FE-API-003c: 401 on /login page does not redirect', async () => {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { href: 'http://localhost/login', pathname: '/login', search: '' },
+    });
+
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ code: 'AUTH_REQUIRED' }, { status: 401 });
+      })
+    );
+
+    try {
+      await authApi.me();
+    } catch {
+      // Expected to reject
+    }
+
+    // href should NOT have been changed to /login?redirect=...
+    expect(window.location.href).toBe('http://localhost/login');
+  });
+
+  it('FE-API-004: 403 with MFA_REQUIRED → redirects to /settings?mfa=required', async () => {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { href: 'http://localhost/', pathname: '/dashboard', search: '' },
+    });
+
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ code: 'MFA_REQUIRED' }, { status: 403 });
+      })
+    );
+
+    try {
+      await authApi.me();
+    } catch {
+      // Expected to reject
+    }
+
+    expect(window.location.href).toBe('/settings?mfa=required');
+  });
+
+  it('FE-API-004b: 403 with MFA_REQUIRED on /settings page does not redirect', async () => {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { href: 'http://localhost/settings', pathname: '/settings', search: '' },
+    });
+
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ code: 'MFA_REQUIRED' }, { status: 403 });
+      })
+    );
+
+    try {
+      await authApi.me();
+    } catch {
+      // Expected to reject
+    }
+
+    // Should NOT redirect when already on /settings
+    expect(window.location.href).toBe('http://localhost/settings');
+  });
+
+  it('FE-API-005: successful API call returns response data', async () => {
+    const user = buildUser();
+
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ user });
+      })
+    );
+
+    const data = await authApi.me();
+
+    expect(data).toMatchObject({ user: { id: user.id, email: user.email } });
+  });
+
+  it('FE-API-006: socket ID header reflects current value from getSocketId at request time', async () => {
+    const headers: Array<string | null> = [];
+
+    (wsMock.getSocketId as ReturnType<typeof vi.fn>)
+      .mockReturnValueOnce('socket-A')
+      .mockReturnValueOnce('socket-B');
+
+    server.use(
+      http.get('/api/auth/me', ({ request }) => {
+        headers.push(request.headers.get('X-Socket-Id'));
+        return HttpResponse.json({ user: buildUser() });
+      })
+    );
+
+    await authApi.me();
+    await authApi.me();
+
+    expect(headers[0]).toBe('socket-A');
+    expect(headers[1]).toBe('socket-B');
+  });
+
+  it('FE-API-007: non-401/403 errors are passed through as rejections', async () => {
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ error: 'Internal error' }, { status: 500 });
+      })
+    );
+
+    await expect(authApi.me()).rejects.toThrow();
+  });
+
+  // ── 401 edge cases ───────────────────────────────────────────────────────────
+
+  it('FE-API-008: 401 AUTH_REQUIRED on /register path does not redirect', async () => {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { href: 'http://localhost/register', pathname: '/register', search: '' },
+    });
+
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ code: 'AUTH_REQUIRED' }, { status: 401 });
+      })
+    );
+
+    try { await authApi.me(); } catch { /* expected */ }
+
+    expect(window.location.href).toBe('http://localhost/register');
+  });
+
+  it('FE-API-009: 401 AUTH_REQUIRED on /shared/:token path does not redirect', async () => {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { href: 'http://localhost/shared/abc123', pathname: '/shared/abc123', search: '' },
+    });
+
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ code: 'AUTH_REQUIRED' }, { status: 401 });
+      })
+    );
+
+    try { await authApi.me(); } catch { /* expected */ }
+
+    expect(window.location.href).toBe('http://localhost/shared/abc123');
+  });
+
+  it('FE-API-010: 401 AUTH_REQUIRED still rejects the promise even when redirect fires', async () => {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { href: 'http://localhost/dashboard', pathname: '/dashboard', search: '' },
+    });
+
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ code: 'AUTH_REQUIRED' }, { status: 401 });
+      })
+    );
+
+    await expect(authApi.me()).rejects.toThrow();
+  });
+
+  // ── 403 edge cases ───────────────────────────────────────────────────────────
+
+  it('FE-API-011: 403 without MFA_REQUIRED code does not redirect', async () => {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { href: 'http://localhost/dashboard', pathname: '/dashboard', search: '' },
+    });
+
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ error: 'Forbidden' }, { status: 403 });
+      })
+    );
+
+    try { await authApi.me(); } catch { /* expected */ }
+
+    expect(window.location.href).toBe('http://localhost/dashboard');
+  });
+
+  it('FE-API-012: 403 MFA_REQUIRED still rejects the promise after redirect fires', async () => {
+    Object.defineProperty(window, 'location', {
+      writable: true,
+      value: { href: 'http://localhost/dashboard', pathname: '/dashboard', search: '' },
+    });
+
+    server.use(
+      http.get('/api/auth/me', () => {
+        return HttpResponse.json({ code: 'MFA_REQUIRED' }, { status: 403 });
+      })
+    );
+
+    await expect(authApi.me()).rejects.toThrow();
+  });
+
+  // ── backupApi.download ───────────────────────────────────────────────────────
+
+  it('FE-API-013: backupApi.download creates a temp anchor and clicks it', async () => {
+    // backupApi.download uses native fetch (not axios). Mock fetch directly and
+    // use a plain-object Response duck-type to avoid MSW patching the Response
+    // constructor (which calls blob.stream() — not implemented in jsdom's Blob).
+    const blob = new Blob(['zip-bytes'], { type: 'application/zip' });
+    vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+      ok: true,
+      blob: () => Promise.resolve(blob),
+    } as unknown as Response);
+    const createObjectURL = vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:mock-url');
+    const revokeObjectURL = vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => {});
+
+    // Spy on createElement to intercept the anchor click
+    const originalCreate = document.createElement.bind(document);
+    const clickSpy = vi.fn();
+    vi.spyOn(document, 'createElement').mockImplementation((tag: string) => {
+      const el = originalCreate(tag);
+      if (tag === 'a') {
+        Object.defineProperty(el, 'click', { writable: true, value: clickSpy });
+      }
+      return el;
+    });
+
+    await expect(backupApi.download('backup.zip')).resolves.toBeUndefined();
+    expect(createObjectURL).toHaveBeenCalled();
+    expect(revokeObjectURL).toHaveBeenCalled();
+
+    vi.restoreAllMocks();
+  });
+
+  it('FE-API-014: backupApi.download throws when response is not ok', async () => {
+    server.use(
+      http.get('/api/backup/download/missing.zip', () => {
+        return new HttpResponse(null, { status: 404 });
+      })
+    );
+
+    await expect(backupApi.download('missing.zip')).rejects.toThrow('Download failed');
+  });
+
+  // ── API namespace URL spot-checks ────────────────────────────────────────────
+
+  it('FE-API-015: tripsApi.list() makes GET to /api/trips', async () => {
+    server.use(
+      http.get('/api/trips', () => HttpResponse.json([]))
+    );
+
+    const result = await tripsApi.list();
+    expect(result).toEqual([]);
+  });
+
+  it('FE-API-016: tripsApi.get(42) makes GET to /api/trips/42', async () => {
+    let hitUrl = '';
+    server.use(
+      http.get('/api/trips/42', ({ request }) => {
+        hitUrl = new URL(request.url).pathname;
+        return HttpResponse.json({ id: 42 });
+      })
+    );
+
+    await tripsApi.get(42);
+    expect(hitUrl).toBe('/api/trips/42');
+  });
+
+  it('FE-API-017: placesApi.create posts to /api/trips/1/places and returns data directly', async () => {
+    const place = { id: 1, name: 'Paris', trip_id: 1 };
+    server.use(
+      http.post('/api/trips/1/places', () => HttpResponse.json(place))
+    );
+
+    const result = await placesApi.create(1, { name: 'Paris' });
+    expect(result).toMatchObject({ name: 'Paris' });
+  });
+
+  it('FE-API-018: packingApi.bulkImport posts correct payload', async () => {
+    let receivedBody: unknown;
+    server.use(
+      http.post('/api/trips/1/packing/import', async ({ request }) => {
+        receivedBody = await request.json();
+        return HttpResponse.json({ imported: 1 });
+      })
+    );
+
+    await packingApi.bulkImport(1, [{ name: 'Sunscreen' }]);
+    expect(receivedBody).toMatchObject({ items: [{ name: 'Sunscreen' }] });
+  });
+
+  it('FE-API-019: inAppNotificationsApi.list passes unread_only query param', async () => {
+    let searchParams: URLSearchParams | null = null;
+    server.use(
+      http.get('/api/notifications/in-app', ({ request }) => {
+        searchParams = new URL(request.url).searchParams;
+        return HttpResponse.json([]);
+      })
+    );
+
+    await inAppNotificationsApi.list({ unread_only: true });
+    expect(searchParams?.get('unread_only')).toBe('true');
+  });
+
+  it('FE-API-020: shareApi.getSharedTrip hits /api/shared/tok123', async () => {
+    let hitPath = '';
+    server.use(
+      http.get('/api/shared/tok123', ({ request }) => {
+        hitPath = new URL(request.url).pathname;
+        return HttpResponse.json({ token: 'tok123' });
+      })
+    );
+
+    const result = await shareApi.getSharedTrip('tok123');
+    expect(hitPath).toBe('/api/shared/tok123');
+    expect(result).toMatchObject({ token: 'tok123' });
+  });
+
+  // ── authApi method spot-checks ───────────────────────────────────────────────
+
+  it('FE-API-021: authApi.login posts email and password to /api/auth/login', async () => {
+    const user = buildUser();
+    let receivedBody: unknown;
+    server.use(
+      http.post('/api/auth/login', async ({ request }) => {
+        receivedBody = await request.json();
+        return HttpResponse.json({ user });
+      })
+    );
+
+    const result = await authApi.login({ email: 'a@b.com', password: 'pass' });
+    expect(receivedBody).toMatchObject({ email: 'a@b.com', password: 'pass' });
+    expect(result).toMatchObject({ user: { id: user.id } });
+  });
+
+  it('FE-API-022: authApi.uploadAvatar sends multipart/form-data', async () => {
+    // jsdom's FormData ≠ undici's FormData — MSW body serialisation of FormData
+    // hangs under CI resource constraints. Spy + mock at the axios level to verify
+    // the correct args are passed without going through the network stack.
+    const postSpy = vi.spyOn(apiClient, 'post').mockResolvedValueOnce({ data: { avatar_url: '/uploads/avatar.jpg' } } as any);
+
+    const formData = new FormData();
+    formData.append('avatar', new Blob(['img'], { type: 'image/jpeg' }), 'avatar.jpg');
+
+    await authApi.uploadAvatar(formData);
+    expect(postSpy).toHaveBeenCalledWith('/auth/avatar', expect.any(FormData), expect.anything());
+    postSpy.mockRestore();
+  });
+
+  it('FE-API-023: authApi.mcpTokens.create posts name to /api/auth/mcp-tokens', async () => {
+    let receivedBody: unknown;
+    server.use(
+      http.post('/api/auth/mcp-tokens', async ({ request }) => {
+        receivedBody = await request.json();
+        return HttpResponse.json({ id: 1, name: 'My Token', token: 'tok' });
+      })
+    );
+
+    await authApi.mcpTokens.create('My Token');
+    expect(receivedBody).toMatchObject({ name: 'My Token' });
+  });
+});
+
+describe('API namespace smoke tests', () => {
+  it('daysApi.list fetches trip days', async () => {
+    server.use(http.get('/api/trips/1/days', () => HttpResponse.json([])));
+    await expect(daysApi.list(1)).resolves.toEqual([]);
+  });
+
+  it('assignmentsApi.list fetches day assignments', async () => {
+    server.use(http.get('/api/trips/1/days/1/assignments', () => HttpResponse.json([])));
+    await expect(assignmentsApi.list(1, 1)).resolves.toEqual([]);
+  });
+
+  it('tagsApi.list fetches tags', async () => {
+    server.use(http.get('/api/tags', () => HttpResponse.json([])));
+    await expect(tagsApi.list()).resolves.toEqual([]);
+  });
+
+  it('categoriesApi.list fetches categories', async () => {
+    server.use(http.get('/api/categories', () => HttpResponse.json([])));
+    await expect(categoriesApi.list()).resolves.toEqual([]);
+  });
+
+  it('adminApi.users fetches admin users', async () => {
+    server.use(http.get('/api/admin/users', () => HttpResponse.json([])));
+    await expect(adminApi.users()).resolves.toEqual([]);
+  });
+
+  it('addonsApi.enabled fetches enabled addons', async () => {
+    server.use(http.get('/api/addons', () => HttpResponse.json([])));
+    await expect(addonsApi.enabled()).resolves.toEqual([]);
+  });
+
+  it('mapsApi.search posts query', async () => {
+    server.use(http.post('/api/maps/search', () => HttpResponse.json({ results: [] })));
+    await expect(mapsApi.search('Paris')).resolves.toMatchObject({ results: [] });
+  });
+
+  it('budgetApi.list fetches budget items', async () => {
+    server.use(http.get('/api/trips/1/budget', () => HttpResponse.json([])));
+    await expect(budgetApi.list(1)).resolves.toEqual([]);
+  });
+
+  it('filesApi.list fetches trip files', async () => {
+    server.use(http.get('/api/trips/1/files', () => HttpResponse.json([])));
+    await expect(filesApi.list(1)).resolves.toEqual([]);
+  });
+
+  it('reservationsApi.list fetches reservations', async () => {
+    server.use(http.get('/api/trips/1/reservations', () => HttpResponse.json([])));
+    await expect(reservationsApi.list(1)).resolves.toEqual([]);
+  });
+
+  it('weatherApi.get fetches weather data', async () => {
+    server.use(http.get('/api/weather', () => HttpResponse.json({ temp: 20 })));
+    await expect(weatherApi.get(48.8, 2.3, '2025-06-01')).resolves.toMatchObject({ temp: 20 });
+  });
+
+  it('settingsApi.get fetches settings', async () => {
+    server.use(http.get('/api/settings', () => HttpResponse.json({ dark_mode: false })));
+    await expect(settingsApi.get()).resolves.toMatchObject({ dark_mode: false });
+  });
+
+  it('accommodationsApi.list fetches accommodations', async () => {
+    server.use(http.get('/api/trips/1/accommodations', () => HttpResponse.json([])));
+    await expect(accommodationsApi.list(1)).resolves.toEqual([]);
+  });
+
+  it('dayNotesApi.list fetches day notes', async () => {
+    server.use(http.get('/api/trips/1/days/1/notes', () => HttpResponse.json([])));
+    await expect(dayNotesApi.list(1, 1)).resolves.toEqual([]);
+  });
+
+  it('collabApi.getNotes fetches collab notes', async () => {
+    server.use(http.get('/api/trips/1/collab/notes', () => HttpResponse.json([])));
+    await expect(collabApi.getNotes(1)).resolves.toEqual([]);
+  });
+
+  it('notificationsApi.getPreferences fetches preferences', async () => {
+    server.use(http.get('/api/notifications/preferences', () => HttpResponse.json({ email: true })));
+    await expect(notificationsApi.getPreferences()).resolves.toMatchObject({ email: true });
+  });
+
+  it('inAppNotificationsApi.unreadCount fetches unread count', async () => {
+    server.use(http.get('/api/notifications/in-app/unread-count', () => HttpResponse.json({ count: 3 })));
+    await expect(inAppNotificationsApi.unreadCount()).resolves.toMatchObject({ count: 3 });
+  });
+
+  it('inAppNotificationsApi.markRead marks a notification read', async () => {
+    server.use(http.put('/api/notifications/in-app/5/read', () => HttpResponse.json({ ok: true })));
+    await expect(inAppNotificationsApi.markRead(5)).resolves.toMatchObject({ ok: true });
+  });
+
+  it('inAppNotificationsApi.markAllRead marks all notifications read', async () => {
+    server.use(http.put('/api/notifications/in-app/read-all', () => HttpResponse.json({ ok: true })));
+    await expect(inAppNotificationsApi.markAllRead()).resolves.toMatchObject({ ok: true });
+  });
+
+  it('inAppNotificationsApi.delete deletes a notification', async () => {
+    server.use(http.delete('/api/notifications/in-app/5', () => HttpResponse.json({ ok: true })));
+    await expect(inAppNotificationsApi.delete(5)).resolves.toMatchObject({ ok: true });
+  });
+
+  it('inAppNotificationsApi.markUnread marks a notification unread', async () => {
+    server.use(http.put('/api/notifications/in-app/5/unread', () => HttpResponse.json({ ok: true })));
+    await expect(inAppNotificationsApi.markUnread(5)).resolves.toMatchObject({ ok: true });
+  });
+
+  it('inAppNotificationsApi.deleteAll deletes all notifications', async () => {
+    server.use(http.delete('/api/notifications/in-app/all', () => HttpResponse.json({ ok: true })));
+    await expect(inAppNotificationsApi.deleteAll()).resolves.toMatchObject({ ok: true });
+  });
+
+  it('inAppNotificationsApi.respond posts a response', async () => {
+    server.use(http.post('/api/notifications/in-app/5/respond', () => HttpResponse.json({ ok: true })));
+    await expect(inAppNotificationsApi.respond(5, 'positive')).resolves.toMatchObject({ ok: true });
+  });
+
+  it('notificationsApi.updatePreferences updates preferences', async () => {
+    server.use(http.put('/api/notifications/preferences', () => HttpResponse.json({ ok: true })));
+    await expect(notificationsApi.updatePreferences({ email: { trip_invite: true } })).resolves.toMatchObject({ ok: true });
+  });
+
+  it('backupApi.list fetches backup list', async () => {
+    server.use(http.get('/api/backup/list', () => HttpResponse.json([])));
+    await expect(backupApi.list()).resolves.toEqual([]);
+  });
+
+  // ── tripsApi additional methods ──────────────────────────────────────────────
+
+  it('tripsApi.create posts new trip', async () => {
+    server.use(http.post('/api/trips', () => HttpResponse.json({ id: 1, title: 'Test' })));
+    await expect(tripsApi.create({ title: 'Test' })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('tripsApi.update puts trip data', async () => {
+    server.use(http.put('/api/trips/1', () => HttpResponse.json({ id: 1 })));
+    await expect(tripsApi.update(1, { title: 'Updated' })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('tripsApi.delete deletes a trip', async () => {
+    server.use(http.delete('/api/trips/1', () => HttpResponse.json({ ok: true })));
+    await expect(tripsApi.delete(1)).resolves.toMatchObject({ ok: true });
+  });
+
+  it('tripsApi.getMembers fetches trip members', async () => {
+    server.use(http.get('/api/trips/1/members', () => HttpResponse.json([])));
+    await expect(tripsApi.getMembers(1)).resolves.toEqual([]);
+  });
+
+  it('tripsApi.copy copies a trip', async () => {
+    server.use(http.post('/api/trips/1/copy', () => HttpResponse.json({ id: 99 })));
+    await expect(tripsApi.copy(1)).resolves.toMatchObject({ id: 99 });
+  });
+
+  // ── placesApi additional methods ─────────────────────────────────────────────
+
+  it('placesApi.list fetches places', async () => {
+    server.use(http.get('/api/trips/1/places', () => HttpResponse.json([])));
+    await expect(placesApi.list(1)).resolves.toEqual([]);
+  });
+
+  it('placesApi.get fetches a place', async () => {
+    server.use(http.get('/api/trips/1/places/5', () => HttpResponse.json({ id: 5 })));
+    await expect(placesApi.get(1, 5)).resolves.toMatchObject({ id: 5 });
+  });
+
+  it('placesApi.update updates a place', async () => {
+    server.use(http.put('/api/trips/1/places/5', () => HttpResponse.json({ id: 5 })));
+    await expect(placesApi.update(1, 5, { name: 'Rome' })).resolves.toMatchObject({ id: 5 });
+  });
+
+  it('placesApi.delete deletes a place', async () => {
+    server.use(http.delete('/api/trips/1/places/5', () => HttpResponse.json({ ok: true })));
+    await expect(placesApi.delete(1, 5)).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── packingApi additional methods ────────────────────────────────────────────
+
+  it('packingApi.list fetches packing items', async () => {
+    server.use(http.get('/api/trips/1/packing', () => HttpResponse.json([])));
+    await expect(packingApi.list(1)).resolves.toEqual([]);
+  });
+
+  it('packingApi.create creates a packing item', async () => {
+    server.use(http.post('/api/trips/1/packing', () => HttpResponse.json({ id: 1, name: 'Towel' })));
+    await expect(packingApi.create(1, { name: 'Towel' })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('packingApi.delete deletes a packing item', async () => {
+    server.use(http.delete('/api/trips/1/packing/1', () => HttpResponse.json({ ok: true })));
+    await expect(packingApi.delete(1, 1)).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── assignmentsApi additional methods ────────────────────────────────────────
+
+  it('assignmentsApi.create creates an assignment', async () => {
+    server.use(http.post('/api/trips/1/days/1/assignments', () => HttpResponse.json({ id: 1 })));
+    await expect(assignmentsApi.create(1, 1, { place_id: 5 })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('assignmentsApi.delete deletes an assignment', async () => {
+    server.use(http.delete('/api/trips/1/days/1/assignments/1', () => HttpResponse.json({ ok: true })));
+    await expect(assignmentsApi.delete(1, 1, 1)).resolves.toMatchObject({ ok: true });
+  });
+
+  it('assignmentsApi.reorder reorders assignments', async () => {
+    server.use(http.put('/api/trips/1/days/1/assignments/reorder', () => HttpResponse.json({ ok: true })));
+    await expect(assignmentsApi.reorder(1, 1, [3, 1, 2])).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── daysApi additional methods ───────────────────────────────────────────────
+
+  it('daysApi.create creates a day', async () => {
+    server.use(http.post('/api/trips/1/days', () => HttpResponse.json({ id: 1 })));
+    await expect(daysApi.create(1, { date: '2025-06-01' })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('daysApi.delete deletes a day', async () => {
+    server.use(http.delete('/api/trips/1/days/1', () => HttpResponse.json({ ok: true })));
+    await expect(daysApi.delete(1, 1)).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── tagsApi / categoriesApi additional methods ────────────────────────────────
+
+  it('tagsApi.create creates a tag', async () => {
+    server.use(http.post('/api/tags', () => HttpResponse.json({ id: 1, name: 'Fun' })));
+    await expect(tagsApi.create({ name: 'Fun' })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('tagsApi.delete deletes a tag', async () => {
+    server.use(http.delete('/api/tags/1', () => HttpResponse.json({ ok: true })));
+    await expect(tagsApi.delete(1)).resolves.toMatchObject({ ok: true });
+  });
+
+  it('categoriesApi.create creates a category', async () => {
+    server.use(http.post('/api/categories', () => HttpResponse.json({ id: 1, name: 'Food' })));
+    await expect(categoriesApi.create({ name: 'Food' })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('categoriesApi.delete deletes a category', async () => {
+    server.use(http.delete('/api/categories/1', () => HttpResponse.json({ ok: true })));
+    await expect(categoriesApi.delete(1)).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── adminApi additional methods ───────────────────────────────────────────────
+
+  it('adminApi.stats fetches admin stats', async () => {
+    server.use(http.get('/api/admin/stats', () => HttpResponse.json({ trips: 5 })));
+    await expect(adminApi.stats()).resolves.toMatchObject({ trips: 5 });
+  });
+
+  it('adminApi.createUser creates a user', async () => {
+    server.use(http.post('/api/admin/users', () => HttpResponse.json({ id: 10 })));
+    await expect(adminApi.createUser({ email: 'x@x.com' })).resolves.toMatchObject({ id: 10 });
+  });
+
+  // ── budgetApi additional methods ─────────────────────────────────────────────
+
+  it('budgetApi.create creates a budget item', async () => {
+    server.use(http.post('/api/trips/1/budget', () => HttpResponse.json({ id: 1 })));
+    await expect(budgetApi.create(1, { name: 'Hotel' })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('budgetApi.delete deletes a budget item', async () => {
+    server.use(http.delete('/api/trips/1/budget/1', () => HttpResponse.json({ ok: true })));
+    await expect(budgetApi.delete(1, 1)).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── reservationsApi additional methods ───────────────────────────────────────
+
+  it('reservationsApi.create creates a reservation', async () => {
+    server.use(http.post('/api/trips/1/reservations', () => HttpResponse.json({ id: 1 })));
+    await expect(reservationsApi.create(1, { title: 'Hotel' })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('reservationsApi.delete deletes a reservation', async () => {
+    server.use(http.delete('/api/trips/1/reservations/1', () => HttpResponse.json({ ok: true })));
+    await expect(reservationsApi.delete(1, 1)).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── settingsApi additional methods ───────────────────────────────────────────
+
+  it('settingsApi.set updates a setting', async () => {
+    server.use(http.put('/api/settings', () => HttpResponse.json({ ok: true })));
+    await expect(settingsApi.set('dark_mode', true)).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── accommodationsApi additional methods ─────────────────────────────────────
+
+  it('accommodationsApi.create creates accommodation', async () => {
+    server.use(http.post('/api/trips/1/accommodations', () => HttpResponse.json({ id: 1 })));
+    await expect(accommodationsApi.create(1, { place_id: 1, start_day_id: 1, end_day_id: 1 })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('accommodationsApi.delete deletes accommodation', async () => {
+    server.use(http.delete('/api/trips/1/accommodations/1', () => HttpResponse.json({ ok: true })));
+    await expect(accommodationsApi.delete(1, 1)).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── dayNotesApi additional methods ───────────────────────────────────────────
+
+  it('dayNotesApi.create creates a day note', async () => {
+    server.use(http.post('/api/trips/1/days/1/notes', () => HttpResponse.json({ id: 1 })));
+    await expect(dayNotesApi.create(1, 1, { text: 'Hello' })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('dayNotesApi.delete deletes a day note', async () => {
+    server.use(http.delete('/api/trips/1/days/1/notes/1', () => HttpResponse.json({ ok: true })));
+    await expect(dayNotesApi.delete(1, 1, 1)).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── collabApi additional methods ─────────────────────────────────────────────
+
+  it('collabApi.createNote creates a note', async () => {
+    server.use(http.post('/api/trips/1/collab/notes', () => HttpResponse.json({ id: 1 })));
+    await expect(collabApi.createNote(1, { title: 'Note' })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('collabApi.deleteNote deletes a note', async () => {
+    server.use(http.delete('/api/trips/1/collab/notes/1', () => HttpResponse.json({ ok: true })));
+    await expect(collabApi.deleteNote(1, 1)).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── backupApi additional methods ─────────────────────────────────────────────
+
+  it('backupApi.getAutoSettings fetches auto backup settings', async () => {
+    server.use(http.get('/api/backup/auto-settings', () => HttpResponse.json({ enabled: true })));
+    await expect(backupApi.getAutoSettings()).resolves.toMatchObject({ enabled: true });
+  });
+
+  it('backupApi.delete deletes a backup', async () => {
+    server.use(http.delete('/api/backup/backup.zip', () => HttpResponse.json({ ok: true })));
+    await expect(backupApi.delete('backup.zip')).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── shareApi additional methods ───────────────────────────────────────────────
+
+  it('shareApi.createLink creates a share link', async () => {
+    server.use(http.post('/api/trips/1/share-link', () => HttpResponse.json({ token: 'abc' })));
+    await expect(shareApi.createLink(1)).resolves.toMatchObject({ token: 'abc' });
+  });
+
+  it('shareApi.deleteLink deletes a share link', async () => {
+    server.use(http.delete('/api/trips/1/share-link', () => HttpResponse.json({ ok: true })));
+    await expect(shareApi.deleteLink(1)).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── notificationsApi additional methods ───────────────────────────────────────
+
+  it('notificationsApi.testWebhook tests webhook endpoint', async () => {
+    server.use(http.post('/api/notifications/test-webhook', () => HttpResponse.json({ ok: true })));
+    await expect(notificationsApi.testWebhook('http://example.com')).resolves.toMatchObject({ ok: true });
+  });
+
+  it('notificationsApi.testSmtp tests smtp endpoint', async () => {
+    server.use(http.post('/api/notifications/test-smtp', () => HttpResponse.json({ ok: true })));
+    await expect(notificationsApi.testSmtp('user@example.com')).resolves.toMatchObject({ ok: true });
+  });
+
+  // ── mapsApi additional methods ────────────────────────────────────────────────
+
+  it('mapsApi.reverse fetches reverse geocode', async () => {
+    server.use(http.get('/api/maps/reverse', () => HttpResponse.json({ address: 'Paris' })));
+    await expect(mapsApi.reverse(48.8, 2.3)).resolves.toMatchObject({ address: 'Paris' });
+  });
+
+  // ── collabApi messaging methods ───────────────────────────────────────────────
+
+  it('collabApi.getMessages fetches messages', async () => {
+    server.use(http.get('/api/trips/1/collab/messages', () => HttpResponse.json([])));
+    await expect(collabApi.getMessages(1)).resolves.toEqual([]);
+  });
+
+  it('collabApi.sendMessage sends a message', async () => {
+    server.use(http.post('/api/trips/1/collab/messages', () => HttpResponse.json({ id: 1 })));
+    await expect(collabApi.sendMessage(1, { text: 'Hello' })).resolves.toMatchObject({ id: 1 });
+  });
+
+  it('collabApi.deleteMessage deletes a message', async () => {
+    server.use(http.delete('/api/trips/1/collab/messages/1', () => HttpResponse.json({ ok: true })));
+    await expect(collabApi.deleteMessage(1, 1)).resolves.toMatchObject({ ok: true });
+  });
+
+  it('collabApi.reactMessage reacts to a message', async () => {
+    server.use(http.post('/api/trips/1/collab/messages/1/react', () => HttpResponse.json({ ok: true })));
+    await expect(collabApi.reactMessage(1, 1, '👍')).resolves.toMatchObject({ ok: true });
+  });
+
+  it('collabApi.getPolls fetches polls', async () => {
+    server.use(http.get('/api/trips/1/collab/polls', () => HttpResponse.json([])));
+    await expect(collabApi.getPolls(1)).resolves.toEqual([]);
+  });
+
+  it('backupApi.uploadRestore uploads and restores a backup', async () => {
+    // FormData POST hangs on CI — mock at the axios level (see FE-API-022 comment).
+    const postSpy = vi.spyOn(apiClient, 'post').mockResolvedValueOnce({ data: { ok: true } } as any);
+    const file = new File(['data'], 'backup.zip', { type: 'application/zip' });
+    await expect(backupApi.uploadRestore(file)).resolves.toMatchObject({ ok: true });
+    postSpy.mockRestore();
+  });
+
+  it('backupApi.restore restores a named backup', async () => {
+    server.use(http.post('/api/backup/restore/backup.zip', () => HttpResponse.json({ ok: true })));
+    await expect(backupApi.restore('backup.zip')).resolves.toMatchObject({ ok: true });
+  });
+
+  it('backupApi.create creates a backup', async () => {
+    server.use(http.post('/api/backup/create', () => HttpResponse.json({ filename: 'backup.zip' })));
+    await expect(backupApi.create()).resolves.toMatchObject({ filename: 'backup.zip' });
+  });
+});
+
+describe('mapsApi', () => {
+  it('FE-MAPS-001: mapsApi.autocomplete sends input, lang, and locationBias', async () => {
+    let capturedBody: any = null;
+
+    server.use(
+      http.post('/api/maps/autocomplete', async ({ request }) => {
+        capturedBody = await request.json();
+        return HttpResponse.json({
+          suggestions: [{ placeId: 'ChIJ1234', mainText: 'Paris', secondaryText: 'France' }],
+          source: 'google',
+        });
+      })
+    );
+
+    const result = await mapsApi.autocomplete('Par', 'fr', { low: { lat: 48.5, lng: 2.0 }, high: { lat: 49.0, lng: 2.8 } });
+
+    expect(capturedBody).toEqual({
+      input: 'Par',
+      lang: 'fr',
+      locationBias: { low: { lat: 48.5, lng: 2.0 }, high: { lat: 49.0, lng: 2.8 } },
+    });
+    expect(result.suggestions).toHaveLength(1);
+    expect(result.suggestions[0].mainText).toBe('Paris');
+    expect(result.source).toBe('google');
+  });
+
+  it('FE-MAPS-002: mapsApi.autocomplete works without optional params', async () => {
+    server.use(
+      http.post('/api/maps/autocomplete', async ({ request }) => {
+        const body: any = await request.json();
+        expect(body.lang).toBeUndefined();
+        expect(body.locationBias).toBeUndefined();
+        return HttpResponse.json({ suggestions: [], source: 'nominatim' });
+      })
+    );
+
+    const result = await mapsApi.autocomplete('test');
+    expect(result.suggestions).toEqual([]);
+  });
+
+  it('FE-MAPS-003: mapsApi.autocomplete rejects on server error', async () => {
+    server.use(
+      http.post('/api/maps/autocomplete', () => {
+        return HttpResponse.json({ error: 'Rate limited' }, { status: 429 });
+      })
+    );
+
+    await expect(mapsApi.autocomplete('test')).rejects.toThrow();
+  });
+
+  it('FE-MAPS-004: mapsApi.autocomplete rejects when AbortSignal is aborted', async () => {
+    const controller = new AbortController();
+
+    server.use(
+      http.post('/api/maps/autocomplete', async () => {
+        // Never resolves — request will be aborted
+        await new Promise(() => {});
+        return HttpResponse.json({ suggestions: [] });
+      })
+    );
+
+    const promise = mapsApi.autocomplete('Paris', undefined, undefined, controller.signal);
+    controller.abort();
+
+    await expect(promise).rejects.toThrow();
+  });
+});
diff --git a/client/tests/integration/api/websocket.test.ts b/client/tests/integration/api/websocket.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..566a6e95c7769b60ba3ba6128338dda04ccb94f4
--- /dev/null
+++ b/client/tests/integration/api/websocket.test.ts
@@ -0,0 +1,438 @@
+// IMPORTANT: unmock must be the very first statement before any imports
+vi.unmock('../../../src/api/websocket');
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../helpers/msw/server';
+import {
+  connect,
+  disconnect,
+  joinTrip,
+  leaveTrip,
+  addListener,
+  removeListener,
+  getSocketId,
+  setRefetchCallback,
+} from '../../../src/api/websocket';
+
+// ── Fake WebSocket ────────────────────────────────────────────────────────────
+
+class MockWebSocket {
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+
+  readyState: number = MockWebSocket.OPEN;
+  send = vi.fn();
+  close = vi.fn();
+  onopen: (() => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
+  onclose: (() => void) | null = null;
+  onerror: (() => void) | null = null;
+
+  constructor(public url: string) {
+    MockWebSocket.instances.push(this);
+  }
+
+  static instances: MockWebSocket[] = [];
+  static reset() {
+    MockWebSocket.instances = [];
+  }
+}
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  MockWebSocket.reset();
+
+  // Replace globalThis.WebSocket with MockWebSocket directly.
+  // jsdom marks WebSocket as non-writable, so we must use defineProperty.
+  Object.defineProperty(globalThis, 'WebSocket', {
+    writable: true,
+    configurable: true,
+    value: MockWebSocket,
+  });
+
+  // Default handler: ws-token returns a valid token
+  server.use(
+    http.post('/api/auth/ws-token', () =>
+      HttpResponse.json({ token: 'test-ws-token' })
+    )
+  );
+});
+
+afterEach(() => {
+  disconnect();
+  setRefetchCallback(null);
+  vi.useRealTimers();
+  server.resetHandlers();
+});
+
+// Helper to get the most recently created MockWebSocket instance
+function lastSocket(): MockWebSocket {
+  return MockWebSocket.instances[MockWebSocket.instances.length - 1];
+}
+
+// ── connect / disconnect ──────────────────────────────────────────────────────
+
+describe('connect / disconnect', () => {
+  it('FE-COMP-WS-001: connect() fetches ws-token and creates a WebSocket with it', async () => {
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(MockWebSocket.instances).toHaveLength(1);
+    expect(MockWebSocket.instances[0].url).toContain('token=test-ws-token');
+  });
+
+  it('FE-COMP-WS-002: connect() sets shouldReconnect so onclose triggers reconnect', async () => {
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(MockWebSocket.instances).toHaveLength(1);
+
+    // Simulate socket close (triggers scheduleReconnect)
+    lastSocket().onclose!();
+
+    // Advance past initial reconnect delay (1000ms) — reconnect fires
+    await vi.advanceTimersByTimeAsync(1001);
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(MockWebSocket.instances).toHaveLength(2);
+  });
+
+  it('FE-COMP-WS-003: disconnect() prevents reconnect after socket close', async () => {
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    const sock = lastSocket();
+    disconnect();
+
+    // After disconnect, onclose is nulled — simulating close should be safe
+    // but we also fire it manually to be sure
+    if (sock.onclose) sock.onclose();
+
+    await vi.advanceTimersByTimeAsync(5000);
+    await vi.advanceTimersByTimeAsync(0);
+
+    // Still only the original socket
+    expect(MockWebSocket.instances).toHaveLength(1);
+  });
+
+  it('FE-COMP-WS-004: connect() is idempotent — calling twice creates only one socket', async () => {
+    connect();
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(MockWebSocket.instances).toHaveLength(1);
+  });
+});
+
+// ── ws-token fetch failures ───────────────────────────────────────────────────
+
+describe('ws-token fetch failures', () => {
+  it('FE-COMP-WS-005: 401 on ws-token fetch stops reconnect entirely', async () => {
+    server.use(
+      http.post('/api/auth/ws-token', () =>
+        new HttpResponse(null, { status: 401 })
+      )
+    );
+
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    // No socket should be created
+    expect(MockWebSocket.instances).toHaveLength(0);
+
+    // Advance timers — no retry should fire
+    await vi.advanceTimersByTimeAsync(10000);
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(MockWebSocket.instances).toHaveLength(0);
+  });
+
+  it('FE-COMP-WS-006: non-401 error on ws-token schedules a reconnect', async () => {
+    server.use(
+      http.post('/api/auth/ws-token', () =>
+        new HttpResponse(null, { status: 503 })
+      )
+    );
+
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    // No socket yet
+    expect(MockWebSocket.instances).toHaveLength(0);
+
+    // Now allow the next fetch to succeed
+    server.use(
+      http.post('/api/auth/ws-token', () =>
+        HttpResponse.json({ token: 'retry-token' })
+      )
+    );
+
+    // Advance past initial reconnect delay
+    await vi.advanceTimersByTimeAsync(1001);
+    await vi.advanceTimersByTimeAsync(0);
+
+    // A socket should now be created
+    expect(MockWebSocket.instances).toHaveLength(1);
+  });
+});
+
+// ── onopen / join on reconnect ────────────────────────────────────────────────
+
+describe('onopen / join on reconnect', () => {
+  it('FE-COMP-WS-007: onopen sends join messages for all active trips', async () => {
+    joinTrip(42);
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    const sock = lastSocket();
+    sock.onopen!();
+
+    expect(sock.send).toHaveBeenCalledWith(
+      JSON.stringify({ type: 'join', tripId: '42' })
+    );
+  });
+
+  it('FE-COMP-WS-008: onopen invokes refetchCallback for each active trip', async () => {
+    const refetch = vi.fn();
+    setRefetchCallback(refetch);
+    joinTrip(1);
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    lastSocket().onopen!();
+
+    expect(refetch).toHaveBeenCalledWith('1');
+  });
+});
+
+// ── joinTrip / leaveTrip ──────────────────────────────────────────────────────
+
+describe('joinTrip / leaveTrip', () => {
+  it('FE-COMP-WS-009: joinTrip sends join message immediately when socket is open', async () => {
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+    const sock = lastSocket();
+    sock.onopen!();
+
+    joinTrip(99);
+
+    expect(sock.send).toHaveBeenCalledWith(
+      JSON.stringify({ type: 'join', tripId: '99' })
+    );
+  });
+
+  it('FE-COMP-WS-010: joinTrip queues trip when socket is not open yet', async () => {
+    joinTrip(5);
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+
+    const sock = lastSocket();
+    sock.onopen!();
+
+    expect(sock.send).toHaveBeenCalledWith(
+      JSON.stringify({ type: 'join', tripId: '5' })
+    );
+  });
+
+  it('FE-COMP-WS-011: leaveTrip sends leave message and removes from activeTrips', async () => {
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+    const sock = lastSocket();
+    sock.onopen!();
+
+    joinTrip(7);
+    leaveTrip(7);
+
+    expect(sock.send).toHaveBeenCalledWith(
+      JSON.stringify({ type: 'leave', tripId: '7' })
+    );
+
+    // Simulate close + reconnect — trip 7 should NOT be re-joined
+    sock.onclose!();
+    await vi.advanceTimersByTimeAsync(1001);
+    await vi.advanceTimersByTimeAsync(0);
+
+    const sock2 = lastSocket();
+    sock2.onopen!();
+
+    // send called for initial join (trip 7) but not after leaveTrip
+    const joinCalls = sock2.send.mock.calls.filter(
+      c => JSON.parse(c[0]).tripId === '7'
+    );
+    expect(joinCalls).toHaveLength(0);
+  });
+});
+
+// ── handleMessage / listeners ─────────────────────────────────────────────────
+
+describe('handleMessage / listeners', () => {
+  async function setupConnectedSocket() {
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+    const sock = lastSocket();
+    sock.onopen!();
+    return sock;
+  }
+
+  it('FE-COMP-WS-012: welcome message sets socketId and is NOT dispatched to listeners', async () => {
+    const sock = await setupConnectedSocket();
+    const listener = vi.fn();
+    addListener(listener);
+
+    sock.onmessage!({ data: JSON.stringify({ type: 'welcome', socketId: 'server-sid-1' }) });
+
+    expect(getSocketId()).toBe('server-sid-1');
+    expect(listener).not.toHaveBeenCalled();
+
+    removeListener(listener);
+  });
+
+  it('FE-COMP-WS-013: non-welcome messages are dispatched to all registered listeners', async () => {
+    const sock = await setupConnectedSocket();
+    const l1 = vi.fn();
+    const l2 = vi.fn();
+    addListener(l1);
+    addListener(l2);
+
+    const msg = { type: 'place_added', tripId: '1' };
+    sock.onmessage!({ data: JSON.stringify(msg) });
+
+    expect(l1).toHaveBeenCalledWith(msg);
+    expect(l2).toHaveBeenCalledWith(msg);
+
+    removeListener(l1);
+    removeListener(l2);
+  });
+
+  it('FE-COMP-WS-014: listener error is caught and does not prevent other listeners from firing', async () => {
+    const sock = await setupConnectedSocket();
+    const throwing = vi.fn().mockImplementation(() => { throw new Error('boom'); });
+    const working = vi.fn();
+    addListener(throwing);
+    addListener(working);
+
+    expect(() => {
+      sock.onmessage!({ data: JSON.stringify({ type: 'some_event' }) });
+    }).not.toThrow();
+
+    expect(working).toHaveBeenCalled();
+
+    removeListener(throwing);
+    removeListener(working);
+  });
+
+  it('FE-COMP-WS-015: malformed JSON in message is caught silently', async () => {
+    const sock = await setupConnectedSocket();
+    const listener = vi.fn();
+    addListener(listener);
+
+    expect(() => {
+      sock.onmessage!({ data: 'not-json' });
+    }).not.toThrow();
+
+    expect(listener).not.toHaveBeenCalled();
+
+    removeListener(listener);
+  });
+
+  it('FE-COMP-WS-016: removeListener stops a listener from receiving messages', async () => {
+    const sock = await setupConnectedSocket();
+    const listener = vi.fn();
+    addListener(listener);
+    removeListener(listener);
+
+    sock.onmessage!({ data: JSON.stringify({ type: 'update' }) });
+
+    expect(listener).not.toHaveBeenCalled();
+  });
+});
+
+// ── addListener / removeListener ─────────────────────────────────────────────
+
+describe('addListener / removeListener symmetry', () => {
+  it('FE-COMP-WS-017: listener set grows and shrinks correctly', async () => {
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+    const sock = lastSocket();
+    sock.onopen!();
+
+    const l1 = vi.fn();
+    const l2 = vi.fn();
+    addListener(l1);
+    addListener(l2);
+
+    sock.onmessage!({ data: JSON.stringify({ type: 'ping' }) });
+    expect(l1).toHaveBeenCalledTimes(1);
+    expect(l2).toHaveBeenCalledTimes(1);
+
+    removeListener(l1);
+
+    sock.onmessage!({ data: JSON.stringify({ type: 'ping' }) });
+    expect(l1).toHaveBeenCalledTimes(1); // no new calls
+    expect(l2).toHaveBeenCalledTimes(2);
+
+    removeListener(l2);
+  });
+});
+
+// ── getSocketId / setRefetchCallback ─────────────────────────────────────────
+
+describe('getSocketId / setRefetchCallback', () => {
+  it('FE-COMP-WS-018: getSocketId() returns null before welcome message', async () => {
+    // mySocketId is a module-level singleton that persists between tests.
+    // Use vi.resetModules() + dynamic import to get a fresh module state.
+    vi.resetModules();
+    const freshWs = await import('../../../src/api/websocket');
+    expect(freshWs.getSocketId()).toBeNull();
+    // Clean up: restore the real module for subsequent tests by resetting again
+    vi.resetModules();
+  });
+
+  it('FE-COMP-WS-019: setRefetchCallback(null) clears the callback', async () => {
+    const cb = vi.fn();
+    setRefetchCallback(cb);
+    setRefetchCallback(null);
+
+    joinTrip(10);
+    connect();
+    await vi.advanceTimersByTimeAsync(0);
+    lastSocket().onopen!();
+
+    expect(cb).not.toHaveBeenCalled();
+  });
+});
+
+// ── Reconnect backoff ─────────────────────────────────────────────────────────
+
+describe('reconnect backoff', () => {
+  it('FE-COMP-WS-020: reconnect delay doubles on each failure up to 30s max', async () => {
+    // Make every fetch fail with 503 so reconnect keeps firing
+    server.use(
+      http.post('/api/auth/ws-token', () =>
+        new HttpResponse(null, { status: 503 })
+      )
+    );
+
+    connect();
+
+    const delays = [1000, 2000, 4000, 8000, 16000, 30000];
+    let totalAdvanced = 0;
+
+    for (const delay of delays) {
+      // Wait for the fetch to complete
+      await vi.advanceTimersByTimeAsync(0);
+      // No socket should ever be created
+      expect(MockWebSocket.instances).toHaveLength(0);
+      // Advance to trigger next reconnect
+      await vi.advanceTimersByTimeAsync(delay + 1);
+      totalAdvanced += delay + 1;
+    }
+
+    // After advancing through all delays, still no socket
+    await vi.advanceTimersByTimeAsync(0);
+    expect(MockWebSocket.instances).toHaveLength(0);
+  });
+});
diff --git a/client/tests/integration/hooks/useDayNotes.test.ts b/client/tests/integration/hooks/useDayNotes.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..88c0cdab09a93e7995f14ffc6c1e885c9da06d96
--- /dev/null
+++ b/client/tests/integration/hooks/useDayNotes.test.ts
@@ -0,0 +1,448 @@
+import React from 'react';
+import { renderHook, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { useDayNotes } from '../../../src/hooks/useDayNotes';
+import { useTripStore } from '../../../src/store/tripStore';
+import { TranslationProvider } from '../../../src/i18n/TranslationContext';
+import { server } from '../../helpers/msw/server';
+import { buildDayNote } from '../../helpers/factories';
+import { resetAllStores } from '../../helpers/store';
+
+const wrapper = ({ children }: { children: React.ReactNode }) =>
+  React.createElement(TranslationProvider, null, children);
+
+const TRIP_ID = 1;
+const DAY_ID = 10;
+
+describe('useDayNotes', () => {
+  beforeEach(() => {
+    resetAllStores();
+    vi.clearAllMocks();
+  });
+
+  it('FE-HOOK-DAYNOTES-001: initial noteUi state is empty', () => {
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+    expect(result.current.noteUi).toEqual({});
+  });
+
+  it('FE-HOOK-DAYNOTES-002: initial dayNotes comes from tripStore', () => {
+    const note = buildDayNote({ day_id: DAY_ID });
+    useTripStore.setState({ dayNotes: { [String(DAY_ID)]: [note] } });
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+    expect(result.current.dayNotes[String(DAY_ID)]).toEqual([note]);
+  });
+
+  it('FE-HOOK-DAYNOTES-003: openAddNote sets mode=add and default sort order', () => {
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    act(() => {
+      result.current.openAddNote(DAY_ID, () => []);
+    });
+
+    expect(result.current.noteUi[DAY_ID]).toMatchObject({
+      mode: 'add',
+      text: '',
+      sortOrder: 0, // maxKey(-1) + 1 = 0
+    });
+  });
+
+  it('FE-HOOK-DAYNOTES-004: openAddNote calculates sortOrder as max(sortKey) + 1 from merged items', () => {
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    const getMergedItems = () => [
+      { type: 'note' as const, sortKey: 5, data: buildDayNote() },
+      { type: 'note' as const, sortKey: 10, data: buildDayNote() },
+    ];
+
+    act(() => {
+      result.current.openAddNote(DAY_ID, getMergedItems);
+    });
+
+    expect(result.current.noteUi[DAY_ID]).toMatchObject({
+      mode: 'add',
+      sortOrder: 11, // max(5,10) + 1
+    });
+  });
+
+  it('FE-HOOK-DAYNOTES-005: openEditNote sets mode=edit with note data', () => {
+    const note = buildDayNote({ id: 99, text: 'Hello', time: '10:00', icon: 'Star' });
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    act(() => {
+      result.current.openEditNote(DAY_ID, note);
+    });
+
+    expect(result.current.noteUi[DAY_ID]).toMatchObject({
+      mode: 'edit',
+      noteId: 99,
+      text: 'Hello',
+      time: '10:00',
+      icon: 'Star',
+    });
+  });
+
+  it('FE-HOOK-DAYNOTES-006: cancelNote removes the UI entry for that day', () => {
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    act(() => {
+      result.current.openAddNote(DAY_ID, () => []);
+    });
+    expect(result.current.noteUi[DAY_ID]).toBeDefined();
+
+    act(() => {
+      result.current.cancelNote(DAY_ID);
+    });
+    expect(result.current.noteUi[DAY_ID]).toBeUndefined();
+  });
+
+  it('FE-HOOK-DAYNOTES-007: saveNote with empty text is a no-op', async () => {
+    const spy = vi.fn();
+    server.use(
+      http.post('/api/trips/:id/days/:dayId/notes', () => {
+        spy();
+        return HttpResponse.json({ note: buildDayNote() });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    act(() => {
+      result.current.setNoteUi({ [DAY_ID]: { mode: 'add', text: '', time: '', icon: 'FileText', sortOrder: 0 } });
+    });
+
+    await act(async () => {
+      await result.current.saveNote(DAY_ID);
+    });
+
+    expect(spy).not.toHaveBeenCalled();
+    // noteUi remains set (no cancelNote was called)
+    expect(result.current.noteUi[DAY_ID]).toBeDefined();
+  });
+
+  it('FE-HOOK-DAYNOTES-008: saveNote in add mode calls addDayNote and clears UI', async () => {
+    const createdNote = buildDayNote({ day_id: DAY_ID, text: 'New note' });
+    server.use(
+      http.post('/api/trips/:id/days/:dayId/notes', async () => {
+        return HttpResponse.json({ note: createdNote });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    act(() => {
+      result.current.setNoteUi({
+        [DAY_ID]: { mode: 'add', text: 'New note', time: '', icon: 'FileText', sortOrder: 0 },
+      });
+    });
+
+    await act(async () => {
+      await result.current.saveNote(DAY_ID);
+    });
+
+    // UI should be cleared after successful save
+    expect(result.current.noteUi[DAY_ID]).toBeUndefined();
+  });
+
+  it('FE-HOOK-DAYNOTES-009: saveNote in edit mode calls updateDayNote and clears UI', async () => {
+    const noteId = 55;
+    const updatedNote = buildDayNote({ id: noteId, day_id: DAY_ID, text: 'Updated' });
+    server.use(
+      http.put('/api/trips/:id/days/:dayId/notes/:noteId', async () => {
+        return HttpResponse.json({ note: updatedNote });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    act(() => {
+      result.current.setNoteUi({
+        [DAY_ID]: { mode: 'edit', noteId, text: 'Updated', time: '', icon: 'FileText' },
+      });
+    });
+
+    await act(async () => {
+      await result.current.saveNote(DAY_ID);
+    });
+
+    expect(result.current.noteUi[DAY_ID]).toBeUndefined();
+  });
+
+  it('FE-HOOK-DAYNOTES-010: deleteNote calls deleteDayNote on the store', async () => {
+    const note = buildDayNote({ id: 77, day_id: DAY_ID });
+    useTripStore.setState({ dayNotes: { [String(DAY_ID)]: [note] } });
+
+    server.use(
+      http.delete('/api/trips/:id/days/:dayId/notes/:noteId', () => {
+        return HttpResponse.json({ success: true });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    await act(async () => {
+      await result.current.deleteNote(DAY_ID, 77);
+    });
+
+    // Note should be removed from the store
+    const dayNotes = useTripStore.getState().dayNotes[String(DAY_ID)] || [];
+    expect(dayNotes.find((n) => n.id === 77)).toBeUndefined();
+  });
+
+  it('FE-HOOK-DAYNOTES-011: saveNote on API error shows toast', async () => {
+    const toastSpy = vi.fn();
+    window.__addToast = toastSpy;
+
+    server.use(
+      http.post('/api/trips/:id/days/:dayId/notes', () => {
+        return HttpResponse.json({ error: 'Server error' }, { status: 500 });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    act(() => {
+      result.current.setNoteUi({
+        [DAY_ID]: { mode: 'add', text: 'Test note', time: '', icon: 'FileText', sortOrder: 0 },
+      });
+    });
+
+    await act(async () => {
+      await result.current.saveNote(DAY_ID);
+    });
+
+    expect(toastSpy).toHaveBeenCalledWith(expect.any(String), 'error', undefined);
+    delete window.__addToast;
+  });
+
+  it('FE-HOOK-DAYNOTES-012: deleteNote on API error shows toast', async () => {
+    const toastSpy = vi.fn();
+    window.__addToast = toastSpy;
+
+    const note = buildDayNote({ id: 88, day_id: DAY_ID });
+    useTripStore.setState({ dayNotes: { [String(DAY_ID)]: [note] } });
+
+    server.use(
+      http.delete('/api/trips/:id/days/:dayId/notes/:noteId', () => {
+        return HttpResponse.json({ error: 'Server error' }, { status: 500 });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    await act(async () => {
+      await result.current.deleteNote(DAY_ID, 88);
+    });
+
+    expect(toastSpy).toHaveBeenCalledWith(expect.any(String), 'error', undefined);
+    delete window.__addToast;
+  });
+
+  it('FE-HOOK-DAYNOTES-013: moveNote up calculates midpoint sort order', async () => {
+    let capturedBody: Record<string, unknown> = {};
+    server.use(
+      http.put('/api/trips/:id/days/:dayId/notes/:noteId', async ({ request }) => {
+        capturedBody = await request.json() as Record<string, unknown>;
+        return HttpResponse.json({ note: buildDayNote() });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    const noteA = buildDayNote({ id: 1 });
+    const noteB = buildDayNote({ id: 2 });
+    const noteC = buildDayNote({ id: 3 });
+
+    // merged items with sortKeys 0, 2, 4
+    const getMergedItems = () => [
+      { type: 'note' as const, sortKey: 0, data: noteA },
+      { type: 'note' as const, sortKey: 2, data: noteB },
+      { type: 'note' as const, sortKey: 4, data: noteC },
+    ];
+
+    // Move noteC (idx=2) up → new order should be between idx=0 and idx=1 → (0+2)/2 = 1
+    await act(async () => {
+      await result.current.moveNote(DAY_ID, noteC.id, 'up', getMergedItems);
+    });
+
+    expect(capturedBody.sort_order).toBe(1); // (sortKey[0] + sortKey[1]) / 2 = (0+2)/2
+  });
+
+  it('FE-HOOK-DAYNOTES-014: moveNote down calculates midpoint sort order', async () => {
+    let capturedBody: Record<string, unknown> = {};
+    server.use(
+      http.put('/api/trips/:id/days/:dayId/notes/:noteId', async ({ request }) => {
+        capturedBody = await request.json() as Record<string, unknown>;
+        return HttpResponse.json({ note: buildDayNote() });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    const noteA = buildDayNote({ id: 1 });
+    const noteB = buildDayNote({ id: 2 });
+    const noteC = buildDayNote({ id: 3 });
+
+    const getMergedItems = () => [
+      { type: 'note' as const, sortKey: 0, data: noteA },
+      { type: 'note' as const, sortKey: 2, data: noteB },
+      { type: 'note' as const, sortKey: 4, data: noteC },
+    ];
+
+    // Move noteA (idx=0) down → new order between idx=1 and idx=2 → (2+4)/2 = 3
+    await act(async () => {
+      await result.current.moveNote(DAY_ID, noteA.id, 'down', getMergedItems);
+    });
+
+    expect(capturedBody.sort_order).toBe(3); // (sortKey[1] + sortKey[2]) / 2 = (2+4)/2
+  });
+
+  it('FE-HOOK-DAYNOTES-015: moveNote up at index 0 is a no-op', async () => {
+    const spy = vi.fn();
+    server.use(
+      http.put('/api/trips/:id/days/:dayId/notes/:noteId', () => {
+        spy();
+        return HttpResponse.json({ note: buildDayNote() });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    const noteA = buildDayNote({ id: 1 });
+    const getMergedItems = () => [
+      { type: 'note' as const, sortKey: 0, data: noteA },
+    ];
+
+    await act(async () => {
+      await result.current.moveNote(DAY_ID, noteA.id, 'up', getMergedItems);
+    });
+
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  it('FE-HOOK-DAYNOTES-016: moveNote down at last index is a no-op', async () => {
+    const spy = vi.fn();
+    server.use(
+      http.put('/api/trips/:id/days/:dayId/notes/:noteId', () => {
+        spy();
+        return HttpResponse.json({ note: buildDayNote() });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    const noteA = buildDayNote({ id: 1 });
+    const getMergedItems = () => [
+      { type: 'note' as const, sortKey: 0, data: noteA },
+    ];
+
+    await act(async () => {
+      await result.current.moveNote(DAY_ID, noteA.id, 'down', getMergedItems);
+    });
+
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  it('FE-HOOK-DAYNOTES-017: moveNote down at last item uses sortKey + 1', async () => {
+    let capturedBody: Record<string, unknown> = {};
+    server.use(
+      http.put('/api/trips/:id/days/:dayId/notes/:noteId', async ({ request }) => {
+        capturedBody = await request.json() as Record<string, unknown>;
+        return HttpResponse.json({ note: buildDayNote() });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    const noteA = buildDayNote({ id: 1 });
+    const noteB = buildDayNote({ id: 2 });
+
+    const getMergedItems = () => [
+      { type: 'note' as const, sortKey: 5, data: noteA },
+      { type: 'note' as const, sortKey: 10, data: noteB },
+    ];
+
+    // Move noteA (idx=0) down — only 2 items, so idx < length-1 is false after going down
+    // direction=down, idx=0, length=2, idx < length-2 is false (0 < 0), so newSortOrder = sortKey[1]+1 = 11
+    await act(async () => {
+      await result.current.moveNote(DAY_ID, noteA.id, 'down', getMergedItems);
+    });
+
+    expect(capturedBody.sort_order).toBe(11); // sortKey[idx+1] + 1 = 10 + 1
+  });
+
+  it('FE-HOOK-DAYNOTES-018: moveNote on error shows toast', async () => {
+    const toastSpy = vi.fn();
+    window.__addToast = toastSpy;
+
+    server.use(
+      http.put('/api/trips/:id/days/:dayId/notes/:noteId', () => {
+        return HttpResponse.json({ error: 'Server error' }, { status: 500 });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    const noteA = buildDayNote({ id: 1 });
+    const noteB = buildDayNote({ id: 2 });
+
+    const getMergedItems = () => [
+      { type: 'note' as const, sortKey: 0, data: noteA },
+      { type: 'note' as const, sortKey: 1, data: noteB },
+    ];
+
+    await act(async () => {
+      await result.current.moveNote(DAY_ID, noteA.id, 'down', getMergedItems);
+    });
+
+    expect(toastSpy).toHaveBeenCalledWith(expect.any(String), 'error', undefined);
+    delete window.__addToast;
+  });
+
+  it('FE-HOOK-DAYNOTES-019: moveNote up with only 1 item before uses sortKey - 1', async () => {
+    let capturedBody: Record<string, unknown> = {};
+    server.use(
+      http.put('/api/trips/:id/days/:dayId/notes/:noteId', async ({ request }) => {
+        capturedBody = await request.json() as Record<string, unknown>;
+        return HttpResponse.json({ note: buildDayNote() });
+      })
+    );
+
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    const noteA = buildDayNote({ id: 1 });
+    const noteB = buildDayNote({ id: 2 });
+
+    const getMergedItems = () => [
+      { type: 'note' as const, sortKey: 5, data: noteA },
+      { type: 'note' as const, sortKey: 10, data: noteB },
+    ];
+
+    // Move noteB (idx=1) up — idx >= 2 is false, so newSortOrder = sortKey[idx-1] - 1 = 5-1 = 4
+    await act(async () => {
+      await result.current.moveNote(DAY_ID, noteB.id, 'up', getMergedItems);
+    });
+
+    expect(capturedBody.sort_order).toBe(4); // sortKey[0] - 1 = 5 - 1
+  });
+
+  it('FE-HOOK-DAYNOTES-020: openAddNote calls expandDay if provided', () => {
+    const expandDay = vi.fn();
+    const { result } = renderHook(() => useDayNotes(TRIP_ID), { wrapper });
+
+    act(() => {
+      result.current.openAddNote(DAY_ID, () => [], expandDay);
+    });
+
+    expect(expandDay).toHaveBeenCalledWith(DAY_ID);
+  });
+});
+
+// Type augment for window.__addToast — must mirror the canonical declaration
+// in components/shared/Toast.tsx (a divergent signature is a merge conflict).
+declare global {
+  interface Window {
+    __addToast?: (message: string, type?: 'success' | 'error' | 'warning' | 'info', duration?: number) => number;
+  }
+}
diff --git a/client/tests/integration/hooks/useInAppNotificationListener.test.ts b/client/tests/integration/hooks/useInAppNotificationListener.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..13cfeb0ae3039c424e8e9ed5468d426209e319b7
--- /dev/null
+++ b/client/tests/integration/hooks/useInAppNotificationListener.test.ts
@@ -0,0 +1,226 @@
+import { renderHook, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { useInAppNotificationStore } from '../../../src/store/inAppNotificationStore';
+import { resetAllStores } from '../../helpers/store';
+
+// Capture the listener registered via addListener so we can simulate WS events
+let capturedListener: ((event: Record<string, unknown>) => void) | null = null;
+
+vi.mock('../../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => null),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn((fn) => {
+    capturedListener = fn;
+  }),
+  removeListener: vi.fn(),
+}));
+
+const wsMock = await import('../../../src/api/websocket');
+
+// Import the hook after the mock is in place
+const { useInAppNotificationListener } = await import('../../../src/hooks/useInAppNotificationListener');
+
+describe('useInAppNotificationListener', () => {
+  beforeEach(() => {
+    capturedListener = null;
+    resetAllStores();
+    vi.clearAllMocks();
+    // Re-capture after clear
+    (wsMock.addListener as ReturnType<typeof vi.fn>).mockImplementation((fn) => {
+      capturedListener = fn;
+    });
+  });
+
+  it('FE-HOOK-NOTIFLISTENER-001: on mount, addListener is called once', () => {
+    const { unmount } = renderHook(() => useInAppNotificationListener());
+    expect(wsMock.addListener).toHaveBeenCalledTimes(1);
+    unmount();
+  });
+
+  it('FE-HOOK-NOTIFLISTENER-002: on unmount, removeListener is called with the same function', () => {
+    const { unmount } = renderHook(() => useInAppNotificationListener());
+
+    const registeredFn = (wsMock.addListener as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    unmount();
+
+    expect(wsMock.removeListener).toHaveBeenCalledWith(registeredFn);
+  });
+
+  it('FE-HOOK-NOTIFLISTENER-003: notification:new event calls handleNewNotification on the store', () => {
+    const handleNew = vi.fn();
+    useInAppNotificationStore.setState({ handleNewNotification: handleNew } as any);
+
+    const { unmount } = renderHook(() => useInAppNotificationListener());
+
+    expect(capturedListener).toBeTypeOf('function');
+
+    const notification = {
+      id: 1, type: 'simple', scope: 'trip', target: 1, sender_id: null, sender_username: null,
+      sender_avatar: null, recipient_id: 2, title_key: 'test', title_params: '{}',
+      text_key: 'test_body', text_params: '{}', positive_text_key: null, negative_text_key: null,
+      response: null, navigate_text_key: null, navigate_target: null, is_read: 0,
+      created_at: '2025-01-01T00:00:00Z',
+    };
+
+    act(() => {
+      capturedListener!({ type: 'notification:new', notification });
+    });
+
+    expect(handleNew).toHaveBeenCalledWith(notification);
+    unmount();
+  });
+
+  it('FE-HOOK-NOTIFLISTENER-004: notification:updated event calls handleUpdatedNotification on the store', () => {
+    const handleUpdated = vi.fn();
+    useInAppNotificationStore.setState({ handleUpdatedNotification: handleUpdated } as any);
+
+    const { unmount } = renderHook(() => useInAppNotificationListener());
+
+    const notification = {
+      id: 5, type: 'simple', scope: 'user', target: 1, sender_id: null, sender_username: null,
+      sender_avatar: null, recipient_id: 2, title_key: 'updated', title_params: '{}',
+      text_key: 'updated_body', text_params: '{}', positive_text_key: null, negative_text_key: null,
+      response: 'positive', navigate_text_key: null, navigate_target: null, is_read: 1,
+      created_at: '2025-01-01T00:00:00Z',
+    };
+
+    act(() => {
+      capturedListener!({ type: 'notification:updated', notification });
+    });
+
+    expect(handleUpdated).toHaveBeenCalledWith(notification);
+    unmount();
+  });
+
+  it('FE-HOOK-NOTIFLISTENER-005: unrelated event types are ignored', () => {
+    const handleNew = vi.fn();
+    const handleUpdated = vi.fn();
+    useInAppNotificationStore.setState({
+      handleNewNotification: handleNew,
+      handleUpdatedNotification: handleUpdated,
+    } as any);
+
+    const { unmount } = renderHook(() => useInAppNotificationListener());
+
+    act(() => {
+      capturedListener!({ type: 'place:created', data: {} });
+    });
+
+    expect(handleNew).not.toHaveBeenCalled();
+    expect(handleUpdated).not.toHaveBeenCalled();
+    unmount();
+  });
+
+  it('FE-HOOK-NOTIFLISTENER-006: notification:new actually updates the store unreadCount', () => {
+    renderHook(() => useInAppNotificationListener());
+
+    const initialCount = useInAppNotificationStore.getState().unreadCount;
+
+    act(() => {
+      capturedListener!({
+        type: 'notification:new',
+        notification: {
+          id: 99, type: 'simple', scope: 'trip', target: 1, sender_id: null, sender_username: null,
+          sender_avatar: null, recipient_id: 2, title_key: 'test', title_params: {},
+          text_key: 'body', text_params: {}, positive_text_key: null, negative_text_key: null,
+          response: null, navigate_text_key: null, navigate_target: null, is_read: false,
+          created_at: '2025-01-01T00:00:00Z',
+        },
+      });
+    });
+
+    expect(useInAppNotificationStore.getState().unreadCount).toBe(initialCount + 1);
+  });
+
+  it('FE-HOOK-NOTIFLISTENER-007: notification:updated updates the notification in the store', () => {
+    // Seed a notification
+    useInAppNotificationStore.setState({
+      notifications: [{
+        id: 10, type: 'simple', scope: 'trip', target: 1, sender_id: null, sender_username: null,
+        sender_avatar: null, recipient_id: 2, title_key: 'test', title_params: {},
+        text_key: 'body', text_params: {}, positive_text_key: null, negative_text_key: null,
+        response: null, navigate_text_key: null, navigate_target: null, is_read: false,
+        created_at: '2025-01-01T00:00:00Z',
+      }],
+    });
+
+    renderHook(() => useInAppNotificationListener());
+
+    act(() => {
+      capturedListener!({
+        type: 'notification:updated',
+        notification: {
+          id: 10, type: 'simple', scope: 'trip', target: 1, sender_id: null, sender_username: null,
+          sender_avatar: null, recipient_id: 2, title_key: 'test', title_params: {},
+          text_key: 'body', text_params: {}, positive_text_key: null, negative_text_key: null,
+          response: 'positive', navigate_text_key: null, navigate_target: null, is_read: true,
+          created_at: '2025-01-01T00:00:00Z',
+        },
+      });
+    });
+
+    const updated = useInAppNotificationStore.getState().notifications.find((n) => n.id === 10);
+    expect(updated?.response).toBe('positive');
+    expect(updated?.is_read).toBe(true);
+  });
+
+  it('FE-HOOK-NOTIFLISTENER-008: multiple events processed correctly in sequence', () => {
+    const { unmount } = renderHook(() => useInAppNotificationListener());
+
+    const initial = useInAppNotificationStore.getState().unreadCount;
+
+    act(() => {
+      capturedListener!({
+        type: 'notification:new',
+        notification: {
+          id: 101, type: 'simple', scope: 'trip', target: 1, sender_id: null, sender_username: null,
+          sender_avatar: null, recipient_id: 2, title_key: 'k1', title_params: {},
+          text_key: 'b1', text_params: {}, positive_text_key: null, negative_text_key: null,
+          response: null, navigate_text_key: null, navigate_target: null, is_read: false,
+          created_at: '2025-01-01T00:00:00Z',
+        },
+      });
+      capturedListener!({
+        type: 'notification:new',
+        notification: {
+          id: 102, type: 'simple', scope: 'trip', target: 1, sender_id: null, sender_username: null,
+          sender_avatar: null, recipient_id: 2, title_key: 'k2', title_params: {},
+          text_key: 'b2', text_params: {}, positive_text_key: null, negative_text_key: null,
+          response: null, navigate_text_key: null, navigate_target: null, is_read: false,
+          created_at: '2025-01-01T00:00:00Z',
+        },
+      });
+    });
+
+    expect(useInAppNotificationStore.getState().unreadCount).toBe(initial + 2);
+    unmount();
+  });
+
+  it('FE-HOOK-NOTIFLISTENER-009: listener added on mount is the same one removed on unmount', () => {
+    const { unmount } = renderHook(() => useInAppNotificationListener());
+
+    const addedFn = (wsMock.addListener as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    unmount();
+    const removedFn = (wsMock.removeListener as ReturnType<typeof vi.fn>).mock.calls[0][0];
+
+    expect(addedFn).toBe(removedFn);
+  });
+
+  it('FE-HOOK-NOTIFLISTENER-010: after unmount, listener no longer processes events', () => {
+    const handleNew = vi.fn();
+    useInAppNotificationStore.setState({ handleNewNotification: handleNew } as any);
+
+    const { unmount } = renderHook(() => useInAppNotificationListener());
+    unmount();
+
+    // capturedListener is captured but the component is unmounted
+    // The removeListener was called — the actual implementation would have unregistered it
+    // We verify removeListener was called (the cleanup ran)
+    expect(wsMock.removeListener).toHaveBeenCalled();
+  });
+});
diff --git a/client/tests/integration/hooks/useResizablePanels.test.ts b/client/tests/integration/hooks/useResizablePanels.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b3b085336d6460b4ae3a51d0c0444e74e0c77cdc
--- /dev/null
+++ b/client/tests/integration/hooks/useResizablePanels.test.ts
@@ -0,0 +1,168 @@
+import { renderHook, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { fireEvent } from '@testing-library/react';
+import { useResizablePanels } from '../../../src/hooks/useResizablePanels';
+
+describe('useResizablePanels', () => {
+  beforeEach(() => {
+    localStorage.clear();
+    vi.clearAllMocks();
+  });
+
+  it('FE-HOOK-PANELS-001: default leftWidth is 340 when localStorage is empty', () => {
+    const { result } = renderHook(() => useResizablePanels());
+    expect(result.current.leftWidth).toBe(340);
+  });
+
+  it('FE-HOOK-PANELS-002: default rightWidth is 300 when localStorage is empty', () => {
+    const { result } = renderHook(() => useResizablePanels());
+    expect(result.current.rightWidth).toBe(300);
+  });
+
+  it('FE-HOOK-PANELS-003: leftWidth loaded from localStorage when set', () => {
+    localStorage.setItem('sidebarLeftWidth', '400');
+    const { result } = renderHook(() => useResizablePanels());
+    expect(result.current.leftWidth).toBe(400);
+  });
+
+  it('FE-HOOK-PANELS-004: rightWidth loaded from localStorage when set', () => {
+    localStorage.setItem('sidebarRightWidth', '350');
+    const { result } = renderHook(() => useResizablePanels());
+    expect(result.current.rightWidth).toBe(350);
+  });
+
+  it('FE-HOOK-PANELS-005: startResizeLeft sets body cursor to col-resize', () => {
+    const { result } = renderHook(() => useResizablePanels());
+    act(() => {
+      result.current.startResizeLeft();
+    });
+    expect(document.body.style.cursor).toBe('col-resize');
+  });
+
+  it('FE-HOOK-PANELS-006: startResizeRight sets body cursor to col-resize', () => {
+    const { result } = renderHook(() => useResizablePanels());
+    act(() => {
+      result.current.startResizeRight();
+    });
+    expect(document.body.style.cursor).toBe('col-resize');
+  });
+
+  it('FE-HOOK-PANELS-007: mousedown → mousemove → mouseup updates leftWidth and persists to localStorage', async () => {
+    const { result } = renderHook(() => useResizablePanels());
+
+    act(() => {
+      result.current.startResizeLeft();
+    });
+
+    // mousemove with clientX=350 → w = max(200, min(520, 350-10)) = 340
+    act(() => {
+      fireEvent.mouseMove(document, { clientX: 350 });
+    });
+
+    expect(result.current.leftWidth).toBe(340);
+    expect(localStorage.getItem('sidebarLeftWidth')).toBe('340');
+
+    act(() => {
+      fireEvent.mouseUp(document);
+    });
+
+    expect(document.body.style.cursor).toBe('');
+  });
+
+  it('FE-HOOK-PANELS-008: mousedown → mousemove → mouseup updates rightWidth and persists to localStorage', () => {
+    // Set window.innerWidth for the right panel calculation
+    Object.defineProperty(window, 'innerWidth', { writable: true, configurable: true, value: 1200 });
+
+    const { result } = renderHook(() => useResizablePanels());
+
+    act(() => {
+      result.current.startResizeRight();
+    });
+
+    // mousemove with clientX=800 → w = max(200, min(520, 1200-800-10)) = max(200, min(520, 390)) = 390
+    act(() => {
+      fireEvent.mouseMove(document, { clientX: 800 });
+    });
+
+    expect(result.current.rightWidth).toBe(390);
+    expect(localStorage.getItem('sidebarRightWidth')).toBe('390');
+
+    act(() => {
+      fireEvent.mouseUp(document);
+    });
+
+    expect(document.body.style.cursor).toBe('');
+  });
+
+  it('FE-HOOK-PANELS-009: min width constraint (200) is enforced for left panel', () => {
+    const { result } = renderHook(() => useResizablePanels());
+
+    act(() => {
+      result.current.startResizeLeft();
+    });
+
+    // clientX=50 → w = max(200, min(520, 50-10)) = max(200, 40) = 200
+    act(() => {
+      fireEvent.mouseMove(document, { clientX: 50 });
+    });
+
+    expect(result.current.leftWidth).toBe(200);
+  });
+
+  it('FE-HOOK-PANELS-010: max width constraint (520) is enforced for left panel', () => {
+    const { result } = renderHook(() => useResizablePanels());
+
+    act(() => {
+      result.current.startResizeLeft();
+    });
+
+    // clientX=600 → w = max(200, min(520, 600-10)) = min(520, 590) = 520
+    act(() => {
+      fireEvent.mouseMove(document, { clientX: 600 });
+    });
+
+    expect(result.current.leftWidth).toBe(520);
+  });
+
+  it('FE-HOOK-PANELS-011: mousemove without prior startResize does nothing', () => {
+    const { result } = renderHook(() => useResizablePanels());
+
+    const initialLeft = result.current.leftWidth;
+    const initialRight = result.current.rightWidth;
+
+    act(() => {
+      fireEvent.mouseMove(document, { clientX: 400 });
+    });
+
+    expect(result.current.leftWidth).toBe(initialLeft);
+    expect(result.current.rightWidth).toBe(initialRight);
+  });
+
+  it('FE-HOOK-PANELS-012: body userSelect set to none during resize, cleared on mouseup', () => {
+    const { result } = renderHook(() => useResizablePanels());
+
+    act(() => {
+      result.current.startResizeLeft();
+    });
+
+    expect(document.body.style.userSelect).toBe('none');
+
+    act(() => {
+      fireEvent.mouseUp(document);
+    });
+
+    expect(document.body.style.userSelect).toBe('');
+  });
+
+  it('FE-HOOK-PANELS-013: leftCollapsed and rightCollapsed default to false', () => {
+    const { result } = renderHook(() => useResizablePanels());
+    expect(result.current.leftCollapsed).toBe(false);
+    expect(result.current.rightCollapsed).toBe(false);
+  });
+
+  it('FE-HOOK-PANELS-014: setLeftCollapsed and setRightCollapsed are exposed', () => {
+    const { result } = renderHook(() => useResizablePanels());
+    expect(result.current.setLeftCollapsed).toBeTypeOf('function');
+    expect(result.current.setRightCollapsed).toBeTypeOf('function');
+  });
+});
diff --git a/client/tests/integration/hooks/useRouteCalculation.test.ts b/client/tests/integration/hooks/useRouteCalculation.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..aa97af5be44f6cb0b7e8cec5f44443b38615be1b
--- /dev/null
+++ b/client/tests/integration/hooks/useRouteCalculation.test.ts
@@ -0,0 +1,294 @@
+import { renderHook, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { useRouteCalculation } from '../../../src/hooks/useRouteCalculation';
+import { useTripStore } from '../../../src/store/tripStore';
+import { buildAssignment, buildPlace } from '../../helpers/factories';
+import type { TripStoreState } from '../../../src/store/tripStore';
+import type { RouteSegment } from '../../../src/types';
+
+// Mock the RouteCalculator module to avoid real OSRM fetch calls
+vi.mock('../../../src/components/Map/RouteCalculator', () => ({
+  calculateRouteWithLegs: vi.fn(),
+  calculateRoute: vi.fn(),
+  optimizeRoute: vi.fn((waypoints: unknown[]) => waypoints),
+  generateGoogleMapsUrl: vi.fn(),
+}));
+
+const { calculateRouteWithLegs } = await import('../../../src/components/Map/RouteCalculator');
+
+function buildMockStore(assignments: Record<string, ReturnType<typeof buildAssignment>[]> = {}): Partial<TripStoreState> {
+  // Also populate the real Zustand store so updateRouteForDay (which reads from
+  // useTripStore.getState()) sees the same assignments as the hook's tripStore param.
+  // Reset reservations and days to empty so transport-split logic doesn't interfere.
+  useTripStore.setState({ assignments, reservations: [], days: [] } as any);
+  return { assignments } as Partial<TripStoreState>;
+}
+
+const MOCK_SEGMENTS: RouteSegment[] = [
+  {
+    mid: [48.5, 2.5],
+    from: [48.86, 2.35],
+    to: [48.21, 16.37],
+    distance: 343000,
+    duration: 12600,
+    distanceText: '343 km',
+    durationText: '3 h 30 min',
+    walkingText: '70 h',
+    drivingText: '3 h 30 min',
+  },
+];
+
+// Empty coordinates make the hook fall back to the straight-line geometry,
+// so the `route` assertions keep checking the raw waypoints while the legs
+// still flow through to `routeSegments`.
+const MOCK_ROUTE_WITH_LEGS = {
+  coordinates: [] as [number, number][],
+  distance: 343000,
+  duration: 12600,
+  legs: MOCK_SEGMENTS,
+};
+
+describe('useRouteCalculation', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Reset trip store assignments so each test starts clean
+    useTripStore.setState({ assignments: {} } as any);
+    (calculateRouteWithLegs as ReturnType<typeof vi.fn>).mockResolvedValue(MOCK_ROUTE_WITH_LEGS);
+  });
+
+  it('FE-HOOK-ROUTE-001: with no selectedDayId, route is null', () => {
+    const store = buildMockStore({});
+    const { result } = renderHook(() =>
+      useRouteCalculation(store as TripStoreState, null)
+    );
+    expect(result.current.route).toBeNull();
+  });
+
+  it('FE-HOOK-ROUTE-002: with < 2 waypoints, route remains null', async () => {
+    const place = buildPlace({ lat: 48.8566, lng: 2.3522 });
+    const assignment = buildAssignment({ day_id: 5, order_index: 0, place });
+    const store = buildMockStore({ '5': [assignment] });
+
+    const { result } = renderHook(() =>
+      useRouteCalculation(store as TripStoreState, 5)
+    );
+
+    await act(async () => {});
+    expect(result.current.route).toBeNull();
+  });
+
+  it('FE-HOOK-ROUTE-003: with ≥ 2 geo-coded assignments, sets route coordinates', async () => {
+    const p1 = buildPlace({ lat: 48.8566, lng: 2.3522 });
+    const p2 = buildPlace({ lat: 51.5074, lng: -0.1278 });
+    const a1 = buildAssignment({ day_id: 5, order_index: 0, place: p1 });
+    const a2 = buildAssignment({ day_id: 5, order_index: 1, place: p2 });
+    const store = buildMockStore({ '5': [a1, a2] });
+
+    const { result } = renderHook(() =>
+      useRouteCalculation(store as TripStoreState, 5)
+    );
+
+    await act(async () => {});
+    // route is an array of segments; no transport → single segment with all places
+    expect(result.current.route).toEqual([
+      [[p1.lat, p1.lng], [p2.lat, p2.lng]],
+    ]);
+  });
+
+  it('FE-HOOK-ROUTE-004: calls calculateRouteWithLegs and exposes the returned segments', async () => {
+    const p1 = buildPlace({ lat: 48.8566, lng: 2.3522 });
+    const p2 = buildPlace({ lat: 51.5074, lng: -0.1278 });
+    const a1 = buildAssignment({ day_id: 5, order_index: 0, place: p1 });
+    const a2 = buildAssignment({ day_id: 5, order_index: 1, place: p2 });
+    const store = buildMockStore({ '5': [a1, a2] });
+
+    const { result } = renderHook(() =>
+      useRouteCalculation(store as TripStoreState, 5)
+    );
+
+    await act(async () => {});
+
+    expect(calculateRouteWithLegs).toHaveBeenCalled();
+    expect(result.current.routeSegments).toEqual(MOCK_SEGMENTS);
+  });
+
+  it('FE-HOOK-ROUTE-006: assignments are sorted by order_index before extracting waypoints', async () => {
+    const p1 = buildPlace({ lat: 10, lng: 10 });
+    const p2 = buildPlace({ lat: 20, lng: 20 });
+    // order_index 1 comes before 0 in the array, but should be sorted
+    const a1 = buildAssignment({ day_id: 5, order_index: 1, place: p1 });
+    const a2 = buildAssignment({ day_id: 5, order_index: 0, place: p2 });
+    const store = buildMockStore({ '5': [a1, a2] });
+
+    const { result } = renderHook(() =>
+      useRouteCalculation(store as TripStoreState, 5)
+    );
+
+    await act(async () => {});
+
+    // After sort: a2 (order_index=0) first, then a1 (order_index=1)
+    expect(result.current.route).toEqual([
+      [[p2.lat, p2.lng], [p1.lat, p1.lng]],
+    ]);
+  });
+
+  it('FE-HOOK-ROUTE-007: assignments with no lat/lng are filtered out', async () => {
+    const pValid = buildPlace({ lat: 48.8566, lng: 2.3522 });
+    const pNoGeo = buildPlace({ lat: null as any, lng: null as any });
+    const a1 = buildAssignment({ day_id: 5, order_index: 0, place: pNoGeo });
+    const a2 = buildAssignment({ day_id: 5, order_index: 1, place: pValid });
+    const store = buildMockStore({ '5': [a1, a2] });
+
+    const { result } = renderHook(() =>
+      useRouteCalculation(store as TripStoreState, 5)
+    );
+
+    await act(async () => {});
+    // Only 1 valid waypoint → route is null
+    expect(result.current.route).toBeNull();
+  });
+
+  it('FE-HOOK-ROUTE-008: AbortController.abort() is called when selectedDayId changes', async () => {
+
+    // Make calculateRouteWithLegs resolve slowly
+    let resolveSegments!: (val: typeof MOCK_ROUTE_WITH_LEGS) => void;
+    (calculateRouteWithLegs as ReturnType<typeof vi.fn>).mockImplementationOnce(
+      (_waypoints: unknown[], options: { signal?: AbortSignal }) => {
+        return new Promise<typeof MOCK_ROUTE_WITH_LEGS>((resolve) => {
+          resolveSegments = resolve;
+          options?.signal?.addEventListener('abort', () => resolve(MOCK_ROUTE_WITH_LEGS));
+        });
+      }
+    );
+
+    const p1 = buildPlace({ lat: 10, lng: 10 });
+    const p2 = buildPlace({ lat: 20, lng: 20 });
+    const a1 = buildAssignment({ day_id: 5, order_index: 0, place: p1 });
+    const a2 = buildAssignment({ day_id: 5, order_index: 1, place: p2 });
+
+    const store1 = buildMockStore({ '5': [a1, a2], '6': [a1, a2] });
+
+    const { rerender } = renderHook(
+      ({ dayId }: { dayId: number }) => useRouteCalculation(store1 as TripStoreState, dayId),
+      { initialProps: { dayId: 5 } }
+    );
+
+    // Change to day 6 — should abort in-flight request for day 5
+    await act(async () => {
+      rerender({ dayId: 6 });
+    });
+
+    // calculateRouteWithLegs should have been called at least once for day 5
+    // and once more for day 6
+    expect((calculateRouteWithLegs as ReturnType<typeof vi.fn>).mock.calls.length).toBeGreaterThanOrEqual(1);
+
+    // Cleanup
+    resolveSegments?.(MOCK_ROUTE_WITH_LEGS);
+  });
+
+  it('FE-HOOK-ROUTE-009: AbortError from calculateSegments does not set routeSegments to []', async () => {
+
+    const abortError = new Error('Aborted');
+    abortError.name = 'AbortError';
+    (calculateRouteWithLegs as ReturnType<typeof vi.fn>).mockRejectedValueOnce(abortError);
+
+    const p1 = buildPlace({ lat: 10, lng: 10 });
+    const p2 = buildPlace({ lat: 20, lng: 20 });
+    const a1 = buildAssignment({ day_id: 5, order_index: 0, place: p1 });
+    const a2 = buildAssignment({ day_id: 5, order_index: 1, place: p2 });
+    const store = buildMockStore({ '5': [a1, a2] });
+
+    const { result } = renderHook(() =>
+      useRouteCalculation(store as TripStoreState, 5)
+    );
+
+    await act(async () => {});
+    // AbortError should be swallowed silently — segments remain empty
+    expect(result.current.routeSegments).toEqual([]);
+  });
+
+  it('FE-HOOK-ROUTE-010: non-AbortError from calculateSegments sets routeSegments to []', async () => {
+
+    (calculateRouteWithLegs as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error('Network error'));
+
+    const p1 = buildPlace({ lat: 10, lng: 10 });
+    const p2 = buildPlace({ lat: 20, lng: 20 });
+    const a1 = buildAssignment({ day_id: 5, order_index: 0, place: p1 });
+    const a2 = buildAssignment({ day_id: 5, order_index: 1, place: p2 });
+    const store = buildMockStore({ '5': [a1, a2] });
+
+    const { result } = renderHook(() =>
+      useRouteCalculation(store as TripStoreState, 5)
+    );
+
+    await act(async () => {});
+    expect(result.current.routeSegments).toEqual([]);
+  });
+
+  it('FE-HOOK-ROUTE-011: when selectedDayId is null, route and segments are cleared', async () => {
+    const p1 = buildPlace({ lat: 10, lng: 10 });
+    const p2 = buildPlace({ lat: 20, lng: 20 });
+    const a1 = buildAssignment({ day_id: 5, order_index: 0, place: p1 });
+    const a2 = buildAssignment({ day_id: 5, order_index: 1, place: p2 });
+    const store = buildMockStore({ '5': [a1, a2] });
+
+    const { result, rerender } = renderHook(
+      ({ dayId }: { dayId: number | null }) => useRouteCalculation(store as TripStoreState, dayId),
+      { initialProps: { dayId: 5 as number | null } }
+    );
+
+    await act(async () => {});
+    // Some route may have been set for day 5
+
+    await act(async () => {
+      rerender({ dayId: null });
+    });
+
+    expect(result.current.route).toBeNull();
+    expect(result.current.routeSegments).toEqual([]);
+  });
+
+  it('FE-HOOK-ROUTE-012: setRoute and setRouteInfo are exposed', () => {
+    const store = buildMockStore({});
+    const { result } = renderHook(() =>
+      useRouteCalculation(store as TripStoreState, null)
+    );
+    expect(result.current.setRoute).toBeTypeOf('function');
+    expect(result.current.setRouteInfo).toBeTypeOf('function');
+  });
+
+  it('FE-HOOK-ROUTE-013: route recalculates when assignments change via store update', async () => {
+
+    const p1 = buildPlace({ lat: 10, lng: 10 });
+    const p2 = buildPlace({ lat: 20, lng: 20 });
+    const a1 = buildAssignment({ day_id: 5, order_index: 0, place: p1 });
+    const a2 = buildAssignment({ day_id: 5, order_index: 1, place: p2 });
+
+    let storeData = buildMockStore({ '5': [a1, a2] });
+
+    const { result, rerender } = renderHook(() =>
+      useRouteCalculation(storeData as TripStoreState, 5)
+    );
+
+    await act(async () => {});
+
+    expect(result.current.route).toEqual([
+      [[p1.lat, p1.lng], [p2.lat, p2.lng]],
+    ]);
+
+    // Now add a third place — update both the local store object and the Zustand store
+    const p3 = buildPlace({ lat: 30, lng: 30 });
+    const a3 = buildAssignment({ day_id: 5, order_index: 2, place: p3 });
+    storeData = buildMockStore({ '5': [a1, a2, a3] }); // also calls useTripStore.setState
+
+    await act(async () => {
+      rerender();
+    });
+
+    await act(async () => {});
+
+    expect(result.current.route).toEqual([
+      [[p1.lat, p1.lng], [p2.lat, p2.lng], [p3.lat, p3.lng]],
+    ]);
+  });
+});
diff --git a/client/tests/integration/hooks/useTripWebSocket.test.ts b/client/tests/integration/hooks/useTripWebSocket.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6ea0ccbc63d2abf130a0f58f91d6520bec7feb71
--- /dev/null
+++ b/client/tests/integration/hooks/useTripWebSocket.test.ts
@@ -0,0 +1,135 @@
+import { renderHook, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { useTripWebSocket } from '../../../src/hooks/useTripWebSocket';
+import { useTripStore } from '../../../src/store/tripStore';
+
+vi.mock('../../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => 'mock-socket-id'),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+}));
+
+// Import the mocked module AFTER vi.mock
+const wsMock = await import('../../../src/api/websocket');
+
+describe('useTripWebSocket', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('FE-HOOK-WS-001: on mount, joinTrip(tripId) is called', () => {
+    const { unmount } = renderHook(() => useTripWebSocket(42));
+    expect(wsMock.joinTrip).toHaveBeenCalledWith(42);
+    unmount();
+  });
+
+  it('FE-HOOK-WS-002: on mount, addListener is called (registers event handlers)', () => {
+    const { unmount } = renderHook(() => useTripWebSocket(42));
+    // addListener is called twice: once for handleRemoteEvent, once for collabFileSync
+    expect(wsMock.addListener).toHaveBeenCalled();
+    expect((wsMock.addListener as ReturnType<typeof vi.fn>).mock.calls.length).toBeGreaterThanOrEqual(1);
+    unmount();
+  });
+
+  it('FE-HOOK-WS-003: on unmount, leaveTrip(tripId) is called', () => {
+    const { unmount } = renderHook(() => useTripWebSocket(42));
+    unmount();
+    expect(wsMock.leaveTrip).toHaveBeenCalledWith(42);
+  });
+
+  it('FE-HOOK-WS-004: on unmount, removeListener is called', () => {
+    const { unmount } = renderHook(() => useTripWebSocket(42));
+    unmount();
+    expect(wsMock.removeListener).toHaveBeenCalled();
+  });
+
+  it('FE-HOOK-WS-005: when tripId changes, leaves old trip and joins new one', () => {
+    const { rerender, unmount } = renderHook(({ id }) => useTripWebSocket(id), {
+      initialProps: { id: 1 as number | undefined },
+    });
+    expect(wsMock.joinTrip).toHaveBeenCalledWith(1);
+
+    rerender({ id: 2 });
+
+    expect(wsMock.leaveTrip).toHaveBeenCalledWith(1);
+    expect(wsMock.joinTrip).toHaveBeenCalledWith(2);
+    unmount();
+  });
+
+  it('FE-HOOK-WS-006: one of the registered listeners is handleRemoteEvent from tripStore', () => {
+    const handler = useTripStore.getState().handleRemoteEvent;
+    renderHook(() => useTripWebSocket(42));
+
+    const addListenerCalls = (wsMock.addListener as ReturnType<typeof vi.fn>).mock.calls;
+    const registeredFunctions = addListenerCalls.map((call) => call[0]);
+    expect(registeredFunctions).toContain(handler);
+  });
+
+  it('FE-HOOK-WS-006b: collab file sync listener is also registered (second addListener call)', () => {
+    const { unmount } = renderHook(() => useTripWebSocket(42));
+    // Two listeners registered: handleRemoteEvent + collabFileSync
+    expect((wsMock.addListener as ReturnType<typeof vi.fn>).mock.calls.length).toBe(2);
+    unmount();
+  });
+
+  it('FE-HOOK-WS-006c: collab file sync listener reacts to collab:note:deleted events', () => {
+    const mockLoadFiles = vi.fn();
+    useTripStore.setState({ loadFiles: mockLoadFiles } as any);
+
+    renderHook(() => useTripWebSocket(42));
+
+    // The second addListener call is the collabFileSync function
+    const addListenerCalls = (wsMock.addListener as ReturnType<typeof vi.fn>).mock.calls;
+    const collabFileSync = addListenerCalls[1]?.[0];
+    expect(collabFileSync).toBeTypeOf('function');
+
+    act(() => {
+      collabFileSync({ type: 'collab:note:deleted' });
+    });
+
+    expect(mockLoadFiles).toHaveBeenCalledWith(42);
+  });
+
+  it('FE-HOOK-WS-006d: collab file sync listener reacts to collab:note:updated events', () => {
+    const mockLoadFiles = vi.fn();
+    useTripStore.setState({ loadFiles: mockLoadFiles } as any);
+
+    renderHook(() => useTripWebSocket(42));
+
+    const addListenerCalls = (wsMock.addListener as ReturnType<typeof vi.fn>).mock.calls;
+    const collabFileSync = addListenerCalls[1]?.[0];
+
+    act(() => {
+      collabFileSync({ type: 'collab:note:updated' });
+    });
+
+    expect(mockLoadFiles).toHaveBeenCalledWith(42);
+  });
+
+  it('FE-HOOK-WS-006e: collab file sync listener ignores unrelated event types', () => {
+    const mockLoadFiles = vi.fn();
+    useTripStore.setState({ loadFiles: mockLoadFiles } as any);
+
+    renderHook(() => useTripWebSocket(42));
+
+    const addListenerCalls = (wsMock.addListener as ReturnType<typeof vi.fn>).mock.calls;
+    const collabFileSync = addListenerCalls[1]?.[0];
+
+    act(() => {
+      collabFileSync({ type: 'place:created' });
+    });
+
+    expect(mockLoadFiles).not.toHaveBeenCalled();
+  });
+
+  it('FE-HOOK-WS-007: no joinTrip call when tripId is undefined', () => {
+    renderHook(() => useTripWebSocket(undefined));
+    expect(wsMock.joinTrip).not.toHaveBeenCalled();
+  });
+});
diff --git a/client/tests/setup.ts b/client/tests/setup.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0c0fc01231f8821f757d6679acca8d95eb75b852
--- /dev/null
+++ b/client/tests/setup.ts
@@ -0,0 +1,86 @@
+import '@testing-library/jest-dom/vitest';
+import 'fake-indexeddb/auto';
+import { cleanup } from '@testing-library/react';
+import { afterAll, afterEach, beforeAll, vi } from 'vitest';
+import { server } from './helpers/msw/server';
+
+// Mock the websocket module so stores don't try to open real connections
+vi.mock('../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => null),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+}));
+
+// MSW lifecycle
+beforeAll(() => server.listen({ onUnhandledRequest: 'warn' }));
+afterEach(() => {
+  server.resetHandlers();
+  cleanup();
+  localStorage.clear();
+  sessionStorage.clear();
+});
+afterAll(() => server.close());
+
+// ── jsdom stubs ────────────────────────────────────────────────────────────────
+
+// Force en-US locale for toLocaleDateString so tests are deterministic on
+// non-US dev machines (Windows-de-DE returns "Sonntag" instead of "Sunday").
+// Only affects calls without an explicit locale — callers that pass a locale
+// keep their behavior.
+const _origToLocaleDateString = Date.prototype.toLocaleDateString
+Date.prototype.toLocaleDateString = function (locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions) {
+  return _origToLocaleDateString.call(this, locales ?? 'en-US', options)
+}
+
+// window.matchMedia — used by dark mode / responsive components
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: vi.fn().mockImplementation((query: string) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: vi.fn(),
+    removeListener: vi.fn(),
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    dispatchEvent: vi.fn(),
+  })),
+});
+
+// IntersectionObserver — used by lazy loading
+// Must use a class or regular function (not arrow function) so 'new IntersectionObserver()' works
+class _MockIntersectionObserver {
+  observe = vi.fn()
+  unobserve = vi.fn()
+  disconnect = vi.fn()
+  root = null
+  rootMargin = ''
+  thresholds: ReadonlyArray<number> = []
+  takeRecords = vi.fn(() => [])
+  constructor(_callback: IntersectionObserverCallback, _options?: IntersectionObserverInit) {}
+}
+globalThis.IntersectionObserver = _MockIntersectionObserver as unknown as typeof IntersectionObserver;
+
+// ResizeObserver — used by resizable panels
+class _MockResizeObserver {
+  observe = vi.fn()
+  unobserve = vi.fn()
+  disconnect = vi.fn()
+  constructor(_callback: ResizeObserverCallback) {}
+}
+globalThis.ResizeObserver = _MockResizeObserver as unknown as typeof ResizeObserver;
+
+// URL.createObjectURL / revokeObjectURL — Node 22 URL.createObjectURL requires
+// a native node:buffer Blob; passing a jsdom Blob throws ERR_INVALID_ARG_TYPE.
+// Tests that need blob URLs should mock fetch to return node:buffer Blobs so
+// the real URL.createObjectURL works. For tests that only need the method to
+// exist without returning a real URL, stub it here as a vi.fn fallback.
+if (typeof URL.createObjectURL === 'undefined') {
+  Object.defineProperty(URL, 'createObjectURL', { writable: true, configurable: true, value: vi.fn(() => 'blob:mock') });
+  Object.defineProperty(URL, 'revokeObjectURL', { writable: true, configurable: true, value: vi.fn() });
+}
+
+// Element.prototype.scrollIntoView — jsdom doesn't implement it
+Element.prototype.scrollIntoView = vi.fn();
diff --git a/client/tests/unit/api/authUrl.test.ts b/client/tests/unit/api/authUrl.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e40cb0b3aed1839b578065d103654ab5f0ad2cbc
--- /dev/null
+++ b/client/tests/unit/api/authUrl.test.ts
@@ -0,0 +1,237 @@
+/// <reference types="node" />
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../helpers/msw/server';
+import { getAuthUrl, fetchImageAsBlob, clearImageQueue } from '../../../src/api/authUrl';
+
+// Flush microtasks + a macro-task so async handlers finish
+const flushPromises = () => new Promise<void>(r => setTimeout(r, 10));
+
+beforeEach(() => {
+  clearImageQueue();
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+// ── getAuthUrl ─────────────────────────────────────────────────────────────────
+
+describe('getAuthUrl', () => {
+  describe('FE-COMP-AUTHURL-001: empty URL returns early', () => {
+    it('returns empty string without hitting the network', async () => {
+      const result = await getAuthUrl('', 'download');
+      expect(result).toBe('');
+    });
+  });
+
+  describe('FE-COMP-AUTHURL-002: token appended with ?', () => {
+    it('appends token as first query param when URL has no query string', async () => {
+      server.use(
+        http.post('/api/auth/resource-token', () =>
+          HttpResponse.json({ token: 'abc123' })
+        )
+      );
+      const result = await getAuthUrl('/uploads/file.pdf', 'download');
+      expect(result).toBe('/uploads/file.pdf?token=abc123');
+    });
+  });
+
+  describe('FE-COMP-AUTHURL-003: token appended with &', () => {
+    it('appends token as additional query param when URL already has a query string', async () => {
+      server.use(
+        http.post('/api/auth/resource-token', () =>
+          HttpResponse.json({ token: 'xyz' })
+        )
+      );
+      const result = await getAuthUrl('/uploads/file.pdf?size=lg', 'download');
+      expect(result).toBe('/uploads/file.pdf?size=lg&token=xyz');
+    });
+  });
+
+  describe('FE-COMP-AUTHURL-004: non-ok API response returns original URL', () => {
+    it('returns original URL unchanged when resource-token returns 500', async () => {
+      server.use(
+        http.post('/api/auth/resource-token', () =>
+          HttpResponse.json({}, { status: 500 })
+        )
+      );
+      const result = await getAuthUrl('/uploads/file.pdf', 'download');
+      expect(result).toBe('/uploads/file.pdf');
+    });
+  });
+
+  describe('FE-COMP-AUTHURL-005: fetch throws returns original URL', () => {
+    it('returns original URL when fetch throws a network error', async () => {
+      vi.spyOn(globalThis, 'fetch').mockRejectedValueOnce(
+        new TypeError('Network error')
+      );
+      const result = await getAuthUrl('/uploads/file.pdf', 'download');
+      expect(result).toBe('/uploads/file.pdf');
+    });
+  });
+});
+
+// ── fetchImageAsBlob ───────────────────────────────────────────────────────────
+
+describe('fetchImageAsBlob', () => {
+  describe('FE-COMP-AUTHURL-006: empty URL returns empty string', () => {
+    it('resolves to empty string without network call', async () => {
+      const result = await fetchImageAsBlob('');
+      expect(result).toBe('');
+    });
+  });
+
+  describe('FE-COMP-AUTHURL-007: successful fetch returns blob object URL', () => {
+    it('resolves to a blob URL for a valid image response', async () => {
+      // Node 22 URL.createObjectURL requires a native node:buffer Blob, not a
+      // jsdom Blob — passing the wrong type throws ERR_INVALID_ARG_TYPE (caught,
+      // returns ''). Mock fetch directly with a Node Blob so the real
+      // URL.createObjectURL works without any mocking needed.
+      const { Blob: NodeBlob } = await import('node:buffer');
+      vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce({
+        ok: true,
+        blob: () => Promise.resolve(new NodeBlob(['fake-image'], { type: 'image/jpeg' }) as unknown as Blob),
+      } as unknown as Response);
+      const result = await fetchImageAsBlob('/uploads/photo.jpg');
+      expect(result).toMatch(/^blob:/);
+    });
+  });
+
+  describe('FE-COMP-AUTHURL-008: non-ok response resolves to empty string', () => {
+    it('resolves to empty string when image URL returns 404', async () => {
+      server.use(
+        http.get('/uploads/missing.jpg', () =>
+          HttpResponse.json({}, { status: 404 })
+        )
+      );
+      const result = await fetchImageAsBlob('/uploads/missing.jpg');
+      expect(result).toBe('');
+    });
+  });
+
+  describe('FE-COMP-AUTHURL-009: fetch throws resolves to empty string', () => {
+    it('resolves to empty string when fetch rejects', async () => {
+      vi.spyOn(globalThis, 'fetch').mockRejectedValueOnce(
+        new TypeError('Network error')
+      );
+      const result = await fetchImageAsBlob('/uploads/error.jpg');
+      expect(result).toBe('');
+    });
+  });
+
+  // ── Concurrency tests use vi.spyOn(fetch) for synchronous barrier control ──
+  // When the spy mock runs, it executes synchronously up to its first `await`,
+  // so `resolvers.push(r)` happens synchronously inside fetchImageAsBlob(), giving
+  // us deterministic access to in-flight requests without needing flushPromises().
+
+  describe('FE-COMP-AUTHURL-010: concurrency cap at MAX_CONCURRENT=6', () => {
+    it('fires at most 6 requests simultaneously', async () => {
+      let concurrent = 0;
+      let maxConcurrent = 0;
+      const resolvers: Array<() => void> = [];
+
+      vi.spyOn(globalThis, 'fetch').mockImplementation(async () => {
+        concurrent++;
+        maxConcurrent = Math.max(maxConcurrent, concurrent);
+        await new Promise<void>(r => resolvers.push(r));
+        concurrent--;
+        return new Response(new Blob(['img'], { type: 'image/jpeg' }), { status: 200 });
+      });
+
+      const urls = Array.from({ length: 8 }, (_, i) => `/uploads/img${i}.jpg`);
+      const promises = urls.map(url => fetchImageAsBlob(url));
+
+      // After synchronous calls: 6 run()s called fetch() and pushed to resolvers,
+      // 2 are in the module queue
+      expect(resolvers.length).toBe(6);
+      expect(maxConcurrent).toBeLessThanOrEqual(6);
+
+      // Drain iteratively: each pass resolves current in-flight requests,
+      // then the next batch from the queue starts and pushes new resolvers
+      while (resolvers.length > 0) {
+        resolvers.splice(0).forEach(r => r());
+        await flushPromises();
+      }
+
+      await Promise.all(promises);
+      expect(maxConcurrent).toBeLessThanOrEqual(6);
+    });
+  });
+
+  describe('FE-COMP-AUTHURL-011: queued request runs after active slot frees', () => {
+    it('7th request eventually resolves once one of the 6 active slots is freed', async () => {
+      const resolvers: Array<() => void> = [];
+      const { Blob: NodeBlob } = await import('node:buffer');
+
+      vi.spyOn(globalThis, 'fetch').mockImplementation(async () => {
+        await new Promise<void>(r => resolvers.push(r));
+        return {
+          ok: true,
+          blob: () => Promise.resolve(new NodeBlob(['img'], { type: 'image/jpeg' }) as unknown as Blob),
+        } as unknown as Response;
+      });
+
+      const urls = Array.from({ length: 7 }, (_, i) => `/uploads/queue${i}.jpg`);
+      const promises = urls.map(url => fetchImageAsBlob(url));
+
+      // 6 in-flight, 1 queued
+      expect(resolvers.length).toBe(6);
+
+      // Resolve the 6 active requests
+      resolvers.splice(0).forEach(r => r());
+      await flushPromises();
+
+      // 7th should now have started
+      expect(resolvers.length).toBe(1);
+
+      // Resolve the 7th
+      resolvers.splice(0).forEach(r => r());
+
+      const results = await Promise.all(promises);
+      expect(results).toHaveLength(7);
+      results.forEach(r => expect(r).toMatch(/^blob:/));
+    });
+  });
+});
+
+// ── clearImageQueue ────────────────────────────────────────────────────────────
+
+describe('clearImageQueue', () => {
+  describe('FE-COMP-AUTHURL-012: clearImageQueue discards pending entries', () => {
+    it('removes queued items so they never execute after active slots drain', async () => {
+      const resolvers: Array<() => void> = [];
+      // Track completions via fetch mock instead of URL.createObjectURL spy —
+      // URL.createObjectURL is a Node built-in whose identity varies across
+      // Node versions, making it unreliable to spy on in jsdom tests on CI.
+      let completedFetches = 0;
+      const { Blob: NodeBlob } = await import('node:buffer');
+
+      vi.spyOn(globalThis, 'fetch').mockImplementation(async () => {
+        await new Promise<void>(r => resolvers.push(r));
+        completedFetches++;
+        return {
+          ok: true,
+          blob: () => Promise.resolve(new NodeBlob(['img'], { type: 'image/jpeg' }) as unknown as Blob),
+        } as unknown as Response;
+      });
+
+      const urls = Array.from({ length: 7 }, (_, i) => `/uploads/clear${i}.jpg`);
+      const promises = urls.map(url => fetchImageAsBlob(url));
+
+      // 6 in-flight, 1 queued
+      expect(resolvers.length).toBe(6);
+
+      // Discard the queued 7th request
+      clearImageQueue();
+
+      // Resolve the 6 active requests and let them drain
+      resolvers.splice(0).forEach(r => r());
+      await flushPromises();
+
+      // 6 active slots completed; queue was cleared so the 7th never ran
+      expect(completedFetches).toBe(6);
+
+      // First 6 promises resolved; 7th is orphaned (never resolves)
+      await Promise.all(promises.slice(0, 6));
+    });
+  });
+});
diff --git a/client/tests/unit/api/client.interceptor.test.ts b/client/tests/unit/api/client.interceptor.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a28e3d21c13155479e21b5871b95f6ec9c306de0
--- /dev/null
+++ b/client/tests/unit/api/client.interceptor.test.ts
@@ -0,0 +1,71 @@
+// FE-CLIENT-INTERCEPTOR-001 to FE-CLIENT-INTERCEPTOR-012
+import { describe, it, expect } from 'vitest'
+import { isAuthPublicPath } from '../../../src/api/client'
+
+describe('FE-CLIENT-INTERCEPTOR: 401 AUTH_REQUIRED redirect allowlist', () => {
+  describe('exact-match public paths — no redirect', () => {
+    it('FE-CLIENT-INTERCEPTOR-001: /login', () => {
+      expect(isAuthPublicPath('/login')).toBe(true)
+    })
+
+    it('FE-CLIENT-INTERCEPTOR-002: /register', () => {
+      expect(isAuthPublicPath('/register')).toBe(true)
+    })
+
+    it('FE-CLIENT-INTERCEPTOR-003: /forgot-password', () => {
+      expect(isAuthPublicPath('/forgot-password')).toBe(true)
+    })
+
+    it('FE-CLIENT-INTERCEPTOR-004: /reset-password', () => {
+      expect(isAuthPublicPath('/reset-password')).toBe(true)
+    })
+  })
+
+  describe('prefix-match public paths — no redirect', () => {
+    it('FE-CLIENT-INTERCEPTOR-005: /shared/:token', () => {
+      expect(isAuthPublicPath('/shared/abc123token')).toBe(true)
+    })
+
+    it('FE-CLIENT-INTERCEPTOR-006: /public/journey/:token', () => {
+      expect(isAuthPublicPath('/public/journey/xyz789')).toBe(true)
+    })
+  })
+
+  describe('paths that matched via includes() before fix — must redirect', () => {
+    it('FE-CLIENT-INTERCEPTOR-007: /admin/login', () => {
+      expect(isAuthPublicPath('/admin/login')).toBe(false)
+    })
+
+    it('FE-CLIENT-INTERCEPTOR-008: /admin/register', () => {
+      expect(isAuthPublicPath('/admin/register')).toBe(false)
+    })
+
+    it('FE-CLIENT-INTERCEPTOR-009: /some-login-page', () => {
+      expect(isAuthPublicPath('/some-login-page')).toBe(false)
+    })
+  })
+
+  describe('paths that matched via loose startsWith before fix — must redirect', () => {
+    it('FE-CLIENT-INTERCEPTOR-010: /reset-password-extra', () => {
+      expect(isAuthPublicPath('/reset-password-extra')).toBe(false)
+    })
+
+    it('FE-CLIENT-INTERCEPTOR-011: /forgot-password-extra', () => {
+      expect(isAuthPublicPath('/forgot-password-extra')).toBe(false)
+    })
+  })
+
+  describe('private app paths — must redirect', () => {
+    it('FE-CLIENT-INTERCEPTOR-012: /dashboard', () => {
+      expect(isAuthPublicPath('/dashboard')).toBe(false)
+    })
+
+    it('FE-CLIENT-INTERCEPTOR-013: /trips/123', () => {
+      expect(isAuthPublicPath('/trips/123')).toBe(false)
+    })
+
+    it('FE-CLIENT-INTERCEPTOR-014: / (root)', () => {
+      expect(isAuthPublicPath('/')).toBe(false)
+    })
+  })
+})
diff --git a/client/tests/unit/db/offlineDb.test.ts b/client/tests/unit/db/offlineDb.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1d130a72429682c34861f29a6cff50f7039ae4c1
--- /dev/null
+++ b/client/tests/unit/db/offlineDb.test.ts
@@ -0,0 +1,370 @@
+/**
+ * offlineDb unit tests.
+ *
+ * Uses fake-indexeddb so no real browser IDB is needed.
+ * Each test gets a fresh database by using `use-fake-indexeddb` with Dexie.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import 'fake-indexeddb/auto';
+import Dexie from 'dexie';
+
+// Re-import after fake-indexeddb is set up so Dexie picks up the shim.
+// We re-open a clean db in each test to isolate state.
+import {
+  offlineDb,
+  clearTripData,
+  clearAll,
+  upsertTrip,
+  upsertDays,
+  upsertPlaces,
+  upsertPackingItems,
+  upsertTodoItems,
+  upsertBudgetItems,
+  upsertReservations,
+  upsertTripFiles,
+  upsertSyncMeta,
+  reopenForUser,
+  reopenAnonymous,
+  deleteCurrentUserDb,
+  enforceBlobBudget,
+  type QueuedMutation,
+  type SyncMeta,
+  type BlobCacheEntry,
+} from '../../../src/db/offlineDb';
+import type { Trip, Day, Place, PackingItem, TodoItem, BudgetItem, Reservation, TripFile } from '../../../src/types';
+
+// ── Fixtures ──────────────────────────────────────────────────────────────────
+
+const makeTrip = (id = 1): Trip => ({
+  id,
+  user_id: 42,
+  title: `Trip ${id}`,
+  description: null,
+  start_date: '2026-07-01',
+  end_date: '2026-07-05',
+  currency: 'EUR',
+  cover_image: null,
+  is_archived: 0,
+  reminder_days: 3,
+  created_at: '2026-01-01T00:00:00Z',
+  updated_at: '2026-01-01T00:00:00Z',
+});
+
+const makeDay = (id: number, tripId = 1): Day => ({
+  id,
+  trip_id: tripId,
+  date: '2026-07-01',
+  title: null,
+  notes: null,
+  assignments: [],
+  notes_items: [],
+});
+
+const makePlace = (id: number, tripId = 1): Place => ({
+  id,
+  trip_id: tripId,
+  name: `Place ${id}`,
+  description: null,
+  notes: null,
+  lat: 48.8566,
+  lng: 2.3522,
+  address: null,
+  category_id: null,
+  price: null,
+  currency: null,
+  image_url: null,
+  google_place_id: null,
+  osm_id: null,
+  route_geometry: null,
+  place_time: null,
+  end_time: null,
+  duration_minutes: null,
+  transport_mode: null,
+  website: null,
+  phone: null,
+  created_at: '2026-01-01T00:00:00Z',
+});
+
+const makeBlob = (url: string, tripId = 1, bytes = 10, cachedAt = 1): BlobCacheEntry => ({
+  url,
+  tripId,
+  blob: new Blob(['x'.repeat(bytes)], { type: 'application/pdf' }),
+  bytes,
+  mime: 'application/pdf',
+  cachedAt,
+});
+
+// ── Lifecycle ─────────────────────────────────────────────────────────────────
+
+beforeEach(async () => {
+  // Ensure DB is open (fake-indexeddb resets between test files but not between tests).
+  if (!offlineDb.isOpen()) await offlineDb.open();
+  // Clear all tables before each test.
+  await clearAll();
+});
+
+afterEach(async () => {
+  if (!offlineDb.isOpen()) await offlineDb.open();
+});
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe('offlineDb — trips', () => {
+  it('stores and retrieves a trip via upsertTrip', async () => {
+    const trip = makeTrip(10);
+    await upsertTrip(trip);
+    const stored = await offlineDb.trips.get(10);
+    expect(stored).toBeDefined();
+    expect(stored!.title).toBe('Trip 10');
+  });
+
+  it('upsertTrip overwrites an existing trip (put semantics)', async () => {
+    await upsertTrip(makeTrip(1));
+    await upsertTrip({ ...makeTrip(1), title: 'Updated' });
+    const stored = await offlineDb.trips.get(1);
+    expect(stored!.title).toBe('Updated');
+  });
+});
+
+describe('offlineDb — days', () => {
+  it('stores days and retrieves by trip_id index', async () => {
+    await upsertDays([makeDay(1, 5), makeDay(2, 5), makeDay(3, 9)]);
+    const trip5Days = await offlineDb.days.where('trip_id').equals(5).toArray();
+    expect(trip5Days).toHaveLength(2);
+    expect(trip5Days.map(d => d.id)).toContain(1);
+    expect(trip5Days.map(d => d.id)).toContain(2);
+  });
+});
+
+describe('offlineDb — places', () => {
+  it('stores places and retrieves by trip_id', async () => {
+    await upsertPlaces([makePlace(10, 1), makePlace(11, 1), makePlace(12, 2)]);
+    const places = await offlineDb.places.where('trip_id').equals(1).toArray();
+    expect(places).toHaveLength(2);
+  });
+});
+
+describe('offlineDb — packing / todo / budget / reservations / files', () => {
+  it('upserts packing items', async () => {
+    const item: PackingItem = { id: 1, trip_id: 1, name: 'Passport', category: null, checked: 0, sort_order: 0, quantity: 1 };
+    await upsertPackingItems([item]);
+    expect(await offlineDb.packingItems.count()).toBe(1);
+  });
+
+  it('upserts todo items', async () => {
+    const item: TodoItem = {
+      id: 1, trip_id: 1, name: 'Book hotel', category: null, checked: 0,
+      sort_order: 0, due_date: null, description: null, assigned_user_id: null, priority: 0,
+    };
+    await upsertTodoItems([item]);
+    expect(await offlineDb.todoItems.count()).toBe(1);
+  });
+
+  it('upserts budget items', async () => {
+    const item: BudgetItem = {
+      id: 1, trip_id: 1, name: 'Flight', total_price: 500,
+      category: 'Transport', persons: 1, members: [], expense_date: null, sort_order: 0,
+    };
+    await upsertBudgetItems([item]);
+    expect(await offlineDb.budgetItems.count()).toBe(1);
+  });
+
+  it('upserts reservations', async () => {
+    const item: Reservation = {
+      id: 1, trip_id: 1, title: 'Hotel', type: 'hotel', status: 'confirmed',
+      reservation_time: null, confirmation_number: null, notes: null, created_at: '2026-01-01T00:00:00Z',
+    };
+    await upsertReservations([item]);
+    expect(await offlineDb.reservations.count()).toBe(1);
+  });
+
+  it('upserts trip files', async () => {
+    const file: TripFile = {
+      id: 1, trip_id: 1, filename: 'ticket.pdf', original_name: 'Ticket.pdf',
+      mime_type: 'application/pdf', url: '/api/trips/1/files/1/download', created_at: '2026-01-01T00:00:00Z',
+    };
+    await upsertTripFiles([file]);
+    expect(await offlineDb.tripFiles.count()).toBe(1);
+  });
+});
+
+describe('offlineDb — syncMeta', () => {
+  it('stores and retrieves syncMeta by tripId', async () => {
+    const meta: SyncMeta = {
+      tripId: 7,
+      lastSyncedAt: Date.now(),
+      status: 'idle',
+      tilesBbox: null,
+      filesCachedCount: 0,
+    };
+    await upsertSyncMeta(meta);
+    const stored = await offlineDb.syncMeta.get(7);
+    expect(stored).toBeDefined();
+    expect(stored!.status).toBe('idle');
+  });
+});
+
+describe('offlineDb — mutationQueue', () => {
+  it('stores queued mutations queryable by status', async () => {
+    const pending: QueuedMutation = {
+      id: 'uuid-1', tripId: 1, method: 'POST', url: '/api/trips/1/places',
+      body: { name: 'Eiffel Tower' }, createdAt: Date.now(),
+      status: 'pending', attempts: 0, lastError: null,
+    };
+    const failed: QueuedMutation = {
+      id: 'uuid-2', tripId: 1, method: 'PUT', url: '/api/trips/1/places/5',
+      body: { name: 'Updated' }, createdAt: Date.now(),
+      status: 'failed', attempts: 3, lastError: 'Network error',
+    };
+    await offlineDb.mutationQueue.bulkPut([pending, failed]);
+
+    const pendingRows = await offlineDb.mutationQueue.where('status').equals('pending').toArray();
+    expect(pendingRows).toHaveLength(1);
+    expect(pendingRows[0].id).toBe('uuid-1');
+
+    const failedRows = await offlineDb.mutationQueue.where('status').equals('failed').toArray();
+    expect(failedRows).toHaveLength(1);
+    expect(failedRows[0].lastError).toBe('Network error');
+  });
+});
+
+describe('offlineDb — blobCache', () => {
+  it('stores and retrieves a Blob entry', async () => {
+    const blob = new Blob(['%PDF-1.4 test'], { type: 'application/pdf' });
+    const entry: BlobCacheEntry = {
+      url: '/api/files/99/download',
+      tripId: 1,
+      blob,
+      bytes: blob.size,
+      mime: 'application/pdf',
+      cachedAt: Date.now(),
+    };
+    await offlineDb.blobCache.put(entry);
+
+    const stored = await offlineDb.blobCache.get('/api/files/99/download');
+    expect(stored).toBeDefined();
+    expect(stored!.mime).toBe('application/pdf');
+    expect(stored!.blob).toBeDefined();
+  });
+
+  it('queries blobs by tripId index', async () => {
+    await offlineDb.blobCache.bulkPut([
+      makeBlob('/api/files/1/download', 1),
+      makeBlob('/api/files/2/download', 1),
+      makeBlob('/api/files/3/download', 2),
+    ]);
+    const trip1 = await offlineDb.blobCache.where('tripId').equals(1).toArray();
+    expect(trip1).toHaveLength(2);
+  });
+});
+
+describe('offlineDb — enforceBlobBudget', () => {
+  it('evicts oldest-by-cachedAt entries past the count budget', async () => {
+    // 5 entries with strictly increasing cachedAt; cap to 3.
+    for (let i = 0; i < 5; i++) {
+      await offlineDb.blobCache.put(makeBlob(`/api/files/${i}/download`, 1, 10, i + 1));
+    }
+    await enforceBlobBudget(3, Infinity);
+
+    expect(await offlineDb.blobCache.count()).toBe(3);
+    // Oldest two (cachedAt 1 and 2) are gone; newest survive.
+    expect(await offlineDb.blobCache.get('/api/files/0/download')).toBeUndefined();
+    expect(await offlineDb.blobCache.get('/api/files/1/download')).toBeUndefined();
+    expect(await offlineDb.blobCache.get('/api/files/4/download')).toBeDefined();
+  });
+
+  it('evicts oldest entries past the byte budget', async () => {
+    // 3 entries of 100 bytes each; cap to 250 bytes → newest two (200) survive.
+    for (let i = 0; i < 3; i++) {
+      await offlineDb.blobCache.put(makeBlob(`/api/files/${i}/download`, 1, 100, i + 1));
+    }
+    await enforceBlobBudget(Infinity, 250);
+
+    expect(await offlineDb.blobCache.count()).toBe(2);
+    expect(await offlineDb.blobCache.get('/api/files/0/download')).toBeUndefined();
+  });
+
+  it('is a no-op when already within budget', async () => {
+    await offlineDb.blobCache.put(makeBlob('/api/files/1/download', 1));
+    await enforceBlobBudget(10, Infinity);
+    expect(await offlineDb.blobCache.count()).toBe(1);
+  });
+});
+
+describe('offlineDb — clearTripData', () => {
+  it('removes all data for the given trip across all tables', async () => {
+    await upsertTrip(makeTrip(1));
+    await upsertDays([makeDay(1, 1), makeDay(2, 1)]);
+    await upsertPlaces([makePlace(10, 1)]);
+    const item: PackingItem = { id: 5, trip_id: 1, name: 'Towel', category: null, checked: 0, sort_order: 0, quantity: 1 };
+    await upsertPackingItems([item]);
+
+    await offlineDb.blobCache.put(makeBlob('/api/files/1/download', 1));
+
+    // Also add data for a different trip — should NOT be removed
+    await upsertTrip(makeTrip(2));
+    await upsertDays([makeDay(99, 2)]);
+    await offlineDb.blobCache.put(makeBlob('/api/files/2/download', 2));
+
+    await clearTripData(1);
+
+    expect(await offlineDb.trips.get(1)).toBeUndefined();
+    expect(await offlineDb.days.where('trip_id').equals(1).count()).toBe(0);
+    expect(await offlineDb.places.where('trip_id').equals(1).count()).toBe(0);
+    expect(await offlineDb.packingItems.where('trip_id').equals(1).count()).toBe(0);
+    expect(await offlineDb.blobCache.where('tripId').equals(1).count()).toBe(0);
+
+    // Trip 2 intact
+    expect(await offlineDb.trips.get(2)).toBeDefined();
+    expect(await offlineDb.days.where('trip_id').equals(2).count()).toBe(1);
+    expect(await offlineDb.blobCache.get('/api/files/2/download')).toBeDefined();
+  });
+});
+
+describe('offlineDb — clearAll', () => {
+  it('empties all tables', async () => {
+    await upsertTrip(makeTrip(1));
+    await upsertDays([makeDay(1, 1), makeDay(2, 1)]);
+    await upsertPlaces([makePlace(10, 1)]);
+
+    await clearAll();
+
+    expect(await offlineDb.trips.count()).toBe(0);
+    expect(await offlineDb.days.count()).toBe(0);
+    expect(await offlineDb.places.count()).toBe(0);
+  });
+});
+
+describe('offlineDb — per-user scoping (B4)', () => {
+  afterEach(async () => {
+    // Leave the suite on the anonymous DB so other tests are unaffected.
+    await reopenAnonymous();
+  });
+
+  it('isolates one user\'s cached data from another', async () => {
+    await reopenForUser(1);
+    await upsertPlaces([makePlace(10, 1)]);
+    expect(await offlineDb.places.count()).toBe(1);
+
+    // Switching users must not expose user 1's rows.
+    await reopenForUser(2);
+    expect(await offlineDb.places.count()).toBe(0);
+
+    // Switching back restores user 1's data (different physical DB).
+    await reopenForUser(1);
+    expect(await offlineDb.places.get(10)).toBeDefined();
+  });
+
+  it('deleteCurrentUserDb wipes the user DB and returns to anonymous', async () => {
+    await reopenForUser(5);
+    await upsertPlaces([makePlace(20, 1)]);
+
+    await deleteCurrentUserDb();
+    // Now on the anonymous DB — no user data.
+    expect(await offlineDb.places.count()).toBe(0);
+
+    // Re-opening user 5 starts empty (DB was deleted, not just detached).
+    await reopenForUser(5);
+    expect(await offlineDb.places.count()).toBe(0);
+  });
+});
diff --git a/client/tests/unit/hooks/usePlaceSelection.test.ts b/client/tests/unit/hooks/usePlaceSelection.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a21a9404f002fcaadb4623a1f361b833d42eb425
--- /dev/null
+++ b/client/tests/unit/hooks/usePlaceSelection.test.ts
@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { usePlaceSelection } from '../../../src/hooks/usePlaceSelection';
+
+// FE-HOOK-SEL-001 onwards
+
+describe('usePlaceSelection', () => {
+  it('FE-HOOK-SEL-001: initially both IDs are null', () => {
+    const { result } = renderHook(() => usePlaceSelection());
+    expect(result.current.selectedPlaceId).toBeNull();
+    expect(result.current.selectedAssignmentId).toBeNull();
+  });
+
+  it('FE-HOOK-SEL-002: setSelectedPlaceId sets selectedPlaceId', () => {
+    const { result } = renderHook(() => usePlaceSelection());
+    act(() => { result.current.setSelectedPlaceId(42); });
+    expect(result.current.selectedPlaceId).toBe(42);
+  });
+
+  it('FE-HOOK-SEL-003: setSelectedPlaceId clears selectedAssignmentId', () => {
+    const { result } = renderHook(() => usePlaceSelection());
+    // First set an assignment via selectAssignment
+    act(() => { result.current.selectAssignment(99, 10); });
+    expect(result.current.selectedAssignmentId).toBe(99);
+
+    // Now change the place — assignment must be cleared
+    act(() => { result.current.setSelectedPlaceId(20); });
+    expect(result.current.selectedPlaceId).toBe(20);
+    expect(result.current.selectedAssignmentId).toBeNull();
+  });
+
+  it('FE-HOOK-SEL-004: selectAssignment sets both selectedAssignmentId and selectedPlaceId', () => {
+    const { result } = renderHook(() => usePlaceSelection());
+    act(() => { result.current.selectAssignment(7, 3); });
+    expect(result.current.selectedAssignmentId).toBe(7);
+    expect(result.current.selectedPlaceId).toBe(3);
+  });
+
+  it('FE-HOOK-SEL-005: setSelectedPlaceId(null) resets selectedPlaceId to null and clears assignment', () => {
+    const { result } = renderHook(() => usePlaceSelection());
+    act(() => { result.current.selectAssignment(5, 1); });
+    act(() => { result.current.setSelectedPlaceId(null); });
+    expect(result.current.selectedPlaceId).toBeNull();
+    expect(result.current.selectedAssignmentId).toBeNull();
+  });
+
+  it('FE-HOOK-SEL-006: selectAssignment(null, null) clears both IDs', () => {
+    const { result } = renderHook(() => usePlaceSelection());
+    act(() => { result.current.selectAssignment(5, 1); });
+    act(() => { result.current.selectAssignment(null, null); });
+    expect(result.current.selectedAssignmentId).toBeNull();
+    expect(result.current.selectedPlaceId).toBeNull();
+  });
+
+  it('FE-HOOK-SEL-007: selecting a different place after an assignment clears the assignment', () => {
+    const { result } = renderHook(() => usePlaceSelection());
+    act(() => { result.current.selectAssignment(11, 5); });
+    // Switch to a different place without going through selectAssignment
+    act(() => { result.current.setSelectedPlaceId(99); });
+    expect(result.current.selectedPlaceId).toBe(99);
+    expect(result.current.selectedAssignmentId).toBeNull();
+  });
+});
diff --git a/client/tests/unit/hooks/usePlannerHistory.test.ts b/client/tests/unit/hooks/usePlannerHistory.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9fb0d31d163cc8e64c6518283718628978e36fc1
--- /dev/null
+++ b/client/tests/unit/hooks/usePlannerHistory.test.ts
@@ -0,0 +1,92 @@
+import { describe, it, expect, vi } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { usePlannerHistory } from '../../../src/hooks/usePlannerHistory';
+
+// FE-HOOK-HIST-001 onwards
+
+describe('usePlannerHistory', () => {
+  it('FE-HOOK-HIST-001: starts with canUndo=false and lastActionLabel=null', () => {
+    const { result } = renderHook(() => usePlannerHistory());
+    expect(result.current.canUndo).toBe(false);
+    expect(result.current.lastActionLabel).toBeNull();
+  });
+
+  it('FE-HOOK-HIST-002: pushing an entry sets canUndo=true and lastActionLabel', () => {
+    const { result } = renderHook(() => usePlannerHistory());
+    act(() => {
+      result.current.pushUndo('Delete place', vi.fn());
+    });
+    expect(result.current.canUndo).toBe(true);
+    expect(result.current.lastActionLabel).toBe('Delete place');
+  });
+
+  it('FE-HOOK-HIST-003: calling undo fires the undo function and sets canUndo=false', async () => {
+    const { result } = renderHook(() => usePlannerHistory());
+    const undoFn = vi.fn();
+    act(() => {
+      result.current.pushUndo('Add place', undoFn);
+    });
+    await act(async () => {
+      await result.current.undo();
+    });
+    expect(undoFn).toHaveBeenCalledOnce();
+    expect(result.current.canUndo).toBe(false);
+  });
+
+  it('FE-HOOK-HIST-004: multiple entries stack in LIFO order', () => {
+    const { result } = renderHook(() => usePlannerHistory());
+    act(() => {
+      result.current.pushUndo('First', vi.fn());
+      result.current.pushUndo('Second', vi.fn());
+      result.current.pushUndo('Third', vi.fn());
+    });
+    expect(result.current.lastActionLabel).toBe('Third');
+  });
+
+  it('FE-HOOK-HIST-005: undo consumes entries in LIFO order', async () => {
+    const { result } = renderHook(() => usePlannerHistory());
+    const fn1 = vi.fn();
+    const fn2 = vi.fn();
+    act(() => {
+      result.current.pushUndo('First', fn1);
+      result.current.pushUndo('Second', fn2);
+    });
+    await act(async () => { await result.current.undo(); });
+    expect(fn2).toHaveBeenCalledOnce();
+    expect(fn1).not.toHaveBeenCalled();
+    expect(result.current.lastActionLabel).toBe('First');
+
+    await act(async () => { await result.current.undo(); });
+    expect(fn1).toHaveBeenCalledOnce();
+    expect(result.current.canUndo).toBe(false);
+  });
+
+  it('FE-HOOK-HIST-006: caps history at 30 entries', () => {
+    const { result } = renderHook(() => usePlannerHistory());
+    act(() => {
+      for (let i = 0; i < 31; i++) {
+        result.current.pushUndo(`Action ${i}`, vi.fn());
+      }
+    });
+    // After 31 pushes with cap=30, the oldest entry (Action 0) should be dropped.
+    // canUndo must be true and the stack should not exceed 30.
+    expect(result.current.canUndo).toBe(true);
+    expect(result.current.lastActionLabel).toBe('Action 30');
+  });
+
+  it('FE-HOOK-HIST-007: undo on an empty stack does not throw', async () => {
+    const { result } = renderHook(() => usePlannerHistory());
+    await expect(
+      act(async () => { await result.current.undo(); })
+    ).resolves.not.toThrow();
+    expect(result.current.canUndo).toBe(false);
+  });
+
+  it('FE-HOOK-HIST-008: undo still sets canUndo=false after consuming the last entry', async () => {
+    const { result } = renderHook(() => usePlannerHistory());
+    act(() => { result.current.pushUndo('Only', vi.fn()); });
+    await act(async () => { await result.current.undo(); });
+    expect(result.current.canUndo).toBe(false);
+    expect(result.current.lastActionLabel).toBeNull();
+  });
+});
diff --git a/client/tests/unit/i18n/index.test.ts b/client/tests/unit/i18n/index.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c5d966e7b4ae1b78867098313b9a40dfc670a091
--- /dev/null
+++ b/client/tests/unit/i18n/index.test.ts
@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { render } from '@testing-library/react'
+import React from 'react'
+import {
+  TranslationProvider,
+  useTranslation,
+  getLocaleForLanguage,
+  getIntlLanguage,
+  isRtlLanguage,
+  SUPPORTED_LANGUAGES,
+  detectBrowserLanguage,
+} from '../../../src/i18n'
+import { resetAllStores, seedStore } from '../../helpers/store'
+import { useSettingsStore } from '../../../src/store/settingsStore'
+import { buildSettings } from '../../helpers/factories'
+
+beforeEach(() => {
+  resetAllStores()
+  vi.clearAllMocks()
+})
+
+// ── FE-COMP-I18N-001: Barrel re-exports ───────────────────────────────────────
+
+describe('barrel re-exports', () => {
+  it('FE-COMP-I18N-001: all named exports are defined with expected types', () => {
+    expect(TranslationProvider).toBeDefined()
+    expect(typeof TranslationProvider).toBe('function')
+    expect(useTranslation).toBeDefined()
+    expect(typeof useTranslation).toBe('function')
+    expect(getLocaleForLanguage).toBeDefined()
+    expect(typeof getLocaleForLanguage).toBe('function')
+    expect(getIntlLanguage).toBeDefined()
+    expect(typeof getIntlLanguage).toBe('function')
+    expect(isRtlLanguage).toBeDefined()
+    expect(typeof isRtlLanguage).toBe('function')
+    expect(SUPPORTED_LANGUAGES).toBeDefined()
+    expect(Array.isArray(SUPPORTED_LANGUAGES)).toBe(true)
+  })
+})
+
+// ── FE-COMP-I18N-002/003: getLocaleForLanguage ────────────────────────────────
+
+describe('getLocaleForLanguage', () => {
+  it('FE-COMP-I18N-002: returns correct locale for known languages', () => {
+    expect(getLocaleForLanguage('en')).toBe('en-US')
+    expect(getLocaleForLanguage('de')).toBe('de-DE')
+    expect(getLocaleForLanguage('zh-TW')).toBe('zh-TW')
+    expect(getLocaleForLanguage('ar')).toBe('ar-SA')
+    expect(getLocaleForLanguage('br')).toBe('pt-BR')
+  })
+
+  it('FE-COMP-I18N-003: falls back to en-US for unknown language codes', () => {
+    expect(getLocaleForLanguage('xx')).toBe('en-US')
+  })
+})
+
+// ── FE-COMP-I18N-004/005/006: getIntlLanguage ─────────────────────────────────
+
+describe('getIntlLanguage', () => {
+  it('FE-COMP-I18N-004: returns language code for known supported languages', () => {
+    expect(getIntlLanguage('de')).toBe('de')
+    expect(getIntlLanguage('fr')).toBe('fr')
+    expect(getIntlLanguage('zh-TW')).toBe('zh-TW')
+  })
+
+  it('FE-COMP-I18N-005: maps br to pt-BR', () => {
+    expect(getIntlLanguage('br')).toBe('pt-BR')
+  })
+
+  it('FE-COMP-I18N-006: falls back to en for unknown codes', () => {
+    expect(getIntlLanguage('xx')).toBe('en')
+  })
+})
+
+// ── FE-COMP-I18N-007/008: isRtlLanguage ──────────────────────────────────────
+
+describe('isRtlLanguage', () => {
+  it('FE-COMP-I18N-007: returns true only for Arabic', () => {
+    expect(isRtlLanguage('ar')).toBe(true)
+  })
+
+  it('FE-COMP-I18N-008: returns false for all other supported languages', () => {
+    expect(isRtlLanguage('en')).toBe(false)
+    expect(isRtlLanguage('de')).toBe(false)
+    expect(isRtlLanguage('zh-TW')).toBe(false)
+  })
+})
+
+// ── FE-COMP-I18N-009: SUPPORTED_LANGUAGES ────────────────────────────────────
+
+describe('SUPPORTED_LANGUAGES', () => {
+  it('FE-COMP-I18N-009: contains expected entries with value/label shape', () => {
+    expect(Array.isArray(SUPPORTED_LANGUAGES)).toBe(true)
+    expect(SUPPORTED_LANGUAGES).toHaveLength(20)
+    expect(SUPPORTED_LANGUAGES).toContainEqual(expect.objectContaining({ value: 'en', label: 'English' }))
+    expect(SUPPORTED_LANGUAGES).toContainEqual(expect.objectContaining({ value: 'tr', label: 'Türkçe' }))
+    expect(SUPPORTED_LANGUAGES).toContainEqual(expect.objectContaining({ value: 'ja', label: '日本語' }))
+    expect(SUPPORTED_LANGUAGES).toContainEqual(expect.objectContaining({ value: 'ko', label: '한국어' }))
+    expect(SUPPORTED_LANGUAGES).toContainEqual(expect.objectContaining({ value: 'uk', label: 'Українська' }))
+    expect(SUPPORTED_LANGUAGES).toContainEqual(expect.objectContaining({ value: 'ar', label: 'العربية' }))
+  })
+})
+
+// ── FE-COMP-I18N-016 to 023: detectBrowserLanguage ───────────────────────────
+
+describe('detectBrowserLanguage', () => {
+  afterEach(() => {
+    Object.defineProperty(navigator, 'languages', { value: [], configurable: true })
+    Object.defineProperty(navigator, 'language', { value: '', configurable: true })
+  })
+
+  it('FE-COMP-I18N-016: exact match returns the matched code', () => {
+    Object.defineProperty(navigator, 'languages', { value: ['de'], configurable: true })
+    expect(detectBrowserLanguage()).toBe('de')
+  })
+
+  it('FE-COMP-I18N-017: region-tagged exact match (zh-TW) returns zh-TW', () => {
+    Object.defineProperty(navigator, 'languages', { value: ['zh-TW'], configurable: true })
+    expect(detectBrowserLanguage()).toBe('zh-TW')
+  })
+
+  it('FE-COMP-I18N-018: prefix match (de-AT → de)', () => {
+    Object.defineProperty(navigator, 'languages', { value: ['de-AT'], configurable: true })
+    expect(detectBrowserLanguage()).toBe('de')
+  })
+
+  it('FE-COMP-I18N-019: pt-PT returns null (European Portuguese is a distinct language)', () => {
+    Object.defineProperty(navigator, 'languages', { value: ['pt-PT'], configurable: true })
+    expect(detectBrowserLanguage()).toBeNull()
+  })
+
+  it('FE-COMP-I18N-020: pt-BR maps to br', () => {
+    Object.defineProperty(navigator, 'languages', { value: ['pt-BR'], configurable: true })
+    expect(detectBrowserLanguage()).toBe('br')
+  })
+
+  it('FE-COMP-I18N-021: first-match-wins across multiple entries', () => {
+    Object.defineProperty(navigator, 'languages', { value: ['xx-XX', 'fr'], configurable: true })
+    expect(detectBrowserLanguage()).toBe('fr')
+  })
+
+  it('FE-COMP-I18N-022: unknown language returns null', () => {
+    Object.defineProperty(navigator, 'languages', { value: ['xx'], configurable: true })
+    expect(detectBrowserLanguage()).toBeNull()
+  })
+
+  it('FE-COMP-I18N-023: falls back to navigator.language when navigator.languages is empty', () => {
+    Object.defineProperty(navigator, 'languages', { value: [], configurable: true })
+    Object.defineProperty(navigator, 'language', { value: 'es', configurable: true })
+    expect(detectBrowserLanguage()).toBe('es')
+  })
+})
+
+// ── FE-COMP-I18N-010 to 015: TranslationProvider + useTranslation ─────────────
+
+describe('TranslationProvider + useTranslation integration', () => {
+  it('FE-COMP-I18N-010: useTranslation returns t, language, and locale', () => {
+    seedStore(useSettingsStore, { settings: buildSettings({ language: 'en' }) })
+
+    let result: { language: string; locale: string; tResult: string } | null = null
+
+    function TestComponent() {
+      const { t, language, locale } = useTranslation()
+      result = { language, locale, tResult: t('common.loading') }
+      return null
+    }
+
+    render(
+      React.createElement(TranslationProvider, null, React.createElement(TestComponent))
+    )
+
+    expect(result).not.toBeNull()
+    expect(result!.language).toBe('en')
+    expect(result!.locale).toBe('en-US')
+    expect(result!.tResult).toBeTruthy()
+    expect(typeof result!.tResult).toBe('string')
+  })
+
+  it('FE-COMP-I18N-011: t() with params substitutes {count} placeholders', () => {
+    seedStore(useSettingsStore, { settings: buildSettings({ language: 'en' }) })
+
+    let translated = ''
+
+    function TestComponent() {
+      const { t } = useTranslation()
+      translated = t('dashboard.subtitle.trips', { count: 5, archived: 2 })
+      return null
+    }
+
+    render(
+      React.createElement(TranslationProvider, null, React.createElement(TestComponent))
+    )
+
+    expect(translated).toContain('5')
+    expect(translated).toContain('2')
+    expect(translated).not.toContain('{count}')
+    expect(translated).not.toContain('{archived}')
+  })
+
+  it('FE-COMP-I18N-012: TranslationProvider sets document.documentElement.lang', () => {
+    seedStore(useSettingsStore, { settings: buildSettings({ language: 'de' }) })
+
+    function TestComponent() {
+      useTranslation()
+      return null
+    }
+
+    render(
+      React.createElement(TranslationProvider, null, React.createElement(TestComponent))
+    )
+
+    expect(document.documentElement.lang).toBe('de')
+  })
+
+  it('FE-COMP-I18N-013: TranslationProvider sets dir=rtl for Arabic', () => {
+    seedStore(useSettingsStore, { settings: buildSettings({ language: 'ar' }) })
+
+    function TestComponent() {
+      useTranslation()
+      return null
+    }
+
+    render(
+      React.createElement(TranslationProvider, null, React.createElement(TestComponent))
+    )
+
+    expect(document.documentElement.dir).toBe('rtl')
+  })
+
+  it('FE-COMP-I18N-014: TranslationProvider sets dir=ltr for non-RTL language', () => {
+    seedStore(useSettingsStore, { settings: buildSettings({ language: 'en' }) })
+
+    function TestComponent() {
+      useTranslation()
+      return null
+    }
+
+    render(
+      React.createElement(TranslationProvider, null, React.createElement(TestComponent))
+    )
+
+    expect(document.documentElement.dir).toBe('ltr')
+  })
+
+  it('FE-COMP-I18N-015: t() falls back to English for unknown language', () => {
+    // Seed with a non-existent language to trigger fallback to English translations
+    seedStore(useSettingsStore, { settings: buildSettings({ language: 'xx' as any }) })
+
+    let translated = ''
+
+    function TestComponent() {
+      const { t } = useTranslation()
+      translated = t('common.loading')
+      return null
+    }
+
+    render(
+      React.createElement(TranslationProvider, null, React.createElement(TestComponent))
+    )
+
+    // Should fall back to English translation (non-empty, not the key itself if key exists in en)
+    expect(typeof translated).toBe('string')
+    expect(translated.length).toBeGreaterThan(0)
+  })
+})
diff --git a/client/tests/unit/i18n/parity.test.ts b/client/tests/unit/i18n/parity.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ec60b2eea1e4f1575e37d5983ebc6255b69483c7
--- /dev/null
+++ b/client/tests/unit/i18n/parity.test.ts
@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest'
+import type { TranslationStrings } from '@trek/shared/i18n'
+import en from '@trek/shared/i18n/en'
+import de from '@trek/shared/i18n/de'
+import es from '@trek/shared/i18n/es'
+import fr from '@trek/shared/i18n/fr'
+import hu from '@trek/shared/i18n/hu'
+import itIT from '@trek/shared/i18n/it'
+import tr from '@trek/shared/i18n/tr'
+import ru from '@trek/shared/i18n/ru'
+import zh from '@trek/shared/i18n/zh'
+import zhTW from '@trek/shared/i18n/zh-TW'
+import nl from '@trek/shared/i18n/nl'
+import idID from '@trek/shared/i18n/id'
+import ar from '@trek/shared/i18n/ar'
+import br from '@trek/shared/i18n/br'
+import cs from '@trek/shared/i18n/cs'
+import pl from '@trek/shared/i18n/pl'
+import ja from '@trek/shared/i18n/ja'
+import ko from '@trek/shared/i18n/ko'
+import uk from '@trek/shared/i18n/uk'
+import gr from '@trek/shared/i18n/gr'
+
+// Runtime guard for the aggregated i18n bundles. `t()` resolves keys against the
+// active locale's flat dot-key map (see TranslationContext), so a key that is
+// present in en but missing in another locale silently falls back to English at
+// runtime — easy to ship, hard to notice. This test fails loudly when any locale
+// drifts away from the en key set so translators get an explicit, diagnostic list.
+//
+// The shared package also runs a file-level parity check (shared/scripts), but
+// that one only inspects per-domain source files; this one asserts the *merged*
+// export each locale actually serves to the app.
+
+const NON_EN_LOCALES: Record<string, TranslationStrings> = {
+  de, es, fr, hu, it: itIT, tr, ru, zh, 'zh-TW': zhTW, nl, id: idID,
+  ar, br, cs, pl, ja, ko, uk, gr,
+}
+
+const enKeys = new Set(Object.keys(en))
+
+describe('i18n locale key parity', () => {
+  it('covers every non-en locale', () => {
+    // Keep the assertion set in lockstep with the supported language list minus en.
+    expect(Object.keys(NON_EN_LOCALES)).toHaveLength(19)
+  })
+
+  for (const [locale, strings] of Object.entries(NON_EN_LOCALES)) {
+    it(`${locale} has the exact same key set as en`, () => {
+      const localeKeys = new Set(Object.keys(strings))
+      const missing = [...enKeys].filter((k) => !localeKeys.has(k))
+      const extra = [...localeKeys].filter((k) => !enKeys.has(k))
+
+      const diagnostic =
+        `Locale "${locale}" key drift vs en — ` +
+        `missing ${missing.length}` +
+        (missing.length ? ` (${missing.slice(0, 10).join(', ')}${missing.length > 10 ? ', …' : ''})` : '') +
+        `; extra ${extra.length}` +
+        (extra.length ? ` (${extra.slice(0, 10).join(', ')}${extra.length > 10 ? ', …' : ''})` : '')
+
+      expect(missing, diagnostic).toEqual([])
+      expect(extra, diagnostic).toEqual([])
+    })
+  }
+})
diff --git a/client/tests/unit/remoteEventHandler/assignments.test.ts b/client/tests/unit/remoteEventHandler/assignments.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3da39f9779230f497c5a6bd250c287a3479873ac
--- /dev/null
+++ b/client/tests/unit/remoteEventHandler/assignments.test.ts
@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildDay, buildAssignment, buildPlace } from '../../helpers/factories';
+import type { Assignment } from '../../../src/types';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('remoteEventHandler > assignments', () => {
+  const seedData = () => {
+    useTripStore.setState({
+      days: [buildDay({ id: 10 }), buildDay({ id: 20 })],
+      assignments: {
+        '10': [buildAssignment({ id: 100, day_id: 10 })],
+        '20': [],
+      },
+    });
+  };
+
+  it('FE-WSEVT-ASSIGN-001: assignment:created adds assignment to correct day', () => {
+    seedData();
+    const newAssignment = buildAssignment({ id: 200, day_id: 20 });
+    useTripStore.getState().handleRemoteEvent({ type: 'assignment:created', assignment: newAssignment });
+    const { assignments } = useTripStore.getState();
+    expect(assignments['20']).toHaveLength(1);
+    expect(assignments['20'][0].id).toBe(200);
+    expect(assignments['10']).toHaveLength(1);
+  });
+
+  it('FE-WSEVT-ASSIGN-002: assignment:created is idempotent — no duplicate if same ID', () => {
+    seedData();
+    const duplicate = buildAssignment({ id: 100, day_id: 10 });
+    useTripStore.getState().handleRemoteEvent({ type: 'assignment:created', assignment: duplicate });
+    const { assignments } = useTripStore.getState();
+    expect(assignments['10']).toHaveLength(1);
+  });
+
+  it('FE-WSEVT-ASSIGN-003: assignment:created replaces temp (negative) ID assignment with same place_id', () => {
+    const place = buildPlace({ id: 55 });
+    const tempAssignment = buildAssignment({ id: -1, day_id: 10, place, place_id: place.id });
+    useTripStore.setState({
+      days: [buildDay({ id: 10 })],
+      assignments: { '10': [tempAssignment] },
+    });
+    const realAssignment = buildAssignment({ id: 500, day_id: 10, place, place_id: place.id });
+    useTripStore.getState().handleRemoteEvent({ type: 'assignment:created', assignment: realAssignment });
+    const { assignments } = useTripStore.getState();
+    expect(assignments['10']).toHaveLength(1);
+    expect(assignments['10'][0].id).toBe(500);
+  });
+
+  it('FE-WSEVT-ASSIGN-003b: a second assignment of an already-present place is NOT suppressed (H11)', () => {
+    const place = buildPlace({ id: 55 });
+    useTripStore.setState({
+      days: [buildDay({ id: 10 })],
+      // A committed (positive-id) assignment of place 55 already on the day.
+      assignments: { '10': [buildAssignment({ id: 100, day_id: 10, place, place_id: place.id })] },
+    });
+    // A legitimately new, distinct assignment of the same place arrives.
+    const second = buildAssignment({ id: 300, day_id: 10, place, place_id: place.id });
+    useTripStore.getState().handleRemoteEvent({ type: 'assignment:created', assignment: second });
+    const { assignments } = useTripStore.getState();
+    expect(assignments['10']).toHaveLength(2);
+    expect(assignments['10'].map(a => a.id).sort((x, y) => x - y)).toEqual([100, 300]);
+  });
+
+  it('FE-WSEVT-ASSIGN-003c: temp reconciliation replaces only the matching place, not a sibling temp (H11)', () => {
+    const place55 = buildPlace({ id: 55 });
+    const place66 = buildPlace({ id: 66 });
+    useTripStore.setState({
+      days: [buildDay({ id: 10 })],
+      assignments: {
+        '10': [
+          buildAssignment({ id: -1, day_id: 10, place: place55, place_id: 55 }),
+          buildAssignment({ id: -2, day_id: 10, place: place66, place_id: 66 }),
+        ],
+      },
+    });
+    const real = buildAssignment({ id: 500, day_id: 10, place: place55, place_id: 55 });
+    useTripStore.getState().handleRemoteEvent({ type: 'assignment:created', assignment: real });
+    const { assignments } = useTripStore.getState();
+    const ids = assignments['10'].map(a => a.id);
+    expect(assignments['10']).toHaveLength(2);
+    expect(ids).toContain(500);   // temp 55 reconciled to real
+    expect(ids).toContain(-2);    // sibling temp 66 untouched
+    expect(ids).not.toContain(-1);
+  });
+
+  it('FE-WSEVT-ASSIGN-003d: place-less assignments do not collapse onto each other (H11)', () => {
+    // Defensive: a malformed event lacking place data must not let the
+    // `place?.id === placeId` reconciliation match undefined === undefined.
+    const placeless = (id: number): Assignment =>
+      ({ ...buildAssignment({ id, day_id: 10 }), place: undefined, place_id: undefined } as unknown as Assignment);
+    useTripStore.setState({
+      days: [buildDay({ id: 10 })],
+      assignments: { '10': [placeless(-1)] },
+    });
+    useTripStore.getState().handleRemoteEvent({ type: 'assignment:created', assignment: placeless(700) });
+    const { assignments } = useTripStore.getState();
+    // No placeId → no reconcile; both survive as distinct rows (no collapse).
+    expect(assignments['10']).toHaveLength(2);
+  });
+
+  it('FE-WSEVT-ASSIGN-004: assignment:updated merges updated data into correct day', () => {
+    seedData();
+    const updated = buildAssignment({ id: 100, day_id: 10, notes: 'Updated notes' });
+    useTripStore.getState().handleRemoteEvent({ type: 'assignment:updated', assignment: updated });
+    const { assignments } = useTripStore.getState();
+    expect(assignments['10'][0].notes).toBe('Updated notes');
+  });
+
+  it('FE-WSEVT-ASSIGN-005: assignment:deleted removes assignment from day', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'assignment:deleted', assignmentId: 100, dayId: 10 });
+    const { assignments } = useTripStore.getState();
+    expect(assignments['10']).toHaveLength(0);
+  });
+
+  it('FE-WSEVT-ASSIGN-006: assignment:moved removes from old day and adds to new day', () => {
+    const movedAssignment = buildAssignment({ id: 100, day_id: 20 });
+    useTripStore.setState({
+      days: [buildDay({ id: 10 }), buildDay({ id: 20 })],
+      assignments: {
+        '10': [movedAssignment],
+        '20': [],
+      },
+    });
+    useTripStore.getState().handleRemoteEvent({
+      type: 'assignment:moved',
+      assignment: movedAssignment,
+      oldDayId: 10,
+      newDayId: 20,
+    });
+    const { assignments } = useTripStore.getState();
+    expect(assignments['10']).toHaveLength(0);
+    expect(assignments['20']).toHaveLength(1);
+    expect(assignments['20'][0].id).toBe(100);
+  });
+
+  it('FE-WSEVT-ASSIGN-007: assignment:reordered updates order_index values', () => {
+    const a1 = buildAssignment({ id: 1, day_id: 10, order_index: 0 });
+    const a2 = buildAssignment({ id: 2, day_id: 10, order_index: 1 });
+    const a3 = buildAssignment({ id: 3, day_id: 10, order_index: 2 });
+    useTripStore.setState({
+      assignments: { '10': [a1, a2, a3] },
+    });
+    useTripStore.getState().handleRemoteEvent({
+      type: 'assignment:reordered',
+      dayId: 10,
+      orderedIds: [3, 1, 2],
+    });
+    const { assignments } = useTripStore.getState();
+    const reordered = assignments['10'];
+    const item3 = reordered.find(a => a.id === 3);
+    const item1 = reordered.find(a => a.id === 1);
+    const item2 = reordered.find(a => a.id === 2);
+    expect(item3?.order_index).toBe(0);
+    expect(item1?.order_index).toBe(1);
+    expect(item2?.order_index).toBe(2);
+  });
+});
diff --git a/client/tests/unit/remoteEventHandler/budget.test.ts b/client/tests/unit/remoteEventHandler/budget.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..53e2b3f240711e4d5b86e96112cc027ae48a9a11
--- /dev/null
+++ b/client/tests/unit/remoteEventHandler/budget.test.ts
@@ -0,0 +1,93 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildBudgetItem } from '../../helpers/factories';
+import type { BudgetItemMember } from '../../../src/types';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('remoteEventHandler > budget', () => {
+  const member1: BudgetItemMember = { user_id: 5, paid: 0, username: 'eve' };
+  const member2: BudgetItemMember = { user_id: 6, paid: 1, username: 'frank' };
+
+  const seedData = () => {
+    useTripStore.setState({
+      budgetItems: [
+        buildBudgetItem({ id: 1, persons: 1, members: [{ ...member1 }] }),
+        buildBudgetItem({ id: 2, persons: 2, members: [{ ...member2 }] }),
+      ],
+    });
+  };
+
+  it('FE-WSEVT-BUDGET-001: budget:created adds item to budgetItems', () => {
+    seedData();
+    const newItem = buildBudgetItem({ id: 99, name: 'Hotel' });
+    useTripStore.getState().handleRemoteEvent({ type: 'budget:created', item: newItem });
+    const { budgetItems } = useTripStore.getState();
+    expect(budgetItems).toHaveLength(3);
+    expect(budgetItems.find(i => i.id === 99)).toBeDefined();
+  });
+
+  it('FE-WSEVT-BUDGET-002: budget:created is idempotent — no duplicate if same ID', () => {
+    seedData();
+    const duplicate = buildBudgetItem({ id: 1, name: 'Duplicate' });
+    useTripStore.getState().handleRemoteEvent({ type: 'budget:created', item: duplicate });
+    const { budgetItems } = useTripStore.getState();
+    expect(budgetItems).toHaveLength(2);
+  });
+
+  it('FE-WSEVT-BUDGET-003: budget:updated replaces item in array', () => {
+    seedData();
+    const updated = buildBudgetItem({ id: 1, name: 'Updated Hotel', total_price: 500 });
+    useTripStore.getState().handleRemoteEvent({ type: 'budget:updated', item: updated });
+    const { budgetItems } = useTripStore.getState();
+    const item = budgetItems.find(i => i.id === 1);
+    expect(item?.name).toBe('Updated Hotel');
+    expect(item?.total_price).toBe(500);
+  });
+
+  it('FE-WSEVT-BUDGET-004: budget:deleted removes item by ID', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'budget:deleted', itemId: 1 });
+    const { budgetItems } = useTripStore.getState();
+    expect(budgetItems).toHaveLength(1);
+    expect(budgetItems.find(i => i.id === 1)).toBeUndefined();
+  });
+
+  it('FE-WSEVT-BUDGET-005: budget:members-updated replaces entire members array and persons count', () => {
+    seedData();
+    const newMembers: BudgetItemMember[] = [{ user_id: 7, paid: 1, username: 'grace' }, { user_id: 8, paid: 0, username: 'heidi' }];
+    useTripStore.getState().handleRemoteEvent({
+      type: 'budget:members-updated',
+      itemId: 1,
+      members: newMembers,
+      persons: 3,
+    });
+    const { budgetItems } = useTripStore.getState();
+    const item = budgetItems.find(i => i.id === 1);
+    expect(item?.members).toEqual(newMembers);
+    expect(item?.persons).toBe(3);
+    // Other item should be unchanged
+    const item2 = budgetItems.find(i => i.id === 2);
+    expect(item2?.members).toEqual([{ ...member2 }]);
+  });
+
+  it('FE-WSEVT-BUDGET-006: budget:member-paid-updated toggles specific member paid status', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({
+      type: 'budget:member-paid-updated',
+      itemId: 1,
+      userId: 5,
+      paid: true,
+    });
+    const { budgetItems } = useTripStore.getState();
+    const item = budgetItems.find(i => i.id === 1);
+    const m = item?.members?.find(m => m.user_id === 5);
+    expect(m?.paid).toBe(true);
+    // Other item members unchanged (member2 keeps its seeded paid value)
+    const item2 = budgetItems.find(i => i.id === 2);
+    expect(item2?.members?.[0].paid).toBe(1);
+  });
+});
diff --git a/client/tests/unit/remoteEventHandler/dayNotes.test.ts b/client/tests/unit/remoteEventHandler/dayNotes.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1529680d7cc60bfcf6188fe0aa3474a5c5a38ffe
--- /dev/null
+++ b/client/tests/unit/remoteEventHandler/dayNotes.test.ts
@@ -0,0 +1,60 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildDayNote } from '../../helpers/factories';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('remoteEventHandler > dayNotes', () => {
+  const seedData = () => {
+    useTripStore.setState({
+      dayNotes: {
+        '10': [buildDayNote({ id: 1, day_id: 10, text: 'Original' })],
+        '20': [],
+      },
+    });
+  };
+
+  it('FE-WSEVT-DAYNOTE-001: dayNote:created adds note to correct day', () => {
+    seedData();
+    const newNote = buildDayNote({ id: 99, day_id: 10, text: 'New note' });
+    useTripStore.getState().handleRemoteEvent({ type: 'dayNote:created', dayId: 10, note: newNote });
+    const { dayNotes } = useTripStore.getState();
+    expect(dayNotes['10']).toHaveLength(2);
+    expect(dayNotes['10'].find(n => n.id === 99)).toBeDefined();
+  });
+
+  it('FE-WSEVT-DAYNOTE-002: dayNote:created is idempotent — no duplicate if same ID', () => {
+    seedData();
+    const duplicate = buildDayNote({ id: 1, day_id: 10, text: 'Duplicate' });
+    useTripStore.getState().handleRemoteEvent({ type: 'dayNote:created', dayId: 10, note: duplicate });
+    const { dayNotes } = useTripStore.getState();
+    expect(dayNotes['10']).toHaveLength(1);
+    expect(dayNotes['10'][0].text).toBe('Original');
+  });
+
+  it('FE-WSEVT-DAYNOTE-003: dayNote:updated replaces note in correct day', () => {
+    seedData();
+    const updated = buildDayNote({ id: 1, day_id: 10, text: 'Updated text' });
+    useTripStore.getState().handleRemoteEvent({ type: 'dayNote:updated', dayId: 10, note: updated });
+    const { dayNotes } = useTripStore.getState();
+    expect(dayNotes['10'][0].text).toBe('Updated text');
+  });
+
+  it('FE-WSEVT-DAYNOTE-004: dayNote:deleted removes note from correct day', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'dayNote:deleted', dayId: 10, noteId: 1 });
+    const { dayNotes } = useTripStore.getState();
+    expect(dayNotes['10']).toHaveLength(0);
+  });
+
+  it('FE-WSEVT-DAYNOTE-005: operations on day 10 do not affect day 20', () => {
+    seedData();
+    const newNote = buildDayNote({ id: 50, day_id: 10, text: 'Day 10 note' });
+    useTripStore.getState().handleRemoteEvent({ type: 'dayNote:created', dayId: 10, note: newNote });
+    const { dayNotes } = useTripStore.getState();
+    expect(dayNotes['20']).toHaveLength(0);
+  });
+});
diff --git a/client/tests/unit/remoteEventHandler/days.test.ts b/client/tests/unit/remoteEventHandler/days.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..df2282b20a43b86f5629f6e4b2d21f5891774165
--- /dev/null
+++ b/client/tests/unit/remoteEventHandler/days.test.ts
@@ -0,0 +1,80 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildDay, buildAssignment, buildDayNote } from '../../helpers/factories';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('remoteEventHandler > days', () => {
+  const seedData = () => {
+    useTripStore.setState({
+      days: [buildDay({ id: 10 }), buildDay({ id: 20 })],
+      assignments: {
+        '10': [buildAssignment({ id: 100, day_id: 10 })],
+        '20': [],
+      },
+      dayNotes: {
+        '10': [buildDayNote({ id: 1, day_id: 10 })],
+        '20': [],
+      },
+    });
+  };
+
+  it('FE-WSEVT-DAY-001: day:created adds day to days array', () => {
+    seedData();
+    const newDay = buildDay({ id: 30 });
+    useTripStore.getState().handleRemoteEvent({ type: 'day:created', day: newDay });
+    const { days } = useTripStore.getState();
+    expect(days).toHaveLength(3);
+    expect(days.find(d => d.id === 30)).toBeDefined();
+  });
+
+  it('FE-WSEVT-DAY-002: day:created is idempotent — no duplicate if same ID', () => {
+    seedData();
+    const duplicate = buildDay({ id: 10 });
+    useTripStore.getState().handleRemoteEvent({ type: 'day:created', day: duplicate });
+    const { days } = useTripStore.getState();
+    expect(days).toHaveLength(2);
+  });
+
+  it('FE-WSEVT-DAY-003: day:updated replaces day in days array', () => {
+    seedData();
+    const updated = buildDay({ id: 10, title: 'New Title' });
+    useTripStore.getState().handleRemoteEvent({ type: 'day:updated', day: updated });
+    const { days } = useTripStore.getState();
+    const day10 = days.find(d => d.id === 10);
+    expect(day10?.title).toBe('New Title');
+  });
+
+  it('FE-WSEVT-DAY-004: day:deleted removes day from days array', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'day:deleted', dayId: 10 });
+    const { days } = useTripStore.getState();
+    expect(days).toHaveLength(1);
+    expect(days.find(d => d.id === 10)).toBeUndefined();
+  });
+
+  it('FE-WSEVT-DAY-005: day:deleted removes the assignments key for deleted day', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'day:deleted', dayId: 10 });
+    const { assignments } = useTripStore.getState();
+    expect('10' in assignments).toBe(false);
+  });
+
+  it('FE-WSEVT-DAY-006: day:deleted removes the dayNotes key for deleted day', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'day:deleted', dayId: 10 });
+    const { dayNotes } = useTripStore.getState();
+    expect('10' in dayNotes).toBe(false);
+  });
+
+  it('FE-WSEVT-DAY-007: day:deleted does not remove other days assignments/dayNotes', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'day:deleted', dayId: 10 });
+    const { assignments, dayNotes } = useTripStore.getState();
+    expect('20' in assignments).toBe(true);
+    expect('20' in dayNotes).toBe(true);
+  });
+});
diff --git a/client/tests/unit/remoteEventHandler/files.test.ts b/client/tests/unit/remoteEventHandler/files.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..5623b1a3cde633fd682271f46e90ad21c71bf933
--- /dev/null
+++ b/client/tests/unit/remoteEventHandler/files.test.ts
@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildTripFile } from '../../helpers/factories';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('remoteEventHandler > files', () => {
+  const seedData = () => {
+    useTripStore.setState({
+      files: [buildTripFile({ id: 1, original_name: 'document.pdf' })],
+    });
+  };
+
+  it('FE-WSEVT-FILE-001: file:created prepends new file to array', () => {
+    seedData();
+    const newFile = buildTripFile({ id: 99, original_name: 'photo.jpg' });
+    useTripStore.getState().handleRemoteEvent({ type: 'file:created', file: newFile });
+    const { files } = useTripStore.getState();
+    expect(files).toHaveLength(2);
+    expect(files[0].id).toBe(99); // prepended
+  });
+
+  it('FE-WSEVT-FILE-002: file:created is idempotent — no duplicate if same ID', () => {
+    seedData();
+    const duplicate = buildTripFile({ id: 1, original_name: 'document_dup.pdf' });
+    useTripStore.getState().handleRemoteEvent({ type: 'file:created', file: duplicate });
+    const { files } = useTripStore.getState();
+    expect(files).toHaveLength(1);
+    expect(files[0].original_name).toBe('document.pdf');
+  });
+
+  it('FE-WSEVT-FILE-003: file:updated replaces file in array', () => {
+    seedData();
+    const updated = buildTripFile({ id: 1, original_name: 'renamed.pdf' });
+    useTripStore.getState().handleRemoteEvent({ type: 'file:updated', file: updated });
+    const { files } = useTripStore.getState();
+    expect(files[0].original_name).toBe('renamed.pdf');
+  });
+
+  it('FE-WSEVT-FILE-004: file:deleted removes file by ID', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'file:deleted', fileId: 1 });
+    const { files } = useTripStore.getState();
+    expect(files).toHaveLength(0);
+  });
+
+  it('FE-WSEVT-FILE-005: file:created ordering — newest is first', () => {
+    seedData();
+    const f2 = buildTripFile({ id: 2, original_name: 'second.pdf' });
+    const f3 = buildTripFile({ id: 3, original_name: 'third.pdf' });
+    useTripStore.getState().handleRemoteEvent({ type: 'file:created', file: f2 });
+    useTripStore.getState().handleRemoteEvent({ type: 'file:created', file: f3 });
+    const { files } = useTripStore.getState();
+    expect(files[0].id).toBe(3);
+    expect(files[1].id).toBe(2);
+    expect(files[2].id).toBe(1);
+  });
+});
diff --git a/client/tests/unit/remoteEventHandler/memories.test.ts b/client/tests/unit/remoteEventHandler/memories.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..62b4e0ba577f726a41df1aee8efe10babb9c18b5
--- /dev/null
+++ b/client/tests/unit/remoteEventHandler/memories.test.ts
@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildPlace } from '../../helpers/factories';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('remoteEventHandler > memories', () => {
+  it('FE-WSEVT-MEM-001: memories:updated dispatches CustomEvent on window', () => {
+    const received: Event[] = [];
+    const handler = (e: Event) => received.push(e);
+    window.addEventListener('memories:updated', handler);
+    useTripStore.getState().handleRemoteEvent({ type: 'memories:updated', photos: [] });
+    window.removeEventListener('memories:updated', handler);
+    expect(received).toHaveLength(1);
+  });
+
+  it('FE-WSEVT-MEM-002: memories:updated event type is correct', () => {
+    const received: Event[] = [];
+    const handler = (e: Event) => received.push(e);
+    window.addEventListener('memories:updated', handler);
+    useTripStore.getState().handleRemoteEvent({ type: 'memories:updated', photos: [] });
+    window.removeEventListener('memories:updated', handler);
+    expect(received[0].type).toBe('memories:updated');
+  });
+
+  it('FE-WSEVT-MEM-003: memories:updated event detail contains the payload', () => {
+    const received: CustomEvent[] = [];
+    const handler = (e: Event) => received.push(e as CustomEvent);
+    window.addEventListener('memories:updated', handler);
+    const payload = { photos: [{ id: 1, url: '/photo.jpg' }] };
+    useTripStore.getState().handleRemoteEvent({ type: 'memories:updated', ...payload });
+    window.removeEventListener('memories:updated', handler);
+    expect(received[0].detail).toMatchObject(payload);
+  });
+
+  it('FE-WSEVT-MEM-004: memories:updated does not modify store state', () => {
+    const places = [buildPlace({ id: 42, name: 'Eiffel Tower' })];
+    useTripStore.setState({ places });
+    useTripStore.getState().handleRemoteEvent({ type: 'memories:updated', photos: [] });
+    const { places: afterPlaces } = useTripStore.getState();
+    expect(afterPlaces).toHaveLength(1);
+    expect(afterPlaces[0].id).toBe(42);
+  });
+
+  it('FE-WSEVT-MEM-005: memories:updated fires exactly once per event', () => {
+    const received: Event[] = [];
+    const handler = (e: Event) => received.push(e);
+    window.addEventListener('memories:updated', handler);
+    useTripStore.getState().handleRemoteEvent({ type: 'memories:updated', photos: [] });
+    useTripStore.getState().handleRemoteEvent({ type: 'memories:updated', photos: [] });
+    window.removeEventListener('memories:updated', handler);
+    expect(received).toHaveLength(2);
+  });
+});
diff --git a/client/tests/unit/remoteEventHandler/packing.test.ts b/client/tests/unit/remoteEventHandler/packing.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0c578233a951b4b049b393620cc9d249fc3251dd
--- /dev/null
+++ b/client/tests/unit/remoteEventHandler/packing.test.ts
@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildPackingItem } from '../../helpers/factories';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('remoteEventHandler > packing', () => {
+  const seedData = () => {
+    useTripStore.setState({
+      packingItems: [buildPackingItem({ id: 1, name: 'Sunscreen' })],
+    });
+  };
+
+  it('FE-WSEVT-PACK-001: packing:created adds item to packingItems', () => {
+    seedData();
+    const newItem = buildPackingItem({ id: 99, name: 'Hat' });
+    useTripStore.getState().handleRemoteEvent({ type: 'packing:created', item: newItem });
+    const { packingItems } = useTripStore.getState();
+    expect(packingItems).toHaveLength(2);
+    expect(packingItems.find(i => i.id === 99)).toBeDefined();
+  });
+
+  it('FE-WSEVT-PACK-002: packing:created is idempotent — no duplicate if same ID', () => {
+    seedData();
+    const duplicate = buildPackingItem({ id: 1, name: 'Sunscreen Duplicate' });
+    useTripStore.getState().handleRemoteEvent({ type: 'packing:created', item: duplicate });
+    const { packingItems } = useTripStore.getState();
+    expect(packingItems).toHaveLength(1);
+    expect(packingItems[0].name).toBe('Sunscreen');
+  });
+
+  it('FE-WSEVT-PACK-003: packing:updated replaces item in array', () => {
+    seedData();
+    const updated = buildPackingItem({ id: 1, name: 'SPF 50 Sunscreen' });
+    useTripStore.getState().handleRemoteEvent({ type: 'packing:updated', item: updated });
+    const { packingItems } = useTripStore.getState();
+    expect(packingItems[0].name).toBe('SPF 50 Sunscreen');
+  });
+
+  it('FE-WSEVT-PACK-004: packing:deleted removes item by ID', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'packing:deleted', itemId: 1 });
+    const { packingItems } = useTripStore.getState();
+    expect(packingItems).toHaveLength(0);
+  });
+});
diff --git a/client/tests/unit/remoteEventHandler/places.test.ts b/client/tests/unit/remoteEventHandler/places.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8584f0d28573c54ded59d4869588efb2e44be329
--- /dev/null
+++ b/client/tests/unit/remoteEventHandler/places.test.ts
@@ -0,0 +1,67 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildPlace, buildAssignment } from '../../helpers/factories';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('remoteEventHandler > places', () => {
+  const seedData = () => {
+    const place = buildPlace({ id: 1, name: 'Original' });
+    const assignment = buildAssignment({ id: 100, place, day_id: 10 });
+    useTripStore.setState({
+      places: [place],
+      assignments: { '10': [assignment] },
+    });
+  };
+
+  it('FE-WSEVT-PLACE-001: place:created prepends new place to places array', () => {
+    seedData();
+    const newPlace = buildPlace({ id: 99, name: 'New Place' });
+    useTripStore.getState().handleRemoteEvent({ type: 'place:created', place: newPlace });
+    const { places } = useTripStore.getState();
+    expect(places[0].id).toBe(99);
+    expect(places).toHaveLength(2);
+  });
+
+  it('FE-WSEVT-PLACE-002: place:created is idempotent — no duplicate if same ID', () => {
+    seedData();
+    const duplicate = buildPlace({ id: 1, name: 'Duplicate' });
+    useTripStore.getState().handleRemoteEvent({ type: 'place:created', place: duplicate });
+    const { places } = useTripStore.getState();
+    expect(places).toHaveLength(1);
+    expect(places[0].name).toBe('Original');
+  });
+
+  it('FE-WSEVT-PLACE-003: place:updated updates place in places array', () => {
+    seedData();
+    const updated = buildPlace({ id: 1, name: 'Updated Name' });
+    useTripStore.getState().handleRemoteEvent({ type: 'place:updated', place: updated });
+    const { places } = useTripStore.getState();
+    expect(places[0].name).toBe('Updated Name');
+  });
+
+  it('FE-WSEVT-PLACE-004: place:updated cascades into assignments nested place', () => {
+    seedData();
+    const updated = buildPlace({ id: 1, name: 'Cascaded Update' });
+    useTripStore.getState().handleRemoteEvent({ type: 'place:updated', place: updated });
+    const { assignments } = useTripStore.getState();
+    expect(assignments['10'][0].place?.name).toBe('Cascaded Update');
+  });
+
+  it('FE-WSEVT-PLACE-005: place:deleted removes place from places array', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'place:deleted', placeId: 1 });
+    const { places } = useTripStore.getState();
+    expect(places).toHaveLength(0);
+  });
+
+  it('FE-WSEVT-PLACE-006: place:deleted cascades — assignments referencing that place are removed', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'place:deleted', placeId: 1 });
+    const { assignments } = useTripStore.getState();
+    expect(assignments['10']).toHaveLength(0);
+  });
+});
diff --git a/client/tests/unit/remoteEventHandler/reservations.test.ts b/client/tests/unit/remoteEventHandler/reservations.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..df9cc80b313727cccd0010f00bfa0216d3676771
--- /dev/null
+++ b/client/tests/unit/remoteEventHandler/reservations.test.ts
@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildReservation } from '../../helpers/factories';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('remoteEventHandler > reservations', () => {
+  const seedData = () => {
+    useTripStore.setState({
+      reservations: [buildReservation({ id: 1, title: 'Hotel Paris' })],
+    });
+  };
+
+  it('FE-WSEVT-RESERV-001: reservation:created prepends new reservation to array', () => {
+    seedData();
+    const newRes = buildReservation({ id: 99, title: 'Flight' });
+    useTripStore.getState().handleRemoteEvent({ type: 'reservation:created', reservation: newRes });
+    const { reservations } = useTripStore.getState();
+    expect(reservations).toHaveLength(2);
+    expect(reservations[0].id).toBe(99); // prepended, so first
+  });
+
+  it('FE-WSEVT-RESERV-002: reservation:created is idempotent — no duplicate if same ID', () => {
+    seedData();
+    const duplicate = buildReservation({ id: 1, title: 'Hotel Paris Dup' });
+    useTripStore.getState().handleRemoteEvent({ type: 'reservation:created', reservation: duplicate });
+    const { reservations } = useTripStore.getState();
+    expect(reservations).toHaveLength(1);
+    expect(reservations[0].title).toBe('Hotel Paris');
+  });
+
+  it('FE-WSEVT-RESERV-003: reservation:updated replaces reservation in array', () => {
+    seedData();
+    const updated = buildReservation({ id: 1, title: 'Hotel Lyon' });
+    useTripStore.getState().handleRemoteEvent({ type: 'reservation:updated', reservation: updated });
+    const { reservations } = useTripStore.getState();
+    expect(reservations[0].title).toBe('Hotel Lyon');
+  });
+
+  it('FE-WSEVT-RESERV-004: reservation:deleted removes reservation by ID', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'reservation:deleted', reservationId: 1 });
+    const { reservations } = useTripStore.getState();
+    expect(reservations).toHaveLength(0);
+  });
+
+  it('FE-WSEVT-RESERV-005: reservation:created ordering — newest is first', () => {
+    seedData();
+    const r2 = buildReservation({ id: 2, title: 'Second' });
+    const r3 = buildReservation({ id: 3, title: 'Third' });
+    useTripStore.getState().handleRemoteEvent({ type: 'reservation:created', reservation: r2 });
+    useTripStore.getState().handleRemoteEvent({ type: 'reservation:created', reservation: r3 });
+    const { reservations } = useTripStore.getState();
+    expect(reservations[0].id).toBe(3);
+    expect(reservations[1].id).toBe(2);
+    expect(reservations[2].id).toBe(1);
+  });
+});
diff --git a/client/tests/unit/remoteEventHandler/todo.test.ts b/client/tests/unit/remoteEventHandler/todo.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..1c5c2a688025385cffe5cb19150971b920d24b32
--- /dev/null
+++ b/client/tests/unit/remoteEventHandler/todo.test.ts
@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildTodoItem } from '../../helpers/factories';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('remoteEventHandler > todo', () => {
+  const seedData = () => {
+    useTripStore.setState({
+      todoItems: [buildTodoItem({ id: 1, name: 'Book flights' })],
+    });
+  };
+
+  it('FE-WSEVT-TODO-001: todo:created adds item to todoItems', () => {
+    seedData();
+    const newItem = buildTodoItem({ id: 99, name: 'Pack bags' });
+    useTripStore.getState().handleRemoteEvent({ type: 'todo:created', item: newItem });
+    const { todoItems } = useTripStore.getState();
+    expect(todoItems).toHaveLength(2);
+    expect(todoItems.find(i => i.id === 99)).toBeDefined();
+  });
+
+  it('FE-WSEVT-TODO-002: todo:created is idempotent — no duplicate if same ID', () => {
+    seedData();
+    const duplicate = buildTodoItem({ id: 1, name: 'Book flights duplicate' });
+    useTripStore.getState().handleRemoteEvent({ type: 'todo:created', item: duplicate });
+    const { todoItems } = useTripStore.getState();
+    expect(todoItems).toHaveLength(1);
+    expect(todoItems[0].name).toBe('Book flights');
+  });
+
+  it('FE-WSEVT-TODO-003: todo:updated replaces item in array', () => {
+    seedData();
+    const updated = buildTodoItem({ id: 1, name: 'Book round-trip flights' });
+    useTripStore.getState().handleRemoteEvent({ type: 'todo:updated', item: updated });
+    const { todoItems } = useTripStore.getState();
+    expect(todoItems[0].name).toBe('Book round-trip flights');
+  });
+
+  it('FE-WSEVT-TODO-004: todo:deleted removes item by ID', () => {
+    seedData();
+    useTripStore.getState().handleRemoteEvent({ type: 'todo:deleted', itemId: 1 });
+    const { todoItems } = useTripStore.getState();
+    expect(todoItems).toHaveLength(0);
+  });
+});
diff --git a/client/tests/unit/remoteEventHandler/trip.test.ts b/client/tests/unit/remoteEventHandler/trip.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..992c260b521959cd7b2fb7cbca25d9cd2ea26698
--- /dev/null
+++ b/client/tests/unit/remoteEventHandler/trip.test.ts
@@ -0,0 +1,32 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildTrip, buildPlace } from '../../helpers/factories';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('remoteEventHandler > trip', () => {
+  it('FE-WSEVT-TRIP-001: trip:updated replaces trip in state', () => {
+    const originalTrip = buildTrip({ id: 1, title: 'Paris Trip' });
+    useTripStore.setState({ trip: originalTrip });
+    const updatedTrip = buildTrip({ id: 1, title: 'Paris & Lyon Trip' });
+    useTripStore.getState().handleRemoteEvent({ type: 'trip:updated', trip: updatedTrip });
+    const { trip } = useTripStore.getState();
+    expect(trip?.title).toBe('Paris & Lyon Trip');
+  });
+
+  it('FE-WSEVT-TRIP-002: trip:updated does not affect other state fields', () => {
+    const existingPlace = buildPlace({ id: 55, name: 'Eiffel Tower' });
+    useTripStore.setState({
+      trip: buildTrip({ id: 1, title: 'Original' }),
+      places: [existingPlace],
+    });
+    const updatedTrip = buildTrip({ id: 1, title: 'Updated' });
+    useTripStore.getState().handleRemoteEvent({ type: 'trip:updated', trip: updatedTrip });
+    const { places } = useTripStore.getState();
+    expect(places).toHaveLength(1);
+    expect(places[0].id).toBe(55);
+  });
+});
diff --git a/client/tests/unit/repo/packingRepo.test.ts b/client/tests/unit/repo/packingRepo.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4c25ada2486ac1b57b20f4d60469b1f64bdac95b
--- /dev/null
+++ b/client/tests/unit/repo/packingRepo.test.ts
@@ -0,0 +1,119 @@
+/**
+ * packingRepo unit tests.
+ *
+ * Online path:  calls REST via MSW, writes result to Dexie.
+ * Offline path: returns Dexie cache, skips REST.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import 'fake-indexeddb/auto';
+import { server } from '../../helpers/msw/server';
+import { http, HttpResponse } from 'msw';
+import { packingRepo } from '../../../src/repo/packingRepo';
+import { offlineDb, clearAll } from '../../../src/db/offlineDb';
+import { buildPackingItem } from '../../helpers/factories';
+
+beforeEach(async () => {
+  await clearAll();
+  Object.defineProperty(navigator, 'onLine', { value: true, writable: true, configurable: true });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('packingRepo.list', () => {
+  it('online — fetches from REST and caches in Dexie', async () => {
+    const item = buildPackingItem({ trip_id: 1 });
+    server.use(
+      http.get('/api/trips/1/packing', () => HttpResponse.json({ items: [item] })),
+    );
+
+    const result = await packingRepo.list(1);
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0].id).toBe(item.id);
+
+    await new Promise(r => setTimeout(r, 0));
+    const cached = await offlineDb.packingItems.where('trip_id').equals(1).toArray();
+    expect(cached).toHaveLength(1);
+    expect(cached[0].id).toBe(item.id);
+  });
+
+  it('offline — returns Dexie cache without REST call', async () => {
+    Object.defineProperty(navigator, 'onLine', { value: false });
+
+    const item = buildPackingItem({ trip_id: 1 });
+    await offlineDb.packingItems.put(item);
+
+    let restCalled = false;
+    server.use(
+      http.get('/api/trips/1/packing', () => {
+        restCalled = true;
+        return HttpResponse.json({ items: [] });
+      }),
+    );
+
+    const result = await packingRepo.list(1);
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0].id).toBe(item.id);
+    expect(restCalled).toBe(false);
+  });
+
+  it('offline — returns empty array when nothing cached', async () => {
+    Object.defineProperty(navigator, 'onLine', { value: false });
+    const result = await packingRepo.list(99);
+    expect(result.items).toHaveLength(0);
+  });
+});
+
+describe('packingRepo.create', () => {
+  it('calls REST and caches created item in Dexie', async () => {
+    const item = buildPackingItem({ trip_id: 1, name: 'Sunscreen' });
+    server.use(
+      http.post('/api/trips/1/packing', () => HttpResponse.json({ item })),
+    );
+
+    const result = await packingRepo.create(1, { name: 'Sunscreen' });
+    expect(result.item.name).toBe('Sunscreen');
+
+    await new Promise(r => setTimeout(r, 0));
+    const cached = await offlineDb.packingItems.get(item.id);
+    expect(cached).toBeDefined();
+    expect(cached!.name).toBe('Sunscreen');
+  });
+});
+
+describe('packingRepo.update', () => {
+  it('calls REST and updates Dexie cache', async () => {
+    const original = buildPackingItem({ trip_id: 1, name: 'Jacket', checked: 0 });
+    await offlineDb.packingItems.put(original);
+
+    const updated = { ...original, checked: 1 };
+    server.use(
+      http.put(`/api/trips/1/packing/${original.id}`, () => HttpResponse.json({ item: updated })),
+    );
+
+    const result = await packingRepo.update(1, original.id, { checked: true });
+    expect(result.item.checked).toBe(1);
+
+    await new Promise(r => setTimeout(r, 0));
+    const cached = await offlineDb.packingItems.get(original.id);
+    expect(cached!.checked).toBe(1);
+  });
+});
+
+describe('packingRepo.delete', () => {
+  it('calls REST and removes from Dexie', async () => {
+    const item = buildPackingItem({ trip_id: 1 });
+    await offlineDb.packingItems.put(item);
+
+    server.use(
+      http.delete(`/api/trips/1/packing/${item.id}`, () => HttpResponse.json({ success: true })),
+    );
+
+    await packingRepo.delete(1, item.id);
+
+    await new Promise(r => setTimeout(r, 0));
+    const cached = await offlineDb.packingItems.get(item.id);
+    expect(cached).toBeUndefined();
+  });
+});
diff --git a/client/tests/unit/repo/placeRepo.test.ts b/client/tests/unit/repo/placeRepo.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4724ca56f839c66dea69785cf06128e65b8e6bc0
--- /dev/null
+++ b/client/tests/unit/repo/placeRepo.test.ts
@@ -0,0 +1,134 @@
+/**
+ * placeRepo unit tests.
+ *
+ * Online path:  calls REST via MSW, writes result to Dexie.
+ * Offline path: returns Dexie cache, skips REST.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import 'fake-indexeddb/auto';
+import { server } from '../../helpers/msw/server';
+import { http, HttpResponse } from 'msw';
+import { placeRepo } from '../../../src/repo/placeRepo';
+import { offlineDb, clearAll } from '../../../src/db/offlineDb';
+import { buildPlace } from '../../helpers/factories';
+
+beforeEach(async () => {
+  await clearAll();
+  Object.defineProperty(navigator, 'onLine', { value: true, writable: true, configurable: true });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('placeRepo.list', () => {
+  it('online — fetches from REST and caches in Dexie', async () => {
+    const place = buildPlace({ trip_id: 1 });
+    server.use(
+      http.get('/api/trips/1/places', () => HttpResponse.json({ places: [place] })),
+    );
+
+    const result = await placeRepo.list(1);
+    expect(result.places).toHaveLength(1);
+    expect(result.places[0].id).toBe(place.id);
+
+    // Give fire-and-forget a tick to flush
+    await new Promise(r => setTimeout(r, 0));
+    const cached = await offlineDb.places.where('trip_id').equals(1).toArray();
+    expect(cached).toHaveLength(1);
+    expect(cached[0].id).toBe(place.id);
+  });
+
+  it('offline — returns Dexie cache without REST call', async () => {
+    Object.defineProperty(navigator, 'onLine', { value: false });
+
+    const place = buildPlace({ trip_id: 1 });
+    await offlineDb.places.put(place);
+
+    let restCalled = false;
+    server.use(
+      http.get('/api/trips/1/places', () => {
+        restCalled = true;
+        return HttpResponse.json({ places: [] });
+      }),
+    );
+
+    const result = await placeRepo.list(1);
+    expect(result.places).toHaveLength(1);
+    expect(result.places[0].id).toBe(place.id);
+    expect(restCalled).toBe(false);
+  });
+
+  it('offline — returns empty array when nothing cached', async () => {
+    Object.defineProperty(navigator, 'onLine', { value: false });
+    const result = await placeRepo.list(99);
+    expect(result.places).toHaveLength(0);
+  });
+
+  it('online but request fails — falls back to Dexie cache (captive portal)', async () => {
+    // navigator.onLine lies "true" on a captive portal; the request throws.
+    const place = buildPlace({ trip_id: 1 });
+    await offlineDb.places.put(place);
+
+    server.use(
+      http.get('/api/trips/1/places', () => HttpResponse.error()),
+    );
+
+    const result = await placeRepo.list(1);
+    expect(result.places).toHaveLength(1);
+    expect(result.places[0].id).toBe(place.id);
+  });
+});
+
+describe('placeRepo.create', () => {
+  it('calls REST and caches created place in Dexie', async () => {
+    const place = buildPlace({ trip_id: 1, name: 'Eiffel Tower' });
+    server.use(
+      http.post('/api/trips/1/places', () => HttpResponse.json({ place })),
+    );
+
+    const result = await placeRepo.create(1, { name: 'Eiffel Tower' });
+    expect(result.place.name).toBe('Eiffel Tower');
+
+    await new Promise(r => setTimeout(r, 0));
+    const cached = await offlineDb.places.get(place.id);
+    expect(cached).toBeDefined();
+    expect(cached!.name).toBe('Eiffel Tower');
+  });
+});
+
+describe('placeRepo.update', () => {
+  it('calls REST and updates Dexie cache', async () => {
+    const original = buildPlace({ trip_id: 1, name: 'Old Name' });
+    await offlineDb.places.put(original);
+
+    const updated = { ...original, name: 'New Name' };
+    server.use(
+      http.put(`/api/trips/1/places/${original.id}`, () => HttpResponse.json({ place: updated })),
+    );
+
+    const result = await placeRepo.update(1, original.id, { name: 'New Name' });
+    expect(result.place.name).toBe('New Name');
+
+    await new Promise(r => setTimeout(r, 0));
+    const cached = await offlineDb.places.get(original.id);
+    expect(cached!.name).toBe('New Name');
+  });
+});
+
+describe('placeRepo.delete', () => {
+  it('calls REST and removes from Dexie', async () => {
+    const place = buildPlace({ trip_id: 1 });
+    await offlineDb.places.put(place);
+
+    server.use(
+      http.delete(`/api/trips/1/places/${place.id}`, () => HttpResponse.json({ success: true })),
+    );
+
+    await placeRepo.delete(1, place.id);
+
+    await new Promise(r => setTimeout(r, 0));
+    const cached = await offlineDb.places.get(place.id);
+    expect(cached).toBeUndefined();
+  });
+});
diff --git a/client/tests/unit/repo/withOfflineFallback.test.ts b/client/tests/unit/repo/withOfflineFallback.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6a679df2c2673e1a5570b80e809aed2ea83c0109
--- /dev/null
+++ b/client/tests/unit/repo/withOfflineFallback.test.ts
@@ -0,0 +1,76 @@
+/**
+ * onlineThenCache — the read-through fallback shared by every repo (H2).
+ *
+ * Branches:
+ *   - navigator offline → cache only (skip the request)
+ *   - online but the request fails at the network level → fall back to cache
+ *   - online but the server returns an HTTP error → rethrow (don't mask)
+ *   - online and the request succeeds → return it, skip cache
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { onlineThenCache } from '../../../src/repo/withOfflineFallback';
+
+beforeEach(() => {
+  Object.defineProperty(navigator, 'onLine', { value: true, writable: true, configurable: true });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('onlineThenCache', () => {
+  it('returns the online result when online', async () => {
+    const online = vi.fn().mockResolvedValue('online');
+    const cache = vi.fn().mockResolvedValue('cache');
+
+    expect(await onlineThenCache(online, cache)).toBe('online');
+    expect(online).toHaveBeenCalledOnce();
+    expect(cache).not.toHaveBeenCalled();
+  });
+
+  it('reads the cache without calling online when navigator is offline', async () => {
+    Object.defineProperty(navigator, 'onLine', { value: false });
+    const online = vi.fn().mockResolvedValue('online');
+    const cache = vi.fn().mockResolvedValue('cache');
+
+    expect(await onlineThenCache(online, cache)).toBe('cache');
+    expect(online).not.toHaveBeenCalled();
+  });
+
+  it('falls back to the cache on a network-level failure (no HTTP response)', async () => {
+    // Axios network error: the request never reached the server (captive portal).
+    const netErr = Object.assign(new Error('Network Error'), { isAxiosError: true, response: undefined });
+    const online = vi.fn().mockRejectedValue(netErr);
+    const cache = vi.fn().mockResolvedValue('cache');
+
+    expect(await onlineThenCache(online, cache)).toBe('cache');
+    expect(online).toHaveBeenCalledOnce();
+    expect(cache).toHaveBeenCalledOnce();
+  });
+
+  it('rethrows a genuine HTTP error (server responded) instead of masking it', async () => {
+    // 404/403/500 mean the server replied — callers must see it, not a stale cache.
+    const httpErr = Object.assign(new Error('Not Found'), { isAxiosError: true, response: { status: 404 } });
+    const online = vi.fn().mockRejectedValue(httpErr);
+    const cache = vi.fn().mockResolvedValue('cache');
+
+    await expect(onlineThenCache(online, cache)).rejects.toThrow('Not Found');
+    expect(cache).not.toHaveBeenCalled();
+  });
+
+  it('rethrows a non-Axios error rather than swallowing it', async () => {
+    const online = vi.fn().mockRejectedValue(new Error('bug'));
+    const cache = vi.fn().mockResolvedValue('cache');
+
+    await expect(onlineThenCache(online, cache)).rejects.toThrow('bug');
+    expect(cache).not.toHaveBeenCalled();
+  });
+
+  it('propagates a cache error (e.g. nothing cached) when online also failed', async () => {
+    Object.defineProperty(navigator, 'onLine', { value: false });
+    const online = vi.fn().mockResolvedValue('online');
+    const cache = vi.fn().mockRejectedValue(new Error('No cached data'));
+
+    await expect(onlineThenCache(online, cache)).rejects.toThrow('No cached data');
+  });
+});
diff --git a/client/tests/unit/services/photoService.test.ts b/client/tests/unit/services/photoService.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..953078cf776dc9b2231bc1b8c06a78e58fc05e6e
--- /dev/null
+++ b/client/tests/unit/services/photoService.test.ts
@@ -0,0 +1,343 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+// Module-level types for dynamic imports
+type PhotoServiceModule = typeof import('../../../src/services/photoService');
+type ApiClientModule = typeof import('../../../src/api/client');
+
+let svc: PhotoServiceModule;
+let mockPlacePhoto: ReturnType<typeof vi.fn>;
+
+// ── Canvas mock helpers ────────────────────────────────────────────────────────
+
+function setupCanvasMock(dataUrl = 'data:image/webp;base64,mock') {
+  vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue({
+    beginPath: vi.fn(),
+    arc: vi.fn(),
+    clip: vi.fn(),
+    drawImage: vi.fn(),
+  } as unknown as CanvasRenderingContext2D);
+  vi.spyOn(HTMLCanvasElement.prototype, 'toDataURL').mockReturnValue(dataUrl);
+}
+
+// ── Image src interceptor ──────────────────────────────────────────────────────
+// jsdom doesn't load images; we override the src setter so onload/onerror fire.
+
+function setupImageAutoLoad(succeed = true) {
+  Object.defineProperty(HTMLImageElement.prototype, 'src', {
+    configurable: true,
+    set(url: string) {
+      (this as HTMLImageElement & { _src: string })._src = url;
+      // Fire asynchronously so assignment completes before handler runs
+      Promise.resolve().then(() => {
+        if (succeed && typeof this.onload === 'function') {
+          this.onload(new Event('load'));
+        } else if (!succeed && typeof this.onerror === 'function') {
+          this.onerror(new Event('error'));
+        }
+      });
+    },
+    get() {
+      return (this as HTMLImageElement & { _src: string })._src ?? '';
+    },
+  });
+}
+
+function restoreImageSrc() {
+  // Remove override — jsdom's descriptor is on the prototype, restoring
+  // configurable property to original (no-op src) is sufficient for test isolation.
+  Object.defineProperty(HTMLImageElement.prototype, 'src', {
+    configurable: true,
+    set(_url: string) {},
+    get() { return ''; },
+  });
+}
+
+// ── Module reset helpers ───────────────────────────────────────────────────────
+
+async function freshImports() {
+  vi.resetModules();
+  vi.doMock('../../../src/api/client', () => ({
+    mapsApi: { placePhoto: vi.fn() },
+  }));
+  svc = await import('../../../src/services/photoService');
+  const apiClient = await import('../../../src/api/client') as ApiClientModule;
+  mockPlacePhoto = vi.mocked(apiClient.mapsApi.placePhoto);
+}
+
+// ── Flush all pending microtasks + macrotasks ──────────────────────────────────
+const flush = () => new Promise<void>(r => setTimeout(r, 0));
+
+// ==============================================================================
+
+beforeEach(async () => {
+  await freshImports();
+  setupCanvasMock();
+  setupImageAutoLoad(true); // default: image loads succeed so urlToBase64 resolves and .finally() runs
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  restoreImageSrc();
+  vi.clearAllMocks();
+});
+
+// ==============================================================================
+// getCached / isLoading
+// ==============================================================================
+
+describe('getCached', () => {
+  it('FE-COMP-PHOTO-001: returns undefined for an unknown key', () => {
+    expect(svc.getCached('missing')).toBeUndefined();
+  });
+});
+
+describe('isLoading', () => {
+  it('FE-COMP-PHOTO-002: returns false before any fetch', () => {
+    expect(svc.isLoading('key')).toBe(false);
+  });
+});
+
+// ==============================================================================
+// fetchPhoto — cache hit
+// ==============================================================================
+
+describe('fetchPhoto — cache hit', () => {
+  it('FE-COMP-PHOTO-003: callback fires immediately on second call; API called only once', async () => {
+    mockPlacePhoto.mockResolvedValue({ photoUrl: 'https://example.com/photo.jpg' });
+
+    const cb1 = vi.fn();
+    svc.fetchPhoto('k', 'pid', undefined, undefined, undefined, cb1);
+    await flush();
+
+    expect(mockPlacePhoto).toHaveBeenCalledTimes(1);
+    expect(cb1).toHaveBeenCalledWith(expect.objectContaining({ photoUrl: 'https://example.com/photo.jpg' }));
+
+    const cb2 = vi.fn();
+    svc.fetchPhoto('k', 'pid', undefined, undefined, undefined, cb2);
+    // Cache hit → synchronous call, no additional API request
+    expect(cb2).toHaveBeenCalledWith(expect.objectContaining({ photoUrl: 'https://example.com/photo.jpg' }));
+    expect(mockPlacePhoto).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ==============================================================================
+// fetchPhoto — in-flight deduplication
+// ==============================================================================
+
+describe('fetchPhoto — in-flight deduplication', () => {
+  it('FE-COMP-PHOTO-004: concurrent calls make only one API request; both callbacks receive result', async () => {
+    let resolve!: (v: { photoUrl: string }) => void;
+    mockPlacePhoto.mockReturnValue(new Promise<{ photoUrl: string }>(r => { resolve = r; }));
+
+    const cb1 = vi.fn();
+    const cb2 = vi.fn();
+    svc.fetchPhoto('k', 'pid', undefined, undefined, undefined, cb1);
+    svc.fetchPhoto('k', 'pid', undefined, undefined, undefined, cb2);
+
+    // acquireRequestSlot() is async (Promise.resolve), so flush microtasks before asserting
+    await flush();
+    expect(mockPlacePhoto).toHaveBeenCalledTimes(1);
+
+    resolve({ photoUrl: 'https://example.com/photo.jpg' });
+    await flush();
+
+    expect(cb1).toHaveBeenCalledWith(expect.objectContaining({ photoUrl: 'https://example.com/photo.jpg' }));
+    expect(cb2).toHaveBeenCalledWith(expect.objectContaining({ photoUrl: 'https://example.com/photo.jpg' }));
+  });
+});
+
+// ==============================================================================
+// fetchPhoto — photoUrl present
+// ==============================================================================
+
+describe('fetchPhoto — photoUrl present', () => {
+  it('FE-COMP-PHOTO-005: callback receives entry with photoUrl set and thumbDataUrl null at call time', async () => {
+    mockPlacePhoto.mockResolvedValue({ photoUrl: 'https://example.com/photo.jpg' });
+
+    // Capture a shallow clone at the moment of the call, before the entry is mutated by thumb generation
+    const snapshots: { photoUrl: string | null; thumbDataUrl: string | null }[] = [];
+    const cb = vi.fn((entry: { photoUrl: string | null; thumbDataUrl: string | null }) => {
+      snapshots.push({ ...entry });
+    });
+
+    svc.fetchPhoto('k', 'pid', undefined, undefined, undefined, cb);
+    await flush();
+
+    expect(cb).toHaveBeenCalledTimes(1);
+    expect(snapshots[0]).toEqual({ photoUrl: 'https://example.com/photo.jpg', thumbDataUrl: null });
+  });
+
+  it('FE-COMP-PHOTO-006: getCached returns the entry after fetch resolves', async () => {
+    mockPlacePhoto.mockResolvedValue({ photoUrl: 'https://example.com/photo.jpg' });
+
+    svc.fetchPhoto('k', 'pid');
+    await flush();
+
+    const entry = svc.getCached('k');
+    expect(entry).toBeDefined();
+    expect(entry!.photoUrl).toBe('https://example.com/photo.jpg');
+  });
+
+  it('FE-COMP-PHOTO-007: isLoading returns false after fetch completes', async () => {
+    mockPlacePhoto.mockResolvedValue({ photoUrl: 'https://example.com/photo.jpg' });
+
+    svc.fetchPhoto('k', 'pid');
+    await flush();
+
+    expect(svc.isLoading('k')).toBe(false);
+  });
+});
+
+// ==============================================================================
+// fetchPhoto — photoUrl null
+// ==============================================================================
+
+describe('fetchPhoto — photoUrl null', () => {
+  it('FE-COMP-PHOTO-008: callback receives null entry when API returns no photoUrl', async () => {
+    mockPlacePhoto.mockResolvedValue({});
+
+    const cb = vi.fn();
+    svc.fetchPhoto('k', 'pid', undefined, undefined, undefined, cb);
+    await flush();
+
+    expect(cb).toHaveBeenCalledWith({ photoUrl: null, thumbDataUrl: null });
+    expect(svc.getCached('k')).toEqual({ photoUrl: null, thumbDataUrl: null });
+  });
+});
+
+// ==============================================================================
+// fetchPhoto — API error
+// ==============================================================================
+
+describe('fetchPhoto — API error', () => {
+  it('FE-COMP-PHOTO-009: callback receives null entry on API rejection', async () => {
+    mockPlacePhoto.mockRejectedValue(new Error('Network error'));
+
+    const cb = vi.fn();
+    svc.fetchPhoto('k', 'pid', undefined, undefined, undefined, cb);
+    await flush();
+
+    expect(cb).toHaveBeenCalledWith({ photoUrl: null, thumbDataUrl: null });
+    expect(svc.getCached('k')).toEqual({ photoUrl: null, thumbDataUrl: null });
+  });
+});
+
+// ==============================================================================
+// onPhotoLoaded
+// ==============================================================================
+
+describe('onPhotoLoaded', () => {
+  it('FE-COMP-PHOTO-010: listener fires once when photo is fetched', async () => {
+    mockPlacePhoto.mockResolvedValue({ photoUrl: 'https://example.com/photo.jpg' });
+
+    const fn = vi.fn();
+    svc.onPhotoLoaded('k', fn);
+    svc.fetchPhoto('k', 'pid');
+    await flush();
+
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledWith(expect.objectContaining({ photoUrl: 'https://example.com/photo.jpg' }));
+  });
+
+  it('FE-COMP-PHOTO-011: unsubscribe prevents callback from being called', async () => {
+    mockPlacePhoto.mockResolvedValue({ photoUrl: 'https://example.com/photo.jpg' });
+
+    const fn = vi.fn();
+    const unsub = svc.onPhotoLoaded('k', fn);
+    unsub();
+    svc.fetchPhoto('k', 'pid');
+    await flush();
+
+    expect(fn).not.toHaveBeenCalled();
+  });
+});
+
+// ==============================================================================
+// onThumbReady
+// ==============================================================================
+
+describe('onThumbReady', () => {
+  it('FE-COMP-PHOTO-012: fires when urlToBase64 produces a thumb', async () => {
+    mockPlacePhoto.mockResolvedValue({ photoUrl: 'https://example.com/img.jpg' });
+    setupImageAutoLoad(true); // trigger img.onload → canvas path runs
+    vi.spyOn(HTMLCanvasElement.prototype, 'toDataURL').mockReturnValue('data:image/webp;base64,thumb');
+
+    const fn = vi.fn();
+    svc.onThumbReady('k', fn);
+    svc.fetchPhoto('k', 'pid');
+
+    // flush microtasks + macrotasks to let urlToBase64 complete
+    await flush();
+    await flush();
+
+    expect(fn).toHaveBeenCalledWith('data:image/webp;base64,thumb');
+    expect(svc.getCached('k')?.thumbDataUrl).toBe('data:image/webp;base64,thumb');
+  });
+
+  it('FE-COMP-PHOTO-013: unsubscribe prevents thumb callback', async () => {
+    mockPlacePhoto.mockResolvedValue({ photoUrl: 'https://example.com/img.jpg' });
+    setupImageAutoLoad(true);
+
+    const fn = vi.fn();
+    const unsub = svc.onThumbReady('k', fn);
+    unsub();
+    svc.fetchPhoto('k', 'pid');
+
+    await flush();
+    await flush();
+
+    expect(fn).not.toHaveBeenCalled();
+  });
+});
+
+// ==============================================================================
+// urlToBase64
+// ==============================================================================
+
+describe('urlToBase64', () => {
+  it('FE-COMP-PHOTO-014: returns null when image fails to load', async () => {
+    setupImageAutoLoad(false); // triggers onerror
+    const result = await svc.urlToBase64('https://bad-url.jpg');
+    expect(result).toBeNull();
+  });
+
+  it('FE-COMP-PHOTO-015: returns a data URL string on successful load', async () => {
+    setupImageAutoLoad(true);
+    vi.spyOn(HTMLCanvasElement.prototype, 'toDataURL').mockReturnValue('data:image/webp;base64,abc123');
+
+    const result = await svc.urlToBase64('https://example.com/img.jpg', 48);
+    expect(result).toBe('data:image/webp;base64,abc123');
+  });
+
+  it('FE-COMP-PHOTO-016: canvas clip/draw path does not throw', async () => {
+    setupImageAutoLoad(true);
+    await expect(svc.urlToBase64('https://example.com/img.jpg')).resolves.not.toThrow();
+  });
+});
+
+// ==============================================================================
+// getAllThumbs
+// ==============================================================================
+
+describe('getAllThumbs', () => {
+  it('FE-COMP-PHOTO-017: returns only entries with a non-null thumbDataUrl', async () => {
+    // key1: photo with thumb
+    mockPlacePhoto.mockResolvedValueOnce({ photoUrl: 'https://example.com/img1.jpg' });
+    // key2: no photo, no thumb
+    mockPlacePhoto.mockResolvedValueOnce({});
+
+    setupImageAutoLoad(true);
+    vi.spyOn(HTMLCanvasElement.prototype, 'toDataURL').mockReturnValue('data:image/webp;base64,thumb1');
+
+    svc.fetchPhoto('key1', 'pid1');
+    svc.fetchPhoto('key2', 'pid2');
+
+    await flush();
+    await flush();
+
+    const thumbs = svc.getAllThumbs();
+    expect(Object.keys(thumbs)).toContain('key1');
+    expect(thumbs['key1']).toBe('data:image/webp;base64,thumb1');
+    expect(Object.keys(thumbs)).not.toContain('key2');
+  });
+});
diff --git a/client/tests/unit/shared-contract.test.ts b/client/tests/unit/shared-contract.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e82f5dd96667594b8dcf92fe08195de78031e6f5
--- /dev/null
+++ b/client/tests/unit/shared-contract.test.ts
@@ -0,0 +1,10 @@
+import { describe, it, expect } from 'vitest';
+// Smoke test: proves the client toolchain (vite / vitest) resolves @trek/shared.
+import { idParamSchema, paginationQuerySchema } from '@trek/shared';
+
+describe('@trek/shared resolves in the client toolchain', () => {
+  it('imports and uses a shared schema', () => {
+    expect(idParamSchema.parse('7')).toBe(7);
+    expect(paginationQuerySchema.parse({})).toEqual({ page: 1, perPage: 50 });
+  });
+});
diff --git a/client/tests/unit/slices/assignmentsSlice.test.ts b/client/tests/unit/slices/assignmentsSlice.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2978581884bd4daee8226843f645b67bd61bdb59
--- /dev/null
+++ b/client/tests/unit/slices/assignmentsSlice.test.ts
@@ -0,0 +1,222 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores, seedStore } from '../../helpers/store';
+import { buildPlace, buildAssignment } from '../../helpers/factories';
+import { server } from '../../helpers/msw/server';
+
+vi.mock('../../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => null),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+}));
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('assignmentsSlice', () => {
+  describe('assignPlaceToDay', () => {
+    it('FE-ASSIGN-001: assignPlaceToDay adds optimistic temp ID (negative) immediately', async () => {
+      const place = buildPlace({ id: 10, trip_id: 1 });
+      seedStore(useTripStore, {
+        places: [place],
+        assignments: { '1': [] },
+      });
+
+      // Don't await — check state mid-flight
+      let tempAdded = false;
+      server.use(
+        http.post('/api/trips/1/days/1/assignments', async () => {
+          const state = useTripStore.getState();
+          const dayAssignments = state.assignments['1'];
+          if (dayAssignments.some(a => a.id < 0)) {
+            tempAdded = true;
+          }
+          const result = buildAssignment({ day_id: 1, place_id: 10, place });
+          return HttpResponse.json({ assignment: result });
+        }),
+      );
+
+      await useTripStore.getState().assignPlaceToDay(1, 1, 10);
+      expect(tempAdded).toBe(true);
+    });
+
+    it('FE-ASSIGN-002: after API success, temp ID is replaced with real assignment', async () => {
+      const place = buildPlace({ id: 10, trip_id: 1 });
+      seedStore(useTripStore, {
+        places: [place],
+        assignments: { '1': [] },
+      });
+
+      const realAssignment = buildAssignment({ id: 999, day_id: 1, place_id: 10, place });
+      server.use(
+        http.post('/api/trips/1/days/1/assignments', () =>
+          HttpResponse.json({ assignment: realAssignment })
+        ),
+      );
+
+      await useTripStore.getState().assignPlaceToDay(1, 1, 10);
+
+      const dayAssignments = useTripStore.getState().assignments['1'];
+      expect(dayAssignments).toHaveLength(1);
+      expect(dayAssignments[0].id).toBe(999);
+      expect(dayAssignments.every(a => a.id > 0)).toBe(true);
+    });
+
+    it('FE-ASSIGN-003: on API failure, temp assignment is removed (rollback)', async () => {
+      const place = buildPlace({ id: 10, trip_id: 1 });
+      seedStore(useTripStore, {
+        places: [place],
+        assignments: { '1': [] },
+      });
+
+      server.use(
+        http.post('/api/trips/1/days/1/assignments', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().assignPlaceToDay(1, 1, 10)).rejects.toThrow();
+
+      const dayAssignments = useTripStore.getState().assignments['1'];
+      expect(dayAssignments).toHaveLength(0);
+    });
+
+    it('FE-ASSIGN-001b: returns undefined if place not found in store', async () => {
+      seedStore(useTripStore, {
+        places: [], // no places seeded
+        assignments: { '1': [] },
+      });
+
+      const result = await useTripStore.getState().assignPlaceToDay(1, 1, 999);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('removeAssignment', () => {
+    it('FE-ASSIGN-004: removeAssignment is optimistically removed, re-added on failure', async () => {
+      const place = buildPlace({ id: 10, trip_id: 1 });
+      const assignment = buildAssignment({ id: 100, day_id: 1, place });
+      seedStore(useTripStore, {
+        assignments: { '1': [assignment] },
+      });
+
+      server.use(
+        http.delete('/api/trips/1/days/1/assignments/100', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().removeAssignment(1, 1, 100)).rejects.toThrow();
+
+      // Should be rolled back
+      const dayAssignments = useTripStore.getState().assignments['1'];
+      expect(dayAssignments).toHaveLength(1);
+      expect(dayAssignments[0].id).toBe(100);
+    });
+
+    it('FE-ASSIGN-004b: removeAssignment success removes from store', async () => {
+      const place = buildPlace({ id: 10, trip_id: 1 });
+      const assignment = buildAssignment({ id: 100, day_id: 1, place });
+      seedStore(useTripStore, {
+        assignments: { '1': [assignment] },
+      });
+
+      await useTripStore.getState().removeAssignment(1, 1, 100);
+
+      expect(useTripStore.getState().assignments['1']).toHaveLength(0);
+    });
+  });
+
+  describe('reorderAssignments', () => {
+    it('FE-ASSIGN-005: reorderAssignments updates order_index of assignments', async () => {
+      const place1 = buildPlace({ id: 10 });
+      const place2 = buildPlace({ id: 20 });
+      const a1 = buildAssignment({ id: 1, day_id: 5, order_index: 0, place: place1 });
+      const a2 = buildAssignment({ id: 2, day_id: 5, order_index: 1, place: place2 });
+      seedStore(useTripStore, {
+        assignments: { '5': [a1, a2] },
+      });
+
+      await useTripStore.getState().reorderAssignments(1, 5, [2, 1]);
+
+      const dayAssignments = useTripStore.getState().assignments['5'];
+      const reorderedA2 = dayAssignments.find(a => a.id === 2);
+      const reorderedA1 = dayAssignments.find(a => a.id === 1);
+      expect(reorderedA2?.order_index).toBe(0);
+      expect(reorderedA1?.order_index).toBe(1);
+    });
+
+    it('FE-ASSIGN-005b: reorderAssignments rolls back on failure', async () => {
+      const place1 = buildPlace({ id: 10 });
+      const place2 = buildPlace({ id: 20 });
+      const a1 = buildAssignment({ id: 1, day_id: 5, order_index: 0, place: place1 });
+      const a2 = buildAssignment({ id: 2, day_id: 5, order_index: 1, place: place2 });
+      seedStore(useTripStore, {
+        assignments: { '5': [a1, a2] },
+      });
+
+      server.use(
+        http.put('/api/trips/1/days/5/assignments/reorder', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().reorderAssignments(1, 5, [2, 1])).rejects.toThrow();
+
+      const dayAssignments = useTripStore.getState().assignments['5'];
+      expect(dayAssignments.find(a => a.id === 1)?.order_index).toBe(0);
+      expect(dayAssignments.find(a => a.id === 2)?.order_index).toBe(1);
+    });
+  });
+
+  describe('moveAssignment', () => {
+    it('FE-ASSIGN-006: moveAssignment removes from source day and adds to target day', async () => {
+      const place = buildPlace({ id: 10 });
+      const assignment = buildAssignment({ id: 50, day_id: 1, order_index: 0, place });
+      seedStore(useTripStore, {
+        assignments: {
+          '1': [assignment],
+          '2': [],
+        },
+      });
+
+      await useTripStore.getState().moveAssignment(1, 50, 1, 2);
+
+      expect(useTripStore.getState().assignments['1']).toHaveLength(0);
+      expect(useTripStore.getState().assignments['2']).toHaveLength(1);
+      expect(useTripStore.getState().assignments['2'][0].id).toBe(50);
+    });
+
+    it('FE-ASSIGN-007: moveAssignment rolls back on failure', async () => {
+      const place = buildPlace({ id: 10 });
+      const assignment = buildAssignment({ id: 50, day_id: 1, order_index: 0, place });
+      seedStore(useTripStore, {
+        assignments: {
+          '1': [assignment],
+          '2': [],
+        },
+      });
+
+      server.use(
+        http.put('/api/trips/1/assignments/50/move', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().moveAssignment(1, 50, 1, 2)).rejects.toThrow();
+
+      // Rolled back: assignment back in day 1
+      expect(useTripStore.getState().assignments['1']).toHaveLength(1);
+      expect(useTripStore.getState().assignments['1'][0].id).toBe(50);
+      expect(useTripStore.getState().assignments['2']).toHaveLength(0);
+    });
+  });
+});
diff --git a/client/tests/unit/slices/budgetSlice.test.ts b/client/tests/unit/slices/budgetSlice.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3b428d1b4bc0c4f6d2f0b7ee9485833c429fa9f4
--- /dev/null
+++ b/client/tests/unit/slices/budgetSlice.test.ts
@@ -0,0 +1,176 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores, seedStore } from '../../helpers/store';
+import { buildBudgetItem, buildReservation } from '../../helpers/factories';
+import { server } from '../../helpers/msw/server';
+
+vi.mock('../../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => null),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+}));
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('budgetSlice', () => {
+  describe('loadBudgetItems', () => {
+    it('FE-BUDGET-001: loadBudgetItems fetches and replaces budgetItems', async () => {
+      seedStore(useTripStore, { budgetItems: [] });
+
+      const item = buildBudgetItem({ trip_id: 1 });
+      server.use(
+        http.get('/api/trips/1/budget', () => HttpResponse.json({ items: [item] })),
+      );
+
+      await useTripStore.getState().loadBudgetItems(1);
+
+      expect(useTripStore.getState().budgetItems).toHaveLength(1);
+      expect(useTripStore.getState().budgetItems[0].id).toBe(item.id);
+    });
+  });
+
+  describe('addBudgetItem', () => {
+    it('FE-BUDGET-002: addBudgetItem appends to budgetItems', async () => {
+      const existing = buildBudgetItem({ trip_id: 1 });
+      seedStore(useTripStore, { budgetItems: [existing] });
+
+      const result = await useTripStore.getState().addBudgetItem(1, { name: 'Hotel', total_price: 200 });
+
+      expect(result.name).toBe('Hotel');
+      expect(useTripStore.getState().budgetItems).toHaveLength(2);
+    });
+
+    it('FE-BUDGET-003: addBudgetItem on failure throws', async () => {
+      server.use(
+        http.post('/api/trips/1/budget', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(
+        useTripStore.getState().addBudgetItem(1, { name: 'Fail' })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('updateBudgetItem', () => {
+    it('FE-BUDGET-004: updateBudgetItem replaces item in array', async () => {
+      const item = buildBudgetItem({ id: 10, trip_id: 1, name: 'Old', total_price: 100 });
+      seedStore(useTripStore, { budgetItems: [item] });
+
+      server.use(
+        http.put('/api/trips/1/budget/10', async ({ request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          return HttpResponse.json({ item: { ...item, ...body } });
+        }),
+      );
+
+      const result = await useTripStore.getState().updateBudgetItem(1, 10, { name: 'Updated', total_price: 150 });
+
+      expect(result.name).toBe('Updated');
+      expect(useTripStore.getState().budgetItems[0].name).toBe('Updated');
+    });
+
+    it('FE-BUDGET-005: updateBudgetItem with total_price triggers loadReservations when reservation_id present', async () => {
+      const item = buildBudgetItem({ id: 10, trip_id: 1, total_price: 100 });
+      const initialReservation = buildReservation({ trip_id: 1 });
+      const newReservation = buildReservation({ trip_id: 1, title: 'Refreshed Reservation' });
+      seedStore(useTripStore, {
+        budgetItems: [item],
+        reservations: [initialReservation],
+      });
+
+      server.use(
+        http.put('/api/trips/1/budget/10', async ({ request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          // Return item with reservation_id to trigger loadReservations
+          return HttpResponse.json({ item: { ...item, ...body, reservation_id: 42 } });
+        }),
+        http.get('/api/trips/1/reservations', () =>
+          HttpResponse.json({ reservations: [newReservation] })
+        ),
+      );
+
+      await useTripStore.getState().updateBudgetItem(1, 10, { total_price: 200 } as Record<string, unknown>);
+
+      // Wait for the async loadReservations to complete
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(useTripStore.getState().reservations).toHaveLength(1);
+      expect(useTripStore.getState().reservations[0].title).toBe('Refreshed Reservation');
+    });
+  });
+
+  describe('deleteBudgetItem', () => {
+    it('FE-BUDGET-006: deleteBudgetItem optimistically removes item, rolls back on failure', async () => {
+      const item = buildBudgetItem({ id: 10, trip_id: 1 });
+      seedStore(useTripStore, { budgetItems: [item] });
+
+      server.use(
+        http.delete('/api/trips/1/budget/10', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().deleteBudgetItem(1, 10)).rejects.toThrow();
+
+      expect(useTripStore.getState().budgetItems).toHaveLength(1);
+      expect(useTripStore.getState().budgetItems[0].id).toBe(10);
+    });
+
+    it('FE-BUDGET-006b: deleteBudgetItem success removes item', async () => {
+      const item1 = buildBudgetItem({ id: 10, trip_id: 1 });
+      const item2 = buildBudgetItem({ id: 20, trip_id: 1 });
+      seedStore(useTripStore, { budgetItems: [item1, item2] });
+
+      await useTripStore.getState().deleteBudgetItem(1, 10);
+
+      expect(useTripStore.getState().budgetItems).toHaveLength(1);
+      expect(useTripStore.getState().budgetItems[0].id).toBe(20);
+    });
+  });
+
+  describe('setBudgetItemMembers', () => {
+    it('FE-BUDGET-007: setBudgetItemMembers updates members array on item', async () => {
+      const item = buildBudgetItem({ id: 10, trip_id: 1, members: [] });
+      seedStore(useTripStore, { budgetItems: [item] });
+
+      const members = [{ user_id: 1, paid: false }, { user_id: 2, paid: false }];
+      server.use(
+        http.put('/api/trips/1/budget/10/members', () =>
+          HttpResponse.json({ members, item: { ...item, persons: 2, members } })
+        ),
+      );
+
+      const result = await useTripStore.getState().setBudgetItemMembers(1, 10, [1, 2]);
+
+      expect(result.members).toHaveLength(2);
+      const updatedItem = useTripStore.getState().budgetItems.find(i => i.id === 10);
+      expect(updatedItem?.members).toHaveLength(2);
+      expect(updatedItem?.persons).toBe(2);
+    });
+  });
+
+  describe('toggleBudgetMemberPaid', () => {
+    it('FE-BUDGET-008: toggleBudgetMemberPaid updates paid status after API success', async () => {
+      const member = { user_id: 5, paid: 0, username: 'dave' };
+      const item = buildBudgetItem({ id: 10, trip_id: 1, members: [member] });
+      seedStore(useTripStore, { budgetItems: [item] });
+
+      await useTripStore.getState().toggleBudgetMemberPaid(1, 10, 5, true);
+
+      const updatedItem = useTripStore.getState().budgetItems.find(i => i.id === 10);
+      const updatedMember = updatedItem?.members.find(m => m.user_id === 5);
+      expect(updatedMember?.paid).toBe(true);
+    });
+  });
+});
diff --git a/client/tests/unit/slices/dayNotesSlice.test.ts b/client/tests/unit/slices/dayNotesSlice.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3d770ec0f659220aefa278cb4a93444ace18c2ec
--- /dev/null
+++ b/client/tests/unit/slices/dayNotesSlice.test.ts
@@ -0,0 +1,177 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores, seedStore } from '../../helpers/store';
+import { buildDay, buildDayNote } from '../../helpers/factories';
+import { server } from '../../helpers/msw/server';
+
+vi.mock('../../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => null),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+}));
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('dayNotesSlice', () => {
+  describe('addDayNote', () => {
+    it('FE-DAYNOTES-001: addDayNote inserts temp note immediately, replaces on success', async () => {
+      seedStore(useTripStore, { dayNotes: { '1': [] } });
+
+      let tempAdded = false;
+      const realNote = buildDayNote({ id: 500, day_id: 1, text: 'New note' });
+
+      server.use(
+        http.post('/api/trips/1/days/1/notes', async () => {
+          const state = useTripStore.getState();
+          const notes = state.dayNotes['1'];
+          if (notes.some(n => n.id < 0)) {
+            tempAdded = true;
+          }
+          return HttpResponse.json({ note: realNote });
+        }),
+      );
+
+      const result = await useTripStore.getState().addDayNote(1, 1, { text: 'New note', sort_order: 0 });
+
+      expect(tempAdded).toBe(true);
+      expect(result.id).toBe(500);
+      const notes = useTripStore.getState().dayNotes['1'];
+      expect(notes).toHaveLength(1);
+      expect(notes[0].id).toBe(500);
+    });
+
+    it('FE-DAYNOTES-002: addDayNote on failure rolls back — temp note removed', async () => {
+      seedStore(useTripStore, { dayNotes: { '1': [] } });
+
+      server.use(
+        http.post('/api/trips/1/days/1/notes', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(
+        useTripStore.getState().addDayNote(1, 1, { text: 'Fail note', sort_order: 0 })
+      ).rejects.toThrow();
+
+      expect(useTripStore.getState().dayNotes['1']).toHaveLength(0);
+    });
+  });
+
+  describe('updateDayNote', () => {
+    it('FE-DAYNOTES-003: updateDayNote replaces note in map by id', async () => {
+      const note = buildDayNote({ id: 10, day_id: 1, text: 'Old text' });
+      seedStore(useTripStore, { dayNotes: { '1': [note] } });
+
+      const updated = { ...note, text: 'Updated text' };
+      server.use(
+        http.put('/api/trips/1/days/1/notes/10', () =>
+          HttpResponse.json({ note: updated })
+        ),
+      );
+
+      const result = await useTripStore.getState().updateDayNote(1, 1, 10, { text: 'Updated text' });
+
+      expect(result.text).toBe('Updated text');
+      expect(useTripStore.getState().dayNotes['1'][0].text).toBe('Updated text');
+    });
+  });
+
+  describe('deleteDayNote', () => {
+    it('FE-DAYNOTES-004: deleteDayNote optimistically removes note, restores on failure', async () => {
+      const note = buildDayNote({ id: 10, day_id: 1 });
+      seedStore(useTripStore, { dayNotes: { '1': [note] } });
+
+      server.use(
+        http.delete('/api/trips/1/days/1/notes/10', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().deleteDayNote(1, 1, 10)).rejects.toThrow();
+
+      // Rolled back
+      expect(useTripStore.getState().dayNotes['1']).toHaveLength(1);
+      expect(useTripStore.getState().dayNotes['1'][0].id).toBe(10);
+    });
+
+    it('FE-DAYNOTES-004b: deleteDayNote success removes note from correct day', async () => {
+      const note1 = buildDayNote({ id: 10, day_id: 1 });
+      const note2 = buildDayNote({ id: 20, day_id: 1 });
+      seedStore(useTripStore, { dayNotes: { '1': [note1, note2] } });
+
+      await useTripStore.getState().deleteDayNote(1, 1, 10);
+
+      const notes = useTripStore.getState().dayNotes['1'];
+      expect(notes).toHaveLength(1);
+      expect(notes[0].id).toBe(20);
+    });
+  });
+
+  describe('moveDayNote', () => {
+    it('FE-DAYNOTES-005: moveDayNote removes from source, adds to target (delete+create)', async () => {
+      const note = buildDayNote({ id: 10, day_id: 1, text: 'Move me' });
+      const newNote = buildDayNote({ id: 99, day_id: 2, text: 'Move me' });
+      seedStore(useTripStore, { dayNotes: { '1': [note], '2': [] } });
+
+      server.use(
+        http.delete('/api/trips/1/days/1/notes/10', () => HttpResponse.json({ success: true })),
+        http.post('/api/trips/1/days/2/notes', () => HttpResponse.json({ note: newNote })),
+      );
+
+      await useTripStore.getState().moveDayNote(1, 1, 2, 10);
+
+      expect(useTripStore.getState().dayNotes['1']).toHaveLength(0);
+      expect(useTripStore.getState().dayNotes['2']).toHaveLength(1);
+      expect(useTripStore.getState().dayNotes['2'][0].id).toBe(99);
+    });
+
+    it('FE-DAYNOTES-006: moveDayNote rolls back to source day on failure', async () => {
+      const note = buildDayNote({ id: 10, day_id: 1, text: 'Move me' });
+      seedStore(useTripStore, { dayNotes: { '1': [note], '2': [] } });
+
+      server.use(
+        http.delete('/api/trips/1/days/1/notes/10', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().moveDayNote(1, 1, 2, 10)).rejects.toThrow();
+
+      expect(useTripStore.getState().dayNotes['1']).toHaveLength(1);
+      expect(useTripStore.getState().dayNotes['1'][0].id).toBe(10);
+    });
+  });
+
+  describe('updateDayNotes', () => {
+    it('FE-DAYNOTES-007: updateDayNotes persists notes text and updates days array', async () => {
+      const day = buildDay({ id: 1, trip_id: 1, notes: null });
+      seedStore(useTripStore, { days: [day] });
+
+      await useTripStore.getState().updateDayNotes(1, 1, 'My travel notes');
+
+      const updatedDay = useTripStore.getState().days.find(d => d.id === 1);
+      expect(updatedDay?.notes).toBe('My travel notes');
+    });
+  });
+
+  describe('updateDayTitle', () => {
+    it('FE-DAYNOTES-008: updateDayTitle persists title and updates days array', async () => {
+      const day = buildDay({ id: 1, trip_id: 1, title: null });
+      seedStore(useTripStore, { days: [day] });
+
+      await useTripStore.getState().updateDayTitle(1, 1, 'Day at the Beach');
+
+      const updatedDay = useTripStore.getState().days.find(d => d.id === 1);
+      expect(updatedDay?.title).toBe('Day at the Beach');
+    });
+  });
+});
diff --git a/client/tests/unit/slices/filesSlice.test.ts b/client/tests/unit/slices/filesSlice.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7f5adc8c5999b57c22956109d9fbb947dda2ba10
--- /dev/null
+++ b/client/tests/unit/slices/filesSlice.test.ts
@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { useTripStore } from '../../../src/store/tripStore';
+import { filesApi } from '../../../src/api/client';
+import { resetAllStores, seedStore } from '../../helpers/store';
+import { buildTripFile } from '../../helpers/factories';
+import { server } from '../../helpers/msw/server';
+
+vi.mock('../../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => null),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+}));
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('filesSlice', () => {
+  describe('loadFiles', () => {
+    it('FE-FILES-001: loadFiles fetches and replaces files array', async () => {
+      const staleFile = buildTripFile({ trip_id: 1, filename: 'stale.pdf' });
+      seedStore(useTripStore, { files: [staleFile] });
+
+      const freshFile = buildTripFile({ trip_id: 1, filename: 'fresh.pdf' });
+      server.use(
+        http.get('/api/trips/1/files', () => HttpResponse.json({ files: [freshFile] })),
+      );
+
+      await useTripStore.getState().loadFiles(1);
+
+      const files = useTripStore.getState().files;
+      expect(files).toHaveLength(1);
+      expect(files[0].filename).toBe('fresh.pdf');
+    });
+
+    it('FE-FILES-002: loadFiles silently catches errors', async () => {
+      server.use(
+        http.get('/api/trips/1/files', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      // Should not throw
+      await useTripStore.getState().loadFiles(1);
+    });
+  });
+
+  describe('addFile', () => {
+    it('FE-FILES-003: addFile uploads and prepends file to files array', async () => {
+      const existing = buildTripFile({ trip_id: 1, filename: 'existing.pdf' });
+      seedStore(useTripStore, { files: [existing] });
+
+      const uploaded = buildTripFile({ trip_id: 1, filename: 'new-upload.pdf' });
+      // FormData POST hangs on CI — mock at the API boundary instead of MSW.
+      const uploadSpy = vi.spyOn(filesApi, 'upload').mockResolvedValueOnce({ file: uploaded });
+
+      const formData = new FormData();
+      formData.append('file', new Blob(['content'], { type: 'application/pdf' }), 'new-upload.pdf');
+
+      const result = await useTripStore.getState().addFile(1, formData);
+      uploadSpy.mockRestore();
+
+      expect(result.filename).toBe('new-upload.pdf');
+      const files = useTripStore.getState().files;
+      expect(files).toHaveLength(2);
+      // prepends
+      expect(files[0].filename).toBe('new-upload.pdf');
+    });
+
+    it('FE-FILES-004: addFile on failure throws', async () => {
+      server.use(
+        http.post('/api/trips/1/files', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      const formData = new FormData();
+
+      await expect(useTripStore.getState().addFile(1, formData)).rejects.toThrow();
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('FE-FILES-005: deleteFile removes file from array after API success', async () => {
+      const file1 = buildTripFile({ id: 10, trip_id: 1 });
+      const file2 = buildTripFile({ id: 20, trip_id: 1 });
+      seedStore(useTripStore, { files: [file1, file2] });
+
+      await useTripStore.getState().deleteFile(1, 10);
+
+      const files = useTripStore.getState().files;
+      expect(files).toHaveLength(1);
+      expect(files[0].id).toBe(20);
+    });
+
+    it('FE-FILES-006: deleteFile on failure throws', async () => {
+      const file = buildTripFile({ id: 10, trip_id: 1 });
+      seedStore(useTripStore, { files: [file] });
+
+      server.use(
+        http.delete('/api/trips/1/files/10', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().deleteFile(1, 10)).rejects.toThrow();
+
+      // File remains since server-first (only removes after success)
+      expect(useTripStore.getState().files).toHaveLength(1);
+    });
+  });
+});
diff --git a/client/tests/unit/slices/packingSlice.test.ts b/client/tests/unit/slices/packingSlice.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..901c0a08223d32a0c42874cd96f19fdba7ad4227
--- /dev/null
+++ b/client/tests/unit/slices/packingSlice.test.ts
@@ -0,0 +1,135 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores, seedStore } from '../../helpers/store';
+import { buildPackingItem } from '../../helpers/factories';
+import { server } from '../../helpers/msw/server';
+
+vi.mock('../../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => null),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+}));
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('packingSlice', () => {
+  describe('addPackingItem', () => {
+    it('FE-PACKING-001: addPackingItem calls API and appends item to packingItems', async () => {
+      const existing = buildPackingItem({ trip_id: 1, name: 'Existing' });
+      seedStore(useTripStore, { packingItems: [existing] });
+
+      const result = await useTripStore.getState().addPackingItem(1, { name: 'Toothbrush', quantity: 1 });
+
+      expect(result.name).toBe('Toothbrush');
+      const items = useTripStore.getState().packingItems;
+      expect(items).toHaveLength(2);
+      // addPackingItem appends (not prepends)
+      expect(items[items.length - 1].name).toBe('Toothbrush');
+    });
+
+    it('FE-PACKING-002: addPackingItem on failure throws', async () => {
+      server.use(
+        http.post('/api/trips/1/packing', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(
+        useTripStore.getState().addPackingItem(1, { name: 'Fail item' })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('updatePackingItem', () => {
+    it('FE-PACKING-003: updatePackingItem replaces item in array by id', async () => {
+      const item = buildPackingItem({ id: 10, trip_id: 1, name: 'Old name', quantity: 1 });
+      seedStore(useTripStore, { packingItems: [item] });
+
+      server.use(
+        http.put('/api/trips/1/packing/10', async ({ request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          return HttpResponse.json({ item: { ...item, ...body } });
+        }),
+      );
+
+      const result = await useTripStore.getState().updatePackingItem(1, 10, { name: 'New name' });
+
+      expect(result.name).toBe('New name');
+      expect(useTripStore.getState().packingItems[0].name).toBe('New name');
+    });
+  });
+
+  describe('deletePackingItem', () => {
+    it('FE-PACKING-004: deletePackingItem optimistically removes item, rollback on failure', async () => {
+      const item = buildPackingItem({ id: 10, trip_id: 1 });
+      seedStore(useTripStore, { packingItems: [item] });
+
+      server.use(
+        http.delete('/api/trips/1/packing/10', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().deletePackingItem(1, 10)).rejects.toThrow();
+
+      expect(useTripStore.getState().packingItems).toHaveLength(1);
+      expect(useTripStore.getState().packingItems[0].id).toBe(10);
+    });
+
+    it('FE-PACKING-004b: deletePackingItem success removes item', async () => {
+      const item1 = buildPackingItem({ id: 10, trip_id: 1 });
+      const item2 = buildPackingItem({ id: 20, trip_id: 1 });
+      seedStore(useTripStore, { packingItems: [item1, item2] });
+
+      await useTripStore.getState().deletePackingItem(1, 10);
+
+      const items = useTripStore.getState().packingItems;
+      expect(items).toHaveLength(1);
+      expect(items[0].id).toBe(20);
+    });
+  });
+
+  describe('togglePackingItem', () => {
+    it('FE-PACKING-005: togglePackingItem sets checked optimistically', async () => {
+      const item = buildPackingItem({ id: 10, trip_id: 1, checked: 0 });
+      seedStore(useTripStore, { packingItems: [item] });
+
+      server.use(
+        http.put('/api/trips/1/packing/10', async ({ request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          return HttpResponse.json({ item: { ...item, ...body } });
+        }),
+      );
+
+      await useTripStore.getState().togglePackingItem(1, 10, true);
+
+      expect(useTripStore.getState().packingItems[0].checked).toBe(1);
+    });
+
+    it('FE-PACKING-006: togglePackingItem rolls back checked on API failure', async () => {
+      const item = buildPackingItem({ id: 10, trip_id: 1, checked: 0 });
+      seedStore(useTripStore, { packingItems: [item] });
+
+      server.use(
+        http.put('/api/trips/1/packing/10', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      // toggle does NOT throw on error (silent rollback)
+      await useTripStore.getState().togglePackingItem(1, 10, true);
+
+      // Should be rolled back to original value
+      expect(useTripStore.getState().packingItems[0].checked).toBe(0);
+    });
+  });
+});
diff --git a/client/tests/unit/slices/placesSlice.test.ts b/client/tests/unit/slices/placesSlice.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..93a9310e190ab7b1fcbadb8ee13938a37b993717
--- /dev/null
+++ b/client/tests/unit/slices/placesSlice.test.ts
@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores, seedStore } from '../../helpers/store';
+import { buildPlace, buildAssignment } from '../../helpers/factories';
+import { server } from '../../helpers/msw/server';
+
+vi.mock('../../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => null),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+}));
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('placesSlice', () => {
+  describe('addPlace', () => {
+    it('FE-PLACES-001: addPlace calls API and prepends place to places array', async () => {
+      const existing = buildPlace({ trip_id: 1 });
+      seedStore(useTripStore, { places: [existing] });
+
+      const result = await useTripStore.getState().addPlace(1, { name: 'New Place' });
+
+      expect(result.name).toBe('New Place');
+      const places = useTripStore.getState().places;
+      expect(places).toHaveLength(2);
+      expect(places[0].name).toBe('New Place'); // prepended
+    });
+
+    it('FE-PLACES-002: addPlace on failure throws and places remain unchanged', async () => {
+      const existing = buildPlace({ trip_id: 1 });
+      seedStore(useTripStore, { places: [existing] });
+
+      server.use(
+        http.post('/api/trips/:id/places', () =>
+          HttpResponse.json({ message: 'Server error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().addPlace(1, { name: 'Fail' })).rejects.toThrow();
+      expect(useTripStore.getState().places).toEqual([existing]);
+    });
+  });
+
+  describe('updatePlace', () => {
+    it('FE-PLACES-003: updatePlace calls API and updates place in array', async () => {
+      const place = buildPlace({ id: 10, trip_id: 1, name: 'Old Name' });
+      seedStore(useTripStore, { places: [place] });
+
+      server.use(
+        http.put('/api/trips/:id/places/:placeId', async ({ params, request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          return HttpResponse.json({ place: { ...place, ...body, id: Number(params.placeId) } });
+        }),
+      );
+
+      const result = await useTripStore.getState().updatePlace(1, 10, { name: 'New Name' });
+
+      expect(result.name).toBe('New Name');
+      const updated = useTripStore.getState().places.find(p => p.id === 10);
+      expect(updated?.name).toBe('New Name');
+    });
+
+    it('FE-PLACES-004: updatePlace cascades to assignments map — assignment place field updated', async () => {
+      const place = buildPlace({ id: 10, trip_id: 1, name: 'Old Place' });
+      const assignment = buildAssignment({ id: 100, day_id: 1, place });
+      seedStore(useTripStore, {
+        places: [place],
+        assignments: { '1': [assignment] },
+      });
+
+      server.use(
+        http.put('/api/trips/1/places/10', async ({ request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          return HttpResponse.json({ place: { ...place, ...body } });
+        }),
+      );
+
+      await useTripStore.getState().updatePlace(1, 10, { name: 'Updated Place' });
+
+      const updatedAssignments = useTripStore.getState().assignments['1'];
+      expect(updatedAssignments[0].place.name).toBe('Updated Place');
+    });
+  });
+
+  describe('deletePlace', () => {
+    it('FE-PLACES-005: deletePlace removes place from places array', async () => {
+      const place1 = buildPlace({ id: 10, trip_id: 1 });
+      const place2 = buildPlace({ id: 20, trip_id: 1 });
+      seedStore(useTripStore, { places: [place1, place2], assignments: {} });
+
+      server.use(
+        http.delete('/api/trips/1/places/10', () => HttpResponse.json({ success: true })),
+      );
+
+      await useTripStore.getState().deletePlace(1, 10);
+
+      const places = useTripStore.getState().places;
+      expect(places).toHaveLength(1);
+      expect(places[0].id).toBe(20);
+    });
+
+    it('FE-PLACES-006: deletePlace cascades — assignments referencing the place are removed', async () => {
+      const place = buildPlace({ id: 10, trip_id: 1 });
+      const otherPlace = buildPlace({ id: 20, trip_id: 1 });
+      const assignmentWithPlace = buildAssignment({ id: 100, day_id: 1, place });
+      const assignmentOther = buildAssignment({ id: 200, day_id: 1, place: otherPlace });
+
+      seedStore(useTripStore, {
+        places: [place, otherPlace],
+        assignments: { '1': [assignmentWithPlace, assignmentOther] },
+      });
+
+      server.use(
+        http.delete('/api/trips/1/places/10', () => HttpResponse.json({ success: true })),
+      );
+
+      await useTripStore.getState().deletePlace(1, 10);
+
+      const dayAssignments = useTripStore.getState().assignments['1'];
+      expect(dayAssignments).toHaveLength(1);
+      expect(dayAssignments[0].id).toBe(200);
+    });
+  });
+
+  describe('refreshPlaces', () => {
+    it('FE-PLACES-007: refreshPlaces re-fetches and replaces places array', async () => {
+      const stale = buildPlace({ id: 99, trip_id: 1, name: 'Stale' });
+      seedStore(useTripStore, { places: [stale] });
+
+      const fresh = buildPlace({ trip_id: 1, name: 'Fresh' });
+      server.use(
+        http.get('/api/trips/1/places', () => HttpResponse.json({ places: [fresh] })),
+      );
+
+      await useTripStore.getState().refreshPlaces(1);
+
+      const places = useTripStore.getState().places;
+      expect(places).toHaveLength(1);
+      expect(places[0].name).toBe('Fresh');
+    });
+  });
+});
diff --git a/client/tests/unit/slices/reservationsSlice.test.ts b/client/tests/unit/slices/reservationsSlice.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a95b91b77a96ef22a60ea95e7429bfbe73b39ab4
--- /dev/null
+++ b/client/tests/unit/slices/reservationsSlice.test.ts
@@ -0,0 +1,182 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores, seedStore } from '../../helpers/store';
+import { buildReservation } from '../../helpers/factories';
+import { server } from '../../helpers/msw/server';
+
+vi.mock('../../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => null),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+}));
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('reservationsSlice', () => {
+  describe('loadReservations', () => {
+    it('FE-RESERV-001: loadReservations fetches and replaces reservations', async () => {
+      seedStore(useTripStore, { reservations: [] });
+
+      const reservation = buildReservation({ trip_id: 1 });
+      server.use(
+        http.get('/api/trips/1/reservations', () =>
+          HttpResponse.json({ reservations: [reservation] })
+        ),
+      );
+
+      await useTripStore.getState().loadReservations(1);
+
+      expect(useTripStore.getState().reservations).toHaveLength(1);
+      expect(useTripStore.getState().reservations[0].id).toBe(reservation.id);
+    });
+  });
+
+  describe('addReservation', () => {
+    it('FE-RESERV-002: addReservation prepends to reservations array', async () => {
+      const existing = buildReservation({ trip_id: 1, title: 'Existing' });
+      seedStore(useTripStore, { reservations: [existing] });
+
+      const result = await useTripStore.getState().addReservation(1, {
+        title: 'New Hotel',
+        type: 'hotel',
+        status: 'pending',
+      });
+
+      expect(result.title).toBe('New Hotel');
+      const reservations = useTripStore.getState().reservations;
+      expect(reservations).toHaveLength(2);
+      // addReservation prepends
+      expect(reservations[0].title).toBe('New Hotel');
+    });
+
+    it('FE-RESERV-003: addReservation on failure throws', async () => {
+      server.use(
+        http.post('/api/trips/1/reservations', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(
+        useTripStore.getState().addReservation(1, { title: 'Fail' })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('updateReservation', () => {
+    it('FE-RESERV-004: updateReservation replaces item in array by id', async () => {
+      const reservation = buildReservation({ id: 10, trip_id: 1, title: 'Old', status: 'pending' });
+      seedStore(useTripStore, { reservations: [reservation] });
+
+      server.use(
+        http.put('/api/trips/1/reservations/10', async ({ request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          return HttpResponse.json({ reservation: { ...reservation, ...body } });
+        }),
+      );
+
+      const result = await useTripStore.getState().updateReservation(1, 10, { title: 'Updated Hotel' });
+
+      expect(result.title).toBe('Updated Hotel');
+      expect(useTripStore.getState().reservations[0].title).toBe('Updated Hotel');
+    });
+  });
+
+  describe('toggleReservationStatus', () => {
+    it('FE-RESERV-005: toggleReservationStatus flips confirmed to pending optimistically', async () => {
+      const reservation = buildReservation({ id: 10, trip_id: 1, status: 'confirmed' });
+      seedStore(useTripStore, { reservations: [reservation] });
+
+      server.use(
+        http.put('/api/trips/1/reservations/10', async ({ request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          return HttpResponse.json({ reservation: { ...reservation, ...body } });
+        }),
+      );
+
+      await useTripStore.getState().toggleReservationStatus(1, 10);
+
+      expect(useTripStore.getState().reservations[0].status).toBe('pending');
+    });
+
+    it('FE-RESERV-006: toggleReservationStatus flips pending to confirmed optimistically', async () => {
+      const reservation = buildReservation({ id: 10, trip_id: 1, status: 'pending' });
+      seedStore(useTripStore, { reservations: [reservation] });
+
+      server.use(
+        http.put('/api/trips/1/reservations/10', async ({ request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          return HttpResponse.json({ reservation: { ...reservation, ...body } });
+        }),
+      );
+
+      await useTripStore.getState().toggleReservationStatus(1, 10);
+
+      expect(useTripStore.getState().reservations[0].status).toBe('confirmed');
+    });
+
+    it('FE-RESERV-007: toggleReservationStatus rolls back and surfaces the error on API failure', async () => {
+      const reservation = buildReservation({ id: 10, trip_id: 1, status: 'confirmed' });
+      seedStore(useTripStore, { reservations: [reservation] });
+
+      server.use(
+        http.put('/api/trips/1/reservations/10', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      // Rolls back the optimistic toggle AND rejects, so the caller's catch can
+      // show a toast (previously the failure was swallowed and the toast never fired).
+      await expect(useTripStore.getState().toggleReservationStatus(1, 10)).rejects.toThrow();
+
+      expect(useTripStore.getState().reservations[0].status).toBe('confirmed');
+    });
+
+    it('FE-RESERV-008: toggleReservationStatus does nothing if reservation not found', async () => {
+      seedStore(useTripStore, { reservations: [] });
+
+      // Should not throw
+      await useTripStore.getState().toggleReservationStatus(1, 999);
+
+      expect(useTripStore.getState().reservations).toHaveLength(0);
+    });
+  });
+
+  describe('deleteReservation', () => {
+    it('FE-RESERV-009: deleteReservation removes from reservations after API success', async () => {
+      const r1 = buildReservation({ id: 10, trip_id: 1 });
+      const r2 = buildReservation({ id: 20, trip_id: 1 });
+      seedStore(useTripStore, { reservations: [r1, r2] });
+
+      await useTripStore.getState().deleteReservation(1, 10);
+
+      const reservations = useTripStore.getState().reservations;
+      expect(reservations).toHaveLength(1);
+      expect(reservations[0].id).toBe(20);
+    });
+
+    it('FE-RESERV-010: deleteReservation on failure throws (no optimistic, server-first)', async () => {
+      const reservation = buildReservation({ id: 10, trip_id: 1 });
+      seedStore(useTripStore, { reservations: [reservation] });
+
+      server.use(
+        http.delete('/api/trips/1/reservations/10', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().deleteReservation(1, 10)).rejects.toThrow();
+
+      // Still in state since server-first (only removes after success)
+      expect(useTripStore.getState().reservations).toHaveLength(1);
+    });
+  });
+});
diff --git a/client/tests/unit/slices/todoSlice.test.ts b/client/tests/unit/slices/todoSlice.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..123426bc3ba85a4bc0d6f9b5df81d1187c24dbdf
--- /dev/null
+++ b/client/tests/unit/slices/todoSlice.test.ts
@@ -0,0 +1,150 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { useTripStore } from '../../../src/store/tripStore';
+import { resetAllStores, seedStore } from '../../helpers/store';
+import { buildTodoItem } from '../../helpers/factories';
+import { server } from '../../helpers/msw/server';
+
+vi.mock('../../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => null),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+}));
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('todoSlice', () => {
+  describe('addTodoItem', () => {
+    it('FE-TODO-001: addTodoItem calls API and appends item to todoItems', async () => {
+      const existing = buildTodoItem({ trip_id: 1 });
+      seedStore(useTripStore, { todoItems: [existing] });
+
+      const result = await useTripStore.getState().addTodoItem(1, { name: 'Buy sunscreen', priority: 1 });
+
+      expect(result.name).toBe('Buy sunscreen');
+      const items = useTripStore.getState().todoItems;
+      expect(items).toHaveLength(2);
+    });
+
+    it('FE-TODO-002: addTodoItem on failure throws', async () => {
+      server.use(
+        http.post('/api/trips/1/todo', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(
+        useTripStore.getState().addTodoItem(1, { name: 'Fail' })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('updateTodoItem', () => {
+    it('FE-TODO-003: updateTodoItem replaces item and preserves priority field', async () => {
+      const item = buildTodoItem({ id: 10, trip_id: 1, name: 'Old', priority: 2, sort_order: 5 });
+      seedStore(useTripStore, { todoItems: [item] });
+
+      server.use(
+        http.put('/api/trips/1/todo/10', async ({ request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          return HttpResponse.json({ item: { ...item, ...body } });
+        }),
+      );
+
+      const result = await useTripStore.getState().updateTodoItem(1, 10, { name: 'Updated', priority: 2 });
+
+      expect(result.name).toBe('Updated');
+      expect(result.priority).toBe(2);
+      expect(useTripStore.getState().todoItems[0].name).toBe('Updated');
+      expect(useTripStore.getState().todoItems[0].priority).toBe(2);
+    });
+  });
+
+  describe('deleteTodoItem', () => {
+    it('FE-TODO-004: deleteTodoItem optimistically removes item, rollback on failure', async () => {
+      const item = buildTodoItem({ id: 10, trip_id: 1 });
+      seedStore(useTripStore, { todoItems: [item] });
+
+      server.use(
+        http.delete('/api/trips/1/todo/10', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      await expect(useTripStore.getState().deleteTodoItem(1, 10)).rejects.toThrow();
+
+      expect(useTripStore.getState().todoItems).toHaveLength(1);
+      expect(useTripStore.getState().todoItems[0].id).toBe(10);
+    });
+
+    it('FE-TODO-004b: deleteTodoItem success removes item from array', async () => {
+      const item1 = buildTodoItem({ id: 10, trip_id: 1 });
+      const item2 = buildTodoItem({ id: 20, trip_id: 1 });
+      seedStore(useTripStore, { todoItems: [item1, item2] });
+
+      await useTripStore.getState().deleteTodoItem(1, 10);
+
+      const items = useTripStore.getState().todoItems;
+      expect(items).toHaveLength(1);
+      expect(items[0].id).toBe(20);
+    });
+  });
+
+  describe('toggleTodoItem', () => {
+    it('FE-TODO-005: toggleTodoItem sets checked optimistically to 1', async () => {
+      const item = buildTodoItem({ id: 10, trip_id: 1, checked: 0 });
+      seedStore(useTripStore, { todoItems: [item] });
+
+      server.use(
+        http.put('/api/trips/1/todo/10', async ({ request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          return HttpResponse.json({ item: { ...item, ...body } });
+        }),
+      );
+
+      await useTripStore.getState().toggleTodoItem(1, 10, true);
+
+      expect(useTripStore.getState().todoItems[0].checked).toBe(1);
+    });
+
+    it('FE-TODO-006: toggleTodoItem rolls back checked on API failure (silent)', async () => {
+      const item = buildTodoItem({ id: 10, trip_id: 1, checked: 0 });
+      seedStore(useTripStore, { todoItems: [item] });
+
+      server.use(
+        http.put('/api/trips/1/todo/10', () =>
+          HttpResponse.json({ message: 'Error' }, { status: 500 })
+        ),
+      );
+
+      // Does NOT throw
+      await useTripStore.getState().toggleTodoItem(1, 10, true);
+
+      expect(useTripStore.getState().todoItems[0].checked).toBe(0);
+    });
+
+    it('FE-TODO-007: toggleTodoItem preserves sort_order field', async () => {
+      const item = buildTodoItem({ id: 10, trip_id: 1, checked: 0, sort_order: 3 });
+      seedStore(useTripStore, { todoItems: [item] });
+
+      server.use(
+        http.put('/api/trips/1/todo/10', async ({ request }) => {
+          const body = await request.json() as Record<string, unknown>;
+          return HttpResponse.json({ item: { ...item, ...body } });
+        }),
+      );
+
+      await useTripStore.getState().toggleTodoItem(1, 10, true);
+
+      expect(useTripStore.getState().todoItems[0].sort_order).toBe(3);
+    });
+  });
+});
diff --git a/client/tests/unit/stores/addonStore.test.ts b/client/tests/unit/stores/addonStore.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d195b445640ce76ee26783ba2235bd9678e3c9a1
--- /dev/null
+++ b/client/tests/unit/stores/addonStore.test.ts
@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../helpers/msw/server';
+import { useAddonStore } from '../../../src/store/addonStore';
+import { resetAllStores } from '../../helpers/store';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('addonStore', () => {
+  describe('FE-ADDON-001: loadAddons()', () => {
+    it('fetches and stores enabled addons', async () => {
+      await useAddonStore.getState().loadAddons();
+      const state = useAddonStore.getState();
+
+      expect(state.loaded).toBe(true);
+      expect(state.addons.length).toBeGreaterThan(0);
+      expect(state.addons[0]).toHaveProperty('id');
+      expect(state.addons[0]).toHaveProperty('enabled', true);
+      expect(state.bagTracking).toBe(false);
+    });
+
+    it('captures the global bagTracking flag from the response', async () => {
+      server.use(
+        http.get('/api/addons', () =>
+          HttpResponse.json({ bagTracking: true, addons: [] })
+        )
+      );
+
+      await useAddonStore.getState().loadAddons();
+      expect(useAddonStore.getState().bagTracking).toBe(true);
+    });
+  });
+
+  describe('FE-ADDON-002: isEnabled returns true for known addon', () => {
+    it('returns true when addon is in the list and enabled', async () => {
+      await useAddonStore.getState().loadAddons();
+      expect(useAddonStore.getState().isEnabled('vacay')).toBe(true);
+    });
+  });
+
+  describe('FE-ADDON-003: isEnabled returns false for unknown addon', () => {
+    it('returns false when addon is not in the list', async () => {
+      await useAddonStore.getState().loadAddons();
+      expect(useAddonStore.getState().isEnabled('nonexistent')).toBe(false);
+    });
+  });
+
+  describe('FE-ADDON-004: API failure', () => {
+    it('sets loaded: true and keeps addons empty on API error', async () => {
+      server.use(
+        http.get('/api/addons', () =>
+          HttpResponse.json({ error: 'Server error' }, { status: 500 })
+        )
+      );
+
+      await useAddonStore.getState().loadAddons();
+      const state = useAddonStore.getState();
+
+      expect(state.loaded).toBe(true);
+      expect(state.addons).toEqual([]);
+    });
+  });
+});
diff --git a/client/tests/unit/stores/authStore.test.ts b/client/tests/unit/stores/authStore.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..228697190e3a0bfaac0ad6eba1a7a86c03a77f35
--- /dev/null
+++ b/client/tests/unit/stores/authStore.test.ts
@@ -0,0 +1,491 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../helpers/msw/server';
+import { useAuthStore } from '../../../src/store/authStore';
+import { authApi } from '../../../src/api/client';
+import { resetAllStores } from '../../helpers/store';
+import { buildUser } from '../../helpers/factories';
+
+// The websocket module is already mocked globally in tests/setup.ts
+import { connect, disconnect } from '../../../src/api/websocket';
+
+beforeEach(() => {
+  resetAllStores();
+  vi.clearAllMocks();
+});
+
+describe('authStore', () => {
+  describe('FE-AUTH-001: Successful login', () => {
+    it('sets user, isAuthenticated: true, isLoading: false', async () => {
+      const user = buildUser();
+      server.use(
+        http.post('/api/auth/login', () =>
+          HttpResponse.json({ user, token: 'tok' })
+        )
+      );
+
+      await useAuthStore.getState().login(user.email, 'password');
+      const state = useAuthStore.getState();
+
+      expect(state.user).toEqual(user);
+      expect(state.isAuthenticated).toBe(true);
+      expect(state.isLoading).toBe(false);
+      expect(state.error).toBeNull();
+    });
+  });
+
+  describe('FE-AUTH-002: Login failure', () => {
+    it('sets error and isAuthenticated: false', async () => {
+      server.use(
+        http.post('/api/auth/login', () =>
+          HttpResponse.json({ error: 'Bad credentials' }, { status: 401 })
+        )
+      );
+
+      await expect(
+        useAuthStore.getState().login('bad@example.com', 'wrong')
+      ).rejects.toThrow();
+
+      const state = useAuthStore.getState();
+      expect(state.error).toBe('Bad credentials');
+      expect(state.isAuthenticated).toBe(false);
+      expect(state.isLoading).toBe(false);
+    });
+  });
+
+  describe('FE-AUTH-003: Login calls connect()', () => {
+    it('calls connect from websocket module after successful login', async () => {
+      const user = buildUser();
+      server.use(
+        http.post('/api/auth/login', () =>
+          HttpResponse.json({ user, token: 'tok' })
+        )
+      );
+
+      await useAuthStore.getState().login(user.email, 'password');
+
+      expect(connect).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe('FE-AUTH-004: loadUser with valid session', () => {
+    it('sets user state from /auth/me', async () => {
+      const user = buildUser();
+      server.use(
+        http.get('/api/auth/me', () => HttpResponse.json({ user }))
+      );
+
+      await useAuthStore.getState().loadUser();
+      const state = useAuthStore.getState();
+
+      expect(state.user).toEqual(user);
+      expect(state.isAuthenticated).toBe(true);
+      expect(state.isLoading).toBe(false);
+    });
+  });
+
+  describe('FE-AUTH-005: loadUser with 401', () => {
+    it('clears auth state on 401', async () => {
+      server.use(
+        http.get('/api/auth/me', () =>
+          HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+        )
+      );
+
+      // Pre-seed as authenticated
+      useAuthStore.setState({ user: buildUser(), isAuthenticated: true });
+
+      await useAuthStore.getState().loadUser();
+      const state = useAuthStore.getState();
+
+      expect(state.user).toBeNull();
+      expect(state.isAuthenticated).toBe(false);
+      expect(state.isLoading).toBe(false);
+    });
+  });
+
+  describe('FE-AUTH-006: logout', () => {
+    it('calls disconnect() and clears user state', async () => {
+      useAuthStore.setState({ user: buildUser(), isAuthenticated: true });
+
+      await useAuthStore.getState().logout();
+      const state = useAuthStore.getState();
+
+      expect(disconnect).toHaveBeenCalledOnce();
+      expect(state.user).toBeNull();
+      expect(state.isAuthenticated).toBe(false);
+    });
+  });
+
+  describe('FE-AUTH-007: Register success', () => {
+    it('sets user and authenticates', async () => {
+      const user = buildUser();
+      server.use(
+        http.post('/api/auth/register', () =>
+          HttpResponse.json({ user, token: 'tok' })
+        )
+      );
+
+      await useAuthStore.getState().register(user.username, user.email, 'password');
+      const state = useAuthStore.getState();
+
+      expect(state.user).toEqual(user);
+      expect(state.isAuthenticated).toBe(true);
+      expect(state.isLoading).toBe(false);
+    });
+  });
+
+  describe('FE-AUTH-008: authSequence guard', () => {
+    it('stale loadUser does not overwrite fresh login state', async () => {
+      let resolveStale!: (v: Response) => void;
+      const stalePromise = new Promise<Response>((res) => { resolveStale = res; });
+
+      // First call to /auth/me will hang until we resolve it manually
+      let callCount = 0;
+      server.use(
+        http.get('/api/auth/me', async () => {
+          callCount++;
+          if (callCount === 1) {
+            // Stale request — wait
+            await stalePromise;
+            return HttpResponse.json({ user: buildUser({ username: 'stale' }) });
+          }
+          // Should not be called a second time in this test
+          return HttpResponse.json({ user: buildUser({ username: 'fresh' }) });
+        })
+      );
+
+      // Start loadUser but don't await yet
+      const staleLoad = useAuthStore.getState().loadUser();
+
+      // Meanwhile, perform a login (bumps authSequence)
+      const freshUser = buildUser({ username: 'freshlogin' });
+      server.use(
+        http.post('/api/auth/login', () =>
+          HttpResponse.json({ user: freshUser, token: 'tok' })
+        )
+      );
+      await useAuthStore.getState().login(freshUser.email, 'password');
+
+      // Now resolve the stale loadUser response
+      resolveStale(new Response());
+      await staleLoad;
+
+      // The fresh login state must be preserved
+      const state = useAuthStore.getState();
+      expect(state.user?.username).toBe('freshlogin');
+      expect(state.isAuthenticated).toBe(true);
+    });
+  });
+
+  describe('FE-AUTH-009: MFA-required state handling', () => {
+    it('returns mfa_required flag and does not set user as authenticated', async () => {
+      server.use(
+        http.post('/api/auth/login', () =>
+          HttpResponse.json({ mfa_required: true, mfa_token: 'mfa-tok-123' })
+        )
+      );
+
+      const result = await useAuthStore.getState().login('user@example.com', 'password');
+
+      expect(result).toMatchObject({ mfa_required: true, mfa_token: 'mfa-tok-123' });
+      const state = useAuthStore.getState();
+      expect(state.isAuthenticated).toBe(false);
+      expect(state.user).toBeNull();
+    });
+  });
+
+  describe('FE-STORE-AUTH-010: completeMfaLogin success', () => {
+    it('sets user, isAuthenticated, and calls connect', async () => {
+      const user = buildUser();
+      server.use(
+        http.post('/api/auth/mfa/verify-login', () =>
+          HttpResponse.json({ user, token: 'mfa-session-tok' })
+        )
+      );
+
+      await useAuthStore.getState().completeMfaLogin('mfa-tok', '123456');
+      const state = useAuthStore.getState();
+
+      expect(state.user).toEqual(user);
+      expect(state.isAuthenticated).toBe(true);
+      expect(state.isLoading).toBe(false);
+      expect(connect).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe('FE-STORE-AUTH-011: completeMfaLogin failure', () => {
+    it('sets error and remains unauthenticated', async () => {
+      server.use(
+        http.post('/api/auth/mfa/verify-login', () =>
+          HttpResponse.json({ error: 'Invalid code' }, { status: 401 })
+        )
+      );
+
+      await expect(
+        useAuthStore.getState().completeMfaLogin('mfa-tok', '000000')
+      ).rejects.toThrow();
+
+      const state = useAuthStore.getState();
+      expect(state.error).toBeTruthy();
+      expect(state.isAuthenticated).toBe(false);
+      expect(state.isLoading).toBe(false);
+    });
+  });
+
+  describe('FE-STORE-AUTH-012: register failure', () => {
+    it('sets error on registration failure', async () => {
+      server.use(
+        http.post('/api/auth/register', () =>
+          HttpResponse.json({ error: 'Email taken' }, { status: 400 })
+        )
+      );
+
+      await expect(
+        useAuthStore.getState().register('u', 'e@e.com', 'pw')
+      ).rejects.toThrow();
+
+      const state = useAuthStore.getState();
+      expect(state.error).toBe('Email taken');
+      expect(state.isAuthenticated).toBe(false);
+    });
+  });
+
+  describe('FE-STORE-AUTH-013: loadUser silent mode', () => {
+    it('does not toggle isLoading when silent: true', async () => {
+      const user = buildUser();
+      server.use(
+        http.get('/api/auth/me', () => HttpResponse.json({ user }))
+      );
+
+      useAuthStore.setState({ isLoading: false });
+
+      // isLoading should remain false immediately after calling (silent mode)
+      const loadPromise = useAuthStore.getState().loadUser({ silent: true });
+      expect(useAuthStore.getState().isLoading).toBe(false);
+
+      await loadPromise;
+      const state = useAuthStore.getState();
+      expect(state.isAuthenticated).toBe(true);
+      expect(state.isLoading).toBe(false);
+    });
+  });
+
+  describe('FE-STORE-AUTH-014: loadUser network error (non-401)', () => {
+    it('preserves auth state on network error', async () => {
+      server.use(
+        http.get('/api/auth/me', () =>
+          HttpResponse.json({ error: 'Server error' }, { status: 500 })
+        )
+      );
+
+      useAuthStore.setState({ user: buildUser(), isAuthenticated: true });
+
+      await useAuthStore.getState().loadUser();
+      const state = useAuthStore.getState();
+
+      expect(state.isAuthenticated).toBe(true);
+      expect(state.isLoading).toBe(false);
+    });
+  });
+
+  describe('FE-STORE-AUTH-015: updateMapsKey', () => {
+    it('updates user maps_api_key', async () => {
+      server.use(
+        http.put('/api/auth/me/maps-key', () =>
+          HttpResponse.json({ success: true })
+        )
+      );
+
+      useAuthStore.setState({ user: buildUser() });
+
+      await useAuthStore.getState().updateMapsKey('my-key');
+      expect(useAuthStore.getState().user?.maps_api_key).toBe('my-key');
+    });
+  });
+
+  describe('FE-STORE-AUTH-016: updateMapsKey with null clears key', () => {
+    it('sets maps_api_key to null', async () => {
+      server.use(
+        http.put('/api/auth/me/maps-key', () =>
+          HttpResponse.json({ success: true })
+        )
+      );
+
+      useAuthStore.setState({ user: buildUser({ maps_api_key: 'old-key' }) });
+
+      await useAuthStore.getState().updateMapsKey(null);
+      expect(useAuthStore.getState().user?.maps_api_key).toBeNull();
+    });
+  });
+
+  describe('FE-STORE-AUTH-017: updateApiKeys', () => {
+    it('updates user with returned data', async () => {
+      const updatedUser = buildUser({ username: 'apiuser' });
+      server.use(
+        http.put('/api/auth/me/api-keys', () =>
+          HttpResponse.json({ user: updatedUser })
+        )
+      );
+
+      useAuthStore.setState({ user: buildUser() });
+
+      await useAuthStore.getState().updateApiKeys({ some_api_key: 'val' });
+      expect(useAuthStore.getState().user).toEqual(updatedUser);
+    });
+  });
+
+  describe('FE-STORE-AUTH-018: updateProfile', () => {
+    it('updates user profile', async () => {
+      const updatedUser = buildUser({ username: 'updated' });
+      server.use(
+        http.put('/api/auth/me/settings', () =>
+          HttpResponse.json({ user: updatedUser })
+        )
+      );
+
+      useAuthStore.setState({ user: buildUser() });
+
+      await useAuthStore.getState().updateProfile({ username: 'updated' });
+      expect(useAuthStore.getState().user?.username).toBe('updated');
+    });
+  });
+
+  describe('FE-STORE-AUTH-019: setDemoMode(true)', () => {
+    it('sets demoMode and localStorage', () => {
+      useAuthStore.getState().setDemoMode(true);
+      expect(useAuthStore.getState().demoMode).toBe(true);
+      expect(localStorage.getItem('demo_mode')).toBe('true');
+    });
+  });
+
+  describe('FE-STORE-AUTH-020: setDemoMode(false)', () => {
+    it('clears demoMode and localStorage', () => {
+      localStorage.setItem('demo_mode', 'true');
+      useAuthStore.getState().setDemoMode(false);
+      expect(useAuthStore.getState().demoMode).toBe(false);
+      expect(localStorage.getItem('demo_mode')).toBeNull();
+    });
+  });
+
+  describe('FE-STORE-AUTH-021: demoLogin success', () => {
+    it('authenticates and sets demoMode', async () => {
+      const user = buildUser();
+      server.use(
+        http.post('/api/auth/demo-login', () =>
+          HttpResponse.json({ user, token: 'tok' })
+        )
+      );
+
+      await useAuthStore.getState().demoLogin();
+      const state = useAuthStore.getState();
+
+      expect(state.isAuthenticated).toBe(true);
+      expect(state.demoMode).toBe(true);
+      expect(state.isLoading).toBe(false);
+      expect(connect).toHaveBeenCalled();
+    });
+  });
+
+  describe('FE-STORE-AUTH-022: simple setters', () => {
+    it('updates devMode, hasMapsKey, serverTimezone, appRequireMfa, tripRemindersEnabled', () => {
+      const { setDevMode, setHasMapsKey, setServerTimezone, setAppRequireMfa, setTripRemindersEnabled } =
+        useAuthStore.getState();
+
+      setDevMode(true);
+      expect(useAuthStore.getState().devMode).toBe(true);
+
+      setHasMapsKey(true);
+      expect(useAuthStore.getState().hasMapsKey).toBe(true);
+
+      setServerTimezone('Europe/Berlin');
+      expect(useAuthStore.getState().serverTimezone).toBe('Europe/Berlin');
+
+      setAppRequireMfa(true);
+      expect(useAuthStore.getState().appRequireMfa).toBe(true);
+
+      setTripRemindersEnabled(true);
+      expect(useAuthStore.getState().tripRemindersEnabled).toBe(true);
+    });
+  });
+
+  describe('FE-STORE-AUTH-023: deleteAvatar', () => {
+    it('sets avatar_url to null', async () => {
+      server.use(
+        http.delete('/api/auth/avatar', () =>
+          HttpResponse.json({ success: true })
+        )
+      );
+
+      useAuthStore.setState({ user: buildUser({ avatar_url: '/uploads/avatar.png' }) });
+
+      await useAuthStore.getState().deleteAvatar();
+      expect(useAuthStore.getState().user?.avatar_url).toBeNull();
+    });
+  });
+
+  describe('FE-STORE-AUTH-UPLOAD: uploadAvatar', () => {
+    it('updates avatar_url from response', async () => {
+      // FormData POST hangs on CI — mock at the API boundary instead of MSW.
+      const uploadSpy = vi.spyOn(authApi, 'uploadAvatar').mockResolvedValueOnce({ avatar_url: '/uploads/avatar-new.png' });
+
+      useAuthStore.setState({ user: buildUser() });
+
+      const file = new File(['x'], 'avatar.png', { type: 'image/png' });
+      const result = await useAuthStore.getState().uploadAvatar(file);
+
+      expect(result.avatar_url).toBe('/uploads/avatar-new.png');
+      expect(useAuthStore.getState().user?.avatar_url).toBe('/uploads/avatar-new.png');
+      uploadSpy.mockRestore();
+    });
+  });
+
+  describe('FE-STORE-AUTH-PERSIST-001: logout resets persisted snapshot', () => {
+    it('snapshot has isAuthenticated:false after logout (PWA offline will redirect to login)', async () => {
+      useAuthStore.setState({ user: buildUser(), isAuthenticated: true });
+
+      await useAuthStore.getState().logout();
+
+      const snapshot = JSON.parse(localStorage.getItem('trek_auth_snapshot') ?? '{}');
+      expect(snapshot?.state?.isAuthenticated).toBe(false);
+      expect(snapshot?.state?.user).toBeNull();
+    });
+  });
+
+  describe('FE-STORE-AUTH-PERSIST-002: 401 resets persisted snapshot', () => {
+    it('snapshot has isAuthenticated:false after 401 (expired session clears offline access)', async () => {
+      useAuthStore.setState({ user: buildUser(), isAuthenticated: true });
+
+      server.use(
+        http.get('/api/auth/me', () =>
+          HttpResponse.json({ error: 'Unauthorized' }, { status: 401 })
+        )
+      );
+
+      await useAuthStore.getState().loadUser();
+
+      const snapshot = JSON.parse(localStorage.getItem('trek_auth_snapshot') ?? '{}');
+      expect(snapshot?.state?.isAuthenticated).toBe(false);
+      expect(useAuthStore.getState().isAuthenticated).toBe(false);
+    });
+  });
+
+  describe('FE-STORE-AUTH-PERSIST-003: network error preserves snapshot', () => {
+    it('snapshot retains isAuthenticated:true on network error (offline PWA skips login screen)', async () => {
+      useAuthStore.setState({ user: buildUser(), isAuthenticated: true });
+
+      server.use(
+        http.get('/api/auth/me', () =>
+          HttpResponse.json({ error: 'Server error' }, { status: 500 })
+        )
+      );
+
+      await useAuthStore.getState().loadUser();
+
+      // Persist middleware writes the state; isAuthenticated must stay true
+      const snapshot = JSON.parse(localStorage.getItem('trek_auth_snapshot') ?? '{}');
+      expect(snapshot?.state?.isAuthenticated).toBe(true);
+      expect(useAuthStore.getState().isAuthenticated).toBe(true);
+    });
+  });
+});
diff --git a/client/tests/unit/stores/inAppNotificationStore.test.ts b/client/tests/unit/stores/inAppNotificationStore.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ba6772272e23ca8e07736d2e5804089b8557f91a
--- /dev/null
+++ b/client/tests/unit/stores/inAppNotificationStore.test.ts
@@ -0,0 +1,351 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../helpers/msw/server';
+import { useInAppNotificationStore } from '../../../src/store/inAppNotificationStore';
+import { resetAllStores } from '../../helpers/store';
+
+// Raw notification factory matching the server shape (is_read as 0/1, params as strings)
+function buildRawNotif(overrides: Record<string, unknown> = {}) {
+  const id = Math.floor(Math.random() * 100000);
+  return {
+    id,
+    type: 'simple',
+    scope: 'trip',
+    target: 1,
+    sender_id: 2,
+    sender_username: 'alice',
+    sender_avatar: null,
+    recipient_id: 1,
+    title_key: 'notif.title',
+    title_params: '{}',
+    text_key: 'notif.text',
+    text_params: '{}',
+    positive_text_key: null,
+    negative_text_key: null,
+    response: null,
+    navigate_text_key: null,
+    navigate_target: null,
+    is_read: 0,
+    created_at: '2025-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('inAppNotificationStore', () => {
+  describe('FE-NOTIF-001: fetchNotifications() loads first page', () => {
+    it('populates notifications, total, and unreadCount', async () => {
+      await useInAppNotificationStore.getState().fetchNotifications();
+      const state = useInAppNotificationStore.getState();
+
+      expect(state.notifications.length).toBeGreaterThan(0);
+      expect(state.total).toBeGreaterThan(0);
+      expect(state.unreadCount).toBe(5);
+      expect(state.isLoading).toBe(false);
+    });
+  });
+
+  describe('FE-NOTIF-002: Pagination — loading more appends to list', () => {
+    it('appends additional notifications when fetchNotifications is called again', async () => {
+      // First page
+      await useInAppNotificationStore.getState().fetchNotifications(true);
+      const firstPageCount = useInAppNotificationStore.getState().notifications.length;
+      const total = useInAppNotificationStore.getState().total;
+
+      // Only test pagination if there are more items
+      if (firstPageCount < total) {
+        await useInAppNotificationStore.getState().fetchNotifications();
+        const state = useInAppNotificationStore.getState();
+        expect(state.notifications.length).toBeGreaterThan(firstPageCount);
+      } else {
+        // All notifications fit in one page
+        expect(firstPageCount).toBe(total);
+      }
+    });
+  });
+
+  describe('FE-NOTIF-003: markRead(id)', () => {
+    it('updates is_read to true for the notification', async () => {
+      // Seed with an unread notification
+      const unread = buildRawNotif({ id: 42, is_read: 0 });
+      useInAppNotificationStore.setState({
+        notifications: [{ ...unread, title_params: {}, text_params: {}, is_read: false }] as never,
+        unreadCount: 1,
+      });
+
+      await useInAppNotificationStore.getState().markRead(42);
+      const state = useInAppNotificationStore.getState();
+
+      const notif = state.notifications.find((n) => n.id === 42);
+      expect(notif?.is_read).toBe(true);
+      expect(state.unreadCount).toBe(0);
+    });
+  });
+
+  describe('FE-NOTIF-004: handleNewNotification() prepends to list', () => {
+    it('adds a new notification at the start of the list', () => {
+      // Seed existing notifications
+      useInAppNotificationStore.setState({
+        notifications: [{ ...buildRawNotif({ id: 1 }), title_params: {}, text_params: {}, is_read: false }] as never,
+        total: 1,
+        unreadCount: 1,
+      });
+
+      const newRaw = buildRawNotif({ id: 99 });
+      useInAppNotificationStore.getState().handleNewNotification(newRaw as never);
+
+      const state = useInAppNotificationStore.getState();
+      expect(state.notifications[0].id).toBe(99);
+      expect(state.notifications.length).toBe(2);
+      expect(state.total).toBe(2);
+      expect(state.unreadCount).toBe(2);
+    });
+  });
+
+  describe('FE-NOTIF-005: handleUpdatedNotification() updates existing notification', () => {
+    it('replaces the notification in the list', () => {
+      useInAppNotificationStore.setState({
+        notifications: [{ ...buildRawNotif({ id: 7, is_read: 0 }), title_params: {}, text_params: {}, is_read: false }] as never,
+        total: 1,
+        unreadCount: 1,
+      });
+
+      const updated = buildRawNotif({ id: 7, is_read: 1 });
+      useInAppNotificationStore.getState().handleUpdatedNotification(updated as never);
+
+      const state = useInAppNotificationStore.getState();
+      const notif = state.notifications.find((n) => n.id === 7);
+      expect(notif?.is_read).toBe(true);
+    });
+  });
+
+  describe('FE-NOTIF-006: Unread count is correct', () => {
+    it('unreadCount matches the number of unread notifications', async () => {
+      await useInAppNotificationStore.getState().fetchNotifications(true);
+      const state = useInAppNotificationStore.getState();
+
+      // The mock returns 5 unread from the server
+      expect(state.unreadCount).toBe(5);
+    });
+  });
+
+  describe('FE-STORE-NOTIF-007: fetchNotifications early-return when already loading', () => {
+    it('does not fetch when isLoading is true', async () => {
+      useInAppNotificationStore.setState({ isLoading: true });
+
+      await useInAppNotificationStore.getState().fetchNotifications();
+      const state = useInAppNotificationStore.getState();
+
+      expect(state.notifications).toEqual([]);
+      expect(state.isLoading).toBe(true);
+    });
+  });
+
+  describe('FE-STORE-NOTIF-008: fetchNotifications(reset=true) resets existing list', () => {
+    it('replaces seeded notifications with fresh data', async () => {
+      // Seed store with 3 notifications
+      useInAppNotificationStore.setState({
+        notifications: [
+          { ...buildRawNotif({ id: 901 }), title_params: {}, text_params: {}, is_read: false },
+          { ...buildRawNotif({ id: 902 }), title_params: {}, text_params: {}, is_read: false },
+          { ...buildRawNotif({ id: 903 }), title_params: {}, text_params: {}, is_read: false },
+        ] as never,
+        total: 3,
+      });
+
+      await useInAppNotificationStore.getState().fetchNotifications(true);
+      const state = useInAppNotificationStore.getState();
+
+      // Should not contain seeded IDs
+      expect(state.notifications.find(n => n.id === 901)).toBeUndefined();
+      expect(state.notifications.find(n => n.id === 902)).toBeUndefined();
+      expect(state.notifications.find(n => n.id === 903)).toBeUndefined();
+      // Should contain data from MSW (IDs 1-20)
+      expect(state.notifications.length).toBe(20);
+      expect(state.isLoading).toBe(false);
+    });
+  });
+
+  describe('FE-STORE-NOTIF-009: hasMore is set correctly', () => {
+    it('hasMore is true when more items exist, false when all loaded', async () => {
+      // Default MSW returns 25 total, 20 per page
+      await useInAppNotificationStore.getState().fetchNotifications(true);
+      expect(useInAppNotificationStore.getState().hasMore).toBe(true);
+
+      // Second page: offset=20, returns 5 items, total=25 => 25 >= 25 => hasMore=false
+      await useInAppNotificationStore.getState().fetchNotifications();
+      expect(useInAppNotificationStore.getState().hasMore).toBe(false);
+    });
+  });
+
+  describe('FE-STORE-NOTIF-010: fetchUnreadCount updates unreadCount', () => {
+    it('sets unreadCount from server response', async () => {
+      useInAppNotificationStore.setState({ unreadCount: 0 });
+
+      await useInAppNotificationStore.getState().fetchUnreadCount();
+      expect(useInAppNotificationStore.getState().unreadCount).toBe(5);
+    });
+  });
+
+  describe('FE-STORE-NOTIF-011: markUnread(id)', () => {
+    it('sets is_read to false and increments unreadCount', async () => {
+      useInAppNotificationStore.setState({
+        notifications: [{ ...buildRawNotif({ id: 50, is_read: 1 }), title_params: {}, text_params: {}, is_read: true }] as never,
+        unreadCount: 0,
+      });
+
+      await useInAppNotificationStore.getState().markUnread(50);
+      const state = useInAppNotificationStore.getState();
+
+      expect(state.notifications.find(n => n.id === 50)?.is_read).toBe(false);
+      expect(state.unreadCount).toBe(1);
+    });
+  });
+
+  describe('FE-STORE-NOTIF-012: markAllRead()', () => {
+    it('marks all notifications as read and sets unreadCount to 0', async () => {
+      useInAppNotificationStore.setState({
+        notifications: [
+          { ...buildRawNotif({ id: 60 }), title_params: {}, text_params: {}, is_read: false },
+          { ...buildRawNotif({ id: 61 }), title_params: {}, text_params: {}, is_read: false },
+          { ...buildRawNotif({ id: 62 }), title_params: {}, text_params: {}, is_read: false },
+        ] as never,
+        unreadCount: 3,
+      });
+
+      await useInAppNotificationStore.getState().markAllRead();
+      const state = useInAppNotificationStore.getState();
+
+      expect(state.notifications.every(n => n.is_read === true)).toBe(true);
+      expect(state.unreadCount).toBe(0);
+    });
+  });
+
+  describe('FE-STORE-NOTIF-013: deleteNotification removes unread item and decrements counts', () => {
+    it('removes notification and decrements total and unreadCount', async () => {
+      useInAppNotificationStore.setState({
+        notifications: [{ ...buildRawNotif({ id: 5 }), title_params: {}, text_params: {}, is_read: false }] as never,
+        total: 3,
+        unreadCount: 1,
+      });
+
+      await useInAppNotificationStore.getState().deleteNotification(5);
+      const state = useInAppNotificationStore.getState();
+
+      expect(state.notifications.find(n => n.id === 5)).toBeUndefined();
+      expect(state.total).toBe(2);
+      expect(state.unreadCount).toBe(0);
+    });
+  });
+
+  describe('FE-STORE-NOTIF-014: deleteNotification on read item does not decrement unreadCount', () => {
+    it('decrements total but not unreadCount', async () => {
+      useInAppNotificationStore.setState({
+        notifications: [{ ...buildRawNotif({ id: 6, is_read: 1 }), title_params: {}, text_params: {}, is_read: true }] as never,
+        total: 2,
+        unreadCount: 0,
+      });
+
+      await useInAppNotificationStore.getState().deleteNotification(6);
+      const state = useInAppNotificationStore.getState();
+
+      expect(state.total).toBe(1);
+      expect(state.unreadCount).toBe(0);
+    });
+  });
+
+  describe('FE-STORE-NOTIF-015: deleteAll clears all state', () => {
+    it('resets notifications, total, unreadCount, and hasMore', async () => {
+      useInAppNotificationStore.setState({
+        notifications: [
+          { ...buildRawNotif({ id: 70 }), title_params: {}, text_params: {}, is_read: false },
+          { ...buildRawNotif({ id: 71 }), title_params: {}, text_params: {}, is_read: false },
+        ] as never,
+        total: 2,
+        unreadCount: 2,
+        hasMore: true,
+      });
+
+      await useInAppNotificationStore.getState().deleteAll();
+      const state = useInAppNotificationStore.getState();
+
+      expect(state.notifications).toEqual([]);
+      expect(state.total).toBe(0);
+      expect(state.unreadCount).toBe(0);
+      expect(state.hasMore).toBe(false);
+    });
+  });
+
+  describe('FE-STORE-NOTIF-016: respondToBoolean updates notification', () => {
+    it('updates response and is_read from server', async () => {
+      useInAppNotificationStore.setState({
+        notifications: [{
+          ...buildRawNotif({ id: 10, type: 'boolean' }),
+          title_params: {},
+          text_params: {},
+          is_read: false,
+        }] as never,
+        unreadCount: 1,
+      });
+
+      await useInAppNotificationStore.getState().respondToBoolean(10, 'positive');
+      const state = useInAppNotificationStore.getState();
+
+      const notif = state.notifications.find(n => n.id === 10);
+      expect(notif?.response).toBe('positive');
+      expect(notif?.is_read).toBe(true);
+    });
+  });
+
+  describe('FE-STORE-NOTIF-017: normalizeNotification coerces stringified params', () => {
+    it('parses JSON string params into objects', () => {
+      const raw = buildRawNotif({
+        id: 200,
+        title_params: '{"trip":"Rome"}',
+        text_params: '{"user":"alice"}',
+      });
+
+      useInAppNotificationStore.getState().handleNewNotification(raw as never);
+      const notif = useInAppNotificationStore.getState().notifications.find(n => n.id === 200);
+
+      expect(notif?.title_params).toEqual({ trip: 'Rome' });
+      expect(notif?.text_params).toEqual({ user: 'alice' });
+    });
+  });
+
+  describe('FE-STORE-NOTIF-018: normalizeNotification handles already-parsed params', () => {
+    it('stores object params without error', () => {
+      const raw = buildRawNotif({
+        id: 201,
+        title_params: {},
+        text_params: { key: 'value' },
+      });
+
+      expect(() => {
+        useInAppNotificationStore.getState().handleNewNotification(raw as never);
+      }).not.toThrow();
+
+      const notif = useInAppNotificationStore.getState().notifications.find(n => n.id === 201);
+      expect(notif?.title_params).toEqual({});
+      expect(notif?.text_params).toEqual({ key: 'value' });
+    });
+  });
+
+  describe('FE-STORE-NOTIF-019: fetchUnreadCount is best-effort', () => {
+    it('does not throw on server error and preserves state', async () => {
+      useInAppNotificationStore.setState({ unreadCount: 3 });
+
+      server.use(
+        http.get('/api/notifications/in-app/unread-count', () => {
+          return new HttpResponse(null, { status: 500 });
+        }),
+      );
+
+      await expect(useInAppNotificationStore.getState().fetchUnreadCount()).resolves.not.toThrow();
+      expect(useInAppNotificationStore.getState().unreadCount).toBe(3);
+    });
+  });
+});
diff --git a/client/tests/unit/stores/permissionsStore.test.ts b/client/tests/unit/stores/permissionsStore.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7f5f88aa314c3d032189f149db104d31c3e3495b
--- /dev/null
+++ b/client/tests/unit/stores/permissionsStore.test.ts
@@ -0,0 +1,110 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { renderHook } from '@testing-library/react';
+import { usePermissionsStore, useCanDo } from '../../../src/store/permissionsStore';
+import { useAuthStore } from '../../../src/store/authStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildUser, buildAdmin } from '../../helpers/factories';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('permissionsStore', () => {
+  describe('FE-PERMS-001: setPermissions()', () => {
+    it('stores the permission map', () => {
+      const perms = { trip_create: 'everybody', file_upload: 'trip_member' } as const;
+      usePermissionsStore.getState().setPermissions(perms);
+
+      expect(usePermissionsStore.getState().permissions).toEqual(perms);
+    });
+  });
+
+  describe('FE-PERMS-002: useCanDo() — basic allow/deny', () => {
+    it('returns false when user is not authenticated', () => {
+      usePermissionsStore.getState().setPermissions({ trip_create: 'everybody' });
+
+      const { result } = renderHook(() => useCanDo());
+      expect(result.current('trip_create')).toBe(false);
+    });
+
+    it('returns true for "everybody" when user is authenticated', () => {
+      useAuthStore.setState({ user: buildUser(), isAuthenticated: true });
+      usePermissionsStore.getState().setPermissions({ trip_create: 'everybody' });
+
+      const { result } = renderHook(() => useCanDo());
+      expect(result.current('trip_create')).toBe(true);
+    });
+
+    it('returns true when action has no configured permission (default allow)', () => {
+      useAuthStore.setState({ user: buildUser(), isAuthenticated: true });
+      usePermissionsStore.getState().setPermissions({});
+
+      const { result } = renderHook(() => useCanDo());
+      expect(result.current('unconfigured_action')).toBe(true);
+    });
+  });
+
+  describe('Admin user', () => {
+    it('can do anything regardless of configured permissions', () => {
+      useAuthStore.setState({ user: buildAdmin(), isAuthenticated: true });
+      usePermissionsStore.getState().setPermissions({ restricted_action: 'admin' });
+
+      const { result } = renderHook(() => useCanDo());
+      expect(result.current('restricted_action')).toBe(true);
+    });
+  });
+
+  describe('Owner permissions', () => {
+    it('trip_owner level: owner can act, member cannot', () => {
+      const user = buildUser({ id: 42 });
+      useAuthStore.setState({ user, isAuthenticated: true });
+      usePermissionsStore.getState().setPermissions({ delete_trip: 'trip_owner' });
+
+      const { result } = renderHook(() => useCanDo());
+      const trip = { owner_id: 42 };      // user is owner
+      const otherTrip = { owner_id: 99 }; // user is not owner
+
+      expect(result.current('delete_trip', trip)).toBe(true);
+      expect(result.current('delete_trip', otherTrip)).toBe(false);
+    });
+
+    it('trip_owner level: is_owner flag grants access', () => {
+      const user = buildUser({ id: 1 });
+      useAuthStore.setState({ user, isAuthenticated: true });
+      usePermissionsStore.getState().setPermissions({ delete_trip: 'trip_owner' });
+
+      const { result } = renderHook(() => useCanDo());
+      expect(result.current('delete_trip', { is_owner: true })).toBe(true);
+      expect(result.current('delete_trip', { is_owner: false })).toBe(false);
+    });
+  });
+
+  describe('Member permissions', () => {
+    it('trip_member level: members and owners can act, unauthenticated trip context cannot', () => {
+      const user = buildUser({ id: 1 });
+      useAuthStore.setState({ user, isAuthenticated: true });
+      usePermissionsStore.getState().setPermissions({ upload_file: 'trip_member' });
+
+      const { result } = renderHook(() => useCanDo());
+      const asOwner = { owner_id: 1 };       // user is owner
+      const asMember = { owner_id: 99 };     // user is member (trip context provided, not owner)
+      const noTrip = null;                   // no trip context
+
+      expect(result.current('upload_file', asOwner)).toBe(true);
+      expect(result.current('upload_file', asMember)).toBe(true);
+      expect(result.current('upload_file', noTrip)).toBe(false);
+    });
+  });
+
+  describe('Nobody / admin-only level', () => {
+    it('admin level: regular user is denied even as trip owner', () => {
+      const user = buildUser({ id: 1 });
+      useAuthStore.setState({ user, isAuthenticated: true });
+      usePermissionsStore.getState().setPermissions({ admin_action: 'admin' });
+
+      const { result } = renderHook(() => useCanDo());
+      expect(result.current('admin_action', { owner_id: 1 })).toBe(false);
+      expect(result.current('admin_action')).toBe(false);
+    });
+  });
+});
diff --git a/client/tests/unit/stores/settingsStore.test.ts b/client/tests/unit/stores/settingsStore.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cc020f5ffa2aed7203d568a2800af6cf7e790541
--- /dev/null
+++ b/client/tests/unit/stores/settingsStore.test.ts
@@ -0,0 +1,219 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../helpers/msw/server';
+import { useSettingsStore } from '../../../src/store/settingsStore';
+import { resetAllStores } from '../../helpers/store';
+import { buildSettings } from '../../helpers/factories';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('settingsStore', () => {
+  describe('FE-SETTINGS-001: loadSettings()', () => {
+    it('fetches settings and updates store', async () => {
+      const settings = buildSettings({ default_currency: 'EUR', language: 'de' });
+      server.use(
+        http.get('/api/settings', () => HttpResponse.json({ settings }))
+      );
+
+      await useSettingsStore.getState().loadSettings();
+      const state = useSettingsStore.getState();
+
+      expect(state.settings.default_currency).toBe('EUR');
+      expect(state.settings.language).toBe('de');
+      expect(state.isLoaded).toBe(true);
+    });
+  });
+
+  describe('FE-SETTINGS-002: updateSetting() optimistic update', () => {
+    it('immediately updates local state before API resolves', async () => {
+      // The store's set() is called synchronously before the first await (settingsApi.set)
+      // so state is visible without needing to await the full action.
+      const promise = useSettingsStore.getState().updateSetting('default_currency', 'GBP');
+
+      // Check optimistic state — no await needed here
+      expect(useSettingsStore.getState().settings.default_currency).toBe('GBP');
+
+      // Let the API call finish to avoid dangling promises
+      await promise;
+    });
+  });
+
+  describe('FE-SETTINGS-003: updateSetting() reverts on API failure', () => {
+    it('throws when API fails', async () => {
+      server.use(
+        http.put('/api/settings', () =>
+          HttpResponse.json({ error: 'Server error' }, { status: 500 })
+        )
+      );
+
+      // The store optimistically sets, then throws — the revert is a throw
+      await expect(
+        useSettingsStore.getState().updateSetting('default_currency', 'GBP')
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('FE-SETTINGS-004: Language change', () => {
+    it('updates language field and localStorage', async () => {
+      await useSettingsStore.getState().updateSetting('language', 'fr');
+
+      const state = useSettingsStore.getState();
+      expect(state.settings.language).toBe('fr');
+      expect(localStorage.getItem('app_language')).toBe('fr');
+    });
+  });
+
+  describe('FE-SETTINGS-005: loadSettings failure', () => {
+    it('sets isLoaded: true even on API failure (graceful)', async () => {
+      server.use(
+        http.get('/api/settings', () =>
+          HttpResponse.json({ error: 'Server error' }, { status: 500 })
+        )
+      );
+
+      await useSettingsStore.getState().loadSettings();
+      const state = useSettingsStore.getState();
+
+      expect(state.isLoaded).toBe(true);
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-006: setLanguageLocal updates state and localStorage', () => {
+    it('sets language in state and localStorage without an API call', () => {
+      useSettingsStore.getState().setLanguageLocal('ja');
+
+      const state = useSettingsStore.getState();
+      expect(state.settings.language).toBe('ja');
+      expect(localStorage.getItem('app_language')).toBe('ja');
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-007: setLanguageLocal without prior localStorage value', () => {
+    it('writes to localStorage even when no prior value exists', () => {
+      localStorage.clear();
+
+      useSettingsStore.getState().setLanguageLocal('ko');
+
+      const state = useSettingsStore.getState();
+      expect(state.settings.language).toBe('ko');
+      expect(localStorage.getItem('app_language')).toBe('ko');
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-008: updateSettings bulk update', () => {
+    it('updates multiple settings keys and calls bulk API', async () => {
+      await useSettingsStore.getState().updateSettings({ dark_mode: true, default_currency: 'JPY' });
+
+      const state = useSettingsStore.getState();
+      expect(state.settings.dark_mode).toBe(true);
+      expect(state.settings.default_currency).toBe('JPY');
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-009: updateSettings optimistic update', () => {
+    it('updates state synchronously before API resolves', async () => {
+      const promise = useSettingsStore.getState().updateSettings({ dark_mode: true });
+
+      expect(useSettingsStore.getState().settings.dark_mode).toBe(true);
+
+      await promise;
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-010: updateSettings API failure throws', () => {
+    it('throws when bulk API returns 500', async () => {
+      server.use(
+        http.post('/api/settings/bulk', () =>
+          HttpResponse.json({ error: 'Server error' }, { status: 500 })
+        )
+      );
+
+      await expect(
+        useSettingsStore.getState().updateSettings({ dark_mode: true })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-011: updateSetting non-language key does not write to localStorage', () => {
+    it('does not modify app_language in localStorage', async () => {
+      const before = localStorage.getItem('app_language');
+
+      await useSettingsStore.getState().updateSetting('dark_mode', true);
+
+      expect(localStorage.getItem('app_language')).toBe(before);
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-012: loadSettings merges server values with defaults', () => {
+    it('preserves default keys not returned by server', async () => {
+      server.use(
+        http.get('/api/settings', () =>
+          HttpResponse.json({ settings: { dark_mode: true } })
+        )
+      );
+
+      await useSettingsStore.getState().loadSettings();
+
+      const state = useSettingsStore.getState();
+      expect(state.settings.dark_mode).toBe(true);
+      expect(state.settings.default_currency).toBe('USD');
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-013: updateSetting for time_format', () => {
+    it('updates time_format in state', async () => {
+      await useSettingsStore.getState().updateSetting('time_format', '24h');
+
+      expect(useSettingsStore.getState().settings.time_format).toBe('24h');
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-015: setLanguageTransient updates state without touching localStorage', () => {
+    it('sets language in state but does not write to localStorage', () => {
+      localStorage.clear();
+
+      useSettingsStore.getState().setLanguageTransient('fr');
+
+      expect(useSettingsStore.getState().settings.language).toBe('fr');
+      expect(localStorage.getItem('app_language')).toBeNull();
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-016: setLanguageTransient rejects unsupported language code', () => {
+    it('leaves state unchanged for an unknown code', () => {
+      const before = useSettingsStore.getState().settings.language;
+
+      useSettingsStore.getState().setLanguageTransient('xx');
+
+      expect(useSettingsStore.getState().settings.language).toBe(before);
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-017: setLanguageTransient does not overwrite an explicit localStorage choice', () => {
+    it('localStorage remains unchanged after a transient set', () => {
+      localStorage.setItem('app_language', 'de');
+
+      useSettingsStore.getState().setLanguageTransient('es');
+
+      expect(localStorage.getItem('app_language')).toBe('de');
+    });
+  });
+
+  describe('FE-STORE-SETTINGS-014: updateSetting API failure leaves optimistic state', () => {
+    it('throws on API failure but keeps the optimistic state', async () => {
+      server.use(
+        http.put('/api/settings', () =>
+          HttpResponse.json({ error: 'Server error' }, { status: 500 })
+        )
+      );
+
+      await expect(
+        useSettingsStore.getState().updateSetting('default_zoom', 15)
+      ).rejects.toThrow();
+
+      expect(useSettingsStore.getState().settings.default_zoom).toBe(15);
+    });
+  });
+});
diff --git a/client/tests/unit/stores/vacayStore.test.ts b/client/tests/unit/stores/vacayStore.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..261c558be2c3770d0654195e7b62b53771628257
--- /dev/null
+++ b/client/tests/unit/stores/vacayStore.test.ts
@@ -0,0 +1,404 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { server } from '../../helpers/msw/server';
+import { useVacayStore } from '../../../src/store/vacayStore';
+import { resetAllStores } from '../../helpers/store';
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+describe('vacayStore', () => {
+  describe('FE-VACAY-001: loadAll()', () => {
+    it('fetches plan, years, entries, and stats, updates state', async () => {
+      await useVacayStore.getState().loadAll();
+      const state = useVacayStore.getState();
+
+      expect(state.plan).not.toBeNull();
+      expect(state.plan?.id).toBe(1);
+      expect(state.years).toEqual([2025, 2026]);
+      expect(state.entries.length).toBeGreaterThan(0);
+      expect(state.stats.length).toBeGreaterThan(0);
+      expect(state.loading).toBe(false);
+    });
+  });
+
+  describe('FE-VACAY-002: toggleEntry()', () => {
+    it('calls the toggle API then reloads entries and stats', async () => {
+      // Seed selected year
+      useVacayStore.setState({ selectedYear: 2025 });
+
+      let toggled = false;
+      server.use(
+        http.post('/api/addons/vacay/entries/toggle', () => {
+          toggled = true;
+          return HttpResponse.json({ success: true });
+        })
+      );
+
+      await useVacayStore.getState().toggleEntry('2025-06-20');
+
+      expect(toggled).toBe(true);
+      // After toggle, entries are refreshed from MSW (2 entries)
+      expect(useVacayStore.getState().entries.length).toBe(2);
+    });
+  });
+
+  describe('FE-VACAY-003: loadHolidays() — holidays_enabled with calendars', () => {
+    it('populates holidays map when plan has holiday calendars', async () => {
+      // Set plan state with holidays_enabled and a simple (non-regional) calendar
+      useVacayStore.setState({
+        selectedYear: 2025,
+        plan: {
+          id: 1,
+          holidays_enabled: true,
+          holidays_region: null,
+          holiday_calendars: [
+            { id: 1, plan_id: 1, region: 'DE', label: 'Germany', color: '#ef4444', sort_order: 0 },
+          ],
+          block_weekends: true,
+          carry_over_enabled: false,
+          company_holidays_enabled: false,
+        },
+      });
+
+      // Override MSW to return non-regional holidays (no counties)
+      server.use(
+        http.get('/api/addons/vacay/holidays/:year/:country', () =>
+          HttpResponse.json([
+            { date: '2025-12-25', name: 'Christmas', localName: 'Weihnachten', global: true, counties: null },
+            { date: '2025-01-01', name: 'New Year', localName: 'Neujahr', global: true, counties: null },
+          ])
+        )
+      );
+
+      await useVacayStore.getState().loadHolidays(2025);
+      const state = useVacayStore.getState();
+
+      expect(Object.keys(state.holidays).length).toBeGreaterThan(0);
+      expect(state.holidays['2025-12-25']).toBeDefined();
+      expect(state.holidays['2025-12-25'].name).toBe('Christmas');
+    });
+  });
+
+  describe('FE-VACAY-003b: loadHolidays() — holidays not enabled', () => {
+    it('sets holidays to empty map when holidays_enabled is false', async () => {
+      useVacayStore.setState({
+        selectedYear: 2025,
+        plan: {
+          id: 1,
+          holidays_enabled: false,
+          holidays_region: null,
+          holiday_calendars: [],
+          block_weekends: true,
+          carry_over_enabled: false,
+          company_holidays_enabled: false,
+        },
+      });
+
+      await useVacayStore.getState().loadHolidays(2025);
+      expect(useVacayStore.getState().holidays).toEqual({});
+    });
+  });
+
+  describe('FE-VACAY-004a: updatePlan()', () => {
+    it('updates plan and reloads entries, stats, holidays', async () => {
+      // Need existing plan for holiday check in loadHolidays
+      useVacayStore.setState({
+        selectedYear: 2025,
+        plan: {
+          id: 1,
+          holidays_enabled: false,
+          holidays_region: null,
+          holiday_calendars: [],
+          block_weekends: true,
+          carry_over_enabled: false,
+          company_holidays_enabled: false,
+        },
+      });
+
+      await useVacayStore.getState().updatePlan({ holidays_enabled: true });
+      const state = useVacayStore.getState();
+
+      // The MSW handler for PUT /addons/vacay/plan returns holidays_enabled: true
+      expect(state.plan?.holidays_enabled).toBe(true);
+    });
+  });
+
+  describe('FE-VACAY-004b: addYear()', () => {
+    it('adds a year and the years list is updated', async () => {
+      await useVacayStore.getState().addYear(2027);
+      expect(useVacayStore.getState().years).toContain(2027);
+    });
+  });
+
+  describe('FE-VACAY-004c: removeYear()', () => {
+    it('removes a year and updates the years list', async () => {
+      useVacayStore.setState({ years: [2025, 2026], selectedYear: 2026 });
+
+      await useVacayStore.getState().removeYear(2026);
+      const state = useVacayStore.getState();
+
+      // MSW returns [2025] after delete
+      expect(state.years).toEqual([2025]);
+      // selectedYear should shift to the last remaining year
+      expect(state.selectedYear).toBe(2025);
+    });
+  });
+
+  describe('FE-STORE-VACAY-005: setSelectedYear and setSelectedUserId', () => {
+    it('updates selectedYear state', () => {
+      useVacayStore.getState().setSelectedYear(2028);
+      expect(useVacayStore.getState().selectedYear).toBe(2028);
+    });
+
+    it('updates selectedUserId state', () => {
+      useVacayStore.getState().setSelectedUserId(42);
+      expect(useVacayStore.getState().selectedUserId).toBe(42);
+    });
+
+    it('sets selectedUserId to null', () => {
+      useVacayStore.setState({ selectedUserId: 42 });
+      useVacayStore.getState().setSelectedUserId(null);
+      expect(useVacayStore.getState().selectedUserId).toBeNull();
+    });
+  });
+
+  describe('FE-STORE-VACAY-006: loadEntries() uses selectedYear when no year arg', () => {
+    it('falls back to selectedYear when called without argument', async () => {
+      useVacayStore.setState({ selectedYear: 2025 });
+      await useVacayStore.getState().loadEntries();
+      expect(useVacayStore.getState().entries.length).toBe(2);
+    });
+  });
+
+  describe('FE-STORE-VACAY-007: loadStats() uses selectedYear when no year arg', () => {
+    it('falls back to selectedYear when called without argument', async () => {
+      useVacayStore.setState({ selectedYear: 2025 });
+      await useVacayStore.getState().loadStats();
+      expect(useVacayStore.getState().stats.length).toBe(1);
+    });
+  });
+
+  describe('FE-STORE-VACAY-008: invite()', () => {
+    it('calls invite API and reloads plan', async () => {
+      let inviteCalled = false;
+      server.use(
+        http.post('/api/addons/vacay/invite', () => {
+          inviteCalled = true;
+          return HttpResponse.json({ success: true });
+        })
+      );
+
+      await useVacayStore.getState().invite(5);
+      const state = useVacayStore.getState();
+
+      expect(inviteCalled).toBe(true);
+      expect(state.plan).not.toBeNull();
+      expect(state.plan?.id).toBe(1);
+    });
+  });
+
+  describe('FE-STORE-VACAY-009: declineInvite()', () => {
+    it('calls decline API and reloads plan', async () => {
+      await useVacayStore.getState().declineInvite(2);
+      expect(useVacayStore.getState().plan?.id).toBe(1);
+    });
+  });
+
+  describe('FE-STORE-VACAY-010: cancelInvite()', () => {
+    it('calls cancel API and reloads plan', async () => {
+      await useVacayStore.getState().cancelInvite(3);
+      const state = useVacayStore.getState();
+      expect(state.plan).not.toBeNull();
+      expect(state.plan?.id).toBe(1);
+    });
+  });
+
+  describe('FE-STORE-VACAY-011: acceptInvite()', () => {
+    it('calls loadAll after accepting invite', async () => {
+      await useVacayStore.getState().acceptInvite(1);
+      const state = useVacayStore.getState();
+
+      expect(state.plan).not.toBeNull();
+      expect(state.years).toEqual([2025, 2026]);
+      expect(state.loading).toBe(false);
+    });
+  });
+
+  describe('FE-STORE-VACAY-012: dissolve()', () => {
+    it('calls loadAll after dissolving', async () => {
+      await useVacayStore.getState().dissolve();
+      const state = useVacayStore.getState();
+
+      expect(state.plan).not.toBeNull();
+      expect(state.loading).toBe(false);
+    });
+  });
+
+  describe('FE-STORE-VACAY-013: updateColor()', () => {
+    it('reloads plan and entries after updating color', async () => {
+      server.use(
+        http.put('/api/addons/vacay/color', () =>
+          HttpResponse.json({ success: true })
+        )
+      );
+
+      await useVacayStore.getState().updateColor('#ff0000');
+      const state = useVacayStore.getState();
+
+      expect(state.plan?.id).toBe(1);
+      expect(state.entries.length).toBe(2);
+    });
+  });
+
+  describe('FE-STORE-VACAY-014: toggleCompanyHoliday()', () => {
+    it('reloads entries and stats after toggling company holiday', async () => {
+      useVacayStore.setState({ selectedYear: 2025 });
+
+      server.use(
+        http.post('/api/addons/vacay/entries/company-holiday', () =>
+          HttpResponse.json({ success: true })
+        )
+      );
+
+      await useVacayStore.getState().toggleCompanyHoliday('2025-12-26');
+      const state = useVacayStore.getState();
+
+      expect(state.entries.length).toBe(2);
+      expect(state.stats.length).toBe(1);
+    });
+  });
+
+  describe('FE-STORE-VACAY-015: updateVacationDays()', () => {
+    it('reloads stats for the given year', async () => {
+      await useVacayStore.getState().updateVacationDays(2025, 25);
+      expect(useVacayStore.getState().stats.length).toBe(1);
+    });
+  });
+
+  describe('FE-STORE-VACAY-016: removeYear() when selectedYear is not the removed year', () => {
+    it('does not change selectedYear when a different year is removed', async () => {
+      useVacayStore.setState({ years: [2025, 2026], selectedYear: 2025 });
+
+      await useVacayStore.getState().removeYear(2026);
+      const state = useVacayStore.getState();
+
+      expect(state.years).toEqual([2025]);
+      expect(state.selectedYear).toBe(2025);
+    });
+  });
+
+  describe('FE-STORE-VACAY-017: addHolidayCalendar()', () => {
+    it('reloads plan and holidays after adding a holiday calendar', async () => {
+      server.use(
+        http.post('/api/addons/vacay/plan/holiday-calendars', () =>
+          HttpResponse.json({
+            calendar: { id: 1, plan_id: 1, region: 'DE', label: null, color: '#ef4444', sort_order: 0 },
+          })
+        )
+      );
+
+      await useVacayStore.getState().addHolidayCalendar({ region: 'DE', color: '#ef4444' });
+      expect(useVacayStore.getState().plan?.id).toBe(1);
+    });
+  });
+
+  describe('FE-STORE-VACAY-018: updateHolidayCalendar()', () => {
+    it('reloads plan and holidays after updating a holiday calendar', async () => {
+      server.use(
+        http.put('/api/addons/vacay/plan/holiday-calendars/:id', () =>
+          HttpResponse.json({
+            calendar: { id: 1, plan_id: 1, region: 'US', label: 'US Holidays', color: '#3b82f6', sort_order: 0 },
+          })
+        )
+      );
+
+      await useVacayStore.getState().updateHolidayCalendar(1, { label: 'US Holidays' });
+      expect(useVacayStore.getState().plan?.id).toBe(1);
+    });
+  });
+
+  describe('FE-STORE-VACAY-019: deleteHolidayCalendar()', () => {
+    it('reloads plan and holidays after deleting a holiday calendar', async () => {
+      await useVacayStore.getState().deleteHolidayCalendar(1);
+      expect(useVacayStore.getState().plan?.id).toBe(1);
+    });
+  });
+
+  describe('FE-STORE-VACAY-020: loadHolidays() with regional calendar includes matching counties', () => {
+    it('includes holidays matching the region county and excludes non-matching ones', async () => {
+      useVacayStore.setState({
+        selectedYear: 2025,
+        plan: {
+          id: 1,
+          holidays_enabled: true,
+          holidays_region: null,
+          holiday_calendars: [
+            { id: 1, plan_id: 1, region: 'DE-BY', label: null, color: '#ef4444', sort_order: 0 },
+          ],
+          block_weekends: false,
+          carry_over_enabled: false,
+          company_holidays_enabled: false,
+        },
+      });
+
+      server.use(
+        http.get('/api/addons/vacay/holidays/:year/:country', () =>
+          HttpResponse.json([
+            { date: '2025-11-01', name: 'All Saints Day', localName: 'Allerheiligen', global: false, counties: ['DE-BY', 'DE-BW'] },
+            { date: '2025-08-15', name: 'Assumption Day', localName: 'Mariä Himmelfahrt', global: false, counties: ['DE-BY'] },
+            { date: '2025-03-19', name: 'St. Joseph', localName: 'Sankt Joseph', global: false, counties: ['DE-NW'] },
+          ])
+        )
+      );
+
+      await useVacayStore.getState().loadHolidays(2025);
+      const holidays = useVacayStore.getState().holidays;
+
+      // DE-BY holidays should be included
+      expect(holidays['2025-11-01']).toBeDefined();
+      expect(holidays['2025-08-15']).toBeDefined();
+      // DE-NW only holiday should be excluded
+      expect(holidays['2025-03-19']).toBeUndefined();
+    });
+  });
+
+  describe('FE-STORE-VACAY-021: loadHolidays() skips regional calendar when data has no county breakdown', () => {
+    it('results in empty holidays map when all entries are global (no counties)', async () => {
+      useVacayStore.setState({
+        selectedYear: 2025,
+        plan: {
+          id: 1,
+          holidays_enabled: true,
+          holidays_region: null,
+          holiday_calendars: [
+            { id: 1, plan_id: 1, region: 'DE-BY', label: null, color: '#ef4444', sort_order: 0 },
+          ],
+          block_weekends: false,
+          carry_over_enabled: false,
+          company_holidays_enabled: false,
+        },
+      });
+
+      server.use(
+        http.get('/api/addons/vacay/holidays/:year/:country', () =>
+          HttpResponse.json([
+            { date: '2025-12-25', name: 'Christmas', localName: 'Weihnachten', global: true, counties: null },
+            { date: '2025-01-01', name: 'New Year', localName: 'Neujahr', global: true, counties: null },
+          ])
+        )
+      );
+
+      await useVacayStore.getState().loadHolidays(2025);
+      // hasRegions is false (no counties), region is 'DE-BY' (non-null)
+      // so the condition `hasRegions && !region` is false → proceeds to county filter
+      // h.global is true → all holidays are included despite region filter
+      // Actually: global=true entries are included by the `h.global` check in the forEach
+      // The test verifies behavior when counties: null + global: true
+      const holidays = useVacayStore.getState().holidays;
+      // Global holidays are included even for regional calendars when counties data is absent
+      expect(holidays['2025-12-25']).toBeDefined();
+    });
+  });
+});
diff --git a/client/tests/unit/sync/mutationQueue.test.ts b/client/tests/unit/sync/mutationQueue.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8e7868acf3cdbeb80a4da1c9d8d4cf7eef16f63f
--- /dev/null
+++ b/client/tests/unit/sync/mutationQueue.test.ts
@@ -0,0 +1,464 @@
+/**
+ * mutationQueue unit tests.
+ *
+ * Covers: enqueue, flush (2xx success, 4xx fail, network error), idempotency header,
+ * pending count, create temp-id reconciliation, delete Dexie cleanup.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import 'fake-indexeddb/auto';
+import { server } from '../../helpers/msw/server';
+import { http, HttpResponse } from 'msw';
+import { setAuthed } from '../../../src/sync/authGate';
+import { mutationQueue, generateUUID, nextTempId } from '../../../src/sync/mutationQueue';
+import { offlineDb, clearAll } from '../../../src/db/offlineDb';
+import { placeRepo } from '../../../src/repo/placeRepo';
+import { buildPlace, buildPackingItem } from '../../helpers/factories';
+
+beforeEach(async () => {
+  await clearAll();
+  mutationQueue._resetFlushing();
+  setAuthed(true);
+  Object.defineProperty(navigator, 'onLine', { value: true, writable: true, configurable: true });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  setAuthed(false);
+});
+
+// ── helpers ──────────────────────────────────────────────────────────────────
+
+function makeMutation(overrides: Partial<Parameters<typeof mutationQueue.enqueue>[0]> = {}) {
+  return {
+    id: generateUUID(),
+    tripId: 1,
+    method: 'POST' as const,
+    url: '/trips/1/places',
+    body: { name: 'Eiffel Tower' },
+    resource: 'places',
+    ...overrides,
+  };
+}
+
+// ── enqueue ───────────────────────────────────────────────────────────────────
+
+describe('mutationQueue.enqueue', () => {
+  it('stores mutation with pending status', async () => {
+    const id = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id }));
+
+    const stored = await offlineDb.mutationQueue.get(id);
+    expect(stored).toBeDefined();
+    expect(stored!.status).toBe('pending');
+    expect(stored!.attempts).toBe(0);
+  });
+
+  it('returns the mutation id', async () => {
+    const id = generateUUID();
+    const returned = await mutationQueue.enqueue(makeMutation({ id }));
+    expect(returned).toBe(id);
+  });
+});
+
+// ── flush — success path ──────────────────────────────────────────────────────
+
+describe('mutationQueue.flush — 2xx success', () => {
+  it('removes mutation from queue and writes canonical entity to Dexie', async () => {
+    const place = buildPlace({ trip_id: 1, id: 42 });
+    const id = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id }));
+
+    server.use(
+      http.post('/api/trips/1/places', () => HttpResponse.json({ place })),
+    );
+
+    await mutationQueue.flush();
+
+    const queued = await offlineDb.mutationQueue.get(id);
+    expect(queued).toBeUndefined();
+
+    const cached = await offlineDb.places.get(42);
+    expect(cached).toBeDefined();
+    expect(cached!.name).toBe(place.name);
+  });
+
+  it('attaches X-Idempotency-Key header matching the mutation id', async () => {
+    const place = buildPlace({ trip_id: 1 });
+    const id = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id }));
+
+    let capturedKey: string | null = null;
+    server.use(
+      http.post('/api/trips/1/places', ({ request }) => {
+        capturedKey = request.headers.get('X-Idempotency-Key');
+        return HttpResponse.json({ place });
+      }),
+    );
+
+    await mutationQueue.flush();
+    expect(capturedKey).toBe(id);
+  });
+
+  it('removes temp entry and adds canonical entry on CREATE flush', async () => {
+    const tempId = -12345;
+    const place = buildPlace({ trip_id: 1, id: 99 });
+    const id = generateUUID();
+
+    // Optimistic temp entry in Dexie
+    await offlineDb.places.put({ ...place, id: tempId });
+
+    await mutationQueue.enqueue(makeMutation({ id, tempId }));
+
+    server.use(
+      http.post('/api/trips/1/places', () => HttpResponse.json({ place })),
+    );
+
+    await mutationQueue.flush();
+
+    expect(await offlineDb.places.get(tempId)).toBeUndefined();
+    expect(await offlineDb.places.get(99)).toBeDefined();
+  });
+
+  it('handles DELETE: removes entity from Dexie after flush', async () => {
+    const place = buildPlace({ trip_id: 1, id: 55 });
+    await offlineDb.places.put(place);
+
+    const id = generateUUID();
+    await mutationQueue.enqueue({
+      id,
+      tripId: 1,
+      method: 'DELETE',
+      url: '/trips/1/places/55',
+      body: undefined,
+      resource: 'places',
+      entityId: 55,
+    });
+
+    server.use(
+      http.delete('/api/trips/1/places/55', () => HttpResponse.json({ success: true })),
+    );
+
+    await mutationQueue.flush();
+
+    expect(await offlineDb.mutationQueue.get(id)).toBeUndefined();
+    expect(await offlineDb.places.get(55)).toBeUndefined();
+  });
+});
+
+// ── flush — error paths ───────────────────────────────────────────────────────
+
+describe('mutationQueue.flush — 4xx client error', () => {
+  it('marks mutation as failed and continues to next mutation', async () => {
+    const id1 = generateUUID();
+    const id2 = generateUUID();
+    const place = buildPlace({ trip_id: 1 });
+
+    // Enqueue in order
+    await mutationQueue.enqueue(makeMutation({ id: id1 }));
+    await mutationQueue.enqueue(makeMutation({ id: id2 }));
+
+    let callCount = 0;
+    server.use(
+      http.post('/api/trips/1/places', () => {
+        callCount++;
+        if (callCount === 1) {
+          return HttpResponse.json({ error: 'Bad request' }, { status: 400 });
+        }
+        return HttpResponse.json({ place });
+      }),
+    );
+
+    await mutationQueue.flush();
+
+    const m1 = await offlineDb.mutationQueue.get(id1);
+    expect(m1).toBeDefined();
+    expect(m1!.status).toBe('failed');
+
+    // Second mutation succeeded and was removed
+    expect(await offlineDb.mutationQueue.get(id2)).toBeUndefined();
+  });
+});
+
+describe('mutationQueue.flush — network error', () => {
+  it('resets to pending and stops flush without marking failed', async () => {
+    const id = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id }));
+
+    server.use(
+      http.post('/api/trips/1/places', () => HttpResponse.error()),
+    );
+
+    await mutationQueue.flush();
+
+    const m = await offlineDb.mutationQueue.get(id);
+    expect(m).toBeDefined();
+    expect(m!.status).toBe('pending');
+    expect(m!.attempts).toBe(1);
+  });
+});
+
+// ── flush — offline guard ─────────────────────────────────────────────────────
+
+describe('mutationQueue.flush — offline guard', () => {
+  it('does nothing when offline', async () => {
+    Object.defineProperty(navigator, 'onLine', { value: false });
+    const id = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id }));
+
+    let called = false;
+    server.use(
+      http.post('/api/trips/1/places', () => {
+        called = true;
+        return HttpResponse.json({ place: buildPlace({ trip_id: 1 }) });
+      }),
+    );
+
+    await mutationQueue.flush();
+    expect(called).toBe(false);
+    const m = await offlineDb.mutationQueue.get(id);
+    expect(m!.status).toBe('pending');
+  });
+
+  it('does nothing when logged out (auth gate closed)', async () => {
+    setAuthed(false);
+    const id = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id }));
+
+    let called = false;
+    server.use(
+      http.post('/api/trips/1/places', () => {
+        called = true;
+        return HttpResponse.json({ place: buildPlace({ trip_id: 1 }) });
+      }),
+    );
+
+    await mutationQueue.flush();
+    expect(called).toBe(false);
+    const m = await offlineDb.mutationQueue.get(id);
+    expect(m!.status).toBe('pending');
+  });
+});
+
+// ── pending / pendingCount ────────────────────────────────────────────────────
+
+describe('mutationQueue.pending', () => {
+  it('returns pending mutations for a trip', async () => {
+    const id1 = generateUUID();
+    const id2 = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id: id1, tripId: 1 }));
+    await mutationQueue.enqueue(makeMutation({ id: id2, tripId: 2 }));
+
+    const trip1 = await mutationQueue.pending(1);
+    expect(trip1).toHaveLength(1);
+    expect(trip1[0].id).toBe(id1);
+  });
+
+  it('returns all pending when no tripId given', async () => {
+    await mutationQueue.enqueue(makeMutation({ id: generateUUID(), tripId: 1 }));
+    await mutationQueue.enqueue(makeMutation({ id: generateUUID(), tripId: 2 }));
+
+    const all = await mutationQueue.pending();
+    expect(all).toHaveLength(2);
+  });
+
+  it('excludes failed mutations', async () => {
+    const id = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id }));
+    await offlineDb.mutationQueue.update(id, { status: 'failed' });
+
+    const pending = await mutationQueue.pending(1);
+    expect(pending).toHaveLength(0);
+  });
+});
+
+describe('mutationQueue.pendingCount', () => {
+  it('returns zero for empty queue', async () => {
+    expect(await mutationQueue.pendingCount()).toBe(0);
+  });
+
+  it('counts pending and syncing, excludes failed', async () => {
+    const id1 = generateUUID();
+    const id2 = generateUUID();
+    const id3 = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id: id1 }));
+    await mutationQueue.enqueue(makeMutation({ id: id2 }));
+    await mutationQueue.enqueue(makeMutation({ id: id3 }));
+    await offlineDb.mutationQueue.update(id3, { status: 'failed' });
+
+    expect(await mutationQueue.pendingCount()).toBe(2);
+  });
+});
+
+describe('mutationQueue.failedCount', () => {
+  it('counts only failed mutations (not pending/syncing)', async () => {
+    const id1 = generateUUID();
+    const id2 = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id: id1 }));
+    await mutationQueue.enqueue(makeMutation({ id: id2 }));
+    await offlineDb.mutationQueue.update(id2, { status: 'failed' });
+
+    expect(await mutationQueue.failedCount()).toBe(1);
+    expect(await mutationQueue.pendingCount()).toBe(1);
+  });
+});
+
+// ── B2: collision-free temp ids ────────────────────────────────────────────────
+
+describe('nextTempId (B2)', () => {
+  it('returns distinct negative ids even within the same millisecond', () => {
+    mutationQueue._resetFlushing();
+    const a = nextTempId();
+    const b = nextTempId();
+    const c = nextTempId();
+    expect(a).toBeLessThan(0);
+    expect(new Set([a, b, c]).size).toBe(3);
+  });
+
+  it('two tight offline creates produce two distinct Dexie rows', async () => {
+    Object.defineProperty(navigator, 'onLine', { value: false });
+    await placeRepo.create(1, { name: 'First' });
+    await placeRepo.create(1, { name: 'Second' });
+
+    const rows = await offlineDb.places.where('trip_id').equals(1).toArray();
+    expect(rows).toHaveLength(2);
+    expect(rows.map(r => r.name).sort()).toEqual(['First', 'Second']);
+  });
+});
+
+// ── B1: temp-id → real-id remapping ─────────────────────────────────────────────
+
+describe('mutationQueue.flush — temp-id remapping (B1)', () => {
+  it('rewrites a dependent PUT/DELETE to the real id within one flush', async () => {
+    const tempId = -1;
+    await offlineDb.places.put({ ...buildPlace({ trip_id: 1 }), id: tempId });
+
+    const createId = generateUUID();
+    const putId = generateUUID();
+    const deleteId = generateUUID();
+
+    await mutationQueue.enqueue({
+      id: createId, tripId: 1, method: 'POST', url: '/trips/1/places',
+      body: { name: 'Temp' }, resource: 'places', tempId,
+    });
+    await mutationQueue.enqueue({
+      id: putId, tripId: 1, method: 'PUT', url: '/trips/1/places/{id}',
+      body: { name: 'Edited' }, resource: 'places', entityId: tempId, tempEntityId: tempId,
+    });
+    await mutationQueue.enqueue({
+      id: deleteId, tripId: 1, method: 'DELETE', url: '/trips/1/places/{id}',
+      body: undefined, resource: 'places', entityId: tempId, tempEntityId: tempId,
+    });
+
+    const putUrls: string[] = [];
+    const deleteUrls: string[] = [];
+    server.use(
+      http.post('/api/trips/1/places', () => HttpResponse.json({ place: buildPlace({ trip_id: 1, id: 42 }) })),
+      http.put('/api/trips/1/places/:id', ({ params }) => { putUrls.push(String(params.id)); return HttpResponse.json({ place: buildPlace({ trip_id: 1, id: 42, name: 'Edited' }) }); }),
+      http.delete('/api/trips/1/places/:id', ({ params }) => { deleteUrls.push(String(params.id)); return HttpResponse.json({ success: true }); }),
+    );
+
+    await mutationQueue.flush();
+
+    expect(putUrls).toEqual(['42']);
+    expect(deleteUrls).toEqual(['42']);
+    expect(await mutationQueue.pendingCount()).toBe(0);
+    expect(await mutationQueue.failedCount()).toBe(0);
+  });
+
+  it('durably rewrites a still-queued dependent after the CREATE flushes alone', async () => {
+    const tempId = -7;
+    await offlineDb.places.put({ ...buildPlace({ trip_id: 1 }), id: tempId });
+
+    const createId = generateUUID();
+    const putId = generateUUID();
+    await mutationQueue.enqueue({
+      id: createId, tripId: 1, method: 'POST', url: '/trips/1/places',
+      body: { name: 'Temp' }, resource: 'places', tempId,
+    });
+    await mutationQueue.enqueue({
+      id: putId, tripId: 1, method: 'PUT', url: '/trips/1/places/{id}',
+      body: { name: 'Edited' }, resource: 'places', entityId: tempId, tempEntityId: tempId,
+    });
+
+    // Only the CREATE succeeds this round; the PUT errors out (network) and stays queued.
+    let putAttempts = 0;
+    server.use(
+      http.post('/api/trips/1/places', () => HttpResponse.json({ place: buildPlace({ trip_id: 1, id: 88 }) })),
+      http.put('/api/trips/1/places/:id', () => { putAttempts++; return HttpResponse.error(); }),
+    );
+
+    await mutationQueue.flush();
+
+    const queuedPut = await offlineDb.mutationQueue.get(putId);
+    expect(queuedPut).toBeDefined();
+    expect(queuedPut!.url).toBe('/trips/1/places/88');
+    expect(queuedPut!.entityId).toBe(88);
+    expect(queuedPut!.tempEntityId).toBeUndefined();
+    expect(putAttempts).toBeGreaterThanOrEqual(1);
+  });
+
+  it('marks an orphaned dependent (placeholder never resolved) as failed', async () => {
+    const putId = generateUUID();
+    await mutationQueue.enqueue({
+      id: putId, tripId: 1, method: 'PUT', url: '/trips/1/places/{id}',
+      body: { name: 'Edited' }, resource: 'places', entityId: -999, tempEntityId: -999,
+    });
+
+    await mutationQueue.flush();
+
+    const m = await offlineDb.mutationQueue.get(putId);
+    expect(m!.status).toBe('failed');
+  });
+});
+
+// ── B3: terminal rollback + retryable classification ────────────────────────────
+
+describe('mutationQueue.flush — failure handling (B3)', () => {
+  it('rolls back the phantom optimistic row on a terminal 400 CREATE', async () => {
+    const tempId = -3;
+    await offlineDb.places.put({ ...buildPlace({ trip_id: 1 }), id: tempId });
+
+    const id = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id, tempId }));
+
+    server.use(
+      http.post('/api/trips/1/places', () => HttpResponse.json({ error: 'Bad' }, { status: 400 })),
+    );
+
+    await mutationQueue.flush();
+
+    expect(await offlineDb.places.get(tempId)).toBeUndefined();
+    const m = await offlineDb.mutationQueue.get(id);
+    expect(m!.status).toBe('failed');
+  });
+
+  it('treats 429 as retryable: resets to pending and stops the flush', async () => {
+    const id = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id }));
+
+    server.use(
+      http.post('/api/trips/1/places', () => HttpResponse.json({ error: 'slow down' }, { status: 429 })),
+    );
+
+    await mutationQueue.flush();
+
+    const m = await offlineDb.mutationQueue.get(id);
+    expect(m!.status).toBe('pending');
+    expect(m!.attempts).toBe(1);
+    expect(await mutationQueue.failedCount()).toBe(0);
+  });
+
+  it('treats 401 as retryable rather than dropping the change', async () => {
+    const id = generateUUID();
+    await mutationQueue.enqueue(makeMutation({ id }));
+
+    server.use(
+      http.post('/api/trips/1/places', () => HttpResponse.json({ error: 'AUTH_REQUIRED' }, { status: 401 })),
+    );
+
+    await mutationQueue.flush();
+
+    const m = await offlineDb.mutationQueue.get(id);
+    expect(m!.status).toBe('pending');
+  });
+});
diff --git a/client/tests/unit/sync/persistentStorage.test.ts b/client/tests/unit/sync/persistentStorage.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..722053f71b335c5ee858695358332e91bf2b1723
--- /dev/null
+++ b/client/tests/unit/sync/persistentStorage.test.ts
@@ -0,0 +1,47 @@
+/**
+ * requestPersistentStorage (H8 / M6) — best-effort persistent storage request
+ * so prefetched tiles / file blobs / IndexedDB aren't evicted under pressure.
+ */
+import { describe, it, expect, afterEach, vi } from 'vitest';
+import { requestPersistentStorage } from '../../../src/sync/persistentStorage';
+
+const original = (navigator as Navigator & { storage?: StorageManager }).storage;
+
+afterEach(() => {
+  Object.defineProperty(navigator, 'storage', { value: original, configurable: true });
+  vi.restoreAllMocks();
+});
+
+function stubStorage(storage: unknown) {
+  Object.defineProperty(navigator, 'storage', { value: storage, configurable: true });
+}
+
+describe('requestPersistentStorage', () => {
+  it('requests persistence when not already granted', async () => {
+    const persist = vi.fn().mockResolvedValue(true);
+    const persisted = vi.fn().mockResolvedValue(false);
+    stubStorage({ persist, persisted });
+
+    expect(await requestPersistentStorage()).toBe(true);
+    expect(persist).toHaveBeenCalledOnce();
+  });
+
+  it('skips the prompt when already persisted', async () => {
+    const persist = vi.fn().mockResolvedValue(true);
+    const persisted = vi.fn().mockResolvedValue(true);
+    stubStorage({ persist, persisted });
+
+    expect(await requestPersistentStorage()).toBe(true);
+    expect(persist).not.toHaveBeenCalled();
+  });
+
+  it('returns false (no throw) when the API is unavailable', async () => {
+    stubStorage(undefined);
+    expect(await requestPersistentStorage()).toBe(false);
+  });
+
+  it('returns false (no throw) when persist rejects', async () => {
+    stubStorage({ persist: vi.fn().mockRejectedValue(new Error('denied')) });
+    expect(await requestPersistentStorage()).toBe(false);
+  });
+});
diff --git a/client/tests/unit/sync/syncTriggers.test.ts b/client/tests/unit/sync/syncTriggers.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ad3bc2656e1ae877d37d5aa3fb58e94011bc5e89
--- /dev/null
+++ b/client/tests/unit/sync/syncTriggers.test.ts
@@ -0,0 +1,76 @@
+/**
+ * syncTriggers — reconnect/online wiring (H1).
+ *
+ * Verifies the previously-dead refetch path is wired: on WS reconnect and on the
+ * `online` event the active trip's store is re-hydrated (after the queue flush).
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const flush = vi.fn(() => Promise.resolve());
+const syncAll = vi.fn(() => Promise.resolve());
+const hydrate = vi.fn(() => Promise.resolve());
+
+let refetchCb: ((tripId: string) => void) | null = null;
+let preReconnect: (() => Promise<void>) | null = null;
+
+vi.mock('../../../src/sync/mutationQueue', () => ({
+  mutationQueue: { flush: () => flush() },
+}));
+vi.mock('../../../src/sync/tripSyncManager', () => ({
+  tripSyncManager: { syncAll: () => syncAll() },
+}));
+vi.mock('../../../src/api/websocket', () => ({
+  setPreReconnectHook: (fn: (() => Promise<void>) | null) => { preReconnect = fn; },
+  setRefetchCallback: (fn: ((tripId: string) => void) | null) => { refetchCb = fn; },
+  getActiveTrips: () => ['7'],
+}));
+vi.mock('../../../src/store/tripStore', () => ({
+  useTripStore: { getState: () => ({ hydrateActiveTrip: hydrate }) },
+}));
+
+import { registerSyncTriggers, unregisterSyncTriggers } from '../../../src/sync/syncTriggers';
+
+const flushMicrotasks = async () => {
+  for (let i = 0; i < 5; i++) await Promise.resolve();
+};
+
+beforeEach(() => {
+  flush.mockClear(); syncAll.mockClear(); hydrate.mockClear();
+  refetchCb = null; preReconnect = null;
+  Object.defineProperty(navigator, 'onLine', { value: true, writable: true, configurable: true });
+});
+
+afterEach(() => {
+  unregisterSyncTriggers();
+});
+
+describe('syncTriggers', () => {
+  it('registers a refetch callback that hydrates the active trip', () => {
+    registerSyncTriggers();
+    expect(refetchCb).toBeTypeOf('function');
+    refetchCb!('7');
+    expect(hydrate).toHaveBeenCalledWith('7');
+  });
+
+  it('also registers the pre-reconnect flush hook', () => {
+    registerSyncTriggers();
+    expect(preReconnect).toBeTypeOf('function');
+  });
+
+  it('clears both reconnect hooks on unregister', () => {
+    registerSyncTriggers();
+    unregisterSyncTriggers();
+    expect(refetchCb).toBeNull();
+    expect(preReconnect).toBeNull();
+  });
+
+  it('online event flushes, then re-seeds Dexie and re-hydrates active trips', async () => {
+    registerSyncTriggers();
+    window.dispatchEvent(new Event('online'));
+    await flushMicrotasks();
+
+    expect(flush).toHaveBeenCalled();
+    expect(syncAll).toHaveBeenCalled();
+    expect(hydrate).toHaveBeenCalledWith('7');
+  });
+});
diff --git a/client/tests/unit/sync/tilePrefetcher.test.ts b/client/tests/unit/sync/tilePrefetcher.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..768283850ab62c97bf0f83c0f9e5f2687a9a5b62
--- /dev/null
+++ b/client/tests/unit/sync/tilePrefetcher.test.ts
@@ -0,0 +1,248 @@
+/**
+ * tilePrefetcher unit tests.
+ *
+ * Covers: bbox computation, tile math, URL building, size guard,
+ * offline/no-SW guard, syncMeta update.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import 'fake-indexeddb/auto';
+import {
+  computeBbox,
+  lngToTileX,
+  latToTileY,
+  buildTileUrl,
+  countTiles,
+  prefetchTiles,
+  prefetchTilesForTrip,
+  MAX_TILES,
+  type TileBbox,
+} from '../../../src/sync/tilePrefetcher';
+import { offlineDb, clearAll, upsertSyncMeta } from '../../../src/db/offlineDb';
+import { buildPlace } from '../../helpers/factories';
+
+beforeEach(async () => {
+  await clearAll();
+  Object.defineProperty(navigator, 'onLine', { value: true, writable: true, configurable: true });
+  // Stub fetch + serviceWorker so prefetch path is exercised
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({ ok: true }));
+  Object.defineProperty(navigator, 'serviceWorker', {
+    value: { controller: {} },
+    writable: true,
+    configurable: true,
+  });
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+// ── bbox computation ──────────────────────────────────────────────────────────
+
+describe('computeBbox', () => {
+  it('returns null when no places have coordinates', () => {
+    const places = [buildPlace({ lat: null, lng: null })];
+    expect(computeBbox(places)).toBeNull();
+  });
+
+  it('expands single-point bbox to at least 0.1° span', () => {
+    const place = buildPlace({ lat: 48.8566, lng: 2.3522 });
+    const bbox = computeBbox([place])!;
+    expect(bbox.maxLat - bbox.minLat).toBeGreaterThan(0.09);
+    expect(bbox.maxLng - bbox.minLng).toBeGreaterThan(0.09);
+  });
+
+  it('computes multi-point bbox with padding', () => {
+    const places = [
+      buildPlace({ lat: 48.8566, lng: 2.3522 }),  // Paris
+      buildPlace({ lat: 51.5074, lng: -0.1278 }),  // London
+    ];
+    const bbox = computeBbox(places, 0.1)!;
+    // Padded bbox should extend beyond raw points
+    expect(bbox.minLat).toBeLessThan(48.8566);
+    expect(bbox.maxLat).toBeGreaterThan(51.5074);
+    expect(bbox.minLng).toBeLessThan(-0.1278);
+    expect(bbox.maxLng).toBeGreaterThan(2.3522);
+  });
+
+  it('clamps to valid Mercator lat bounds', () => {
+    const places = [buildPlace({ lat: 85.0, lng: 0 })];
+    const bbox = computeBbox(places, 0.5)!;
+    expect(bbox.maxLat).toBeLessThanOrEqual(85.0511);
+  });
+});
+
+// ── tile math ─────────────────────────────────────────────────────────────────
+
+describe('lngToTileX', () => {
+  it('returns 0 for lng=-180 at any zoom', () => {
+    expect(lngToTileX(-180, 10)).toBe(0);
+  });
+
+  it('returns max tile for lng=180 at zoom 1', () => {
+    // At zoom 1: 2^1 = 2 tiles, lng=180 → x = floor(360/360 * 2) = floor(2) = 2
+    // But tile range is 0..1, so this is the "overflow" edge — that's fine
+    expect(lngToTileX(180, 1)).toBe(2);
+  });
+
+  it('increases with more easterly longitude', () => {
+    const x1 = lngToTileX(0, 10);
+    const x2 = lngToTileX(10, 10);
+    expect(x2).toBeGreaterThan(x1);
+  });
+});
+
+describe('latToTileY', () => {
+  it('returns smaller y for higher latitude (north = top)', () => {
+    const yNorth = latToTileY(60, 10);
+    const ySouth = latToTileY(10, 10);
+    expect(yNorth).toBeLessThan(ySouth);
+  });
+
+  it('equator is roughly half the tile grid', () => {
+    const yEq = latToTileY(0, 1);
+    // zoom 1 → 2 rows, equator ≈ row 1
+    expect(yEq).toBe(1);
+  });
+});
+
+// ── URL building ───────────────────────────────────────────────────────────────
+
+describe('buildTileUrl', () => {
+  it('replaces {z}, {x}, {y}, {r} correctly', () => {
+    const tmpl = 'https://tile.example.com/{z}/{x}/{y}.png';
+    const url = buildTileUrl(tmpl, 10, 500, 300);
+    expect(url).toBe('https://tile.example.com/10/500/300.png');
+  });
+
+  it('replaces {s} with a subdomain character', () => {
+    const tmpl = 'https://{s}.tiles.example.com/{z}/{x}/{y}.png';
+    const url = buildTileUrl(tmpl, 10, 0, 0);
+    expect(url).toMatch(/^https:\/\/[abcd]\.tiles\.example\.com\/10\/0\/0\.png$/);
+  });
+
+  it('removes {r} (retina placeholder)', () => {
+    const tmpl = 'https://tiles.example.com/{z}/{x}/{y}{r}.png';
+    const url = buildTileUrl(tmpl, 10, 0, 0);
+    expect(url).toBe('https://tiles.example.com/10/0/0.png');
+  });
+});
+
+// ── countTiles ────────────────────────────────────────────────────────────────
+
+describe('countTiles', () => {
+  it('returns more tiles at higher zoom levels', () => {
+    const bbox: TileBbox = { minLat: 48.7, maxLat: 49.0, minLng: 2.2, maxLng: 2.5 };
+    const low = countTiles(bbox, 10, 10);
+    const high = countTiles(bbox, 12, 12);
+    expect(high).toBeGreaterThan(low);
+  });
+
+  it('stops counting after exceeding MAX_TILES', () => {
+    // Very large bbox — should hit cap quickly at high zooms
+    const bbox: TileBbox = { minLat: -60, maxLat: 60, minLng: -180, maxLng: 180 };
+    const count = countTiles(bbox, 10, 16);
+    expect(count).toBeGreaterThan(MAX_TILES);
+  });
+});
+
+// ── prefetchTiles guards ───────────────────────────────────────────────────────
+
+describe('prefetchTiles — offline guard', () => {
+  it('returns 0 and does not fetch when offline', async () => {
+    Object.defineProperty(navigator, 'onLine', { value: false });
+    const bbox: TileBbox = { minLat: 48.8, maxLat: 48.9, minLng: 2.3, maxLng: 2.4 };
+    const count = await prefetchTiles(bbox, 'https://{s}.example.com/{z}/{x}/{y}.png', 10, 10);
+    expect(count).toBe(0);
+    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
+  });
+
+  it('returns 0 when no service worker controller', async () => {
+    Object.defineProperty(navigator, 'serviceWorker', {
+      value: { controller: null },
+      configurable: true,
+    });
+    const bbox: TileBbox = { minLat: 48.8, maxLat: 48.9, minLng: 2.3, maxLng: 2.4 };
+    const count = await prefetchTiles(bbox, 'https://{s}.example.com/{z}/{x}/{y}.png', 10, 10);
+    expect(count).toBe(0);
+  });
+});
+
+describe('prefetchTiles — normal operation', () => {
+  it('fetches tiles and returns count', async () => {
+    const bbox: TileBbox = { minLat: 48.84, maxLat: 48.87, minLng: 2.33, maxLng: 2.37 };
+    const count = await prefetchTiles(bbox, 'https://{s}.example.com/{z}/{x}/{y}.png', 10, 11);
+    expect(count).toBeGreaterThan(0);
+    expect(vi.mocked(fetch)).toHaveBeenCalled();
+  });
+
+  it('stops at zoom level where cap is exceeded', async () => {
+    // Use a very small MAX_TILES override by using a huge bbox
+    const bbox: TileBbox = { minLat: -80, maxLat: 80, minLng: -170, maxLng: 170 };
+    // This bbox at zoom 10 alone has thousands of tiles — should trigger early stop
+    const count = await prefetchTiles(bbox, 'https://{s}.example.com/{z}/{x}/{y}.png', 10, 16);
+    expect(count).toBeLessThanOrEqual(MAX_TILES);
+  });
+});
+
+// ── prefetchTilesForTrip ──────────────────────────────────────────────────────
+
+describe('prefetchTilesForTrip', () => {
+  it('no-ops when no places have coordinates', async () => {
+    const places = [buildPlace({ lat: null, lng: null })];
+    await prefetchTilesForTrip(1, places);
+    expect(vi.mocked(fetch)).not.toHaveBeenCalled();
+  });
+
+  it('updates syncMeta tilesBbox after prefetch', async () => {
+    await upsertSyncMeta({ tripId: 1, lastSyncedAt: Date.now(), status: 'idle', tilesBbox: null, filesCachedCount: 0 });
+
+    const places = [
+      buildPlace({ trip_id: 1, lat: 48.8566, lng: 2.3522 }),
+    ];
+    await prefetchTilesForTrip(1, places, 'https://{s}.example.com/{z}/{x}/{y}.png');
+
+    const meta = await offlineDb.syncMeta.get(1);
+    expect(meta!.tilesBbox).not.toBeNull();
+    expect(meta!.tilesBbox).toHaveLength(4);
+  });
+
+  it('zoom-clamps instead of skipping when the bbox exceeds MAX_TILES', async () => {
+    await upsertSyncMeta({ tripId: 1, lastSyncedAt: Date.now(), status: 'idle', tilesBbox: null, filesCachedCount: 0 });
+
+    // ~4° road-trip span: low zooms fit the budget, high zooms (z14+) blow past
+    // it. The old guard skipped the whole trip; now we keep what fits.
+    const places = [
+      buildPlace({ trip_id: 1, lat: 45.0, lng: 0.0 }),
+      buildPlace({ trip_id: 1, lat: 49.0, lng: 4.0 }),
+    ];
+    await prefetchTilesForTrip(1, places, 'https://{s}.example.com/{z}/{x}/{y}.png');
+
+    // Previously this skipped entirely; now it prefetches a clamped subset.
+    const calls = vi.mocked(fetch).mock.calls.length;
+    expect(calls).toBeGreaterThan(0);
+    expect(calls).toBeLessThanOrEqual(MAX_TILES);
+  });
+
+  it('prefetches a region-sized (0.5°) trip that the old all-or-nothing guard would have skipped', async () => {
+    await upsertSyncMeta({ tripId: 1, lastSyncedAt: Date.now(), status: 'idle', tilesBbox: null, filesCachedCount: 0 });
+
+    const places = [
+      buildPlace({ trip_id: 1, lat: 48.6, lng: 2.1 }),
+      buildPlace({ trip_id: 1, lat: 49.1, lng: 2.6 }),
+    ];
+    await prefetchTilesForTrip(1, places, 'https://{s}.example.com/{z}/{x}/{y}.png');
+
+    const calls = vi.mocked(fetch).mock.calls.length;
+    expect(calls).toBeGreaterThan(0);
+    expect(calls).toBeLessThanOrEqual(MAX_TILES);
+  });
+});
+
+// ── cap coherence ───────────────────────────────────────────────────────────────
+
+describe('MAX_TILES budget', () => {
+  it('matches the Workbox map-tiles maxEntries in vite.config.js (drift guard)', () => {
+    expect(MAX_TILES).toBe(12288);
+  });
+});
diff --git a/client/tests/unit/sync/tripSyncManager.test.ts b/client/tests/unit/sync/tripSyncManager.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..46ff38291ed8842c6100532921f69300d2a0873d
--- /dev/null
+++ b/client/tests/unit/sync/tripSyncManager.test.ts
@@ -0,0 +1,285 @@
+/**
+ * tripSyncManager unit tests.
+ *
+ * Covers: trip filtering (shouldCache/isStale), bundle fetch → Dexie upsert,
+ * stale trip eviction, offline guard, file blob caching.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import 'fake-indexeddb/auto';
+import { server } from '../../helpers/msw/server';
+import { http, HttpResponse } from 'msw';
+import { tripSyncManager } from '../../../src/sync/tripSyncManager';
+import { setAuthed } from '../../../src/sync/authGate';
+import { offlineDb, clearAll, upsertTrip } from '../../../src/db/offlineDb';
+import {
+  buildTrip,
+  buildDay,
+  buildPlace,
+  buildPackingItem,
+  buildTodoItem,
+  buildBudgetItem,
+  buildReservation,
+  buildTripFile,
+} from '../../helpers/factories';
+
+// Helper to get today ± N days as YYYY-MM-DD
+function dateOffset(days: number): string {
+  const d = new Date();
+  d.setDate(d.getDate() + days);
+  return d.toISOString().slice(0, 10);
+}
+
+function makeBundle(tripId: number) {
+  const trip = buildTrip({ id: tripId, end_date: dateOffset(3) });
+  return {
+    trip,
+    days: [buildDay({ trip_id: tripId, assignments: [], notes_items: [] })],
+    places: [buildPlace({ trip_id: tripId })],
+    packingItems: [buildPackingItem({ trip_id: tripId })],
+    todoItems: [buildTodoItem({ trip_id: tripId })],
+    budgetItems: [buildBudgetItem({ trip_id: tripId })],
+    reservations: [buildReservation({ trip_id: tripId })],
+    files: [buildTripFile({ trip_id: tripId, url: `/api/trips/${tripId}/files/99/download`, mime_type: 'application/pdf' })],
+  };
+}
+
+beforeEach(async () => {
+  await clearAll();
+  tripSyncManager._resetSyncing();
+  setAuthed(true);
+  Object.defineProperty(navigator, 'onLine', { value: true, writable: true, configurable: true });
+  // Stub fetch for blob caching (used by cacheFilesForTrip)
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+    ok: true,
+    blob: async () => new Blob(['data'], { type: 'application/pdf' }),
+  }));
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+  setAuthed(false);
+});
+
+describe('tripSyncManager.syncAll — auth gate (B4)', () => {
+  it('no-ops when logged out (gate closed)', async () => {
+    setAuthed(false);
+    let called = false;
+    server.use(
+      http.get('/api/trips', () => { called = true; return HttpResponse.json({ trips: [] }); }),
+    );
+    await tripSyncManager.syncAll();
+    expect(called).toBe(false);
+  });
+});
+
+// ── offline guard ─────────────────────────────────────────────────────────────
+
+describe('tripSyncManager.syncAll — offline guard', () => {
+  it('does nothing when offline', async () => {
+    Object.defineProperty(navigator, 'onLine', { value: false });
+
+    let listed = false;
+    server.use(
+      http.get('/api/trips', () => { listed = true; return HttpResponse.json({ trips: [] }); }),
+    );
+
+    await tripSyncManager.syncAll();
+    expect(listed).toBe(false);
+  });
+});
+
+// ── trip filtering ─────────────────────────────────────────────────────────────
+
+describe('tripSyncManager.syncAll — trip filtering', () => {
+  it('caches ongoing trips (end_date >= today)', async () => {
+    const tripId = 100;
+    const bundle = makeBundle(tripId);
+
+    server.use(
+      http.get('/api/trips', () =>
+        HttpResponse.json({ trips: [buildTrip({ id: tripId, end_date: dateOffset(2) })] }),
+      ),
+      http.get(`/api/trips/${tripId}/bundle`, () => HttpResponse.json(bundle)),
+    );
+
+    await tripSyncManager.syncAll();
+
+    const cached = await offlineDb.trips.get(tripId);
+    expect(cached).toBeDefined();
+    expect(cached!.id).toBe(tripId);
+  });
+
+  it('caches trips with no end_date', async () => {
+    const tripId = 101;
+    const bundle = makeBundle(tripId);
+    const trip = buildTrip({ id: tripId, end_date: null as unknown as string });
+
+    server.use(
+      http.get('/api/trips', () => HttpResponse.json({ trips: [trip] })),
+      http.get(`/api/trips/${tripId}/bundle`, () => HttpResponse.json({ ...bundle, trip })),
+    );
+
+    await tripSyncManager.syncAll();
+    expect(await offlineDb.trips.get(tripId)).toBeDefined();
+  });
+
+  it('does not cache past trips (end_date < today)', async () => {
+    const tripId = 102;
+
+    server.use(
+      http.get('/api/trips', () =>
+        HttpResponse.json({ trips: [buildTrip({ id: tripId, end_date: dateOffset(-1) })] }),
+      ),
+    );
+
+    // Bundle should NOT be called for past trips
+    let bundleCalled = false;
+    server.use(
+      http.get(`/api/trips/${tripId}/bundle`, () => {
+        bundleCalled = true;
+        return HttpResponse.json({});
+      }),
+    );
+
+    await tripSyncManager.syncAll();
+    expect(bundleCalled).toBe(false);
+    expect(await offlineDb.trips.get(tripId)).toBeUndefined();
+  });
+});
+
+// ── stale eviction ─────────────────────────────────────────────────────────────
+
+describe('tripSyncManager.syncAll — stale eviction', () => {
+  it('evicts trips that ended more than 7 days ago', async () => {
+    const staleId = 200;
+    // Seed Dexie as if previously cached
+    await upsertTrip(buildTrip({ id: staleId, end_date: dateOffset(-8) }));
+
+    server.use(
+      http.get('/api/trips', () =>
+        HttpResponse.json({ trips: [buildTrip({ id: staleId, end_date: dateOffset(-8) })] }),
+      ),
+    );
+
+    await tripSyncManager.syncAll();
+    expect(await offlineDb.trips.get(staleId)).toBeUndefined();
+  });
+
+  it('does NOT evict trips that ended exactly 6 days ago', async () => {
+    const recentId = 201;
+    const bundle = makeBundle(recentId);
+    const trip = buildTrip({ id: recentId, end_date: dateOffset(-6) });
+
+    server.use(
+      http.get('/api/trips', () => HttpResponse.json({ trips: [trip] })),
+      http.get(`/api/trips/${recentId}/bundle`, () => HttpResponse.json({ ...bundle, trip })),
+    );
+
+    await tripSyncManager.syncAll();
+    // end_date = -6 days: still within 7d window, but < today so not cached
+    // i.e., shouldCache is false (end_date < today) so won't be fetched
+    // but also isStale is false (end_date = -6 >= cutoff -7), so won't be evicted
+    // → trip should simply not appear in Dexie (not cached, not evicted pre-seeded data)
+    expect(await offlineDb.trips.get(recentId)).toBeUndefined();
+  });
+});
+
+// ── bundle upsert ──────────────────────────────────────────────────────────────
+
+describe('tripSyncManager.syncAll — bundle upsert', () => {
+  it('writes all bundle entities to Dexie', async () => {
+    const tripId = 300;
+    const bundle = makeBundle(tripId);
+
+    server.use(
+      http.get('/api/trips', () =>
+        HttpResponse.json({ trips: [buildTrip({ id: tripId, end_date: dateOffset(5) })] }),
+      ),
+      http.get(`/api/trips/${tripId}/bundle`, () => HttpResponse.json(bundle)),
+    );
+
+    await tripSyncManager.syncAll();
+
+    expect(await offlineDb.trips.get(tripId)).toBeDefined();
+    expect(await offlineDb.days.where('trip_id').equals(tripId).count()).toBe(1);
+    expect(await offlineDb.places.where('trip_id').equals(tripId).count()).toBe(1);
+    expect(await offlineDb.packingItems.where('trip_id').equals(tripId).count()).toBe(1);
+    expect(await offlineDb.todoItems.where('trip_id').equals(tripId).count()).toBe(1);
+    expect(await offlineDb.budgetItems.where('trip_id').equals(tripId).count()).toBe(1);
+    expect(await offlineDb.reservations.where('trip_id').equals(tripId).count()).toBe(1);
+    expect(await offlineDb.tripFiles.where('trip_id').equals(tripId).count()).toBe(1);
+  });
+
+  it('writes syncMeta with lastSyncedAt', async () => {
+    const tripId = 301;
+    const bundle = makeBundle(tripId);
+
+    server.use(
+      http.get('/api/trips', () =>
+        HttpResponse.json({ trips: [buildTrip({ id: tripId, end_date: dateOffset(5) })] }),
+      ),
+      http.get(`/api/trips/${tripId}/bundle`, () => HttpResponse.json(bundle)),
+    );
+
+    const before = Date.now();
+    await tripSyncManager.syncAll();
+    const after = Date.now();
+
+    const meta = await offlineDb.syncMeta.get(tripId);
+    expect(meta).toBeDefined();
+    expect(meta!.lastSyncedAt).toBeGreaterThanOrEqual(before);
+    expect(meta!.lastSyncedAt).toBeLessThanOrEqual(after);
+  });
+});
+
+// ── file blob caching ──────────────────────────────────────────────────────────
+
+describe('tripSyncManager — file blob caching', () => {
+  it('caches non-photo files after bundle sync', async () => {
+    const tripId = 400;
+    const bundle = makeBundle(tripId);
+
+    server.use(
+      http.get('/api/trips', () =>
+        HttpResponse.json({ trips: [buildTrip({ id: tripId, end_date: dateOffset(5) })] }),
+      ),
+      http.get(`/api/trips/${tripId}/bundle`, () => HttpResponse.json(bundle)),
+    );
+
+    await tripSyncManager.syncAll();
+
+    // Give fire-and-forget a tick
+    await new Promise(r => setTimeout(r, 50));
+
+    const cached = await offlineDb.blobCache.toArray();
+    expect(cached.length).toBeGreaterThan(0);
+    expect(cached[0].url).toContain('/download');
+  });
+
+  it('does not cache photo files (image/* MIME)', async () => {
+    const tripId = 401;
+    const photoFile = buildTripFile({
+      trip_id: tripId,
+      mime_type: 'image/jpeg',
+      url: `/api/trips/${tripId}/files/77/download`,
+    });
+    const bundle = {
+      ...makeBundle(tripId),
+      files: [photoFile],
+    };
+
+    server.use(
+      http.get('/api/trips', () =>
+        HttpResponse.json({ trips: [buildTrip({ id: tripId, end_date: dateOffset(5) })] }),
+      ),
+      http.get(`/api/trips/${tripId}/bundle`, () => HttpResponse.json(bundle)),
+    );
+
+    await tripSyncManager.syncAll();
+    await new Promise(r => setTimeout(r, 50));
+
+    const cached = await offlineDb.blobCache.toArray();
+    expect(cached.length).toBe(0);
+  });
+});
diff --git a/client/tests/unit/tripStore.test.ts b/client/tests/unit/tripStore.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8f8259a26d7469a6b4292f94a30d54c39174dc79
--- /dev/null
+++ b/client/tests/unit/tripStore.test.ts
@@ -0,0 +1,372 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { http, HttpResponse } from 'msw';
+import { useTripStore } from '../../src/store/tripStore';
+import { resetAllStores } from '../helpers/store';
+import { buildTrip, buildDay, buildPlace, buildPackingItem, buildTodoItem, buildTag, buildCategory, buildAssignment, buildDayNote, buildBudgetItem, buildReservation, buildTripFile } from '../helpers/factories';
+import { server } from '../helpers/msw/server';
+
+vi.mock('../../src/api/websocket', () => ({
+  connect: vi.fn(),
+  disconnect: vi.fn(),
+  getSocketId: vi.fn(() => null),
+  joinTrip: vi.fn(),
+  leaveTrip: vi.fn(),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+  setRefetchCallback: vi.fn(),
+  setPreReconnectHook: vi.fn(),
+}));
+
+beforeEach(() => {
+  resetAllStores();
+});
+
+/** Full set of MSW handlers for one trip's loadTrip fan-out. */
+function tripHandlers(
+  id: number,
+  data: {
+    budget?: unknown[]; reservations?: unknown[]; files?: unknown[];
+    tags?: unknown[]; categories?: unknown[];
+  },
+) {
+  return [
+    http.get(`/api/trips/${id}`, () => HttpResponse.json({ trip: buildTrip({ id }) })),
+    http.get(`/api/trips/${id}/days`, () => HttpResponse.json({ days: [] })),
+    http.get(`/api/trips/${id}/places`, () => HttpResponse.json({ places: [] })),
+    http.get(`/api/trips/${id}/packing`, () => HttpResponse.json({ items: [] })),
+    http.get(`/api/trips/${id}/todo`, () => HttpResponse.json({ items: [] })),
+    http.get(`/api/trips/${id}/budget`, () => HttpResponse.json({ items: data.budget ?? [] })),
+    http.get(`/api/trips/${id}/reservations`, () => HttpResponse.json({ reservations: data.reservations ?? [] })),
+    http.get(`/api/trips/${id}/files`, () => HttpResponse.json({ files: data.files ?? [] })),
+    http.get('/api/tags', () => HttpResponse.json({ tags: data.tags ?? [] })),
+    http.get('/api/categories', () => HttpResponse.json({ categories: data.categories ?? [] })),
+  ];
+}
+
+describe('tripStore', () => {
+  describe('loadTrip', () => {
+    it('FE-TRIP-001: fires parallel API calls for trips, days, places, packing, todo, tags, categories', async () => {
+      const calledUrls: string[] = [];
+      server.use(
+        http.get('/api/trips/:id', ({ params }) => {
+          calledUrls.push(`/api/trips/${params.id}`);
+          return HttpResponse.json({ trip: buildTrip({ id: Number(params.id) }) });
+        }),
+        http.get('/api/trips/:id/days', ({ params }) => {
+          calledUrls.push(`/api/trips/${params.id}/days`);
+          return HttpResponse.json({ days: [] });
+        }),
+        http.get('/api/trips/:id/places', ({ params }) => {
+          calledUrls.push(`/api/trips/${params.id}/places`);
+          return HttpResponse.json({ places: [] });
+        }),
+        http.get('/api/trips/:id/packing', ({ params }) => {
+          calledUrls.push(`/api/trips/${params.id}/packing`);
+          return HttpResponse.json({ items: [] });
+        }),
+        http.get('/api/trips/:id/todo', ({ params }) => {
+          calledUrls.push(`/api/trips/${params.id}/todo`);
+          return HttpResponse.json({ items: [] });
+        }),
+        http.get('/api/tags', () => {
+          calledUrls.push('/api/tags');
+          return HttpResponse.json({ tags: [] });
+        }),
+        http.get('/api/categories', () => {
+          calledUrls.push('/api/categories');
+          return HttpResponse.json({ categories: [] });
+        }),
+      );
+
+      await useTripStore.getState().loadTrip(1);
+
+      expect(calledUrls).toContain('/api/trips/1');
+      expect(calledUrls).toContain('/api/trips/1/days');
+      expect(calledUrls).toContain('/api/trips/1/places');
+      expect(calledUrls).toContain('/api/trips/1/packing');
+      expect(calledUrls).toContain('/api/trips/1/todo');
+      expect(calledUrls).toContain('/api/tags');
+      expect(calledUrls).toContain('/api/categories');
+    });
+
+    it('FE-TRIP-002: after loadTrip, all store fields are populated', async () => {
+      const trip = buildTrip({ id: 1 });
+      const place = buildPlace({ trip_id: 1 });
+      const packingItem = buildPackingItem({ trip_id: 1 });
+      const todoItem = buildTodoItem({ trip_id: 1 });
+      const tag = buildTag();
+      const category = buildCategory();
+
+      server.use(
+        http.get('/api/trips/1', () => HttpResponse.json({ trip })),
+        http.get('/api/trips/1/days', () => HttpResponse.json({ days: [] })),
+        http.get('/api/trips/1/places', () => HttpResponse.json({ places: [place] })),
+        http.get('/api/trips/1/packing', () => HttpResponse.json({ items: [packingItem] })),
+        http.get('/api/trips/1/todo', () => HttpResponse.json({ items: [todoItem] })),
+        http.get('/api/tags', () => HttpResponse.json({ tags: [tag] })),
+        http.get('/api/categories', () => HttpResponse.json({ categories: [category] })),
+      );
+
+      await useTripStore.getState().loadTrip(1);
+      const state = useTripStore.getState();
+
+      expect(state.trip).toEqual(trip);
+      expect(state.places).toEqual([place]);
+      expect(state.packingItems).toEqual([packingItem]);
+      expect(state.todoItems).toEqual([todoItem]);
+      expect(state.tags).toEqual([tag]);
+      expect(state.categories).toEqual([category]);
+    });
+
+    it('FE-TRIP-003: loadTrip extracts assignments map from days response', async () => {
+      const assignment = buildAssignment({ day_id: 10, order_index: 0 });
+      const day = buildDay({ id: 10, assignments: [assignment], notes_items: [] });
+
+      server.use(
+        http.get('/api/trips/1', () => HttpResponse.json({ trip: buildTrip({ id: 1 }) })),
+        http.get('/api/trips/1/days', () => HttpResponse.json({ days: [day] })),
+        http.get('/api/trips/1/places', () => HttpResponse.json({ places: [] })),
+        http.get('/api/trips/1/packing', () => HttpResponse.json({ items: [] })),
+        http.get('/api/trips/1/todo', () => HttpResponse.json({ items: [] })),
+        http.get('/api/tags', () => HttpResponse.json({ tags: [] })),
+        http.get('/api/categories', () => HttpResponse.json({ categories: [] })),
+      );
+
+      await useTripStore.getState().loadTrip(1);
+      const { assignments } = useTripStore.getState();
+
+      expect(assignments['10']).toBeDefined();
+      expect(assignments['10']).toEqual([assignment]);
+    });
+
+    it('FE-TRIP-004: loadTrip extracts dayNotes map from days response', async () => {
+      const note = buildDayNote({ day_id: 10 });
+      const day = buildDay({ id: 10, assignments: [], notes_items: [note] });
+
+      server.use(
+        http.get('/api/trips/1', () => HttpResponse.json({ trip: buildTrip({ id: 1 }) })),
+        http.get('/api/trips/1/days', () => HttpResponse.json({ days: [day] })),
+        http.get('/api/trips/1/places', () => HttpResponse.json({ places: [] })),
+        http.get('/api/trips/1/packing', () => HttpResponse.json({ items: [] })),
+        http.get('/api/trips/1/todo', () => HttpResponse.json({ items: [] })),
+        http.get('/api/tags', () => HttpResponse.json({ tags: [] })),
+        http.get('/api/categories', () => HttpResponse.json({ categories: [] })),
+      );
+
+      await useTripStore.getState().loadTrip(1);
+      const { dayNotes } = useTripStore.getState();
+
+      expect(dayNotes['10']).toBeDefined();
+      expect(dayNotes['10']).toEqual([note]);
+    });
+
+    it('FE-TRIP-005: loadTrip sets isLoading true during, false after', async () => {
+      let wasLoadingDuringFetch = false;
+
+      server.use(
+        http.get('/api/trips/1', () => {
+          wasLoadingDuringFetch = useTripStore.getState().isLoading;
+          return HttpResponse.json({ trip: buildTrip({ id: 1 }) });
+        }),
+        http.get('/api/trips/1/days', () => HttpResponse.json({ days: [] })),
+        http.get('/api/trips/1/places', () => HttpResponse.json({ places: [] })),
+        http.get('/api/trips/1/packing', () => HttpResponse.json({ items: [] })),
+        http.get('/api/trips/1/todo', () => HttpResponse.json({ items: [] })),
+        http.get('/api/tags', () => HttpResponse.json({ tags: [] })),
+        http.get('/api/categories', () => HttpResponse.json({ categories: [] })),
+      );
+
+      const promise = useTripStore.getState().loadTrip(1);
+      expect(useTripStore.getState().isLoading).toBe(true);
+      await promise;
+      expect(wasLoadingDuringFetch).toBe(true);
+      expect(useTripStore.getState().isLoading).toBe(false);
+    });
+
+    it('FE-TRIP-006: loadTrip on API failure sets error and isLoading: false', async () => {
+      server.use(
+        http.get('/api/trips/1', () => HttpResponse.json({ message: 'Not found' }, { status: 404 })),
+        http.get('/api/trips/1/days', () => HttpResponse.json({ days: [] })),
+        http.get('/api/trips/1/places', () => HttpResponse.json({ places: [] })),
+        http.get('/api/trips/1/packing', () => HttpResponse.json({ items: [] })),
+        http.get('/api/trips/1/todo', () => HttpResponse.json({ items: [] })),
+        http.get('/api/tags', () => HttpResponse.json({ tags: [] })),
+        http.get('/api/categories', () => HttpResponse.json({ categories: [] })),
+      );
+
+      await expect(useTripStore.getState().loadTrip(1)).rejects.toThrow();
+
+      const state = useTripStore.getState();
+      expect(state.isLoading).toBe(false);
+      expect(state.error).not.toBeNull();
+    });
+
+    it('FE-TRIP-H5: loadTrip uniformly hydrates budget, reservations and files', async () => {
+      const budgetItem = buildBudgetItem({ trip_id: 1 });
+      const reservation = buildReservation({ trip_id: 1 });
+      const file = buildTripFile({ trip_id: 1 });
+      server.use(...tripHandlers(1, { budget: [budgetItem], reservations: [reservation], files: [file] }));
+
+      await useTripStore.getState().loadTrip(1);
+      const state = useTripStore.getState();
+
+      expect(state.budgetItems).toEqual([budgetItem]);
+      expect(state.reservations).toEqual([reservation]);
+      expect(state.files).toEqual([file]);
+    });
+
+    it('FE-TRIP-H4: switching trips does not leak budget/reservations/files from the previous trip', async () => {
+      // Trip 1 has budget/reservations/files; trip 2 has none.
+      server.use(...tripHandlers(1, {
+        budget: [buildBudgetItem({ trip_id: 1 })],
+        reservations: [buildReservation({ trip_id: 1 })],
+        files: [buildTripFile({ trip_id: 1 })],
+      }));
+      await useTripStore.getState().loadTrip(1);
+      expect(useTripStore.getState().budgetItems).toHaveLength(1);
+
+      server.use(...tripHandlers(2, {}));
+      await useTripStore.getState().loadTrip(2);
+      const state = useTripStore.getState();
+
+      expect(state.trip!.id).toBe(2);
+      expect(state.budgetItems).toEqual([]);
+      expect(state.reservations).toEqual([]);
+      expect(state.files).toEqual([]);
+    });
+
+    it('FE-TRIP-H4b: resetTrip clears every trip-scoped slice but keeps tags/categories', async () => {
+      server.use(...tripHandlers(1, {
+        budget: [buildBudgetItem({ trip_id: 1 })],
+        reservations: [buildReservation({ trip_id: 1 })],
+        files: [buildTripFile({ trip_id: 1 })],
+        tags: [buildTag()],
+      }));
+      await useTripStore.getState().loadTrip(1);
+      expect(useTripStore.getState().budgetItems).toHaveLength(1);
+
+      useTripStore.getState().resetTrip();
+      const state = useTripStore.getState();
+
+      expect(state.trip).toBeNull();
+      expect(state.places).toEqual([]);
+      expect(state.budgetItems).toEqual([]);
+      expect(state.reservations).toEqual([]);
+      expect(state.files).toEqual([]);
+      expect(state.selectedDayId).toBeNull();
+      // Global lookups survive a trip reset.
+      expect(state.tags).toHaveLength(1);
+    });
+  });
+
+  describe('hydrateActiveTrip', () => {
+    const loadHandlers = (places: unknown[] = [], budget: unknown[] = []) => [
+      http.get('/api/trips/1', () => HttpResponse.json({ trip: buildTrip({ id: 1 }) })),
+      http.get('/api/trips/1/days', () => HttpResponse.json({ days: [] })),
+      http.get('/api/trips/1/places', () => HttpResponse.json({ places })),
+      http.get('/api/trips/1/packing', () => HttpResponse.json({ items: [] })),
+      http.get('/api/trips/1/todo', () => HttpResponse.json({ items: [] })),
+      http.get('/api/trips/1/budget', () => HttpResponse.json({ items: budget })),
+      http.get('/api/trips/1/reservations', () => HttpResponse.json({ reservations: [] })),
+      http.get('/api/trips/1/files', () => HttpResponse.json({ files: [] })),
+      http.get('/api/tags', () => HttpResponse.json({ tags: [] })),
+      http.get('/api/categories', () => HttpResponse.json({ categories: [] })),
+    ];
+
+    it('FE-TRIP-H1: silently refreshes resources without resetting or splashing', async () => {
+      server.use(...loadHandlers());
+      await useTripStore.getState().loadTrip(1);
+      expect(useTripStore.getState().trip!.id).toBe(1);
+
+      // New collaborative state arrives (as if edited by someone while we were offline).
+      const place = buildPlace({ trip_id: 1 });
+      const budgetItem = buildBudgetItem({ trip_id: 1 });
+      server.use(...loadHandlers([place], [budgetItem]));
+
+      await useTripStore.getState().hydrateActiveTrip(1);
+      const state = useTripStore.getState();
+
+      expect(state.places).toEqual([place]);
+      expect(state.budgetItems).toEqual([budgetItem]);
+      expect(state.trip!.id).toBe(1);      // trip not reset
+      expect(state.isLoading).toBe(false); // no splash toggled
+    });
+  });
+
+  describe('refreshDays', () => {
+    it('FE-TRIP-007: refreshDays re-fetches days and rebuilds assignments/dayNotes maps', async () => {
+      const assignment = buildAssignment({ day_id: 20, order_index: 0 });
+      const note = buildDayNote({ day_id: 20 });
+      const day = buildDay({ id: 20, assignments: [assignment], notes_items: [note] });
+
+      server.use(
+        http.get('/api/trips/1/days', () => HttpResponse.json({ days: [day] })),
+      );
+
+      await useTripStore.getState().refreshDays(1);
+      const state = useTripStore.getState();
+
+      expect(state.days).toHaveLength(1);
+      expect(state.assignments['20']).toEqual([assignment]);
+      expect(state.dayNotes['20']).toEqual([note]);
+    });
+  });
+
+  describe('updateTrip', () => {
+    it('FE-TRIP-008: updateTrip persists and refreshes trip + days', async () => {
+      const updatedTrip = buildTrip({ id: 1, title: 'Updated Trip' });
+
+      server.use(
+        http.put('/api/trips/1', () => HttpResponse.json({ trip: updatedTrip })),
+        http.get('/api/trips/1/days', () => HttpResponse.json({ days: [] })),
+      );
+
+      const result = await useTripStore.getState().updateTrip(1, { title: 'Updated Trip' });
+
+      expect(result).toEqual(updatedTrip);
+      expect(useTripStore.getState().trip).toEqual(updatedTrip);
+    });
+  });
+
+  describe('setSelectedDay', () => {
+    it('FE-TRIP-009: setSelectedDay updates selectedDayId', () => {
+      useTripStore.getState().setSelectedDay(42);
+      expect(useTripStore.getState().selectedDayId).toBe(42);
+
+      useTripStore.getState().setSelectedDay(null);
+      expect(useTripStore.getState().selectedDayId).toBeNull();
+    });
+  });
+
+  describe('addTag', () => {
+    it('FE-TRIP-010: addTag creates tag and appends to tags', async () => {
+      const existingTag = buildTag();
+      useTripStore.setState({ tags: [existingTag] });
+
+      const newTagData = { name: 'New Tag', color: '#00ff00' };
+
+      const result = await useTripStore.getState().addTag(newTagData);
+
+      expect(result.name).toBe('New Tag');
+      const tags = useTripStore.getState().tags;
+      expect(tags).toHaveLength(2);
+      expect(tags[tags.length - 1].name).toBe('New Tag');
+    });
+  });
+
+  describe('addCategory', () => {
+    it('FE-TRIP-011: addCategory creates category and appends to categories', async () => {
+      const existingCategory = buildCategory();
+      useTripStore.setState({ categories: [existingCategory] });
+
+      const newCategoryData = { name: 'New Category', icon: 'hotel' };
+
+      const result = await useTripStore.getState().addCategory(newCategoryData);
+
+      expect(result.name).toBe('New Category');
+      const categories = useTripStore.getState().categories;
+      expect(categories).toHaveLength(2);
+      expect(categories[categories.length - 1].name).toBe('New Category');
+    });
+  });
+});
diff --git a/client/tests/unit/utils/fileDownload.test.ts b/client/tests/unit/utils/fileDownload.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2045d2175d67705ca681e515a3fb31cec37b21e5
--- /dev/null
+++ b/client/tests/unit/utils/fileDownload.test.ts
@@ -0,0 +1,225 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { downloadFile, openFile } from '../../../src/utils/fileDownload'
+import { getCachedBlob } from '../../../src/db/offlineDb'
+
+// Mock the offline DB so these tests never touch Dexie/IndexedDB.
+vi.mock('../../../src/db/offlineDb', () => ({ getCachedBlob: vi.fn() }))
+
+function makeFetchMock(status: number, blob: Blob = new Blob(['data'], { type: 'application/pdf' })) {
+  return vi.fn().mockResolvedValue({
+    status,
+    ok: status >= 200 && status < 300,
+    blob: () => Promise.resolve(blob),
+  })
+}
+
+beforeEach(() => {
+  vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:mock-url')
+  vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => {})
+  vi.spyOn(document.body, 'appendChild').mockImplementation((el) => el)
+  vi.spyOn(document.body, 'removeChild').mockImplementation((el) => el)
+  vi.useFakeTimers()
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  vi.useRealTimers()
+})
+
+describe('assertRelativeUrl (URL guard)', () => {
+  it('rejects absolute http URLs', async () => {
+    await expect(downloadFile('https://evil.com/x')).rejects.toThrow('Refusing to fetch non-relative URL')
+  })
+  it('rejects protocol-relative URLs', async () => {
+    await expect(downloadFile('//evil.com/x')).rejects.toThrow('Refusing to fetch non-relative URL')
+  })
+  it('allows relative paths', async () => {
+    vi.stubGlobal('fetch', makeFetchMock(200))
+    vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {})
+    await expect(downloadFile('/trips/1/files/2/download')).resolves.toBeUndefined()
+  })
+})
+
+describe('downloadFile', () => {
+  it('fetches with credentials:include and triggers anchor download', async () => {
+    const fetchMock = makeFetchMock(200)
+    vi.stubGlobal('fetch', fetchMock)
+
+    const clickSpy = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {})
+
+    await downloadFile('/uploads/files/test.pdf', 'test.pdf')
+
+    expect(fetchMock).toHaveBeenCalledWith('/uploads/files/test.pdf', { credentials: 'include' })
+    expect(URL.createObjectURL).toHaveBeenCalled()
+    expect(clickSpy).toHaveBeenCalled()
+
+    // Revoke happens after setTimeout(100)
+    vi.runAllTimers()
+    expect(URL.revokeObjectURL).toHaveBeenCalledWith('blob:mock-url')
+  })
+
+  it('sets download attribute to filename when provided', async () => {
+    vi.stubGlobal('fetch', makeFetchMock(200))
+    vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {})
+
+    await downloadFile('/uploads/files/report.pdf', 'report.pdf')
+
+    // Check anchor was created with download attribute
+    const appendCalls = (document.body.appendChild as ReturnType<typeof vi.fn>).mock.calls
+    const anchor = appendCalls[0]?.[0] as HTMLAnchorElement
+    expect(anchor.download).toBe('report.pdf')
+  })
+
+  it('throws on 401 response', async () => {
+    vi.stubGlobal('fetch', makeFetchMock(401))
+    await expect(downloadFile('/uploads/files/secret.pdf')).rejects.toThrow('Unauthorized')
+    expect(URL.createObjectURL).not.toHaveBeenCalled()
+  })
+})
+
+describe('openFile', () => {
+  it('fetches with credentials:include and opens blob URL via target=_blank anchor', async () => {
+    vi.stubGlobal('fetch', makeFetchMock(200))
+    const openSpy = vi.spyOn(window, 'open').mockReturnValue(null)
+    const clickSpy = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {})
+
+    await openFile('/uploads/files/doc.pdf')
+
+    expect(window.fetch).toHaveBeenCalledWith('/uploads/files/doc.pdf', { credentials: 'include' })
+    expect(URL.createObjectURL).toHaveBeenCalled()
+    // Must NOT call window.open — that path returns null when noreferrer is
+    // set, which previously caused the file to also open in the current tab.
+    expect(openSpy).not.toHaveBeenCalled()
+    expect(clickSpy).toHaveBeenCalledTimes(1)
+
+    // The anchor used to open the new tab must be target=_blank, must NOT
+    // carry a `download` attribute (otherwise it would download in-page
+    // instead of opening), and must use rel=noopener noreferrer.
+    const appendCalls = (document.body.appendChild as ReturnType<typeof vi.fn>).mock.calls
+    const anchor = appendCalls[0]?.[0] as HTMLAnchorElement
+    expect(anchor.target).toBe('_blank')
+    expect(anchor.rel).toBe('noopener noreferrer')
+    expect(anchor.hasAttribute('download')).toBe(false)
+
+    // Revoke happens after 30s timeout
+    vi.runAllTimers()
+    expect(URL.revokeObjectURL).toHaveBeenCalledWith('blob:mock-url')
+  })
+
+  it('does not trigger a second in-page action for safe inline types (regression: no double-open)', async () => {
+    vi.stubGlobal('fetch', makeFetchMock(200))
+    const clickSpy = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {})
+
+    await openFile('/uploads/files/doc.pdf', 'doc.pdf')
+
+    // Exactly ONE anchor click — opening the new tab. No fallback download.
+    expect(clickSpy).toHaveBeenCalledTimes(1)
+  })
+
+  it('throws on 401 response', async () => {
+    vi.stubGlobal('fetch', makeFetchMock(401, new Blob([], { type: 'application/pdf' })))
+    await expect(openFile('/uploads/files/secret.pdf')).rejects.toThrow('Unauthorized')
+    expect(URL.createObjectURL).not.toHaveBeenCalled()
+  })
+
+  it('forces download for unsafe MIME types (HTML) instead of opening inline', async () => {
+    const htmlBlob = new Blob(['<script>alert(1)</script>'], { type: 'text/html' })
+    vi.stubGlobal('fetch', makeFetchMock(200, htmlBlob))
+    const openSpy = vi.spyOn(window, 'open').mockReturnValue({} as Window)
+    const clickSpy = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {})
+
+    await openFile('/uploads/files/malicious.html', 'malicious.html')
+
+    // Must NOT open inline — download anchor clicked instead
+    expect(openSpy).not.toHaveBeenCalled()
+    expect(clickSpy).toHaveBeenCalledTimes(1)
+
+    const appendCalls = (document.body.appendChild as ReturnType<typeof vi.fn>).mock.calls
+    const anchor = appendCalls[0]?.[0] as HTMLAnchorElement
+    expect(anchor.download).toBe('malicious.html')
+  })
+
+  it('forces download for SVG MIME type', async () => {
+    const svgBlob = new Blob(['<svg><script>alert(1)</script></svg>'], { type: 'image/svg+xml' })
+    vi.stubGlobal('fetch', makeFetchMock(200, svgBlob))
+    const openSpy = vi.spyOn(window, 'open').mockReturnValue({} as Window)
+    const clickSpy = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {})
+
+    await openFile('/uploads/files/malicious.svg')
+
+    expect(openSpy).not.toHaveBeenCalled()
+    expect(clickSpy).toHaveBeenCalledTimes(1)
+  })
+
+  it('falls back to download in iOS PWA standalone mode (blob URL inaccessible to Safari)', async () => {
+    vi.stubGlobal('fetch', makeFetchMock(200))
+    const clickSpy = vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {})
+    // Simulate iOS PWA (Add-to-Home-Screen) context
+    Object.defineProperty(navigator, 'standalone', { configurable: true, value: true })
+
+    try {
+      await openFile('/uploads/files/doc.pdf', 'doc.pdf')
+
+      // Single anchor click — and it must be a DOWNLOAD anchor (no target=_blank),
+      // because target="_blank" in iOS PWA would hand off to Safari which cannot
+      // read the in-WebView blob URL.
+      expect(clickSpy).toHaveBeenCalledTimes(1)
+      const appendCalls = (document.body.appendChild as ReturnType<typeof vi.fn>).mock.calls
+      const anchor = appendCalls[0]?.[0] as HTMLAnchorElement
+      expect(anchor.target).toBe('')
+      expect(anchor.download).toBe('doc.pdf')
+    } finally {
+      // Clean up the non-standard iOS-only property we forced above.
+      delete (navigator as any).standalone
+    }
+  })
+})
+
+describe('offline fallback (#1046)', () => {
+  function setOnline(value: boolean) {
+    Object.defineProperty(navigator, 'onLine', { value, configurable: true })
+  }
+  beforeEach(() => vi.mocked(getCachedBlob).mockReset())
+  afterEach(() => setOnline(true))
+
+  it('serves the cached blob without a network call when offline', async () => {
+    setOnline(false)
+    const blob = new Blob(['x'], { type: 'application/pdf' })
+    vi.mocked(getCachedBlob).mockResolvedValue(blob)
+    const fetchSpy = vi.fn()
+    vi.stubGlobal('fetch', fetchSpy)
+    vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {})
+
+    await downloadFile('/uploads/files/cached.pdf')
+
+    expect(fetchSpy).not.toHaveBeenCalled()
+    expect(getCachedBlob).toHaveBeenCalledWith('/uploads/files/cached.pdf')
+    expect(URL.createObjectURL).toHaveBeenCalledWith(blob)
+  })
+
+  it('falls back to the cache when a live fetch rejects (network error) while online', async () => {
+    setOnline(true)
+    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('network down')))
+    const blob = new Blob(['x'], { type: 'application/pdf' })
+    vi.mocked(getCachedBlob).mockResolvedValue(blob)
+    vi.spyOn(HTMLAnchorElement.prototype, 'click').mockImplementation(() => {})
+
+    await downloadFile('/uploads/files/cached.pdf')
+
+    expect(getCachedBlob).toHaveBeenCalledWith('/uploads/files/cached.pdf')
+    expect(URL.createObjectURL).toHaveBeenCalledWith(blob)
+  })
+
+  it('throws when offline and the file was never cached', async () => {
+    setOnline(false)
+    vi.mocked(getCachedBlob).mockResolvedValue(null)
+    await expect(downloadFile('/uploads/files/missing.pdf')).rejects.toThrow(/offline/i)
+  })
+
+  it('does not consult the cache on an HTTP error — a 401 still surfaces', async () => {
+    setOnline(true)
+    vi.stubGlobal('fetch', makeFetchMock(401))
+    await expect(downloadFile('/uploads/files/secret.pdf')).rejects.toThrow('Unauthorized')
+    expect(getCachedBlob).not.toHaveBeenCalled()
+  })
+})
diff --git a/client/tests/unit/utils/formatters.test.ts b/client/tests/unit/utils/formatters.test.ts
new file mode 100644
index 0000000000000000000000000000000000000000..961070028bea576705ecdf0392615b6eb6fafb7b
--- /dev/null
+++ b/client/tests/unit/utils/formatters.test.ts
@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest';
+import { formatDate, formatTime, dayTotalCost, currencyDecimals } from '../../../src/utils/formatters';
+import type { AssignmentsMap } from '../../../src/types';
+
+// dayTotalCost intentionally exercises edge-case price inputs (string / non-numeric),
+// which are looser than the canonical AssignmentsMap shape — hence the casts below.
+const asMap = (m: unknown): AssignmentsMap => m as AssignmentsMap;
+
+describe('currencyDecimals', () => {
+  it('returns 0 for zero-decimal currencies', () => {
+    expect(currencyDecimals('JPY')).toBe(0);
+    expect(currencyDecimals('KRW')).toBe(0);
+    expect(currencyDecimals('jpy')).toBe(0); // case-insensitive
+  });
+
+  it('returns 2 for standard currencies', () => {
+    expect(currencyDecimals('EUR')).toBe(2);
+    expect(currencyDecimals('USD')).toBe(2);
+    expect(currencyDecimals('GBP')).toBe(2);
+  });
+});
+
+describe('formatDate', () => {
+  it('returns null for null/undefined input', () => {
+    expect(formatDate(null, 'en-US')).toBeNull();
+    expect(formatDate(undefined, 'en-US')).toBeNull();
+  });
+
+  it('formats a date string and returns a non-empty string', () => {
+    const result = formatDate('2025-06-01', 'en-US');
+    expect(result).not.toBeNull();
+    expect(typeof result).toBe('string');
+    expect(result!.length).toBeGreaterThan(0);
+  });
+
+  it('accepts an optional timeZone parameter without throwing', () => {
+    const result = formatDate('2025-06-01', 'en-US', 'America/New_York');
+    expect(result).not.toBeNull();
+  });
+});
+
+describe('formatTime', () => {
+  it('returns empty string for null/undefined', () => {
+    expect(formatTime(null, 'en-US', '24h')).toBe('');
+    expect(formatTime(undefined, 'en-US', '24h')).toBe('');
+  });
+
+  it('formats 24h time', () => {
+    expect(formatTime('14:30', 'en-US', '24h')).toBe('14:30');
+    expect(formatTime('09:05', 'en-US', '24h')).toBe('09:05');
+  });
+
+  it('appends Uhr suffix for German locale in 24h mode', () => {
+    expect(formatTime('14:30', 'de-DE', '24h')).toBe('14:30 Uhr');
+  });
+
+  it('formats 12h time', () => {
+    expect(formatTime('14:30', 'en-US', '12h')).toBe('2:30 PM');
+    expect(formatTime('00:00', 'en-US', '12h')).toBe('12:00 AM');
+    expect(formatTime('12:00', 'en-US', '12h')).toBe('12:00 PM');
+    expect(formatTime('01:00', 'en-US', '12h')).toBe('1:00 AM');
+  });
+});
+
+describe('dayTotalCost', () => {
+  it('returns null when there are no assignments', () => {
+    expect(dayTotalCost(1, {}, 'EUR')).toBeNull();
+  });
+
+  it('returns null when no places have prices', () => {
+    const assignments = {
+      '1': [
+        { id: 1, day_id: 1, order_index: 0, notes: null, place: { id: 1, trip_id: 1, name: 'P', lat: null, lng: null, description: null, address: null, category_id: null, icon: null, price: null, image_url: null, google_place_id: null, osm_id: null, route_geometry: null, place_time: null, end_time: null, created_at: '' } },
+      ],
+    };
+    expect(dayTotalCost(1, asMap(assignments), 'EUR')).toBeNull();
+  });
+
+  it('sums prices across assignments', () => {
+    const assignments = {
+      '1': [
+        { id: 1, day_id: 1, order_index: 0, notes: null, place: { id: 1, trip_id: 1, name: 'A', lat: null, lng: null, description: null, address: null, category_id: null, icon: null, price: '20', image_url: null, google_place_id: null, osm_id: null, route_geometry: null, place_time: null, end_time: null, created_at: '' } },
+        { id: 2, day_id: 1, order_index: 1, notes: null, place: { id: 2, trip_id: 1, name: 'B', lat: null, lng: null, description: null, address: null, category_id: null, icon: null, price: '30', image_url: null, google_place_id: null, osm_id: null, route_geometry: null, place_time: null, end_time: null, created_at: '' } },
+      ],
+    };
+    expect(dayTotalCost(1, asMap(assignments), 'EUR')).toBe('50 EUR');
+  });
+
+  it('ignores non-numeric price strings', () => {
+    const assignments = {
+      '1': [
+        { id: 1, day_id: 1, order_index: 0, notes: null, place: { id: 1, trip_id: 1, name: 'A', lat: null, lng: null, description: null, address: null, category_id: null, icon: null, price: 'free', image_url: null, google_place_id: null, osm_id: null, route_geometry: null, place_time: null, end_time: null, created_at: '' } },
+      ],
+    };
+    expect(dayTotalCost(1, asMap(assignments), 'EUR')).toBeNull();
+  });
+
+  it('uses the dayId key to look up assignments', () => {
+    const assignments = {
+      '2': [
+        { id: 3, day_id: 2, order_index: 0, notes: null, place: { id: 3, trip_id: 1, name: 'C', lat: null, lng: null, description: null, address: null, category_id: null, icon: null, price: '10', image_url: null, google_place_id: null, osm_id: null, route_geometry: null, place_time: null, end_time: null, created_at: '' } },
+      ],
+    };
+    expect(dayTotalCost(1, asMap(assignments), 'USD')).toBeNull();
+    expect(dayTotalCost(2, asMap(assignments), 'USD')).toBe('10 USD');
+  });
+});
diff --git a/client/tsconfig.json b/client/tsconfig.json
new file mode 100644
index 0000000000000000000000000000000000000000..d3c51f17e37c152ed6b23feb1e6b1b4c2f4c2bad
--- /dev/null
+++ b/client/tsconfig.json
@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "baseUrl": ".",
+    "ignoreDeprecations": "6.0",
+    "paths": {
+      "@trek/shared": ["../shared/src/index.ts"],
+      "@trek/shared/*": ["../shared/src/*"]
+    },
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "allowJs": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src", "tests"]
+}
diff --git a/client/vite.config.js b/client/vite.config.js
new file mode 100644
index 0000000000000000000000000000000000000000..b08517b0034e1b4acd8785916ce5dcc321ebca4c
--- /dev/null
+++ b/client/vite.config.js
@@ -0,0 +1,157 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import { VitePWA } from 'vite-plugin-pwa'
+
+export default defineConfig({
+  plugins: [
+    react(),
+    VitePWA({
+      registerType: 'autoUpdate',
+      workbox: {
+        maximumFileSizeToCacheInBytes: 10 * 1024 * 1024,
+        globPatterns: ['**/*.{js,css,html,svg,png,woff,woff2,ttf}'],
+        navigateFallback: 'index.html',
+        navigateFallbackDenylist: [/^\/api/, /^\/uploads/, /^\/mcp/, /^\/oauth\//, /^\/.well-known\//],
+        runtimeCaching: [
+          {
+            // Carto map tiles (default provider)
+            // maxEntries MUST stay >= MAX_TILES in src/sync/tilePrefetcher.ts
+            // (both are 12288) so prefetched tiles aren't evicted on arrival.
+            urlPattern: /^https:\/\/[a-d]\.basemaps\.cartocdn\.com\/.*/i,
+            handler: 'CacheFirst',
+            options: {
+              cacheName: 'map-tiles',
+              expiration: { maxEntries: 12288, maxAgeSeconds: 30 * 24 * 60 * 60 },
+              cacheableResponse: { statuses: [0, 200] },
+            },
+          },
+          {
+            // OpenStreetMap tiles (fallback / alternative)
+            // Shares the 'map-tiles' cache; keep maxEntries equal to the Carto
+            // rule above and MAX_TILES in src/sync/tilePrefetcher.ts (12288).
+            urlPattern: /^https:\/\/[a-c]\.tile\.openstreetmap\.org\/.*/i,
+            handler: 'CacheFirst',
+            options: {
+              cacheName: 'map-tiles',
+              expiration: { maxEntries: 12288, maxAgeSeconds: 30 * 24 * 60 * 60 },
+              cacheableResponse: { statuses: [0, 200] },
+            },
+          },
+          {
+            // Leaflet CSS/JS from unpkg CDN
+            urlPattern: /^https:\/\/unpkg\.com\/.*/i,
+            handler: 'CacheFirst',
+            options: {
+              cacheName: 'cdn-libs',
+              expiration: { maxEntries: 30, maxAgeSeconds: 365 * 24 * 60 * 60 },
+              cacheableResponse: { statuses: [0, 200] },
+            },
+          },
+          {
+            // Mapbox GL style, glyphs, sprites and vector tiles. Best-effort
+            // offline only: opportunistically caches what the user has already
+            // viewed online. Full pre-download offline maps require the Leaflet
+            // renderer (raster prefetch in tilePrefetcher.ts) — the GL vector
+            // pipeline is not prefetched. StaleWhileRevalidate keeps the basemap
+            // fresh online while still serving from cache when offline. Mapbox
+            // sends CORS, so responses are non-opaque (real 200s, no quota pad).
+            urlPattern: /^https:\/\/(api\.mapbox\.com|[a-d]\.tiles\.mapbox\.com)\/.*/i,
+            handler: 'StaleWhileRevalidate',
+            options: {
+              cacheName: 'mapbox-tiles',
+              expiration: { maxEntries: 3000, maxAgeSeconds: 30 * 24 * 60 * 60 },
+              cacheableResponse: { statuses: [200] },
+            },
+          },
+          {
+            // API calls — network only. We deliberately do NOT cache API
+            // responses in the Service Worker: Workbox keys entries by URL and
+            // cannot vary on the httpOnly session cookie, so a shared device
+            // could serve one user's cached data to the next (cross-user leak).
+            // Offline reads are served from the per-user IndexedDB cache via the
+            // repo layer instead. The urlPattern is kept so these requests still
+            // bypass the SPA navigation fallback.
+            urlPattern: /\/api\/(?!auth|admin|backup|settings|health).*/i,
+            handler: 'NetworkOnly',
+          },
+          {
+            // Uploaded files (photos, covers — public assets only)
+            urlPattern: /\/uploads\/(?:covers|avatars)\/.*/i,
+            handler: 'CacheFirst',
+            options: {
+              cacheName: 'user-uploads',
+              expiration: { maxEntries: 300, maxAgeSeconds: 7 * 24 * 60 * 60 },
+              cacheableResponse: { statuses: [200] },
+            },
+          },
+        ],
+      },
+      manifest: {
+        name: 'TREK \u2014 Travel Planner',
+        short_name: 'TREK',
+        description: 'Travel Resource & Exploration Kit',
+        theme_color: '#111827',
+        background_color: '#0f172a',
+        display: 'standalone',
+        scope: '/',
+        start_url: '/',
+        categories: ['travel', 'navigation'],
+        icons: [
+          { src: 'icons/apple-touch-icon-180x180.png', sizes: '180x180', type: 'image/png' },
+          { src: 'icons/icon-192x192.png', sizes: '192x192', type: 'image/png' },
+          { src: 'icons/icon-512x512.png', sizes: '512x512', type: 'image/png' },
+          { src: 'icons/icon-512x512.png', sizes: '512x512', type: 'image/png', purpose: 'maskable' },
+          { src: 'icons/icon.svg', sizes: 'any', type: 'image/svg+xml' },
+        ],
+      },
+    }),
+  ],
+  build: {
+    sourcemap: false,
+    modulePreload: { polyfill: true },
+  },
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:3001',
+        changeOrigin: true,
+      },
+      '/uploads': {
+        target: 'http://localhost:3001',
+        changeOrigin: true,
+      },
+      '/ws': {
+        target: 'http://localhost:3001',
+        ws: true,
+      },
+      '/mcp': {
+        target: 'http://localhost:3001',
+        changeOrigin: true,
+      },
+      // OAuth 2.1 endpoints handled by backend (SDK authorize handler + token/revoke)
+      // /oauth/authorize goes to backend so the SDK can redirect to /oauth/consent
+      // /oauth/consent is served by Vite as a SPA route (no proxy entry needed)
+      '/oauth/authorize': {
+        target: 'http://localhost:3001',
+        changeOrigin: true,
+      },
+      '/oauth/token': {
+        target: 'http://localhost:3001',
+        changeOrigin: true,
+      },
+      '/oauth/register': {
+        target: 'http://localhost:3001',
+        changeOrigin: true,
+      },
+      '/oauth/revoke': {
+        target: 'http://localhost:3001',
+        changeOrigin: true,
+      },
+      '/.well-known': {
+        target: 'http://localhost:3001',
+        changeOrigin: true,
+      },
+    }
+  }
+})
diff --git a/client/vitest.config.ts b/client/vitest.config.ts
new file mode 100644
index 0000000000000000000000000000000000000000..97fdc1b06a36cc4492b05ee043a39b98bfb4076e
--- /dev/null
+++ b/client/vitest.config.ts
@@ -0,0 +1,29 @@
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    root: '.',
+    globals: true,
+    environment: './tests/environment/jsdom-native-abort.ts',
+    include: [
+      'tests/**/*.test.{ts,tsx}',
+      'src/**/*.test.{ts,tsx}',
+    ],
+    setupFiles: ['tests/setup.ts'],
+    testTimeout: 15000,
+    hookTimeout: 15000,
+    pool: 'forks',
+    silent: false,
+    reporters: ['verbose'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['lcov', 'text'],
+      reportsDirectory: './coverage',
+      include: ['src/**/*.{ts,tsx}'],
+      exclude: ['src/main.tsx', 'src/vite-env.d.ts'],
+    },
+    css: false,
+  },
+});
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000000000000000000000000000000000000..17cbdcae74e931cb8a969314ef796188cecaa301
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,57 @@
+services:
+  app:
+    image: mauriceboe/trek:dev
+    container_name: trek
+    read_only: true
+    security_opt:
+      - no-new-privileges:true
+    cap_drop:
+      - ALL
+    cap_add:
+      - CHOWN
+      - SETUID
+      - SETGID
+    tmpfs:
+      - /tmp:noexec,nosuid,size=128m
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+      - ENCRYPTION_KEY=${ENCRYPTION_KEY:-} # Recommended. Generate with: openssl rand -hex 32. If unset, falls back to data/.jwt_secret (existing installs) or auto-generates a key (fresh installs).
+      - TZ=${TZ:-UTC} # Timezone for logs, reminders and scheduled tasks (e.g. Europe/Berlin)
+      - LOG_LEVEL=${LOG_LEVEL:-info} # info = concise user actions; debug = verbose admin-level details
+#      - DEFAULT_LANGUAGE=en # Default language on the login page for users with no saved preference. Browser/OS language is auto-detected first; this is the fallback. Supported: de, en, es, fr, hu, nl, br, cs, pl, ru, zh, zh-TW, it, ar
+#      - SESSION_DURATION=30d # How long users stay logged in (trek_session JWT + cookie maxAge). Accepts: 1h | 12h | 7d | 30d | 90d. Default: 24h
+#      - SESSION_DURATION_REMEMBER=30d # Session length when "Remember me" is ticked at login: longer-lived JWT + persistent cookie that survives browser restarts. Same format as SESSION_DURATION. Default: 30d
+      - ALLOWED_ORIGINS=${ALLOWED_ORIGINS:-} # Comma-separated origins for CORS and email notification links
+#      - FORCE_HTTPS=true # Optional. Enables HTTPS redirect, HSTS, CSP upgrade-insecure-requests, and secure cookies behind a TLS proxy
+#      - HSTS_INCLUDE_SUBDOMAINS=false # When true: adds includeSubDomains to the HSTS header. Only effective when HSTS is active. Leave false if sibling subdomains still run over plain HTTP.
+#      - COOKIE_SECURE=false # Escape hatch: force session cookies over plain HTTP even in production. Not recommended.
+#      - TRUST_PROXY=1 # Trusted proxy count for X-Forwarded-For / X-Forwarded-Proto. Required for FORCE_HTTPS to work.
+#      - ALLOW_INTERNAL_NETWORK=false # Set to true if Immich or other services are hosted on your local network (RFC-1918 IPs). Loopback and link-local addresses remain blocked regardless.
+#      - APP_URL=https://trek.example.com # Public base URL — required when OIDC is enabled (must match the redirect URI registered with your IdP); also used as base URL for links in email notifications
+#      - OIDC_ISSUER=https://auth.example.com # OpenID Connect provider URL
+#      - OIDC_CLIENT_ID=trek # OpenID Connect client ID
+#      - OIDC_CLIENT_SECRET=supersecret # OpenID Connect client secret
+#      - OIDC_DISPLAY_NAME=SSO # Label shown on the SSO login button
+#      - OIDC_ONLY=false # Set true to force SSO-only mode: disables password login and registration, overrides Admin > Settings toggles, cannot be changed at runtime
+#      - OIDC_ADMIN_CLAIM=groups # OIDC claim used to identify admin users
+#      - OIDC_ADMIN_VALUE=app-trek-admins # Value of the OIDC claim that grants admin role
+#      - OIDC_SCOPE=openid email profile # Fully overrides the default. Add extra scopes as needed (e.g. add groups if using OIDC_ADMIN_CLAIM)
+#      - OIDC_DISCOVERY_URL= # Override the OIDC discovery endpoint for providers with non-standard paths (e.g. Authentik)
+#      - ADMIN_EMAIL=admin@trek.local # Initial admin e-mail — only used on first boot when no users exist
+#      - ADMIN_PASSWORD=changeme      # Initial admin password — only used on first boot when no users exist
+#      - MCP_RATE_LIMIT=300 # Max MCP API requests per user per minute (default: 300)
+#      - MCP_MAX_SESSION_PER_USER=20 # Max concurrent MCP sessions per user (default: 20)
+#      - KITINERARY_EXTRACTOR_PATH= # Optional. Full path to kitinerary-extractor binary. Auto-detected from PATH and /usr/lib/*/libexec/kf6/ when unset.
+    volumes:
+      - ./data:/app/data
+      - ./uploads:/app/uploads
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "http://localhost:3000/api/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 15s
diff --git a/docs/TREK-Generated-by-MCP.pdf b/docs/TREK-Generated-by-MCP.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..5112ed43e5d8d54262147f7705d8dcd6bd36b71b
Binary files /dev/null and b/docs/TREK-Generated-by-MCP.pdf differ
diff --git a/docs/logo-trek-dark.gif b/docs/logo-trek-dark.gif
new file mode 100644
index 0000000000000000000000000000000000000000..3fa5cb56639b4f1ebbc69d5eadea8c5f85af5914
Binary files /dev/null and b/docs/logo-trek-dark.gif differ
diff --git a/docs/logo-trek-light.gif b/docs/logo-trek-light.gif
new file mode 100644
index 0000000000000000000000000000000000000000..a7b7f60703f68cc1e6a2aaa1d846c91d752794fc
Binary files /dev/null and b/docs/logo-trek-light.gif differ
diff --git a/docs/screenshots/admin.png b/docs/screenshots/admin.png
new file mode 100644
index 0000000000000000000000000000000000000000..8797275b683338f5fd3df1c0c7fbad1526b8c9c0
Binary files /dev/null and b/docs/screenshots/admin.png differ
diff --git a/docs/screenshots/atlas.png b/docs/screenshots/atlas.png
new file mode 100644
index 0000000000000000000000000000000000000000..bb420dbdd059847cddce394461b089aab31744b6
Binary files /dev/null and b/docs/screenshots/atlas.png differ
diff --git a/docs/screenshots/budget.png b/docs/screenshots/budget.png
new file mode 100644
index 0000000000000000000000000000000000000000..a1bd19dedd96ce7d934032976dd6ed7d5d4afff0
Binary files /dev/null and b/docs/screenshots/budget.png differ
diff --git a/docs/screenshots/dashboard.png b/docs/screenshots/dashboard.png
new file mode 100644
index 0000000000000000000000000000000000000000..b2a6ad82a774decd20c05fa49af8139faaa33946
Binary files /dev/null and b/docs/screenshots/dashboard.png differ
diff --git a/docs/screenshots/journey.png b/docs/screenshots/journey.png
new file mode 100644
index 0000000000000000000000000000000000000000..f0deb0de09eb1e8f5403e431ab4738efff43bd8e
Binary files /dev/null and b/docs/screenshots/journey.png differ
diff --git a/docs/screenshots/trip-iceland.png b/docs/screenshots/trip-iceland.png
new file mode 100644
index 0000000000000000000000000000000000000000..cdbdaa4ab8d0e957bf1a12c92307e0c5818bfa25
Binary files /dev/null and b/docs/screenshots/trip-iceland.png differ
diff --git a/docs/screenshots/trip-planner.png b/docs/screenshots/trip-planner.png
new file mode 100644
index 0000000000000000000000000000000000000000..f95bcb746dd9e355ad15837200d1c296420f2d53
Binary files /dev/null and b/docs/screenshots/trip-planner.png differ
diff --git a/docs/screenshots/vacay.png b/docs/screenshots/vacay.png
new file mode 100644
index 0000000000000000000000000000000000000000..af76a6f4acce7e4f733a1bccdf0b1b72f1d732d5
Binary files /dev/null and b/docs/screenshots/vacay.png differ
diff --git a/docs/subtitle-dark.png b/docs/subtitle-dark.png
new file mode 100644
index 0000000000000000000000000000000000000000..73a09f70170ba26c0c6b78714818a344a7a3d87c
Binary files /dev/null and b/docs/subtitle-dark.png differ
diff --git a/docs/subtitle-light.png b/docs/subtitle-light.png
new file mode 100644
index 0000000000000000000000000000000000000000..07c5ba8141497708c7ba4e7bf4cdf6aa8c9fbb70
Binary files /dev/null and b/docs/subtitle-light.png differ
diff --git a/docs/system-notices.md b/docs/system-notices.md
new file mode 100644
index 0000000000000000000000000000000000000000..612a9ef3fa4ab6f4c2ef228b0e7f0209aaec4d63
--- /dev/null
+++ b/docs/system-notices.md
@@ -0,0 +1,765 @@
+# System Notices — Technical Documentation & Dev Guide
+
+System notices are server-evaluated, user-targeted messages shown in the TREK UI as modals, banners, or toasts. They are used for onboarding, upgrade announcements, breaking change warnings, and time-boxed campaigns. Every aspect — targeting, display, copy, and dismissal — is controlled from one place: the server-side registry.
+
+---
+
+## Table of Contents
+
+1. [Architecture overview](#1-architecture-overview)
+2. [Data flow](#2-data-flow)
+3. [Database schema](#3-database-schema)
+4. [The notice registry](#4-the-notice-registry)
+5. [Notice fields reference](#5-notice-fields-reference)
+6. [Condition system](#6-condition-system)
+7. [Display types](#7-display-types)
+8. [CTAs (call to action)](#8-ctas-call-to-action)
+9. [i18n — translation keys](#9-i18n--translation-keys)
+10. [Client store & dismissal](#10-client-store--dismissal)
+11. [Sorting & priority](#11-sorting--priority)
+12. [How-to recipes](#12-how-to-recipes)
+13. [Testing](#13-testing)
+14. [Rules & constraints](#14-rules--constraints)
+
+---
+
+## 1. Architecture overview
+
+```
+server/src/systemNotices/
+├── types.ts        — TypeScript types (SystemNotice, NoticeCondition, …)
+├── registry.ts     — Authoritative list of all notices (edit here to add/change/remove)
+├── conditions.ts   — Condition evaluators + custom predicate registry
+└── service.ts      — Queries DB, evaluates conditions, sorts, strips server-only fields
+
+server/src/routes/systemNotices.ts   — REST endpoints
+
+client/src/store/systemNoticeStore.ts             — Zustand store (fetch + optimistic dismiss)
+client/src/components/SystemNotices/
+├── SystemNoticeHost.tsx    — Renders all three channels (modal / banner / toast)
+├── SystemNoticeModal.tsx   — Modal renderer (pager, animations, keyboard nav)
+├── SystemNoticeBanner.tsx  — Banner + toast renderers
+└── noticeActions.ts        — Client-side action registry for action-kind CTAs
+
+client/src/pages/Trips/noticeActions.ts   — Example domain action registration
+```
+
+There are **no database rows for notice definitions**. The registry is code-only. The database only stores which notices a user has dismissed.
+
+---
+
+## 2. Data flow
+
+```
+1. User authenticates
+        │
+        ▼
+2. authStore.loadUser() completes
+        │
+        ▼
+3. SystemNoticeHost mounts → calls useSystemNoticeStore.fetch()
+        │   (also triggered on cold page reload if store not yet loaded)
+        ▼
+4. GET /api/system-notices/active
+        │
+        ▼
+5. service.getActiveNoticesFor(userId)
+   ├── reads user row  (login_count, first_seen_version, role)
+   ├── counts user trips
+   ├── reads user_notice_dismissals
+   ├── filters SYSTEM_NOTICES:
+   │     – not dismissed
+   │     – within [minVersion, maxVersion) range for the running app version
+   │     – all conditions pass (AND logic)
+   ├── sorts by priority → severity → publishedAt (desc)
+   └── strips server-only fields (conditions, publishedAt, minVersion, maxVersion, priority)
+        │
+        ▼
+6. Client receives SystemNoticeDTO[]
+        │
+        ▼
+7. SystemNoticeHost partitions by display type
+   ├── modal  → ModalRenderer  (multi-page pager, slide transitions)
+   ├── banner → BannerRenderer (sticky top bar, max 2)
+   └── toast  → ToastRenderer  (fires window.__addToast, auto-dismisses)
+        │
+        ▼
+8. User dismisses → POST /api/system-notices/:id/dismiss
+   ├── Server: INSERT OR IGNORE into user_notice_dismissals
+   └── Client: optimistic remove from store (retry once on failure)
+```
+
+---
+
+## 3. Database schema
+
+Added in **migration 101** (`server/src/db/migrations.ts`).
+
+### `users` columns (added by migration 101)
+
+| Column | Type | Default | Purpose |
+|---|---|---|---|
+| `first_seen_version` | `TEXT` | `'0.0.0'` | App version at account creation. Used by `existingUserBeforeVersion` condition. Backfilled users get `'0.0.0'`. |
+| `login_count` | `INTEGER` | `0` | Incremented on each successful login. Used by `firstLogin` condition. |
+
+### `user_notice_dismissals`
+
+| Column | Type | Notes |
+|---|---|---|
+| `user_id` | `INTEGER` | FK → `users.id` CASCADE DELETE |
+| `notice_id` | `TEXT` | Matches `SystemNotice.id` from registry |
+| `dismissed_at` | `INTEGER` | Unix ms timestamp |
+
+Primary key: `(user_id, notice_id)` — dismissals are idempotent.
+
+---
+
+## 4. The notice registry
+
+**`server/src/systemNotices/registry.ts`** is the single source of truth. Add, change, or retire notices here.
+
+```typescript
+export const SYSTEM_NOTICES: SystemNotice[] = [
+  {
+    id: 'my-notice',           // ← globally unique, never reuse
+    display: 'modal',
+    severity: 'info',
+    titleKey: 'system_notice.my_notice.title',
+    bodyKey:  'system_notice.my_notice.body',
+    dismissible: true,
+    conditions: [{ kind: 'firstLogin' }],
+    publishedAt: '2026-05-01T00:00:00Z',
+    priority: 50,
+  },
+];
+```
+
+### The golden rule for IDs
+
+**Never remove or renumber an entry. Never reuse an ID.**
+
+Dismissals are stored in the database keyed by `id`. Removing an entry means dismissed users would see it again if you ever add a notice with the same ID. If a notice is no longer needed, set `maxVersion` to the upper version on which it should appear (e.g. `4.0.0` means show notice until `4.0.0` is reached) — do not delete the entry.
+
+---
+
+## 5. Notice fields reference
+
+### Required fields
+
+| Field | Type | Description |
+|---|---|---|
+| `id` | `string` | Globally unique, stable identifier. Use kebab-case, descriptive, version-scoped when appropriate (`v3-photos`, `welcome-v1`). Max recommended length: 40 chars. |
+| `display` | `'modal' \| 'banner' \| 'toast'` | How the notice is rendered. See [§7 Display types](#7-display-types). |
+| `severity` | `'info' \| 'warn' \| 'critical'` | Affects colour scheme and accessibility role. `critical` notices cannot be toasts. |
+| `titleKey` | `string` | i18n key for the title. |
+| `bodyKey` | `string` | i18n key for the body. Markdown supported in modals; plain text only in banners/toasts. |
+| `dismissible` | `boolean` | If `false`, the X button and ESC key are hidden/blocked. Use only for `critical` notices that require action before proceeding. |
+| `conditions` | `NoticeCondition[]` | Empty array (`[]`) means always shown (same as `[{ kind: 'always' }]`). All conditions must pass (AND logic). |
+| `publishedAt` | `string` | ISO 8601 date. Used as a tiebreaker in sorting. Set to the deployment date. |
+
+### Optional fields
+
+| Field | Type | Description |
+|---|---|---|
+| `priority` | `number` | Higher number = shown first. Primary sort key. Default: `0`. |
+| `minVersion` | `string` | Lowest app version (inclusive, semver) that should show this notice. Omit for no lower bound. |
+| `maxVersion` | `string` | Upper bound (exclusive, semver) — notice is hidden once this version ships. `maxVersion: '4.0.0'` means shown on `< 4.0.0`. Omit for no upper bound. |
+| `icon` | `string` | Lucide icon name (e.g. `'Sparkles'`, `'ImageOff'`). Shown in the modal's severity icon circle. Falls back to the severity default icon if absent or unrecognised. |
+| `bodyParams` | `Record<string, string>` | Interpolation parameters for `bodyKey`. Values replace `{key}` placeholders in the translated string. **Never hardcode version numbers or dates directly in translation strings — use this instead.** |
+| `media` | `NoticeMedia` | Image to display in the modal. See below. |
+| `highlights` | `Array<{ labelKey: string; iconName?: string }>` | Bullet-point feature list rendered below the body in modals. Each entry is a translation key + optional Lucide icon name. |
+| `cta` | `NoticeCta` | Primary action button. See [§8 CTAs](#8-ctas-call-to-action). |
+
+> **Version bounds:** The range is `[minVersion, maxVersion)` — lower bound inclusive, upper bound exclusive. So `maxVersion: '4.0.0'` hides the notice once the app reaches 4.0.0. Both bounds are compared after stripping prerelease/build metadata via `semver.coerce`, so a server running `3.0.0-pre.42` is treated as `3.0.0` — consistent with `existingUserBeforeVersion` and staging environments behave like production.
+
+### `NoticeMedia`
+
+```typescript
+interface NoticeMedia {
+  src: string;          // URL or path
+  srcDark?: string;     // Optional dark-mode variant
+  altKey: string;       // i18n key for alt text
+  placement?: 'hero' | 'inline';  // default: 'hero' (full-width above body)
+  aspectRatio?: string; // CSS aspect-ratio value, default '16/9'
+}
+```
+
+### Character limits
+
+| Field | Modal | Banner | Toast |
+|---|---|---|---|
+| Title | ≤ 40 chars | ≤ 40 chars | ≤ 40 chars |
+| Body | ≤ 400 chars (markdown) | ≤ 140 chars (plain) | ≤ 80 chars (plain) |
+| CTA label | ≤ 20 chars, a verb | ≤ 20 chars | ≤ 20 chars |
+
+---
+
+## 6. Condition system
+
+Conditions are evaluated **server-side** on every `GET /api/system-notices/active` call. The client never sees conditions — only the filtered result.
+
+All conditions in `conditions[]` must pass (AND logic). To implement OR logic, create multiple notices with overlapping IDs is not possible — instead use a `custom` predicate with internal OR logic.
+
+### Built-in conditions
+
+#### `always`
+```typescript
+{ kind: 'always' }
+```
+Always passes. Equivalent to an empty `conditions` array.
+
+---
+
+#### `firstLogin`
+```typescript
+{ kind: 'firstLogin' }
+```
+Passes when `users.login_count <= 1`. The counter is incremented during login, so this fires on the first fetch after the very first login. Useful for onboarding notices.
+
+---
+
+#### `noTrips`
+```typescript
+{ kind: 'noTrips' }
+```
+Passes when the user has zero trips. Often combined with `firstLogin`.
+
+---
+
+#### `existingUserBeforeVersion`
+```typescript
+{ kind: 'existingUserBeforeVersion', version: '3.0.0' }
+```
+Passes when:
+- `users.first_seen_version < version` (user existed before this version)
+- AND the running app version `>= version` (the version has been deployed)
+
+Backfilled/legacy users have `first_seen_version = '0.0.0'` and always pass the first condition. Use this for upgrade announcements targeting users who were around before a breaking change.
+
+---
+
+#### `dateWindow`
+```typescript
+{ kind: 'dateWindow', startsAt: '2026-06-01T00:00:00Z', endsAt: '2026-07-01T00:00:00Z' }
+```
+Passes when the current server time is inside `[startsAt, endsAt]`. `endsAt` is optional (open-ended). Use for campaigns, maintenance banners, and time-limited promotions.
+
+---
+
+#### `role`
+```typescript
+{ kind: 'role', roles: ['admin'] }
+// or both roles:
+{ kind: 'role', roles: ['admin', 'user'] }
+```
+Passes when the user's role is in the given list.
+
+---
+
+#### `addonEnabled`
+```typescript
+{ kind: 'addonEnabled', addonId: 'journey' }
+```
+Passes when the named addon is enabled in admin settings. Addon IDs are the string values in `server/src/addons.ts` (`ADDON_IDS`). Use this to gate notices that promote features behind an addon.
+
+---
+
+#### `custom`
+```typescript
+{ kind: 'custom', id: 'my-predicate-id' }
+```
+Delegates evaluation to a predicate registered server-side with `registerPredicate`. This is the escape hatch for logic not covered by the built-in conditions.
+
+**Registering a custom predicate:**
+
+```typescript
+// server/src/systemNotices/conditions.ts exports registerPredicate
+import { registerPredicate } from '../systemNotices/conditions.js';
+
+registerPredicate('has-immich-configured', (ctx) => {
+  // ctx.user = { login_count, first_seen_version, role, noTrips }
+  // ctx.currentAppVersion = string
+  // ctx.now = Date
+  return someDbCheck(ctx.user);
+});
+```
+
+Register predicates at application startup before the first `getActiveNoticesFor` call.
+
+---
+
+### Combining conditions (AND)
+
+```typescript
+conditions: [
+  { kind: 'existingUserBeforeVersion', version: '3.0.0' },
+  { kind: 'addonEnabled', addonId: 'journey' },
+]
+// Only shows to pre-3.0 users AND only if the journey addon is enabled.
+```
+
+---
+
+## 7. Display types
+
+### `modal`
+
+Full-screen overlay with backdrop. On mobile: bottom sheet with drag-to-dismiss. On desktop: centered card.
+
+**Features:**
+- Markdown body (via `react-markdown` + `remark-gfm` + `rehype-sanitize`)
+- Optional hero or inline image
+- Optional highlights list (icon + label bullets)
+- Optional CTA button + "Not now" link
+- OK button when no CTA is defined
+- **Multi-page pager**: when multiple modal notices are active simultaneously, they are rendered as a paginated single modal with prev/next arrows, dot indicators, `N / M` counter, and keyboard arrow navigation
+- Slide transition between pages
+- ESC to dismiss all (if current notice is dismissible)
+- CTA and OK dismiss **all** active modal notices, not just the current page
+- "Not now" dismisses only the current page
+
+**Non-dismissible modals** (`dismissible: false`): X button, ESC key, and pager navigation are all disabled until the user acts on the CTA. Use only for `critical` severity.
+
+---
+
+### `banner`
+
+Sticky top bar below the navigation. Slides in with a translate-Y animation.
+
+**Constraints:**
+- Maximum 2 banners shown simultaneously (the 2 highest-priority active banners)
+- Plain text only (no markdown)
+- RTL-aware left-border accent
+- Reports its height via a CSS variable `--banner-stack-h` for layout reflow
+
+---
+
+### `toast`
+
+Fires the global `window.__addToast` toast system. Auto-dismisses after 6 s (`info`) or 9 s (`warn`). The notice is dismissed from the store after the toast expires.
+
+**Constraints:**
+- `critical` severity is not allowed as a toast — the renderer logs a warning and auto-dismisses it instead
+- Plain text only
+- No interaction (no CTA rendered via toast)
+
+---
+
+## 8. CTAs (call to action)
+
+A CTA renders as the primary blue button in modals and as an underline link in banners. There are two kinds.
+
+### `nav` — navigate to a route
+
+```typescript
+cta: {
+  kind: 'nav',
+  labelKey: 'system_notice.my_notice.cta_label',
+  href: '/journey',
+}
+```
+
+On click: navigates to `href` using React Router, then **dismisses all active modal notices** (or the current banner notice). The label is resolved through the i18n system.
+
+---
+
+### `action` — run a registered client-side handler
+
+```typescript
+cta: {
+  kind: 'action',
+  labelKey: 'system_notice.my_notice.cta_label',
+  actionId: 'open:trip-create',
+  dismissOnAction: true,  // default true — set false to keep notice open after action
+}
+```
+
+On click: looks up `actionId` in the client-side action registry and calls the handler, then **dismisses all active modal notices**.
+
+**To add a new action:**
+
+1. Create (or extend) a `noticeActions.ts` file in the relevant feature directory:
+
+```typescript
+// client/src/pages/MyFeature/noticeActions.ts
+import { registerNoticeAction } from '../../components/SystemNotices/noticeActions.js';
+
+registerNoticeAction('open:my-feature', ({ navigate }) => {
+  navigate('/my-feature?from=notice');
+});
+```
+
+2. Import it as a side-effect in `client/src/App.tsx`:
+
+```typescript
+import './pages/MyFeature/noticeActions.js'
+```
+
+3. The registry integrity test (`server/tests/unit/systemNotices/registry.test.ts`) automatically scans all `noticeActions.ts` files and verifies that every `actionId` in the registry is registered. The test will fail if you add an `actionId` to the registry without registering it on the client.
+
+**Action handler signature:**
+
+```typescript
+(ctx: NoticeActionContext) => void | Promise<void>
+
+interface NoticeActionContext {
+  navigate: NavigateFunction; // React Router navigate function
+}
+```
+
+### Dismiss behaviour summary
+
+| Trigger | What is dismissed |
+|---|---|
+| X button (modal) | All active modal notices |
+| ESC key | All active modal notices (if current is dismissible) |
+| CTA button | All active modal notices |
+| OK button (no CTA) | All active modal notices |
+| "Not now" link | Current page only |
+| Banner dismiss (X) | That banner only |
+| Backdrop click (modal) | Current page only |
+| Swipe down (mobile) | Current page only |
+| Toast expires | That toast only |
+
+---
+
+## 9. i18n — translation keys
+
+Every notice field that is user-visible (`titleKey`, `bodyKey`, CTA `labelKey`, highlight `labelKey`, media `altKey`) is an i18n key resolved through `useTranslation().t()`. The key string is what gets stored in the registry; the display value lives in the translation files.
+
+**Translation files location:** `client/src/i18n/translations/` (15 files: `en`, `de`, `fr`, `es`, `it`, `nl`, `pl`, `cs`, `hu`, `ru`, `zh`, `zhTw`, `ar`, `br`, `id`)
+
+### Key naming convention
+
+```
+system_notice.<notice_id_snake>.<field>
+```
+
+Examples:
+```
+system_notice.welcome_v1.title
+system_notice.welcome_v1.body
+system_notice.welcome_v1.cta_label
+system_notice.welcome_v1.highlight_plan
+system_notice.welcome_v1.hero_alt
+```
+
+### Adding keys
+
+Add the English key to `client/src/i18n/translations/en.ts` first, then replicate to the other 14 files. Group related notice keys together with a comment:
+
+```typescript
+// System notices — my feature
+'system_notice.my_notice.title': 'My feature is here',
+'system_notice.my_notice.body': 'Here is what changed.',
+'system_notice.my_notice.cta_label': 'Explore',
+```
+
+### `bodyParams` interpolation
+
+For values that vary at runtime (version numbers, dates, counts), use `{placeholder}` syntax in the translation string and pass `bodyParams` in the registry entry:
+
+```typescript
+// In registry:
+bodyKey: 'system_notice.my_notice.body',
+bodyParams: { version: '3.1.0', date: '1 May 2026' },
+
+// In en.ts:
+'system_notice.my_notice.body': 'TREK {version} was released on {date}.',
+```
+
+**Never hardcode dynamic values directly in translation strings.** The interpolation runs client-side in `ModalRenderer` before rendering.
+
+### Multiline bodies (modals only)
+
+Use `\n\n` (escaped, not literal newlines) for paragraph breaks in modal body strings:
+
+```typescript
+'system_notice.my_notice.body': 'First paragraph.\n\nSecond paragraph.',
+```
+
+Literal newlines in single-quoted TypeScript strings cause a parse error.
+
+### Pager i18n keys
+
+The pager UI uses its own keys (already present in all 15 files):
+
+```
+system_notice.pager.prev       → "Previous notice"
+system_notice.pager.next       → "Next notice"
+system_notice.pager.counter    → "{current} / {total}"
+system_notice.pager.goto       → "Go to notice {n}"
+system_notice.pager.position   → "Notice {current} of {total}"  (aria-live)
+```
+
+---
+
+## 10. Client store & dismissal
+
+`client/src/store/systemNoticeStore.ts` (Zustand, no persistence).
+
+| Action | Behaviour |
+|---|---|
+| `fetch()` | `GET /api/system-notices/active`. Fails silently (non-critical). Sets `loaded = true` regardless. |
+| `dismiss(id)` | Optimistic: removes notice from store immediately. POSTs to `/api/system-notices/{id}/dismiss` in background with one retry on failure. |
+
+`SystemNoticeHost` triggers `fetch()` on mount if `loaded === false`. Auth store also triggers it after login, so on a fresh login the fetch happens exactly once.
+
+---
+
+## 11. Sorting & priority
+
+Notices are sorted before being sent to the client. The sort order is:
+
+1. **`priority`** (descending) — primary key. Higher number appears first.
+2. **`severity`** (descending) — tiebreaker: `critical` (2) > `warn` (1) > `info` (0).
+3. **`publishedAt`** (descending) — final tiebreaker: more recent notices first.
+
+This means `priority` always wins over severity. Assign priorities deliberately so the intended reading order is preserved when multiple notices are active simultaneously.
+
+Current priority allocations in the registry:
+
+| Range | Use |
+|---|---|
+| 100 | Onboarding / first-login |
+| 80–90 | Major version upgrade notices |
+| 50–70 | Feature announcements |
+| 10–40 | Campaigns, banners |
+| 0 (default) | Miscellaneous |
+
+---
+
+## 12. How-to recipes
+
+### Add a new modal notice
+
+1. **Registry** — add an entry to `SYSTEM_NOTICES` in `server/src/systemNotices/registry.ts`:
+
+```typescript
+{
+  id: 'my-feature-v2',
+  display: 'modal',
+  severity: 'info',
+  icon: 'Zap',
+  titleKey: 'system_notice.my_feature_v2.title',
+  bodyKey:  'system_notice.my_feature_v2.body',
+  highlights: [
+    { labelKey: 'system_notice.my_feature_v2.highlight_one', iconName: 'Check' },
+  ],
+  cta: {
+    kind: 'nav',
+    labelKey: 'system_notice.my_feature_v2.cta_label',
+    href: '/my-feature',
+  },
+  dismissible: true,
+  conditions: [{ kind: 'existingUserBeforeVersion', version: '2.0.0' }],
+  publishedAt: '2026-06-01T00:00:00Z',
+  priority: 60,
+},
+```
+
+2. **i18n** — add keys to `client/src/i18n/translations/en.ts` and the 14 other language files.
+
+3. **Test** — run `cd server && npx vitest run tests/unit/systemNotices/` to verify registry integrity.
+
+---
+
+### Add a notice with an action CTA
+
+1. Create the action handler in the relevant feature directory:
+
+```typescript
+// client/src/pages/MyFeature/noticeActions.ts
+import { registerNoticeAction } from '../../components/SystemNotices/noticeActions.js';
+
+registerNoticeAction('open:my-feature-dialog', ({ navigate }) => {
+  navigate('/my-feature?dialog=welcome');
+});
+```
+
+2. Import it in `client/src/App.tsx`:
+
+```typescript
+import './pages/MyFeature/noticeActions.js'
+```
+
+3. Reference the `actionId` in the registry:
+
+```typescript
+cta: {
+  kind: 'action',
+  labelKey: 'system_notice.my_notice.cta_label',
+  actionId: 'open:my-feature-dialog',
+},
+```
+
+The registry integrity test will catch any `actionId` that appears in the registry but lacks a `registerNoticeAction` call.
+
+---
+
+### Retire a notice (stop showing it)
+
+**Do not delete the entry.** Set `maxVersion` to the last app version on which the notice should appear. Once the app is upgraded past that version, the service filters it out automatically. The database row for dismissed users remains harmless.
+
+```typescript
+{
+  id: 'old-campaign',
+  // ... all existing fields unchanged ...
+  maxVersion: '3.1.0',   // hidden once 3.1.0 ships (exclusive upper bound)
+}
+```
+
+To scope a notice to a specific version window (e.g. a v3-only announcement), combine both bounds:
+
+```typescript
+{
+  id: 'v3-only',
+  minVersion: '3.0.0',
+  maxVersion: '4.0.0',   // shown on >= 3.0.0 and < 4.0.0
+}
+```
+
+---
+
+### Show a notice only during a campaign window
+
+Combine `dateWindow` with any other targeting conditions:
+
+```typescript
+conditions: [
+  { kind: 'dateWindow', startsAt: '2026-06-15T00:00:00Z', endsAt: '2026-06-30T23:59:59Z' },
+  { kind: 'role', roles: ['admin'] },
+],
+```
+
+---
+
+### Show a notice only if an addon is enabled
+
+```typescript
+conditions: [
+  { kind: 'addonEnabled', addonId: 'journey' },
+],
+```
+
+Addon IDs are the string values in `server/src/addons.ts` → `ADDON_IDS`.
+
+---
+
+### Add a custom condition
+
+```typescript
+// server/src/startup.ts (or wherever your bootstrap code runs)
+import { registerPredicate } from './systemNotices/conditions.js';
+
+registerPredicate('has-no-profile-photo', (ctx) => {
+  const row = db.prepare('SELECT avatar FROM users WHERE id = ?').get(ctx.user.id);
+  return !row?.avatar;
+});
+```
+
+Then reference it in the registry:
+
+```typescript
+conditions: [{ kind: 'custom', id: 'has-no-profile-photo' }],
+```
+
+---
+
+### Create a multipage upgrade announcement
+
+Give multiple notices the same `conditions` and adjacent `priority` values. The pager groups all active modal notices together automatically — no extra wiring required.
+
+```typescript
+// Page 1 — breaking change (higher priority, warn severity)
+{ id: 'v4-breaking', priority: 90, severity: 'warn', conditions: [{ kind: 'existingUserBeforeVersion', version: '4.0.0' }], ... },
+
+// Page 2 — new feature (lower priority, info severity)
+{ id: 'v4-feature',  priority: 80, severity: 'info', conditions: [{ kind: 'existingUserBeforeVersion', version: '4.0.0' }], ... },
+```
+
+Users who have already dismissed page 1 will only see page 2 on their next session.
+
+---
+
+## 13. Testing
+
+### Server unit tests
+
+**`server/tests/unit/systemNotices/conditions.test.ts`**
+
+Tests each condition kind in isolation using `evaluate()` directly. No DB required.
+
+**`server/tests/unit/systemNotices/registry.test.ts`**
+
+Validates registry integrity:
+- No duplicate `id` values
+- All `action` CTA `actionId`s have a corresponding `registerNoticeAction()` call in the client source (scanned via regex — no JSON file needed)
+- All `publishedAt` values parse as valid ISO dates
+
+Run: `cd server && npx vitest run tests/unit/systemNotices/`
+
+**`server/tests/integration/systemNotices.test.ts`**
+
+Integration tests against a real in-memory SQLite database:
+- `GET /api/system-notices/active` returns 401 without auth, returns correct notices per user state
+- `POST /api/system-notices/:id/dismiss` stores the dismissal and filters on subsequent requests
+- Dismissing an unknown ID returns 404
+
+Run: `cd server && npx vitest run tests/integration/systemNotices.test.ts`
+
+---
+
+### Client unit tests
+
+**`client/src/components/SystemNotices/SystemNoticeModal.test.tsx`**
+
+Tests `ModalRenderer` with fake timers (`vi.useFakeTimers()`) and MSW for the dismiss endpoint. Key helpers:
+
+```typescript
+// Flush the 500 ms grace delay that gates the modal's visible state
+async function flushGraceDelay() {
+  await act(async () => { vi.runAllTimers(); });
+}
+
+// Minimal notice factory
+function makeNotice(overrides?: Partial<SystemNoticeDTO>): SystemNoticeDTO
+```
+
+Covered cases (FE-SN-MODAL-001 to 018):
+- Grace delay before visibility
+- Dismiss button, X button, ESC key
+- Non-dismissible notices (all affordances blocked)
+- CTA nav button — dismisses all notices
+- Body param interpolation
+- Pager: counter, dots, prev/next buttons, keyboard arrows, dot click, non-dismissible lock
+- Dismiss-does-not-skip regression
+- X and ESC dismiss all in multipage scenario
+- Last notice close
+
+Run: `cd client && npm run test -- SystemNoticeModal`
+
+---
+
+### Running all notice tests
+
+```bash
+cd server && npx vitest run tests/unit/systemNotices/ tests/integration/systemNotices.test.ts
+cd client && npm run test -- SystemNoticeModal
+```
+
+---
+
+## 14. Rules & constraints
+
+| Rule | Reason |
+|---|---|
+| Never delete or reuse a notice `id` | Dismissal records are keyed by `id`. Deletion causes dismissed users to see the notice again. |
+| Never use literal newlines in translation strings | Single-quoted TS strings with literal newlines cause esbuild parse errors. Use `\n\n` (escaped). |
+| Never hardcode version numbers or dates in translation strings | Use `bodyParams` so strings stay translatable without retranslation per release. |
+| `critical` severity must have `dismissible: false` | `critical` toasts are auto-dismissed with a warning; a dismissible critical modal is inconsistent UX. |
+| `critical` must not use `display: 'toast'` | The toast renderer logs a warning and auto-dismisses critical toasts rather than showing them. |
+| CTA labels ≤ 20 chars, sentence case, a verb | Consistent button copy across the app. |
+| Priorities must be set explicitly for upgrade notices | Adjacent notices form a multipage group; ordering matters for the reading flow. |
+| `action` CTA `actionId` must be registered client-side | The registry integrity test enforces this. Add both the registry entry and the `registerNoticeAction` call in the same PR. |
+| `maxVersion` over deletion for retiring notices | See §12. Deletion would cause dismissed users to re-see the notice if the ID were ever reused. |
diff --git a/docs/tiles/grid-desktop.svg b/docs/tiles/grid-desktop.svg
new file mode 100644
index 0000000000000000000000000000000000000000..5070a59ae081a213bbec6a6ea3e0fb2497c6dc96
--- /dev/null
+++ b/docs/tiles/grid-desktop.svg
@@ -0,0 +1,146 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1600 820" role="img" aria-label="TREK feature tiles">
+  <g transform="translate(0 0)">
+    <defs>
+      <clipPath id="clip-planner"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-planner)">
+      <rect width="520" height="260" fill="#FFE8D9"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#B5492D" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><rect x="3" y="4" width="18" height="18" rx="2"/><path d="M8 2v4M16 2v4M3 10h18"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#B5492D" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="18" height="18" rx="2"/><path d="M8 2v4M16 2v4M3 10h18"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#B5492D">TRIP PLANNER</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Drag and drop</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#B5492D">day by day</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#7C3B2A">Reorder, move across days, optimise</text>
+    </g>
+  </g>
+  <g transform="translate(540 0)">
+    <defs>
+      <clipPath id="clip-maps"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-maps)">
+      <rect width="520" height="260" fill="#DDEDFB"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#1E5AA8" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M1 6l7-3 8 3 7-3v15l-7 3-8-3-7 3zM8 3v15M16 6v15"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#1E5AA8" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M1 6l7-3 8 3 7-3v15l-7 3-8-3-7 3zM8 3v15M16 6v15"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#1E5AA8">MAPS</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">See it all</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1E5AA8">on the map</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#3B4D66">Leaflet + Mapbox GL, 3D buildings</text>
+    </g>
+  </g>
+  <g transform="translate(1080 0)">
+    <defs>
+      <clipPath id="clip-collab"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-collab)">
+      <rect width="520" height="260" fill="#D6F0E3"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#1F7A4E" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87M16 3.13a4 4 0 0 1 0 7.75"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#1F7A4E" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87M16 3.13a4 4 0 0 1 0 7.75"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#1F7A4E">COLLAB</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Plan together</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1F7A4E">in real time</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#325646">WebSocket sync, chat, polls, notes</text>
+    </g>
+  </g>
+  <g transform="translate(0 280)">
+    <defs>
+      <clipPath id="clip-budget"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-budget)">
+      <rect width="520" height="260" fill="#FDF0C7"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#8A6A1E" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M20 12V8a2 2 0 0 0-2-2H4a2 2 0 0 1 0-4h14v4"/><path d="M2 6v14a2 2 0 0 0 2 2h18v-8H16a2 2 0 0 1 0-4h6"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#8A6A1E" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 12V8a2 2 0 0 0-2-2H4a2 2 0 0 1 0-4h14v4"/><path d="M2 6v14a2 2 0 0 0 2 2h18v-8H16a2 2 0 0 1 0-4h6"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#8A6A1E">BUDGET</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Track costs</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#8A6A1E">per person</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#6B5523">Pie chart, multi-currency, splits</text>
+    </g>
+  </g>
+  <g transform="translate(540 280)">
+    <defs>
+      <clipPath id="clip-packing"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-packing)">
+      <rect width="520" height="260" fill="#E4DEF6"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#5443A5" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><polyline points="3.27 6.96 12 12.01 20.73 6.96"/><line x1="12" y1="22.08" x2="12" y2="12"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#5443A5" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><polyline points="3.27 6.96 12 12.01 20.73 6.96"/><line x1="12" y1="22.08" x2="12" y2="12"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#5443A5">PACKING</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Lists, sorted.</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#5443A5">by category</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#4A3E72">Templates, bag tracking, weights</text>
+    </g>
+  </g>
+  <g transform="translate(1080 280)">
+    <defs>
+      <clipPath id="clip-journal"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-journal)">
+      <rect width="520" height="260" fill="#FBDAE4"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#9A2F58" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20"/><path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#9A2F58" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20"/><path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#9A2F58">JOURNEY</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">A journal for</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#9A2F58">every trip</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#6E3345">Magazine entries, photos, maps</text>
+    </g>
+  </g>
+  <g transform="translate(0 560)">
+    <defs>
+      <clipPath id="clip-vacay"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-vacay)">
+      <rect width="520" height="260" fill="#D4DCF7"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#2F3FA4" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M17.8 19.2 16 11l3.5-3.5C21 6 21.5 4 21 3c-1-.5-3 0-4.5 1.5L13 8 4.8 6.2c-.5-.1-.9.1-1.1.5l-.3.5c-.2.5-.1 1 .3 1.3L9 12l-2 3H4l-1 1 3 2 2 3 1-1v-3l3-2 3.5 5.3c.3.4.8.5 1.3.3l.5-.2c.4-.3.6-.7.5-1.2z"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#2F3FA4" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.8 19.2 16 11l3.5-3.5C21 6 21.5 4 21 3c-1-.5-3 0-4.5 1.5L13 8 4.8 6.2c-.5-.1-.9.1-1.1.5l-.3.5c-.2.5-.1 1 .3 1.3L9 12l-2 3H4l-1 1 3 2 2 3 1-1v-3l3-2 3.5 5.3c.3.4.8.5 1.3.3l.5-.2c.4-.3.6-.7.5-1.2z"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#2F3FA4">VACAY</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Vacation days,</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#2F3FA4">visualised</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#3B4471">Calendar, 100+ country holidays</text>
+    </g>
+  </g>
+  <g transform="translate(540 560)">
+    <defs>
+      <clipPath id="clip-mcp"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-mcp)">
+      <rect width="520" height="260" fill="#CFEDE6"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#116E64" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><rect x="3" y="11" width="18" height="10" rx="2"/><circle cx="12" cy="5" r="2"/><path d="M12 7v4M8 16h.01M16 16h.01"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#116E64" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="11" width="18" height="10" rx="2"/><circle cx="12" cy="5" r="2"/><path d="M12 7v4M8 16h.01M16 16h.01"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#116E64">AI / MCP</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Let AI plan</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#116E64">your trips</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#2C524C">80+ tools, OAuth 2.1, Claude-ready</text>
+    </g>
+  </g>
+  <g transform="translate(1080 560)">
+    <defs>
+      <clipPath id="clip-selfhost"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-selfhost)">
+      <rect width="520" height="260" fill="#E4E6EB"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#2D3544" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><rect x="2" y="2" width="20" height="8" rx="2"/><rect x="2" y="14" width="20" height="8" rx="2"/><line x1="6" y1="6" x2="6.01" y2="6"/><line x1="6" y1="18" x2="6.01" y2="18"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#2D3544" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="2" y="2" width="20" height="8" rx="2"/><rect x="2" y="14" width="20" height="8" rx="2"/><line x1="6" y1="6" x2="6.01" y2="6"/><line x1="6" y1="18" x2="6.01" y2="18"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#2D3544">SELF-HOSTED</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Runs on</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#2D3544">your server</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#414958">Docker, SQLite, AGPL — your data, yours</text>
+    </g>
+  </g>
+</svg>
\ No newline at end of file
diff --git a/docs/tiles/grid-mobile.svg b/docs/tiles/grid-mobile.svg
new file mode 100644
index 0000000000000000000000000000000000000000..e4d74d1bf9635edf7d14294ff0ba5ceb2d9ba46a
--- /dev/null
+++ b/docs/tiles/grid-mobile.svg
@@ -0,0 +1,130 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1060 1100" role="img" aria-label="TREK feature tiles">
+  <g transform="translate(0 0)">
+    <defs>
+      <clipPath id="clip-planner"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-planner)">
+      <rect width="520" height="260" fill="#FFE8D9"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#B5492D" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><rect x="3" y="4" width="18" height="18" rx="2"/><path d="M8 2v4M16 2v4M3 10h18"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#B5492D" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="4" width="18" height="18" rx="2"/><path d="M8 2v4M16 2v4M3 10h18"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#B5492D">TRIP PLANNER</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Drag and drop</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#B5492D">day by day</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#7C3B2A">Reorder, move across days, optimise</text>
+    </g>
+  </g>
+  <g transform="translate(540 0)">
+    <defs>
+      <clipPath id="clip-maps"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-maps)">
+      <rect width="520" height="260" fill="#DDEDFB"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#1E5AA8" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M1 6l7-3 8 3 7-3v15l-7 3-8-3-7 3zM8 3v15M16 6v15"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#1E5AA8" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M1 6l7-3 8 3 7-3v15l-7 3-8-3-7 3zM8 3v15M16 6v15"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#1E5AA8">MAPS</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">See it all</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1E5AA8">on the map</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#3B4D66">Leaflet + Mapbox GL, 3D buildings</text>
+    </g>
+  </g>
+  <g transform="translate(0 280)">
+    <defs>
+      <clipPath id="clip-collab"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-collab)">
+      <rect width="520" height="260" fill="#D6F0E3"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#1F7A4E" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87M16 3.13a4 4 0 0 1 0 7.75"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#1F7A4E" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87M16 3.13a4 4 0 0 1 0 7.75"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#1F7A4E">COLLAB</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Plan together</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1F7A4E">in real time</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#325646">WebSocket sync, chat, polls, notes</text>
+    </g>
+  </g>
+  <g transform="translate(540 280)">
+    <defs>
+      <clipPath id="clip-budget"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-budget)">
+      <rect width="520" height="260" fill="#FDF0C7"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#8A6A1E" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M20 12V8a2 2 0 0 0-2-2H4a2 2 0 0 1 0-4h14v4"/><path d="M2 6v14a2 2 0 0 0 2 2h18v-8H16a2 2 0 0 1 0-4h6"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#8A6A1E" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 12V8a2 2 0 0 0-2-2H4a2 2 0 0 1 0-4h14v4"/><path d="M2 6v14a2 2 0 0 0 2 2h18v-8H16a2 2 0 0 1 0-4h6"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#8A6A1E">BUDGET</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Track costs</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#8A6A1E">per person</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#6B5523">Pie chart, multi-currency, splits</text>
+    </g>
+  </g>
+  <g transform="translate(0 560)">
+    <defs>
+      <clipPath id="clip-packing"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-packing)">
+      <rect width="520" height="260" fill="#E4DEF6"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#5443A5" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><polyline points="3.27 6.96 12 12.01 20.73 6.96"/><line x1="12" y1="22.08" x2="12" y2="12"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#5443A5" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"/><polyline points="3.27 6.96 12 12.01 20.73 6.96"/><line x1="12" y1="22.08" x2="12" y2="12"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#5443A5">PACKING</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Lists, sorted.</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#5443A5">by category</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#4A3E72">Templates, bag tracking, weights</text>
+    </g>
+  </g>
+  <g transform="translate(540 560)">
+    <defs>
+      <clipPath id="clip-journal"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-journal)">
+      <rect width="520" height="260" fill="#FBDAE4"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#9A2F58" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20"/><path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#9A2F58" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20"/><path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#9A2F58">JOURNEY</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">A journal for</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#9A2F58">every trip</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#6E3345">Magazine entries, photos, maps</text>
+    </g>
+  </g>
+  <g transform="translate(0 840)">
+    <defs>
+      <clipPath id="clip-vacay"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-vacay)">
+      <rect width="520" height="260" fill="#D4DCF7"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#2F3FA4" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><path d="M17.8 19.2 16 11l3.5-3.5C21 6 21.5 4 21 3c-1-.5-3 0-4.5 1.5L13 8 4.8 6.2c-.5-.1-.9.1-1.1.5l-.3.5c-.2.5-.1 1 .3 1.3L9 12l-2 3H4l-1 1 3 2 2 3 1-1v-3l3-2 3.5 5.3c.3.4.8.5 1.3.3l.5-.2c.4-.3.6-.7.5-1.2z"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#2F3FA4" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.8 19.2 16 11l3.5-3.5C21 6 21.5 4 21 3c-1-.5-3 0-4.5 1.5L13 8 4.8 6.2c-.5-.1-.9.1-1.1.5l-.3.5c-.2.5-.1 1 .3 1.3L9 12l-2 3H4l-1 1 3 2 2 3 1-1v-3l3-2 3.5 5.3c.3.4.8.5 1.3.3l.5-.2c.4-.3.6-.7.5-1.2z"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#2F3FA4">VACAY</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Vacation days,</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#2F3FA4">visualised</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#3B4471">Calendar, 100+ country holidays</text>
+    </g>
+  </g>
+  <g transform="translate(540 840)">
+    <defs>
+      <clipPath id="clip-mcp"><rect width="520" height="260" rx="22"/></clipPath>
+    </defs>
+    <g clip-path="url(#clip-mcp)">
+      <rect width="520" height="260" fill="#CFEDE6"/>
+      <circle cx="520" cy="0" r="220" fill="#FFFFFF" opacity="0.35"/>
+      <g transform="translate(390 22) scale(6)" fill="none" stroke="#116E64" stroke-width="0.7" stroke-linecap="round" stroke-linejoin="round" opacity="0.10"><rect x="3" y="11" width="18" height="10" rx="2"/><circle cx="12" cy="5" r="2"/><path d="M12 7v4M8 16h.01M16 16h.01"/></g>
+      <rect x="436" y="28" width="56" height="56" rx="14" fill="#FFFFFF" opacity="0.7"/>
+      <g transform="translate(450 42) scale(1.15)" fill="none" stroke="#116E64" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="11" width="18" height="10" rx="2"/><circle cx="12" cy="5" r="2"/><path d="M12 7v4M8 16h.01M16 16h.01"/></g>
+      <text x="36" y="62" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="18" font-weight="800" letter-spacing="2.8" fill="#116E64">AI / MCP</text>
+      <text x="36" y="132" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#1A1A1F">Let AI plan</text>
+      <text x="36" y="184" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Display', system-ui, Segoe UI, Roboto, sans-serif" font-size="48" font-weight="800" letter-spacing="-1.2" fill="#116E64">your trips</text>
+      <text x="36" y="224" font-family="-apple-system, BlinkMacSystemFont, 'SF Pro Text', system-ui, Segoe UI, Roboto, sans-serif" font-size="20" font-weight="500" fill="#2C524C">80+ tools, OAuth 2.1, Claude-ready</text>
+    </g>
+  </g>
+</svg>
\ No newline at end of file
diff --git a/docs/trek-icon.png b/docs/trek-icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..b6f059ce428c2cbec437bb4fa9610868abeea61a
Binary files /dev/null and b/docs/trek-icon.png differ
diff --git a/node_modules/.bin/acorn b/node_modules/.bin/acorn
new file mode 100644
index 0000000000000000000000000000000000000000..3ef3c124b08bd4fb0f27cd13301dfeeae4a6464c
--- /dev/null
+++ b/node_modules/.bin/acorn
@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+"use strict"
+
+require("../dist/bin.js")
diff --git a/node_modules/.bin/baseline-browser-mapping b/node_modules/.bin/baseline-browser-mapping
new file mode 100644
index 0000000000000000000000000000000000000000..b52b3b0930145d6628f6c8fa770cdac7a5857684
--- /dev/null
+++ b/node_modules/.bin/baseline-browser-mapping
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+"use strict";const{getCompatibleVersions:e}=require("./index.cjs"),a=process.argv.slice(2),s={};for(let e=0;e<a.length;e++){const r=a[e];r&&("-h"===r||"--help"===r?s.help=!0:"--include-downstream-browsers"===r?s["include-downstream-browsers"]=!0:"--list-all-compatible-versions"===r?s["list-all-compatible-versions"]=!0:"--include-kaios"===r?s["include-kaios"]=!0:"--suppress-warnings"===r?s["suppress-warnings"]=!0:r.startsWith("--target-year=")?s["target-year"]=r.substring(14):"--target-year"===r?s["target-year"]=a[++e]:r.startsWith("--widely-available-on-date=")?s["widely-available-on-date"]=r.substring(27):"--widely-available-on-date"===r?s["widely-available-on-date"]=a[++e]:r.startsWith("--override-last-updated=")?s["override-last-updated"]=r.substring(24):"--override-last-updated"===r?s["override-last-updated"]=a[++e]:(console.error(`Unknown argument: ${r}`),process.exit(1)))}s.help&&(console.log("\nGet Baseline Widely available browser versions or Baseline year browser versions.\n\nUsage: baseline-browser-mapping [options]\n\nOptions:\n      --target-year                   Pass a year between 2015 and the current year to get browser versions compatible \n                                      with all Newly Available features as of the end of the year specified.\n      --widely-available-on-date      Pass a date in the format 'YYYY-MM-DD' to get versions compatible with Widely \n                                      available on the specified date.\n      --include-downstream-browsers   Whether to include browsers that use the same engines as a core Baseline browser.\n      --include-kaios                 Whether to include KaiOS in downstream browsers.  Requires --include-downstream-browsers.\n      --list-all-compatible-versions  Whether to include only the minimum compatible browser versions or all compatible versions.\n      --suppress-warnings             Supress potential warnings about data staleness when using a very recent feature cut off date.\n      --override-last-updated         Override the last updated date for the baseline data for debugging purposes.\n  -h, --help                          Show help\n\nExamples:\n  npx baseline-browser-mapping --target-year 2020\n  npx baseline-browser-mapping --widely-available-on-date 2023-04-05\n  npx baseline-browser-mapping --include-downstream-browsers\n  npx baseline-browser-mapping --list-all-compatible-versions\n".trim()),process.exit(0)),console.log(e({targetYear:s["target-year"]?Number.parseInt(s["target-year"]):void 0,widelyAvailableOnDate:s["widely-available-on-date"],includeDownstreamBrowsers:s["include-downstream-browsers"],listAllCompatibleVersions:s["list-all-compatible-versions"],includeKaiOS:s["include-kaios"],suppressWarnings:s["suppress-warnings"],overrideLastUpdated:s["override-last-updated"]?Number.parseInt(s["override-last-updated"]):void 0}));
diff --git a/node_modules/.bin/browserslist b/node_modules/.bin/browserslist
new file mode 100644
index 0000000000000000000000000000000000000000..78c08d743a8e478c346029e241b1f795b646fbd2
--- /dev/null
+++ b/node_modules/.bin/browserslist
@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+var fs = require('fs')
+var updateDb = require('update-browserslist-db')
+
+var browserslist = require('./')
+var pkg = require('./package.json')
+
+var args = process.argv.slice(2)
+
+var USAGE =
+  'Usage:\n' +
+  '  npx browserslist\n' +
+  '  npx browserslist "QUERIES"\n' +
+  '  npx browserslist --json "QUERIES"\n' +
+  '  npx browserslist --config="path/to/browserlist/file"\n' +
+  '  npx browserslist --coverage "QUERIES"\n' +
+  '  npx browserslist --coverage=US "QUERIES"\n' +
+  '  npx browserslist --coverage=US,RU,global "QUERIES"\n' +
+  '  npx browserslist --env="environment name defined in config"\n' +
+  '  npx browserslist --stats="path/to/browserlist/stats/file"\n' +
+  '  npx browserslist --mobile-to-desktop\n' +
+  '  npx browserslist --ignore-unknown-versions\n'
+
+function isArg(arg) {
+  return args.some(function (str) {
+    return str === arg || str.indexOf(arg + '=') === 0
+  })
+}
+
+function error(msg) {
+  process.stderr.write('browserslist: ' + msg + '\n')
+  process.exit(1)
+}
+
+if (isArg('--help') || isArg('-h')) {
+  process.stdout.write(pkg.description + '.\n\n' + USAGE + '\n')
+} else if (isArg('--version') || isArg('-v')) {
+  process.stdout.write('browserslist ' + pkg.version + '\n')
+} else if (isArg('--update-db')) {
+  /* c8 ignore next 8 */
+  process.stdout.write(
+    'The --update-db command is deprecated.\n' +
+      'Please use npx update-browserslist-db@latest instead.\n'
+  )
+  process.stdout.write('Browserslist DB update will still be made.\n')
+  updateDb(function (str) {
+    process.stdout.write(str)
+  })
+} else {
+  var mode = 'browsers'
+  var opts = {}
+  var queries
+  var areas
+
+  for (var i = 0; i < args.length; i++) {
+    if (args[i][0] !== '-') {
+      queries = args[i].replace(/^["']|["']$/g, '')
+      continue
+    }
+
+    var arg = args[i].split('=')
+    var name = arg[0]
+    var value = arg[1]
+
+    if (value) value = value.replace(/^["']|["']$/g, '')
+
+    if (name === '--config' || name === '-b') {
+      opts.config = value
+    } else if (name === '--env' || name === '-e') {
+      opts.env = value
+    } else if (name === '--stats' || name === '-s') {
+      opts.stats = value
+    } else if (name === '--coverage' || name === '-c') {
+      if (mode !== 'json') mode = 'coverage'
+      if (value) {
+        areas = value.split(',')
+      } else {
+        areas = ['global']
+      }
+    } else if (name === '--json') {
+      mode = 'json'
+    } else if (name === '--mobile-to-desktop') {
+      /* c8 ignore next */
+      opts.mobileToDesktop = true
+    } else if (name === '--ignore-unknown-versions') {
+      /* c8 ignore next */
+      opts.ignoreUnknownVersions = true
+    } else {
+      error('Unknown arguments ' + args[i] + '.\n\n' + USAGE)
+    }
+  }
+
+  var browsers
+  try {
+    browsers = browserslist(queries, opts)
+  } catch (e) {
+    if (e.name === 'BrowserslistError') {
+      error(e.message)
+    } /* c8 ignore start */ else {
+      throw e
+    } /* c8 ignore end */
+  }
+
+  var coverage
+  if (mode === 'browsers') {
+    browsers.forEach(function (browser) {
+      process.stdout.write(browser + '\n')
+    })
+  } else if (areas) {
+    coverage = areas.map(function (area) {
+      var stats
+      if (area !== 'global') {
+        stats = area
+      } else if (opts.stats) {
+        stats = JSON.parse(fs.readFileSync(opts.stats))
+      }
+      var result = browserslist.coverage(browsers, stats)
+      var round = Math.round(result * 100) / 100.0
+
+      return [area, round]
+    })
+
+    if (mode === 'coverage') {
+      var prefix = 'These browsers account for '
+      process.stdout.write(prefix)
+      coverage.forEach(function (data, index) {
+        var area = data[0]
+        var round = data[1]
+        var end = 'globally'
+        if (area && area !== 'global') {
+          end = 'in the ' + area.toUpperCase()
+        } else if (opts.stats) {
+          end = 'in custom statistics'
+        }
+
+        if (index !== 0) {
+          process.stdout.write(prefix.replace(/./g, ' '))
+        }
+
+        process.stdout.write(round + '% of all users ' + end + '\n')
+      })
+    }
+  }
+
+  if (mode === 'json') {
+    var data = { browsers: browsers }
+    if (coverage) {
+      data.coverage = coverage.reduce(function (object, j) {
+        object[j[0]] = j[1]
+        return object
+      }, {})
+    }
+    process.stdout.write(JSON.stringify(data, null, '  ') + '\n')
+  }
+}
diff --git a/node_modules/.bin/crc32 b/node_modules/.bin/crc32
new file mode 100644
index 0000000000000000000000000000000000000000..334e7d2ccd35aa4203b0427e4bf420fa88e947ea
--- /dev/null
+++ b/node_modules/.bin/crc32
@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/* crc32.js (C) 2014-present SheetJS -- http://sheetjs.com */
+/* eslint-env node */
+/* vim: set ts=2 ft=javascript: */
+/*jshint node:true */
+
+var X/*:CRC32Module*/;
+try { X = require('../'); } catch(e) { X = require('crc-32'); }
+
+function help()/*:number*/ {
+[
+"usage: crc32 [options] [filename]",
+"",
+"Options:",
+"    -h, --help           output usage information",
+"    -V, --version        output the version number",
+"    -S, --seed=<n>       use integer seed as starting value (rolling CRC)",
+"    -H, --hex-seed=<h>   use hex seed as starting value (rolling CRC)",
+"    -d, --signed         print result with format `%d` (default)",
+"    -u, --unsigned       print result with format `%u`",
+"    -x, --hex            print result with format `%0.8x`",
+"    -X, --HEX            print result with format `%0.8X`",
+"    -c, --crc32c         use CRC32C (Castagnoli)",
+"    -F, --format=<s>     use specified printf format",
+"",
+"Set filename = '-' or pipe data into crc32 to read from stdin",
+"Default output mode is signed (-d)",
+""
+].forEach(function(l) { console.log(l); });
+	return 0;
+}
+
+function version()/*:number*/ { console.log(X.version); return 0; }
+
+var fs = require('fs');
+try { require('exit-on-epipe'); } catch(e) {}
+
+function die(msg/*:string*/, ec/*:?number*/)/*:void*/ { console.error(msg); process.exit(ec || 0); }
+
+var args/*:Array<string>*/ = process.argv.slice(2);
+var filename/*:string*/ = "";
+var fmt/*:string*/ = "";
+var seed = 0, r = 10;
+
+for(var i = 0; i < args.length; ++i) {
+	var arg = args[i];
+	if(arg.charCodeAt(0) != 45) { if(filename === "") filename = arg; continue; }
+	var m = arg.indexOf("=") == -1 ? arg : arg.substr(0, arg.indexOf("="));
+	switch(m) {
+		case "-": filename = "-"; break;
+
+		case "--help":     case "-h": process.exit(help()); break;
+		case "--version":  case "-V": process.exit(version()); break;
+
+		case "--crc32c":   case "-c": try { X = require('../crc32c'); } catch(e) { X = require('crc-32/crc32c'); } break;
+
+		case "--signed":   case "-d": fmt = "%d"; break;
+		case "--unsigned": case "-u": fmt = "%u"; break;
+		case "--hex":      case "-x": fmt = "%0.8x"; break;
+		case "--HEX":      case "-X": fmt = "%0.8X"; break;
+		case "--format":   case "-F":
+			try {
+				require("printj");
+				fmt = ((m!=arg) ? arg.substr(m.length+1) : args[++i])||"";
+			} catch(e) {
+				console.error("The `crc-32` module removed the `printj` dependency for formatting");
+				console.error("Use the `crc32-cli` module instead:");
+				console.error("    $ npx crc32-cli [options] [filename]");
+			} break;
+
+		case "--hex-seed": case "-H": r = 16;
+		/* falls through */
+		case "--seed":     case "-S":
+			seed=parseInt((m!=arg) ? arg.substr(m.length+1) : args[++i], r)||0; break;
+
+		default: die("crc32: unrecognized option `" + arg + "'", 22);
+	}
+}
+
+if(!process.stdin.isTTY) filename = filename || "-";
+if(filename.length===0) die("crc32: must specify a filename ('-' for stdin)",1);
+
+var crc32 = seed;
+// $FlowIgnore -- Writable is callable but type sig disagrees
+var writable = require('stream').Writable();
+writable._write = function(chunk, e, cb) { crc32 = X.buf(chunk, crc32); cb(); };
+writable._writev = function(chunks, cb) {
+	chunks.forEach(function(c) { crc32 = X.buf(c.chunk, crc32);});
+	cb();
+};
+writable.on('finish', function() {
+	if(fmt === "") console.log(crc32);
+	else try { console.log(require("printj").sprintf(fmt, crc32)); } catch(e) {
+		switch(fmt) {
+			case "%d": console.log(crc32); break;
+			case "%u": console.log(crc32 >>> 0); break;
+			case "%0.8x": console.log((crc32 >>> 0).toString(16).padStart(8, "0").toLowerCase()); break;
+			case "%0.8X": console.log((crc32 >>> 0).toString(16).padStart(8, "0").toUpperCase()); break;
+		}
+	}
+});
+
+if(filename === "-") process.stdin.pipe(writable);
+else if(fs.existsSync(filename)) fs.createReadStream(filename).pipe(writable);
+else die("crc32: " + filename + ": No such file or directory", 2);
diff --git a/node_modules/.bin/eslint b/node_modules/.bin/eslint
new file mode 100644
index 0000000000000000000000000000000000000000..6e4858186ebf9f3f0d9a43487fa090f8723b5053
--- /dev/null
+++ b/node_modules/.bin/eslint
@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+
+/**
+ * @fileoverview Main CLI that is run via the eslint command.
+ * @author Nicholas C. Zakas
+ */
+
+/* eslint no-console:off -- CLI */
+
+"use strict";
+
+const mod = require("node:module");
+
+// to use V8's code cache to speed up instantiation time
+mod.enableCompileCache?.();
+
+// must do this initialization *before* other requires in order to work
+if (process.argv.includes("--debug")) {
+	require("debug").enable("eslint:*,-eslint:code-path,eslintrc:*");
+}
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Read data from stdin til the end.
+ *
+ * Note: See
+ * - https://github.com/nodejs/node/blob/master/doc/api/process.md#processstdin
+ * - https://github.com/nodejs/node/blob/master/doc/api/process.md#a-note-on-process-io
+ * - https://lists.gnu.org/archive/html/bug-gnu-emacs/2016-01/msg00419.html
+ * - https://github.com/nodejs/node/issues/7439 (historical)
+ *
+ * On Windows using `fs.readFileSync(STDIN_FILE_DESCRIPTOR, "utf8")` seems
+ * to read 4096 bytes before blocking and never drains to read further data.
+ *
+ * The investigation on the Emacs thread indicates:
+ *
+ * > Emacs on MS-Windows uses pipes to communicate with subprocesses; a
+ * > pipe on Windows has a 4K buffer. So as soon as Emacs writes more than
+ * > 4096 bytes to the pipe, the pipe becomes full, and Emacs then waits for
+ * > the subprocess to read its end of the pipe, at which time Emacs will
+ * > write the rest of the stuff.
+ * @returns {Promise<string>} The read text.
+ */
+function readStdin() {
+	return new Promise((resolve, reject) => {
+		let content = "";
+		let chunk = "";
+
+		process.stdin
+			.setEncoding("utf8")
+			.on("readable", () => {
+				while ((chunk = process.stdin.read()) !== null) {
+					content += chunk;
+				}
+			})
+			.on("end", () => resolve(content))
+			.on("error", reject);
+	});
+}
+
+/**
+ * Spawns an external command and propagates its exit status.
+ * @param {string} command The command to run.
+ * @param {string[]} args The command arguments.
+ * @throws {Error} If the command cannot be spawned.
+ * @returns {void}
+ */
+function spawnExternalCommand(command, args) {
+	const spawn = require("cross-spawn");
+	const result = spawn.sync(command, args, {
+		encoding: "utf8",
+		stdio: "inherit",
+	});
+
+	if (result.error) {
+		throw result.error;
+	}
+
+	if (result.signal) {
+		process.kill(process.pid, result.signal);
+		return;
+	}
+
+	process.exitCode = result.status ?? 0;
+}
+
+/**
+ * Get the error message of a given value.
+ * @param {any} error The value to get.
+ * @returns {string} The error message.
+ */
+function getErrorMessage(error) {
+	// Lazy loading because this is used only if an error happened.
+	const util = require("node:util");
+
+	// Foolproof -- third-party module might throw non-object.
+	if (typeof error !== "object" || error === null) {
+		return String(error);
+	}
+
+	// Use templates if `error.messageTemplate` is present.
+	if (typeof error.messageTemplate === "string") {
+		try {
+			const template = require(`../messages/${error.messageTemplate}.js`);
+
+			return template(error.messageData || {});
+		} catch {
+			// Ignore template error then fallback to use `error.stack`.
+		}
+	}
+
+	// Use the stacktrace if it's an error object.
+	if (typeof error.stack === "string") {
+		return error.stack;
+	}
+
+	// Otherwise, dump the object.
+	return util.format("%o", error);
+}
+
+/**
+ * Tracks error messages that are shown to the user so we only ever show the
+ * same message once.
+ * @type {Set<string>}
+ */
+const displayedErrors = new Set();
+
+/**
+ * Tracks whether an unexpected error was caught
+ * @type {boolean}
+ */
+let hadFatalError = false;
+
+/**
+ * Catch and report unexpected error.
+ * @param {any} error The thrown error object.
+ * @returns {void}
+ */
+function onFatalError(error) {
+	process.exitCode = 2;
+	hadFatalError = true;
+
+	const { version } = require("../package.json");
+	const message = `
+Oops! Something went wrong! :(
+
+ESLint: ${version}
+
+${getErrorMessage(error)}`;
+
+	if (!displayedErrors.has(message)) {
+		console.error(message);
+		displayedErrors.add(message);
+	}
+}
+
+//------------------------------------------------------------------------------
+// Execution
+//------------------------------------------------------------------------------
+
+(async function main() {
+	process.on("uncaughtException", onFatalError);
+	process.on("unhandledRejection", onFatalError);
+
+	// Call the config initializer if `--init` is present.
+	if (process.argv.includes("--init")) {
+		// `eslint --init` has been moved to `@eslint/create-config`
+		console.warn(
+			"You can also run this command directly using 'npm init @eslint/config@latest'.",
+		);
+
+		spawnExternalCommand("npm", ["init", "@eslint/config@latest"]);
+		return;
+	}
+
+	// start the MCP server if `--mcp` is present
+	if (process.argv.includes("--mcp")) {
+		console.warn(
+			"You can also run this command directly using 'npx @eslint/mcp@latest'.",
+		);
+
+		spawnExternalCommand("npx", ["@eslint/mcp@latest"]);
+		return;
+	}
+
+	// Otherwise, call the CLI.
+	const cli = require("../lib/cli");
+	const exitCode = await cli.execute(
+		process.argv,
+		process.argv.includes("--stdin") ? await readStdin() : void 0,
+	);
+
+	/*
+	 * If an uncaught exception or unhandled rejection was detected in the meantime,
+	 * keep the fatal exit code 2 that is already assigned to `process.exitCode`.
+	 * Without this condition, exit code 2 (unsuccessful execution) could be overwritten with
+	 * 1 (successful execution, lint problems found) or even 0 (successful execution, no lint problems found).
+	 * This ensures that unexpected errors that seemingly don't affect the success
+	 * of the execution will still cause a non-zero exit code, as it's a common
+	 * practice and the default behavior of Node.js to exit with non-zero
+	 * in case of an uncaught exception or unhandled rejection.
+	 *
+	 * Otherwise, assign the exit code returned from CLI.
+	 */
+	if (!hadFatalError) {
+		process.exitCode = exitCode;
+	}
+})().catch(onFatalError);
diff --git a/node_modules/.bin/eslint-config-prettier b/node_modules/.bin/eslint-config-prettier
new file mode 100644
index 0000000000000000000000000000000000000000..da85433640340258448a748ac62b830855f8a668
--- /dev/null
+++ b/node_modules/.bin/eslint-config-prettier
@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const validators = require("./validators");
+const config = require("..");
+const prettier = require("../prettier");
+
+// Require locally installed eslint, for `npx eslint-config-prettier` support
+// with no local eslint-config-prettier installation.
+const localRequire = (request) =>
+  require(
+    require.resolve(request, {
+      paths: [process.cwd(), ...require.resolve.paths("eslint")],
+    })
+  );
+
+let experimentalApi = {};
+try {
+  experimentalApi = localRequire("eslint/use-at-your-own-risk");
+} catch (_error) {}
+
+const { ESLint, FlatESLint = experimentalApi.FlatESLint } =
+  localRequire("eslint");
+
+const SPECIAL_RULES_URL =
+  "https://github.com/prettier/eslint-config-prettier#special-rules";
+
+const PRETTIER_RULES_URL =
+  "https://github.com/prettier/eslint-config-prettier#arrow-body-style-and-prefer-arrow-callback";
+
+if (module === require.main) {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error(help());
+    process.exit(1);
+  }
+
+  const eslint = new ESLint();
+  const flatESLint = FlatESLint === undefined ? undefined : new FlatESLint();
+
+  Promise.all(
+    args.map((file) => {
+      switch (process.env.ESLINT_USE_FLAT_CONFIG) {
+        case "true": {
+          return flatESLint.calculateConfigForFile(file);
+        }
+        case "false": {
+          return eslint.calculateConfigForFile(file);
+        }
+        default: {
+          // This turns synchronous errors (such as `.calculateConfigForFile` not existing)
+          // and turns them into promise rejections.
+          return Promise.resolve()
+            .then(() => flatESLint.calculateConfigForFile(file))
+            .catch(() => eslint.calculateConfigForFile(file));
+        }
+      }
+    })
+  )
+    .then((configs) => {
+      const rules = configs.flatMap(
+        (
+          // Initializing config and rules for files that aren't included in the flat config,
+          // which is a very unlikely scenario, but should still be treated as a success
+          { rules = {} } = {},
+          index
+        ) => Object.entries(rules).map((entry) => [...entry, args[index]])
+      );
+      const result = processRules(rules);
+      if (result.stderr) {
+        console.error(result.stderr);
+      }
+      if (result.stdout) {
+        console.error(result.stdout);
+      }
+      process.exit(result.code);
+    })
+    .catch((error) => {
+      console.error(error.message);
+      process.exit(1);
+    });
+}
+
+function help() {
+  return `
+Usage: npx eslint-config-prettier FILE...
+
+Resolves an ESLint configuration for every given FILE and checks if they
+contain rules that are unnecessary or conflict with Prettier. Example:
+
+  npx eslint-config-prettier index.js test/index.js other/file/to/check.js
+
+Exit codes:
+
+0: No automatically detectable problems found.
+1: General error.
+2: Conflicting rules found.
+
+For more information, see:
+https://github.com/prettier/eslint-config-prettier#cli-helper-tool
+  `.trim();
+}
+
+function processRules(configRules) {
+  const regularRules = filterRules(config.rules, (_, value) => value === "off");
+  const optionsRules = filterRules(
+    config.rules,
+    (ruleName, value) => value === 0 && ruleName in validators
+  );
+  const specialRules = filterRules(
+    config.rules,
+    (ruleName, value) => value === 0 && !(ruleName in validators)
+  );
+
+  const enabledRules = configRules
+    .map(([ruleName, value, source]) => {
+      const arrayValue = Array.isArray(value) ? value : [value];
+      const [level, ...options] = arrayValue;
+      const isOff = level === "off" || level === 0;
+      return isOff ? null : { ruleName, options, source };
+    })
+    .filter(Boolean);
+
+  const flaggedRules = enabledRules.filter(
+    ({ ruleName }) => ruleName in config.rules
+  );
+
+  const regularFlaggedRuleNames = filterRuleNames(
+    flaggedRules,
+    ({ ruleName }) => ruleName in regularRules
+  );
+  const optionsFlaggedRuleNames = filterRuleNames(
+    flaggedRules,
+    ({ ruleName, ...rule }) =>
+      ruleName in optionsRules && !validators[ruleName](rule)
+  );
+  const specialFlaggedRuleNames = filterRuleNames(
+    flaggedRules,
+    ({ ruleName }) => ruleName in specialRules
+  );
+  const prettierFlaggedRuleNames = filterRuleNames(
+    enabledRules,
+    ({ ruleName, source }) =>
+      ruleName in prettier.rules &&
+      enabledRules.some(
+        (rule) =>
+          rule.ruleName === "prettier/prettier" && rule.source === source
+      )
+  );
+
+  const regularMessage = [
+    "The following rules are unnecessary or might conflict with Prettier:",
+    "",
+    printRuleNames(regularFlaggedRuleNames),
+  ].join("\n");
+
+  const optionsMessage = [
+    "The following rules are enabled with config that might conflict with Prettier. See:",
+    SPECIAL_RULES_URL,
+    "",
+    printRuleNames(optionsFlaggedRuleNames),
+  ].join("\n");
+
+  const specialMessage = [
+    "The following rules are enabled but cannot be automatically checked. See:",
+    SPECIAL_RULES_URL,
+    "",
+    printRuleNames(specialFlaggedRuleNames),
+  ].join("\n");
+
+  const prettierMessage = [
+    "The following rules can cause issues when using eslint-plugin-prettier at the same time.",
+    "Only enable them if you know what you are doing! See:",
+    PRETTIER_RULES_URL,
+    "",
+    printRuleNames(prettierFlaggedRuleNames),
+  ].join("\n");
+
+  if (
+    regularFlaggedRuleNames.length === 0 &&
+    optionsFlaggedRuleNames.length === 0
+  ) {
+    const message =
+      specialFlaggedRuleNames.length === 0 &&
+      prettierFlaggedRuleNames.length === 0
+        ? "No rules that are unnecessary or conflict with Prettier were found."
+        : [
+            specialFlaggedRuleNames.length === 0 ? null : specialMessage,
+            prettierFlaggedRuleNames.length === 0 ? null : prettierMessage,
+            "Other than that, no rules that are unnecessary or conflict with Prettier were found.",
+          ]
+            .filter(Boolean)
+            .join("\n\n");
+
+    return {
+      stdout: message,
+      code: 0,
+    };
+  }
+
+  const message = [
+    regularFlaggedRuleNames.length === 0 ? null : regularMessage,
+    optionsFlaggedRuleNames.length === 0 ? null : optionsMessage,
+    specialFlaggedRuleNames.length === 0 ? null : specialMessage,
+    prettierFlaggedRuleNames.length === 0 ? null : prettierMessage,
+  ]
+    .filter(Boolean)
+    .join("\n\n");
+
+  return {
+    stdout: message,
+    code: 2,
+  };
+}
+
+function filterRules(rules, fn) {
+  return Object.fromEntries(
+    Object.entries(rules)
+      .filter(([ruleName, value]) => fn(ruleName, value))
+      .map(([ruleName]) => [ruleName, true])
+  );
+}
+
+function filterRuleNames(rules, fn) {
+  return [
+    ...new Set(rules.filter((rule) => fn(rule)).map((rule) => rule.ruleName)),
+  ];
+}
+
+function printRuleNames(ruleNames) {
+  return ruleNames
+    .slice()
+    .sort()
+    .map((ruleName) => `- ${ruleName}`)
+    .join("\n");
+}
+
+exports.processRules = processRules;
diff --git a/node_modules/.bin/fxparser b/node_modules/.bin/fxparser
new file mode 100644
index 0000000000000000000000000000000000000000..b4773e40362211ccd6b227bcfa836b4a4f5ba8e3
--- /dev/null
+++ b/node_modules/.bin/fxparser
@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+'use strict';
+/*eslint-disable no-console*/
+import fs from 'fs';
+import { resolve } from 'path';
+import {XMLParser, XMLValidator} from "../fxp.js";
+import ReadToEnd from './read.js';
+import cmdDetail from "./man.js"
+
+console.warn("\x1b[33m%s\x1b[0m", "⚠️  Warning: The built-in CLI interface is now deprecated.");
+console.warn("Please install the dedicated CLI package instead:");
+console.warn("  npm install -g fxp-cli");
+
+if (process.argv[2] === '--help' || process.argv[2] === '-h') {
+  console.log(cmdDetail);
+} else if (process.argv[2] === '--version') {
+  const packageJsonPath = resolve(process.cwd(), 'package.json');
+  const version = JSON.parse(fs.readFileSync(packageJsonPath).toString()).version;
+  console.log(version);
+} else {
+  const options = {
+    removeNSPrefix: true,
+    ignoreAttributes: false,
+    parseTagValue: true,
+    parseAttributeValue: true,
+  };
+  let fileName = '';
+  let outputFileName;
+  let validate = false;
+  let validateOnly = false;
+  for (let i = 2; i < process.argv.length; i++) {
+    if (process.argv[i] === '-ns') {
+      options.removeNSPrefix = false;
+    } else if (process.argv[i] === '-a') {
+      options.ignoreAttributes = true;
+    } else if (process.argv[i] === '-c') {
+      options.parseTagValue = false;
+      options.parseAttributeValue = false;
+    } else if (process.argv[i] === '-o') {
+      outputFileName = process.argv[++i];
+    } else if (process.argv[i] === '-v') {
+      validate = true;
+    } else if (process.argv[i] === '-V') {
+      validateOnly = true;
+    } else {
+      //filename
+      fileName = process.argv[i];
+    }
+  }
+  
+  const callback = function(xmlData) {
+    let output = '';
+    if (validateOnly) {
+      output = XMLValidator.validate(xmlData);
+      process.exitCode = output === true ? 0 : 1;
+    }  else {
+      const parser = new XMLParser(options);
+      output = JSON.stringify(parser.parse(xmlData,validate), null, 4);
+    }
+    if (outputFileName) {
+      writeToFile(outputFileName, output);
+    } else {
+      console.log(output);
+    }
+  };
+
+
+  try {
+    
+    if (!fileName) {
+      ReadToEnd.readToEnd(process.stdin, function(err, data) {
+        if (err) {
+          throw err;
+        }
+        callback(data.toString());
+      });
+    } else {
+      fs.readFile(fileName, function(err, data) {
+        if (err) {
+          throw err;
+        }
+        callback(data.toString());
+      });
+    }
+  } catch (e) {
+    console.log('Seems an invalid file or stream.' + e);
+  }
+}
+
+function writeToFile(fileName, data) {
+  fs.writeFile(fileName, data, function(err) {
+    if (err) {
+      throw err;
+    }
+    console.log('JSON output has been written to ' + fileName);
+  });
+}
diff --git a/node_modules/.bin/jiti b/node_modules/.bin/jiti
new file mode 100644
index 0000000000000000000000000000000000000000..2867c64676c200685520975b43698493766fb2ba
--- /dev/null
+++ b/node_modules/.bin/jiti
@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+const { resolve } = require("node:path");
+
+const script = process.argv.splice(2, 1)[0];
+
+if (!script) {
+   
+  console.error("Usage: jiti <path> [...arguments]");
+  process.exit(1);
+}
+
+const pwd = process.cwd();
+const jiti = require("..")(pwd);
+const resolved = (process.argv[1] = jiti.resolve(resolve(pwd, script)));
+jiti(resolved);
diff --git a/node_modules/.bin/js-yaml b/node_modules/.bin/js-yaml
new file mode 100644
index 0000000000000000000000000000000000000000..abcd7e000bd312d4c03f3faf85f75b7a82218d5a
--- /dev/null
+++ b/node_modules/.bin/js-yaml
@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+'use strict'
+
+const fs = require('fs')
+const argparse = require('argparse')
+const yaml = require('..')
+
+/// /////////////////////////////////////////////////////////////////////////////
+
+const cli = new argparse.ArgumentParser({
+  prog: 'js-yaml',
+  add_help: true
+})
+
+cli.add_argument('-v', '--version', {
+  action: 'version',
+  version: require('../package.json').version
+})
+
+cli.add_argument('-c', '--compact', {
+  help: 'Display errors in compact mode',
+  action: 'store_true'
+})
+
+// deprecated (not needed after we removed output colors)
+// option suppressed, but not completely removed for compatibility
+cli.add_argument('-j', '--to-json', {
+  help: argparse.SUPPRESS,
+  dest: 'json',
+  action: 'store_true'
+})
+
+cli.add_argument('-t', '--trace', {
+  help: 'Show stack trace on error',
+  action: 'store_true'
+})
+
+cli.add_argument('file', {
+  help: 'File to read, utf-8 encoded without BOM',
+  nargs: '?',
+  default: '-'
+})
+
+/// /////////////////////////////////////////////////////////////////////////////
+
+const options = cli.parse_args()
+
+/// /////////////////////////////////////////////////////////////////////////////
+
+function readFile (filename, encoding, callback) {
+  if (options.file === '-') {
+    // read from stdin
+
+    const chunks = []
+
+    process.stdin.on('data', function (chunk) {
+      chunks.push(chunk)
+    })
+
+    process.stdin.on('end', function () {
+      return callback(null, Buffer.concat(chunks).toString(encoding))
+    })
+  } else {
+    fs.readFile(filename, encoding, callback)
+  }
+}
+
+readFile(options.file, 'utf8', function (error, input) {
+  let output
+  let isYaml
+
+  if (error) {
+    if (error.code === 'ENOENT') {
+      console.error('File not found: ' + options.file)
+      process.exit(2)
+    }
+
+    console.error(
+      (options.trace && error.stack) ||
+      error.message ||
+      String(error))
+
+    process.exit(1)
+  }
+
+  try {
+    output = JSON.parse(input)
+    isYaml = false
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      try {
+        output = []
+        yaml.loadAll(input, function (doc) { output.push(doc) }, {})
+        isYaml = true
+
+        if (output.length === 0) output = null
+        else if (output.length === 1) output = output[0]
+      } catch (e) {
+        if (options.trace && err.stack) console.error(e.stack)
+        else console.error(e.toString(options.compact))
+
+        process.exit(1)
+      }
+    } else {
+      console.error(
+        (options.trace && err.stack) ||
+        err.message ||
+        String(err))
+
+      process.exit(1)
+    }
+  }
+
+  if (isYaml) console.log(JSON.stringify(output, null, '  '))
+  else console.log(yaml.dump(output))
+})
diff --git a/node_modules/.bin/jsesc b/node_modules/.bin/jsesc
new file mode 100644
index 0000000000000000000000000000000000000000..e9a541db322abe86e96da58a3ab528de98b90ce9
--- /dev/null
+++ b/node_modules/.bin/jsesc
@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+(function() {
+
+	var fs = require('fs');
+	var stringEscape = require('../jsesc.js');
+	var strings = process.argv.splice(2);
+	var stdin = process.stdin;
+	var data;
+	var timeout;
+	var isObject = false;
+	var options = {};
+	var log = console.log;
+
+	var main = function() {
+		var option = strings[0];
+
+		if (/^(?:-h|--help|undefined)$/.test(option)) {
+			log(
+				'jsesc v%s - https://mths.be/jsesc',
+				stringEscape.version
+			);
+			log([
+				'\nUsage:\n',
+				'\tjsesc [string]',
+				'\tjsesc [-s | --single-quotes] [string]',
+				'\tjsesc [-d | --double-quotes] [string]',
+				'\tjsesc [-w | --wrap] [string]',
+				'\tjsesc [-e | --escape-everything] [string]',
+				'\tjsesc [-t | --escape-etago] [string]',
+				'\tjsesc [-6 | --es6] [string]',
+				'\tjsesc [-l | --lowercase-hex] [string]',
+				'\tjsesc [-j | --json] [string]',
+				'\tjsesc [-o | --object] [stringified_object]', // `JSON.parse()` the argument
+				'\tjsesc [-p | --pretty] [string]', // `compact: false`
+				'\tjsesc [-v | --version]',
+				'\tjsesc [-h | --help]',
+				'\nExamples:\n',
+				'\tjsesc \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\tjsesc --json \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\tjsesc --json --escape-everything \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\tjsesc --double-quotes --wrap \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\'',
+				'\techo \'f\xF6o \u2665 b\xE5r \uD834\uDF06 baz\' | jsesc'
+			].join('\n'));
+			return process.exit(1);
+		}
+
+		if (/^(?:-v|--version)$/.test(option)) {
+			log('v%s', stringEscape.version);
+			return process.exit(1);
+		}
+
+		strings.forEach(function(string) {
+			// Process options
+			if (/^(?:-s|--single-quotes)$/.test(string)) {
+				options.quotes = 'single';
+				return;
+			}
+			if (/^(?:-d|--double-quotes)$/.test(string)) {
+				options.quotes = 'double';
+				return;
+			}
+			if (/^(?:-w|--wrap)$/.test(string)) {
+				options.wrap = true;
+				return;
+			}
+			if (/^(?:-e|--escape-everything)$/.test(string)) {
+				options.escapeEverything = true;
+				return;
+			}
+			if (/^(?:-t|--escape-etago)$/.test(string)) {
+				options.escapeEtago = true;
+				return;
+			}
+			if (/^(?:-6|--es6)$/.test(string)) {
+				options.es6 = true;
+				return;
+			}
+			if (/^(?:-l|--lowercase-hex)$/.test(string)) {
+				options.lowercaseHex = true;
+				return;
+			}
+			if (/^(?:-j|--json)$/.test(string)) {
+				options.json = true;
+				return;
+			}
+			if (/^(?:-o|--object)$/.test(string)) {
+				isObject = true;
+				return;
+			}
+			if (/^(?:-p|--pretty)$/.test(string)) {
+				isObject = true;
+				options.compact = false;
+				return;
+			}
+
+			// Process string(s)
+			var result;
+			try {
+				if (isObject) {
+					string = JSON.parse(string);
+				}
+				result = stringEscape(string, options);
+				log(result);
+			} catch(error) {
+				log(error.message + '\n');
+				log('Error: failed to escape.');
+				log('If you think this is a bug in jsesc, please report it:');
+				log('https://github.com/mathiasbynens/jsesc/issues/new');
+				log(
+					'\nStack trace using jsesc@%s:\n',
+					stringEscape.version
+				);
+				log(error.stack);
+				return process.exit(1);
+			}
+		});
+		// Return with exit status 0 outside of the `forEach` loop, in case
+		// multiple strings were passed in.
+		return process.exit(0);
+
+	};
+
+	if (stdin.isTTY) {
+		// handle shell arguments
+		main();
+	} else {
+		// Either the script is called from within a non-TTY context,
+		// or `stdin` content is being piped in.
+		if (!process.stdout.isTTY) { // called from a non-TTY context
+			timeout = setTimeout(function() {
+				// if no piped data arrived after a while, handle shell arguments
+				main();
+			}, 250);
+		}
+
+		data = '';
+		stdin.on('data', function(chunk) {
+			clearTimeout(timeout);
+			data += chunk;
+		});
+		stdin.on('end', function() {
+			strings.push(data.trim());
+			main();
+		});
+		stdin.resume();
+	}
+
+}());
diff --git a/node_modules/.bin/json5 b/node_modules/.bin/json5
new file mode 100644
index 0000000000000000000000000000000000000000..93cb80921e21aed8acfdd81bf5c096138f2e228f
--- /dev/null
+++ b/node_modules/.bin/json5
@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+const pkg = require('../package.json')
+const JSON5 = require('./')
+
+const argv = parseArgs()
+
+if (argv.version) {
+    version()
+} else if (argv.help) {
+    usage()
+} else {
+    const inFilename = argv.defaults[0]
+
+    let readStream
+    if (inFilename) {
+        readStream = fs.createReadStream(inFilename)
+    } else {
+        readStream = process.stdin
+    }
+
+    let json5 = ''
+    readStream.on('data', data => {
+        json5 += data
+    })
+
+    readStream.on('end', () => {
+        let space
+        if (argv.space === 't' || argv.space === 'tab') {
+            space = '\t'
+        } else {
+            space = Number(argv.space)
+        }
+
+        let value
+        try {
+            value = JSON5.parse(json5)
+            if (!argv.validate) {
+                const json = JSON.stringify(value, null, space)
+
+                let writeStream
+
+                // --convert is for backward compatibility with v0.5.1. If
+                // specified with <file> and not --out-file, then a file with
+                // the same name but with a .json extension will be written.
+                if (argv.convert && inFilename && !argv.outFile) {
+                    const parsedFilename = path.parse(inFilename)
+                    const outFilename = path.format(
+                        Object.assign(
+                            parsedFilename,
+                            {base: path.basename(parsedFilename.base, parsedFilename.ext) + '.json'}
+                        )
+                    )
+
+                    writeStream = fs.createWriteStream(outFilename)
+                } else if (argv.outFile) {
+                    writeStream = fs.createWriteStream(argv.outFile)
+                } else {
+                    writeStream = process.stdout
+                }
+
+                writeStream.write(json)
+            }
+        } catch (err) {
+            console.error(err.message)
+            process.exit(1)
+        }
+    })
+}
+
+function parseArgs () {
+    let convert
+    let space
+    let validate
+    let outFile
+    let version
+    let help
+    const defaults = []
+
+    const args = process.argv.slice(2)
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i]
+        switch (arg) {
+        case '--convert':
+        case '-c':
+            convert = true
+            break
+
+        case '--space':
+        case '-s':
+            space = args[++i]
+            break
+
+        case '--validate':
+        case '-v':
+            validate = true
+            break
+
+        case '--out-file':
+        case '-o':
+            outFile = args[++i]
+            break
+
+        case '--version':
+        case '-V':
+            version = true
+            break
+
+        case '--help':
+        case '-h':
+            help = true
+            break
+
+        default:
+            defaults.push(arg)
+            break
+        }
+    }
+
+    return {
+        convert,
+        space,
+        validate,
+        outFile,
+        version,
+        help,
+        defaults,
+    }
+}
+
+function version () {
+    console.log(pkg.version)
+}
+
+function usage () {
+    console.log(
+        `
+  Usage: json5 [options] <file>
+
+  If <file> is not provided, then STDIN is used.
+
+  Options:
+
+    -s, --space              The number of spaces to indent or 't' for tabs
+    -o, --out-file [file]    Output to the specified file, otherwise STDOUT
+    -v, --validate           Validate JSON5 but do not output JSON
+    -V, --version            Output the version number
+    -h, --help               Output usage information`
+    )
+}
diff --git a/node_modules/.bin/mime b/node_modules/.bin/mime
new file mode 100644
index 0000000000000000000000000000000000000000..ab70a49c41aeaee64a44a3667094710dbad2efb0
--- /dev/null
+++ b/node_modules/.bin/mime
@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+'use strict';
+
+process.title = 'mime';
+let mime = require('.');
+let pkg = require('./package.json');
+let args = process.argv.splice(2);
+
+if (args.includes('--version') || args.includes('-v') || args.includes('--v')) {
+  console.log(pkg.version);
+  process.exit(0);
+} else if (args.includes('--name') || args.includes('-n') || args.includes('--n')) {
+  console.log(pkg.name);
+  process.exit(0);
+} else if (args.includes('--help') || args.includes('-h') || args.includes('--h')) {
+  console.log(pkg.name + ' - ' + pkg.description + '\n');
+  console.log(`Usage:
+
+  mime [flags] [path_or_extension]
+
+  Flags:
+    --help, -h                     Show this message
+    --version, -v                  Display the version
+    --name, -n                     Print the name of the program
+
+  Note: the command will exit after it executes if a command is specified
+  The path_or_extension is the path to the file or the extension of the file.
+
+  Examples:
+    mime --help
+    mime --version
+    mime --name
+    mime -v
+    mime src/log.js
+    mime new.py
+    mime foo.sh
+  `);
+  process.exit(0);
+}
+
+let file = args[0];
+let type = mime.getType(file);
+
+process.stdout.write(type + '\n');
+
diff --git a/node_modules/.bin/msw b/node_modules/.bin/msw
new file mode 100644
index 0000000000000000000000000000000000000000..e22bd0e916cb1116c10b5294204bd1350999dc5d
--- /dev/null
+++ b/node_modules/.bin/msw
@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import yargs from 'yargs'
+import { init } from './init.js'
+
+// eslint-disable-next-line @typescript-eslint/no-unused-expressions
+yargs(process.argv.slice(2))
+  .usage('$0 <cmd> [args]')
+  .command(
+    'init',
+    'Initializes Mock Service Worker at the specified directory',
+    (yargs) => {
+      yargs
+        .positional('publicDir', {
+          type: 'string',
+          description: 'Relative path to the public directory',
+          demandOption: false,
+          normalize: true,
+        })
+        .option('save', {
+          type: 'boolean',
+          description: 'Save the worker directory in your package.json',
+        })
+        .option('cwd', {
+          type: 'string',
+          description: 'Custom current worker directory',
+          normalize: true,
+        })
+        .example('msw init')
+        .example('msw init ./public')
+        .example('msw init ./static --save')
+    },
+    init,
+  )
+  .demandCommand()
+  .help().argv
diff --git a/node_modules/.bin/nanoid b/node_modules/.bin/nanoid
new file mode 100644
index 0000000000000000000000000000000000000000..c76db0faa81f6d683c4a18a212f804fb70cf8143
--- /dev/null
+++ b/node_modules/.bin/nanoid
@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+let { nanoid, customAlphabet } = require('..')
+
+function print(msg) {
+  process.stdout.write(msg + '\n')
+}
+
+function error(msg) {
+  process.stderr.write(msg + '\n')
+  process.exit(1)
+}
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  print(`
+  Usage
+    $ nanoid [options]
+
+  Options
+    -s, --size       Generated ID size
+    -a, --alphabet   Alphabet to use
+    -h, --help       Show this help
+
+  Examples
+    $ nanoid --s 15
+    S9sBF77U6sDB8Yg
+
+    $ nanoid --size 10 --alphabet abc
+    bcabababca`)
+  process.exit()
+}
+
+let alphabet, size
+for (let i = 2; i < process.argv.length; i++) {
+  let arg = process.argv[i]
+  if (arg === '--size' || arg === '-s') {
+    size = Number(process.argv[i + 1])
+    i += 1
+    if (Number.isNaN(size) || size <= 0) {
+      error('Size must be positive integer')
+    }
+  } else if (arg === '--alphabet' || arg === '-a') {
+    alphabet = process.argv[i + 1]
+    i += 1
+  } else {
+    error('Unknown argument ' + arg)
+  }
+}
+
+if (alphabet) {
+  let customNanoid = customAlphabet(alphabet, size)
+  print(customNanoid())
+} else {
+  print(nanoid(size))
+}
diff --git a/node_modules/.bin/node-which b/node_modules/.bin/node-which
new file mode 100644
index 0000000000000000000000000000000000000000..7cee3729eebdd09e39bd891aa4d17483ea4a757a
--- /dev/null
+++ b/node_modules/.bin/node-which
@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+var which = require("../")
+if (process.argv.length < 3)
+  usage()
+
+function usage () {
+  console.error('usage: which [-as] program ...')
+  process.exit(1)
+}
+
+var all = false
+var silent = false
+var dashdash = false
+var args = process.argv.slice(2).filter(function (arg) {
+  if (dashdash || !/^-/.test(arg))
+    return true
+
+  if (arg === '--') {
+    dashdash = true
+    return false
+  }
+
+  var flags = arg.substr(1).split('')
+  for (var f = 0; f < flags.length; f++) {
+    var flag = flags[f]
+    switch (flag) {
+      case 's':
+        silent = true
+        break
+      case 'a':
+        all = true
+        break
+      default:
+        console.error('which: illegal option -- ' + flag)
+        usage()
+    }
+  }
+  return false
+})
+
+process.exit(args.reduce(function (pv, current) {
+  try {
+    var f = which.sync(current, { all: all })
+    if (all)
+      f = f.join('\n')
+    if (!silent)
+      console.log(f)
+    return pv;
+  } catch (e) {
+    return 1;
+  }
+}, 0))
diff --git a/node_modules/.bin/nodemon b/node_modules/.bin/nodemon
new file mode 100644
index 0000000000000000000000000000000000000000..3d490f140dd264f98dfb50ab820456c88fe92a64
--- /dev/null
+++ b/node_modules/.bin/nodemon
@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+const cli = require('../lib/cli');
+const nodemon = require('../lib/');
+const options = cli.parse(process.argv);
+
+nodemon(options);
+
+const fs = require('fs');
+
+// checks for available update and returns an instance
+const pkg = JSON.parse(fs.readFileSync(__dirname + '/../package.json'));
+
+if (pkg.version.indexOf('0.0.0') !== 0 && options.noUpdateNotifier !== true) {
+  require('simple-update-notifier')({ pkg });
+}
diff --git a/node_modules/.bin/nodetouch b/node_modules/.bin/nodetouch
new file mode 100644
index 0000000000000000000000000000000000000000..f78f0829d1fa9c09fc6565a51ceefc4a1bc80cda
--- /dev/null
+++ b/node_modules/.bin/nodetouch
@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+const touch = require("../index.js")
+
+const usage = code => {
+  console[code ? 'error' : 'log'](
+    'usage:\n' +
+    'touch [-acfm] [-r file] [-t [[CC]YY]MMDDhhmm[.SS]] file ...'
+  )
+  process.exit(code)
+}
+
+const singleFlags = {
+  a: 'atime',
+  m: 'mtime',
+  c: 'nocreate',
+  f: 'force'
+}
+
+const singleOpts = {
+  r: 'ref',
+  t: 'time'
+}
+
+const files = []
+const args = process.argv.slice(2)
+const options = {}
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i]
+  if (!arg.match(/^-/)) {
+    files.push(arg)
+    continue
+  }
+
+  // expand shorthands
+  if (arg.charAt(1) !== '-') {
+    const expand = []
+    for (let f = 1; f < arg.length; f++) {
+      const fc = arg.charAt(f)
+      const sf = singleFlags[fc]
+      const so = singleOpts[fc]
+      if (sf)
+        expand.push('--' + sf)
+      else if (so) {
+        const soslice = arg.slice(f + 1)
+        const soval = soslice.charAt(0) === '=' ? soslice : '=' + soslice
+        expand.push('--' + so + soval)
+        f = arg.length
+      } else if (arg !== '-' + fc)
+        expand.push('-' + fc)
+    }
+    if (expand.length) {
+      args.splice.apply(args, [i, 1].concat(expand))
+      i--
+      continue
+    }
+  }
+
+  const argsplit = arg.split('=')
+  const key = argsplit.shift().replace(/^\-\-/, '')
+  const val = argsplit.length ? argsplit.join('=') : null
+
+  switch (key) {
+    case 'time':
+      const timestr = val || args[++i]
+      // [-t [[CC]YY]MMDDhhmm[.SS]]
+      const parsedtime = timestr.match(
+        /^(([0-9]{2})?([0-9]{2}))?([0-9]{2})([0-9]{2})([0-9]{2})([0-9]{2})(\.([0-9]{2}))?$/
+      )
+      if (!parsedtime) {
+        console.error('touch: out of range or illegal ' +
+                      'time specification: ' +
+                      '[[CC]YY]MMDDhhmm[.SS]')
+        process.exit(1)
+      } else {
+        const y = +parsedtime[1]
+        const year = parsedtime[2] ? y
+          : y <= 68 ? 2000 + y
+          : 1900 + y
+
+        const MM = +parsedtime[4] - 1
+        const dd = +parsedtime[5]
+        const hh = +parsedtime[6]
+        const mm = +parsedtime[7]
+        const ss = +parsedtime[8]
+
+        options.time = new Date(Date.UTC(year, MM, dd, hh, mm, ss))
+      }
+      continue
+
+    case 'ref':
+      options.ref = val || args[++i]
+      continue
+
+    case 'mtime':
+    case 'nocreate':
+    case 'atime':
+    case 'force':
+      options[key] = true
+      continue
+
+    default:
+      console.error('touch: illegal option -- ' + arg)
+      usage(1)
+  }
+}
+
+if (!files.length)
+  usage()
+
+process.exitCode = 0
+Promise.all(files.map(f => touch(f, options)))
+  .catch(er => process.exitCode = 1)
diff --git a/node_modules/.bin/parser b/node_modules/.bin/parser
new file mode 100644
index 0000000000000000000000000000000000000000..4808c5ee86f71fc4452fa6bb50580669fe52e8f2
--- /dev/null
+++ b/node_modules/.bin/parser
@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/* eslint-disable no-var, unicorn/prefer-node-protocol */
+
+var parser = require("..");
+var fs = require("fs");
+
+var filename = process.argv[2];
+if (!filename) {
+  console.error("no filename specified");
+} else {
+  var file = fs.readFileSync(filename, "utf8");
+  var ast = parser.parse(file);
+
+  console.log(JSON.stringify(ast, null, "  "));
+}
diff --git a/node_modules/.bin/pixelmatch b/node_modules/.bin/pixelmatch
new file mode 100644
index 0000000000000000000000000000000000000000..85bbb1a788ab6de50e76a4bbbcc4583b62e8ff63
--- /dev/null
+++ b/node_modules/.bin/pixelmatch
@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+/* eslint-disable no-process-exit */
+
+'use strict';
+
+const PNG = require('pngjs').PNG;
+const fs = require('fs');
+const match = require('../.');
+
+if (process.argv.length < 4) {
+    console.log('Usage: pixelmatch image1.png image2.png [diff.png] [threshold] [includeAA]');
+    process.exit(64);
+}
+
+const [,, img1Path, img2Path, diffPath, threshold, includeAA] = process.argv;
+const options = {};
+if (threshold !== undefined) options.threshold = +threshold;
+if (includeAA !== undefined) options.includeAA = includeAA !== 'false';
+
+const img1 = PNG.sync.read(fs.readFileSync(img1Path));
+const img2 = PNG.sync.read(fs.readFileSync(img2Path));
+
+const {width, height} = img1;
+
+if (img2.width !== width || img2.height !== height) {
+    console.log(`Image dimensions do not match: ${width}x${height} vs ${img2.width}x${img2.height}`);
+    process.exit(65);
+}
+
+const diff = diffPath ? new PNG({width, height}) : null;
+
+console.time('matched in');
+const diffs = match(img1.data, img2.data, diff ? diff.data : null, width, height, options);
+console.timeEnd('matched in');
+
+console.log(`different pixels: ${diffs}`);
+console.log(`error: ${Math.round(100 * 100 * diffs / (width * height)) / 100}%`);
+
+if (diff) {
+    fs.writeFileSync(diffPath, PNG.sync.write(diff));
+}
+process.exit(diffs ? 66 : 0);
diff --git a/node_modules/.bin/prebuild-install b/node_modules/.bin/prebuild-install
new file mode 100644
index 0000000000000000000000000000000000000000..e5260cce5707aba8272a4bfa9658bd5dc5d7ce8c
--- /dev/null
+++ b/node_modules/.bin/prebuild-install
@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+const path = require('path')
+const fs = require('fs')
+const napi = require('napi-build-utils')
+
+const pkg = require(path.resolve('package.json'))
+const rc = require('./rc')(pkg)
+const log = require('./log')(rc, process.env)
+const download = require('./download')
+const asset = require('./asset')
+const util = require('./util')
+
+const prebuildClientVersion = require('./package.json').version
+if (rc.version) {
+  console.log(prebuildClientVersion)
+  process.exit(0)
+}
+
+if (rc.path) process.chdir(rc.path)
+
+if (rc.runtime === 'electron' && rc.target[0] === '4' && rc.abi === '64') {
+  log.error(`Electron version ${rc.target} found - skipping prebuild-install work due to known ABI issue`)
+  log.error('More information about this issue can be found at https://github.com/lgeiger/node-abi/issues/54')
+  process.exit(1)
+}
+
+if (!fs.existsSync('package.json')) {
+  log.error('setup', 'No package.json found. Aborting...')
+  process.exit(1)
+}
+
+if (rc.help) {
+  console.error(fs.readFileSync(path.join(__dirname, 'help.txt'), 'utf-8'))
+  process.exit(0)
+}
+
+log.info('begin', 'Prebuild-install version', prebuildClientVersion)
+
+const opts = Object.assign({}, rc, { pkg: pkg, log: log })
+
+if (napi.isNapiRuntime(rc.runtime)) napi.logUnsupportedVersion(rc.target, log)
+
+const origin = util.packageOrigin(process.env, pkg)
+
+if (opts.force) {
+  log.warn('install', 'prebuilt binaries enforced with --force!')
+  log.warn('install', 'prebuilt binaries may be out of date!')
+} else if (origin && origin.length > 4 && origin.substr(0, 4) === 'git+') {
+  log.info('install', 'installing from git repository, skipping download.')
+  process.exit(1)
+} else if (opts.buildFromSource) {
+  log.info('install', '--build-from-source specified, not attempting download.')
+  process.exit(1)
+}
+
+const startDownload = function (downloadUrl) {
+  download(downloadUrl, opts, function (err) {
+    if (err) {
+      log.warn('install', err.message)
+      return process.exit(1)
+    }
+    log.info('install', 'Successfully installed prebuilt binary!')
+  })
+}
+
+if (opts.token) {
+  asset(opts, function (err, assetId) {
+    if (err) {
+      log.warn('install', err.message)
+      return process.exit(1)
+    }
+
+    startDownload(util.getAssetUrl(opts, assetId))
+  })
+} else {
+  startDownload(util.getDownloadUrl(opts))
+}
diff --git a/node_modules/.bin/prettier b/node_modules/.bin/prettier
new file mode 100644
index 0000000000000000000000000000000000000000..642c99dd135f7b9ea845f6d4faacef76e195e5aa
--- /dev/null
+++ b/node_modules/.bin/prettier
@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = function(cb, mod) {
+  return function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+};
+
+// node_modules/semver-compare/index.js
+var require_semver_compare = __commonJS({
+  "node_modules/semver-compare/index.js": function(exports2, module2) {
+    module2.exports = function cmp(a, b) {
+      var pa = a.split(".");
+      var pb = b.split(".");
+      for (var i = 0; i < 3; i++) {
+        var na = Number(pa[i]);
+        var nb = Number(pb[i]);
+        if (na > nb) return 1;
+        if (nb > na) return -1;
+        if (!isNaN(na) && isNaN(nb)) return 1;
+        if (isNaN(na) && !isNaN(nb)) return -1;
+      }
+      return 0;
+    };
+  }
+});
+
+// node_modules/please-upgrade-node/index.js
+var require_please_upgrade_node = __commonJS({
+  "node_modules/please-upgrade-node/index.js": function(exports2, module2) {
+    var semverCompare = require_semver_compare();
+    module2.exports = function pleaseUpgradeNode2(pkg, opts) {
+      var opts = opts || {};
+      var requiredVersion = pkg.engines.node.replace(">=", "");
+      var currentVersion = process.version.replace("v", "");
+      if (semverCompare(currentVersion, requiredVersion) === -1) {
+        if (opts.message) {
+          console.error(opts.message(requiredVersion));
+        } else {
+          console.error(
+            pkg.name + " requires at least version " + requiredVersion + " of Node, please upgrade"
+          );
+        }
+        if (opts.hasOwnProperty("exitCode")) {
+          process.exit(opts.exitCode);
+        } else {
+          process.exit(1);
+        }
+      }
+    };
+  }
+});
+
+// bin/prettier.cjs
+var nodeModule = require("module");
+if (typeof nodeModule.enableCompileCache === "function") {
+  nodeModule.enableCompileCache();
+}
+var pleaseUpgradeNode = require_please_upgrade_node();
+var packageJson = require("../package.json");
+pleaseUpgradeNode(packageJson);
+var dynamicImport = new Function("module", "return import(module)");
+var promise;
+var index = process.argv.indexOf("--experimental-cli");
+if (process.env.PRETTIER_EXPERIMENTAL_CLI || index !== -1) {
+  if (index !== -1) {
+    process.argv.splice(index, 1);
+  }
+  promise = dynamicImport("../internal/experimental-cli.mjs").then(
+    function(cli) {
+      return cli.__promise;
+    }
+  );
+} else {
+  promise = dynamicImport("../internal/legacy-cli.mjs").then(function runCli(cli) {
+    return cli.run();
+  });
+}
+module.exports.__promise = promise;
diff --git a/node_modules/.bin/qrcode b/node_modules/.bin/qrcode
new file mode 100644
index 0000000000000000000000000000000000000000..dd990b63cdbfcb266263496363f47ac8f86601d7
--- /dev/null
+++ b/node_modules/.bin/qrcode
@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+var yargs = require('yargs')
+var qr = require('../lib')
+
+function save (file, text, options) {
+  qr.toFile(file, text, options, function (err, data) {
+    if (err) {
+      console.error('Error:', err.message)
+      process.exit(1)
+    }
+
+    console.log('saved qrcode to: ' + file + '\n')
+  })
+}
+
+function print (text, options) {
+  options.type = 'terminal'
+  qr.toString(text, options, function (err, text) {
+    if (err) {
+      console.error('Error:', err.message)
+      process.exit(1)
+    }
+
+    console.log(text)
+  })
+}
+
+function parseOptions (args) {
+  return {
+    version: args.qversion,
+    errorCorrectionLevel: args.error,
+    type: args.type,
+    small: !!args.small,
+    inverse: !!args.inverse,
+    maskPattern: args.mask,
+    margin: args.qzone,
+    width: args.width,
+    scale: args.scale,
+    color: {
+      light: args.lightcolor,
+      dark: args.darkcolor
+    }
+  }
+}
+
+function processInputs (text, opts) {
+  if (!text.length) {
+    yargs.showHelp()
+    process.exit(1)
+  }
+
+  if (opts.output) {
+    save(opts.output, text, parseOptions(opts))
+  } else {
+    print(text, parseOptions(opts))
+  }
+}
+
+var argv = yargs
+  .detectLocale(false)
+  .usage('Usage: $0 [options] <input string>')
+  .option('v', {
+    alias: 'qversion',
+    description: 'QR Code symbol version (1 - 40)',
+    group: 'QR Code options:',
+    type: 'number'
+  })
+  .option('e', {
+    alias: 'error',
+    description: 'Error correction level',
+    choices: ['L', 'M', 'Q', 'H'],
+    group: 'QR Code options:'
+  })
+  .option('m', {
+    alias: 'mask',
+    description: 'Mask pattern (0 - 7)',
+    group: 'QR Code options:',
+    type: 'number'
+  })
+  .option('t', {
+    alias: 'type',
+    description: 'Output type',
+    choices: ['png', 'svg', 'utf8'],
+    implies: 'output',
+    group: 'Renderer options:'
+  })
+  .option('i', {
+    alias: 'inverse',
+    type: 'boolean',
+    description: 'Invert colors',
+    group: 'Renderer options:'
+  })
+  .option('w', {
+    alias: 'width',
+    description: 'Image width (px)',
+    conflicts: 'scale',
+    group: 'Renderer options:',
+    type: 'number'
+  })
+  .option('s', {
+    alias: 'scale',
+    description: 'Scale factor',
+    conflicts: 'width',
+    group: 'Renderer options:',
+    type: 'number'
+  })
+  .option('q', {
+    alias: 'qzone',
+    description: 'Quiet zone size',
+    group: 'Renderer options:',
+    type: 'number'
+  })
+  .option('l', {
+    alias: 'lightcolor',
+    description: 'Light RGBA hex color',
+    group: 'Renderer options:'
+  })
+  .option('d', {
+    alias: 'darkcolor',
+    description: 'Dark RGBA hex color',
+    group: 'Renderer options:'
+  })
+  .option('small', {
+    type: 'boolean',
+    description: 'Output smaller QR code to terminal',
+    conflicts: 'type',
+    group: 'Renderer options:'
+  })
+  .option('o', {
+    alias: 'output',
+    description: 'Output file'
+  })
+  .help('h')
+  .alias('h', 'help')
+  .version()
+  .example('$0 "some text"', 'Draw in terminal window')
+  .example('$0 -o out.png "some text"', 'Save as png image')
+  .example('$0 -d F00 -o out.png "some text"', 'Use red as foreground color')
+  .parserConfiguration({'parse-numbers': false})
+  .argv
+
+if (process.stdin.isTTY) {
+  processInputs(argv._.join(' '), argv)
+} else {
+  var text = ''
+  process.stdin.setEncoding('utf8')
+  process.stdin.on('readable', function () {
+    var chunk = process.stdin.read()
+    if (chunk !== null) {
+      text += chunk
+    }
+  })
+
+  process.stdin.on('end', function () {
+    // this process can be run as a command outside of a tty so if there was no
+    // data on stdin read from argv
+    processInputs(text.length?text:argv._.join(' '), argv)
+  })
+}
diff --git a/node_modules/.bin/rc b/node_modules/.bin/rc
new file mode 100644
index 0000000000000000000000000000000000000000..ab05b6072b01701227f5e2765b327a8e409c6553
--- /dev/null
+++ b/node_modules/.bin/rc
@@ -0,0 +1,4 @@
+#! /usr/bin/env node
+var rc = require('./index')
+
+console.log(JSON.stringify(rc(process.argv[2]), false, 2))
diff --git a/node_modules/.bin/rolldown b/node_modules/.bin/rolldown
new file mode 100644
index 0000000000000000000000000000000000000000..814234a5ca3ad686aa259095d82e9212195b9664
--- /dev/null
+++ b/node_modules/.bin/rolldown
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/cli.mjs';
diff --git a/node_modules/.bin/rollup b/node_modules/.bin/rollup
new file mode 100644
index 0000000000000000000000000000000000000000..fc55f8b18eb22b0044b4a892cf06ea2efc91088e
--- /dev/null
+++ b/node_modules/.bin/rollup
@@ -0,0 +1,1912 @@
+#!/usr/bin/env node
+/*
+  @license
+	Rollup.js v4.62.0
+	Sat, 13 Jun 2026 08:30:18 GMT - commit 5e0066d92defee0097f10fb814e63f60b2a7b612
+
+	https://github.com/rollup/rollup
+
+	Released under the MIT License.
+*/
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const process$1 = require('node:process');
+const rollup = require('../shared/rollup.js');
+const require$$2 = require('util');
+const require$$0 = require('path');
+const require$$0$1 = require('fs');
+const parseAst_js = require('../shared/parseAst.js');
+const fseventsImporter = require('../shared/fsevents-importer.js');
+const promises = require('node:fs/promises');
+const path = require('node:path');
+const loadConfigFile_js = require('../shared/loadConfigFile.js');
+require('../native.js');
+require('node:perf_hooks');
+require('node:url');
+require('../getLogFilter.js');
+
+const help = "rollup version 4.62.0\n=====================================\n\nUsage: rollup [options] <entry file>\n\nOptions:\n\n-c, --config <filename>     Use this config file (if argument is used but value\n                 is unspecified, Rollup will try to load configuration files in\n                 the following order:\n                 rollup.config.mjs -> rollup.config.cjs -> rollup.config.js)\n-d, --dir <dirname>         Directory for chunks (if absent, prints to stdout)\n-e, --external <ids>        Comma-separate list of module IDs to exclude\n-f, --format <format>       Type of output (amd, cjs, es, iife, umd, system)\n-g, --globals <pairs>       Comma-separate list of `moduleID:Global` pairs\n-h, --help                  Show this help message\n-i, --input <filename>      Input (alternative to <entry file>)\n-m, --sourcemap             Generate sourcemap (`-m inline` for inline map)\n-n, --name <name>           Name for UMD export\n-o, --file <output>         Single output file (if absent, prints to stdout)\n-p, --plugin <plugin>       Use the plugin specified (may be repeated)\n-v, --version               Show version number\n-w, --watch                 Watch files in bundle and rebuild on changes\n--amd.autoId                Generate the AMD ID based off the chunk name\n--amd.basePath <prefix>     Path to prepend to auto generated AMD ID\n--amd.define <name>         Function to use in place of `define`\n--amd.forceJsExtensionForImports Use `.js` extension in AMD imports\n--amd.id <id>               ID for AMD module (default is anonymous)\n--assetFileNames <pattern>  Name pattern for emitted assets\n--banner <text>             Code to insert at top of bundle (outside wrapper)\n--chunkFileNames <pattern>  Name pattern for emitted secondary chunks\n--compact                   Minify wrapper code\n--context <variable>        Specify top-level `this` value\n--no-dynamicImportInCjs     Write external dynamic CommonJS imports as require\n--entryFileNames <pattern>  Name pattern for emitted entry chunks\n--environment <values>      Settings passed to config file (see example)\n--no-esModule               Do not add __esModule property\n--exports <mode>            Specify export mode (auto, default, named, none)\n--extend                    Extend global variable defined by --name\n--no-externalImportAttributes Omit import attributes in \"es\" output\n--no-externalLiveBindings   Do not generate code to support live bindings\n--failAfterWarnings         Exit with an error if the build produced warnings\n--filterLogs <filter>       Filter log messages\n--footer <text>             Code to insert at end of bundle (outside wrapper)\n--forceExit                 Force exit the process when done\n--no-freeze                 Do not freeze namespace objects\n--generatedCode <preset>    Which code features to use (es5/es2015)\n--generatedCode.arrowFunctions Use arrow functions in generated code\n--generatedCode.constBindings Use \"const\" in generated code\n--generatedCode.objectShorthand Use shorthand properties in generated code\n--no-generatedCode.reservedNamesAsProps Always quote reserved names as props\n--generatedCode.symbols     Use symbols in generated code\n--hashCharacters <name>     Use the specified character set for file hashes\n--no-hoistTransitiveImports Do not hoist transitive imports into entry chunks\n--importAttributesKey <name> Use the specified keyword for import attributes\n--no-indent                 Don't indent result\n--inlineDynamicImports      Create single bundle when using dynamic imports\n--no-interop                Do not include interop block\n--intro <text>              Code to insert at top of bundle (inside wrapper)\n--logLevel <level>          Which kind of logs to display\n--no-makeAbsoluteExternalsRelative Prevent normalization of external imports\n--maxParallelFileOps <value> How many files to read in parallel\n--minifyInternalExports     Force or disable minification of internal exports\n--noConflict                Generate a noConflict method for UMD globals\n--outro <text>              Code to insert at end of bundle (inside wrapper)\n--perf                      Display performance timings\n--no-preserveEntrySignatures Avoid facade chunks for entry points\n--preserveModules           Preserve module structure\n--preserveModulesRoot       Put preserved modules under this path at root level\n--preserveSymlinks          Do not follow symlinks when resolving files\n--no-reexportProtoFromExternal Ignore `__proto__` in star re-exports\n--no-sanitizeFileName       Do not replace invalid characters in file names\n--shimMissingExports        Create shim variables for missing exports\n--silent                    Don't print warnings\n--sourcemapBaseUrl <url>    Emit absolute sourcemap URLs with given base\n--sourcemapDebugIds         Emit unique debug ids in source and sourcemaps\n--sourcemapExcludeSources   Do not include source code in source maps\n--sourcemapFile <file>      Specify bundle position for source maps\n--sourcemapFileNames <pattern> Name pattern for emitted sourcemaps\n--stdin=ext                 Specify file extension used for stdin input\n--no-stdin                  Do not read \"-\" from stdin\n--no-strict                 Don't emit `\"use strict\";` in the generated modules\n--strictDeprecations        Throw errors for deprecated features\n--no-systemNullSetters      Do not replace empty SystemJS setters with `null`\n--no-treeshake              Disable tree-shaking optimisations\n--no-treeshake.annotations  Ignore pure call annotations\n--treeshake.correctVarValueBeforeDeclaration Deoptimize variables until declared\n--treeshake.manualPureFunctions <names> Manually declare functions as pure\n--no-treeshake.moduleSideEffects Assume modules have no side effects\n--no-treeshake.propertyReadSideEffects Ignore property access side effects\n--no-treeshake.tryCatchDeoptimization Do not turn off try-catch-tree-shaking\n--no-treeshake.unknownGlobalSideEffects Assume unknown globals do not throw\n--validate                  Validate output\n--waitForBundleInput        Wait for bundle input files\n--watch.allowInputInsideOutputPath Whether the input path is allowed to be a\n                 subpath of the output path\n--watch.buildDelay <number> Throttle watch rebuilds\n--no-watch.clearScreen      Do not clear the screen when rebuilding\n--watch.exclude <files>     Exclude files from being watched\n--watch.include <files>     Limit watching to specified files\n--watch.onBundleEnd <cmd>   Shell command to run on `\"BUNDLE_END\"` event\n--watch.onBundleStart <cmd> Shell command to run on `\"BUNDLE_START\"` event\n--watch.onEnd <cmd>         Shell command to run on `\"END\"` event\n--watch.onError <cmd>       Shell command to run on `\"ERROR\"` event\n--watch.onStart <cmd>       Shell command to run on `\"START\"` event\n--watch.skipWrite           Do not write files to disk when watching\n\nExamples:\n\n# use settings in config file\nrollup -c\n\n# in config file, process.env.INCLUDE_DEPS === 'true'\n# and process.env.BUILD === 'production'\nrollup -c --environment INCLUDE_DEPS,BUILD:production\n\n# create CommonJS bundle.js from src/main.js\nrollup --format=cjs --file=bundle.js -- src/main.js\n\n# create self-executing IIFE using `window.jQuery`\n# and `window._` as external globals\nrollup -f iife --globals jquery:jQuery,lodash:_ \\\n  -i src/app.js -o build/app.js -m build/app.js.map\n\nNotes:\n\n* When piping to stdout, only inline sourcemaps are permitted\n\nFor more information visit https://rollupjs.org\n";
+
+/**
+ * @license
+ * Copyright (c) 2016, Contributors
+ * SPDX-License-Identifier: ISC
+ */
+function camelCase(str) {
+    // Handle the case where an argument is provided as camel case, e.g., fooBar.
+    // by ensuring that the string isn't already mixed case:
+    const isCamelCase = str !== str.toLowerCase() && str !== str.toUpperCase();
+    if (!isCamelCase) {
+        str = str.toLowerCase();
+    }
+    if (str.indexOf('-') === -1 && str.indexOf('_') === -1) {
+        return str;
+    }
+    else {
+        let camelcase = '';
+        let nextChrUpper = false;
+        const leadingHyphens = str.match(/^-+/);
+        for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) {
+            let chr = str.charAt(i);
+            if (nextChrUpper) {
+                nextChrUpper = false;
+                chr = chr.toUpperCase();
+            }
+            if (i !== 0 && (chr === '-' || chr === '_')) {
+                nextChrUpper = true;
+            }
+            else if (chr !== '-' && chr !== '_') {
+                camelcase += chr;
+            }
+        }
+        return camelcase;
+    }
+}
+function decamelize(str, joinString) {
+    const lowercase = str.toLowerCase();
+    joinString = joinString || '-';
+    let notCamelcase = '';
+    for (let i = 0; i < str.length; i++) {
+        const chrLower = lowercase.charAt(i);
+        const chrString = str.charAt(i);
+        if (chrLower !== chrString && i > 0) {
+            notCamelcase += `${joinString}${lowercase.charAt(i)}`;
+        }
+        else {
+            notCamelcase += chrString;
+        }
+    }
+    return notCamelcase;
+}
+function looksLikeNumber(x) {
+    if (x === null || x === undefined)
+        return false;
+    // if loaded from config, may already be a number.
+    if (typeof x === 'number')
+        return true;
+    // hexadecimal.
+    if (/^0x[0-9a-f]+$/i.test(x))
+        return true;
+    // don't treat 0123 as a number; as it drops the leading '0'.
+    if (/^0[^.]/.test(x))
+        return false;
+    return /^[-]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
+}
+
+/**
+ * @license
+ * Copyright (c) 2016, Contributors
+ * SPDX-License-Identifier: ISC
+ */
+// take an un-split argv string and tokenize it.
+function tokenizeArgString(argString) {
+    if (Array.isArray(argString)) {
+        return argString.map(e => typeof e !== 'string' ? e + '' : e);
+    }
+    argString = argString.trim();
+    let i = 0;
+    let prevC = null;
+    let c = null;
+    let opening = null;
+    const args = [];
+    for (let ii = 0; ii < argString.length; ii++) {
+        prevC = c;
+        c = argString.charAt(ii);
+        // split on spaces unless we're in quotes.
+        if (c === ' ' && !opening) {
+            if (!(prevC === ' ')) {
+                i++;
+            }
+            continue;
+        }
+        // don't split the string if we're in matching
+        // opening or closing single and double quotes.
+        if (c === opening) {
+            opening = null;
+        }
+        else if ((c === "'" || c === '"') && !opening) {
+            opening = c;
+        }
+        if (!args[i])
+            args[i] = '';
+        args[i] += c;
+    }
+    return args;
+}
+
+/**
+ * @license
+ * Copyright (c) 2016, Contributors
+ * SPDX-License-Identifier: ISC
+ */
+var DefaultValuesForTypeKey;
+(function (DefaultValuesForTypeKey) {
+    DefaultValuesForTypeKey["BOOLEAN"] = "boolean";
+    DefaultValuesForTypeKey["STRING"] = "string";
+    DefaultValuesForTypeKey["NUMBER"] = "number";
+    DefaultValuesForTypeKey["ARRAY"] = "array";
+})(DefaultValuesForTypeKey || (DefaultValuesForTypeKey = {}));
+
+/**
+ * @license
+ * Copyright (c) 2016, Contributors
+ * SPDX-License-Identifier: ISC
+ */
+let mixin;
+class YargsParser {
+    constructor(_mixin) {
+        mixin = _mixin;
+    }
+    parse(argsInput, options) {
+        const opts = Object.assign({
+            alias: undefined,
+            array: undefined,
+            boolean: undefined,
+            config: undefined,
+            configObjects: undefined,
+            configuration: undefined,
+            coerce: undefined,
+            count: undefined,
+            default: undefined,
+            envPrefix: undefined,
+            narg: undefined,
+            normalize: undefined,
+            string: undefined,
+            number: undefined,
+            __: undefined,
+            key: undefined
+        }, options);
+        // allow a string argument to be passed in rather
+        // than an argv array.
+        const args = tokenizeArgString(argsInput);
+        // tokenizeArgString adds extra quotes to args if argsInput is a string
+        // only strip those extra quotes in processValue if argsInput is a string
+        const inputIsString = typeof argsInput === 'string';
+        // aliases might have transitive relationships, normalize this.
+        const aliases = combineAliases(Object.assign(Object.create(null), opts.alias));
+        const configuration = Object.assign({
+            'boolean-negation': true,
+            'camel-case-expansion': true,
+            'combine-arrays': false,
+            'dot-notation': true,
+            'duplicate-arguments-array': true,
+            'flatten-duplicate-arrays': true,
+            'greedy-arrays': true,
+            'halt-at-non-option': false,
+            'nargs-eats-options': false,
+            'negation-prefix': 'no-',
+            'parse-numbers': true,
+            'parse-positional-numbers': true,
+            'populate--': false,
+            'set-placeholder-key': false,
+            'short-option-groups': true,
+            'strip-aliased': false,
+            'strip-dashed': false,
+            'unknown-options-as-args': false
+        }, opts.configuration);
+        const defaults = Object.assign(Object.create(null), opts.default);
+        const configObjects = opts.configObjects || [];
+        const envPrefix = opts.envPrefix;
+        const notFlagsOption = configuration['populate--'];
+        const notFlagsArgv = notFlagsOption ? '--' : '_';
+        const newAliases = Object.create(null);
+        const defaulted = Object.create(null);
+        // allow a i18n handler to be passed in, default to a fake one (util.format).
+        const __ = opts.__ || mixin.format;
+        const flags = {
+            aliases: Object.create(null),
+            arrays: Object.create(null),
+            bools: Object.create(null),
+            strings: Object.create(null),
+            numbers: Object.create(null),
+            counts: Object.create(null),
+            normalize: Object.create(null),
+            configs: Object.create(null),
+            nargs: Object.create(null),
+            coercions: Object.create(null),
+            keys: []
+        };
+        const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
+        const negatedBoolean = new RegExp('^--' + configuration['negation-prefix'] + '(.+)');
+        [].concat(opts.array || []).filter(Boolean).forEach(function (opt) {
+            const key = typeof opt === 'object' ? opt.key : opt;
+            // assign to flags[bools|strings|numbers]
+            const assignment = Object.keys(opt).map(function (key) {
+                const arrayFlagKeys = {
+                    boolean: 'bools',
+                    string: 'strings',
+                    number: 'numbers'
+                };
+                return arrayFlagKeys[key];
+            }).filter(Boolean).pop();
+            // assign key to be coerced
+            if (assignment) {
+                flags[assignment][key] = true;
+            }
+            flags.arrays[key] = true;
+            flags.keys.push(key);
+        });
+        [].concat(opts.boolean || []).filter(Boolean).forEach(function (key) {
+            flags.bools[key] = true;
+            flags.keys.push(key);
+        });
+        [].concat(opts.string || []).filter(Boolean).forEach(function (key) {
+            flags.strings[key] = true;
+            flags.keys.push(key);
+        });
+        [].concat(opts.number || []).filter(Boolean).forEach(function (key) {
+            flags.numbers[key] = true;
+            flags.keys.push(key);
+        });
+        [].concat(opts.count || []).filter(Boolean).forEach(function (key) {
+            flags.counts[key] = true;
+            flags.keys.push(key);
+        });
+        [].concat(opts.normalize || []).filter(Boolean).forEach(function (key) {
+            flags.normalize[key] = true;
+            flags.keys.push(key);
+        });
+        if (typeof opts.narg === 'object') {
+            Object.entries(opts.narg).forEach(([key, value]) => {
+                if (typeof value === 'number') {
+                    flags.nargs[key] = value;
+                    flags.keys.push(key);
+                }
+            });
+        }
+        if (typeof opts.coerce === 'object') {
+            Object.entries(opts.coerce).forEach(([key, value]) => {
+                if (typeof value === 'function') {
+                    flags.coercions[key] = value;
+                    flags.keys.push(key);
+                }
+            });
+        }
+        if (typeof opts.config !== 'undefined') {
+            if (Array.isArray(opts.config) || typeof opts.config === 'string') {
+                [].concat(opts.config).filter(Boolean).forEach(function (key) {
+                    flags.configs[key] = true;
+                });
+            }
+            else if (typeof opts.config === 'object') {
+                Object.entries(opts.config).forEach(([key, value]) => {
+                    if (typeof value === 'boolean' || typeof value === 'function') {
+                        flags.configs[key] = value;
+                    }
+                });
+            }
+        }
+        // create a lookup table that takes into account all
+        // combinations of aliases: {f: ['foo'], foo: ['f']}
+        extendAliases(opts.key, aliases, opts.default, flags.arrays);
+        // apply default values to all aliases.
+        Object.keys(defaults).forEach(function (key) {
+            (flags.aliases[key] || []).forEach(function (alias) {
+                defaults[alias] = defaults[key];
+            });
+        });
+        let error = null;
+        checkConfiguration();
+        let notFlags = [];
+        const argv = Object.assign(Object.create(null), { _: [] });
+        // TODO(bcoe): for the first pass at removing object prototype  we didn't
+        // remove all prototypes from objects returned by this API, we might want
+        // to gradually move towards doing so.
+        const argvReturn = {};
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            const truncatedArg = arg.replace(/^-{3,}/, '---');
+            let broken;
+            let key;
+            let letters;
+            let m;
+            let next;
+            let value;
+            // any unknown option (except for end-of-options, "--")
+            if (arg !== '--' && /^-/.test(arg) && isUnknownOptionAsArg(arg)) {
+                pushPositional(arg);
+                // ---, ---=, ----, etc,
+            }
+            else if (truncatedArg.match(/^---+(=|$)/)) {
+                // options without key name are invalid.
+                pushPositional(arg);
+                continue;
+                // -- separated by =
+            }
+            else if (arg.match(/^--.+=/) || (!configuration['short-option-groups'] && arg.match(/^-.+=/))) {
+                // Using [\s\S] instead of . because js doesn't support the
+                // 'dotall' regex modifier. See:
+                // http://stackoverflow.com/a/1068308/13216
+                m = arg.match(/^--?([^=]+)=([\s\S]*)$/);
+                // arrays format = '--f=a b c'
+                if (m !== null && Array.isArray(m) && m.length >= 3) {
+                    if (checkAllAliases(m[1], flags.arrays)) {
+                        i = eatArray(i, m[1], args, m[2]);
+                    }
+                    else if (checkAllAliases(m[1], flags.nargs) !== false) {
+                        // nargs format = '--f=monkey washing cat'
+                        i = eatNargs(i, m[1], args, m[2]);
+                    }
+                    else {
+                        setArg(m[1], m[2], true);
+                    }
+                }
+            }
+            else if (arg.match(negatedBoolean) && configuration['boolean-negation']) {
+                m = arg.match(negatedBoolean);
+                if (m !== null && Array.isArray(m) && m.length >= 2) {
+                    key = m[1];
+                    setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);
+                }
+                // -- separated by space.
+            }
+            else if (arg.match(/^--.+/) || (!configuration['short-option-groups'] && arg.match(/^-[^-]+/))) {
+                m = arg.match(/^--?(.+)/);
+                if (m !== null && Array.isArray(m) && m.length >= 2) {
+                    key = m[1];
+                    if (checkAllAliases(key, flags.arrays)) {
+                        // array format = '--foo a b c'
+                        i = eatArray(i, key, args);
+                    }
+                    else if (checkAllAliases(key, flags.nargs) !== false) {
+                        // nargs format = '--foo a b c'
+                        // should be truthy even if: flags.nargs[key] === 0
+                        i = eatNargs(i, key, args);
+                    }
+                    else {
+                        next = args[i + 1];
+                        if (next !== undefined && (!next.match(/^-/) ||
+                            next.match(negative)) &&
+                            !checkAllAliases(key, flags.bools) &&
+                            !checkAllAliases(key, flags.counts)) {
+                            setArg(key, next);
+                            i++;
+                        }
+                        else if (/^(true|false)$/.test(next)) {
+                            setArg(key, next);
+                            i++;
+                        }
+                        else {
+                            setArg(key, defaultValue(key));
+                        }
+                    }
+                }
+                // dot-notation flag separated by '='.
+            }
+            else if (arg.match(/^-.\..+=/)) {
+                m = arg.match(/^-([^=]+)=([\s\S]*)$/);
+                if (m !== null && Array.isArray(m) && m.length >= 3) {
+                    setArg(m[1], m[2]);
+                }
+                // dot-notation flag separated by space.
+            }
+            else if (arg.match(/^-.\..+/) && !arg.match(negative)) {
+                next = args[i + 1];
+                m = arg.match(/^-(.\..+)/);
+                if (m !== null && Array.isArray(m) && m.length >= 2) {
+                    key = m[1];
+                    if (next !== undefined && !next.match(/^-/) &&
+                        !checkAllAliases(key, flags.bools) &&
+                        !checkAllAliases(key, flags.counts)) {
+                        setArg(key, next);
+                        i++;
+                    }
+                    else {
+                        setArg(key, defaultValue(key));
+                    }
+                }
+            }
+            else if (arg.match(/^-[^-]+/) && !arg.match(negative)) {
+                letters = arg.slice(1, -1).split('');
+                broken = false;
+                for (let j = 0; j < letters.length; j++) {
+                    next = arg.slice(j + 2);
+                    if (letters[j + 1] && letters[j + 1] === '=') {
+                        value = arg.slice(j + 3);
+                        key = letters[j];
+                        if (checkAllAliases(key, flags.arrays)) {
+                            // array format = '-f=a b c'
+                            i = eatArray(i, key, args, value);
+                        }
+                        else if (checkAllAliases(key, flags.nargs) !== false) {
+                            // nargs format = '-f=monkey washing cat'
+                            i = eatNargs(i, key, args, value);
+                        }
+                        else {
+                            setArg(key, value);
+                        }
+                        broken = true;
+                        break;
+                    }
+                    if (next === '-') {
+                        setArg(letters[j], next);
+                        continue;
+                    }
+                    // current letter is an alphabetic character and next value is a number
+                    if (/[A-Za-z]/.test(letters[j]) &&
+                        /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next) &&
+                        checkAllAliases(next, flags.bools) === false) {
+                        setArg(letters[j], next);
+                        broken = true;
+                        break;
+                    }
+                    if (letters[j + 1] && letters[j + 1].match(/\W/)) {
+                        setArg(letters[j], next);
+                        broken = true;
+                        break;
+                    }
+                    else {
+                        setArg(letters[j], defaultValue(letters[j]));
+                    }
+                }
+                key = arg.slice(-1)[0];
+                if (!broken && key !== '-') {
+                    if (checkAllAliases(key, flags.arrays)) {
+                        // array format = '-f a b c'
+                        i = eatArray(i, key, args);
+                    }
+                    else if (checkAllAliases(key, flags.nargs) !== false) {
+                        // nargs format = '-f a b c'
+                        // should be truthy even if: flags.nargs[key] === 0
+                        i = eatNargs(i, key, args);
+                    }
+                    else {
+                        next = args[i + 1];
+                        if (next !== undefined && (!/^(-|--)[^-]/.test(next) ||
+                            next.match(negative)) &&
+                            !checkAllAliases(key, flags.bools) &&
+                            !checkAllAliases(key, flags.counts)) {
+                            setArg(key, next);
+                            i++;
+                        }
+                        else if (/^(true|false)$/.test(next)) {
+                            setArg(key, next);
+                            i++;
+                        }
+                        else {
+                            setArg(key, defaultValue(key));
+                        }
+                    }
+                }
+            }
+            else if (arg.match(/^-[0-9]$/) &&
+                arg.match(negative) &&
+                checkAllAliases(arg.slice(1), flags.bools)) {
+                // single-digit boolean alias, e.g: xargs -0
+                key = arg.slice(1);
+                setArg(key, defaultValue(key));
+            }
+            else if (arg === '--') {
+                notFlags = args.slice(i + 1);
+                break;
+            }
+            else if (configuration['halt-at-non-option']) {
+                notFlags = args.slice(i);
+                break;
+            }
+            else {
+                pushPositional(arg);
+            }
+        }
+        // order of precedence:
+        // 1. command line arg
+        // 2. value from env var
+        // 3. value from config file
+        // 4. value from config objects
+        // 5. configured default value
+        applyEnvVars(argv, true); // special case: check env vars that point to config file
+        applyEnvVars(argv, false);
+        setConfig(argv);
+        setConfigObjects();
+        applyDefaultsAndAliases(argv, flags.aliases, defaults, true);
+        applyCoercions(argv);
+        if (configuration['set-placeholder-key'])
+            setPlaceholderKeys(argv);
+        // for any counts either not in args or without an explicit default, set to 0
+        Object.keys(flags.counts).forEach(function (key) {
+            if (!hasKey(argv, key.split('.')))
+                setArg(key, 0);
+        });
+        // '--' defaults to undefined.
+        if (notFlagsOption && notFlags.length)
+            argv[notFlagsArgv] = [];
+        notFlags.forEach(function (key) {
+            argv[notFlagsArgv].push(key);
+        });
+        if (configuration['camel-case-expansion'] && configuration['strip-dashed']) {
+            Object.keys(argv).filter(key => key !== '--' && key.includes('-')).forEach(key => {
+                delete argv[key];
+            });
+        }
+        if (configuration['strip-aliased']) {
+            [].concat(...Object.keys(aliases).map(k => aliases[k])).forEach(alias => {
+                if (configuration['camel-case-expansion'] && alias.includes('-')) {
+                    delete argv[alias.split('.').map(prop => camelCase(prop)).join('.')];
+                }
+                delete argv[alias];
+            });
+        }
+        // Push argument into positional array, applying numeric coercion:
+        function pushPositional(arg) {
+            const maybeCoercedNumber = maybeCoerceNumber('_', arg);
+            if (typeof maybeCoercedNumber === 'string' || typeof maybeCoercedNumber === 'number') {
+                argv._.push(maybeCoercedNumber);
+            }
+        }
+        // how many arguments should we consume, based
+        // on the nargs option?
+        function eatNargs(i, key, args, argAfterEqualSign) {
+            let ii;
+            let toEat = checkAllAliases(key, flags.nargs);
+            // NaN has a special meaning for the array type, indicating that one or
+            // more values are expected.
+            toEat = typeof toEat !== 'number' || isNaN(toEat) ? 1 : toEat;
+            if (toEat === 0) {
+                if (!isUndefined(argAfterEqualSign)) {
+                    error = Error(__('Argument unexpected for: %s', key));
+                }
+                setArg(key, defaultValue(key));
+                return i;
+            }
+            let available = isUndefined(argAfterEqualSign) ? 0 : 1;
+            if (configuration['nargs-eats-options']) {
+                // classic behavior, yargs eats positional and dash arguments.
+                if (args.length - (i + 1) + available < toEat) {
+                    error = Error(__('Not enough arguments following: %s', key));
+                }
+                available = toEat;
+            }
+            else {
+                // nargs will not consume flag arguments, e.g., -abc, --foo,
+                // and terminates when one is observed.
+                for (ii = i + 1; ii < args.length; ii++) {
+                    if (!args[ii].match(/^-[^0-9]/) || args[ii].match(negative) || isUnknownOptionAsArg(args[ii]))
+                        available++;
+                    else
+                        break;
+                }
+                if (available < toEat)
+                    error = Error(__('Not enough arguments following: %s', key));
+            }
+            let consumed = Math.min(available, toEat);
+            if (!isUndefined(argAfterEqualSign) && consumed > 0) {
+                setArg(key, argAfterEqualSign);
+                consumed--;
+            }
+            for (ii = i + 1; ii < (consumed + i + 1); ii++) {
+                setArg(key, args[ii]);
+            }
+            return (i + consumed);
+        }
+        // if an option is an array, eat all non-hyphenated arguments
+        // following it... YUM!
+        // e.g., --foo apple banana cat becomes ["apple", "banana", "cat"]
+        function eatArray(i, key, args, argAfterEqualSign) {
+            let argsToSet = [];
+            let next = argAfterEqualSign || args[i + 1];
+            // If both array and nargs are configured, enforce the nargs count:
+            const nargsCount = checkAllAliases(key, flags.nargs);
+            if (checkAllAliases(key, flags.bools) && !(/^(true|false)$/.test(next))) {
+                argsToSet.push(true);
+            }
+            else if (isUndefined(next) ||
+                (isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))) {
+                // for keys without value ==> argsToSet remains an empty []
+                // set user default value, if available
+                if (defaults[key] !== undefined) {
+                    const defVal = defaults[key];
+                    argsToSet = Array.isArray(defVal) ? defVal : [defVal];
+                }
+            }
+            else {
+                // value in --option=value is eaten as is
+                if (!isUndefined(argAfterEqualSign)) {
+                    argsToSet.push(processValue(key, argAfterEqualSign, true));
+                }
+                for (let ii = i + 1; ii < args.length; ii++) {
+                    if ((!configuration['greedy-arrays'] && argsToSet.length > 0) ||
+                        (nargsCount && typeof nargsCount === 'number' && argsToSet.length >= nargsCount))
+                        break;
+                    next = args[ii];
+                    if (/^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next))
+                        break;
+                    i = ii;
+                    argsToSet.push(processValue(key, next, inputIsString));
+                }
+            }
+            // If both array and nargs are configured, create an error if less than
+            // nargs positionals were found. NaN has special meaning, indicating
+            // that at least one value is required (more are okay).
+            if (typeof nargsCount === 'number' && ((nargsCount && argsToSet.length < nargsCount) ||
+                (isNaN(nargsCount) && argsToSet.length === 0))) {
+                error = Error(__('Not enough arguments following: %s', key));
+            }
+            setArg(key, argsToSet);
+            return i;
+        }
+        function setArg(key, val, shouldStripQuotes = inputIsString) {
+            if (/-/.test(key) && configuration['camel-case-expansion']) {
+                const alias = key.split('.').map(function (prop) {
+                    return camelCase(prop);
+                }).join('.');
+                addNewAlias(key, alias);
+            }
+            const value = processValue(key, val, shouldStripQuotes);
+            const splitKey = key.split('.');
+            setKey(argv, splitKey, value);
+            // handle populating aliases of the full key
+            if (flags.aliases[key]) {
+                flags.aliases[key].forEach(function (x) {
+                    const keyProperties = x.split('.');
+                    setKey(argv, keyProperties, value);
+                });
+            }
+            // handle populating aliases of the first element of the dot-notation key
+            if (splitKey.length > 1 && configuration['dot-notation']) {
+                (flags.aliases[splitKey[0]] || []).forEach(function (x) {
+                    let keyProperties = x.split('.');
+                    // expand alias with nested objects in key
+                    const a = [].concat(splitKey);
+                    a.shift(); // nuke the old key.
+                    keyProperties = keyProperties.concat(a);
+                    // populate alias only if is not already an alias of the full key
+                    // (already populated above)
+                    if (!(flags.aliases[key] || []).includes(keyProperties.join('.'))) {
+                        setKey(argv, keyProperties, value);
+                    }
+                });
+            }
+            // Set normalize getter and setter when key is in 'normalize' but isn't an array
+            if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
+                const keys = [key].concat(flags.aliases[key] || []);
+                keys.forEach(function (key) {
+                    Object.defineProperty(argvReturn, key, {
+                        enumerable: true,
+                        get() {
+                            return val;
+                        },
+                        set(value) {
+                            val = typeof value === 'string' ? mixin.normalize(value) : value;
+                        }
+                    });
+                });
+            }
+        }
+        function addNewAlias(key, alias) {
+            if (!(flags.aliases[key] && flags.aliases[key].length)) {
+                flags.aliases[key] = [alias];
+                newAliases[alias] = true;
+            }
+            if (!(flags.aliases[alias] && flags.aliases[alias].length)) {
+                addNewAlias(alias, key);
+            }
+        }
+        function processValue(key, val, shouldStripQuotes) {
+            // strings may be quoted, clean this up as we assign values.
+            if (shouldStripQuotes) {
+                val = stripQuotes(val);
+            }
+            // handle parsing boolean arguments --foo=true --bar false.
+            if (checkAllAliases(key, flags.bools) || checkAllAliases(key, flags.counts)) {
+                if (typeof val === 'string')
+                    val = val === 'true';
+            }
+            let value = Array.isArray(val)
+                ? val.map(function (v) { return maybeCoerceNumber(key, v); })
+                : maybeCoerceNumber(key, val);
+            // increment a count given as arg (either no value or value parsed as boolean)
+            if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === 'boolean')) {
+                value = increment();
+            }
+            // Set normalized value when key is in 'normalize' and in 'arrays'
+            if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
+                if (Array.isArray(val))
+                    value = val.map((val) => { return mixin.normalize(val); });
+                else
+                    value = mixin.normalize(val);
+            }
+            return value;
+        }
+        function maybeCoerceNumber(key, value) {
+            if (!configuration['parse-positional-numbers'] && key === '_')
+                return value;
+            if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) {
+                const shouldCoerceNumber = looksLikeNumber(value) && configuration['parse-numbers'] && (Number.isSafeInteger(Math.floor(parseFloat(`${value}`))));
+                if (shouldCoerceNumber || (!isUndefined(value) && checkAllAliases(key, flags.numbers))) {
+                    value = Number(value);
+                }
+            }
+            return value;
+        }
+        // set args from config.json file, this should be
+        // applied last so that defaults can be applied.
+        function setConfig(argv) {
+            const configLookup = Object.create(null);
+            // expand defaults/aliases, in-case any happen to reference
+            // the config.json file.
+            applyDefaultsAndAliases(configLookup, flags.aliases, defaults);
+            Object.keys(flags.configs).forEach(function (configKey) {
+                const configPath = argv[configKey] || configLookup[configKey];
+                if (configPath) {
+                    try {
+                        let config = null;
+                        const resolvedConfigPath = mixin.resolve(mixin.cwd(), configPath);
+                        const resolveConfig = flags.configs[configKey];
+                        if (typeof resolveConfig === 'function') {
+                            try {
+                                config = resolveConfig(resolvedConfigPath);
+                            }
+                            catch (e) {
+                                config = e;
+                            }
+                            if (config instanceof Error) {
+                                error = config;
+                                return;
+                            }
+                        }
+                        else {
+                            config = mixin.require(resolvedConfigPath);
+                        }
+                        setConfigObject(config);
+                    }
+                    catch (ex) {
+                        // Deno will receive a PermissionDenied error if an attempt is
+                        // made to load config without the --allow-read flag:
+                        if (ex.name === 'PermissionDenied')
+                            error = ex;
+                        else if (argv[configKey])
+                            error = Error(__('Invalid JSON config file: %s', configPath));
+                    }
+                }
+            });
+        }
+        // set args from config object.
+        // it recursively checks nested objects.
+        function setConfigObject(config, prev) {
+            Object.keys(config).forEach(function (key) {
+                const value = config[key];
+                const fullKey = prev ? prev + '.' + key : key;
+                // if the value is an inner object and we have dot-notation
+                // enabled, treat inner objects in config the same as
+                // heavily nested dot notations (foo.bar.apple).
+                if (typeof value === 'object' && value !== null && !Array.isArray(value) && configuration['dot-notation']) {
+                    // if the value is an object but not an array, check nested object
+                    setConfigObject(value, fullKey);
+                }
+                else {
+                    // setting arguments via CLI takes precedence over
+                    // values within the config file.
+                    if (!hasKey(argv, fullKey.split('.')) || (checkAllAliases(fullKey, flags.arrays) && configuration['combine-arrays'])) {
+                        setArg(fullKey, value);
+                    }
+                }
+            });
+        }
+        // set all config objects passed in opts
+        function setConfigObjects() {
+            if (typeof configObjects !== 'undefined') {
+                configObjects.forEach(function (configObject) {
+                    setConfigObject(configObject);
+                });
+            }
+        }
+        function applyEnvVars(argv, configOnly) {
+            if (typeof envPrefix === 'undefined')
+                return;
+            const prefix = typeof envPrefix === 'string' ? envPrefix : '';
+            const env = mixin.env();
+            Object.keys(env).forEach(function (envVar) {
+                if (prefix === '' || envVar.lastIndexOf(prefix, 0) === 0) {
+                    // get array of nested keys and convert them to camel case
+                    const keys = envVar.split('__').map(function (key, i) {
+                        if (i === 0) {
+                            key = key.substring(prefix.length);
+                        }
+                        return camelCase(key);
+                    });
+                    if (((configOnly && flags.configs[keys.join('.')]) || !configOnly) && !hasKey(argv, keys)) {
+                        setArg(keys.join('.'), env[envVar]);
+                    }
+                }
+            });
+        }
+        function applyCoercions(argv) {
+            let coerce;
+            const applied = new Set();
+            Object.keys(argv).forEach(function (key) {
+                if (!applied.has(key)) { // If we haven't already coerced this option via one of its aliases
+                    coerce = checkAllAliases(key, flags.coercions);
+                    if (typeof coerce === 'function') {
+                        try {
+                            const value = maybeCoerceNumber(key, coerce(argv[key]));
+                            ([].concat(flags.aliases[key] || [], key)).forEach(ali => {
+                                applied.add(ali);
+                                argv[ali] = value;
+                            });
+                        }
+                        catch (err) {
+                            error = err;
+                        }
+                    }
+                }
+            });
+        }
+        function setPlaceholderKeys(argv) {
+            flags.keys.forEach((key) => {
+                // don't set placeholder keys for dot notation options 'foo.bar'.
+                if (~key.indexOf('.'))
+                    return;
+                if (typeof argv[key] === 'undefined')
+                    argv[key] = undefined;
+            });
+            return argv;
+        }
+        function applyDefaultsAndAliases(obj, aliases, defaults, canLog = false) {
+            Object.keys(defaults).forEach(function (key) {
+                if (!hasKey(obj, key.split('.'))) {
+                    setKey(obj, key.split('.'), defaults[key]);
+                    if (canLog)
+                        defaulted[key] = true;
+                    (aliases[key] || []).forEach(function (x) {
+                        if (hasKey(obj, x.split('.')))
+                            return;
+                        setKey(obj, x.split('.'), defaults[key]);
+                    });
+                }
+            });
+        }
+        function hasKey(obj, keys) {
+            let o = obj;
+            if (!configuration['dot-notation'])
+                keys = [keys.join('.')];
+            keys.slice(0, -1).forEach(function (key) {
+                o = (o[key] || {});
+            });
+            const key = keys[keys.length - 1];
+            if (typeof o !== 'object')
+                return false;
+            else
+                return key in o;
+        }
+        function setKey(obj, keys, value) {
+            let o = obj;
+            if (!configuration['dot-notation'])
+                keys = [keys.join('.')];
+            keys.slice(0, -1).forEach(function (key) {
+                // TODO(bcoe): in the next major version of yargs, switch to
+                // Object.create(null) for dot notation:
+                key = sanitizeKey(key);
+                if (typeof o === 'object' && o[key] === undefined) {
+                    o[key] = {};
+                }
+                if (typeof o[key] !== 'object' || Array.isArray(o[key])) {
+                    // ensure that o[key] is an array, and that the last item is an empty object.
+                    if (Array.isArray(o[key])) {
+                        o[key].push({});
+                    }
+                    else {
+                        o[key] = [o[key], {}];
+                    }
+                    // we want to update the empty object at the end of the o[key] array, so set o to that object
+                    o = o[key][o[key].length - 1];
+                }
+                else {
+                    o = o[key];
+                }
+            });
+            // TODO(bcoe): in the next major version of yargs, switch to
+            // Object.create(null) for dot notation:
+            const key = sanitizeKey(keys[keys.length - 1]);
+            const isTypeArray = checkAllAliases(keys.join('.'), flags.arrays);
+            const isValueArray = Array.isArray(value);
+            let duplicate = configuration['duplicate-arguments-array'];
+            // nargs has higher priority than duplicate
+            if (!duplicate && checkAllAliases(key, flags.nargs)) {
+                duplicate = true;
+                if ((!isUndefined(o[key]) && flags.nargs[key] === 1) || (Array.isArray(o[key]) && o[key].length === flags.nargs[key])) {
+                    o[key] = undefined;
+                }
+            }
+            if (value === increment()) {
+                o[key] = increment(o[key]);
+            }
+            else if (Array.isArray(o[key])) {
+                if (duplicate && isTypeArray && isValueArray) {
+                    o[key] = configuration['flatten-duplicate-arrays'] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]);
+                }
+                else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
+                    o[key] = value;
+                }
+                else {
+                    o[key] = o[key].concat([value]);
+                }
+            }
+            else if (o[key] === undefined && isTypeArray) {
+                o[key] = isValueArray ? value : [value];
+            }
+            else if (duplicate && !(o[key] === undefined ||
+                checkAllAliases(key, flags.counts) ||
+                checkAllAliases(key, flags.bools))) {
+                o[key] = [o[key], value];
+            }
+            else {
+                o[key] = value;
+            }
+        }
+        // extend the aliases list with inferred aliases.
+        function extendAliases(...args) {
+            args.forEach(function (obj) {
+                Object.keys(obj || {}).forEach(function (key) {
+                    // short-circuit if we've already added a key
+                    // to the aliases array, for example it might
+                    // exist in both 'opts.default' and 'opts.key'.
+                    if (flags.aliases[key])
+                        return;
+                    flags.aliases[key] = [].concat(aliases[key] || []);
+                    // For "--option-name", also set argv.optionName
+                    flags.aliases[key].concat(key).forEach(function (x) {
+                        if (/-/.test(x) && configuration['camel-case-expansion']) {
+                            const c = camelCase(x);
+                            if (c !== key && flags.aliases[key].indexOf(c) === -1) {
+                                flags.aliases[key].push(c);
+                                newAliases[c] = true;
+                            }
+                        }
+                    });
+                    // For "--optionName", also set argv['option-name']
+                    flags.aliases[key].concat(key).forEach(function (x) {
+                        if (x.length > 1 && /[A-Z]/.test(x) && configuration['camel-case-expansion']) {
+                            const c = decamelize(x, '-');
+                            if (c !== key && flags.aliases[key].indexOf(c) === -1) {
+                                flags.aliases[key].push(c);
+                                newAliases[c] = true;
+                            }
+                        }
+                    });
+                    flags.aliases[key].forEach(function (x) {
+                        flags.aliases[x] = [key].concat(flags.aliases[key].filter(function (y) {
+                            return x !== y;
+                        }));
+                    });
+                });
+            });
+        }
+        function checkAllAliases(key, flag) {
+            const toCheck = [].concat(flags.aliases[key] || [], key);
+            const keys = Object.keys(flag);
+            const setAlias = toCheck.find(key => keys.includes(key));
+            return setAlias ? flag[setAlias] : false;
+        }
+        function hasAnyFlag(key) {
+            const flagsKeys = Object.keys(flags);
+            const toCheck = [].concat(flagsKeys.map(k => flags[k]));
+            return toCheck.some(function (flag) {
+                return Array.isArray(flag) ? flag.includes(key) : flag[key];
+            });
+        }
+        function hasFlagsMatching(arg, ...patterns) {
+            const toCheck = [].concat(...patterns);
+            return toCheck.some(function (pattern) {
+                const match = arg.match(pattern);
+                return match && hasAnyFlag(match[1]);
+            });
+        }
+        // based on a simplified version of the short flag group parsing logic
+        function hasAllShortFlags(arg) {
+            // if this is a negative number, or doesn't start with a single hyphen, it's not a short flag group
+            if (arg.match(negative) || !arg.match(/^-[^-]+/)) {
+                return false;
+            }
+            let hasAllFlags = true;
+            let next;
+            const letters = arg.slice(1).split('');
+            for (let j = 0; j < letters.length; j++) {
+                next = arg.slice(j + 2);
+                if (!hasAnyFlag(letters[j])) {
+                    hasAllFlags = false;
+                    break;
+                }
+                if ((letters[j + 1] && letters[j + 1] === '=') ||
+                    next === '-' ||
+                    (/[A-Za-z]/.test(letters[j]) && /^-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) ||
+                    (letters[j + 1] && letters[j + 1].match(/\W/))) {
+                    break;
+                }
+            }
+            return hasAllFlags;
+        }
+        function isUnknownOptionAsArg(arg) {
+            return configuration['unknown-options-as-args'] && isUnknownOption(arg);
+        }
+        function isUnknownOption(arg) {
+            arg = arg.replace(/^-{3,}/, '--');
+            // ignore negative numbers
+            if (arg.match(negative)) {
+                return false;
+            }
+            // if this is a short option group and all of them are configured, it isn't unknown
+            if (hasAllShortFlags(arg)) {
+                return false;
+            }
+            // e.g. '--count=2'
+            const flagWithEquals = /^-+([^=]+?)=[\s\S]*$/;
+            // e.g. '-a' or '--arg'
+            const normalFlag = /^-+([^=]+?)$/;
+            // e.g. '-a-'
+            const flagEndingInHyphen = /^-+([^=]+?)-$/;
+            // e.g. '-abc123'
+            const flagEndingInDigits = /^-+([^=]+?\d+)$/;
+            // e.g. '-a/usr/local'
+            const flagEndingInNonWordCharacters = /^-+([^=]+?)\W+.*$/;
+            // check the different types of flag styles, including negatedBoolean, a pattern defined near the start of the parse method
+            return !hasFlagsMatching(arg, flagWithEquals, negatedBoolean, normalFlag, flagEndingInHyphen, flagEndingInDigits, flagEndingInNonWordCharacters);
+        }
+        // make a best effort to pick a default value
+        // for an option based on name and type.
+        function defaultValue(key) {
+            if (!checkAllAliases(key, flags.bools) &&
+                !checkAllAliases(key, flags.counts) &&
+                `${key}` in defaults) {
+                return defaults[key];
+            }
+            else {
+                return defaultForType(guessType(key));
+            }
+        }
+        // return a default value, given the type of a flag.,
+        function defaultForType(type) {
+            const def = {
+                [DefaultValuesForTypeKey.BOOLEAN]: true,
+                [DefaultValuesForTypeKey.STRING]: '',
+                [DefaultValuesForTypeKey.NUMBER]: undefined,
+                [DefaultValuesForTypeKey.ARRAY]: []
+            };
+            return def[type];
+        }
+        // given a flag, enforce a default type.
+        function guessType(key) {
+            let type = DefaultValuesForTypeKey.BOOLEAN;
+            if (checkAllAliases(key, flags.strings))
+                type = DefaultValuesForTypeKey.STRING;
+            else if (checkAllAliases(key, flags.numbers))
+                type = DefaultValuesForTypeKey.NUMBER;
+            else if (checkAllAliases(key, flags.bools))
+                type = DefaultValuesForTypeKey.BOOLEAN;
+            else if (checkAllAliases(key, flags.arrays))
+                type = DefaultValuesForTypeKey.ARRAY;
+            return type;
+        }
+        function isUndefined(num) {
+            return num === undefined;
+        }
+        // check user configuration settings for inconsistencies
+        function checkConfiguration() {
+            // count keys should not be set as array/narg
+            Object.keys(flags.counts).find(key => {
+                if (checkAllAliases(key, flags.arrays)) {
+                    error = Error(__('Invalid configuration: %s, opts.count excludes opts.array.', key));
+                    return true;
+                }
+                else if (checkAllAliases(key, flags.nargs)) {
+                    error = Error(__('Invalid configuration: %s, opts.count excludes opts.narg.', key));
+                    return true;
+                }
+                return false;
+            });
+        }
+        return {
+            aliases: Object.assign({}, flags.aliases),
+            argv: Object.assign(argvReturn, argv),
+            configuration: configuration,
+            defaulted: Object.assign({}, defaulted),
+            error: error,
+            newAliases: Object.assign({}, newAliases)
+        };
+    }
+}
+// if any aliases reference each other, we should
+// merge them together.
+function combineAliases(aliases) {
+    const aliasArrays = [];
+    const combined = Object.create(null);
+    let change = true;
+    // turn alias lookup hash {key: ['alias1', 'alias2']} into
+    // a simple array ['key', 'alias1', 'alias2']
+    Object.keys(aliases).forEach(function (key) {
+        aliasArrays.push([].concat(aliases[key], key));
+    });
+    // combine arrays until zero changes are
+    // made in an iteration.
+    while (change) {
+        change = false;
+        for (let i = 0; i < aliasArrays.length; i++) {
+            for (let ii = i + 1; ii < aliasArrays.length; ii++) {
+                const intersect = aliasArrays[i].filter(function (v) {
+                    return aliasArrays[ii].indexOf(v) !== -1;
+                });
+                if (intersect.length) {
+                    aliasArrays[i] = aliasArrays[i].concat(aliasArrays[ii]);
+                    aliasArrays.splice(ii, 1);
+                    change = true;
+                    break;
+                }
+            }
+        }
+    }
+    // map arrays back to the hash-lookup (de-dupe while
+    // we're at it).
+    aliasArrays.forEach(function (aliasArray) {
+        aliasArray = aliasArray.filter(function (v, i, self) {
+            return self.indexOf(v) === i;
+        });
+        const lastAlias = aliasArray.pop();
+        if (lastAlias !== undefined && typeof lastAlias === 'string') {
+            combined[lastAlias] = aliasArray;
+        }
+    });
+    return combined;
+}
+// this function should only be called when a count is given as an arg
+// it is NOT called to set a default value
+// thus we can start the count at 1 instead of 0
+function increment(orig) {
+    return orig !== undefined ? orig + 1 : 1;
+}
+// TODO(bcoe): in the next major version of yargs, switch to
+// Object.create(null) for dot notation:
+function sanitizeKey(key) {
+    if (key === '__proto__')
+        return '___proto___';
+    return key;
+}
+function stripQuotes(val) {
+    return (typeof val === 'string' &&
+        (val[0] === "'" || val[0] === '"') &&
+        val[val.length - 1] === val[0])
+        ? val.substring(1, val.length - 1)
+        : val;
+}
+
+/**
+ * @fileoverview Main entrypoint for libraries using yargs-parser in Node.js
+ * CJS and ESM environments.
+ *
+ * @license
+ * Copyright (c) 2016, Contributors
+ * SPDX-License-Identifier: ISC
+ */
+var _a, _b, _c;
+// See https://github.com/yargs/yargs-parser#supported-nodejs-versions for our
+// version support policy. The YARGS_MIN_NODE_VERSION is used for testing only.
+const minNodeVersion = (process && process.env && process.env.YARGS_MIN_NODE_VERSION)
+    ? Number(process.env.YARGS_MIN_NODE_VERSION)
+    : 12;
+const nodeVersion = (_b = (_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) !== null && _b !== void 0 ? _b : (_c = process === null || process === void 0 ? void 0 : process.version) === null || _c === void 0 ? void 0 : _c.slice(1);
+if (nodeVersion) {
+    const major = Number(nodeVersion.match(/^([^.]+)/)[1]);
+    if (major < minNodeVersion) {
+        throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`);
+    }
+}
+// Creates a yargs-parser instance using Node.js standard libraries:
+const env = process ? process.env : {};
+const parser = new YargsParser({
+    cwd: process.cwd,
+    env: () => {
+        return env;
+    },
+    format: require$$2.format,
+    normalize: require$$0.normalize,
+    resolve: require$$0.resolve,
+    // TODO: figure  out a  way to combine ESM and CJS coverage, such  that
+    // we can exercise all the lines below:
+    require: (path) => {
+        if (typeof require !== 'undefined') {
+            return require(path);
+        }
+        else if (path.match(/\.json$/)) {
+            // Addresses: https://github.com/yargs/yargs/issues/2040
+            return JSON.parse(require$$0$1.readFileSync(path, 'utf8'));
+        }
+        else {
+            throw Error('only .json config files are supported in ESM');
+        }
+    }
+});
+const yargsParser = function Parser(args, opts) {
+    const result = parser.parse(args.slice(), opts);
+    return result.argv;
+};
+yargsParser.detailed = function (args, opts) {
+    return parser.parse(args.slice(), opts);
+};
+yargsParser.camelCase = camelCase;
+yargsParser.decamelize = decamelize;
+yargsParser.looksLikeNumber = looksLikeNumber;
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __addDisposableResource(env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+
+}
+
+var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function __disposeResources(env) {
+    function fail(e) {
+        env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+        env.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+        while (r = env.stack.pop()) {
+            try {
+                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                if (r.dispose) {
+                    var result = r.dispose.call(r.value);
+                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                else s |= 1;
+            }
+            catch (e) {
+                fail(e);
+            }
+        }
+        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+        if (env.hasError) throw env.error;
+    }
+    return next();
+}
+
+const toZeroIfInfinity = value => Number.isFinite(value) ? value : 0;
+
+function parseNumber(milliseconds) {
+	return {
+		days: Math.trunc(milliseconds / 86_400_000),
+		hours: Math.trunc(milliseconds / 3_600_000 % 24),
+		minutes: Math.trunc(milliseconds / 60_000 % 60),
+		seconds: Math.trunc(milliseconds / 1000 % 60),
+		milliseconds: Math.trunc(milliseconds % 1000),
+		microseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1000) % 1000),
+		nanoseconds: Math.trunc(toZeroIfInfinity(milliseconds * 1e6) % 1000),
+	};
+}
+
+function parseBigint(milliseconds) {
+	return {
+		days: milliseconds / 86_400_000n,
+		hours: milliseconds / 3_600_000n % 24n,
+		minutes: milliseconds / 60_000n % 60n,
+		seconds: milliseconds / 1000n % 60n,
+		milliseconds: milliseconds % 1000n,
+		microseconds: 0n,
+		nanoseconds: 0n,
+	};
+}
+
+function parseMilliseconds(milliseconds) {
+	switch (typeof milliseconds) {
+		case 'number': {
+			if (Number.isFinite(milliseconds)) {
+				return parseNumber(milliseconds);
+			}
+
+			break;
+		}
+
+		case 'bigint': {
+			return parseBigint(milliseconds);
+		}
+
+		// No default
+	}
+
+	throw new TypeError('Expected a finite number or bigint');
+}
+
+const isZero = value => value === 0 || value === 0n;
+const pluralize = (word, count) => (count === 1 || count === 1n) ? word : `${word}s`;
+
+const SECOND_ROUNDING_EPSILON = 0.000_000_1;
+const ONE_DAY_IN_MILLISECONDS = 24n * 60n * 60n * 1000n;
+
+function prettyMilliseconds(milliseconds, options) {
+	const isBigInt = typeof milliseconds === 'bigint';
+	if (!isBigInt && !Number.isFinite(milliseconds)) {
+		throw new TypeError('Expected a finite number or bigint');
+	}
+
+	options = {...options};
+
+	const sign = milliseconds < 0 ? '-' : '';
+	milliseconds = milliseconds < 0 ? -milliseconds : milliseconds; // Cannot use `Math.abs()` because of BigInt support.
+
+	if (options.colonNotation) {
+		options.compact = false;
+		options.formatSubMilliseconds = false;
+		options.separateMilliseconds = false;
+		options.verbose = false;
+	}
+
+	if (options.compact) {
+		options.unitCount = 1;
+		options.secondsDecimalDigits = 0;
+		options.millisecondsDecimalDigits = 0;
+	}
+
+	let result = [];
+
+	const floorDecimals = (value, decimalDigits) => {
+		const flooredInterimValue = Math.floor((value * (10 ** decimalDigits)) + SECOND_ROUNDING_EPSILON);
+		const flooredValue = Math.round(flooredInterimValue) / (10 ** decimalDigits);
+		return flooredValue.toFixed(decimalDigits);
+	};
+
+	const add = (value, long, short, valueString) => {
+		if (
+			(result.length === 0 || !options.colonNotation)
+			&& isZero(value)
+			&& !(options.colonNotation && short === 'm')) {
+			return;
+		}
+
+		valueString ??= String(value);
+		if (options.colonNotation) {
+			const wholeDigits = valueString.includes('.') ? valueString.split('.')[0].length : valueString.length;
+			const minLength = result.length > 0 ? 2 : 1;
+			valueString = '0'.repeat(Math.max(0, minLength - wholeDigits)) + valueString;
+		} else {
+			valueString += options.verbose ? ' ' + pluralize(long, value) : short;
+		}
+
+		result.push(valueString);
+	};
+
+	const parsed = parseMilliseconds(milliseconds);
+	const days = BigInt(parsed.days);
+
+	if (options.hideYearAndDays) {
+		add((BigInt(days) * 24n) + BigInt(parsed.hours), 'hour', 'h');
+	} else {
+		if (options.hideYear) {
+			add(days, 'day', 'd');
+		} else {
+			add(days / 365n, 'year', 'y');
+			add(days % 365n, 'day', 'd');
+		}
+
+		add(Number(parsed.hours), 'hour', 'h');
+	}
+
+	add(Number(parsed.minutes), 'minute', 'm');
+
+	if (!options.hideSeconds) {
+		if (
+			options.separateMilliseconds
+			|| options.formatSubMilliseconds
+			|| (!options.colonNotation && milliseconds < 1000 && !options.subSecondsAsDecimals)
+		) {
+			const seconds = Number(parsed.seconds);
+			const milliseconds = Number(parsed.milliseconds);
+			const microseconds = Number(parsed.microseconds);
+			const nanoseconds = Number(parsed.nanoseconds);
+
+			add(seconds, 'second', 's');
+
+			if (options.formatSubMilliseconds) {
+				add(milliseconds, 'millisecond', 'ms');
+				add(microseconds, 'microsecond', 'µs');
+				add(nanoseconds, 'nanosecond', 'ns');
+			} else {
+				const millisecondsAndBelow
+					= milliseconds
+					+ (microseconds / 1000)
+					+ (nanoseconds / 1e6);
+
+				const millisecondsDecimalDigits
+					= typeof options.millisecondsDecimalDigits === 'number'
+						? options.millisecondsDecimalDigits
+						: 0;
+
+				const roundedMilliseconds = millisecondsAndBelow >= 1
+					? Math.round(millisecondsAndBelow)
+					: Math.ceil(millisecondsAndBelow);
+
+				const millisecondsString = millisecondsDecimalDigits
+					? millisecondsAndBelow.toFixed(millisecondsDecimalDigits)
+					: roundedMilliseconds;
+
+				add(
+					Number.parseFloat(millisecondsString),
+					'millisecond',
+					'ms',
+					millisecondsString,
+				);
+			}
+		} else {
+			const seconds = (
+				(isBigInt ? Number(milliseconds % ONE_DAY_IN_MILLISECONDS) : milliseconds)
+				/ 1000
+			) % 60;
+			const secondsDecimalDigits
+				= typeof options.secondsDecimalDigits === 'number'
+					? options.secondsDecimalDigits
+					: 1;
+			const secondsFixed = floorDecimals(seconds, secondsDecimalDigits);
+			const secondsString = options.keepDecimalsOnWholeSeconds
+				? secondsFixed
+				: secondsFixed.replace(/\.0+$/, '');
+			add(Number.parseFloat(secondsString), 'second', 's', secondsString);
+		}
+	}
+
+	if (result.length === 0) {
+		return sign + '0' + (options.verbose ? ' milliseconds' : 'ms');
+	}
+
+	const separator = options.colonNotation ? ':' : ' ';
+	if (typeof options.unitCount === 'number') {
+		result = result.slice(0, Math.max(options.unitCount, 1));
+	}
+
+	return sign + result.join(separator);
+}
+
+const BYTE_UNITS = [
+	'B',
+	'kB',
+	'MB',
+	'GB',
+	'TB',
+	'PB',
+	'EB',
+	'ZB',
+	'YB',
+];
+
+const BIBYTE_UNITS = [
+	'B',
+	'KiB',
+	'MiB',
+	'GiB',
+	'TiB',
+	'PiB',
+	'EiB',
+	'ZiB',
+	'YiB',
+];
+
+const BIT_UNITS = [
+	'b',
+	'kbit',
+	'Mbit',
+	'Gbit',
+	'Tbit',
+	'Pbit',
+	'Ebit',
+	'Zbit',
+	'Ybit',
+];
+
+const BIBIT_UNITS = [
+	'b',
+	'kibit',
+	'Mibit',
+	'Gibit',
+	'Tibit',
+	'Pibit',
+	'Eibit',
+	'Zibit',
+	'Yibit',
+];
+
+/*
+Formats the given number using `Number#toLocaleString`.
+- If locale is a string, the value is expected to be a locale-key (for example: `de`).
+- If locale is true, the system default locale is used for translation.
+- If no value for locale is specified, the number is returned unmodified.
+*/
+const toLocaleString = (number, locale, options) => {
+	let result = number;
+	if (typeof locale === 'string' || Array.isArray(locale)) {
+		result = number.toLocaleString(locale, options);
+	} else if (locale === true || options !== undefined) {
+		result = number.toLocaleString(undefined, options);
+	}
+
+	return result;
+};
+
+const log10 = numberOrBigInt => {
+	if (typeof numberOrBigInt === 'number') {
+		return Math.log10(numberOrBigInt);
+	}
+
+	const string = numberOrBigInt.toString(10);
+
+	return string.length + Math.log10(`0.${string.slice(0, 15)}`);
+};
+
+const log = numberOrBigInt => {
+	if (typeof numberOrBigInt === 'number') {
+		return Math.log(numberOrBigInt);
+	}
+
+	return log10(numberOrBigInt) * Math.log(10);
+};
+
+const divide = (numberOrBigInt, divisor) => {
+	if (typeof numberOrBigInt === 'number') {
+		return numberOrBigInt / divisor;
+	}
+
+	const integerPart = numberOrBigInt / BigInt(divisor);
+	const remainder = numberOrBigInt % BigInt(divisor);
+	return Number(integerPart) + (Number(remainder) / divisor);
+};
+
+const applyFixedWidth = (result, fixedWidth) => {
+	if (fixedWidth === undefined) {
+		return result;
+	}
+
+	if (typeof fixedWidth !== 'number' || !Number.isSafeInteger(fixedWidth) || fixedWidth < 0) {
+		throw new TypeError(`Expected fixedWidth to be a non-negative integer, got ${typeof fixedWidth}: ${fixedWidth}`);
+	}
+
+	if (fixedWidth === 0) {
+		return result;
+	}
+
+	return result.length < fixedWidth ? result.padStart(fixedWidth, ' ') : result;
+};
+
+const buildLocaleOptions = options => {
+	const {minimumFractionDigits, maximumFractionDigits} = options;
+
+	if (minimumFractionDigits === undefined && maximumFractionDigits === undefined) {
+		return undefined;
+	}
+
+	return {
+		...(minimumFractionDigits !== undefined && {minimumFractionDigits}),
+		...(maximumFractionDigits !== undefined && {maximumFractionDigits}),
+		roundingMode: 'trunc',
+	};
+};
+
+function prettyBytes(number, options) {
+	if (typeof number !== 'bigint' && !Number.isFinite(number)) {
+		throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
+	}
+
+	options = {
+		bits: false,
+		binary: false,
+		space: true,
+		nonBreakingSpace: false,
+		...options,
+	};
+
+	const UNITS = options.bits
+		? (options.binary ? BIBIT_UNITS : BIT_UNITS)
+		: (options.binary ? BIBYTE_UNITS : BYTE_UNITS);
+
+	const separator = options.space ? (options.nonBreakingSpace ? '\u00A0' : ' ') : '';
+
+	// Handle signed zero case
+	const isZero = typeof number === 'number' ? number === 0 : number === 0n;
+	if (options.signed && isZero) {
+		const result = ` 0${separator}${UNITS[0]}`;
+		return applyFixedWidth(result, options.fixedWidth);
+	}
+
+	const isNegative = number < 0;
+	const prefix = isNegative ? '-' : (options.signed ? '+' : '');
+
+	if (isNegative) {
+		number = -number;
+	}
+
+	const localeOptions = buildLocaleOptions(options);
+	let result;
+
+	if (number < 1) {
+		const numberString = toLocaleString(number, options.locale, localeOptions);
+		result = prefix + numberString + separator + UNITS[0];
+	} else {
+		const exponent = Math.min(Math.floor(options.binary ? log(number) / Math.log(1024) : log10(number) / 3), UNITS.length - 1);
+		number = divide(number, (options.binary ? 1024 : 1000) ** exponent);
+
+		if (!localeOptions) {
+			const minPrecision = Math.max(3, Math.floor(number).toString().length);
+			number = number.toPrecision(minPrecision);
+		}
+
+		const numberString = toLocaleString(Number(number), options.locale, localeOptions);
+		const unit = UNITS[exponent];
+		result = prefix + numberString + separator + unit;
+	}
+
+	return applyFixedWidth(result, options.fixedWidth);
+}
+
+function printTimings(timings) {
+    for (const [label, [time, memory, total]] of Object.entries(timings)) {
+        const appliedColor = label[0] === '#' ? (label[1] === '#' ? rollup.bold : rollup.underline) : (text) => text;
+        const row = `${label}: ${time.toFixed(0)}ms, ${prettyBytes(memory)} / ${prettyBytes(total)}`;
+        console.info(appliedColor(row));
+    }
+}
+
+async function build(inputOptions, warnings, silent = false) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const outputOptions = inputOptions.output;
+        const useStdout = !outputOptions[0].file && !outputOptions[0].dir;
+        const start = Date.now();
+        const files = useStdout ? ['stdout'] : outputOptions.map(t => parseAst_js.relativeId(t.file || t.dir));
+        if (!silent) {
+            let inputFiles;
+            if (typeof inputOptions.input === 'string') {
+                inputFiles = inputOptions.input;
+            }
+            else if (Array.isArray(inputOptions.input)) {
+                inputFiles = inputOptions.input.join(', ');
+            }
+            else if (typeof inputOptions.input === 'object' && inputOptions.input !== null) {
+                inputFiles = Object.values(inputOptions.input).join(', ');
+            }
+            rollup.stderr(rollup.cyan(`\n${rollup.bold(inputFiles)} → ${rollup.bold(files.join(', '))}...`));
+        }
+        const bundle = __addDisposableResource(env_1, await rollup.rollup(inputOptions), true);
+        if (useStdout) {
+            const output = outputOptions[0];
+            if (output.sourcemap && output.sourcemap !== 'inline') {
+                rollup.handleError(parseAst_js.logOnlyInlineSourcemapsForStdout());
+            }
+            const { output: outputs } = await bundle.generate(output);
+            for (const file of outputs) {
+                if (outputs.length > 1)
+                    process$1.stdout.write(`\n${rollup.cyan(rollup.bold(`//→ ${file.fileName}:`))}\n`);
+                process$1.stdout.write(file.type === 'asset' ? file.source : file.code);
+            }
+            if (!silent) {
+                warnings.flush();
+            }
+            return;
+        }
+        await Promise.all(outputOptions.map(bundle.write));
+        if (!silent) {
+            warnings.flush();
+            rollup.stderr(rollup.green(`created ${rollup.bold(files.join(', '))} in ${rollup.bold(prettyMilliseconds(Date.now() - start))}`));
+            if (bundle && bundle.getTimings) {
+                printTimings(bundle.getTimings());
+            }
+        }
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
+}
+
+const DEFAULT_CONFIG_BASE = 'rollup.config';
+async function getConfigPath(commandConfig) {
+    if (commandConfig === true) {
+        return path.resolve(await findConfigFileNameInCwd());
+    }
+    if (commandConfig.slice(0, 5) === 'node:') {
+        const packageName = commandConfig.slice(5);
+        try {
+            return require.resolve(`rollup-config-${packageName}`, { paths: [process$1.cwd()] });
+        }
+        catch {
+            try {
+                return require.resolve(packageName, { paths: [process$1.cwd()] });
+            }
+            catch (error) {
+                if (error.code === 'MODULE_NOT_FOUND') {
+                    rollup.handleError(parseAst_js.logMissingExternalConfig(commandConfig));
+                }
+                throw error;
+            }
+        }
+    }
+    return path.resolve(commandConfig);
+}
+async function findConfigFileNameInCwd() {
+    const filesInWorkingDirectory = new Set(await promises.readdir(process$1.cwd()));
+    for (const extension of ['mjs', 'cjs', 'ts']) {
+        const fileName = `${DEFAULT_CONFIG_BASE}.${extension}`;
+        if (filesInWorkingDirectory.has(fileName))
+            return fileName;
+    }
+    return `${DEFAULT_CONFIG_BASE}.js`;
+}
+
+async function loadConfigFromCommand(commandOptions, watchMode) {
+    const warnings = loadConfigFile_js.batchWarnings(commandOptions);
+    if (!commandOptions.input && (commandOptions.stdin || !process$1.stdin.isTTY)) {
+        commandOptions.input = loadConfigFile_js.stdinName;
+    }
+    const options = await rollup.mergeOptions({ input: [] }, watchMode, commandOptions, warnings.log);
+    await loadConfigFile_js.addCommandPluginsToInputOptions(options, commandOptions);
+    return { options: [options], warnings };
+}
+
+async function runRollup(command) {
+    let inputSource;
+    if (command._.length > 0) {
+        if (command.input) {
+            rollup.handleError(parseAst_js.logDuplicateImportOptions());
+        }
+        inputSource = command._;
+    }
+    else if (typeof command.input === 'string') {
+        inputSource = [command.input];
+    }
+    else {
+        inputSource = command.input;
+    }
+    if (inputSource && inputSource.length > 0) {
+        if (inputSource.some((input) => input.includes('='))) {
+            command.input = {};
+            for (const input of inputSource) {
+                const equalsIndex = input.indexOf('=');
+                const value = input.slice(Math.max(0, equalsIndex + 1));
+                const key = input.slice(0, Math.max(0, equalsIndex)) || parseAst_js.getAliasName(input);
+                command.input[key] = value;
+            }
+        }
+        else {
+            command.input = inputSource;
+        }
+    }
+    if (command.environment) {
+        const environment = Array.isArray(command.environment)
+            ? command.environment
+            : [command.environment];
+        for (const argument of environment) {
+            for (const pair of argument.split(',')) {
+                const [key, ...value] = pair.split(':');
+                process$1.env[key] = value.length === 0 ? String(true) : value.join(':');
+            }
+        }
+    }
+    if (rollup.isWatchEnabled(command.watch)) {
+        await fseventsImporter.loadFsEvents();
+        const { watch } = await Promise.resolve().then(() => require('../shared/watch-cli.js'));
+        await watch(command);
+    }
+    else {
+        try {
+            const { options, warnings } = await getConfigs(command);
+            try {
+                for (const inputOptions of options) {
+                    if (!inputOptions.cache) {
+                        // We explicitly disable the cache when unused as the CLI will not
+                        // use the cache object on the bundle when not in watch mode. This
+                        // improves performance as the cache is not generated.
+                        inputOptions.cache = false;
+                    }
+                    await build(inputOptions, warnings, command.silent);
+                }
+                if (command.failAfterWarnings && warnings.warningOccurred) {
+                    warnings.flush();
+                    rollup.handleError(parseAst_js.logFailAfterWarnings());
+                }
+            }
+            catch (error) {
+                warnings.flush();
+                rollup.handleError(error);
+            }
+        }
+        catch (error) {
+            rollup.handleError(error);
+        }
+    }
+}
+async function getConfigs(command) {
+    if (command.config) {
+        const configFile = await getConfigPath(command.config);
+        const { options, warnings } = await loadConfigFile_js.loadConfigFile(configFile, command, false);
+        return { options, warnings };
+    }
+    return await loadConfigFromCommand(command, false);
+}
+
+const command = yargsParser(process$1.argv.slice(2), {
+    alias: rollup.commandAliases,
+    configuration: { 'camel-case-expansion': false }
+});
+if (command.help || (process$1.argv.length <= 2 && process$1.stdin.isTTY)) {
+    console.log(`\n${help}\n`);
+}
+else if (command.version) {
+    console.log(`rollup v${rollup.version}`);
+}
+else {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        require('source-map-support').install();
+    }
+    catch {
+        // do nothing
+    }
+    const promise = runRollup(command);
+    if (command.forceExit) {
+        promise.then(() => process$1.exit());
+    }
+}
+
+exports.getConfigPath = getConfigPath;
+exports.loadConfigFromCommand = loadConfigFromCommand;
+exports.prettyMilliseconds = prettyMilliseconds;
+exports.printTimings = printTimings;
+//# sourceMappingURL=rollup.map
diff --git a/node_modules/.bin/semver b/node_modules/.bin/semver
new file mode 100644
index 0000000000000000000000000000000000000000..9ae8aadb95fbd9a67a0e8da3a1c8eacc86e86201
--- /dev/null
+++ b/node_modules/.bin/semver
@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+'use strict'
+
+const argv = process.argv.slice(2)
+
+let versions = []
+
+const range = []
+
+let inc = null
+
+const version = require('../package.json').version
+
+let loose = false
+
+let includePrerelease = false
+
+let coerce = false
+
+let rtl = false
+
+let identifier
+
+let identifierBase
+
+const semver = require('../')
+const parseOptions = require('../internal/parse-options')
+
+let reverse = false
+
+let options = {}
+
+const main = () => {
+  if (!argv.length) {
+    return help()
+  }
+  while (argv.length) {
+    let a = argv.shift()
+    const indexOfEqualSign = a.indexOf('=')
+    if (indexOfEqualSign !== -1) {
+      const value = a.slice(indexOfEqualSign + 1)
+      a = a.slice(0, indexOfEqualSign)
+      argv.unshift(value)
+    }
+
+    switch (a) {
+      case '-rv': case '-rev': case '--rev': case '--reverse':
+        reverse = true
+        break
+      case '-l': case '--loose':
+        loose = true
+        break
+      case '-p': case '--include-prerelease':
+        includePrerelease = true
+        break
+      case '-v': case '--version':
+        versions.push(argv.shift())
+        break
+      case '-i': case '--inc': case '--increment':
+        if (semver.RELEASE_TYPES.includes(argv[0]) || (argv[0] === 'release')) {
+          inc = { value: argv.shift(), maybeErrantValue: null, option: a }
+        } else {
+          inc = { value: 'patch', maybeErrantValue: argv[0], option: a }
+        }
+        break
+      case '--preid':
+        identifier = argv.shift()
+        break
+      case '-r': case '--range':
+        range.push(argv.shift())
+        break
+      case '-n':
+        identifierBase = argv.shift()
+        if (identifierBase === 'false') {
+          identifierBase = false
+        }
+        break
+      case '-c': case '--coerce':
+        coerce = true
+        break
+      case '--rtl':
+        rtl = true
+        break
+      case '--ltr':
+        rtl = false
+        break
+      case '-h': case '--help': case '-?':
+        return help()
+      default:
+        versions.push(a)
+        break
+    }
+  }
+
+  options = parseOptions({ loose, includePrerelease, rtl })
+
+  if (
+    inc &&
+    versions.includes(inc.maybeErrantValue) &&
+    !semver.valid(inc.maybeErrantValue, options)
+  ) {
+    console.warn(`Invalid value for ${inc.option}; defaulting to 'patch'. This may become a failure in future major versions.`)
+  }
+
+  versions = versions.map((v) => {
+    return coerce ? (semver.coerce(v, options) || { version: v }).version : v
+  }).filter((v) => {
+    return semver.valid(v, options)
+  })
+  if (!versions.length) {
+    return fail()
+  }
+  if (inc && (versions.length !== 1 || range.length)) {
+    return failInc()
+  }
+
+  for (let i = 0, l = range.length; i < l; i++) {
+    versions = versions.filter((v) => {
+      return semver.satisfies(v, range[i], options)
+    })
+    if (!versions.length) {
+      return fail()
+    }
+  }
+  versions
+    .sort((a, b) => semver[reverse ? 'rcompare' : 'compare'](a, b, options))
+    .map(v => semver.clean(v, options))
+    .map(v => inc ? semver.inc(v, inc.value, options, identifier, identifierBase) : v)
+    .forEach(v => console.log(v))
+}
+
+const failInc = () => {
+  console.error('--inc can only be used on a single version with no range')
+  fail()
+}
+
+const fail = () => process.exit(1)
+
+const help = () => console.log(
+`SemVer ${version}
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, prerelease, or release.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
+-n <base>
+        Base number to be used for the prerelease identifier.
+        Can be either 0 or 1, or false to omit the number altogether.
+        Defaults to 0.
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.`)
+
+main()
diff --git a/node_modules/.bin/specificity b/node_modules/.bin/specificity
new file mode 100644
index 0000000000000000000000000000000000000000..9d26b686fb92b85c03cb0cfcc3eeec0c09e9015b
--- /dev/null
+++ b/node_modules/.bin/specificity
@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import Specificity from '../dist/index.js';
+
+if (!process.argv[2]) {
+    console.error('❌ Missing selector argument');
+    process.exit(1);
+}
+
+try {
+    const specificities = Specificity.calculate(process.argv[2]);
+    console.log(specificities.map((specificity) => `${specificity}`).join('\n'));
+} catch (e) {
+    console.error(`❌ ${e.message}`);
+}
diff --git a/node_modules/.bin/terser b/node_modules/.bin/terser
new file mode 100644
index 0000000000000000000000000000000000000000..b0cdc7c570e3149b05660695f17f7427863dde96
--- /dev/null
+++ b/node_modules/.bin/terser
@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+"use strict";
+
+require("../tools/exit.cjs");
+
+try {
+    require("source-map-support").install();
+} catch (err) {}
+
+const fs = require("fs");
+const path = require("path");
+const program = require("commander");
+
+const packageJson = require("../package.json");
+const { _run_cli: run_cli } = require("..");
+
+run_cli({ program, packageJson, fs, path }).catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});
diff --git a/node_modules/.bin/tldts b/node_modules/.bin/tldts
new file mode 100644
index 0000000000000000000000000000000000000000..9d7e9d4cd901a523812c7cd39fedb035ca1e4415
--- /dev/null
+++ b/node_modules/.bin/tldts
@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const { parse } = require('..');
+const readline = require('readline');
+
+if (process.argv.length > 2) {
+  // URL(s) was specified in the command arguments
+  console.log(
+    JSON.stringify(parse(process.argv[process.argv.length - 1]), null, 2),
+  );
+} else {
+  // No arguments were specified, read URLs from each line of STDIN
+  const rlInterface = readline.createInterface({
+    input: process.stdin,
+  });
+  rlInterface.on('line', function (line) {
+    console.log(JSON.stringify(parse(line), null, 2));
+  });
+}
diff --git a/node_modules/.bin/tree-kill b/node_modules/.bin/tree-kill
new file mode 100644
index 0000000000000000000000000000000000000000..1acb8158959fb9634e6ac5c965370a101f337bda
--- /dev/null
+++ b/node_modules/.bin/tree-kill
@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+kill = require('.')
+try {
+  kill(process.argv[2], process.argv[3], function(err){
+    if (err) {
+      console.log(err.message)
+      process.exit(1)
+    }
+  })
+}
+catch (err) {
+  console.log(err.message)
+  process.exit(1)
+}
diff --git a/node_modules/.bin/tsc b/node_modules/.bin/tsc
new file mode 100644
index 0000000000000000000000000000000000000000..19c62bf7a0004aab7bd188aae51ff2564fdfc18d
--- /dev/null
+++ b/node_modules/.bin/tsc
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/tsc.js')
diff --git a/node_modules/.bin/tsserver b/node_modules/.bin/tsserver
new file mode 100644
index 0000000000000000000000000000000000000000..7143b6a73ab8a901ccf93752cc36f8e9f8191d93
--- /dev/null
+++ b/node_modules/.bin/tsserver
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../lib/tsserver.js')
diff --git a/node_modules/.bin/tsx b/node_modules/.bin/tsx
new file mode 100644
index 0000000000000000000000000000000000000000..c3e3c1931d79cb2268ae9b8f4509fcf18110aea5
--- /dev/null
+++ b/node_modules/.bin/tsx
@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+var Rn=Object.defineProperty;var a=(t,e)=>Rn(t,"name",{value:e,configurable:!0});import{constants as lt}from"node:os";import bn from"tty";import{transformSync as vn}from"esbuild";import{v as Sn}from"./package-Bj47PlGH.mjs";import{r as Ie,g as Bn,i as $n}from"./get-pipe-path-_tAJyU_v.mjs";import{pathToFileURL as Tn,fileURLToPath as xn}from"node:url";import On from"child_process";import z from"path";import De from"fs";import{i as mu,a as Nn,t as Hn}from"./node-features-B9BBLzwu.mjs";import Pn from"node:path";import Ln from"events";import ge from"util";import In from"stream";import _u from"os";import{g as kn,l as Mn,e as Gn,f as Wn,y as me}from"./index-gbaejti9.mjs";import jn from"node:net";import ct from"node:fs";import{t as Un}from"./temporary-directory-BDDVQOvU.mjs";import"module";const Kn="known-flag",Vn="unknown-flag",zn="argument",{stringify:_e}=JSON,Yn=/\B([A-Z])/g,qn=a(t=>t.replace(Yn,"-$1").toLowerCase(),"v$1"),{hasOwnProperty:Xn}=Object.prototype,Ae=a((t,e)=>Xn.call(t,e),"w$2"),Qn=a(t=>Array.isArray(t),"L$2"),Au=a(t=>typeof t=="function"?[t,!1]:Qn(t)?[t[0],!0]:Au(t.type),"b$2"),Zn=a((t,e)=>t===Boolean?e!=="false":e,"d$2"),Jn=a((t,e)=>typeof e=="boolean"?e:t===Number&&e===""?Number.NaN:t(e),"m$1"),er=/[\s.:=]/,tr=a(t=>{const e=`Flag name ${_e(t)}`;if(t.length===0)throw new Error(`${e} cannot be empty`);if(t.length===1)throw new Error(`${e} must be longer than a character`);const u=t.match(er);if(u)throw new Error(`${e} cannot contain ${_e(u?.[0])}`)},"B"),ur=a(t=>{const e={},u=a((s,n)=>{if(Ae(e,s))throw new Error(`Duplicate flags named ${_e(s)}`);e[s]=n},"r");for(const s in t){if(!Ae(t,s))continue;tr(s);const n=t[s],r=[[],...Au(n),n];u(s,r);const i=qn(s);if(s!==i&&u(i,r),"alias"in n&&typeof n.alias=="string"){const{alias:D}=n,o=`Flag alias ${_e(D)} for flag ${_e(s)}`;if(D.length===0)throw new Error(`${o} cannot be empty`);if(D.length>1)throw new Error(`${o} must be a single character`);u(D,r)}}return e},"K$1"),sr=a((t,e)=>{const u={};for(const s in t){if(!Ae(t,s))continue;const[n,,r,i]=e[s];if(n.length===0&&"default"in i){let{default:D}=i;typeof D=="function"&&(D=D()),u[s]=D}else u[s]=r?n:n.pop()}return u},"_$2"),ke="--",nr=/[.:=]/,rr=/^-{1,2}\w/,ir=a(t=>{if(!rr.test(t))return;const e=!t.startsWith(ke);let u=t.slice(e?1:2),s;const n=u.match(nr);if(n){const{index:r}=n;s=u.slice(r+1),u=u.slice(0,r)}return[u,s,e]},"N"),Dr=a((t,{onFlag:e,onArgument:u})=>{let s;const n=a((r,i)=>{if(typeof s!="function")return!0;s(r,i),s=void 0},"o");for(let r=0;r<t.length;r+=1){const i=t[r];if(i===ke){n();const o=t.slice(r+1);u?.(o,[r],!0);break}const D=ir(i);if(D){if(n(),!e)continue;const[o,c,f]=D;if(f)for(let h=0;h<o.length;h+=1){n();const l=h===o.length-1;s=e(o[h],l?c:void 0,[r,h+1,l])}else s=e(o,c,[r])}else n(i,[r])&&u?.([i],[r])}n()},"$$1"),or=a((t,e)=>{for(const[u,s,n]of e.reverse()){if(s){const r=t[u];let i=r.slice(0,s);if(n||(i+=r.slice(s+1)),i!=="-"){t[u]=i;continue}}t.splice(u,1)}},"E"),yu=a((t,e=process.argv.slice(2),{ignore:u}={})=>{const s=[],n=ur(t),r={},i=[];return i[ke]=[],Dr(e,{onFlag(D,o,c){const f=Ae(n,D);if(!u?.(f?Kn:Vn,D,o)){if(f){const[h,l]=n[D],p=Zn(l,o),C=a((g,y)=>{s.push(c),y&&s.push(y),h.push(Jn(l,g||""))},"p");return p===void 0?C:C(p)}Ae(r,D)||(r[D]=[]),r[D].push(o===void 0?!0:o),s.push(c)}},onArgument(D,o,c){u?.(zn,e[o[0]])||(i.push(...D),c?(i[ke]=D,e.splice(o[0])):s.push(o))}}),or(e,s),{flags:sr(t,n),unknownFlags:r,_:i}},"U$2");var ar=Object.create,Me=Object.defineProperty,lr=Object.defineProperties,cr=Object.getOwnPropertyDescriptor,fr=Object.getOwnPropertyDescriptors,hr=Object.getOwnPropertyNames,wu=Object.getOwnPropertySymbols,dr=Object.getPrototypeOf,Ru=Object.prototype.hasOwnProperty,Er=Object.prototype.propertyIsEnumerable,bu=a((t,e,u)=>e in t?Me(t,e,{enumerable:!0,configurable:!0,writable:!0,value:u}):t[e]=u,"W$1"),Ge=a((t,e)=>{for(var u in e||(e={}))Ru.call(e,u)&&bu(t,u,e[u]);if(wu)for(var u of wu(e))Er.call(e,u)&&bu(t,u,e[u]);return t},"p"),ft=a((t,e)=>lr(t,fr(e)),"c"),pr=a(t=>Me(t,"__esModule",{value:!0}),"nD"),Cr=a((t,e)=>()=>(t&&(e=t(t=0)),e),"rD"),Fr=a((t,e)=>()=>(e||t((e={exports:{}}).exports,e),e.exports),"iD"),gr=a((t,e,u,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of hr(e))!Ru.call(t,n)&&n!=="default"&&Me(t,n,{get:a(()=>e[n],"get"),enumerable:!(s=cr(e,n))||s.enumerable});return t},"oD"),mr=a((t,e)=>gr(pr(Me(t!=null?ar(dr(t)):{},"default",{value:t,enumerable:!0})),t),"BD"),K=Cr(()=>{}),_r=Fr((t,e)=>{K(),e.exports=function(){return/\uD83C\uDFF4\uDB40\uDC67\uDB40\uDC62(?:\uDB40\uDC77\uDB40\uDC6C\uDB40\uDC73|\uDB40\uDC73\uDB40\uDC63\uDB40\uDC74|\uDB40\uDC65\uDB40\uDC6E\uDB40\uDC67)\uDB40\uDC7F|(?:\uD83E\uDDD1\uD83C\uDFFF\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFF\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFE])|(?:\uD83E\uDDD1\uD83C\uDFFE\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFE\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFD\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFD\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFC\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFC\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|(?:\uD83E\uDDD1\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83E\uDDD1|\uD83D\uDC69\uD83C\uDFFB\u200D\uD83E\uDD1D\u200D(?:\uD83D[\uDC68\uDC69]))(?:\uD83C[\uDFFC-\uDFFF])|\uD83D\uDC68(?:\uD83C\uDFFB(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFC-\uDFFF])|[\u2695\u2696\u2708]\uFE0F|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))?|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFF]))|\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D)?\uD83D\uDC68|(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFE])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB-\uDFFD\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFC\uDFFE\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83E\uDD1D\u200D\uD83D\uDC68(?:\uD83C[\uDFFB\uDFFD-\uDFFF])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])\uFE0F|\u200D(?:(?:\uD83D[\uDC68\uDC69])\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D[\uDC66\uDC67])|\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC)?|(?:\uD83D\uDC69(?:\uD83C\uDFFB\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|(?:\uD83C[\uDFFC-\uDFFF])\u200D\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69]))|\uD83E\uDDD1(?:\uD83C[\uDFFB-\uDFFF])\u200D\uD83E\uDD1D\u200D\uD83E\uDDD1)(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67]))|\uD83D\uDC69(?:\u200D(?:\u2764\uFE0F\u200D(?:\uD83D\uDC8B\u200D(?:\uD83D[\uDC68\uDC69])|\uD83D[\uDC68\uDC69])|\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83E\uDDD1(?:\u200D(?:\uD83E\uDD1D\u200D\uD83E\uDDD1|\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFF\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFE\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFD\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFC\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD])|\uD83C\uDFFB\u200D(?:\uD83C[\uDF3E\uDF73\uDF7C\uDF84\uDF93\uDFA4\uDFA8\uDFEB\uDFED]|\uD83D[\uDCBB\uDCBC\uDD27\uDD2C\uDE80\uDE92]|\uD83E[\uDDAF-\uDDB3\uDDBC\uDDBD]))|\uD83D\uDC69\u200D\uD83D\uDC66\u200D\uD83D\uDC66|\uD83D\uDC69\u200D\uD83D\uDC69\u200D(?:\uD83D[\uDC66\uDC67])|\uD83D\uDC69\u200D\uD83D\uDC67\u200D(?:\uD83D[\uDC66\uDC67])|(?:\uD83D\uDC41\uFE0F\u200D\uD83D\uDDE8|\uD83E\uDDD1(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDC69(?:\uD83C\uDFFF\u200D[\u2695\u2696\u2708]|\uD83C\uDFFE\u200D[\u2695\u2696\u2708]|\uD83C\uDFFD\u200D[\u2695\u2696\u2708]|\uD83C\uDFFC\u200D[\u2695\u2696\u2708]|\uD83C\uDFFB\u200D[\u2695\u2696\u2708]|\u200D[\u2695\u2696\u2708])|\uD83D\uDE36\u200D\uD83C\uDF2B|\uD83C\uDFF3\uFE0F\u200D\u26A7|\uD83D\uDC3B\u200D\u2744|(?:(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF])\u200D[\u2640\u2642]|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])\u200D[\u2640\u2642]|\uD83C\uDFF4\u200D\u2620|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])\u200D[\u2640\u2642]|[\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u2328\u23CF\u23ED-\u23EF\u23F1\u23F2\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB\u25FC\u2600-\u2604\u260E\u2611\u2618\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u2692\u2694-\u2697\u2699\u269B\u269C\u26A0\u26A7\u26B0\u26B1\u26C8\u26CF\u26D1\u26D3\u26E9\u26F0\u26F1\u26F4\u26F7\u26F8\u2702\u2708\u2709\u270F\u2712\u2714\u2716\u271D\u2721\u2733\u2734\u2744\u2747\u2763\u27A1\u2934\u2935\u2B05-\u2B07\u3030\u303D\u3297\u3299]|\uD83C[\uDD70\uDD71\uDD7E\uDD7F\uDE02\uDE37\uDF21\uDF24-\uDF2C\uDF36\uDF7D\uDF96\uDF97\uDF99-\uDF9B\uDF9E\uDF9F\uDFCD\uDFCE\uDFD4-\uDFDF\uDFF5\uDFF7]|\uD83D[\uDC3F\uDCFD\uDD49\uDD4A\uDD6F\uDD70\uDD73\uDD76-\uDD79\uDD87\uDD8A-\uDD8D\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA\uDECB\uDECD-\uDECF\uDEE0-\uDEE5\uDEE9\uDEF0\uDEF3])\uFE0F|\uD83C\uDFF3\uFE0F\u200D\uD83C\uDF08|\uD83D\uDC69\u200D\uD83D\uDC67|\uD83D\uDC69\u200D\uD83D\uDC66|\uD83D\uDE35\u200D\uD83D\uDCAB|\uD83D\uDE2E\u200D\uD83D\uDCA8|\uD83D\uDC15\u200D\uD83E\uDDBA|\uD83E\uDDD1(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83D\uDC69(?:\uD83C\uDFFF|\uD83C\uDFFE|\uD83C\uDFFD|\uD83C\uDFFC|\uD83C\uDFFB)?|\uD83C\uDDFD\uD83C\uDDF0|\uD83C\uDDF6\uD83C\uDDE6|\uD83C\uDDF4\uD83C\uDDF2|\uD83D\uDC08\u200D\u2B1B|\u2764\uFE0F\u200D(?:\uD83D\uDD25|\uD83E\uDE79)|\uD83D\uDC41\uFE0F|\uD83C\uDFF3\uFE0F|\uD83C\uDDFF(?:\uD83C[\uDDE6\uDDF2\uDDFC])|\uD83C\uDDFE(?:\uD83C[\uDDEA\uDDF9])|\uD83C\uDDFC(?:\uD83C[\uDDEB\uDDF8])|\uD83C\uDDFB(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDEE\uDDF3\uDDFA])|\uD83C\uDDFA(?:\uD83C[\uDDE6\uDDEC\uDDF2\uDDF3\uDDF8\uDDFE\uDDFF])|\uD83C\uDDF9(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDED\uDDEF-\uDDF4\uDDF7\uDDF9\uDDFB\uDDFC\uDDFF])|\uD83C\uDDF8(?:\uD83C[\uDDE6-\uDDEA\uDDEC-\uDDF4\uDDF7-\uDDF9\uDDFB\uDDFD-\uDDFF])|\uD83C\uDDF7(?:\uD83C[\uDDEA\uDDF4\uDDF8\uDDFA\uDDFC])|\uD83C\uDDF5(?:\uD83C[\uDDE6\uDDEA-\uDDED\uDDF0-\uDDF3\uDDF7-\uDDF9\uDDFC\uDDFE])|\uD83C\uDDF3(?:\uD83C[\uDDE6\uDDE8\uDDEA-\uDDEC\uDDEE\uDDF1\uDDF4\uDDF5\uDDF7\uDDFA\uDDFF])|\uD83C\uDDF2(?:\uD83C[\uDDE6\uDDE8-\uDDED\uDDF0-\uDDFF])|\uD83C\uDDF1(?:\uD83C[\uDDE6-\uDDE8\uDDEE\uDDF0\uDDF7-\uDDFB\uDDFE])|\uD83C\uDDF0(?:\uD83C[\uDDEA\uDDEC-\uDDEE\uDDF2\uDDF3\uDDF5\uDDF7\uDDFC\uDDFE\uDDFF])|\uD83C\uDDEF(?:\uD83C[\uDDEA\uDDF2\uDDF4\uDDF5])|\uD83C\uDDEE(?:\uD83C[\uDDE8-\uDDEA\uDDF1-\uDDF4\uDDF6-\uDDF9])|\uD83C\uDDED(?:\uD83C[\uDDF0\uDDF2\uDDF3\uDDF7\uDDF9\uDDFA])|\uD83C\uDDEC(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEE\uDDF1-\uDDF3\uDDF5-\uDDFA\uDDFC\uDDFE])|\uD83C\uDDEB(?:\uD83C[\uDDEE-\uDDF0\uDDF2\uDDF4\uDDF7])|\uD83C\uDDEA(?:\uD83C[\uDDE6\uDDE8\uDDEA\uDDEC\uDDED\uDDF7-\uDDFA])|\uD83C\uDDE9(?:\uD83C[\uDDEA\uDDEC\uDDEF\uDDF0\uDDF2\uDDF4\uDDFF])|\uD83C\uDDE8(?:\uD83C[\uDDE6\uDDE8\uDDE9\uDDEB-\uDDEE\uDDF0-\uDDF5\uDDF7\uDDFA-\uDDFF])|\uD83C\uDDE7(?:\uD83C[\uDDE6\uDDE7\uDDE9-\uDDEF\uDDF1-\uDDF4\uDDF6-\uDDF9\uDDFB\uDDFC\uDDFE\uDDFF])|\uD83C\uDDE6(?:\uD83C[\uDDE8-\uDDEC\uDDEE\uDDF1\uDDF2\uDDF4\uDDF6-\uDDFA\uDDFC\uDDFD\uDDFF])|[#\*0-9]\uFE0F\u20E3|\u2764\uFE0F|(?:\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD])(?:\uD83C[\uDFFB-\uDFFF])|(?:\u26F9|\uD83C[\uDFCB\uDFCC]|\uD83D\uDD75)(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|\uD83C\uDFF4|(?:[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5])(?:\uD83C[\uDFFB-\uDFFF])|(?:[\u261D\u270C\u270D]|\uD83D[\uDD74\uDD90])(?:\uFE0F|\uD83C[\uDFFB-\uDFFF])|[\u270A\u270B]|\uD83C[\uDF85\uDFC2\uDFC7]|\uD83D[\uDC08\uDC15\uDC3B\uDC42\uDC43\uDC46-\uDC50\uDC66\uDC67\uDC6B-\uDC6D\uDC72\uDC74-\uDC76\uDC78\uDC7C\uDC83\uDC85\uDC8F\uDC91\uDCAA\uDD7A\uDD95\uDD96\uDE2E\uDE35\uDE36\uDE4C\uDE4F\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1C\uDD1E\uDD1F\uDD30-\uDD34\uDD36\uDD77\uDDB5\uDDB6\uDDBB\uDDD2\uDDD3\uDDD5]|\uD83C[\uDFC3\uDFC4\uDFCA]|\uD83D[\uDC6E\uDC70\uDC71\uDC73\uDC77\uDC81\uDC82\uDC86\uDC87\uDE45-\uDE47\uDE4B\uDE4D\uDE4E\uDEA3\uDEB4-\uDEB6]|\uD83E[\uDD26\uDD35\uDD37-\uDD39\uDD3D\uDD3E\uDDB8\uDDB9\uDDCD-\uDDCF\uDDD4\uDDD6-\uDDDD]|\uD83D\uDC6F|\uD83E[\uDD3C\uDDDE\uDDDF]|[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF84\uDF86-\uDF93\uDFA0-\uDFC1\uDFC5\uDFC6\uDFC8\uDFC9\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC07\uDC09-\uDC14\uDC16-\uDC3A\uDC3C-\uDC3E\uDC40\uDC44\uDC45\uDC51-\uDC65\uDC6A\uDC79-\uDC7B\uDC7D-\uDC80\uDC84\uDC88-\uDC8E\uDC90\uDC92-\uDCA9\uDCAB-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDDA4\uDDFB-\uDE2D\uDE2F-\uDE34\uDE37-\uDE44\uDE48-\uDE4A\uDE80-\uDEA2\uDEA4-\uDEB3\uDEB7-\uDEBF\uDEC1-\uDEC5\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0D\uDD0E\uDD10-\uDD17\uDD1D\uDD20-\uDD25\uDD27-\uDD2F\uDD3A\uDD3F-\uDD45\uDD47-\uDD76\uDD78\uDD7A-\uDDB4\uDDB7\uDDBA\uDDBC-\uDDCB\uDDD0\uDDE0-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6]|(?:[\u231A\u231B\u23E9-\u23EC\u23F0\u23F3\u25FD\u25FE\u2614\u2615\u2648-\u2653\u267F\u2693\u26A1\u26AA\u26AB\u26BD\u26BE\u26C4\u26C5\u26CE\u26D4\u26EA\u26F2\u26F3\u26F5\u26FA\u26FD\u2705\u270A\u270B\u2728\u274C\u274E\u2753-\u2755\u2757\u2795-\u2797\u27B0\u27BF\u2B1B\u2B1C\u2B50\u2B55]|\uD83C[\uDC04\uDCCF\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE1A\uDE2F\uDE32-\uDE36\uDE38-\uDE3A\uDE50\uDE51\uDF00-\uDF20\uDF2D-\uDF35\uDF37-\uDF7C\uDF7E-\uDF93\uDFA0-\uDFCA\uDFCF-\uDFD3\uDFE0-\uDFF0\uDFF4\uDFF8-\uDFFF]|\uD83D[\uDC00-\uDC3E\uDC40\uDC42-\uDCFC\uDCFF-\uDD3D\uDD4B-\uDD4E\uDD50-\uDD67\uDD7A\uDD95\uDD96\uDDA4\uDDFB-\uDE4F\uDE80-\uDEC5\uDECC\uDED0-\uDED2\uDED5-\uDED7\uDEEB\uDEEC\uDEF4-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])|(?:[#\*0-9\xA9\xAE\u203C\u2049\u2122\u2139\u2194-\u2199\u21A9\u21AA\u231A\u231B\u2328\u23CF\u23E9-\u23F3\u23F8-\u23FA\u24C2\u25AA\u25AB\u25B6\u25C0\u25FB-\u25FE\u2600-\u2604\u260E\u2611\u2614\u2615\u2618\u261D\u2620\u2622\u2623\u2626\u262A\u262E\u262F\u2638-\u263A\u2640\u2642\u2648-\u2653\u265F\u2660\u2663\u2665\u2666\u2668\u267B\u267E\u267F\u2692-\u2697\u2699\u269B\u269C\u26A0\u26A1\u26A7\u26AA\u26AB\u26B0\u26B1\u26BD\u26BE\u26C4\u26C5\u26C8\u26CE\u26CF\u26D1\u26D3\u26D4\u26E9\u26EA\u26F0-\u26F5\u26F7-\u26FA\u26FD\u2702\u2705\u2708-\u270D\u270F\u2712\u2714\u2716\u271D\u2721\u2728\u2733\u2734\u2744\u2747\u274C\u274E\u2753-\u2755\u2757\u2763\u2764\u2795-\u2797\u27A1\u27B0\u27BF\u2934\u2935\u2B05-\u2B07\u2B1B\u2B1C\u2B50\u2B55\u3030\u303D\u3297\u3299]|\uD83C[\uDC04\uDCCF\uDD70\uDD71\uDD7E\uDD7F\uDD8E\uDD91-\uDD9A\uDDE6-\uDDFF\uDE01\uDE02\uDE1A\uDE2F\uDE32-\uDE3A\uDE50\uDE51\uDF00-\uDF21\uDF24-\uDF93\uDF96\uDF97\uDF99-\uDF9B\uDF9E-\uDFF0\uDFF3-\uDFF5\uDFF7-\uDFFF]|\uD83D[\uDC00-\uDCFD\uDCFF-\uDD3D\uDD49-\uDD4E\uDD50-\uDD67\uDD6F\uDD70\uDD73-\uDD7A\uDD87\uDD8A-\uDD8D\uDD90\uDD95\uDD96\uDDA4\uDDA5\uDDA8\uDDB1\uDDB2\uDDBC\uDDC2-\uDDC4\uDDD1-\uDDD3\uDDDC-\uDDDE\uDDE1\uDDE3\uDDE8\uDDEF\uDDF3\uDDFA-\uDE4F\uDE80-\uDEC5\uDECB-\uDED2\uDED5-\uDED7\uDEE0-\uDEE5\uDEE9\uDEEB\uDEEC\uDEF0\uDEF3-\uDEFC\uDFE0-\uDFEB]|\uD83E[\uDD0C-\uDD3A\uDD3C-\uDD45\uDD47-\uDD78\uDD7A-\uDDCB\uDDCD-\uDDFF\uDE70-\uDE74\uDE78-\uDE7A\uDE80-\uDE86\uDE90-\uDEA8\uDEB0-\uDEB6\uDEC0-\uDEC2\uDED0-\uDED6])\uFE0F|(?:[\u261D\u26F9\u270A-\u270D]|\uD83C[\uDF85\uDFC2-\uDFC4\uDFC7\uDFCA-\uDFCC]|\uD83D[\uDC42\uDC43\uDC46-\uDC50\uDC66-\uDC78\uDC7C\uDC81-\uDC83\uDC85-\uDC87\uDC8F\uDC91\uDCAA\uDD74\uDD75\uDD7A\uDD90\uDD95\uDD96\uDE45-\uDE47\uDE4B-\uDE4F\uDEA3\uDEB4-\uDEB6\uDEC0\uDECC]|\uD83E[\uDD0C\uDD0F\uDD18-\uDD1F\uDD26\uDD30-\uDD39\uDD3C-\uDD3E\uDD77\uDDB5\uDDB6\uDDB8\uDDB9\uDDBB\uDDCD-\uDDCF\uDDD1-\uDDDD])/g}});K(),K(),K();var Ar=a(t=>{var e,u,s;let n=(e=process.stdout.columns)!=null?e:Number.POSITIVE_INFINITY;return typeof t=="function"&&(t=t(n)),t||(t={}),Array.isArray(t)?{columns:t,stdoutColumns:n}:{columns:(u=t.columns)!=null?u:[],stdoutColumns:(s=t.stdoutColumns)!=null?s:n}},"v");K(),K(),K(),K(),K();function yr({onlyFirst:t=!1}={}){let e=["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)","(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"].join("|");return new RegExp(e,t?void 0:"g")}a(yr,"w$1");function vu(t){if(typeof t!="string")throw new TypeError(`Expected a \`string\`, got \`${typeof t}\``);return t.replace(yr(),"")}a(vu,"d$1"),K();function wr(t){return Number.isInteger(t)?t>=4352&&(t<=4447||t===9001||t===9002||11904<=t&&t<=12871&&t!==12351||12880<=t&&t<=19903||19968<=t&&t<=42182||43360<=t&&t<=43388||44032<=t&&t<=55203||63744<=t&&t<=64255||65040<=t&&t<=65049||65072<=t&&t<=65131||65281<=t&&t<=65376||65504<=t&&t<=65510||110592<=t&&t<=110593||127488<=t&&t<=127569||131072<=t&&t<=262141):!1}a(wr,"y$1");var Rr=mr(_r());function oe(t){if(typeof t!="string"||t.length===0||(t=vu(t),t.length===0))return 0;t=t.replace((0,Rr.default)(),"  ");let e=0;for(let u=0;u<t.length;u++){let s=t.codePointAt(u);s<=31||s>=127&&s<=159||s>=768&&s<=879||(s>65535&&u++,e+=wr(s)?2:1)}return e}a(oe,"g");var Su=a(t=>Math.max(...t.split(`
+`).map(oe)),"b$1"),br=a(t=>{let e=[];for(let u of t){let{length:s}=u,n=s-e.length;for(let r=0;r<n;r+=1)e.push(0);for(let r=0;r<s;r+=1){let i=Su(u[r]);i>e[r]&&(e[r]=i)}}return e},"k$1");K();var Bu=/^\d+%$/,$u={width:"auto",align:"left",contentWidth:0,paddingLeft:0,paddingRight:0,paddingTop:0,paddingBottom:0,horizontalPadding:0,paddingLeftString:"",paddingRightString:""},vr=a((t,e)=>{var u;let s=[];for(let n=0;n<t.length;n+=1){let r=(u=e[n])!=null?u:"auto";if(typeof r=="number"||r==="auto"||r==="content-width"||typeof r=="string"&&Bu.test(r)){s.push(ft(Ge({},$u),{width:r,contentWidth:t[n]}));continue}if(r&&typeof r=="object"){let i=ft(Ge(Ge({},$u),r),{contentWidth:t[n]});i.horizontalPadding=i.paddingLeft+i.paddingRight,s.push(i);continue}throw new Error(`Invalid column width: ${JSON.stringify(r)}`)}return s},"sD");function Sr(t,e){for(let u of t){let{width:s}=u;if(s==="content-width"&&(u.width=u.contentWidth),s==="auto"){let o=Math.min(20,u.contentWidth);u.width=o,u.autoOverflow=u.contentWidth-o}if(typeof s=="string"&&Bu.test(s)){let o=Number.parseFloat(s.slice(0,-1))/100;u.width=Math.floor(e*o)-(u.paddingLeft+u.paddingRight)}let{horizontalPadding:n}=u,r=1,i=r+n;if(i>=e){let o=i-e,c=Math.ceil(u.paddingLeft/n*o),f=o-c;u.paddingLeft-=c,u.paddingRight-=f,u.horizontalPadding=u.paddingLeft+u.paddingRight}u.paddingLeftString=u.paddingLeft?" ".repeat(u.paddingLeft):"",u.paddingRightString=u.paddingRight?" ".repeat(u.paddingRight):"";let D=e-u.horizontalPadding;u.width=Math.max(Math.min(u.width,D),r)}}a(Sr,"aD");var Tu=a(()=>Object.assign([],{columns:0}),"G$1");function Br(t,e){let u=[Tu()],[s]=u;for(let n of t){let r=n.width+n.horizontalPadding;s.columns+r>e&&(s=Tu(),u.push(s)),s.push(n),s.columns+=r}for(let n of u){let r=n.reduce((l,p)=>l+p.width+p.horizontalPadding,0),i=e-r;if(i===0)continue;let D=n.filter(l=>"autoOverflow"in l),o=D.filter(l=>l.autoOverflow>0),c=o.reduce((l,p)=>l+p.autoOverflow,0),f=Math.min(c,i);for(let l of o){let p=Math.floor(l.autoOverflow/c*f);l.width+=p,i-=p}let h=Math.floor(i/D.length);for(let l=0;l<D.length;l+=1){let p=D[l];l===D.length-1?p.width+=i:p.width+=h,i-=h}}return u}a(Br,"lD");function $r(t,e,u){let s=vr(u,e);return Sr(s,t),Br(s,t)}a($r,"Z$1"),K(),K(),K();var ht=10,xu=a((t=0)=>e=>`\x1B[${e+t}m`,"U$1"),Ou=a((t=0)=>e=>`\x1B[${38+t};5;${e}m`,"V$1"),Nu=a((t=0)=>(e,u,s)=>`\x1B[${38+t};2;${e};${u};${s}m`,"Y");function Tr(){let t=new Map,e={modifier:{reset:[0,0],bold:[1,22],dim:[2,22],italic:[3,23],underline:[4,24],overline:[53,55],inverse:[7,27],hidden:[8,28],strikethrough:[9,29]},color:{black:[30,39],red:[31,39],green:[32,39],yellow:[33,39],blue:[34,39],magenta:[35,39],cyan:[36,39],white:[37,39],blackBright:[90,39],redBright:[91,39],greenBright:[92,39],yellowBright:[93,39],blueBright:[94,39],magentaBright:[95,39],cyanBright:[96,39],whiteBright:[97,39]},bgColor:{bgBlack:[40,49],bgRed:[41,49],bgGreen:[42,49],bgYellow:[43,49],bgBlue:[44,49],bgMagenta:[45,49],bgCyan:[46,49],bgWhite:[47,49],bgBlackBright:[100,49],bgRedBright:[101,49],bgGreenBright:[102,49],bgYellowBright:[103,49],bgBlueBright:[104,49],bgMagentaBright:[105,49],bgCyanBright:[106,49],bgWhiteBright:[107,49]}};e.color.gray=e.color.blackBright,e.bgColor.bgGray=e.bgColor.bgBlackBright,e.color.grey=e.color.blackBright,e.bgColor.bgGrey=e.bgColor.bgBlackBright;for(let[u,s]of Object.entries(e)){for(let[n,r]of Object.entries(s))e[n]={open:`\x1B[${r[0]}m`,close:`\x1B[${r[1]}m`},s[n]=e[n],t.set(r[0],r[1]);Object.defineProperty(e,u,{value:s,enumerable:!1})}return Object.defineProperty(e,"codes",{value:t,enumerable:!1}),e.color.close="\x1B[39m",e.bgColor.close="\x1B[49m",e.color.ansi=xu(),e.color.ansi256=Ou(),e.color.ansi16m=Nu(),e.bgColor.ansi=xu(ht),e.bgColor.ansi256=Ou(ht),e.bgColor.ansi16m=Nu(ht),Object.defineProperties(e,{rgbToAnsi256:{value:a((u,s,n)=>u===s&&s===n?u<8?16:u>248?231:Math.round((u-8)/247*24)+232:16+36*Math.round(u/255*5)+6*Math.round(s/255*5)+Math.round(n/255*5),"value"),enumerable:!1},hexToRgb:{value:a(u=>{let s=/(?<colorString>[a-f\d]{6}|[a-f\d]{3})/i.exec(u.toString(16));if(!s)return[0,0,0];let{colorString:n}=s.groups;n.length===3&&(n=n.split("").map(i=>i+i).join(""));let r=Number.parseInt(n,16);return[r>>16&255,r>>8&255,r&255]},"value"),enumerable:!1},hexToAnsi256:{value:a(u=>e.rgbToAnsi256(...e.hexToRgb(u)),"value"),enumerable:!1},ansi256ToAnsi:{value:a(u=>{if(u<8)return 30+u;if(u<16)return 90+(u-8);let s,n,r;if(u>=232)s=((u-232)*10+8)/255,n=s,r=s;else{u-=16;let o=u%36;s=Math.floor(u/36)/5,n=Math.floor(o/6)/5,r=o%6/5}let i=Math.max(s,n,r)*2;if(i===0)return 30;let D=30+(Math.round(r)<<2|Math.round(n)<<1|Math.round(s));return i===2&&(D+=60),D},"value"),enumerable:!1},rgbToAnsi:{value:a((u,s,n)=>e.ansi256ToAnsi(e.rgbToAnsi256(u,s,n)),"value"),enumerable:!1},hexToAnsi:{value:a(u=>e.ansi256ToAnsi(e.hexToAnsi256(u)),"value"),enumerable:!1}}),e}a(Tr,"AD");var xr=Tr(),Or=xr,We=new Set(["\x1B","\x9B"]),Nr=39,dt="\x07",Hu="[",Hr="]",Pu="m",Et=`${Hr}8;;`,Lu=a(t=>`${We.values().next().value}${Hu}${t}${Pu}`,"J$1"),Iu=a(t=>`${We.values().next().value}${Et}${t}${dt}`,"Q"),Pr=a(t=>t.split(" ").map(e=>oe(e)),"hD"),pt=a((t,e,u)=>{let s=[...e],n=!1,r=!1,i=oe(vu(t[t.length-1]));for(let[D,o]of s.entries()){let c=oe(o);if(i+c<=u?t[t.length-1]+=o:(t.push(o),i=0),We.has(o)&&(n=!0,r=s.slice(D+1).join("").startsWith(Et)),n){r?o===dt&&(n=!1,r=!1):o===Pu&&(n=!1);continue}i+=c,i===u&&D<s.length-1&&(t.push(""),i=0)}!i&&t[t.length-1].length>0&&t.length>1&&(t[t.length-2]+=t.pop())},"S$1"),Lr=a(t=>{let e=t.split(" "),u=e.length;for(;u>0&&!(oe(e[u-1])>0);)u--;return u===e.length?t:e.slice(0,u).join(" ")+e.slice(u).join("")},"cD"),Ir=a((t,e,u={})=>{if(u.trim!==!1&&t.trim()==="")return"";let s="",n,r,i=Pr(t),D=[""];for(let[c,f]of t.split(" ").entries()){u.trim!==!1&&(D[D.length-1]=D[D.length-1].trimStart());let h=oe(D[D.length-1]);if(c!==0&&(h>=e&&(u.wordWrap===!1||u.trim===!1)&&(D.push(""),h=0),(h>0||u.trim===!1)&&(D[D.length-1]+=" ",h++)),u.hard&&i[c]>e){let l=e-h,p=1+Math.floor((i[c]-l-1)/e);Math.floor((i[c]-1)/e)<p&&D.push(""),pt(D,f,e);continue}if(h+i[c]>e&&h>0&&i[c]>0){if(u.wordWrap===!1&&h<e){pt(D,f,e);continue}D.push("")}if(h+i[c]>e&&u.wordWrap===!1){pt(D,f,e);continue}D[D.length-1]+=f}u.trim!==!1&&(D=D.map(c=>Lr(c)));let o=[...D.join(`
+`)];for(let[c,f]of o.entries()){if(s+=f,We.has(f)){let{groups:l}=new RegExp(`(?:\\${Hu}(?<code>\\d+)m|\\${Et}(?<uri>.*)${dt})`).exec(o.slice(c).join(""))||{groups:{}};if(l.code!==void 0){let p=Number.parseFloat(l.code);n=p===Nr?void 0:p}else l.uri!==void 0&&(r=l.uri.length===0?void 0:l.uri)}let h=Or.codes.get(Number(n));o[c+1]===`
+`?(r&&(s+=Iu("")),n&&h&&(s+=Lu(h))):f===`
+`&&(n&&h&&(s+=Lu(n)),r&&(s+=Iu(r)))}return s},"dD");function kr(t,e,u){return String(t).normalize().replace(/\r\n/g,`
+`).split(`
+`).map(s=>Ir(s,e,u)).join(`
+`)}a(kr,"T$1");var ku=a(t=>Array.from({length:t}).fill(""),"X");function Mr(t,e){let u=[],s=0;for(let n of t){let r=0,i=n.map(o=>{var c;let f=(c=e[s])!=null?c:"";s+=1,o.preprocess&&(f=o.preprocess(f)),Su(f)>o.width&&(f=kr(f,o.width,{hard:!0}));let h=f.split(`
+`);if(o.postprocess){let{postprocess:l}=o;h=h.map((p,C)=>l.call(o,p,C))}return o.paddingTop&&h.unshift(...ku(o.paddingTop)),o.paddingBottom&&h.push(...ku(o.paddingBottom)),h.length>r&&(r=h.length),ft(Ge({},o),{lines:h})}),D=[];for(let o=0;o<r;o+=1){let c=i.map(f=>{var h;let l=(h=f.lines[o])!=null?h:"",p=Number.isFinite(f.width)?" ".repeat(f.width-oe(l)):"",C=f.paddingLeftString;return f.align==="right"&&(C+=p),C+=l,f.align==="left"&&(C+=p),C+f.paddingRightString}).join("");D.push(c)}u.push(D.join(`
+`))}return u.join(`
+`)}a(Mr,"P");function Gr(t,e){if(!t||t.length===0)return"";let u=br(t),s=u.length;if(s===0)return"";let{stdoutColumns:n,columns:r}=Ar(e);if(r.length>s)throw new Error(`${r.length} columns defined, but only ${s} columns found`);let i=$r(n,r,u);return t.map(D=>Mr(i,D)).join(`
+`)}a(Gr,"mD"),K();var Wr=["<",">","=",">=","<="];function jr(t){if(!Wr.includes(t))throw new TypeError(`Invalid breakpoint operator: ${t}`)}a(jr,"xD");function Ur(t){let e=Object.keys(t).map(u=>{let[s,n]=u.split(" ");jr(s);let r=Number.parseInt(n,10);if(Number.isNaN(r))throw new TypeError(`Invalid breakpoint value: ${n}`);let i=t[u];return{operator:s,breakpoint:r,value:i}}).sort((u,s)=>s.breakpoint-u.breakpoint);return u=>{var s;return(s=e.find(({operator:n,breakpoint:r})=>n==="="&&u===r||n===">"&&u>r||n==="<"&&u<r||n===">="&&u>=r||n==="<="&&u<=r))==null?void 0:s.value}}a(Ur,"wD");const Kr=a(t=>t.replace(/[\W_]([a-z\d])?/gi,(e,u)=>u?u.toUpperCase():""),"S"),Vr=a(t=>t.replace(/\B([A-Z])/g,"-$1").toLowerCase(),"q"),zr={"> 80":[{width:"content-width",paddingLeft:2,paddingRight:8},{width:"auto"}],"> 40":[{width:"auto",paddingLeft:2,paddingRight:8,preprocess:a(t=>t.trim(),"preprocess")},{width:"100%",paddingLeft:2,paddingBottom:1}],"> 0":{stdoutColumns:1e3,columns:[{width:"content-width",paddingLeft:2,paddingRight:8},{width:"content-width"}]}};function Yr(t){let e=!1;return{type:"table",data:{tableData:Object.keys(t).sort((u,s)=>u.localeCompare(s)).map(u=>{const s=t[u],n="alias"in s;return n&&(e=!0),{name:u,flag:s,flagFormatted:`--${Vr(u)}`,aliasesEnabled:e,aliasFormatted:n?`-${s.alias}`:void 0}}).map(u=>(u.aliasesEnabled=e,[{type:"flagName",data:u},{type:"flagDescription",data:u}])),tableBreakpoints:zr}}}a(Yr,"D");const Mu=a(t=>!t||(t.version??(t.help?t.help.version:void 0)),"A"),Gu=a(t=>{const e="parent"in t&&t.parent?.name;return(e?`${e} `:"")+t.name},"C");function qr(t){const e=[];t.name&&e.push(Gu(t));const u=Mu(t)??("parent"in t&&Mu(t.parent));if(u&&e.push(`v${u}`),e.length!==0)return{id:"name",type:"text",data:`${e.join(" ")}
+`}}a(qr,"R");function Xr(t){const{help:e}=t;if(!(!e||!e.description))return{id:"description",type:"text",data:`${e.description}
+`}}a(Xr,"L");function Qr(t){const e=t.help||{};if("usage"in e)return e.usage?{id:"usage",type:"section",data:{title:"Usage:",body:Array.isArray(e.usage)?e.usage.join(`
+`):e.usage}}:void 0;if(t.name){const u=[],s=[Gu(t)];if(t.flags&&Object.keys(t.flags).length>0&&s.push("[flags...]"),t.parameters&&t.parameters.length>0){const{parameters:n}=t,r=n.indexOf("--"),i=r>-1&&n.slice(r+1).some(D=>D.startsWith("<"));s.push(n.map(D=>D!=="--"?D:i?"--":"[--]").join(" "))}if(s.length>1&&u.push(s.join(" ")),"commands"in t&&t.commands?.length&&u.push(`${t.name} <command>`),u.length>0)return{id:"usage",type:"section",data:{title:"Usage:",body:u.join(`
+`)}}}}a(Qr,"T");function Zr(t){return!("commands"in t)||!t.commands?.length?void 0:{id:"commands",type:"section",data:{title:"Commands:",body:{type:"table",data:{tableData:t.commands.map(e=>[e.options.name,e.options.help?e.options.help.description:""]),tableOptions:[{width:"content-width",paddingLeft:2,paddingRight:8}]}},indentBody:0}}}a(Zr,"_");function Jr(t){if(!(!t.flags||Object.keys(t.flags).length===0))return{id:"flags",type:"section",data:{title:"Flags:",body:Yr(t.flags),indentBody:0}}}a(Jr,"k");function ei(t){const{help:e}=t;if(!e||!e.examples||e.examples.length===0)return;let{examples:u}=e;if(Array.isArray(u)&&(u=u.join(`
+`)),u)return{id:"examples",type:"section",data:{title:"Examples:",body:u}}}a(ei,"F");function ti(t){if(!("alias"in t)||!t.alias)return;const{alias:e}=t;return{id:"aliases",type:"section",data:{title:"Aliases:",body:Array.isArray(e)?e.join(", "):e}}}a(ti,"H");const ui=a(t=>[qr,Xr,Qr,Zr,Jr,ei,ti].map(e=>e(t)).filter(Boolean),"U"),si=bn.WriteStream.prototype.hasColors();class ni{static{a(this,"M")}text(e){return e}bold(e){return si?`\x1B[1m${e}\x1B[22m`:e.toLocaleUpperCase()}indentText({text:e,spaces:u}){return e.replace(/^/gm," ".repeat(u))}heading(e){return this.bold(e)}section({title:e,body:u,indentBody:s=2}){return`${(e?`${this.heading(e)}
+`:"")+(u?this.indentText({text:this.render(u),spaces:s}):"")}
+`}table({tableData:e,tableOptions:u,tableBreakpoints:s}){return Gr(e.map(n=>n.map(r=>this.render(r))),s?Ur(s):u)}flagParameter(e){return e===Boolean?"":e===String?"<string>":e===Number?"<number>":Array.isArray(e)?this.flagParameter(e[0]):"<value>"}flagOperator(e){return" "}flagName(e){const{flag:u,flagFormatted:s,aliasesEnabled:n,aliasFormatted:r}=e;let i="";if(r?i+=`${r}, `:n&&(i+="    "),i+=s,"placeholder"in u&&typeof u.placeholder=="string")i+=`${this.flagOperator(e)}${u.placeholder}`;else{const D=this.flagParameter("type"in u?u.type:u);D&&(i+=`${this.flagOperator(e)}${D}`)}return i}flagDefault(e){return JSON.stringify(e)}flagDescription({flag:e}){let u="description"in e?e.description??"":"";if("default"in e){let{default:s}=e;typeof s=="function"&&(s=s()),s&&(u+=` (default: ${this.flagDefault(s)})`)}return u}render(e){if(typeof e=="string")return e;if(Array.isArray(e))return e.map(u=>this.render(u)).join(`
+`);if("type"in e&&this[e.type]){const u=this[e.type];if(typeof u=="function")return u.call(this,e.data)}throw new Error(`Invalid node type: ${JSON.stringify(e)}`)}}const Ct=/^[\w.-]+$/,{stringify:ee}=JSON,ri=/[|\\{}()[\]^$+*?.]/;function Ft(t){const e=[];let u,s;for(const n of t){if(s)throw new Error(`Invalid parameter: Spread parameter ${ee(s)} must be last`);const r=n[0],i=n[n.length-1];let D;if(r==="<"&&i===">"&&(D=!0,u))throw new Error(`Invalid parameter: Required parameter ${ee(n)} cannot come after optional parameter ${ee(u)}`);if(r==="["&&i==="]"&&(D=!1,u=n),D===void 0)throw new Error(`Invalid parameter: ${ee(n)}. Must be wrapped in <> (required parameter) or [] (optional parameter)`);let o=n.slice(1,-1);const c=o.slice(-3)==="...";c&&(s=n,o=o.slice(0,-3));const f=o.match(ri);if(f)throw new Error(`Invalid parameter: ${ee(n)}. Invalid character found ${ee(f[0])}`);e.push({name:o,required:D,spread:c})}return e}a(Ft,"w");function gt(t,e,u,s){for(let n=0;n<e.length;n+=1){const{name:r,required:i,spread:D}=e[n],o=Kr(r);if(o in t)throw new Error(`Invalid parameter: ${ee(r)} is used more than once.`);const c=D?u.slice(n):u[n];if(D&&(n=e.length),i&&(!c||D&&c.length===0))return console.error(`Error: Missing required parameter ${ee(r)}
+`),s(),process.exit(1);t[o]=c}}a(gt,"b");function ii(t){return t===void 0||t!==!1}a(ii,"W");function Wu(t,e,u,s){const n={...e.flags},r=e.version;r&&(n.version={type:Boolean,description:"Show version"});const{help:i}=e,D=ii(i);D&&!("help"in n)&&(n.help={type:Boolean,alias:"h",description:"Show help"});const o=yu(n,s,{ignore:e.ignoreArgv}),c=a(()=>{console.log(e.version)},"f");if(r&&o.flags.version===!0)return c(),process.exit(0);const f=new ni,h=D&&i?.render?i.render:C=>f.render(C),l=a(C=>{const g=ui({...e,...C?{help:C}:{},flags:n});console.log(h(g,f))},"u");if(D&&o.flags.help===!0)return l(),process.exit(0);if(e.parameters){let{parameters:C}=e,g=o._;const y=C.indexOf("--"),B=C.slice(y+1),H=Object.create(null);if(y>-1&&B.length>0){C=C.slice(0,y);const $=o._["--"];g=g.slice(0,-$.length||void 0),gt(H,Ft(C),g,l),gt(H,Ft(B),$,l)}else gt(H,Ft(C),g,l);Object.assign(o._,H)}const p={...o,showVersion:c,showHelp:l};return typeof u=="function"&&u(p),{command:t,...p}}a(Wu,"x");function Di(t,e){const u=new Map;for(const s of e){const n=[s.options.name],{alias:r}=s.options;r&&(Array.isArray(r)?n.push(...r):n.push(r));for(const i of n){if(u.has(i))throw new Error(`Duplicate command name found: ${ee(i)}`);u.set(i,s)}}return u.get(t)}a(Di,"z");function ju(t,e,u=process.argv.slice(2)){if(!t)throw new Error("Options is required");if("name"in t&&(!t.name||!Ct.test(t.name)))throw new Error(`Invalid script name: ${ee(t.name)}`);const s=u[0];if(t.commands&&Ct.test(s)){const n=Di(s,t.commands);if(n)return Wu(n.options.name,{...n.options,parent:t},n.callback,u.slice(1))}return Wu(void 0,t,e,u)}a(ju,"Z");function oi(t,e){if(!t)throw new Error("Command options are required");const{name:u}=t;if(t.name===void 0)throw new Error("Command name is required");if(!Ct.test(u))throw new Error(`Invalid command name ${JSON.stringify(u)}. Command names must be one word.`);return{options:t,callback:e}}a(oi,"G");var ai=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{};function li(t){return t&&t.__esModule&&Object.prototype.hasOwnProperty.call(t,"default")?t.default:t}a(li,"getDefaultExportFromCjs");var fe={exports:{}},mt,Uu;function ci(){if(Uu)return mt;Uu=1,mt=s,s.sync=n;var t=De;function e(r,i){var D=i.pathExt!==void 0?i.pathExt:process.env.PATHEXT;if(!D||(D=D.split(";"),D.indexOf("")!==-1))return!0;for(var o=0;o<D.length;o++){var c=D[o].toLowerCase();if(c&&r.substr(-c.length).toLowerCase()===c)return!0}return!1}a(e,"checkPathExt");function u(r,i,D){return!r.isSymbolicLink()&&!r.isFile()?!1:e(i,D)}a(u,"checkStat");function s(r,i,D){t.stat(r,function(o,c){D(o,o?!1:u(c,r,i))})}a(s,"isexe");function n(r,i){return u(t.statSync(r),r,i)}return a(n,"sync"),mt}a(ci,"requireWindows");var _t,Ku;function fi(){if(Ku)return _t;Ku=1,_t=e,e.sync=u;var t=De;function e(r,i,D){t.stat(r,function(o,c){D(o,o?!1:s(c,i))})}a(e,"isexe");function u(r,i){return s(t.statSync(r),i)}a(u,"sync");function s(r,i){return r.isFile()&&n(r,i)}a(s,"checkStat");function n(r,i){var D=r.mode,o=r.uid,c=r.gid,f=i.uid!==void 0?i.uid:process.getuid&&process.getuid(),h=i.gid!==void 0?i.gid:process.getgid&&process.getgid(),l=parseInt("100",8),p=parseInt("010",8),C=parseInt("001",8),g=l|p,y=D&C||D&p&&c===h||D&l&&o===f||D&g&&f===0;return y}return a(n,"checkMode"),_t}a(fi,"requireMode");var je;process.platform==="win32"||ai.TESTING_WINDOWS?je=ci():je=fi();var hi=At;At.sync=di;function At(t,e,u){if(typeof e=="function"&&(u=e,e={}),!u){if(typeof Promise!="function")throw new TypeError("callback not provided");return new Promise(function(s,n){At(t,e||{},function(r,i){r?n(r):s(i)})})}je(t,e||{},function(s,n){s&&(s.code==="EACCES"||e&&e.ignoreErrors)&&(s=null,n=!1),u(s,n)})}a(At,"isexe$1");function di(t,e){try{return je.sync(t,e||{})}catch(u){if(e&&e.ignoreErrors||u.code==="EACCES")return!1;throw u}}a(di,"sync");const he=process.platform==="win32"||process.env.OSTYPE==="cygwin"||process.env.OSTYPE==="msys",Vu=z,Ei=he?";":":",zu=hi,Yu=a(t=>Object.assign(new Error(`not found: ${t}`),{code:"ENOENT"}),"getNotFoundError"),qu=a((t,e)=>{const u=e.colon||Ei,s=t.match(/\//)||he&&t.match(/\\/)?[""]:[...he?[process.cwd()]:[],...(e.path||process.env.PATH||"").split(u)],n=he?e.pathExt||process.env.PATHEXT||".EXE;.CMD;.BAT;.COM":"",r=he?n.split(u):[""];return he&&t.indexOf(".")!==-1&&r[0]!==""&&r.unshift(""),{pathEnv:s,pathExt:r,pathExtExe:n}},"getPathInfo"),Xu=a((t,e,u)=>{typeof e=="function"&&(u=e,e={}),e||(e={});const{pathEnv:s,pathExt:n,pathExtExe:r}=qu(t,e),i=[],D=a(c=>new Promise((f,h)=>{if(c===s.length)return e.all&&i.length?f(i):h(Yu(t));const l=s[c],p=/^".*"$/.test(l)?l.slice(1,-1):l,C=Vu.join(p,t),g=!p&&/^\.[\\\/]/.test(t)?t.slice(0,2)+C:C;f(o(g,c,0))}),"step"),o=a((c,f,h)=>new Promise((l,p)=>{if(h===n.length)return l(D(f+1));const C=n[h];zu(c+C,{pathExt:r},(g,y)=>{if(!g&&y)if(e.all)i.push(c+C);else return l(c+C);return l(o(c,f,h+1))})}),"subStep");return u?D(0).then(c=>u(null,c),u):D(0)},"which$1"),pi=a((t,e)=>{e=e||{};const{pathEnv:u,pathExt:s,pathExtExe:n}=qu(t,e),r=[];for(let i=0;i<u.length;i++){const D=u[i],o=/^".*"$/.test(D)?D.slice(1,-1):D,c=Vu.join(o,t),f=!o&&/^\.[\\\/]/.test(t)?t.slice(0,2)+c:c;for(let h=0;h<s.length;h++){const l=f+s[h];try{if(zu.sync(l,{pathExt:n}))if(e.all)r.push(l);else return l}catch{}}}if(e.all&&r.length)return r;if(e.nothrow)return null;throw Yu(t)},"whichSync");var Ci=Xu;Xu.sync=pi;var yt={exports:{}};const Qu=a((t={})=>{const e=t.env||process.env;return(t.platform||process.platform)!=="win32"?"PATH":Object.keys(e).reverse().find(s=>s.toUpperCase()==="PATH")||"Path"},"pathKey");yt.exports=Qu,yt.exports.default=Qu;var Fi=yt.exports;const Zu=z,gi=Ci,mi=Fi;function Ju(t,e){const u=t.options.env||process.env,s=process.cwd(),n=t.options.cwd!=null,r=n&&process.chdir!==void 0&&!process.chdir.disabled;if(r)try{process.chdir(t.options.cwd)}catch{}let i;try{i=gi.sync(t.command,{path:u[mi({env:u})],pathExt:e?Zu.delimiter:void 0})}catch{}finally{r&&process.chdir(s)}return i&&(i=Zu.resolve(n?t.options.cwd:"",i)),i}a(Ju,"resolveCommandAttempt");function _i(t){return Ju(t)||Ju(t,!0)}a(_i,"resolveCommand$1");var Ai=_i,wt={};const Rt=/([()\][%!^"`<>&|;, *?])/g;function yi(t){return t=t.replace(Rt,"^$1"),t}a(yi,"escapeCommand");function wi(t,e){return t=`${t}`,t=t.replace(/(\\*)"/g,'$1$1\\"'),t=t.replace(/(\\*)$/,"$1$1"),t=`"${t}"`,t=t.replace(Rt,"^$1"),e&&(t=t.replace(Rt,"^$1")),t}a(wi,"escapeArgument"),wt.command=yi,wt.argument=wi;var Ri=/^#!(.*)/;const bi=Ri;var vi=a((t="")=>{const e=t.match(bi);if(!e)return null;const[u,s]=e[0].replace(/#! ?/,"").split(" "),n=u.split("/").pop();return n==="env"?s:s?`${n} ${s}`:n},"shebangCommand$1");const bt=De,Si=vi;function Bi(t){const u=Buffer.alloc(150);let s;try{s=bt.openSync(t,"r"),bt.readSync(s,u,0,150,0),bt.closeSync(s)}catch{}return Si(u.toString())}a(Bi,"readShebang$1");var $i=Bi;const Ti=z,es=Ai,ts=wt,xi=$i,Oi=process.platform==="win32",Ni=/\.(?:com|exe)$/i,Hi=/node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;function Pi(t){t.file=es(t);const e=t.file&&xi(t.file);return e?(t.args.unshift(t.file),t.command=e,es(t)):t.file}a(Pi,"detectShebang");function Li(t){if(!Oi)return t;const e=Pi(t),u=!Ni.test(e);if(t.options.forceShell||u){const s=Hi.test(e);t.command=Ti.normalize(t.command),t.command=ts.command(t.command),t.args=t.args.map(r=>ts.argument(r,s));const n=[t.command].concat(t.args).join(" ");t.args=["/d","/s","/c",`"${n}"`],t.command=process.env.comspec||"cmd.exe",t.options.windowsVerbatimArguments=!0}return t}a(Li,"parseNonShell");function Ii(t,e,u){e&&!Array.isArray(e)&&(u=e,e=null),e=e?e.slice(0):[],u=Object.assign({},u);const s={command:t,args:e,options:u,file:void 0,original:{command:t,args:e}};return u.shell?s:Li(s)}a(Ii,"parse$5");var ki=Ii;const vt=process.platform==="win32";function St(t,e){return Object.assign(new Error(`${e} ${t.command} ENOENT`),{code:"ENOENT",errno:"ENOENT",syscall:`${e} ${t.command}`,path:t.command,spawnargs:t.args})}a(St,"notFoundError");function Mi(t,e){if(!vt)return;const u=t.emit;t.emit=function(s,n){if(s==="exit"){const r=us(n,e);if(r)return u.call(t,"error",r)}return u.apply(t,arguments)}}a(Mi,"hookChildProcess");function us(t,e){return vt&&t===1&&!e.file?St(e.original,"spawn"):null}a(us,"verifyENOENT");function Gi(t,e){return vt&&t===1&&!e.file?St(e.original,"spawnSync"):null}a(Gi,"verifyENOENTSync");var Wi={hookChildProcess:Mi,verifyENOENT:us,verifyENOENTSync:Gi,notFoundError:St};const ss=On,Bt=ki,$t=Wi;function ns(t,e,u){const s=Bt(t,e,u),n=ss.spawn(s.command,s.args,s.options);return $t.hookChildProcess(n,s),n}a(ns,"spawn");function ji(t,e,u){const s=Bt(t,e,u),n=ss.spawnSync(s.command,s.args,s.options);return n.error=n.error||$t.verifyENOENTSync(n.status,s),n}a(ji,"spawnSync"),fe.exports=ns,fe.exports.spawn=ns,fe.exports.sync=ji,fe.exports._parse=Bt,fe.exports._enoent=$t;var Ui=fe.exports,Ki=li(Ui);const rs=a((t,e)=>{const u={...process.env},s=["inherit","inherit","inherit"];process.send&&s.push("ipc"),e&&(e.noCache&&(u.TSX_DISABLE_CACHE="1"),e.tsconfigPath&&(u.TSX_TSCONFIG_PATH=e.tsconfigPath));const n=t.filter(r=>r!=="-i"&&r!=="--interactive").length===0;return Ki(process.execPath,["--require",Ie.resolve("./preflight.cjs"),...n?["--require",Ie.resolve("./patch-repl.cjs")]:[],mu(Nn)?"--import":"--loader",Tn(Ie.resolve("./loader.mjs")).toString(),...t],{stdio:s,env:u})},"run");var Ue={};const Vi=z,te="\\\\/",is=`[^${te}]`,ue="\\.",zi="\\+",Yi="\\?",Ke="\\/",qi="(?=.)",Ds="[^/]",Tt=`(?:${Ke}|$)`,os=`(?:^|${Ke})`,xt=`${ue}{1,2}${Tt}`,Xi=`(?!${ue})`,Qi=`(?!${os}${xt})`,Zi=`(?!${ue}{0,1}${Tt})`,Ji=`(?!${xt})`,eD=`[^.${Ke}]`,tD=`${Ds}*?`,as={DOT_LITERAL:ue,PLUS_LITERAL:zi,QMARK_LITERAL:Yi,SLASH_LITERAL:Ke,ONE_CHAR:qi,QMARK:Ds,END_ANCHOR:Tt,DOTS_SLASH:xt,NO_DOT:Xi,NO_DOTS:Qi,NO_DOT_SLASH:Zi,NO_DOTS_SLASH:Ji,QMARK_NO_DOT:eD,STAR:tD,START_ANCHOR:os},uD={...as,SLASH_LITERAL:`[${te}]`,QMARK:is,STAR:`${is}*?`,DOTS_SLASH:`${ue}{1,2}(?:[${te}]|$)`,NO_DOT:`(?!${ue})`,NO_DOTS:`(?!(?:^|[${te}])${ue}{1,2}(?:[${te}]|$))`,NO_DOT_SLASH:`(?!${ue}{0,1}(?:[${te}]|$))`,NO_DOTS_SLASH:`(?!${ue}{1,2}(?:[${te}]|$))`,QMARK_NO_DOT:`[^.${te}]`,START_ANCHOR:`(?:^|[${te}])`,END_ANCHOR:`(?:[${te}]|$)`},sD={alnum:"a-zA-Z0-9",alpha:"a-zA-Z",ascii:"\\x00-\\x7F",blank:" \\t",cntrl:"\\x00-\\x1F\\x7F",digit:"0-9",graph:"\\x21-\\x7E",lower:"a-z",print:"\\x20-\\x7E ",punct:"\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",space:" \\t\\r\\n\\v\\f",upper:"A-Z",word:"A-Za-z0-9_",xdigit:"A-Fa-f0-9"};var Ve={MAX_LENGTH:1024*64,POSIX_REGEX_SOURCE:sD,REGEX_BACKSLASH:/\\(?![*+?^${}(|)[\]])/g,REGEX_NON_SPECIAL_CHARS:/^[^@![\].,$*+?^{}()|\\/]+/,REGEX_SPECIAL_CHARS:/[-*+?.^${}(|)[\]]/,REGEX_SPECIAL_CHARS_BACKREF:/(\\?)((\W)(\3*))/g,REGEX_SPECIAL_CHARS_GLOBAL:/([-*+?.^${}(|)[\]])/g,REGEX_REMOVE_BACKSLASH:/(?:\[.*?[^\\]\]|\\(?=.))/g,REPLACEMENTS:{"***":"*","**/**":"**","**/**/**":"**"},CHAR_0:48,CHAR_9:57,CHAR_UPPERCASE_A:65,CHAR_LOWERCASE_A:97,CHAR_UPPERCASE_Z:90,CHAR_LOWERCASE_Z:122,CHAR_LEFT_PARENTHESES:40,CHAR_RIGHT_PARENTHESES:41,CHAR_ASTERISK:42,CHAR_AMPERSAND:38,CHAR_AT:64,CHAR_BACKWARD_SLASH:92,CHAR_CARRIAGE_RETURN:13,CHAR_CIRCUMFLEX_ACCENT:94,CHAR_COLON:58,CHAR_COMMA:44,CHAR_DOT:46,CHAR_DOUBLE_QUOTE:34,CHAR_EQUAL:61,CHAR_EXCLAMATION_MARK:33,CHAR_FORM_FEED:12,CHAR_FORWARD_SLASH:47,CHAR_GRAVE_ACCENT:96,CHAR_HASH:35,CHAR_HYPHEN_MINUS:45,CHAR_LEFT_ANGLE_BRACKET:60,CHAR_LEFT_CURLY_BRACE:123,CHAR_LEFT_SQUARE_BRACKET:91,CHAR_LINE_FEED:10,CHAR_NO_BREAK_SPACE:160,CHAR_PERCENT:37,CHAR_PLUS:43,CHAR_QUESTION_MARK:63,CHAR_RIGHT_ANGLE_BRACKET:62,CHAR_RIGHT_CURLY_BRACE:125,CHAR_RIGHT_SQUARE_BRACKET:93,CHAR_SEMICOLON:59,CHAR_SINGLE_QUOTE:39,CHAR_SPACE:32,CHAR_TAB:9,CHAR_UNDERSCORE:95,CHAR_VERTICAL_LINE:124,CHAR_ZERO_WIDTH_NOBREAK_SPACE:65279,SEP:Vi.sep,extglobChars(t){return{"!":{type:"negate",open:"(?:(?!(?:",close:`))${t.STAR})`},"?":{type:"qmark",open:"(?:",close:")?"},"+":{type:"plus",open:"(?:",close:")+"},"*":{type:"star",open:"(?:",close:")*"},"@":{type:"at",open:"(?:",close:")"}}},globChars(t){return t===!0?uD:as}};(function(t){const e=z,u=process.platform==="win32",{REGEX_BACKSLASH:s,REGEX_REMOVE_BACKSLASH:n,REGEX_SPECIAL_CHARS:r,REGEX_SPECIAL_CHARS_GLOBAL:i}=Ve;t.isObject=D=>D!==null&&typeof D=="object"&&!Array.isArray(D),t.hasRegexChars=D=>r.test(D),t.isRegexChar=D=>D.length===1&&t.hasRegexChars(D),t.escapeRegex=D=>D.replace(i,"\\$1"),t.toPosixSlashes=D=>D.replace(s,"/"),t.removeBackslashes=D=>D.replace(n,o=>o==="\\"?"":o),t.supportsLookbehinds=()=>{const D=process.version.slice(1).split(".").map(Number);return D.length===3&&D[0]>=9||D[0]===8&&D[1]>=10},t.isWindows=D=>D&&typeof D.windows=="boolean"?D.windows:u===!0||e.sep==="\\",t.escapeLast=(D,o,c)=>{const f=D.lastIndexOf(o,c);return f===-1?D:D[f-1]==="\\"?t.escapeLast(D,o,f-1):`${D.slice(0,f)}\\${D.slice(f)}`},t.removePrefix=(D,o={})=>{let c=D;return c.startsWith("./")&&(c=c.slice(2),o.prefix="./"),c},t.wrapOutput=(D,o={},c={})=>{const f=c.contains?"":"^",h=c.contains?"":"$";let l=`${f}(?:${D})${h}`;return o.negated===!0&&(l=`(?:^(?!${l}).*$)`),l}})(Ue);const ls=Ue,{CHAR_ASTERISK:Ot,CHAR_AT:nD,CHAR_BACKWARD_SLASH:ye,CHAR_COMMA:rD,CHAR_DOT:Nt,CHAR_EXCLAMATION_MARK:Ht,CHAR_FORWARD_SLASH:cs,CHAR_LEFT_CURLY_BRACE:Pt,CHAR_LEFT_PARENTHESES:Lt,CHAR_LEFT_SQUARE_BRACKET:iD,CHAR_PLUS:DD,CHAR_QUESTION_MARK:fs,CHAR_RIGHT_CURLY_BRACE:oD,CHAR_RIGHT_PARENTHESES:hs,CHAR_RIGHT_SQUARE_BRACKET:aD}=Ve,ds=a(t=>t===cs||t===ye,"isPathSeparator"),Es=a(t=>{t.isPrefix!==!0&&(t.depth=t.isGlobstar?1/0:1)},"depth"),lD=a((t,e)=>{const u=e||{},s=t.length-1,n=u.parts===!0||u.scanToEnd===!0,r=[],i=[],D=[];let o=t,c=-1,f=0,h=0,l=!1,p=!1,C=!1,g=!1,y=!1,B=!1,H=!1,$=!1,Q=!1,G=!1,ne=0,W,A,v={value:"",depth:0,isGlob:!1};const M=a(()=>c>=s,"eos"),F=a(()=>o.charCodeAt(c+1),"peek"),O=a(()=>(W=A,o.charCodeAt(++c)),"advance");for(;c<s;){A=O();let j;if(A===ye){H=v.backslashes=!0,A=O(),A===Pt&&(B=!0);continue}if(B===!0||A===Pt){for(ne++;M()!==!0&&(A=O());){if(A===ye){H=v.backslashes=!0,O();continue}if(A===Pt){ne++;continue}if(B!==!0&&A===Nt&&(A=O())===Nt){if(l=v.isBrace=!0,C=v.isGlob=!0,G=!0,n===!0)continue;break}if(B!==!0&&A===rD){if(l=v.isBrace=!0,C=v.isGlob=!0,G=!0,n===!0)continue;break}if(A===oD&&(ne--,ne===0)){B=!1,l=v.isBrace=!0,G=!0;break}}if(n===!0)continue;break}if(A===cs){if(r.push(c),i.push(v),v={value:"",depth:0,isGlob:!1},G===!0)continue;if(W===Nt&&c===f+1){f+=2;continue}h=c+1;continue}if(u.noext!==!0&&(A===DD||A===nD||A===Ot||A===fs||A===Ht)===!0&&F()===Lt){if(C=v.isGlob=!0,g=v.isExtglob=!0,G=!0,A===Ht&&c===f&&(Q=!0),n===!0){for(;M()!==!0&&(A=O());){if(A===ye){H=v.backslashes=!0,A=O();continue}if(A===hs){C=v.isGlob=!0,G=!0;break}}continue}break}if(A===Ot){if(W===Ot&&(y=v.isGlobstar=!0),C=v.isGlob=!0,G=!0,n===!0)continue;break}if(A===fs){if(C=v.isGlob=!0,G=!0,n===!0)continue;break}if(A===iD){for(;M()!==!0&&(j=O());){if(j===ye){H=v.backslashes=!0,O();continue}if(j===aD){p=v.isBracket=!0,C=v.isGlob=!0,G=!0;break}}if(n===!0)continue;break}if(u.nonegate!==!0&&A===Ht&&c===f){$=v.negated=!0,f++;continue}if(u.noparen!==!0&&A===Lt){if(C=v.isGlob=!0,n===!0){for(;M()!==!0&&(A=O());){if(A===Lt){H=v.backslashes=!0,A=O();continue}if(A===hs){G=!0;break}}continue}break}if(C===!0){if(G=!0,n===!0)continue;break}}u.noext===!0&&(g=!1,C=!1);let T=o,re="",d="";f>0&&(re=o.slice(0,f),o=o.slice(f),h-=f),T&&C===!0&&h>0?(T=o.slice(0,h),d=o.slice(h)):C===!0?(T="",d=o):T=o,T&&T!==""&&T!=="/"&&T!==o&&ds(T.charCodeAt(T.length-1))&&(T=T.slice(0,-1)),u.unescape===!0&&(d&&(d=ls.removeBackslashes(d)),T&&H===!0&&(T=ls.removeBackslashes(T)));const E={prefix:re,input:t,start:f,base:T,glob:d,isBrace:l,isBracket:p,isGlob:C,isExtglob:g,isGlobstar:y,negated:$,negatedExtglob:Q};if(u.tokens===!0&&(E.maxDepth=0,ds(A)||i.push(v),E.tokens=i),u.parts===!0||u.tokens===!0){let j;for(let b=0;b<r.length;b++){const Z=j?j+1:f,J=r[b],V=t.slice(Z,J);u.tokens&&(b===0&&f!==0?(i[b].isPrefix=!0,i[b].value=re):i[b].value=V,Es(i[b]),E.maxDepth+=i[b].depth),(b!==0||V!=="")&&D.push(V),j=J}if(j&&j+1<t.length){const b=t.slice(j+1);D.push(b),u.tokens&&(i[i.length-1].value=b,Es(i[i.length-1]),E.maxDepth+=i[i.length-1].depth)}E.slashes=r,E.parts=D}return E},"scan$1");var cD=lD;const ze=Ve,Y=Ue,{MAX_LENGTH:Ye,POSIX_REGEX_SOURCE:fD,REGEX_NON_SPECIAL_CHARS:hD,REGEX_SPECIAL_CHARS_BACKREF:dD,REPLACEMENTS:ps}=ze,ED=a((t,e)=>{if(typeof e.expandRange=="function")return e.expandRange(...t,e);t.sort();const u=`[${t.join("-")}]`;try{new RegExp(u)}catch{return t.map(n=>Y.escapeRegex(n)).join("..")}return u},"expandRange"),de=a((t,e)=>`Missing ${t}: "${e}" - use "\\\\${e}" to match literal characters`,"syntaxError"),It=a((t,e)=>{if(typeof t!="string")throw new TypeError("Expected a string");t=ps[t]||t;const u={...e},s=typeof u.maxLength=="number"?Math.min(Ye,u.maxLength):Ye;let n=t.length;if(n>s)throw new SyntaxError(`Input length: ${n}, exceeds maximum allowed length: ${s}`);const r={type:"bos",value:"",output:u.prepend||""},i=[r],D=u.capture?"":"?:",o=Y.isWindows(e),c=ze.globChars(o),f=ze.extglobChars(c),{DOT_LITERAL:h,PLUS_LITERAL:l,SLASH_LITERAL:p,ONE_CHAR:C,DOTS_SLASH:g,NO_DOT:y,NO_DOT_SLASH:B,NO_DOTS_SLASH:H,QMARK:$,QMARK_NO_DOT:Q,STAR:G,START_ANCHOR:ne}=c,W=a(_=>`(${D}(?:(?!${ne}${_.dot?g:h}).)*?)`,"globstar"),A=u.dot?"":y,v=u.dot?$:Q;let M=u.bash===!0?W(u):G;u.capture&&(M=`(${M})`),typeof u.noext=="boolean"&&(u.noextglob=u.noext);const F={input:t,index:-1,start:0,dot:u.dot===!0,consumed:"",output:"",prefix:"",backtrack:!1,negated:!1,brackets:0,braces:0,parens:0,quotes:0,globstar:!1,tokens:i};t=Y.removePrefix(t,F),n=t.length;const O=[],T=[],re=[];let d=r,E;const j=a(()=>F.index===n-1,"eos"),b=F.peek=(_=1)=>t[F.index+_],Z=F.advance=()=>t[++F.index]||"",J=a(()=>t.slice(F.index+1),"remaining"),V=a((_="",x=0)=>{F.consumed+=_,F.index+=x},"consume"),Ne=a(_=>{F.output+=_.output!=null?_.output:_.value,V(_.value)},"append"),yn=a(()=>{let _=1;for(;b()==="!"&&(b(2)!=="("||b(3)==="?");)Z(),F.start++,_++;return _%2===0?!1:(F.negated=!0,F.start++,!0)},"negate"),He=a(_=>{F[_]++,re.push(_)},"increment"),ie=a(_=>{F[_]--,re.pop()},"decrement"),R=a(_=>{if(d.type==="globstar"){const x=F.braces>0&&(_.type==="comma"||_.type==="brace"),m=_.extglob===!0||O.length&&(_.type==="pipe"||_.type==="paren");_.type!=="slash"&&_.type!=="paren"&&!x&&!m&&(F.output=F.output.slice(0,-d.output.length),d.type="star",d.value="*",d.output=M,F.output+=d.output)}if(O.length&&_.type!=="paren"&&(O[O.length-1].inner+=_.value),(_.value||_.output)&&Ne(_),d&&d.type==="text"&&_.type==="text"){d.value+=_.value,d.output=(d.output||"")+_.value;return}_.prev=d,i.push(_),d=_},"push"),Pe=a((_,x)=>{const m={...f[x],conditions:1,inner:""};m.prev=d,m.parens=F.parens,m.output=F.output;const w=(u.capture?"(":"")+m.open;He("parens"),R({type:_,value:x,output:F.output?"":C}),R({type:"paren",extglob:!0,value:Z(),output:w}),O.push(m)},"extglobOpen"),wn=a(_=>{let x=_.close+(u.capture?")":""),m;if(_.type==="negate"){let w=M;if(_.inner&&_.inner.length>1&&_.inner.includes("/")&&(w=W(u)),(w!==M||j()||/^\)+$/.test(J()))&&(x=_.close=`)$))${w}`),_.inner.includes("*")&&(m=J())&&/^\.[^\\/.]+$/.test(m)){const N=It(m,{...e,fastpaths:!1}).output;x=_.close=`)${N})${w})`}_.prev.type==="bos"&&(F.negatedExtglob=!0)}R({type:"paren",extglob:!0,value:E,output:x}),ie("parens")},"extglobClose");if(u.fastpaths!==!1&&!/(^[*!]|[/()[\]{}"])/.test(t)){let _=!1,x=t.replace(dD,(m,w,N,U,L,at)=>U==="\\"?(_=!0,m):U==="?"?w?w+U+(L?$.repeat(L.length):""):at===0?v+(L?$.repeat(L.length):""):$.repeat(N.length):U==="."?h.repeat(N.length):U==="*"?w?w+U+(L?M:""):M:w?m:`\\${m}`);return _===!0&&(u.unescape===!0?x=x.replace(/\\/g,""):x=x.replace(/\\+/g,m=>m.length%2===0?"\\\\":m?"\\":"")),x===t&&u.contains===!0?(F.output=t,F):(F.output=Y.wrapOutput(x,F,e),F)}for(;!j();){if(E=Z(),E==="\0")continue;if(E==="\\"){const m=b();if(m==="/"&&u.bash!==!0||m==="."||m===";")continue;if(!m){E+="\\",R({type:"text",value:E});continue}const w=/^\\+/.exec(J());let N=0;if(w&&w[0].length>2&&(N=w[0].length,F.index+=N,N%2!==0&&(E+="\\")),u.unescape===!0?E=Z():E+=Z(),F.brackets===0){R({type:"text",value:E});continue}}if(F.brackets>0&&(E!=="]"||d.value==="["||d.value==="[^")){if(u.posix!==!1&&E===":"){const m=d.value.slice(1);if(m.includes("[")&&(d.posix=!0,m.includes(":"))){const w=d.value.lastIndexOf("["),N=d.value.slice(0,w),U=d.value.slice(w+2),L=fD[U];if(L){d.value=N+L,F.backtrack=!0,Z(),!r.output&&i.indexOf(d)===1&&(r.output=C);continue}}}(E==="["&&b()!==":"||E==="-"&&b()==="]")&&(E=`\\${E}`),E==="]"&&(d.value==="["||d.value==="[^")&&(E=`\\${E}`),u.posix===!0&&E==="!"&&d.value==="["&&(E="^"),d.value+=E,Ne({value:E});continue}if(F.quotes===1&&E!=='"'){E=Y.escapeRegex(E),d.value+=E,Ne({value:E});continue}if(E==='"'){F.quotes=F.quotes===1?0:1,u.keepQuotes===!0&&R({type:"text",value:E});continue}if(E==="("){He("parens"),R({type:"paren",value:E});continue}if(E===")"){if(F.parens===0&&u.strictBrackets===!0)throw new SyntaxError(de("opening","("));const m=O[O.length-1];if(m&&F.parens===m.parens+1){wn(O.pop());continue}R({type:"paren",value:E,output:F.parens?")":"\\)"}),ie("parens");continue}if(E==="["){if(u.nobracket===!0||!J().includes("]")){if(u.nobracket!==!0&&u.strictBrackets===!0)throw new SyntaxError(de("closing","]"));E=`\\${E}`}else He("brackets");R({type:"bracket",value:E});continue}if(E==="]"){if(u.nobracket===!0||d&&d.type==="bracket"&&d.value.length===1){R({type:"text",value:E,output:`\\${E}`});continue}if(F.brackets===0){if(u.strictBrackets===!0)throw new SyntaxError(de("opening","["));R({type:"text",value:E,output:`\\${E}`});continue}ie("brackets");const m=d.value.slice(1);if(d.posix!==!0&&m[0]==="^"&&!m.includes("/")&&(E=`/${E}`),d.value+=E,Ne({value:E}),u.literalBrackets===!1||Y.hasRegexChars(m))continue;const w=Y.escapeRegex(d.value);if(F.output=F.output.slice(0,-d.value.length),u.literalBrackets===!0){F.output+=w,d.value=w;continue}d.value=`(${D}${w}|${d.value})`,F.output+=d.value;continue}if(E==="{"&&u.nobrace!==!0){He("braces");const m={type:"brace",value:E,output:"(",outputIndex:F.output.length,tokensIndex:F.tokens.length};T.push(m),R(m);continue}if(E==="}"){const m=T[T.length-1];if(u.nobrace===!0||!m){R({type:"text",value:E,output:E});continue}let w=")";if(m.dots===!0){const N=i.slice(),U=[];for(let L=N.length-1;L>=0&&(i.pop(),N[L].type!=="brace");L--)N[L].type!=="dots"&&U.unshift(N[L].value);w=ED(U,u),F.backtrack=!0}if(m.comma!==!0&&m.dots!==!0){const N=F.output.slice(0,m.outputIndex),U=F.tokens.slice(m.tokensIndex);m.value=m.output="\\{",E=w="\\}",F.output=N;for(const L of U)F.output+=L.output||L.value}R({type:"brace",value:E,output:w}),ie("braces"),T.pop();continue}if(E==="|"){O.length>0&&O[O.length-1].conditions++,R({type:"text",value:E});continue}if(E===","){let m=E;const w=T[T.length-1];w&&re[re.length-1]==="braces"&&(w.comma=!0,m="|"),R({type:"comma",value:E,output:m});continue}if(E==="/"){if(d.type==="dot"&&F.index===F.start+1){F.start=F.index+1,F.consumed="",F.output="",i.pop(),d=r;continue}R({type:"slash",value:E,output:p});continue}if(E==="."){if(F.braces>0&&d.type==="dot"){d.value==="."&&(d.output=h);const m=T[T.length-1];d.type="dots",d.output+=E,d.value+=E,m.dots=!0;continue}if(F.braces+F.parens===0&&d.type!=="bos"&&d.type!=="slash"){R({type:"text",value:E,output:h});continue}R({type:"dot",value:E,output:h});continue}if(E==="?"){if(!(d&&d.value==="(")&&u.noextglob!==!0&&b()==="("&&b(2)!=="?"){Pe("qmark",E);continue}if(d&&d.type==="paren"){const w=b();let N=E;if(w==="<"&&!Y.supportsLookbehinds())throw new Error("Node.js v10 or higher is required for regex lookbehinds");(d.value==="("&&!/[!=<:]/.test(w)||w==="<"&&!/<([!=]|\w+>)/.test(J()))&&(N=`\\${E}`),R({type:"text",value:E,output:N});continue}if(u.dot!==!0&&(d.type==="slash"||d.type==="bos")){R({type:"qmark",value:E,output:Q});continue}R({type:"qmark",value:E,output:$});continue}if(E==="!"){if(u.noextglob!==!0&&b()==="("&&(b(2)!=="?"||!/[!=<:]/.test(b(3)))){Pe("negate",E);continue}if(u.nonegate!==!0&&F.index===0){yn();continue}}if(E==="+"){if(u.noextglob!==!0&&b()==="("&&b(2)!=="?"){Pe("plus",E);continue}if(d&&d.value==="("||u.regex===!1){R({type:"plus",value:E,output:l});continue}if(d&&(d.type==="bracket"||d.type==="paren"||d.type==="brace")||F.parens>0){R({type:"plus",value:E});continue}R({type:"plus",value:l});continue}if(E==="@"){if(u.noextglob!==!0&&b()==="("&&b(2)!=="?"){R({type:"at",extglob:!0,value:E,output:""});continue}R({type:"text",value:E});continue}if(E!=="*"){(E==="$"||E==="^")&&(E=`\\${E}`);const m=hD.exec(J());m&&(E+=m[0],F.index+=m[0].length),R({type:"text",value:E});continue}if(d&&(d.type==="globstar"||d.star===!0)){d.type="star",d.star=!0,d.value+=E,d.output=M,F.backtrack=!0,F.globstar=!0,V(E);continue}let _=J();if(u.noextglob!==!0&&/^\([^?]/.test(_)){Pe("star",E);continue}if(d.type==="star"){if(u.noglobstar===!0){V(E);continue}const m=d.prev,w=m.prev,N=m.type==="slash"||m.type==="bos",U=w&&(w.type==="star"||w.type==="globstar");if(u.bash===!0&&(!N||_[0]&&_[0]!=="/")){R({type:"star",value:E,output:""});continue}const L=F.braces>0&&(m.type==="comma"||m.type==="brace"),at=O.length&&(m.type==="pipe"||m.type==="paren");if(!N&&m.type!=="paren"&&!L&&!at){R({type:"star",value:E,output:""});continue}for(;_.slice(0,3)==="/**";){const Le=t[F.index+4];if(Le&&Le!=="/")break;_=_.slice(3),V("/**",3)}if(m.type==="bos"&&j()){d.type="globstar",d.value+=E,d.output=W(u),F.output=d.output,F.globstar=!0,V(E);continue}if(m.type==="slash"&&m.prev.type!=="bos"&&!U&&j()){F.output=F.output.slice(0,-(m.output+d.output).length),m.output=`(?:${m.output}`,d.type="globstar",d.output=W(u)+(u.strictSlashes?")":"|$)"),d.value+=E,F.globstar=!0,F.output+=m.output+d.output,V(E);continue}if(m.type==="slash"&&m.prev.type!=="bos"&&_[0]==="/"){const Le=_[1]!==void 0?"|$":"";F.output=F.output.slice(0,-(m.output+d.output).length),m.output=`(?:${m.output}`,d.type="globstar",d.output=`${W(u)}${p}|${p}${Le})`,d.value+=E,F.output+=m.output+d.output,F.globstar=!0,V(E+Z()),R({type:"slash",value:"/",output:""});continue}if(m.type==="bos"&&_[0]==="/"){d.type="globstar",d.value+=E,d.output=`(?:^|${p}|${W(u)}${p})`,F.output=d.output,F.globstar=!0,V(E+Z()),R({type:"slash",value:"/",output:""});continue}F.output=F.output.slice(0,-d.output.length),d.type="globstar",d.output=W(u),d.value+=E,F.output+=d.output,F.globstar=!0,V(E);continue}const x={type:"star",value:E,output:M};if(u.bash===!0){x.output=".*?",(d.type==="bos"||d.type==="slash")&&(x.output=A+x.output),R(x);continue}if(d&&(d.type==="bracket"||d.type==="paren")&&u.regex===!0){x.output=E,R(x);continue}(F.index===F.start||d.type==="slash"||d.type==="dot")&&(d.type==="dot"?(F.output+=B,d.output+=B):u.dot===!0?(F.output+=H,d.output+=H):(F.output+=A,d.output+=A),b()!=="*"&&(F.output+=C,d.output+=C)),R(x)}for(;F.brackets>0;){if(u.strictBrackets===!0)throw new SyntaxError(de("closing","]"));F.output=Y.escapeLast(F.output,"["),ie("brackets")}for(;F.parens>0;){if(u.strictBrackets===!0)throw new SyntaxError(de("closing",")"));F.output=Y.escapeLast(F.output,"("),ie("parens")}for(;F.braces>0;){if(u.strictBrackets===!0)throw new SyntaxError(de("closing","}"));F.output=Y.escapeLast(F.output,"{"),ie("braces")}if(u.strictSlashes!==!0&&(d.type==="star"||d.type==="bracket")&&R({type:"maybe_slash",value:"",output:`${p}?`}),F.backtrack===!0){F.output="";for(const _ of F.tokens)F.output+=_.output!=null?_.output:_.value,_.suffix&&(F.output+=_.suffix)}return F},"parse$3");It.fastpaths=(t,e)=>{const u={...e},s=typeof u.maxLength=="number"?Math.min(Ye,u.maxLength):Ye,n=t.length;if(n>s)throw new SyntaxError(`Input length: ${n}, exceeds maximum allowed length: ${s}`);t=ps[t]||t;const r=Y.isWindows(e),{DOT_LITERAL:i,SLASH_LITERAL:D,ONE_CHAR:o,DOTS_SLASH:c,NO_DOT:f,NO_DOTS:h,NO_DOTS_SLASH:l,STAR:p,START_ANCHOR:C}=ze.globChars(r),g=u.dot?h:f,y=u.dot?l:f,B=u.capture?"":"?:",H={negated:!1,prefix:""};let $=u.bash===!0?".*?":p;u.capture&&($=`(${$})`);const Q=a(A=>A.noglobstar===!0?$:`(${B}(?:(?!${C}${A.dot?c:i}).)*?)`,"globstar"),G=a(A=>{switch(A){case"*":return`${g}${o}${$}`;case".*":return`${i}${o}${$}`;case"*.*":return`${g}${$}${i}${o}${$}`;case"*/*":return`${g}${$}${D}${o}${y}${$}`;case"**":return g+Q(u);case"**/*":return`(?:${g}${Q(u)}${D})?${y}${o}${$}`;case"**/*.*":return`(?:${g}${Q(u)}${D})?${y}${$}${i}${o}${$}`;case"**/.*":return`(?:${g}${Q(u)}${D})?${i}${o}${$}`;default:{const v=/^(.*?)\.(\w+)$/.exec(A);if(!v)return;const M=G(v[1]);return M?M+i+v[2]:void 0}}},"create"),ne=Y.removePrefix(t,H);let W=G(ne);return W&&u.strictSlashes!==!0&&(W+=`${D}?`),W};var pD=It;const CD=z,FD=cD,kt=pD,Mt=Ue,gD=Ve,mD=a(t=>t&&typeof t=="object"&&!Array.isArray(t),"isObject$1"),P=a((t,e,u=!1)=>{if(Array.isArray(t)){const f=t.map(l=>P(l,e,u));return a(l=>{for(const p of f){const C=p(l);if(C)return C}return!1},"arrayMatcher")}const s=mD(t)&&t.tokens&&t.input;if(t===""||typeof t!="string"&&!s)throw new TypeError("Expected pattern to be a non-empty string");const n=e||{},r=Mt.isWindows(e),i=s?P.compileRe(t,e):P.makeRe(t,e,!1,!0),D=i.state;delete i.state;let o=a(()=>!1,"isIgnored");if(n.ignore){const f={...e,ignore:null,onMatch:null,onResult:null};o=P(n.ignore,f,u)}const c=a((f,h=!1)=>{const{isMatch:l,match:p,output:C}=P.test(f,i,e,{glob:t,posix:r}),g={glob:t,state:D,regex:i,posix:r,input:f,output:C,match:p,isMatch:l};return typeof n.onResult=="function"&&n.onResult(g),l===!1?(g.isMatch=!1,h?g:!1):o(f)?(typeof n.onIgnore=="function"&&n.onIgnore(g),g.isMatch=!1,h?g:!1):(typeof n.onMatch=="function"&&n.onMatch(g),h?g:!0)},"matcher");return u&&(c.state=D),c},"picomatch$3");P.test=(t,e,u,{glob:s,posix:n}={})=>{if(typeof t!="string")throw new TypeError("Expected input to be a string");if(t==="")return{isMatch:!1,output:""};const r=u||{},i=r.format||(n?Mt.toPosixSlashes:null);let D=t===s,o=D&&i?i(t):t;return D===!1&&(o=i?i(t):t,D=o===s),(D===!1||r.capture===!0)&&(r.matchBase===!0||r.basename===!0?D=P.matchBase(t,e,u,n):D=e.exec(o)),{isMatch:!!D,match:D,output:o}},P.matchBase=(t,e,u,s=Mt.isWindows(u))=>(e instanceof RegExp?e:P.makeRe(e,u)).test(CD.basename(t)),P.isMatch=(t,e,u)=>P(e,u)(t),P.parse=(t,e)=>Array.isArray(t)?t.map(u=>P.parse(u,e)):kt(t,{...e,fastpaths:!1}),P.scan=(t,e)=>FD(t,e),P.compileRe=(t,e,u=!1,s=!1)=>{if(u===!0)return t.output;const n=e||{},r=n.contains?"":"^",i=n.contains?"":"$";let D=`${r}(?:${t.output})${i}`;t&&t.negated===!0&&(D=`^(?!${D}).*$`);const o=P.toRegex(D,e);return s===!0&&(o.state=t),o},P.makeRe=(t,e={},u=!1,s=!1)=>{if(!t||typeof t!="string")throw new TypeError("Expected a non-empty string");let n={negated:!1,fastpaths:!0};return e.fastpaths!==!1&&(t[0]==="."||t[0]==="*")&&(n.output=kt.fastpaths(t,e)),n.output||(n=kt(t,e)),P.compileRe(n,e,u,s)},P.toRegex=(t,e)=>{try{const u=e||{};return new RegExp(t,u.flags||(u.nocase?"i":""))}catch(u){if(e&&e.debug===!0)throw u;return/$^/}},P.constants=gD;var _D=P,Cs=_D;const we=De,{Readable:AD}=In,Re=z,{promisify:qe}=ge,Gt=Cs,yD=qe(we.readdir),wD=qe(we.stat),Fs=qe(we.lstat),RD=qe(we.realpath),bD="!",gs="READDIRP_RECURSIVE_ERROR",vD=new Set(["ENOENT","EPERM","EACCES","ELOOP",gs]),Wt="files",ms="directories",Xe="files_directories",Qe="all",_s=[Wt,ms,Xe,Qe],SD=a(t=>vD.has(t.code),"isNormalFlowError"),[As,BD]=process.versions.node.split(".").slice(0,2).map(t=>Number.parseInt(t,10)),$D=process.platform==="win32"&&(As>10||As===10&&BD>=5),ys=a(t=>{if(t!==void 0){if(typeof t=="function")return t;if(typeof t=="string"){const e=Gt(t.trim());return u=>e(u.basename)}if(Array.isArray(t)){const e=[],u=[];for(const s of t){const n=s.trim();n.charAt(0)===bD?u.push(Gt(n.slice(1))):e.push(Gt(n))}return u.length>0?e.length>0?s=>e.some(n=>n(s.basename))&&!u.some(n=>n(s.basename)):s=>!u.some(n=>n(s.basename)):s=>e.some(n=>n(s.basename))}}},"normalizeFilter");class ot extends AD{static{a(this,"ReaddirpStream")}static get defaultOptions(){return{root:".",fileFilter:a(e=>!0,"fileFilter"),directoryFilter:a(e=>!0,"directoryFilter"),type:Wt,lstat:!1,depth:2147483648,alwaysStat:!1}}constructor(e={}){super({objectMode:!0,autoDestroy:!0,highWaterMark:e.highWaterMark||4096});const u={...ot.defaultOptions,...e},{root:s,type:n}=u;this._fileFilter=ys(u.fileFilter),this._directoryFilter=ys(u.directoryFilter);const r=u.lstat?Fs:wD;$D?this._stat=i=>r(i,{bigint:!0}):this._stat=r,this._maxDepth=u.depth,this._wantsDir=[ms,Xe,Qe].includes(n),this._wantsFile=[Wt,Xe,Qe].includes(n),this._wantsEverything=n===Qe,this._root=Re.resolve(s),this._isDirent="Dirent"in we&&!u.alwaysStat,this._statsProp=this._isDirent?"dirent":"stats",this._rdOptions={encoding:"utf8",withFileTypes:this._isDirent},this.parents=[this._exploreDir(s,1)],this.reading=!1,this.parent=void 0}async _read(e){if(!this.reading){this.reading=!0;try{for(;!this.destroyed&&e>0;){const{path:u,depth:s,files:n=[]}=this.parent||{};if(n.length>0){const r=n.splice(0,e).map(i=>this._formatEntry(i,u));for(const i of await Promise.all(r)){if(this.destroyed)return;const D=await this._getEntryType(i);D==="directory"&&this._directoryFilter(i)?(s<=this._maxDepth&&this.parents.push(this._exploreDir(i.fullPath,s+1)),this._wantsDir&&(this.push(i),e--)):(D==="file"||this._includeAsFile(i))&&this._fileFilter(i)&&this._wantsFile&&(this.push(i),e--)}}else{const r=this.parents.pop();if(!r){this.push(null);break}if(this.parent=await r,this.destroyed)return}}}catch(u){this.destroy(u)}finally{this.reading=!1}}}async _exploreDir(e,u){let s;try{s=await yD(e,this._rdOptions)}catch(n){this._onError(n)}return{files:s,depth:u,path:e}}async _formatEntry(e,u){let s;try{const n=this._isDirent?e.name:e,r=Re.resolve(Re.join(u,n));s={path:Re.relative(this._root,r),fullPath:r,basename:n},s[this._statsProp]=this._isDirent?e:await this._stat(r)}catch(n){this._onError(n)}return s}_onError(e){SD(e)&&!this.destroyed?this.emit("warn",e):this.destroy(e)}async _getEntryType(e){const u=e&&e[this._statsProp];if(u){if(u.isFile())return"file";if(u.isDirectory())return"directory";if(u&&u.isSymbolicLink()){const s=e.fullPath;try{const n=await RD(s),r=await Fs(n);if(r.isFile())return"file";if(r.isDirectory()){const i=n.length;if(s.startsWith(n)&&s.substr(i,1)===Re.sep){const D=new Error(`Circular symlink detected: "${s}" points to "${n}"`);return D.code=gs,this._onError(D)}return"directory"}}catch(n){this._onError(n)}}}}_includeAsFile(e){const u=e&&e[this._statsProp];return u&&this._wantsEverything&&!u.isDirectory()}}const Ee=a((t,e={})=>{let u=e.entryType||e.type;if(u==="both"&&(u=Xe),u&&(e.type=u),t){if(typeof t!="string")throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");if(u&&!_s.includes(u))throw new Error(`readdirp: Invalid type passed. Use one of ${_s.join(", ")}`)}else throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");return e.root=t,new ot(e)},"readdirp$1"),TD=a((t,e={})=>new Promise((u,s)=>{const n=[];Ee(t,e).on("data",r=>n.push(r)).on("end",()=>u(n)).on("error",r=>s(r))}),"readdirpPromise");Ee.promise=TD,Ee.ReaddirpStream=ot,Ee.default=Ee;var xD=Ee,jt={exports:{}};/*!
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */var ws=a(function(t,e){if(typeof t!="string")throw new TypeError("expected path to be a string");if(t==="\\"||t==="/")return"/";var u=t.length;if(u<=1)return t;var s="";if(u>4&&t[3]==="\\"){var n=t[2];(n==="?"||n===".")&&t.slice(0,2)==="\\\\"&&(t=t.slice(2),s="//")}var r=t.split(/[/\\]+/);return e!==!1&&r[r.length-1]===""&&r.pop(),s+r.join("/")},"normalizePath$2"),OD=jt.exports;Object.defineProperty(OD,"__esModule",{value:!0});const Rs=Cs,ND=ws,bs="!",HD={returnIndex:!1},PD=a(t=>Array.isArray(t)?t:[t],"arrify$1"),LD=a((t,e)=>{if(typeof t=="function")return t;if(typeof t=="string"){const u=Rs(t,e);return s=>t===s||u(s)}return t instanceof RegExp?u=>t.test(u):u=>!1},"createPattern"),vs=a((t,e,u,s)=>{const n=Array.isArray(u),r=n?u[0]:u;if(!n&&typeof r!="string")throw new TypeError("anymatch: second argument must be a string: got "+Object.prototype.toString.call(r));const i=ND(r,!1);for(let o=0;o<e.length;o++){const c=e[o];if(c(i))return s?-1:!1}const D=n&&[i].concat(u.slice(1));for(let o=0;o<t.length;o++){const c=t[o];if(n?c(...D):c(i))return s?o:!0}return s?-1:!1},"matchPatterns"),Ut=a((t,e,u=HD)=>{if(t==null)throw new TypeError("anymatch: specify first argument");const s=typeof u=="boolean"?{returnIndex:u}:u,n=s.returnIndex||!1,r=PD(t),i=r.filter(o=>typeof o=="string"&&o.charAt(0)===bs).map(o=>o.slice(1)).map(o=>Rs(o,s)),D=r.filter(o=>typeof o!="string"||typeof o=="string"&&o.charAt(0)!==bs).map(o=>LD(o,s));return e==null?(o,c=!1)=>vs(D,i,o,typeof c=="boolean"?c:!1):vs(D,i,e,n)},"anymatch$1");Ut.default=Ut,jt.exports=Ut;var ID=jt.exports;/*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */var kD=a(function(e){if(typeof e!="string"||e==="")return!1;for(var u;u=/(\\).|([@?!+*]\(.*\))/g.exec(e);){if(u[2])return!0;e=e.slice(u.index+u[0].length)}return!1},"isExtglob");/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */var MD=kD,Ss={"{":"}","(":")","[":"]"},GD=a(function(t){if(t[0]==="!")return!0;for(var e=0,u=-2,s=-2,n=-2,r=-2,i=-2;e<t.length;){if(t[e]==="*"||t[e+1]==="?"&&/[\].+)]/.test(t[e])||s!==-1&&t[e]==="["&&t[e+1]!=="]"&&(s<e&&(s=t.indexOf("]",e)),s>e&&(i===-1||i>s||(i=t.indexOf("\\",e),i===-1||i>s)))||n!==-1&&t[e]==="{"&&t[e+1]!=="}"&&(n=t.indexOf("}",e),n>e&&(i=t.indexOf("\\",e),i===-1||i>n))||r!==-1&&t[e]==="("&&t[e+1]==="?"&&/[:!=]/.test(t[e+2])&&t[e+3]!==")"&&(r=t.indexOf(")",e),r>e&&(i=t.indexOf("\\",e),i===-1||i>r))||u!==-1&&t[e]==="("&&t[e+1]!=="|"&&(u<e&&(u=t.indexOf("|",e)),u!==-1&&t[u+1]!==")"&&(r=t.indexOf(")",u),r>u&&(i=t.indexOf("\\",u),i===-1||i>r))))return!0;if(t[e]==="\\"){var D=t[e+1];e+=2;var o=Ss[D];if(o){var c=t.indexOf(o,e);c!==-1&&(e=c+1)}if(t[e]==="!")return!0}else e++}return!1},"strictCheck"),WD=a(function(t){if(t[0]==="!")return!0;for(var e=0;e<t.length;){if(/[*?{}()[\]]/.test(t[e]))return!0;if(t[e]==="\\"){var u=t[e+1];e+=2;var s=Ss[u];if(s){var n=t.indexOf(s,e);n!==-1&&(e=n+1)}if(t[e]==="!")return!0}else e++}return!1},"relaxedCheck"),Bs=a(function(e,u){if(typeof e!="string"||e==="")return!1;if(MD(e))return!0;var s=GD;return u&&u.strict===!1&&(s=WD),s(e)},"isGlob"),jD=Bs,UD=z.posix.dirname,KD=_u.platform()==="win32",Kt="/",VD=/\\/g,zD=/[\{\[].*[\}\]]$/,YD=/(^|[^\\])([\{\[]|\([^\)]+$)/,qD=/\\([\!\*\?\|\[\]\(\)\{\}])/g,XD=a(function(e,u){var s=Object.assign({flipBackslashes:!0},u);s.flipBackslashes&&KD&&e.indexOf(Kt)<0&&(e=e.replace(VD,Kt)),zD.test(e)&&(e+=Kt),e+="a";do e=UD(e);while(jD(e)||YD.test(e));return e.replace(qD,"$1")},"globParent"),Ze={};(function(t){t.isInteger=e=>typeof e=="number"?Number.isInteger(e):typeof e=="string"&&e.trim()!==""?Number.isInteger(Number(e)):!1,t.find=(e,u)=>e.nodes.find(s=>s.type===u),t.exceedsLimit=(e,u,s=1,n)=>n===!1||!t.isInteger(e)||!t.isInteger(u)?!1:(Number(u)-Number(e))/Number(s)>=n,t.escapeNode=(e,u=0,s)=>{let n=e.nodes[u];n&&(s&&n.type===s||n.type==="open"||n.type==="close")&&n.escaped!==!0&&(n.value="\\"+n.value,n.escaped=!0)},t.encloseBrace=e=>e.type!=="brace"||e.commas>>0+e.ranges>>0?!1:(e.invalid=!0,!0),t.isInvalidBrace=e=>e.type!=="brace"?!1:e.invalid===!0||e.dollar?!0:!(e.commas>>0+e.ranges>>0)||e.open!==!0||e.close!==!0?(e.invalid=!0,!0):!1,t.isOpenOrClose=e=>e.type==="open"||e.type==="close"?!0:e.open===!0||e.close===!0,t.reduce=e=>e.reduce((u,s)=>(s.type==="text"&&u.push(s.value),s.type==="range"&&(s.type="text"),u),[]),t.flatten=(...e)=>{const u=[],s=a(n=>{for(let r=0;r<n.length;r++){let i=n[r];Array.isArray(i)?s(i):i!==void 0&&u.push(i)}return u},"flat");return s(e),u}})(Ze);const $s=Ze;var Vt=a((t,e={})=>{let u=a((s,n={})=>{let r=e.escapeInvalid&&$s.isInvalidBrace(n),i=s.invalid===!0&&e.escapeInvalid===!0,D="";if(s.value)return(r||i)&&$s.isOpenOrClose(s)?"\\"+s.value:s.value;if(s.value)return s.value;if(s.nodes)for(let o of s.nodes)D+=u(o);return D},"stringify");return u(t)},"stringify$4");/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */var QD=a(function(t){return typeof t=="number"?t-t===0:typeof t=="string"&&t.trim()!==""?Number.isFinite?Number.isFinite(+t):isFinite(+t):!1},"isNumber$2");/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */const Ts=QD,ae=a((t,e,u)=>{if(Ts(t)===!1)throw new TypeError("toRegexRange: expected the first argument to be a number");if(e===void 0||t===e)return String(t);if(Ts(e)===!1)throw new TypeError("toRegexRange: expected the second argument to be a number.");let s={relaxZeros:!0,...u};typeof s.strictZeros=="boolean"&&(s.relaxZeros=s.strictZeros===!1);let n=String(s.relaxZeros),r=String(s.shorthand),i=String(s.capture),D=String(s.wrap),o=t+":"+e+"="+n+r+i+D;if(ae.cache.hasOwnProperty(o))return ae.cache[o].result;let c=Math.min(t,e),f=Math.max(t,e);if(Math.abs(c-f)===1){let g=t+"|"+e;return s.capture?`(${g})`:s.wrap===!1?g:`(?:${g})`}let h=Ls(t)||Ls(e),l={min:t,max:e,a:c,b:f},p=[],C=[];if(h&&(l.isPadded=h,l.maxLen=String(l.max).length),c<0){let g=f<0?Math.abs(f):1;C=xs(g,Math.abs(c),l,s),c=l.a=0}return f>=0&&(p=xs(c,f,l,s)),l.negatives=C,l.positives=p,l.result=ZD(C,p),s.capture===!0?l.result=`(${l.result})`:s.wrap!==!1&&p.length+C.length>1&&(l.result=`(?:${l.result})`),ae.cache[o]=l,l.result},"toRegexRange$1");function ZD(t,e,u){let s=zt(t,e,"-",!1)||[],n=zt(e,t,"",!1)||[],r=zt(t,e,"-?",!0)||[];return s.concat(r).concat(n).join("|")}a(ZD,"collatePatterns");function JD(t,e){let u=1,s=1,n=Ns(t,u),r=new Set([e]);for(;t<=n&&n<=e;)r.add(n),u+=1,n=Ns(t,u);for(n=Hs(e+1,s)-1;t<n&&n<=e;)r.add(n),s+=1,n=Hs(e+1,s)-1;return r=[...r],r.sort(uo),r}a(JD,"splitToRanges");function eo(t,e,u){if(t===e)return{pattern:t,count:[],digits:0};let s=to(t,e),n=s.length,r="",i=0;for(let D=0;D<n;D++){let[o,c]=s[D];o===c?r+=o:o!=="0"||c!=="9"?r+=so(o,c):i++}return i&&(r+=u.shorthand===!0?"\\d":"[0-9]"),{pattern:r,count:[i],digits:n}}a(eo,"rangeToPattern");function xs(t,e,u,s){let n=JD(t,e),r=[],i=t,D;for(let o=0;o<n.length;o++){let c=n[o],f=eo(String(i),String(c),s),h="";if(!u.isPadded&&D&&D.pattern===f.pattern){D.count.length>1&&D.count.pop(),D.count.push(f.count[0]),D.string=D.pattern+Ps(D.count),i=c+1;continue}u.isPadded&&(h=no(c,u,s)),f.string=h+f.pattern+Ps(f.count),r.push(f),i=c+1,D=f}return r}a(xs,"splitToPatterns");function zt(t,e,u,s,n){let r=[];for(let i of t){let{string:D}=i;!s&&!Os(e,"string",D)&&r.push(u+D),s&&Os(e,"string",D)&&r.push(u+D)}return r}a(zt,"filterPatterns");function to(t,e){let u=[];for(let s=0;s<t.length;s++)u.push([t[s],e[s]]);return u}a(to,"zip");function uo(t,e){return t>e?1:e>t?-1:0}a(uo,"compare");function Os(t,e,u){return t.some(s=>s[e]===u)}a(Os,"contains");function Ns(t,e){return Number(String(t).slice(0,-e)+"9".repeat(e))}a(Ns,"countNines");function Hs(t,e){return t-t%Math.pow(10,e)}a(Hs,"countZeros");function Ps(t){let[e=0,u=""]=t;return u||e>1?`{${e+(u?","+u:"")}}`:""}a(Ps,"toQuantifier");function so(t,e,u){return`[${t}${e-t===1?"":"-"}${e}]`}a(so,"toCharacterClass");function Ls(t){return/^-?(0+)\d/.test(t)}a(Ls,"hasPadding");function no(t,e,u){if(!e.isPadded)return t;let s=Math.abs(e.maxLen-String(t).length),n=u.relaxZeros!==!1;switch(s){case 0:return"";case 1:return n?"0?":"0";case 2:return n?"0{0,2}":"00";default:return n?`0{0,${s}}`:`0{${s}}`}}a(no,"padZeros"),ae.cache={},ae.clearCache=()=>ae.cache={};var ro=ae;/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */const io=ge,Is=ro,ks=a(t=>t!==null&&typeof t=="object"&&!Array.isArray(t),"isObject"),Do=a(t=>e=>t===!0?Number(e):String(e),"transform"),Yt=a(t=>typeof t=="number"||typeof t=="string"&&t!=="","isValidValue"),be=a(t=>Number.isInteger(+t),"isNumber"),qt=a(t=>{let e=`${t}`,u=-1;if(e[0]==="-"&&(e=e.slice(1)),e==="0")return!1;for(;e[++u]==="0";);return u>0},"zeros"),oo=a((t,e,u)=>typeof t=="string"||typeof e=="string"?!0:u.stringify===!0,"stringify$3"),ao=a((t,e,u)=>{if(e>0){let s=t[0]==="-"?"-":"";s&&(t=t.slice(1)),t=s+t.padStart(s?e-1:e,"0")}return u===!1?String(t):t},"pad"),Ms=a((t,e)=>{let u=t[0]==="-"?"-":"";for(u&&(t=t.slice(1),e--);t.length<e;)t="0"+t;return u?"-"+t:t},"toMaxLen"),lo=a((t,e)=>{t.negatives.sort((i,D)=>i<D?-1:i>D?1:0),t.positives.sort((i,D)=>i<D?-1:i>D?1:0);let u=e.capture?"":"?:",s="",n="",r;return t.positives.length&&(s=t.positives.join("|")),t.negatives.length&&(n=`-(${u}${t.negatives.join("|")})`),s&&n?r=`${s}|${n}`:r=s||n,e.wrap?`(${u}${r})`:r},"toSequence"),Gs=a((t,e,u,s)=>{if(u)return Is(t,e,{wrap:!1,...s});let n=String.fromCharCode(t);if(t===e)return n;let r=String.fromCharCode(e);return`[${n}-${r}]`},"toRange"),Ws=a((t,e,u)=>{if(Array.isArray(t)){let s=u.wrap===!0,n=u.capture?"":"?:";return s?`(${n}${t.join("|")})`:t.join("|")}return Is(t,e,u)},"toRegex"),js=a((...t)=>new RangeError("Invalid range arguments: "+io.inspect(...t)),"rangeError"),Us=a((t,e,u)=>{if(u.strictRanges===!0)throw js([t,e]);return[]},"invalidRange"),co=a((t,e)=>{if(e.strictRanges===!0)throw new TypeError(`Expected step "${t}" to be a number`);return[]},"invalidStep"),fo=a((t,e,u=1,s={})=>{let n=Number(t),r=Number(e);if(!Number.isInteger(n)||!Number.isInteger(r)){if(s.strictRanges===!0)throw js([t,e]);return[]}n===0&&(n=0),r===0&&(r=0);let i=n>r,D=String(t),o=String(e),c=String(u);u=Math.max(Math.abs(u),1);let f=qt(D)||qt(o)||qt(c),h=f?Math.max(D.length,o.length,c.length):0,l=f===!1&&oo(t,e,s)===!1,p=s.transform||Do(l);if(s.toRegex&&u===1)return Gs(Ms(t,h),Ms(e,h),!0,s);let C={negatives:[],positives:[]},g=a(H=>C[H<0?"negatives":"positives"].push(Math.abs(H)),"push"),y=[],B=0;for(;i?n>=r:n<=r;)s.toRegex===!0&&u>1?g(n):y.push(ao(p(n,B),h,l)),n=i?n-u:n+u,B++;return s.toRegex===!0?u>1?lo(C,s):Ws(y,null,{wrap:!1,...s}):y},"fillNumbers"),ho=a((t,e,u=1,s={})=>{if(!be(t)&&t.length>1||!be(e)&&e.length>1)return Us(t,e,s);let n=s.transform||(l=>String.fromCharCode(l)),r=`${t}`.charCodeAt(0),i=`${e}`.charCodeAt(0),D=r>i,o=Math.min(r,i),c=Math.max(r,i);if(s.toRegex&&u===1)return Gs(o,c,!1,s);let f=[],h=0;for(;D?r>=i:r<=i;)f.push(n(r,h)),r=D?r-u:r+u,h++;return s.toRegex===!0?Ws(f,null,{wrap:!1,options:s}):f},"fillLetters"),Je=a((t,e,u,s={})=>{if(e==null&&Yt(t))return[t];if(!Yt(t)||!Yt(e))return Us(t,e,s);if(typeof u=="function")return Je(t,e,1,{transform:u});if(ks(u))return Je(t,e,0,u);let n={...s};return n.capture===!0&&(n.wrap=!0),u=u||n.step||1,be(u)?be(t)&&be(e)?fo(t,e,u,n):ho(t,e,Math.max(Math.abs(u),1),n):u!=null&&!ks(u)?co(u,n):Je(t,e,1,u)},"fill$2");var Ks=Je;const Eo=Ks,Vs=Ze,po=a((t,e={})=>{let u=a((s,n={})=>{let r=Vs.isInvalidBrace(n),i=s.invalid===!0&&e.escapeInvalid===!0,D=r===!0||i===!0,o=e.escapeInvalid===!0?"\\":"",c="";if(s.isOpen===!0||s.isClose===!0)return o+s.value;if(s.type==="open")return D?o+s.value:"(";if(s.type==="close")return D?o+s.value:")";if(s.type==="comma")return s.prev.type==="comma"?"":D?s.value:"|";if(s.value)return s.value;if(s.nodes&&s.ranges>0){let f=Vs.reduce(s.nodes),h=Eo(...f,{...e,wrap:!1,toRegex:!0});if(h.length!==0)return f.length>1&&h.length>1?`(${h})`:h}if(s.nodes)for(let f of s.nodes)c+=u(f,s);return c},"walk");return u(t)},"compile$1");var Co=po;const Fo=Ks,zs=Vt,pe=Ze,le=a((t="",e="",u=!1)=>{let s=[];if(t=[].concat(t),e=[].concat(e),!e.length)return t;if(!t.length)return u?pe.flatten(e).map(n=>`{${n}}`):e;for(let n of t)if(Array.isArray(n))for(let r of n)s.push(le(r,e,u));else for(let r of e)u===!0&&typeof r=="string"&&(r=`{${r}}`),s.push(Array.isArray(r)?le(n,r,u):n+r);return pe.flatten(s)},"append"),go=a((t,e={})=>{let u=e.rangeLimit===void 0?1e3:e.rangeLimit,s=a((n,r={})=>{n.queue=[];let i=r,D=r.queue;for(;i.type!=="brace"&&i.type!=="root"&&i.parent;)i=i.parent,D=i.queue;if(n.invalid||n.dollar){D.push(le(D.pop(),zs(n,e)));return}if(n.type==="brace"&&n.invalid!==!0&&n.nodes.length===2){D.push(le(D.pop(),["{}"]));return}if(n.nodes&&n.ranges>0){let h=pe.reduce(n.nodes);if(pe.exceedsLimit(...h,e.step,u))throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");let l=Fo(...h,e);l.length===0&&(l=zs(n,e)),D.push(le(D.pop(),l)),n.nodes=[];return}let o=pe.encloseBrace(n),c=n.queue,f=n;for(;f.type!=="brace"&&f.type!=="root"&&f.parent;)f=f.parent,c=f.queue;for(let h=0;h<n.nodes.length;h++){let l=n.nodes[h];if(l.type==="comma"&&n.type==="brace"){h===1&&c.push(""),c.push("");continue}if(l.type==="close"){D.push(le(D.pop(),c,o));continue}if(l.value&&l.type!=="open"){c.push(le(c.pop(),l.value));continue}l.nodes&&s(l,n)}return c},"walk");return pe.flatten(s(t))},"expand$1");var mo=go,_o={MAX_LENGTH:1024*64,CHAR_0:"0",CHAR_9:"9",CHAR_UPPERCASE_A:"A",CHAR_LOWERCASE_A:"a",CHAR_UPPERCASE_Z:"Z",CHAR_LOWERCASE_Z:"z",CHAR_LEFT_PARENTHESES:"(",CHAR_RIGHT_PARENTHESES:")",CHAR_ASTERISK:"*",CHAR_AMPERSAND:"&",CHAR_AT:"@",CHAR_BACKSLASH:"\\",CHAR_BACKTICK:"`",CHAR_CARRIAGE_RETURN:"\r",CHAR_CIRCUMFLEX_ACCENT:"^",CHAR_COLON:":",CHAR_COMMA:",",CHAR_DOLLAR:"$",CHAR_DOT:".",CHAR_DOUBLE_QUOTE:'"',CHAR_EQUAL:"=",CHAR_EXCLAMATION_MARK:"!",CHAR_FORM_FEED:"\f",CHAR_FORWARD_SLASH:"/",CHAR_HASH:"#",CHAR_HYPHEN_MINUS:"-",CHAR_LEFT_ANGLE_BRACKET:"<",CHAR_LEFT_CURLY_BRACE:"{",CHAR_LEFT_SQUARE_BRACKET:"[",CHAR_LINE_FEED:`
+`,CHAR_NO_BREAK_SPACE:"\xA0",CHAR_PERCENT:"%",CHAR_PLUS:"+",CHAR_QUESTION_MARK:"?",CHAR_RIGHT_ANGLE_BRACKET:">",CHAR_RIGHT_CURLY_BRACE:"}",CHAR_RIGHT_SQUARE_BRACKET:"]",CHAR_SEMICOLON:";",CHAR_SINGLE_QUOTE:"'",CHAR_SPACE:" ",CHAR_TAB:"	",CHAR_UNDERSCORE:"_",CHAR_VERTICAL_LINE:"|",CHAR_ZERO_WIDTH_NOBREAK_SPACE:"\uFEFF"};const Ao=Vt,{MAX_LENGTH:Ys,CHAR_BACKSLASH:Xt,CHAR_BACKTICK:yo,CHAR_COMMA:wo,CHAR_DOT:Ro,CHAR_LEFT_PARENTHESES:bo,CHAR_RIGHT_PARENTHESES:vo,CHAR_LEFT_CURLY_BRACE:So,CHAR_RIGHT_CURLY_BRACE:Bo,CHAR_LEFT_SQUARE_BRACKET:qs,CHAR_RIGHT_SQUARE_BRACKET:Xs,CHAR_DOUBLE_QUOTE:$o,CHAR_SINGLE_QUOTE:To,CHAR_NO_BREAK_SPACE:xo,CHAR_ZERO_WIDTH_NOBREAK_SPACE:Oo}=_o,No=a((t,e={})=>{if(typeof t!="string")throw new TypeError("Expected a string");let u=e||{},s=typeof u.maxLength=="number"?Math.min(Ys,u.maxLength):Ys;if(t.length>s)throw new SyntaxError(`Input length (${t.length}), exceeds max characters (${s})`);let n={type:"root",input:t,nodes:[]},r=[n],i=n,D=n,o=0,c=t.length,f=0,h=0,l;const p=a(()=>t[f++],"advance"),C=a(g=>{if(g.type==="text"&&D.type==="dot"&&(D.type="text"),D&&D.type==="text"&&g.type==="text"){D.value+=g.value;return}return i.nodes.push(g),g.parent=i,g.prev=D,D=g,g},"push");for(C({type:"bos"});f<c;)if(i=r[r.length-1],l=p(),!(l===Oo||l===xo)){if(l===Xt){C({type:"text",value:(e.keepEscaping?l:"")+p()});continue}if(l===Xs){C({type:"text",value:"\\"+l});continue}if(l===qs){o++;let g;for(;f<c&&(g=p());){if(l+=g,g===qs){o++;continue}if(g===Xt){l+=p();continue}if(g===Xs&&(o--,o===0))break}C({type:"text",value:l});continue}if(l===bo){i=C({type:"paren",nodes:[]}),r.push(i),C({type:"text",value:l});continue}if(l===vo){if(i.type!=="paren"){C({type:"text",value:l});continue}i=r.pop(),C({type:"text",value:l}),i=r[r.length-1];continue}if(l===$o||l===To||l===yo){let g=l,y;for(e.keepQuotes!==!0&&(l="");f<c&&(y=p());){if(y===Xt){l+=y+p();continue}if(y===g){e.keepQuotes===!0&&(l+=y);break}l+=y}C({type:"text",value:l});continue}if(l===So){h++;let y={type:"brace",open:!0,close:!1,dollar:D.value&&D.value.slice(-1)==="$"||i.dollar===!0,depth:h,commas:0,ranges:0,nodes:[]};i=C(y),r.push(i),C({type:"open",value:l});continue}if(l===Bo){if(i.type!=="brace"){C({type:"text",value:l});continue}let g="close";i=r.pop(),i.close=!0,C({type:g,value:l}),h--,i=r[r.length-1];continue}if(l===wo&&h>0){if(i.ranges>0){i.ranges=0;let g=i.nodes.shift();i.nodes=[g,{type:"text",value:Ao(i)}]}C({type:"comma",value:l}),i.commas++;continue}if(l===Ro&&h>0&&i.commas===0){let g=i.nodes;if(h===0||g.length===0){C({type:"text",value:l});continue}if(D.type==="dot"){if(i.range=[],D.value+=l,D.type="range",i.nodes.length!==3&&i.nodes.length!==5){i.invalid=!0,i.ranges=0,D.type="text";continue}i.ranges++,i.args=[];continue}if(D.type==="range"){g.pop();let y=g[g.length-1];y.value+=D.value+l,D=y,i.ranges--;continue}C({type:"dot",value:l});continue}C({type:"text",value:l})}do if(i=r.pop(),i.type!=="root"){i.nodes.forEach(B=>{B.nodes||(B.type==="open"&&(B.isOpen=!0),B.type==="close"&&(B.isClose=!0),B.nodes||(B.type="text"),B.invalid=!0)});let g=r[r.length-1],y=g.nodes.indexOf(i);g.nodes.splice(y,1,...i.nodes)}while(r.length>0);return C({type:"eos"}),n},"parse$1");var Ho=No;const Qs=Vt,Po=Co,Lo=mo,Io=Ho,q=a((t,e={})=>{let u=[];if(Array.isArray(t))for(let s of t){let n=q.create(s,e);Array.isArray(n)?u.push(...n):u.push(n)}else u=[].concat(q.create(t,e));return e&&e.expand===!0&&e.nodupes===!0&&(u=[...new Set(u)]),u},"braces$1");q.parse=(t,e={})=>Io(t,e),q.stringify=(t,e={})=>Qs(typeof t=="string"?q.parse(t,e):t,e),q.compile=(t,e={})=>(typeof t=="string"&&(t=q.parse(t,e)),Po(t,e)),q.expand=(t,e={})=>{typeof t=="string"&&(t=q.parse(t,e));let u=Lo(t,e);return e.noempty===!0&&(u=u.filter(Boolean)),e.nodupes===!0&&(u=[...new Set(u)]),u},q.create=(t,e={})=>t===""||t.length<3?[t]:e.expand!==!0?q.compile(t,e):q.expand(t,e);var ko=q,Mo=["3dm","3ds","3g2","3gp","7z","a","aac","adp","afdesign","afphoto","afpub","ai","aif","aiff","alz","ape","apk","appimage","ar","arj","asf","au","avi","bak","baml","bh","bin","bk","bmp","btif","bz2","bzip2","cab","caf","cgm","class","cmx","cpio","cr2","cur","dat","dcm","deb","dex","djvu","dll","dmg","dng","doc","docm","docx","dot","dotm","dra","DS_Store","dsk","dts","dtshd","dvb","dwg","dxf","ecelp4800","ecelp7470","ecelp9600","egg","eol","eot","epub","exe","f4v","fbs","fh","fla","flac","flatpak","fli","flv","fpx","fst","fvt","g3","gh","gif","graffle","gz","gzip","h261","h263","h264","icns","ico","ief","img","ipa","iso","jar","jpeg","jpg","jpgv","jpm","jxr","key","ktx","lha","lib","lvp","lz","lzh","lzma","lzo","m3u","m4a","m4v","mar","mdi","mht","mid","midi","mj2","mka","mkv","mmr","mng","mobi","mov","movie","mp3","mp4","mp4a","mpeg","mpg","mpga","mxu","nef","npx","numbers","nupkg","o","odp","ods","odt","oga","ogg","ogv","otf","ott","pages","pbm","pcx","pdb","pdf","pea","pgm","pic","png","pnm","pot","potm","potx","ppa","ppam","ppm","pps","ppsm","ppsx","ppt","pptm","pptx","psd","pya","pyc","pyo","pyv","qt","rar","ras","raw","resources","rgb","rip","rlc","rmf","rmvb","rpm","rtf","rz","s3m","s7z","scpt","sgi","shar","snap","sil","sketch","slk","smv","snk","so","stl","suo","sub","swf","tar","tbz","tbz2","tga","tgz","thmx","tif","tiff","tlz","ttc","ttf","txz","udf","uvh","uvi","uvm","uvp","uvs","uvu","viv","vob","war","wav","wax","wbmp","wdp","weba","webm","webp","whl","wim","wm","wma","wmv","wmx","woff","woff2","wrm","wvx","xbm","xif","xla","xlam","xls","xlsb","xlsm","xlsx","xlt","xltm","xltx","xm","xmind","xpi","xpm","xwd","xz","z","zip","zipx"],Go=Mo;const Wo=z,jo=Go,Uo=new Set(jo);var Ko=a(t=>Uo.has(Wo.extname(t).slice(1).toLowerCase()),"isBinaryPath$1"),et={};(function(t){const{sep:e}=z,{platform:u}=process,s=_u;t.EV_ALL="all",t.EV_READY="ready",t.EV_ADD="add",t.EV_CHANGE="change",t.EV_ADD_DIR="addDir",t.EV_UNLINK="unlink",t.EV_UNLINK_DIR="unlinkDir",t.EV_RAW="raw",t.EV_ERROR="error",t.STR_DATA="data",t.STR_END="end",t.STR_CLOSE="close",t.FSEVENT_CREATED="created",t.FSEVENT_MODIFIED="modified",t.FSEVENT_DELETED="deleted",t.FSEVENT_MOVED="moved",t.FSEVENT_CLONED="cloned",t.FSEVENT_UNKNOWN="unknown",t.FSEVENT_FLAG_MUST_SCAN_SUBDIRS=1,t.FSEVENT_TYPE_FILE="file",t.FSEVENT_TYPE_DIRECTORY="directory",t.FSEVENT_TYPE_SYMLINK="symlink",t.KEY_LISTENERS="listeners",t.KEY_ERR="errHandlers",t.KEY_RAW="rawEmitters",t.HANDLER_KEYS=[t.KEY_LISTENERS,t.KEY_ERR,t.KEY_RAW],t.DOT_SLASH=`.${e}`,t.BACK_SLASH_RE=/\\/g,t.DOUBLE_SLASH_RE=/\/\//,t.SLASH_OR_BACK_SLASH_RE=/[/\\]/,t.DOT_RE=/\..*\.(sw[px])$|~$|\.subl.*\.tmp/,t.REPLACER_RE=/^\.[/\\]/,t.SLASH="/",t.SLASH_SLASH="//",t.BRACE_START="{",t.BANG="!",t.ONE_DOT=".",t.TWO_DOTS="..",t.STAR="*",t.GLOBSTAR="**",t.ROOT_GLOBSTAR="/**/*",t.SLASH_GLOBSTAR="/**",t.DIR_SUFFIX="Dir",t.ANYMATCH_OPTS={dot:!0},t.STRING_TYPE="string",t.FUNCTION_TYPE="function",t.EMPTY_STR="",t.EMPTY_FN=()=>{},t.IDENTITY_FN=n=>n,t.isWindows=u==="win32",t.isMacos=u==="darwin",t.isLinux=u==="linux",t.isIBMi=s.type()==="OS400"})(et);const se=De,I=z,{promisify:ve}=ge,Vo=Ko,{isWindows:zo,isLinux:Yo,EMPTY_FN:qo,EMPTY_STR:Xo,KEY_LISTENERS:Ce,KEY_ERR:Qt,KEY_RAW:Se,HANDLER_KEYS:Qo,EV_CHANGE:tt,EV_ADD:ut,EV_ADD_DIR:Zo,EV_ERROR:Zs,STR_DATA:Jo,STR_END:ea,BRACE_START:ta,STAR:ua}=et,sa="watch",na=ve(se.open),Js=ve(se.stat),ra=ve(se.lstat),ia=ve(se.close),Zt=ve(se.realpath),Da={lstat:ra,stat:Js},Jt=a((t,e)=>{t instanceof Set?t.forEach(e):e(t)},"foreach"),Be=a((t,e,u)=>{let s=t[e];s instanceof Set||(t[e]=s=new Set([s])),s.add(u)},"addAndConvert"),oa=a(t=>e=>{const u=t[e];u instanceof Set?u.clear():delete t[e]},"clearItem"),$e=a((t,e,u)=>{const s=t[e];s instanceof Set?s.delete(u):s===u&&delete t[e]},"delFromSet"),en=a(t=>t instanceof Set?t.size===0:!t,"isEmptySet"),st=new Map;function tn(t,e,u,s,n){const r=a((i,D)=>{u(t),n(i,D,{watchedPath:t}),D&&t!==D&&nt(I.resolve(t,D),Ce,I.join(t,D))},"handleEvent");try{return se.watch(t,e,r)}catch(i){s(i)}}a(tn,"createFsWatchInstance");const nt=a((t,e,u,s,n)=>{const r=st.get(t);r&&Jt(r[e],i=>{i(u,s,n)})},"fsWatchBroadcast"),aa=a((t,e,u,s)=>{const{listener:n,errHandler:r,rawEmitter:i}=s;let D=st.get(e),o;if(!u.persistent)return o=tn(t,u,n,r,i),o.close.bind(o);if(D)Be(D,Ce,n),Be(D,Qt,r),Be(D,Se,i);else{if(o=tn(t,u,nt.bind(null,e,Ce),r,nt.bind(null,e,Se)),!o)return;o.on(Zs,async c=>{const f=nt.bind(null,e,Qt);if(D.watcherUnusable=!0,zo&&c.code==="EPERM")try{const h=await na(t,"r");await ia(h),f(c)}catch{}else f(c)}),D={listeners:n,errHandlers:r,rawEmitters:i,watcher:o},st.set(e,D)}return()=>{$e(D,Ce,n),$e(D,Qt,r),$e(D,Se,i),en(D.listeners)&&(D.watcher.close(),st.delete(e),Qo.forEach(oa(D)),D.watcher=void 0,Object.freeze(D))}},"setFsWatchListener"),eu=new Map,la=a((t,e,u,s)=>{const{listener:n,rawEmitter:r}=s;let i=eu.get(e);const D=i&&i.options;return D&&(D.persistent<u.persistent||D.interval>u.interval)&&(i.listeners,i.rawEmitters,se.unwatchFile(e),i=void 0),i?(Be(i,Ce,n),Be(i,Se,r)):(i={listeners:n,rawEmitters:r,options:u,watcher:se.watchFile(e,u,(o,c)=>{Jt(i.rawEmitters,h=>{h(tt,e,{curr:o,prev:c})});const f=o.mtimeMs;(o.size!==c.size||f>c.mtimeMs||f===0)&&Jt(i.listeners,h=>h(t,o))})},eu.set(e,i)),()=>{$e(i,Ce,n),$e(i,Se,r),en(i.listeners)&&(eu.delete(e),se.unwatchFile(e),i.options=i.watcher=void 0,Object.freeze(i))}},"setFsWatchFileListener");let ca=class{static{a(this,"NodeFsHandler")}constructor(e){this.fsw=e,this._boundHandleError=u=>e._handleError(u)}_watchWithNodeFs(e,u){const s=this.fsw.options,n=I.dirname(e),r=I.basename(e);this.fsw._getWatchedDir(n).add(r);const D=I.resolve(e),o={persistent:s.persistent};u||(u=qo);let c;return s.usePolling?(o.interval=s.enableBinaryInterval&&Vo(r)?s.binaryInterval:s.interval,c=la(e,D,o,{listener:u,rawEmitter:this.fsw._emitRaw})):c=aa(e,D,o,{listener:u,errHandler:this._boundHandleError,rawEmitter:this.fsw._emitRaw}),c}_handleFile(e,u,s){if(this.fsw.closed)return;const n=I.dirname(e),r=I.basename(e),i=this.fsw._getWatchedDir(n);let D=u;if(i.has(r))return;const o=a(async(f,h)=>{if(this.fsw._throttle(sa,e,5)){if(!h||h.mtimeMs===0)try{const l=await Js(e);if(this.fsw.closed)return;const p=l.atimeMs,C=l.mtimeMs;(!p||p<=C||C!==D.mtimeMs)&&this.fsw._emit(tt,e,l),Yo&&D.ino!==l.ino?(this.fsw._closeFile(f),D=l,this.fsw._addPathCloser(f,this._watchWithNodeFs(e,o))):D=l}catch{this.fsw._remove(n,r)}else if(i.has(r)){const l=h.atimeMs,p=h.mtimeMs;(!l||l<=p||p!==D.mtimeMs)&&this.fsw._emit(tt,e,h),D=h}}},"listener"),c=this._watchWithNodeFs(e,o);if(!(s&&this.fsw.options.ignoreInitial)&&this.fsw._isntIgnored(e)){if(!this.fsw._throttle(ut,e,0))return;this.fsw._emit(ut,e,u)}return c}async _handleSymlink(e,u,s,n){if(this.fsw.closed)return;const r=e.fullPath,i=this.fsw._getWatchedDir(u);if(!this.fsw.options.followSymlinks){this.fsw._incrReadyCount();let D;try{D=await Zt(s)}catch{return this.fsw._emitReady(),!0}return this.fsw.closed?void 0:(i.has(n)?this.fsw._symlinkPaths.get(r)!==D&&(this.fsw._symlinkPaths.set(r,D),this.fsw._emit(tt,s,e.stats)):(i.add(n),this.fsw._symlinkPaths.set(r,D),this.fsw._emit(ut,s,e.stats)),this.fsw._emitReady(),!0)}if(this.fsw._symlinkPaths.has(r))return!0;this.fsw._symlinkPaths.set(r,!0)}_handleRead(e,u,s,n,r,i,D){if(e=I.join(e,Xo),!s.hasGlob&&(D=this.fsw._throttle("readdir",e,1e3),!D))return;const o=this.fsw._getWatchedDir(s.path),c=new Set;let f=this.fsw._readdirp(e,{fileFilter:a(h=>s.filterPath(h),"fileFilter"),directoryFilter:a(h=>s.filterDir(h),"directoryFilter"),depth:0}).on(Jo,async h=>{if(this.fsw.closed){f=void 0;return}const l=h.path;let p=I.join(e,l);if(c.add(l),!(h.stats.isSymbolicLink()&&await this._handleSymlink(h,e,p,l))){if(this.fsw.closed){f=void 0;return}(l===n||!n&&!o.has(l))&&(this.fsw._incrReadyCount(),p=I.join(r,I.relative(r,p)),this._addToNodeFs(p,u,s,i+1))}}).on(Zs,this._boundHandleError);return new Promise(h=>f.once(ea,()=>{if(this.fsw.closed){f=void 0;return}const l=D?D.clear():!1;h(),o.getChildren().filter(p=>p!==e&&!c.has(p)&&(!s.hasGlob||s.filterPath({fullPath:I.resolve(e,p)}))).forEach(p=>{this.fsw._remove(e,p)}),f=void 0,l&&this._handleRead(e,!1,s,n,r,i,D)}))}async _handleDir(e,u,s,n,r,i,D){const o=this.fsw._getWatchedDir(I.dirname(e)),c=o.has(I.basename(e));!(s&&this.fsw.options.ignoreInitial)&&!r&&!c&&(!i.hasGlob||i.globFilter(e))&&this.fsw._emit(Zo,e,u),o.add(I.basename(e)),this.fsw._getWatchedDir(e);let f,h;const l=this.fsw.options.depth;if((l==null||n<=l)&&!this.fsw._symlinkPaths.has(D)){if(!r&&(await this._handleRead(e,s,i,r,e,n,f),this.fsw.closed))return;h=this._watchWithNodeFs(e,(p,C)=>{C&&C.mtimeMs===0||this._handleRead(p,!1,i,r,e,n,f)})}return h}async _addToNodeFs(e,u,s,n,r){const i=this.fsw._emitReady;if(this.fsw._isIgnored(e)||this.fsw.closed)return i(),!1;const D=this.fsw._getWatchHelpers(e,n);!D.hasGlob&&s&&(D.hasGlob=s.hasGlob,D.globFilter=s.globFilter,D.filterPath=o=>s.filterPath(o),D.filterDir=o=>s.filterDir(o));try{const o=await Da[D.statMethod](D.watchPath);if(this.fsw.closed)return;if(this.fsw._isIgnored(D.watchPath,o))return i(),!1;const c=this.fsw.options.followSymlinks&&!e.includes(ua)&&!e.includes(ta);let f;if(o.isDirectory()){const h=I.resolve(e),l=c?await Zt(e):e;if(this.fsw.closed||(f=await this._handleDir(D.watchPath,o,u,n,r,D,l),this.fsw.closed))return;h!==l&&l!==void 0&&this.fsw._symlinkPaths.set(h,l)}else if(o.isSymbolicLink()){const h=c?await Zt(e):e;if(this.fsw.closed)return;const l=I.dirname(D.watchPath);if(this.fsw._getWatchedDir(l).add(D.watchPath),this.fsw._emit(ut,D.watchPath,o),f=await this._handleDir(l,o,u,n,e,D,h),this.fsw.closed)return;h!==void 0&&this.fsw._symlinkPaths.set(I.resolve(e),h)}else f=this._handleFile(D.watchPath,o,u);return i(),this.fsw._addPathCloser(e,f),!1}catch(o){if(this.fsw._handleError(o))return i(),e}}};var fa=ca,tu={exports:{}};const uu=De,k=z,{promisify:su}=ge;let Fe;try{Fe=Ie("fsevents")}catch(t){process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR&&console.error(t)}if(Fe){const t=process.version.match(/v(\d+)\.(\d+)/);if(t&&t[1]&&t[2]){const e=Number.parseInt(t[1],10),u=Number.parseInt(t[2],10);e===8&&u<16&&(Fe=void 0)}}const{EV_ADD:nu,EV_CHANGE:ha,EV_ADD_DIR:un,EV_UNLINK:rt,EV_ERROR:da,STR_DATA:Ea,STR_END:pa,FSEVENT_CREATED:Ca,FSEVENT_MODIFIED:Fa,FSEVENT_DELETED:ga,FSEVENT_MOVED:ma,FSEVENT_UNKNOWN:_a,FSEVENT_FLAG_MUST_SCAN_SUBDIRS:Aa,FSEVENT_TYPE_FILE:ya,FSEVENT_TYPE_DIRECTORY:Te,FSEVENT_TYPE_SYMLINK:sn,ROOT_GLOBSTAR:nn,DIR_SUFFIX:wa,DOT_SLASH:rn,FUNCTION_TYPE:ru,EMPTY_FN:Ra,IDENTITY_FN:ba}=et,va=a(t=>isNaN(t)?{}:{depth:t},"Depth"),iu=su(uu.stat),Sa=su(uu.lstat),Dn=su(uu.realpath),Ba={stat:iu,lstat:Sa},ce=new Map,$a=10,Ta=new Set([69888,70400,71424,72704,73472,131328,131840,262912]),xa=a((t,e)=>({stop:Fe.watch(t,e)}),"createFSEventsInstance");function Oa(t,e,u,s){let n=k.extname(e)?k.dirname(e):e;const r=k.dirname(n);let i=ce.get(n);Na(r)&&(n=r);const D=k.resolve(t),o=D!==e,c=a((h,l,p)=>{o&&(h=h.replace(e,D)),(h===D||!h.indexOf(D+k.sep))&&u(h,l,p)},"filteredListener");let f=!1;for(const h of ce.keys())if(e.indexOf(k.resolve(h)+k.sep)===0){n=h,i=ce.get(n),f=!0;break}return i||f?i.listeners.add(c):(i={listeners:new Set([c]),rawEmitter:s,watcher:xa(n,(h,l)=>{if(!i.listeners.size||l&Aa)return;const p=Fe.getInfo(h,l);i.listeners.forEach(C=>{C(h,l,p)}),i.rawEmitter(p.event,h,p)})},ce.set(n,i)),()=>{const h=i.listeners;if(h.delete(c),!h.size&&(ce.delete(n),i.watcher))return i.watcher.stop().then(()=>{i.rawEmitter=i.watcher=void 0,Object.freeze(i)})}}a(Oa,"setFSEventsListener");const Na=a(t=>{let e=0;for(const u of ce.keys())if(u.indexOf(t)===0&&(e++,e>=$a))return!0;return!1},"couldConsolidate"),Ha=a(()=>Fe&&ce.size<128,"canUse"),Du=a((t,e)=>{let u=0;for(;!t.indexOf(e)&&(t=k.dirname(t))!==e;)u++;return u},"calcDepth"),on=a((t,e)=>t.type===Te&&e.isDirectory()||t.type===sn&&e.isSymbolicLink()||t.type===ya&&e.isFile(),"sameTypes");let Pa=class{static{a(this,"FsEventsHandler")}constructor(e){this.fsw=e}checkIgnored(e,u){const s=this.fsw._ignoredPaths;if(this.fsw._isIgnored(e,u))return s.add(e),u&&u.isDirectory()&&s.add(e+nn),!0;s.delete(e),s.delete(e+nn)}addOrChange(e,u,s,n,r,i,D,o){const c=r.has(i)?ha:nu;this.handleEvent(c,e,u,s,n,r,i,D,o)}async checkExists(e,u,s,n,r,i,D,o){try{const c=await iu(e);if(this.fsw.closed)return;on(D,c)?this.addOrChange(e,u,s,n,r,i,D,o):this.handleEvent(rt,e,u,s,n,r,i,D,o)}catch(c){c.code==="EACCES"?this.addOrChange(e,u,s,n,r,i,D,o):this.handleEvent(rt,e,u,s,n,r,i,D,o)}}handleEvent(e,u,s,n,r,i,D,o,c){if(!(this.fsw.closed||this.checkIgnored(u)))if(e===rt){const f=o.type===Te;(f||i.has(D))&&this.fsw._remove(r,D,f)}else{if(e===nu){if(o.type===Te&&this.fsw._getWatchedDir(u),o.type===sn&&c.followSymlinks){const h=c.depth===void 0?void 0:Du(s,n)+1;return this._addToFsEvents(u,!1,!0,h)}this.fsw._getWatchedDir(r).add(D)}const f=o.type===Te?e+wa:e;this.fsw._emit(f,u),f===un&&this._addToFsEvents(u,!1,!0)}}_watchWithFsEvents(e,u,s,n){if(this.fsw.closed||this.fsw._isIgnored(e))return;const r=this.fsw.options,D=Oa(e,u,a(async(o,c,f)=>{if(this.fsw.closed||r.depth!==void 0&&Du(o,u)>r.depth)return;const h=s(k.join(e,k.relative(e,o)));if(n&&!n(h))return;const l=k.dirname(h),p=k.basename(h),C=this.fsw._getWatchedDir(f.type===Te?h:l);if(Ta.has(c)||f.event===_a)if(typeof r.ignored===ru){let g;try{g=await iu(h)}catch{}if(this.fsw.closed||this.checkIgnored(h,g))return;on(f,g)?this.addOrChange(h,o,u,l,C,p,f,r):this.handleEvent(rt,h,o,u,l,C,p,f,r)}else this.checkExists(h,o,u,l,C,p,f,r);else switch(f.event){case Ca:case Fa:return this.addOrChange(h,o,u,l,C,p,f,r);case ga:case ma:return this.checkExists(h,o,u,l,C,p,f,r)}},"watchCallback"),this.fsw._emitRaw);return this.fsw._emitReady(),D}async _handleFsEventsSymlink(e,u,s,n){if(!(this.fsw.closed||this.fsw._symlinkPaths.has(u))){this.fsw._symlinkPaths.set(u,!0),this.fsw._incrReadyCount();try{const r=await Dn(e);if(this.fsw.closed)return;if(this.fsw._isIgnored(r))return this.fsw._emitReady();this.fsw._incrReadyCount(),this._addToFsEvents(r||e,i=>{let D=e;return r&&r!==rn?D=i.replace(r,e):i!==rn&&(D=k.join(e,i)),s(D)},!1,n)}catch(r){if(this.fsw._handleError(r))return this.fsw._emitReady()}}}emitAdd(e,u,s,n,r){const i=s(e),D=u.isDirectory(),o=this.fsw._getWatchedDir(k.dirname(i)),c=k.basename(i);D&&this.fsw._getWatchedDir(i),!o.has(c)&&(o.add(c),(!n.ignoreInitial||r===!0)&&this.fsw._emit(D?un:nu,i,u))}initWatch(e,u,s,n){if(this.fsw.closed)return;const r=this._watchWithFsEvents(s.watchPath,k.resolve(e||s.watchPath),n,s.globFilter);this.fsw._addPathCloser(u,r)}async _addToFsEvents(e,u,s,n){if(this.fsw.closed)return;const r=this.fsw.options,i=typeof u===ru?u:ba,D=this.fsw._getWatchHelpers(e);try{const o=await Ba[D.statMethod](D.watchPath);if(this.fsw.closed)return;if(this.fsw._isIgnored(D.watchPath,o))throw null;if(o.isDirectory()){if(D.globFilter||this.emitAdd(i(e),o,i,r,s),n&&n>r.depth)return;this.fsw._readdirp(D.watchPath,{fileFilter:a(c=>D.filterPath(c),"fileFilter"),directoryFilter:a(c=>D.filterDir(c),"directoryFilter"),...va(r.depth-(n||0))}).on(Ea,c=>{if(this.fsw.closed||c.stats.isDirectory()&&!D.filterPath(c))return;const f=k.join(D.watchPath,c.path),{fullPath:h}=c;if(D.followSymlinks&&c.stats.isSymbolicLink()){const l=r.depth===void 0?void 0:Du(f,k.resolve(D.watchPath))+1;this._handleFsEventsSymlink(f,h,i,l)}else this.emitAdd(f,c.stats,i,r,s)}).on(da,Ra).on(pa,()=>{this.fsw._emitReady()})}else this.emitAdd(D.watchPath,o,i,r,s),this.fsw._emitReady()}catch(o){(!o||this.fsw._handleError(o))&&(this.fsw._emitReady(),this.fsw._emitReady())}if(r.persistent&&s!==!0)if(typeof u===ru)this.initWatch(void 0,e,D,i);else{let o;try{o=await Dn(D.watchPath)}catch{}this.initWatch(o,e,D,i)}}};tu.exports=Pa,tu.exports.canUse=Ha;var La=tu.exports;const{EventEmitter:Ia}=Ln,ou=De,S=z,{promisify:an}=ge,ka=xD,au=ID.default,Ma=XD,lu=Bs,Ga=ko,Wa=ws,ja=fa,ln=La,{EV_ALL:cu,EV_READY:Ua,EV_ADD:it,EV_CHANGE:xe,EV_UNLINK:cn,EV_ADD_DIR:Ka,EV_UNLINK_DIR:Va,EV_RAW:za,EV_ERROR:fu,STR_CLOSE:Ya,STR_END:qa,BACK_SLASH_RE:Xa,DOUBLE_SLASH_RE:fn,SLASH_OR_BACK_SLASH_RE:Qa,DOT_RE:Za,REPLACER_RE:Ja,SLASH:hu,SLASH_SLASH:el,BRACE_START:tl,BANG:du,ONE_DOT:hn,TWO_DOTS:ul,GLOBSTAR:sl,SLASH_GLOBSTAR:Eu,ANYMATCH_OPTS:pu,STRING_TYPE:Cu,FUNCTION_TYPE:nl,EMPTY_STR:Fu,EMPTY_FN:rl,isWindows:il,isMacos:Dl,isIBMi:ol}=et,al=an(ou.stat),ll=an(ou.readdir),gu=a((t=[])=>Array.isArray(t)?t:[t],"arrify"),dn=a((t,e=[])=>(t.forEach(u=>{Array.isArray(u)?dn(u,e):e.push(u)}),e),"flatten"),En=a(t=>{const e=dn(gu(t));if(!e.every(u=>typeof u===Cu))throw new TypeError(`Non-string provided as watch path: ${e}`);return e.map(Cn)},"unifyPaths"),pn=a(t=>{let e=t.replace(Xa,hu),u=!1;for(e.startsWith(el)&&(u=!0);e.match(fn);)e=e.replace(fn,hu);return u&&(e=hu+e),e},"toUnix"),Cn=a(t=>pn(S.normalize(pn(t))),"normalizePathToUnix"),Fn=a((t=Fu)=>e=>typeof e!==Cu?e:Cn(S.isAbsolute(e)?e:S.join(t,e)),"normalizeIgnored"),cl=a((t,e)=>S.isAbsolute(t)?t:t.startsWith(du)?du+S.join(e,t.slice(1)):S.join(e,t),"getAbsolutePath"),X=a((t,e)=>t[e]===void 0,"undef");class fl{static{a(this,"DirEntry")}constructor(e,u){this.path=e,this._removeWatcher=u,this.items=new Set}add(e){const{items:u}=this;u&&e!==hn&&e!==ul&&u.add(e)}async remove(e){const{items:u}=this;if(!u||(u.delete(e),u.size>0))return;const s=this.path;try{await ll(s)}catch{this._removeWatcher&&this._removeWatcher(S.dirname(s),S.basename(s))}}has(e){const{items:u}=this;if(u)return u.has(e)}getChildren(){const{items:e}=this;if(e)return[...e.values()]}dispose(){this.items.clear(),delete this.path,delete this._removeWatcher,delete this.items,Object.freeze(this)}}const hl="stat",dl="lstat";class El{static{a(this,"WatchHelper")}constructor(e,u,s,n){this.fsw=n,this.path=e=e.replace(Ja,Fu),this.watchPath=u,this.fullWatchPath=S.resolve(u),this.hasGlob=u!==e,e===Fu&&(this.hasGlob=!1),this.globSymlink=this.hasGlob&&s?void 0:!1,this.globFilter=this.hasGlob?au(e,void 0,pu):!1,this.dirParts=this.getDirParts(e),this.dirParts.forEach(r=>{r.length>1&&r.pop()}),this.followSymlinks=s,this.statMethod=s?hl:dl}checkGlobSymlink(e){return this.globSymlink===void 0&&(this.globSymlink=e.fullParentDir===this.fullWatchPath?!1:{realPath:e.fullParentDir,linkPath:this.fullWatchPath}),this.globSymlink?e.fullPath.replace(this.globSymlink.realPath,this.globSymlink.linkPath):e.fullPath}entryPath(e){return S.join(this.watchPath,S.relative(this.watchPath,this.checkGlobSymlink(e)))}filterPath(e){const{stats:u}=e;if(u&&u.isSymbolicLink())return this.filterDir(e);const s=this.entryPath(e);return(this.hasGlob&&typeof this.globFilter===nl?this.globFilter(s):!0)&&this.fsw._isntIgnored(s,u)&&this.fsw._hasReadPermissions(u)}getDirParts(e){if(!this.hasGlob)return[];const u=[];return(e.includes(tl)?Ga.expand(e):[e]).forEach(n=>{u.push(S.relative(this.watchPath,n).split(Qa))}),u}filterDir(e){if(this.hasGlob){const u=this.getDirParts(this.checkGlobSymlink(e));let s=!1;this.unmatchedGlob=!this.dirParts.some(n=>n.every((r,i)=>(r===sl&&(s=!0),s||!u[0][i]||au(r,u[0][i],pu))))}return!this.unmatchedGlob&&this.fsw._isntIgnored(this.entryPath(e),e.stats)}}class pl extends Ia{static{a(this,"FSWatcher")}constructor(e){super();const u={};e&&Object.assign(u,e),this._watched=new Map,this._closers=new Map,this._ignoredPaths=new Set,this._throttled=new Map,this._symlinkPaths=new Map,this._streams=new Set,this.closed=!1,X(u,"persistent")&&(u.persistent=!0),X(u,"ignoreInitial")&&(u.ignoreInitial=!1),X(u,"ignorePermissionErrors")&&(u.ignorePermissionErrors=!1),X(u,"interval")&&(u.interval=100),X(u,"binaryInterval")&&(u.binaryInterval=300),X(u,"disableGlobbing")&&(u.disableGlobbing=!1),u.enableBinaryInterval=u.binaryInterval!==u.interval,X(u,"useFsEvents")&&(u.useFsEvents=!u.usePolling),ln.canUse()||(u.useFsEvents=!1),X(u,"usePolling")&&!u.useFsEvents&&(u.usePolling=Dl),ol&&(u.usePolling=!0);const n=process.env.CHOKIDAR_USEPOLLING;if(n!==void 0){const o=n.toLowerCase();o==="false"||o==="0"?u.usePolling=!1:o==="true"||o==="1"?u.usePolling=!0:u.usePolling=!!o}const r=process.env.CHOKIDAR_INTERVAL;r&&(u.interval=Number.parseInt(r,10)),X(u,"atomic")&&(u.atomic=!u.usePolling&&!u.useFsEvents),u.atomic&&(this._pendingUnlinks=new Map),X(u,"followSymlinks")&&(u.followSymlinks=!0),X(u,"awaitWriteFinish")&&(u.awaitWriteFinish=!1),u.awaitWriteFinish===!0&&(u.awaitWriteFinish={});const i=u.awaitWriteFinish;i&&(i.stabilityThreshold||(i.stabilityThreshold=2e3),i.pollInterval||(i.pollInterval=100),this._pendingWrites=new Map),u.ignored&&(u.ignored=gu(u.ignored));let D=0;this._emitReady=()=>{D++,D>=this._readyCount&&(this._emitReady=rl,this._readyEmitted=!0,process.nextTick(()=>this.emit(Ua)))},this._emitRaw=(...o)=>this.emit(za,...o),this._readyEmitted=!1,this.options=u,u.useFsEvents?this._fsEventsHandler=new ln(this):this._nodeFsHandler=new ja(this),Object.freeze(u)}add(e,u,s){const{cwd:n,disableGlobbing:r}=this.options;this.closed=!1;let i=En(e);return n&&(i=i.map(D=>{const o=cl(D,n);return r||!lu(D)?o:Wa(o)})),i=i.filter(D=>D.startsWith(du)?(this._ignoredPaths.add(D.slice(1)),!1):(this._ignoredPaths.delete(D),this._ignoredPaths.delete(D+Eu),this._userIgnored=void 0,!0)),this.options.useFsEvents&&this._fsEventsHandler?(this._readyCount||(this._readyCount=i.length),this.options.persistent&&(this._readyCount+=i.length),i.forEach(D=>this._fsEventsHandler._addToFsEvents(D))):(this._readyCount||(this._readyCount=0),this._readyCount+=i.length,Promise.all(i.map(async D=>{const o=await this._nodeFsHandler._addToNodeFs(D,!s,0,0,u);return o&&this._emitReady(),o})).then(D=>{this.closed||D.filter(o=>o).forEach(o=>{this.add(S.dirname(o),S.basename(u||o))})})),this}unwatch(e){if(this.closed)return this;const u=En(e),{cwd:s}=this.options;return u.forEach(n=>{!S.isAbsolute(n)&&!this._closers.has(n)&&(s&&(n=S.join(s,n)),n=S.resolve(n)),this._closePath(n),this._ignoredPaths.add(n),this._watched.has(n)&&this._ignoredPaths.add(n+Eu),this._userIgnored=void 0}),this}close(){if(this.closed)return this._closePromise;this.closed=!0,this.removeAllListeners();const e=[];return this._closers.forEach(u=>u.forEach(s=>{const n=s();n instanceof Promise&&e.push(n)})),this._streams.forEach(u=>u.destroy()),this._userIgnored=void 0,this._readyCount=0,this._readyEmitted=!1,this._watched.forEach(u=>u.dispose()),["closers","watched","streams","symlinkPaths","throttled"].forEach(u=>{this[`_${u}`].clear()}),this._closePromise=e.length?Promise.all(e).then(()=>{}):Promise.resolve(),this._closePromise}getWatched(){const e={};return this._watched.forEach((u,s)=>{const n=this.options.cwd?S.relative(this.options.cwd,s):s;e[n||hn]=u.getChildren().sort()}),e}emitWithAll(e,u){this.emit(...u),e!==fu&&this.emit(cu,...u)}async _emit(e,u,s,n,r){if(this.closed)return;const i=this.options;il&&(u=S.normalize(u)),i.cwd&&(u=S.relative(i.cwd,u));const D=[e,u];r!==void 0?D.push(s,n,r):n!==void 0?D.push(s,n):s!==void 0&&D.push(s);const o=i.awaitWriteFinish;let c;if(o&&(c=this._pendingWrites.get(u)))return c.lastChange=new Date,this;if(i.atomic){if(e===cn)return this._pendingUnlinks.set(u,D),setTimeout(()=>{this._pendingUnlinks.forEach((f,h)=>{this.emit(...f),this.emit(cu,...f),this._pendingUnlinks.delete(h)})},typeof i.atomic=="number"?i.atomic:100),this;e===it&&this._pendingUnlinks.has(u)&&(e=D[0]=xe,this._pendingUnlinks.delete(u))}if(o&&(e===it||e===xe)&&this._readyEmitted){const f=a((h,l)=>{h?(e=D[0]=fu,D[1]=h,this.emitWithAll(e,D)):l&&(D.length>2?D[2]=l:D.push(l),this.emitWithAll(e,D))},"awfEmit");return this._awaitWriteFinish(u,o.stabilityThreshold,e,f),this}if(e===xe&&!this._throttle(xe,u,50))return this;if(i.alwaysStat&&s===void 0&&(e===it||e===Ka||e===xe)){const f=i.cwd?S.join(i.cwd,u):u;let h;try{h=await al(f)}catch{}if(!h||this.closed)return;D.push(h)}return this.emitWithAll(e,D),this}_handleError(e){const u=e&&e.code;return e&&u!=="ENOENT"&&u!=="ENOTDIR"&&(!this.options.ignorePermissionErrors||u!=="EPERM"&&u!=="EACCES")&&this.emit(fu,e),e||this.closed}_throttle(e,u,s){this._throttled.has(e)||this._throttled.set(e,new Map);const n=this._throttled.get(e),r=n.get(u);if(r)return r.count++,!1;let i;const D=a(()=>{const c=n.get(u),f=c?c.count:0;return n.delete(u),clearTimeout(i),c&&clearTimeout(c.timeoutObject),f},"clear");i=setTimeout(D,s);const o={timeoutObject:i,clear:D,count:0};return n.set(u,o),o}_incrReadyCount(){return this._readyCount++}_awaitWriteFinish(e,u,s,n){let r,i=e;this.options.cwd&&!S.isAbsolute(e)&&(i=S.join(this.options.cwd,e));const D=new Date,o=a(c=>{ou.stat(i,(f,h)=>{if(f||!this._pendingWrites.has(e)){f&&f.code!=="ENOENT"&&n(f);return}const l=Number(new Date);c&&h.size!==c.size&&(this._pendingWrites.get(e).lastChange=l);const p=this._pendingWrites.get(e);l-p.lastChange>=u?(this._pendingWrites.delete(e),n(void 0,h)):r=setTimeout(o,this.options.awaitWriteFinish.pollInterval,h)})},"awaitWriteFinish");this._pendingWrites.has(e)||(this._pendingWrites.set(e,{lastChange:D,cancelWait:a(()=>(this._pendingWrites.delete(e),clearTimeout(r),s),"cancelWait")}),r=setTimeout(o,this.options.awaitWriteFinish.pollInterval))}_getGlobIgnored(){return[...this._ignoredPaths.values()]}_isIgnored(e,u){if(this.options.atomic&&Za.test(e))return!0;if(!this._userIgnored){const{cwd:s}=this.options,n=this.options.ignored,r=n&&n.map(Fn(s)),i=gu(r).filter(o=>typeof o===Cu&&!lu(o)).map(o=>o+Eu),D=this._getGlobIgnored().map(Fn(s)).concat(r,i);this._userIgnored=au(D,void 0,pu)}return this._userIgnored([e,u])}_isntIgnored(e,u){return!this._isIgnored(e,u)}_getWatchHelpers(e,u){const s=u||this.options.disableGlobbing||!lu(e)?e:Ma(e),n=this.options.followSymlinks;return new El(e,s,n,this)}_getWatchedDir(e){this._boundRemove||(this._boundRemove=this._remove.bind(this));const u=S.resolve(e);return this._watched.has(u)||this._watched.set(u,new fl(u,this._boundRemove)),this._watched.get(u)}_hasReadPermissions(e){if(this.options.ignorePermissionErrors)return!0;const s=(e&&Number.parseInt(e.mode,10))&511;return!!(4&Number.parseInt(s.toString(8)[0],10))}_remove(e,u,s){const n=S.join(e,u),r=S.resolve(n);if(s=s??(this._watched.has(n)||this._watched.has(r)),!this._throttle("remove",n,100))return;!s&&!this.options.useFsEvents&&this._watched.size===1&&this.add(e,u,!0),this._getWatchedDir(n).getChildren().forEach(l=>this._remove(n,l));const o=this._getWatchedDir(e),c=o.has(u);o.remove(u),this._symlinkPaths.has(r)&&this._symlinkPaths.delete(r);let f=n;if(this.options.cwd&&(f=S.relative(this.options.cwd,n)),this.options.awaitWriteFinish&&this._pendingWrites.has(f)&&this._pendingWrites.get(f).cancelWait()===it)return;this._watched.delete(n),this._watched.delete(r);const h=s?Va:cn;c&&!this._isIgnored(n)&&this._emit(h,n),this.options.useFsEvents||this._closePath(n)}_closePath(e){this._closeFile(e);const u=S.dirname(e);this._getWatchedDir(u).remove(S.basename(e))}_closeFile(e){const u=this._closers.get(e);u&&(u.forEach(s=>s()),this._closers.delete(e))}_addPathCloser(e,u){if(!u)return;let s=this._closers.get(e);s||(s=[],this._closers.set(e,s)),s.push(u)}_readdirp(e,u){if(this.closed)return;const s={type:cu,alwaysStat:!0,lstat:!0,...u};let n=ka(e,s);return this._streams.add(n),n.once(Ya,()=>{n=void 0}),n.once(qa,()=>{n&&(this._streams.delete(n),n=void 0)}),n}}const Cl=a((t,e)=>{const u=new pl(e);return u.add(t),u},"watch");var Fl=Cl;const Dt=a((t=!0)=>{let e=!1;return u=>{if(e||u==="unknown-flag")return!0;if(u==="argument")return e=!0,t}},"ignoreAfterArgument"),gn=a((t,e=process.argv.slice(2))=>(yu(t,e,{ignore:Dt()}),e),"removeArgvFlags"),gl=a(t=>{let e=Buffer.alloc(0);return u=>{for(e=Buffer.concat([e,u]);e.length>4;){const s=e.readInt32BE(0);if(e.length>=4+s){const n=e.slice(4,4+s);t(n),e=e.slice(4+s)}else break}}},"bufferData"),mn=a(async()=>{const t=jn.createServer(u=>{u.on("data",gl(s=>{const n=JSON.parse(s.toString());t.emit("data",n)}))}),e=Bn(process.pid);return await ct.promises.mkdir(Un,{recursive:!0}),await ct.promises.rm(e,{force:!0}),await new Promise((u,s)=>{t.listen(e,u),t.on("error",s)}),t.unref(),process.on("exit",()=>{if(t.close(),!$n)try{ct.rmSync(e)}catch{}}),t},"createIpcServer"),ml=a(()=>new Date().toLocaleTimeString(),"currentTime"),Oe=a((...t)=>console.log(kn(ml()),Mn("[tsx]"),...t),"log"),_l="\x1Bc",Al=a((t,e)=>{let u;return function(){u&&clearTimeout(u),u=setTimeout(()=>Reflect.apply(t,this,arguments),e)}},"debounce"),_n={noCache:{type:Boolean,description:"Disable caching",default:!1},tsconfig:{type:String,description:"Custom tsconfig.json path"},clearScreen:{type:Boolean,description:"Clearing the screen on rerun",default:!0},ignore:{type:[String],description:"Paths & globs to exclude from being watched (Deprecated: use --exclude)"},include:{type:[String],description:"Additional paths & globs to watch"},exclude:{type:[String],description:"Paths & globs to exclude from being watched"}},yl=oi({name:"watch",parameters:["<script path>"],flags:_n,help:{description:"Run the script and watch for changes"},ignoreArgv:Dt(!1)},async t=>{const e=gn(_n,process.argv.slice(3)),u={noCache:t.flags.noCache,tsconfigPath:t.flags.tsconfig,clearScreen:t.flags.clearScreen,include:t.flags.include,exclude:[...t.flags.ignore,...t.flags.exclude],ipc:!0};let s,n=!1;(await mn()).on("data",l=>{if(l&&typeof l=="object"&&"type"in l&&l.type==="dependency"&&"path"in l&&typeof l.path=="string"){const p=l.path.startsWith("file:")?xn(l.path):l.path;Pn.isAbsolute(p)&&h.add(p)}});const i=a(()=>{if(!n)return rs(e,u)},"spawnProcess");let D=!1;const o=a(async(l,p="SIGTERM",C=5e3)=>{let g=!1;const y=new Promise(B=>{l.on("exit",H=>{g=!0,D=!1,B(H)})});return D=!0,l.kill(p),setTimeout(()=>{g||(Oe(me(`Process didn't exit in ${Math.floor(C/1e3)}s. Force killing...`)),l.kill("SIGKILL"))},C),await y},"killProcess"),c=Al(async(l,p)=>{const C=l?`${l?Gn(l):""}${p?` in ${Wn(`./${p}`)}`:""}`:"";if(D){Oe(C,me("Process hasn't exited. Killing process...")),s.kill("SIGKILL");return}s&&(s.exitCode===null?(Oe(C,me("Restarting...")),await o(s)):Oe(C,me("Rerunning...")),u.clearScreen&&process.stdout.write(_l)),s=i()},100);c();const f=a(l=>{n=!0,s?.exitCode===null?(D&&Oe(me("Previous process hasn't exited yet. Force killing...")),o(s,D?"SIGKILL":l).then(p=>{process.exit(p??0)},()=>{})):process.exit(lt.signals[l])},"relaySignal");process.on("SIGINT",f),process.on("SIGTERM",f);const h=Fl([...t._,...u.include],{cwd:process.cwd(),ignoreInitial:!0,ignored:["**/.*/**","**/.*","**/{node_modules,bower_components,vendor}/**",...u.exclude],ignorePermissionErrors:!0}).on("all",c);process.stdin.on("data",()=>c("Return key"))}),wl=a((t,e)=>{let u;e.on("data",r=>{r&&r.type==="signal"&&u&&u(r.signal)});const s=a(()=>{const r=new Promise(i=>{setTimeout(()=>i(void 0),30),u=i});return r.then(()=>{u=void 0},()=>{}),r},"waitForSignalFromChild"),n=a(async r=>{await s()!==r&&(t.kill(r),await s()!==r&&(t.on("exit",()=>{const o=lt.signals[r];process.exit(128+o)}),t.kill("SIGKILL")))},"relaySignalToChild");process.on("SIGINT",n),process.on("SIGTERM",n)},"relaySignals"),An={noCache:{type:Boolean,description:"Disable caching"},tsconfig:{type:String,description:"Custom tsconfig.json path"}};ju({name:"tsx",parameters:["[script path]"],commands:[yl],flags:{...An,version:{type:Boolean,alias:"v",description:"Show version"},help:{type:Boolean,alias:"h",description:"Show help"}},help:!1,ignoreArgv:Dt()},async t=>{t.flags.version?process.stdout.write(`tsx v${Sn}
+node `):t.flags.help&&(t.showHelp({description:"Node.js runtime enhanced with esbuild for loading TypeScript & ESM"}),console.log(`${"-".repeat(45)}
+`));const e={eval:{type:String,alias:"e"},print:{type:String,alias:"p"}},{_:u,flags:s}=ju({flags:{...e,inputType:String,test:Boolean},help:!1,ignoreArgv:Dt(!1)}),n=gn({...An,...e}),i=["print","eval"].find(c=>!!s[c]);if(i){const{inputType:c}=s,f=s[i],h=vn(f,{loader:"default",sourcefile:"/eval.ts",format:c==="module"?"esm":"cjs"});n.unshift(`--${i}`,h.code)}mu(Hn)&&s.test&&u.length===0&&n.push("**/{test,test/**/*,test-*,*[.-_]test}.?(c|m)@(t|j)s");const D=await mn(),o=rs(n,{noCache:!!t.flags.noCache,tsconfigPath:t.flags.tsconfig});wl(o,D),process.send&&o.on("message",c=>{process.send(c)}),o.send&&process.on("message",c=>{o.send(c)}),o.on("close",c=>{c===null&&(c=lt.signals[o.signalCode]+128),process.exit(c)})});
diff --git a/node_modules/.bin/update-browserslist-db b/node_modules/.bin/update-browserslist-db
new file mode 100644
index 0000000000000000000000000000000000000000..1388e94d08ce1c949cd65ef98172fa64c16c096a
--- /dev/null
+++ b/node_modules/.bin/update-browserslist-db
@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+let { readFileSync } = require('fs')
+let { join } = require('path')
+
+require('./check-npm-version')
+let updateDb = require('./')
+
+const ROOT = __dirname
+
+function getPackage() {
+  return JSON.parse(readFileSync(join(ROOT, 'package.json')))
+}
+
+let args = process.argv.slice(2)
+
+let USAGE = 'Usage:\n  npx update-browserslist-db\n'
+
+function isArg(arg) {
+  return args.some(i => i === arg)
+}
+
+function error(msg) {
+  process.stderr.write('update-browserslist-db: ' + msg + '\n')
+  process.exit(1)
+}
+
+if (isArg('--help') || isArg('-h')) {
+  process.stdout.write(getPackage().description + '.\n\n' + USAGE + '\n')
+} else if (isArg('--version') || isArg('-v')) {
+  process.stdout.write('browserslist-lint ' + getPackage().version + '\n')
+} else {
+  try {
+    updateDb()
+  } catch (e) {
+    if (e.name === 'BrowserslistUpdateError') {
+      error(e.message)
+    } else {
+      throw e
+    }
+  }
+}
diff --git a/node_modules/.bin/uuid b/node_modules/.bin/uuid
new file mode 100644
index 0000000000000000000000000000000000000000..b4f612d447167233cc1473bf54424766c54bc243
--- /dev/null
+++ b/node_modules/.bin/uuid
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../uuid-bin.js';
diff --git a/node_modules/.bin/vite b/node_modules/.bin/vite
new file mode 100644
index 0000000000000000000000000000000000000000..79c49ab70f624eac6d3b0888864e279998c32662
--- /dev/null
+++ b/node_modules/.bin/vite
@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { performance } from 'node:perf_hooks'
+import module from 'node:module'
+
+if (!import.meta.url.includes('node_modules')) {
+  if (!process.env.DEBUG_DISABLE_SOURCE_MAP) {
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins -- only used in dev
+    process.setSourceMapsEnabled(true)
+  }
+
+  process.on('unhandledRejection', (err) => {
+    throw new Error('UNHANDLED PROMISE REJECTION', { cause: err })
+  })
+}
+
+global.__vite_start_time = performance.now()
+
+// check debug mode first before requiring the CLI.
+const debugIndex = process.argv.findIndex((arg) => /^(?:-d|--debug)$/.test(arg))
+const filterIndex = process.argv.findIndex((arg) =>
+  /^(?:-f|--filter)$/.test(arg),
+)
+const profileIndex = process.argv.indexOf('--profile')
+
+if (debugIndex > 0) {
+  let value = process.argv[debugIndex + 1]
+  if (!value || value[0] === '-') {
+    value = 'vite:*'
+  } else {
+    // support debugging multiple flags with comma-separated list
+    value = value
+      .split(',')
+      .map((v) => `vite:${v}`)
+      .join(',')
+  }
+  process.env.DEBUG = `${
+    process.env.DEBUG ? process.env.DEBUG + ',' : ''
+  }${value}`
+
+  if (filterIndex > 0) {
+    const filter = process.argv[filterIndex + 1]
+    if (filter && filter[0] !== '-') {
+      process.env.VITE_DEBUG_FILTER = filter
+    }
+  }
+}
+
+function start() {
+  try {
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins -- it is supported in Node 22.8.0+ and only called if it exists
+    module.enableCompileCache?.()
+    // flush the cache after 10s because the cache is not flushed until process end
+    // for dev server, the cache is never flushed unless manually flushed because the process.exit is called
+    // also flushing the cache in SIGINT handler seems to cause the process to hang
+    setTimeout(() => {
+      try {
+        // eslint-disable-next-line n/no-unsupported-features/node-builtins -- it is supported in Node 22.12.0+ and only called if it exists
+        module.flushCompileCache?.()
+      } catch {}
+    }, 10 * 1000).unref()
+  } catch {}
+  return import('../dist/node/cli.js')
+}
+
+if (profileIndex > 0) {
+  process.argv.splice(profileIndex, 1)
+  const next = process.argv[profileIndex]
+  if (next && next[0] !== '-') {
+    process.argv.splice(profileIndex, 1)
+  }
+  const inspector = await import('node:inspector').then((r) => r.default)
+  const session = (global.__vite_profile_session = new inspector.Session())
+  session.connect()
+  session.post('Profiler.enable', () => {
+    session.post('Profiler.start', start)
+  })
+} else {
+  start()
+}
diff --git a/node_modules/.bin/vitest b/node_modules/.bin/vitest
new file mode 100644
index 0000000000000000000000000000000000000000..02dd4714b90340442ab2b2b72a704a99c9b5e4b8
--- /dev/null
+++ b/node_modules/.bin/vitest
@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './dist/cli.js'
diff --git a/node_modules/.bin/why-is-node-running b/node_modules/.bin/why-is-node-running
new file mode 100644
index 0000000000000000000000000000000000000000..15cf2b9147ab2cb4c36afdc1ff50604e32cd593a
--- /dev/null
+++ b/node_modules/.bin/why-is-node-running
@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+var spawn = require('child_process').spawn
+var path = require('path')
+
+var prog = path.resolve(process.argv[2])
+var progArgs = process.argv.slice(3)
+
+console.log('probing program', prog)
+
+var nodeArgs = [
+  '-r',
+  path.join(__dirname, 'include.js')
+]
+var nodeOpts = { stdio: 'inherit' }
+var child = spawn('node', nodeArgs.concat(prog).concat(progArgs), nodeOpts)
+
+console.log('kill -SIGUSR1', child.pid, 'for logging')
diff --git a/node_modules/.package-lock.json b/node_modules/.package-lock.json
new file mode 100644
index 0000000000000000000000000000000000000000..2cade27b1406afabb0286573ffb743693938133f
--- /dev/null
+++ b/node_modules/.package-lock.json
@@ -0,0 +1,11136 @@
+{
+  "name": "@trek/root",
+  "version": "3.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "5.1.11",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-5.1.11.tgz",
+      "integrity": "sha512-KVw6qIiCTUQhByfTd78h2yD1/00waTmm9uy/R7Ck/ctUyAPj+AEDLkQIdJW0T8+qGgj3j5bpNKK7Q3G+LedJWg==",
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/generational-cache": "^1.0.1",
+        "@csstools/css-calc": "^3.2.0",
+        "@csstools/css-color-parser": "^4.1.0",
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/dom-selector": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-7.1.1.tgz",
+      "integrity": "sha512-67RZDnYRc8H/8MLDgQCDE//zoqVFwajkepHZgmXrbwybzXOEwOWGPYGmALYl9J2DOLfFPPs6kKCqmbzV895hTQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/generational-cache": "^1.0.1",
+        "@asamuzakjp/nwsapi": "^2.3.9",
+        "bidi-js": "^1.0.3",
+        "css-tree": "^3.2.1",
+        "is-potential-custom-element-name": "^1.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/generational-cache": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/generational-cache/-/generational-cache-1.0.1.tgz",
+      "integrity": "sha512-wajfB8KqzMCN2KGNFdLkReeHncd0AslUSrvHVvvYWuU8ghncRJoA50kT3zP9MVL0+9g4/67H+cdvBskj9THPzg==",
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/@asamuzakjp/nwsapi": {
+      "version": "2.3.9",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz",
+      "integrity": "sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==",
+      "license": "MIT"
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz",
+      "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.7.tgz",
+      "integrity": "sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.7.tgz",
+      "integrity": "sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-compilation-targets": "^7.29.7",
+        "@babel/helper-module-transforms": "^7.29.7",
+        "@babel/helpers": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/core/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.7.tgz",
+      "integrity": "sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.29.7.tgz",
+      "integrity": "sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.29.7",
+        "@babel/helper-validator-option": "^7.29.7",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz",
+      "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz",
+      "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.29.7.tgz",
+      "integrity": "sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7",
+        "@babel/traverse": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
+      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
+      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.29.7.tgz",
+      "integrity": "sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.7.tgz",
+      "integrity": "sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.7.tgz",
+      "integrity": "sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.7"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz",
+      "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/types": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.7.tgz",
+      "integrity": "sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.7",
+        "@babel/generator": "^7.29.7",
+        "@babel/helper-globals": "^7.29.7",
+        "@babel/parser": "^7.29.7",
+        "@babel/template": "^7.29.7",
+        "@babel/types": "^7.29.7",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.7.tgz",
+      "integrity": "sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.29.7",
+        "@babel/helper-validator-identifier": "^7.29.7"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@bcoe/v8-coverage": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-1.0.2.tgz",
+      "integrity": "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@borewit/text-codec": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/@borewit/text-codec/-/text-codec-0.2.2.tgz",
+      "integrity": "sha512-DDaRehssg1aNrH4+2hnj1B7vnUGEjU6OIlyRdkMd0aUdIUvKXrJfXsy8LVtXAy7DRvYVluWbMspsRhz2lcW0mQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Borewit"
+      }
+    },
+    "node_modules/@bramus/specificity": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/@bramus/specificity/-/specificity-2.4.2.tgz",
+      "integrity": "sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==",
+      "license": "MIT",
+      "dependencies": {
+        "css-tree": "^3.0.0"
+      },
+      "bin": {
+        "specificity": "bin/cli.js"
+      }
+    },
+    "node_modules/@csstools/color-helpers": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.0.2.tgz",
+      "integrity": "sha512-LMGQLS9EuADloEFkcTBR3BwV/CGHV7zyDxVRtVDTwdI2Ca4it0CCVTT9wCkxSgokjE5Ho41hEPgb8OEUwoXr6Q==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.2.1.tgz",
+      "integrity": "sha512-DtdHlgXh5ZkA43cwBcAm+huzgJiwx3ZTWVjBs94kwz2xKqSimDA3lBgCjphYgwgVUMWatSM0pDd8TILB1yrVVg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "4.1.7",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.1.7.tgz",
+      "integrity": "sha512-CmjJFQTFQx/U/xNJhSjCQ0ilpesPmNQ8+eOUeM/+kDOVW33qsIjeOXc27vrQDdWVkf83ZSWwtg7kXSUvKDJ8cQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/color-helpers": "^6.0.2",
+        "@csstools/css-calc": "^3.2.1"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^4.0.0",
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz",
+      "integrity": "sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^4.0.0"
+      }
+    },
+    "node_modules/@csstools/css-syntax-patches-for-csstree": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.1.5.tgz",
+      "integrity": "sha512-oNjBvzLq2GPZtJphCjLqXow/cHySHSgtxvKZb7OqSZ/xHgw6NWNhfad+6AB9cLeVm6eA9d/qMll3JdEHjy6M+A==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "peerDependencies": {
+        "css-tree": "^3.2.1"
+      },
+      "peerDependenciesMeta": {
+        "css-tree": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.0.tgz",
+      "integrity": "sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/@emnapi/core": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",
+      "integrity": "sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.1",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.11.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.1.tgz",
+      "integrity": "sha512-vgj7R3y3Wgx24IQaGPA/R6YFXLHVMOZ0uVEyIQPaWs+rd1AzfEMXlAC22FYwO1XkKR6NPsq7mUandH8oIRdZFw==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.1.tgz",
+      "integrity": "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
+      "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "eslint-visitor-keys": "^3.4.3"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.12.2",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz",
+      "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/compat": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@eslint/compat/-/compat-2.1.0.tgz",
+      "integrity": "sha512-LgaSCymEpw7tF53xvDw9SNsraPb1IBHxpdABIOM0hW8UAlP8znrjYtuxfR58FSJ3L9BhwD+FaPRFQpZq84Nh6g==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^1.2.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      },
+      "peerDependencies": {
+        "eslint": "^8.40 || 9 || 10"
+      },
+      "peerDependenciesMeta": {
+        "eslint": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@eslint/config-array": {
+      "version": "0.23.5",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.23.5.tgz",
+      "integrity": "sha512-Y3kKLvC1dvTOT+oGlqNQ1XLqK6D1HU2YXPc52NmAlJZbMMWDzGYXMiPRJ8TYD39muD/OTjlZmNJ4ib7dvSrMBA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/object-schema": "^3.0.5",
+        "debug": "^4.3.1",
+        "minimatch": "^10.2.4"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      }
+    },
+    "node_modules/@eslint/config-array/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/@eslint/config-array/node_modules/brace-expansion": {
+      "version": "5.0.6",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
+      "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/@eslint/config-array/node_modules/minimatch": {
+      "version": "10.2.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
+      "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "brace-expansion": "^5.0.5"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@eslint/config-helpers": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.6.0.tgz",
+      "integrity": "sha512-ii6Bw9jJ2zi2cWA2Z+9/QZ/+3DX6kwaV5Q986D/CdP3Lap3w/pgQZ373FV7byY/i7L4IRH/G43I5dz1ClsCbpA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^1.2.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      }
+    },
+    "node_modules/@eslint/core": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-1.2.1.tgz",
+      "integrity": "sha512-MwcE1P+AZ4C6DWlpin/OmOA54mmIZ/+xZuJiQd4SyB29oAJjN30UW9wkKNptW2ctp4cEsvhlLY/CsQ1uoHDloQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "3.3.5",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.5.tgz",
+      "integrity": "sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^6.14.0",
+        "debug": "^4.3.2",
+        "espree": "^10.0.1",
+        "globals": "^14.0.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.1",
+        "minimatch": "^3.1.5",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/ajv": {
+      "version": "6.15.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz",
+      "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.15.tgz",
+      "integrity": "sha512-EwOCDEex4quD37XhqM3omwtMoJjr//isUZz1JopUNWms+4Z2ViyM/k1YIRePpoVNnQhENnxtFjLaxNHrT7xIUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/eslint-visitor-keys": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
+      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/espree": {
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
+      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.15.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@eslint/eslintrc/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/@eslint/eslintrc/node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "10.0.1",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-10.0.1.tgz",
+      "integrity": "sha512-zeR9k5pd4gxjZ0abRoIaxdc7I3nDktoXZk2qOv9gCNWx3mVwEn32VRhyLaRsDiJjTs0xq/T8mfPtyuXu7GWBcA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "eslint": "^10.0.0"
+      },
+      "peerDependenciesMeta": {
+        "eslint": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@eslint/object-schema": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-3.0.5.tgz",
+      "integrity": "sha512-vqTaUEgxzm+YDSdElad6PiRoX4t8VGDjCtt05zn4nU810UIx/uNEV7/lZJ6KwFThKZOzOxzXy48da+No7HZaMw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      }
+    },
+    "node_modules/@eslint/plugin-kit": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.7.2.tgz",
+      "integrity": "sha512-+CNAzxglkrpNf/kKywqQfk74QjtceuOE7Qm+AF8miRvPF/wmmK5+OJOgVh3AVTT3RP2mH3+FOaxlE5v72owk0A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^1.2.1",
+        "levn": "^0.4.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      }
+    },
+    "node_modules/@exodus/bytes": {
+      "version": "1.15.1",
+      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.15.1.tgz",
+      "integrity": "sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==",
+      "license": "MIT",
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "@noble/hashes": "^1.8.0 || ^2.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@noble/hashes": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@hexagon/base64": {
+      "version": "1.1.28",
+      "resolved": "https://registry.npmjs.org/@hexagon/base64/-/base64-1.1.28.tgz",
+      "integrity": "sha512-lhqDEAvWixy3bZ+UOYbPwUbBkwBq5C1LAJ/xPC8Oi+lL54oyakv/npbA0aU2hgCsx/1NUd4IBvV03+aUBWxerw==",
+      "license": "MIT"
+    },
+    "node_modules/@hono/node-server": {
+      "version": "1.19.14",
+      "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.14.tgz",
+      "integrity": "sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.14.1"
+      },
+      "peerDependencies": {
+        "hono": "^4"
+      }
+    },
+    "node_modules/@humanfs/core": {
+      "version": "0.19.2",
+      "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz",
+      "integrity": "sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/types": "^0.15.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/node": {
+      "version": "0.16.8",
+      "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.8.tgz",
+      "integrity": "sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@humanfs/core": "^0.19.2",
+        "@humanfs/types": "^0.15.0",
+        "@humanwhocodes/retry": "^0.4.0"
+      },
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanfs/types": {
+      "version": "0.15.0",
+      "resolved": "https://registry.npmjs.org/@humanfs/types/-/types-0.15.0.tgz",
+      "integrity": "sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/retry": {
+      "version": "0.4.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz",
+      "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@inquirer/ansi": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@inquirer/ansi/-/ansi-2.0.7.tgz",
+      "integrity": "sha512-3eTuUO1vH2cZm2ZKHeQxnOqlTi9EfZDGgIe3BL3I4u+rJHocr9Fz86M4fjYABPvFnQG/gGK551HqDiIcETwU6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+      }
+    },
+    "node_modules/@inquirer/confirm": {
+      "version": "6.1.1",
+      "resolved": "https://registry.npmjs.org/@inquirer/confirm/-/confirm-6.1.1.tgz",
+      "integrity": "sha512-eb8DBZcz/2qHWQda4rk2JiQk5h9QV/cVHi1yjt0f69WFZMRFn0sJTye3EAP8icut8UDMjQPsaH5KbcOogefrFQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/core": "^11.2.1",
+        "@inquirer/type": "^4.0.7"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/core": {
+      "version": "11.2.1",
+      "resolved": "https://registry.npmjs.org/@inquirer/core/-/core-11.2.1.tgz",
+      "integrity": "sha512-Qd6GJT1yVyrZZCfN8W2qKF5ApmqryXRhRKCuip8h01x2w/esJQ2XIYc6f9abMIHgKQdBfFTSOdbHRLAhuM09UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/ansi": "^2.0.7",
+        "@inquirer/figures": "^2.0.7",
+        "@inquirer/type": "^4.0.7",
+        "cli-width": "^4.1.0",
+        "fast-wrap-ansi": "^0.2.0",
+        "mute-stream": "^3.0.0",
+        "signal-exit": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@inquirer/figures": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-2.0.7.tgz",
+      "integrity": "sha512-aJ8TBPOGB6f/2qziPfElISTCEd5XOYTFckA2SGjhNmiKzfK/u4ot3v0DUzGVdUnKjN10EqnnEPck36BkyfLnJw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+      }
+    },
+    "node_modules/@inquirer/type": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/@inquirer/type/-/type-4.0.7.tgz",
+      "integrity": "sha512-t28inv14nMQ1PhKpsJPY+kEs/c00qzeCOS2gTNRyTjG5d6qsVA2fItxW4hkvGZ5lvanGLdtCzVIx5dwdRpN1+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=23.5.0 || ^22.13.0 || ^20.17.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@istanbuljs/schema": {
+      "version": "0.1.6",
+      "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.6.tgz",
+      "integrity": "sha512-+Sg6GCR/wy1oSmQDFq4LQDAhm3ETKnorxN+y5nbLULOR3P0c14f2Wurzj3/xqPXtasLFfHd5iRFQ7AJt4KH2cw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@jimp/core": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/core/-/core-1.6.1.tgz",
+      "integrity": "sha512-+BoKC5G6hkrSy501zcJ2EpfnllP+avPevcBfRcZe/CW+EwEfY6X1EZ8QWyT7NpDIvEEJb1fdJnMMfUnFkxmw9A==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/file-ops": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "await-to-js": "^3.0.0",
+        "exif-parser": "^0.1.12",
+        "file-type": "^21.3.3",
+        "mime": "3"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/diff": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/diff/-/diff-1.6.1.tgz",
+      "integrity": "sha512-YkKDPdHjLgo1Api3+Bhc0GLAygldlpt97NfOKoNg1U6IUNXA6X2MgosCjPfSBiSvJvrrz1fsIR+/4cfYXBI/HQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/plugin-resize": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "pixelmatch": "^5.3.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/file-ops": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/file-ops/-/file-ops-1.6.1.tgz",
+      "integrity": "sha512-T+gX6osHjprbDRad0/B71Evyre7ZdVY1z/gFGEG9Z8KOtZPKboWvPeP2UjbZYWQLy9UKCPQX1FNAnDiOPkJL7w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/js-bmp": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/js-bmp/-/js-bmp-1.6.1.tgz",
+      "integrity": "sha512-xzWzNT4/u5zGrTT3Tme9sGU7YzIKxi13+BCQwLqACbt5DXf9SAfdzRkopZQnmDko+6In5nqaT89Gjs43/WdnYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "bmp-ts": "^1.0.9"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/js-gif": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/js-gif/-/js-gif-1.6.1.tgz",
+      "integrity": "sha512-YjY2W26rQa05XhanYhRZ7dingCiNN+T2Ymb1JiigIbABY0B28wHE3v3Cf1/HZPWGu0hOg36ylaKgV5KxF2M58w==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "gifwrap": "^0.10.1",
+        "omggif": "^1.0.10"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/js-jpeg": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/js-jpeg/-/js-jpeg-1.6.1.tgz",
+      "integrity": "sha512-HT9H3yOmlOFzYmdI15IYdfy6ggQhSRIaHeA+OTJSEORXBqEo97sUZu/DsgHIcX5NJ7TkJBTgZ9BZXsV6UbsyMg==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "jpeg-js": "^0.4.4"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/js-png": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/js-png/-/js-png-1.6.1.tgz",
+      "integrity": "sha512-SZ/KVhI5UjcSzzlXsXdIi/LhJ7UShf2NkMOtVrbZQcGzsqNtynAelrOXeoTxcanfVqmNhAoVHg8yR2cYoqrYjA==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "pngjs": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/js-tiff": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/js-tiff/-/js-tiff-1.6.1.tgz",
+      "integrity": "sha512-jDG/eJquID1M4MBlKMmDRBmz2TpXMv7TUyu2nIRUxhlUc2ogC82T+VQUkca9GJH1BBJ9dx5sSE5dGkWNjIbZxw==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "utif2": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-blit": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-blit/-/plugin-blit-1.6.1.tgz",
+      "integrity": "sha512-MwnI7C7K81uWddY9FLw1fCOIy6SsPIUftUz36Spt7jisCn8/40DhQMlSxpxTNelnZb/2SnloFimQfRZAmHLOqQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-blit/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-blur": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-blur/-/plugin-blur-1.6.1.tgz",
+      "integrity": "sha512-lIo7Tzp5jQu30EFFSK/phXANK3citKVEjepDjQ6ljHoIFtuMRrnybnmI2Md24ulvWlDaz+hh3n6qrMb8ydwhZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/utils": "1.6.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-circle": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-circle/-/plugin-circle-1.6.1.tgz",
+      "integrity": "sha512-kK1PavY6cKHNNKce37vdV4Tmpc1/zDKngGoeOV3j+EMatoHFZUinV3s6F9aWryPs3A0xhCLZgdJ6Zeea1d5LCQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/types": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-circle/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-color": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-color/-/plugin-color-1.6.1.tgz",
+      "integrity": "sha512-LtUN1vAP+LRlZAtTNVhDRSiXx+26Kbz3zJaG6a5k59gQ95jgT5mknnF8lxkHcqJthM4MEk3/tPxkdJpEybyF/A==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "tinycolor2": "^1.6.0",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-color/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-contain": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-contain/-/plugin-contain-1.6.1.tgz",
+      "integrity": "sha512-m0qhrfA8jkTqretGv4w+T/ADFR4GwBpE0sCOC2uJ0dzr44/ddOMsIdrpi89kabqYiPYIrxkgdCVCLm3zn1Vkkg==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/plugin-blit": "1.6.1",
+        "@jimp/plugin-resize": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-contain/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-cover": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-cover/-/plugin-cover-1.6.1.tgz",
+      "integrity": "sha512-hZytnsth0zoll6cPf434BrT+p/v569Wr5tyO6Dp0dH1IDPhzhB5F38sZGMLDo7bzQiN9JFVB3fxkcJ/WYCJ3Mg==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/plugin-crop": "1.6.1",
+        "@jimp/plugin-resize": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-cover/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-crop": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-crop/-/plugin-crop-1.6.1.tgz",
+      "integrity": "sha512-EerRSLlclXyKDnYc/H9w/1amZW7b7v3OGi/VlerPd2M/pAu5X8TkyYWtfqYCXnNp1Ixtd8oCo9zGfY9zoXT4rg==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-crop/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-displace": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-displace/-/plugin-displace-1.6.1.tgz",
+      "integrity": "sha512-K07QVl7xQwIfD6KfxRV/c3E9e7ZBXxUXdWuvoTWcKHL2qV48MOF5Nqbz/aJW4ThnQARIsxvYlZjPFiqkCjlU+g==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-displace/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-dither": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-dither/-/plugin-dither-1.6.1.tgz",
+      "integrity": "sha512-+2V+GCV2WycMoX1/z977TkZ8Zq/4MVSKElHYatgUqtwXMi2fDK2gKYU2g9V39IqFvTJsTIsK0+58VFz/ROBVew==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/types": "1.6.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-fisheye": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-fisheye/-/plugin-fisheye-1.6.1.tgz",
+      "integrity": "sha512-XtS5ZyoZ0vxZxJ6gkqI63SivhtI58vX95foMPM+cyzYkRsJXMOYCr8DScxF5bp4Xr003NjYm/P+7+08tibwzHA==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-fisheye/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-flip": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-flip/-/plugin-flip-1.6.1.tgz",
+      "integrity": "sha512-ws38W/sGj7LobNRayQ83garxiktOyWxM5vO/y4a/2cy9v65SLEUzVkrj+oeAaUSSObdz4HcCEla7XtGlnAGAaA==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/types": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-flip/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-hash": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-hash/-/plugin-hash-1.6.1.tgz",
+      "integrity": "sha512-sZt6ZcMX6i8vFWb4GYnw0pR/o9++ef0dTVcboTB5B/g7nrxCODIB4wfEkJ/YqZM5wUvol77K1qeS0/rVO6z21A==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/js-bmp": "1.6.1",
+        "@jimp/js-jpeg": "1.6.1",
+        "@jimp/js-png": "1.6.1",
+        "@jimp/js-tiff": "1.6.1",
+        "@jimp/plugin-color": "1.6.1",
+        "@jimp/plugin-resize": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "any-base": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-mask": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-mask/-/plugin-mask-1.6.1.tgz",
+      "integrity": "sha512-SIG0/FcmEj3tkwFxc7fAGLO8o4uNzMpSOdQOhbCgxefQKq5wOVMk9BQx/sdMPBwtMLr9WLq0GzLA/rk6t2v20A==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/types": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-mask/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-print": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-print/-/plugin-print-1.6.1.tgz",
+      "integrity": "sha512-BYVz/X3Xzv8XYilVeDy11NOp0h7BTDjlOtu0BekIFHP1yHVd24AXNzbOy52XlzYZWQ0Dl36HOHEpl/nSNrzc6w==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/js-jpeg": "1.6.1",
+        "@jimp/js-png": "1.6.1",
+        "@jimp/plugin-blit": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "parse-bmfont-ascii": "^1.0.6",
+        "parse-bmfont-binary": "^1.0.6",
+        "parse-bmfont-xml": "^1.1.6",
+        "simple-xml-to-json": "^1.2.2",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-print/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-quantize": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-quantize/-/plugin-quantize-1.6.1.tgz",
+      "integrity": "sha512-J2En9PLURfP+vwYDtuZ9T8yBW6BWYZBScydAjRiPBmJfEhTcNQqiiQODrZf7EqbbX/Sy5H6dAeRiqkgoV9N6Ww==",
+      "license": "MIT",
+      "dependencies": {
+        "image-q": "^4.0.0",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-quantize/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-resize": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-resize/-/plugin-resize-1.6.1.tgz",
+      "integrity": "sha512-CLkrtJoIz2HdWnpYiN6p8KYcPc00rCH/SUu6o+lfZL05Q4uhecJlnvXuj9x+U6mDn3ldPmJj6aZqMHuUJzdVqg==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-resize/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-rotate": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-rotate/-/plugin-rotate-1.6.1.tgz",
+      "integrity": "sha512-nOjVjbbj705B02ksysKnh0POAwEBXZtJ9zQ5qC+X7Tavl3JNn+P3BzQovbBxLPSbUSld6XID9z5ijin4PtOAUg==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/plugin-crop": "1.6.1",
+        "@jimp/plugin-resize": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-rotate/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/plugin-threshold": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/plugin-threshold/-/plugin-threshold-1.6.1.tgz",
+      "integrity": "sha512-JOKv9F8s6tnVLf4sB/2fF0F339EFnHvgEdFYugO6VhowKLsap0pEZmLyE/DlRnYtIj2RddHZVxVMp/eKJ04l2Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/plugin-color": "1.6.1",
+        "@jimp/plugin-hash": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1",
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/plugin-threshold/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/types": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/types/-/types-1.6.1.tgz",
+      "integrity": "sha512-leI7YbveTNi565m910XgIOwXyuu074H5qazAD1357HImJSv2hqxnWXpwxQbadGWZ7goZRYBDZy5lpqud0p7q5w==",
+      "license": "MIT",
+      "dependencies": {
+        "zod": "^3.23.8"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jimp/types/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@jimp/utils": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@jimp/utils/-/utils-1.6.1.tgz",
+      "integrity": "sha512-veFPRd93FCnS7AgmCkPgARVGoDRrJ9cm1ujuNyA+UfQ5VKbED2002sm5XfFLFwTsKC8j04heTrwe+tU1dluXOw==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/types": "1.6.1",
+        "tinycolor2": "^1.6.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/source-map": {
+      "version": "0.3.11",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.11.tgz",
+      "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.25"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@levischuck/tiny-cbor": {
+      "version": "0.2.11",
+      "resolved": "https://registry.npmjs.org/@levischuck/tiny-cbor/-/tiny-cbor-0.2.11.tgz",
+      "integrity": "sha512-llBRm4dT4Z89aRsm6u2oEZ8tfwL/2l6BwpZ7JcyieouniDECM5AqNgr/y08zalEIvW3RSK4upYyybDcmjXqAow==",
+      "license": "MIT"
+    },
+    "node_modules/@lukeed/csprng": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@lukeed/csprng/-/csprng-1.1.0.tgz",
+      "integrity": "sha512-Z7C/xXCiGWsg0KuKsHTKJxbWhpI3Vs5GwLfOean7MGyVFGqdRgBbAjOCh6u4bbjPc/8MJ2pZmK/0DLdCbivLDA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/@microsoft/tsdoc": {
+      "version": "0.16.0",
+      "resolved": "https://registry.npmjs.org/@microsoft/tsdoc/-/tsdoc-0.16.0.tgz",
+      "integrity": "sha512-xgAyonlVVS+q7Vc7qLW0UrJU7rSFcETRWsqdXZtjzRU8dF+6CkozTK4V4y1LwOX7j8r/vHphjDeMeGI4tNGeGA==",
+      "license": "MIT"
+    },
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "1.29.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.29.0.tgz",
+      "integrity": "sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ==",
+      "license": "MIT",
+      "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"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@cfworker/json-schema": "^4.1.1",
+        "zod": "^3.25 || ^4.0"
+      },
+      "peerDependenciesMeta": {
+        "@cfworker/json-schema": {
+          "optional": true
+        },
+        "zod": {
+          "optional": false
+        }
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/accepts": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
+      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "^3.0.0",
+        "negotiator": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/body-parser": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.3.0.tgz",
+      "integrity": "sha512-2cGmJupaNgg+QUwVLAucDuWuoMZ6EX9iHDRswZ5lsNYEmwPaRknMPCLZz07yTzVq/83p4o/wzbDZbBrTvGGTIw==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "^3.1.2",
+        "content-type": "^2.0.0",
+        "debug": "^4.4.3",
+        "http-errors": "^2.0.1",
+        "iconv-lite": "^0.7.2",
+        "on-finished": "^2.4.1",
+        "qs": "^6.15.2",
+        "raw-body": "^3.0.2",
+        "type-is": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/body-parser/node_modules/content-type": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.0.0.tgz",
+      "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/content-disposition": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.1.0.tgz",
+      "integrity": "sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/cookie-signature": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
+      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.6.0"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/express": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz",
+      "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "^2.0.0",
+        "body-parser": "^2.2.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"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/finalhandler": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz",
+      "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "on-finished": "^2.4.1",
+        "parseurl": "^1.3.3",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 18.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/fresh": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
+      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/iconv-lite": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
+      "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/media-typer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
+      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/merge-descriptors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
+      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/mime-types": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz",
+      "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/negotiator": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/send": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/send/-/send-1.2.1.tgz",
+      "integrity": "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==",
+      "license": "MIT",
+      "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"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/serve-static": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.1.tgz",
+      "integrity": "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "parseurl": "^1.3.3",
+        "send": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/type-is": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.1.0.tgz",
+      "integrity": "sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^2.0.0",
+        "media-typer": "^1.1.0",
+        "mime-types": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk/node_modules/type-is/node_modules/content-type": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.0.0.tgz",
+      "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@mswjs/interceptors": {
+      "version": "0.41.9",
+      "resolved": "https://registry.npmjs.org/@mswjs/interceptors/-/interceptors-0.41.9.tgz",
+      "integrity": "sha512-VVPPgHyQ6ShqnrmDWuxjmUIsO9gWyOZFmuOfLd9LfBGQJwZfy0gvv9pbHSJuoFNIYC7ZDX9aoFwowjcdSC4E8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@open-draft/deferred-promise": "^2.2.0",
+        "@open-draft/logger": "^0.3.0",
+        "@open-draft/until": "^2.0.0",
+        "is-node-process": "^1.2.0",
+        "outvariant": "^1.4.3",
+        "strict-event-emitter": "^0.5.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@mswjs/interceptors/node_modules/@open-draft/deferred-promise": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/@open-draft/deferred-promise/-/deferred-promise-2.2.0.tgz",
+      "integrity": "sha512-CecwLWx3rhxVQF6V4bAgPS5t+So2sTbPgAzafKkVizyi7tlwpcFpdFqq+wqF2OwNBmqFuu6tOyouTuxgpMfzmA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.5.tgz",
+      "integrity": "sha512-AWPoBRJ9tsnVhor4sjO7rkni+7p+2IAEFj6cx06UgP10jkQHqay/36uRV/bFkgrh18D9vb4cr8Q0Pthskgzy+Q==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@tybys/wasm-util": "^0.10.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "peerDependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1"
+      }
+    },
+    "node_modules/@nestjs/common": {
+      "version": "11.1.27",
+      "resolved": "https://registry.npmjs.org/@nestjs/common/-/common-11.1.27.tgz",
+      "integrity": "sha512-kEGSzqM2lWr4whh4Ubflw+oPZSEzxvRMu9WL+LveZploJWTjec5bBlCiRVlVzTPg2kIwBiLwWSvCCW7Wnin1gg==",
+      "license": "MIT",
+      "dependencies": {
+        "file-type": "21.3.4",
+        "iterare": "1.2.1",
+        "load-esm": "1.0.3",
+        "tslib": "2.8.1",
+        "uid": "2.0.2"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/nest"
+      },
+      "peerDependencies": {
+        "class-transformer": ">=0.4.1",
+        "class-validator": ">=0.13.2",
+        "reflect-metadata": "^0.1.12 || ^0.2.0",
+        "rxjs": "^7.1.0"
+      },
+      "peerDependenciesMeta": {
+        "class-transformer": {
+          "optional": true
+        },
+        "class-validator": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@nestjs/core": {
+      "version": "11.1.27",
+      "resolved": "https://registry.npmjs.org/@nestjs/core/-/core-11.1.27.tgz",
+      "integrity": "sha512-K6DX7hcqmZdeXkv7tsPakKBRCgqL19a4mtbX4FluY0hWtFdtPKp6lbe+lb8gWPfvLdbOWr/CPScn7BSjBX+Ecg==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-safe-stringify": "2.1.1",
+        "iterare": "1.2.1",
+        "path-to-regexp": "8.4.2",
+        "tslib": "2.8.1",
+        "uid": "2.0.2"
+      },
+      "engines": {
+        "node": ">= 20"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/nest"
+      },
+      "peerDependencies": {
+        "@nestjs/common": "^11.0.0",
+        "@nestjs/microservices": "^11.0.0",
+        "@nestjs/platform-express": "^11.0.0",
+        "@nestjs/websockets": "^11.0.0",
+        "reflect-metadata": "^0.1.12 || ^0.2.0",
+        "rxjs": "^7.1.0"
+      },
+      "peerDependenciesMeta": {
+        "@nestjs/microservices": {
+          "optional": true
+        },
+        "@nestjs/platform-express": {
+          "optional": true
+        },
+        "@nestjs/websockets": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@nestjs/mapped-types": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/@nestjs/mapped-types/-/mapped-types-2.1.1.tgz",
+      "integrity": "sha512-SCCoMEJ6jdeI5h/N+KCVF1+pmg/hmEkNA5nHTS8Gvww7T/LCl4o1gFLinw2iQ60w7slFkszHcGLKGdazVI4F8A==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@nestjs/common": "^10.0.0 || ^11.0.0",
+        "class-transformer": "^0.4.0 || ^0.5.0",
+        "class-validator": "^0.13.0 || ^0.14.0 || ^0.15.0",
+        "reflect-metadata": "^0.1.12 || ^0.2.0"
+      },
+      "peerDependenciesMeta": {
+        "class-transformer": {
+          "optional": true
+        },
+        "class-validator": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@nestjs/platform-express": {
+      "version": "11.1.27",
+      "resolved": "https://registry.npmjs.org/@nestjs/platform-express/-/platform-express-11.1.27.tgz",
+      "integrity": "sha512-0ZFhz6H6EdGh4xQVbUNwjoAwBuz73P7FvUAl67h9CTdMqQlJDaQYJApBv8pKfVZ1fGjMCbl0m9DcC6pXaZPWSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "cors": "2.8.6",
+        "express": "5.2.1",
+        "multer": "2.1.1",
+        "path-to-regexp": "8.4.2",
+        "tslib": "2.8.1"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/nest"
+      },
+      "peerDependencies": {
+        "@nestjs/common": "^11.0.0",
+        "@nestjs/core": "^11.0.0"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/accepts": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
+      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "^3.0.0",
+        "negotiator": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/body-parser": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.3.0.tgz",
+      "integrity": "sha512-2cGmJupaNgg+QUwVLAucDuWuoMZ6EX9iHDRswZ5lsNYEmwPaRknMPCLZz07yTzVq/83p4o/wzbDZbBrTvGGTIw==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "^3.1.2",
+        "content-type": "^2.0.0",
+        "debug": "^4.4.3",
+        "http-errors": "^2.0.1",
+        "iconv-lite": "^0.7.2",
+        "on-finished": "^2.4.1",
+        "qs": "^6.15.2",
+        "raw-body": "^3.0.2",
+        "type-is": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/body-parser/node_modules/content-type": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.0.0.tgz",
+      "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/body-parser/node_modules/type-is": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.1.0.tgz",
+      "integrity": "sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^2.0.0",
+        "media-typer": "^1.1.0",
+        "mime-types": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/content-disposition": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.1.0.tgz",
+      "integrity": "sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/cookie-signature": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
+      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.6.0"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/express": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz",
+      "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "^2.0.0",
+        "body-parser": "^2.2.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"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/express/node_modules/type-is": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.1.0.tgz",
+      "integrity": "sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^2.0.0",
+        "media-typer": "^1.1.0",
+        "mime-types": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/express/node_modules/type-is/node_modules/content-type": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.0.0.tgz",
+      "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/finalhandler": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz",
+      "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "on-finished": "^2.4.1",
+        "parseurl": "^1.3.3",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 18.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/fresh": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
+      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/iconv-lite": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
+      "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/media-typer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
+      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/merge-descriptors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
+      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/mime-types": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz",
+      "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/multer": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/multer/-/multer-2.1.1.tgz",
+      "integrity": "sha512-mo+QTzKlx8R7E5ylSXxWzGoXoZbOsRMpyitcht8By2KHvMbf3tjwosZ/Mu/XYU6UuJ3VZnODIrak5ZrPiPyB6A==",
+      "license": "MIT",
+      "dependencies": {
+        "append-field": "^1.0.0",
+        "busboy": "^1.6.0",
+        "concat-stream": "^2.0.0",
+        "type-is": "^1.6.18"
+      },
+      "engines": {
+        "node": ">= 10.16.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/negotiator": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/send": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/send/-/send-1.2.1.tgz",
+      "integrity": "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==",
+      "license": "MIT",
+      "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"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/platform-express/node_modules/serve-static": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.1.tgz",
+      "integrity": "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "parseurl": "^1.3.3",
+        "send": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/@nestjs/swagger": {
+      "version": "11.4.5",
+      "resolved": "https://registry.npmjs.org/@nestjs/swagger/-/swagger-11.4.5.tgz",
+      "integrity": "sha512-lvndlJmWBVDOUT0uEtLi6sSpW1syK2/nbAlHBhiELBORMpJGe9+EiWAT9qHtB10jW91L2Jmlwkr0/lttsYZrig==",
+      "license": "MIT",
+      "dependencies": {
+        "@microsoft/tsdoc": "0.16.0",
+        "@nestjs/mapped-types": "2.1.1",
+        "js-yaml": "4.3.0",
+        "lodash": "4.18.1",
+        "path-to-regexp": "8.4.2",
+        "swagger-ui-dist": "5.32.8"
+      },
+      "peerDependencies": {
+        "@fastify/static": "^8.0.0 || ^9.0.0",
+        "@nestjs/common": "^11.0.1",
+        "@nestjs/core": "^11.0.1",
+        "class-transformer": "*",
+        "class-validator": "*",
+        "reflect-metadata": "^0.1.12 || ^0.2.0"
+      },
+      "peerDependenciesMeta": {
+        "@fastify/static": {
+          "optional": true
+        },
+        "class-transformer": {
+          "optional": true
+        },
+        "class-validator": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@nestjs/testing": {
+      "version": "11.1.27",
+      "resolved": "https://registry.npmjs.org/@nestjs/testing/-/testing-11.1.27.tgz",
+      "integrity": "sha512-I35po13UHZZeGenLWJ3QYwh77RsLau5RcFKWBZ4waVHeARpwjtC7v7n7lGh98swLQdGmZgTnbvKaZ0B5dsUIKA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "2.8.1"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/nest"
+      },
+      "peerDependencies": {
+        "@nestjs/common": "^11.0.0",
+        "@nestjs/core": "^11.0.0",
+        "@nestjs/microservices": "^11.0.0",
+        "@nestjs/platform-express": "^11.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@nestjs/microservices": {
+          "optional": true
+        },
+        "@nestjs/platform-express": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@noble/hashes": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz",
+      "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==",
+      "license": "MIT",
+      "engines": {
+        "node": "^14.21.3 || >=16"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/@nodable/entities": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/@nodable/entities/-/entities-2.2.0.tgz",
+      "integrity": "sha512-9uGyhaQavEUMC8AIddIjau4NsnsXhou+j5sBAGojCM1oxmQpVKTWR/9JxABD6UAv12vpIms55fPZKFQEhG6uBg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodable"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/@open-draft/deferred-promise": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/@open-draft/deferred-promise/-/deferred-promise-3.0.0.tgz",
+      "integrity": "sha512-XW375UK8/9SqUVNVa6M0yEy8+iTi4QN5VZ7aZuRFQmy76LRwI9wy5F4YIBU6T+eTe2/DNDo8tqu8RHlwLHM6RA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@open-draft/logger": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/@open-draft/logger/-/logger-0.3.0.tgz",
+      "integrity": "sha512-X2g45fzhxH238HKO4xbSr7+wBS8Fvw6ixhTDuvLd5mqh6bJJCFAPwU9mPDxbcrRtfxv4u5IHCEH77BmxvXmmxQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-node-process": "^1.2.0",
+        "outvariant": "^1.4.0"
+      }
+    },
+    "node_modules/@open-draft/until": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@open-draft/until/-/until-2.1.0.tgz",
+      "integrity": "sha512-U69T3ItWHvLwGg5eJ0n3I62nWuE6ilHlmz7zM0npLBRvPRd7e6NYmg54vvRtP5mZG7kZqZCFVdsTWo7BPtBujg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@otplib/core": {
+      "version": "12.0.1",
+      "resolved": "https://registry.npmjs.org/@otplib/core/-/core-12.0.1.tgz",
+      "integrity": "sha512-4sGntwbA/AC+SbPhbsziRiD+jNDdIzsZ3JUyfZwjtKyc/wufl1pnSIaG4Uqx8ymPagujub0o92kgBnB89cuAMA==",
+      "license": "MIT"
+    },
+    "node_modules/@otplib/plugin-crypto": {
+      "version": "12.0.1",
+      "resolved": "https://registry.npmjs.org/@otplib/plugin-crypto/-/plugin-crypto-12.0.1.tgz",
+      "integrity": "sha512-qPuhN3QrT7ZZLcLCyKOSNhuijUi9G5guMRVrxq63r9YNOxxQjPm59gVxLM+7xGnHnM6cimY57tuKsjK7y9LM1g==",
+      "deprecated": "Please upgrade to v13 of otplib. Refer to otplib docs for migration paths",
+      "license": "MIT",
+      "dependencies": {
+        "@otplib/core": "^12.0.1"
+      }
+    },
+    "node_modules/@otplib/plugin-thirty-two": {
+      "version": "12.0.1",
+      "resolved": "https://registry.npmjs.org/@otplib/plugin-thirty-two/-/plugin-thirty-two-12.0.1.tgz",
+      "integrity": "sha512-MtT+uqRso909UkbrrYpJ6XFjj9D+x2Py7KjTO9JDPhL0bJUYVu5kFP4TFZW4NFAywrAtFRxOVY261u0qwb93gA==",
+      "deprecated": "Please upgrade to v13 of otplib. Refer to otplib docs for migration paths",
+      "license": "MIT",
+      "dependencies": {
+        "@otplib/core": "^12.0.1",
+        "thirty-two": "^1.0.2"
+      }
+    },
+    "node_modules/@otplib/preset-default": {
+      "version": "12.0.1",
+      "resolved": "https://registry.npmjs.org/@otplib/preset-default/-/preset-default-12.0.1.tgz",
+      "integrity": "sha512-xf1v9oOJRyXfluBhMdpOkr+bsE+Irt+0D5uHtvg6x1eosfmHCsCC6ej/m7FXiWqdo0+ZUI6xSKDhJwc8yfiOPQ==",
+      "deprecated": "Please upgrade to v13 of otplib. Refer to otplib docs for migration paths",
+      "license": "MIT",
+      "dependencies": {
+        "@otplib/core": "^12.0.1",
+        "@otplib/plugin-crypto": "^12.0.1",
+        "@otplib/plugin-thirty-two": "^12.0.1"
+      }
+    },
+    "node_modules/@otplib/preset-v11": {
+      "version": "12.0.1",
+      "resolved": "https://registry.npmjs.org/@otplib/preset-v11/-/preset-v11-12.0.1.tgz",
+      "integrity": "sha512-9hSetMI7ECqbFiKICrNa4w70deTUfArtwXykPUvSHWOdzOlfa9ajglu7mNCntlvxycTiOAXkQGwjQCzzDEMRMg==",
+      "license": "MIT",
+      "dependencies": {
+        "@otplib/core": "^12.0.1",
+        "@otplib/plugin-crypto": "^12.0.1",
+        "@otplib/plugin-thirty-two": "^12.0.1"
+      }
+    },
+    "node_modules/@oxc-project/types": {
+      "version": "0.133.0",
+      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.133.0.tgz",
+      "integrity": "sha512-KzkdCd6Uxqnf6l3HOw1xfatAlUURA0g14cvBYFyJ5SaNOQbOUvBr9PKArcPcrNIeRsBdgcUzOGrhKveVpvOIGA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/Boshen"
+      }
+    },
+    "node_modules/@paralleldrive/cuid2": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/@paralleldrive/cuid2/-/cuid2-2.3.1.tgz",
+      "integrity": "sha512-XO7cAxhnTZl0Yggq6jOgjiOHhbgcO4NqFqwSmQpjK3b6TEE6Uj/jfSk6wzYyemh3+I0sHirKSetjQwn5cZktFw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@noble/hashes": "^1.1.5"
+      }
+    },
+    "node_modules/@peculiar/asn1-android": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-android/-/asn1-android-2.8.0.tgz",
+      "integrity": "sha512-skLbS+IOGv1lUgDqtChr8xvtvEr3HMse/JGBaL2r1J1o/n7a8wqOrovMtlRq/UXLhxvmLaONP67hwtshgzwfzA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-cms": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-cms/-/asn1-cms-2.8.0.tgz",
+      "integrity": "sha512-NgekZOrSJFSBFLFoLfwePguAWAx7z1+f2TEsWFUMyiqqfntZ4+S/S5hzqME3q4pCA0iOsFKdwiQ35dwY24eVqA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "@peculiar/asn1-x509-attr": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-csr": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-csr/-/asn1-csr-2.8.0.tgz",
+      "integrity": "sha512-akbF8+uvleHs8sejNPQxwmVFuInAg6FMNHOwMILXfP518YfFJwdR3jr6oNUPOaEJfuEhn/vkNOCIT6ASUd4mbg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-ecc": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-ecc/-/asn1-ecc-2.8.0.tgz",
+      "integrity": "sha512-ohwlk+u9Rv2NOAY1c6MfHj45ATVF8R1DUN/WCgABiRtLi2ZftlZWZX7KvpAbU8v9xPcmoILfELeEABj/rn18AQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-pfx": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pfx/-/asn1-pfx-2.8.0.tgz",
+      "integrity": "sha512-5yof1ytoB++RQtaFbqSUJ8pxDJtZT6vbVqZ8XoJ61ph7UjNVvfFwAilnCodqkNsAodpy13gDhoxZXw00pghnyg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.8.0",
+        "@peculiar/asn1-pkcs8": "^2.8.0",
+        "@peculiar/asn1-rsa": "^2.8.0",
+        "@peculiar/asn1-schema": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-pkcs8": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.8.0.tgz",
+      "integrity": "sha512-qAKXtLpBEw9LqhKpjw3ajZSXlBur+ipW+y2ivVBQAG6F6qRx94yO+1ZR4mvw+YaCfKSaOzLeYEzsPaBp4SJELA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-pkcs9": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.8.0.tgz",
+      "integrity": "sha512-b5nDWCnkV60+cQ141D6sVVwK9nz64R5n3zSVnklGd+ECdkW2Ol3U1a6yYFlalpSOaD557yuJB64A+q42jG7lUQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.8.0",
+        "@peculiar/asn1-pfx": "^2.8.0",
+        "@peculiar/asn1-pkcs8": "^2.8.0",
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "@peculiar/asn1-x509-attr": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-rsa": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-rsa/-/asn1-rsa-2.8.0.tgz",
+      "integrity": "sha512-zHEUlCqB2mk7x2lxDwHHJy7hWZOPdGHVlsmITWKB5/PbQo61atbu9PJ/0r9dQNMwFzbKPXZ8uK8/91eUhRznSg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-schema": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-schema/-/asn1-schema-2.8.0.tgz",
+      "integrity": "sha512-7YT0U/ze0tF2QOBbE15gKZwy5tvgGyLRiRHLzhlbOpf7BT032oBSd0haZqXn5W6l26WLlu3dyxzjM+2638/z2Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/utils": "^2.0.2",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-x509": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509/-/asn1-x509-2.8.0.tgz",
+      "integrity": "sha512-N0CMuhWUzsWEVq6F1q9X6+VKUnWzSW+cSVg+aPaGGwDdbFoFWTYgin5MHwXgpWd6y9COMBxnfy/Qc+Xc7F0Zwg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/utils": "^2.0.2",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/asn1-x509-attr": {
+      "version": "2.8.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.8.0.tgz",
+      "integrity": "sha512-tHjkfS/qhMnmrlB2J9NhflQlQ7In3khO3CfmVrriOlpTeErY9ZIKOso1hQ5JQiyrJ7ShvqVPk7E5fQmbclkSKA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.8.0",
+        "@peculiar/asn1-x509": "^2.8.0",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/utils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@peculiar/utils/-/utils-2.0.3.tgz",
+      "integrity": "sha512-+oL3HPFRIZ1St2K50lWCXiioIgSoxzz7R1J3uF6neO2yl1sgmpgY6XXJH4BdpoDkMWznQTeYF6oWNDZLCdQ4eQ==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/x509": {
+      "version": "1.14.3",
+      "resolved": "https://registry.npmjs.org/@peculiar/x509/-/x509-1.14.3.tgz",
+      "integrity": "sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.6.0",
+        "@peculiar/asn1-csr": "^2.6.0",
+        "@peculiar/asn1-ecc": "^2.6.0",
+        "@peculiar/asn1-pkcs9": "^2.6.0",
+        "@peculiar/asn1-rsa": "^2.6.0",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.0",
+        "pvtsutils": "^1.3.6",
+        "reflect-metadata": "^0.2.2",
+        "tslib": "^2.8.1",
+        "tsyringe": "^4.10.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@pkgr/core": {
+      "version": "0.3.6",
+      "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.3.6.tgz",
+      "integrity": "sha512-SEeaJLb3qBNF/OaXnaR1NmmBbFYk1zC0ZH/52fATcRPLFg/p791YrcyFFy44Bo9sLaGuSuLp5Q6axbb/O+v/RA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/pkgr"
+      }
+    },
+    "node_modules/@quansync/fs": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/@quansync/fs/-/fs-1.0.0.tgz",
+      "integrity": "sha512-4TJ3DFtlf1L5LDMaM6CanJ/0lckGNtJcMjQ1NAV6zDmA0tEHKZtxNKin8EgPaVX1YzljbxckyT2tJrpQKAtngQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "quansync": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sxzz"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-gnu": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.0.3.tgz",
+      "integrity": "sha512-B8m6tD5+/N5FeNQFbKlLA/2yVq9ycQP1SeedyEYYKWBNR3ZQbkvIUcNnDNM03lO1l5F2roiiFJGgvoLLyZXtSg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/binding-linux-x64-musl": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.0.3.tgz",
+      "integrity": "sha512-pSdpdUJHkuCxun9LE7jvgUB9qsRgaiyNNCX7m/AvHTcq67AiT/Yhoxvw5zPfhrM8k/BfP8ce/hMOpthKDpEUow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz",
+      "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/pluginutils": {
+      "version": "5.4.0",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.4.0.tgz",
+      "integrity": "sha512-MfPp06CjRLfXQ3wY0R8vJDYBy/MvVcc9OulEfR0B8Iv9ko+GCNaRZ+EpJYFl27LhKsZK0o420sYCRHCjfCgeUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "estree-walker": "^2.0.2",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/pluginutils/node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/pluginutils/node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.62.0.tgz",
+      "integrity": "sha512-7SDIalKeIpG0Ifogbbdn58HmSotYMlf23K3dCJEmiVd9Fg36Vmni82iPQec27N3wY4Bvbxftkxz6vSx9OcouTg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.62.0.tgz",
+      "integrity": "sha512-eRZevouTH2i1HeAVLqJuLnt256krQkGY0TN6WsTmsIhuzbh457HuWDMakKwmi0Cjadux983CoSr8Lim2QhUIFw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@scarf/scarf": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/@scarf/scarf/-/scarf-1.4.0.tgz",
+      "integrity": "sha512-xxeapPiUXdZAE3che6f3xogoJPeZgig6omHEy1rIY5WVsB3H2BHNnZH+gHG6x91SCWyQCzWGsuL2Hh3ClO5/qQ==",
+      "hasInstallScript": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/@simplewebauthn/server": {
+      "version": "13.3.1",
+      "resolved": "https://registry.npmjs.org/@simplewebauthn/server/-/server-13.3.1.tgz",
+      "integrity": "sha512-GV/oM/qeycWn8p42JZIMJBsXWQcNFg+nJFzeQTnMA4gN8mXg0+HZFWJerHg8ZN/zlveMS3iV1wzuFpOVWS/46w==",
+      "license": "MIT",
+      "dependencies": {
+        "@hexagon/base64": "^1.1.27",
+        "@levischuck/tiny-cbor": "^0.2.2",
+        "@peculiar/asn1-android": "^2.6.0",
+        "@peculiar/asn1-ecc": "^2.6.1",
+        "@peculiar/asn1-rsa": "^2.6.1",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "@peculiar/x509": "^1.14.3"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@swc/core": {
+      "version": "1.15.41",
+      "resolved": "https://registry.npmjs.org/@swc/core/-/core-1.15.41.tgz",
+      "integrity": "sha512-03nQq/082QRJJiOvp3FGbgxTGyyxMxohPTjhk/W9bD2J0tk4ukITI7goOhOO2WbaHn/lsPmo/zf8+DIXhwpgYQ==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@swc/counter": "^0.1.3",
+        "@swc/types": "^0.1.26"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/swc"
+      },
+      "optionalDependencies": {
+        "@swc/core-darwin-arm64": "1.15.41",
+        "@swc/core-darwin-x64": "1.15.41",
+        "@swc/core-linux-arm-gnueabihf": "1.15.41",
+        "@swc/core-linux-arm64-gnu": "1.15.41",
+        "@swc/core-linux-arm64-musl": "1.15.41",
+        "@swc/core-linux-ppc64-gnu": "1.15.41",
+        "@swc/core-linux-s390x-gnu": "1.15.41",
+        "@swc/core-linux-x64-gnu": "1.15.41",
+        "@swc/core-linux-x64-musl": "1.15.41",
+        "@swc/core-win32-arm64-msvc": "1.15.41",
+        "@swc/core-win32-ia32-msvc": "1.15.41",
+        "@swc/core-win32-x64-msvc": "1.15.41"
+      },
+      "peerDependencies": {
+        "@swc/helpers": ">=0.5.17"
+      },
+      "peerDependenciesMeta": {
+        "@swc/helpers": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@swc/core-linux-x64-gnu": {
+      "version": "1.15.41",
+      "resolved": "https://registry.npmjs.org/@swc/core-linux-x64-gnu/-/core-linux-x64-gnu-1.15.41.tgz",
+      "integrity": "sha512-VxkuQK59c0tHm6uJZCUrS3cyA2JhGGfdU6e41SZz0x/JS+4Sm7C1mIc97In14vkZJopEt7yXA2TouCqZDSygEA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 AND MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@swc/core-linux-x64-musl": {
+      "version": "1.15.41",
+      "resolved": "https://registry.npmjs.org/@swc/core-linux-x64-musl/-/core-linux-x64-musl-1.15.41.tgz",
+      "integrity": "sha512-/0qXIu1ZxggLuovLb22vFfKHq2AA4n6Whw5UwmVCHk4pkw7KWnPIQpMCEqUMPsNkFJig7PPp/TSYFu8ZEb2rtQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 AND MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@swc/counter": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/@swc/counter/-/counter-0.1.3.tgz",
+      "integrity": "sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/@swc/helpers": {
+      "version": "0.5.23",
+      "resolved": "https://registry.npmjs.org/@swc/helpers/-/helpers-0.5.23.tgz",
+      "integrity": "sha512-5lSsMOTXURePglDfvuAQUqkGek9Hg2kksOYay2m0+XR++b2NWYL/4sWyuvVBIs8oKnJaxkdi9whaL/sqN13afw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.8.0"
+      }
+    },
+    "node_modules/@swc/types": {
+      "version": "0.1.27",
+      "resolved": "https://registry.npmjs.org/@swc/types/-/types-0.1.27.tgz",
+      "integrity": "sha512-K6h3iUlqeM946U4sXFYeahefR1YBbXJvko+hv8WS8/0BNJ4OHiHRywMnQUJCqkR7Y9+hqQ1TvEpiKqUhz7NEFg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@swc/counter": "^0.1.3"
+      }
+    },
+    "node_modules/@tokenizer/inflate": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@tokenizer/inflate/-/inflate-0.4.1.tgz",
+      "integrity": "sha512-2mAv+8pkG6GIZiF1kNg1jAjh27IDxEPKwdGul3snfztFerfPGI1LjDezZp3i7BElXompqEtPmoPx6c2wgtWsOA==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.3",
+        "token-types": "^6.1.1"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Borewit"
+      }
+    },
+    "node_modules/@tokenizer/token": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/@tokenizer/token/-/token-0.3.0.tgz",
+      "integrity": "sha512-OvjF+z51L3ov0OyAU0duzsYuvO01PH7x4t6DJx+guahgTnBHkhJdG7soQeTSFLWN3efnHyibZ4Z8l2EuWwJN3A==",
+      "license": "MIT"
+    },
+    "node_modules/@trek/server": {
+      "resolved": "server",
+      "link": true
+    },
+    "node_modules/@trek/shared": {
+      "resolved": "shared",
+      "link": true
+    },
+    "node_modules/@trivago/prettier-plugin-sort-imports": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@trivago/prettier-plugin-sort-imports/-/prettier-plugin-sort-imports-6.0.2.tgz",
+      "integrity": "sha512-3DgfkukFyC/sE/VuYjaUUWoFfuVjPK55vOFDsxD56XXynFMCZDYFogH2l/hDfOsQAm1myoU/1xByJ3tWqtulXA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@babel/generator": "^7.28.0",
+        "@babel/parser": "^7.28.0",
+        "@babel/traverse": "^7.28.0",
+        "@babel/types": "^7.28.0",
+        "javascript-natural-sort": "^0.7.1",
+        "lodash-es": "^4.17.21",
+        "minimatch": "^9.0.0",
+        "parse-imports-exports": "^0.2.4"
+      },
+      "engines": {
+        "node": ">= 20"
+      },
+      "peerDependencies": {
+        "@vue/compiler-sfc": "3.x",
+        "prettier": "2.x - 3.x",
+        "prettier-plugin-ember-template-tag": ">= 2.0.0",
+        "prettier-plugin-svelte": "3.x",
+        "svelte": "4.x || 5.x"
+      },
+      "peerDependenciesMeta": {
+        "@vue/compiler-sfc": {
+          "optional": true
+        },
+        "prettier-plugin-ember-template-tag": {
+          "optional": true
+        },
+        "prettier-plugin-svelte": {
+          "optional": true
+        },
+        "svelte": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.2",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.2.tgz",
+      "integrity": "sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@types/archiver": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/@types/archiver/-/archiver-7.0.0.tgz",
+      "integrity": "sha512-/3vwGwx9n+mCQdYZ2IKGGHEFL30I96UgBlk8EtRDDFQ9uxM1l4O5Ci6r00EMAkiDaTqD9DQ6nVrWRICnBPtzzg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/readdir-glob": "*"
+      }
+    },
+    "node_modules/@types/bcryptjs": {
+      "version": "2.4.6",
+      "resolved": "https://registry.npmjs.org/@types/bcryptjs/-/bcryptjs-2.4.6.tgz",
+      "integrity": "sha512-9xlo6R2qDs5uixm0bcIqCeMCE6HiQsIyel9KQySStiyqNl2tnj2mP3DX1Nf56MD6KMenNNlBBsy3LJ7gUEQPXQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/better-sqlite3": {
+      "version": "7.6.13",
+      "resolved": "https://registry.npmjs.org/@types/better-sqlite3/-/better-sqlite3-7.6.13.tgz",
+      "integrity": "sha512-NMv9ASNARoKksWtsq/SHakpYAYnhBrQgGD8zkLYk/jaK8jUGn08CfEdTRgYhMypUQAfzSP8W6gNLe0q19/t4VA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/body-parser": {
+      "version": "1.19.6",
+      "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz",
+      "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/connect": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/chai": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",
+      "integrity": "sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*",
+        "assertion-error": "^2.0.1"
+      }
+    },
+    "node_modules/@types/connect": {
+      "version": "3.4.38",
+      "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz",
+      "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/cookie-parser": {
+      "version": "1.4.10",
+      "resolved": "https://registry.npmjs.org/@types/cookie-parser/-/cookie-parser-1.4.10.tgz",
+      "integrity": "sha512-B4xqkqfZ8Wek+rCOeRxsjMS9OgvzebEzzLYw7NHYuvzb7IdxOkI0ZHGgeEBX4PUM7QGVvNSK60T3OvWj3YfBRg==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "@types/express": "*"
+      }
+    },
+    "node_modules/@types/cookiejar": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@types/cookiejar/-/cookiejar-2.1.5.tgz",
+      "integrity": "sha512-he+DHOWReW0nghN24E1WUqM0efK4kI9oTqDm6XmK8ZPe2djZ90BSNdGnIyCLzCPw7/pogPlGbzI2wHGGmi4O/Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/cors": {
+      "version": "2.8.19",
+      "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
+      "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/esrecurse": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/@types/esrecurse/-/esrecurse-4.3.1.tgz",
+      "integrity": "sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/express": {
+      "version": "4.17.25",
+      "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.25.tgz",
+      "integrity": "sha512-dVd04UKsfpINUnK0yBoYHDF3xu7xVH4BuDotC/xGuycx4CgbP48X/KF/586bcObxT0HENHXEU8Nqtu6NR+eKhw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/body-parser": "*",
+        "@types/express-serve-static-core": "^4.17.33",
+        "@types/qs": "*",
+        "@types/serve-static": "^1"
+      }
+    },
+    "node_modules/@types/express-serve-static-core": {
+      "version": "4.19.8",
+      "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.8.tgz",
+      "integrity": "sha512-02S5fmqeoKzVZCHPZid4b8JH2eM5HzQLZWN2FohQEy/0eXTq8VXZfSN6Pcr3F6N9R/vNrj7cpgbhjie6m/1tCA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*",
+        "@types/qs": "*",
+        "@types/range-parser": "*",
+        "@types/send": "*"
+      }
+    },
+    "node_modules/@types/http-errors": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.5.tgz",
+      "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/jsesc": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/@types/jsesc/-/jsesc-2.5.1.tgz",
+      "integrity": "sha512-9VN+6yxLOPLOav+7PwjZbxiID2bVaeq0ED4qSQmdQTdjnXJSaCVKTR58t15oqH1H5t8Ng2ZX1SabJVoN9Q34bw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/jsonwebtoken": {
+      "version": "9.0.10",
+      "resolved": "https://registry.npmjs.org/@types/jsonwebtoken/-/jsonwebtoken-9.0.10.tgz",
+      "integrity": "sha512-asx5hIG9Qmf/1oStypjanR7iKTv0gXQ1Ov/jfrX6kS/EO0OFni8orbmGCn0672NHR3kXHwpAwR+B368ZGN/2rA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/ms": "*",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/methods": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/@types/methods/-/methods-1.1.4.tgz",
+      "integrity": "sha512-ymXWVrDiCxTBE3+RIrrP533E70eA+9qu7zdWoHuOmGujkYtzf4HQF96b8nwHLqhuf4ykX61IGRIB38CC6/sImQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/mime": {
+      "version": "1.3.5",
+      "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz",
+      "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/ms": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+      "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+      "license": "MIT"
+    },
+    "node_modules/@types/multer": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@types/multer/-/multer-2.1.0.tgz",
+      "integrity": "sha512-zYZb0+nJhOHtPpGDb3vqPjwpdeGlGC157VpkqNQL+UU2qwoacoQ7MpsAmUptI/0Oa127X32JzWDqQVEXp2RcIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/express": "*"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "25.9.3",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.9.3.tgz",
+      "integrity": "sha512-603BddQMv3pUcr4U2dhujk83N2tTDVr/34wII2B6bJy6g+8WD6yUb11jszNs0gdi4PesVWl7ABt8nYMVpnLUcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": ">=7.24.0 <7.24.7"
+      }
+    },
+    "node_modules/@types/node-cron": {
+      "version": "3.0.11",
+      "resolved": "https://registry.npmjs.org/@types/node-cron/-/node-cron-3.0.11.tgz",
+      "integrity": "sha512-0ikrnug3/IyneSHqCBeslAhlK2aBfYek1fGo4bP4QnZPmiqSGRK+Oy7ZMisLWkesffJvQ1cqAcBnJC+8+nxIAg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/nodemailer": {
+      "version": "7.0.12",
+      "resolved": "https://registry.npmjs.org/@types/nodemailer/-/nodemailer-7.0.12.tgz",
+      "integrity": "sha512-80vKwiIsVSyFA1rRovH59jNPLBOuc6dRZIHEu40gXTkBkZnQv8vog1xSGEb9j5q/tdMAs5ivvDR2pLTU0hGHXA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/qrcode": {
+      "version": "1.5.6",
+      "resolved": "https://registry.npmjs.org/@types/qrcode/-/qrcode-1.5.6.tgz",
+      "integrity": "sha512-te7NQcV2BOvdj2b1hCAHzAoMNuj65kNBMz0KBaxM6c3VGBOhU0dURQKOtH8CFNI/dsKkwlv32p26qYQTWoB5bw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/qs": {
+      "version": "6.15.1",
+      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.15.1.tgz",
+      "integrity": "sha512-GZHUBZR9hckSUhrxmp1nG6NwdpM9fCunJwyThLW1X3AyHgd9IlHb6VANpQQqDr2o/qQp6McZ3y/IA2rVzKzSbw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/range-parser": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz",
+      "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/readdir-glob": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@types/readdir-glob/-/readdir-glob-1.1.5.tgz",
+      "integrity": "sha512-raiuEPUYqXu+nvtY2Pe8s8FEmZ3x5yAH4VkLdihcPdalvsHltomrRC9BzuStrJ9yk06470hS0Crw0f1pXqD+Hg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/semver": {
+      "version": "7.7.1",
+      "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.7.1.tgz",
+      "integrity": "sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/send": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@types/send/-/send-1.2.1.tgz",
+      "integrity": "sha512-arsCikDvlU99zl1g69TcAB3mzZPpxgw0UQnaHeC1Nwb015xp8bknZv5rIfri9xTOcMuaVgvabfIRA7PSZVuZIQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/serve-static": {
+      "version": "1.15.10",
+      "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.10.tgz",
+      "integrity": "sha512-tRs1dB+g8Itk72rlSI2ZrW6vZg0YrLI81iQSTkMmOqnqCaNr/8Ek4VwWcN5vZgCYWbg/JJSGBlUaYGAOP73qBw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/http-errors": "*",
+        "@types/node": "*",
+        "@types/send": "<1"
+      }
+    },
+    "node_modules/@types/serve-static/node_modules/@types/send": {
+      "version": "0.17.6",
+      "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.6.tgz",
+      "integrity": "sha512-Uqt8rPBE8SY0RK8JB1EzVOIZ32uqy8HwdxCnoCOsYrvnswqmFZ/k+9Ikidlk/ImhsdvBsloHbAlewb2IEBV/Og==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/mime": "^1",
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/set-cookie-parser": {
+      "version": "2.4.10",
+      "resolved": "https://registry.npmjs.org/@types/set-cookie-parser/-/set-cookie-parser-2.4.10.tgz",
+      "integrity": "sha512-GGmQVGpQWUe5qglJozEjZV/5dyxbOOZ0LHe/lqyWssB88Y4svNfst0uqBVscdDeIKl5Jy5+aPSvy7mI9tYRguw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/statuses": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/@types/statuses/-/statuses-2.0.6.tgz",
+      "integrity": "sha512-xMAgYwceFhRA2zY+XbEA7mxYbA093wdiW8Vu6gZPGWy9cmOyU9XesH1tNcEWsKFd5Vzrqx5T3D38PWx1FIIXkA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/superagent": {
+      "version": "8.1.10",
+      "resolved": "https://registry.npmjs.org/@types/superagent/-/superagent-8.1.10.tgz",
+      "integrity": "sha512-nbt4IWXABhW0jGmmpRzCFNlbmwCTzZ2gTUsNIr+X+ItdqPms+PAJZbWsNzpS2USqXjcoNLQcO6nXo60zcPQiIg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/cookiejar": "^2.1.5",
+        "@types/methods": "^1.1.4",
+        "@types/node": "*",
+        "form-data": "^4.0.0"
+      }
+    },
+    "node_modules/@types/supertest": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/@types/supertest/-/supertest-6.0.3.tgz",
+      "integrity": "sha512-8WzXq62EXFhJ7QsH3Ocb/iKQ/Ty9ZVWnVzoTKc9tyyFRRF3a74Tk2+TLFgaFFw364Ere+npzHKEJ6ga2LzIL7w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/methods": "^1.1.4",
+        "@types/superagent": "^8.1.0"
+      }
+    },
+    "node_modules/@types/trusted-types": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz",
+      "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
+      "devOptional": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/unzipper": {
+      "version": "0.10.11",
+      "resolved": "https://registry.npmjs.org/@types/unzipper/-/unzipper-0.10.11.tgz",
+      "integrity": "sha512-D25im2zjyMCcgL9ag6N46+wbtJBnXIr7SI4zHf9eJD2Dw2tEB5e+p5MYkrxKIVRscs5QV0EhtU9rgXSPx90oJg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/uuid": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/@types/uuid/-/uuid-10.0.0.tgz",
+      "integrity": "sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@typescript-eslint/eslint-plugin": {
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.61.1.tgz",
+      "integrity": "sha512-ZPlVl3PB3et/59Ne0fv/sci6ZXz4T4Hp4nTJ56i/Y0gR89ARb+KphojTq6j+56E5PIezmOIOOWyY+aWQFd+IkQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/regexpp": "^4.12.2",
+        "@typescript-eslint/scope-manager": "8.61.1",
+        "@typescript-eslint/type-utils": "8.61.1",
+        "@typescript-eslint/utils": "8.61.1",
+        "@typescript-eslint/visitor-keys": "8.61.1",
+        "ignore": "^7.0.5",
+        "natural-compare": "^1.4.0",
+        "ts-api-utils": "^2.5.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "@typescript-eslint/parser": "^8.61.1",
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/eslint-plugin/node_modules/ignore": {
+      "version": "7.0.5",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-7.0.5.tgz",
+      "integrity": "sha512-Hs59xBNfUIunMFgWAbGX5cq6893IbWg4KnrjbYwX3tx0ztorVgTDA6B2sxf8ejHJ4wz8BqGUMYlnzNBer5NvGg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/@typescript-eslint/parser": {
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.61.1.tgz",
+      "integrity": "sha512-PJ5vePq5/ognBbrIcoC5+SHO5dfpeLPzP9FpLkzWrguoYQEeeSjlJpVwOpo1JRSTEi7dRcwNy4h4dzV70PqHcg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/scope-manager": "8.61.1",
+        "@typescript-eslint/types": "8.61.1",
+        "@typescript-eslint/typescript-estree": "8.61.1",
+        "@typescript-eslint/visitor-keys": "8.61.1",
+        "debug": "^4.4.3"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/project-service": {
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.61.1.tgz",
+      "integrity": "sha512-PrC4JYGmR241lYnfhmKGTXkFqv8+ymbTFgSAY0fVXpY82/QkMw5TZPl+vGzuDDU2QYJk9fIDOBTntF+yDv9LEA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/tsconfig-utils": "^8.61.1",
+        "@typescript-eslint/types": "^8.61.1",
+        "debug": "^4.4.3"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/scope-manager": {
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.61.1.tgz",
+      "integrity": "sha512-L2bdIeoQS8FlKAvONAr20w6OcLXeB+qiDKbAooS9A0Ben+iSIkBef0FxqwKWYqt5sa0i4KJtxVyVmhMylKzF5w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.61.1",
+        "@typescript-eslint/visitor-keys": "8.61.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/tsconfig-utils": {
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.61.1.tgz",
+      "integrity": "sha512-UN/H4di+OO7EWx2ovME+8t31YO+KVnK0RRKEHR3kOt21/Ay8BOq3M1OMvWs5vNiqcFCYGYoxK3MXPZzmMUE+yg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/type-utils": {
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.61.1.tgz",
+      "integrity": "sha512-GYRicKmVK0C4fsKgaACaknOUAq9Oa2kwsjnpFhFcS/5p4Ht5IP9OVLbgIgcK4SRk92nVHFluurg1lumD9dBcLw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.61.1",
+        "@typescript-eslint/typescript-estree": "8.61.1",
+        "@typescript-eslint/utils": "8.61.1",
+        "debug": "^4.4.3",
+        "ts-api-utils": "^2.5.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/types": {
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.61.1.tgz",
+      "integrity": "sha512-G+CRlPqLv7Bz1IZVs03x5K59F1veqL0EJUROAdGhKsEq8qOiRiZbI+HUojPq5l0fEGOKModD9br6lObhB8zkoA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree": {
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.61.1.tgz",
+      "integrity": "sha512-u+oQD3BqYWPc8YV9Zab4vaJElJuwOLPRc10Jm1o/qS+6Qwen14HCWwx0Seo4LnSn2wxea2Ik8DxPt2/FHmuhrg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/project-service": "8.61.1",
+        "@typescript-eslint/tsconfig-utils": "8.61.1",
+        "@typescript-eslint/types": "8.61.1",
+        "@typescript-eslint/visitor-keys": "8.61.1",
+        "debug": "^4.4.3",
+        "minimatch": "^10.2.2",
+        "semver": "^7.7.3",
+        "tinyglobby": "^0.2.15",
+        "ts-api-utils": "^2.5.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/brace-expansion": {
+      "version": "5.0.6",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
+      "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
+      "version": "10.2.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
+      "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "brace-expansion": "^5.0.5"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@typescript-eslint/utils": {
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.61.1.tgz",
+      "integrity": "sha512-1+P/3Dj6jvtybE1q0HQ6yBt/gq+oKJyLdEv4HdnqasaEXRSYCAsD59mXEVQnM/ULNdQxbX77tdG4jPRjIS6knA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.9.1",
+        "@typescript-eslint/scope-manager": "8.61.1",
+        "@typescript-eslint/types": "8.61.1",
+        "@typescript-eslint/typescript-estree": "8.61.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/@typescript-eslint/visitor-keys": {
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.61.1.tgz",
+      "integrity": "sha512-6fJ9MHWtK14C1DSkiMlHUSOmrVebL7150xZJBlJiL62jjhIA4JmOq6flwBgDxIdBKKdoiZRel+dfPD5MLfny3w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/types": "8.61.1",
+        "eslint-visitor-keys": "^5.0.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      }
+    },
+    "node_modules/@vitest/coverage-istanbul": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/coverage-istanbul/-/coverage-istanbul-4.1.9.tgz",
+      "integrity": "sha512-4a7DsIwycTf4eYwEDtnMfMV8H80KSKH9PuMHhqL5SwPZzDyUKq2X/TPCVZ7NqIuSz7UbZckmEmkip6iZBI/gEA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.29.0",
+        "@istanbuljs/schema": "^0.1.3",
+        "@jridgewell/gen-mapping": "^0.3.13",
+        "@jridgewell/trace-mapping": "0.3.31",
+        "istanbul-lib-coverage": "^3.2.2",
+        "istanbul-lib-report": "^3.0.1",
+        "istanbul-reports": "^3.2.0",
+        "magicast": "^0.5.2",
+        "obug": "^2.1.1",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "vitest": "4.1.9"
+      }
+    },
+    "node_modules/@vitest/coverage-v8": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/coverage-v8/-/coverage-v8-4.1.9.tgz",
+      "integrity": "sha512-G9/lgqibheLVBDRuya45EbsEXTYcWoSG+TLg7i2axuzx0Eq62eXn+aWXyaVdV5vKvFSWd6ywcX8hA7la9Pvu8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@bcoe/v8-coverage": "^1.0.2",
+        "@vitest/utils": "4.1.9",
+        "ast-v8-to-istanbul": "^1.0.0",
+        "istanbul-lib-coverage": "^3.2.2",
+        "istanbul-lib-report": "^3.0.1",
+        "istanbul-reports": "^3.2.0",
+        "magicast": "^0.5.2",
+        "obug": "^2.1.1",
+        "std-env": "^4.0.0-rc.1",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@vitest/browser": "4.1.9",
+        "vitest": "4.1.9"
+      },
+      "peerDependenciesMeta": {
+        "@vitest/browser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.9.tgz",
+      "integrity": "sha512-vl/rYsUKcBr3SnQn166+XR5ZQcgMx3DQhFWdfli/cWpLnLUmbxZvyrJZotLFUryib+LtArYMSTJ5RbQ57ZqrlA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.1.0",
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "4.1.9",
+        "@vitest/utils": "4.1.9",
+        "chai": "^6.2.2",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-4.1.9.tgz",
+      "integrity": "sha512-EVkXzBjrPGM+cK8/ANWgBrkUCfJfb38/EfTSO8h7pWvKkyPkpWxvR7BkD2MyItMF62C97zAEoqdpUixwR/e+Rw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "4.1.9",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.21"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-4.1.9.tgz",
+      "integrity": "sha512-s0iufns3iIFitdgm+YR7g1whCAaGtXz459VS9/PqyKDEEFgYIhsHOQmXgIgDuYCt7DeQmiZT0Qe2OA2p4ZPu5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-4.1.9.tgz",
+      "integrity": "sha512-KXLMDtc7oe70+3mJfGrPUWPesswH+3sTxAMAMl8DG7I8IUQT4XW718dY5ID3vPUcmlu27CcKfY4P3h3I29SLJg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "4.1.9",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-4.1.9.tgz",
+      "integrity": "sha512-Jc7RKGNBo8Z28WYIm0Niej4xdSPByRf6mU58VpHQkd6Zh05rlnA+twjbK5HyeIGHxrzsc3mJgS43uM0CZKzaIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.9",
+        "@vitest/utils": "4.1.9",
+        "magic-string": "^0.30.21",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-4.1.9.tgz",
+      "integrity": "sha512-fHpsS6mIi+PiEW+vcRVOMkX1oSaPKne3VOclSFICPcGOmfKgXPU5iAah+wcNcj2xPrCCmfq99IDGf+EojhhvhA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-4.1.9.tgz",
+      "integrity": "sha512-A51o8ymO5PpqlWNnBP9ZHPXDIpuMtTLlGSjN7la4US+LJzoUMyhwjA5QXlm39JexgwHKW4Xjs8Z2d3dLCXOeuA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "4.1.9",
+        "convert-source-map": "^2.0.0",
+        "tinyrainbow": "^3.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.17.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.17.0.tgz",
+      "integrity": "sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz",
+      "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ajv-formats": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz",
+      "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "ajv": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/ansis": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/ansis/-/ansis-4.3.1.tgz",
+      "integrity": "sha512-BJ8/l4R5LRE7hW9WdSuGYrLSHi2ynxeFpDFbH0K/CgNeY/tyhk+vO6TYxXC5r5CpUhNVX310xzPsN/H9lCdfOA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/any-base": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/any-base/-/any-base-1.1.0.tgz",
+      "integrity": "sha512-uMgjozySS8adZZYePpaWs8cxB9/kdzmpX6SgJZ+wbz1K5eYk5QMYDVJaZKhxyIHUdnnJkfR7SVgStgH7LkGUyg==",
+      "license": "MIT"
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/anynum": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/anynum/-/anynum-1.0.0.tgz",
+      "integrity": "sha512-xjR9/zBVnUOP6ztMIIgShjsxui80nQUQH+5xJnvrYLs+90bF25/KJqaAi8mk+B4RDtX1Nspi6fmp4YTEts8SfA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/append-field": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/append-field/-/append-field-1.0.0.tgz",
+      "integrity": "sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw==",
+      "license": "MIT"
+    },
+    "node_modules/archiver": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/archiver/-/archiver-6.0.2.tgz",
+      "integrity": "sha512-UQ/2nW7NMl1G+1UnrLypQw1VdT9XZg/ECcKPq7l+STzStrSivFIXIp34D8M5zeNGW5NoOupdYCHv6VySCPNNlw==",
+      "license": "MIT",
+      "dependencies": {
+        "archiver-utils": "^4.0.1",
+        "async": "^3.2.4",
+        "buffer-crc32": "^0.2.1",
+        "readable-stream": "^3.6.0",
+        "readdir-glob": "^1.1.2",
+        "tar-stream": "^3.0.0",
+        "zip-stream": "^5.0.1"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      }
+    },
+    "node_modules/archiver-utils": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/archiver-utils/-/archiver-utils-4.0.1.tgz",
+      "integrity": "sha512-Q4Q99idbvzmgCTEAAhi32BkOyq8iVI5EwdO0PmBDSGIzzjYNdcFn7Q7k3OzbLy4kLUPXfJtG6fO2RjftXbobBg==",
+      "license": "MIT",
+      "dependencies": {
+        "glob": "^8.0.0",
+        "graceful-fs": "^4.2.0",
+        "lazystream": "^1.0.0",
+        "lodash": "^4.17.15",
+        "normalize-path": "^3.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "license": "Python-2.0"
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+      "license": "MIT"
+    },
+    "node_modules/asap": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz",
+      "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/asn1js": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/asn1js/-/asn1js-3.0.10.tgz",
+      "integrity": "sha512-S2s3aOytiKdFRdulw2qPE51MzjzVOisppcVv7jVFR+Kw0kxwvFrDcYA0h7Ndqbmj0HkMIXYWaoj7fli8kgx1eg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "pvtsutils": "^1.3.6",
+        "pvutils": "^1.1.5",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/ast-kit": {
+      "version": "3.0.0-beta.1",
+      "resolved": "https://registry.npmjs.org/ast-kit/-/ast-kit-3.0.0-beta.1.tgz",
+      "integrity": "sha512-trmleAnZ2PxN/loHWVhhx1qeOHSRXq4TDsBBxq3GqeJitfk3+jTQ+v/C1km/KYq9M7wKqCewMh+/NAvVH7m+bw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^8.0.0-beta.4",
+        "estree-walker": "^3.0.3",
+        "pathe": "^2.0.3"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sxzz"
+      }
+    },
+    "node_modules/ast-kit/node_modules/@babel/helper-string-parser": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-8.0.0.tgz",
+      "integrity": "sha512-6mJgmFFFIIO82vvoLt9XtRC7/TkzXfts1t/SpRX4IHSzMgqoPYCWesVu1udUPUWioAE/2fcG6WuI8zrkE1gwrg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.18.0 || >=24.11.0"
+      }
+    },
+    "node_modules/ast-kit/node_modules/@babel/helper-validator-identifier": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-8.0.0.tgz",
+      "integrity": "sha512-kXxQVZHNOctSJJsqzmcbPSCEkM6oHNnDIkua7g9RCO9xRHj2eCiKvRx2KPdfWR9QxcGWnK/oArrtunmie3rL9g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.18.0 || >=24.11.0"
+      }
+    },
+    "node_modules/ast-kit/node_modules/@babel/parser": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-8.0.0.tgz",
+      "integrity": "sha512-aLxAE+imI9bCcyaPrUDjBv3uSkWieifjLe0kuFOZF0zli0L6GCsTmsePnTr55adbIAgYz2zhN1vnFimCBUYcRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^8.0.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": "^22.18.0 || >=24.11.0"
+      }
+    },
+    "node_modules/ast-kit/node_modules/@babel/types": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-8.0.0.tgz",
+      "integrity": "sha512-K8ponJDxBwDHigkeFqaqT5wLGl4bTlwMafR8k7b5CPxr6Ww+UG9ls8Yx6Tcpboxu97eeGVEEyKcHmEyOwN1vSw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^8.0.0",
+        "@babel/helper-validator-identifier": "^8.0.0"
+      },
+      "engines": {
+        "node": "^22.18.0 || >=24.11.0"
+      }
+    },
+    "node_modules/ast-v8-to-istanbul": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/ast-v8-to-istanbul/-/ast-v8-to-istanbul-1.0.4.tgz",
+      "integrity": "sha512-0bC0/4bTSrnwdhU3IsZDwEdojvuPrSg59OYZfKsLRtJZ0u8VBx9DebfqqG8bRdCC0I7vjgxmPi41P0lpkhJHtA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.31",
+        "estree-walker": "^3.0.3",
+        "js-tokens": "^10.0.0"
+      }
+    },
+    "node_modules/ast-v8-to-istanbul/node_modules/js-tokens": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-10.0.0.tgz",
+      "integrity": "sha512-lM/UBzQmfJRo9ABXbPWemivdCW8V2G8FHaHdypQaIy523snUjog0W71ayWXTjiR+ixeMyVHN2XcpnTd/liPg/Q==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/async": {
+      "version": "3.2.6",
+      "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+      "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
+      "license": "MIT"
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/await-to-js": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/await-to-js/-/await-to-js-3.0.0.tgz",
+      "integrity": "sha512-zJAaP9zxTcvTHRlejau3ZOY4V7SRpiByf3/dxx2uyKxxor19tpmpV2QRsTKikckwhaPmr2dVpxxMr7jOCYVp5g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/b4a": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.8.1.tgz",
+      "integrity": "sha512-aiqre1Nr0B/6DgE2N5vwTc+2/oQZ4Wh1t4NznYY4E00y8LCt6NqdRv81so00oo27D8MVKTpUa/MwUUtBLXCoDw==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "react-native-b4a": "*"
+      },
+      "peerDependenciesMeta": {
+        "react-native-b4a": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "license": "MIT"
+    },
+    "node_modules/bare-events": {
+      "version": "2.9.1",
+      "resolved": "https://registry.npmjs.org/bare-events/-/bare-events-2.9.1.tgz",
+      "integrity": "sha512-Z0oHEHAFDZkffN8Qc39zNZjQlMDkPJRyyyZieU1VH7u8c5S+qHZ2S8ixdKIAxEjfHO7FJxXmJWgteOghVanIsg==",
+      "license": "Apache-2.0",
+      "peerDependencies": {
+        "bare-abort-controller": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-abort-controller": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-fs": {
+      "version": "4.7.2",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.7.2.tgz",
+      "integrity": "sha512-aTvMFUWkBmjzKtEQMDGGDNF8bkfpD5N1b/FCwt7A3wrU4t1o/e/85Wzkluh6JlODCjqVESYCkQCdTXqZ9G7VFg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bare-events": "^2.5.4",
+        "bare-path": "^3.0.0",
+        "bare-stream": "^2.6.4",
+        "bare-url": "^2.2.2",
+        "fast-fifo": "^1.3.2"
+      },
+      "engines": {
+        "bare": ">=1.16.0"
+      },
+      "peerDependencies": {
+        "bare-buffer": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-buffer": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-os": {
+      "version": "3.9.1",
+      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.9.1.tgz",
+      "integrity": "sha512-6M5XjcnsygQNPMCMPXSK379xrJFiZ/AEMNBmFEmQW8d/789VQATvriyi5r0HYTL9TkQ26rn3kgdTG3aisbrXkQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "bare": ">=1.14.0"
+      }
+    },
+    "node_modules/bare-path": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.1.tgz",
+      "integrity": "sha512-ghj2DSK/2e99a1anTVPCV4m4YIYtrbXhfM7V3D7XZLOTsybnYyaJloymGqssQc8l/or0UoDyRtNQkmkEF/ysgQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bare-os": "^3.0.1"
+      }
+    },
+    "node_modules/bare-stream": {
+      "version": "2.13.3",
+      "resolved": "https://registry.npmjs.org/bare-stream/-/bare-stream-2.13.3.tgz",
+      "integrity": "sha512-Kc+brLqvEqGkjyfiwJmImAOqLZL7OsoLKuavx+hJjgVV3nLTOjloJyPMFxjUPerGGHrNH0fLU06jjykMLWrERQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "b4a": "^1.8.1",
+        "streamx": "^2.25.0",
+        "teex": "^1.0.1"
+      },
+      "peerDependencies": {
+        "bare-abort-controller": "*",
+        "bare-buffer": "*",
+        "bare-events": "*"
+      },
+      "peerDependenciesMeta": {
+        "bare-abort-controller": {
+          "optional": true
+        },
+        "bare-buffer": {
+          "optional": true
+        },
+        "bare-events": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/bare-url": {
+      "version": "2.4.5",
+      "resolved": "https://registry.npmjs.org/bare-url/-/bare-url-2.4.5.tgz",
+      "integrity": "sha512-K+y9xF1tN+CdPu4qWwr0QiK1Al07eFPGYK5M2pDXcmHdMdgC/tT/bpmMe1hrmRHaidKLkXrC+cRNYf3XVDUhSQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bare-path": "^3.0.0"
+      }
+    },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.37",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.37.tgz",
+      "integrity": "sha512-girxaJ7WZssDOFhzCGZTDKoTa1gk6A1TbflaYTpykLJ4UU9Fz9kx1aREM8JCuoVHbL8X8T/mJg7w2oYSq72Oig==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/bcryptjs": {
+      "version": "2.4.3",
+      "resolved": "https://registry.npmjs.org/bcryptjs/-/bcryptjs-2.4.3.tgz",
+      "integrity": "sha512-V/Hy/X9Vt7f3BbPJEi8BdVFMByHi+jNXrYkW3huaybV/kQ0KJg0Y6PkEMbn+zeT+i+SiKZ/HMqJGIIt4LZDqNQ==",
+      "license": "MIT"
+    },
+    "node_modules/better-sqlite3": {
+      "version": "12.11.1",
+      "resolved": "https://registry.npmjs.org/better-sqlite3/-/better-sqlite3-12.11.1.tgz",
+      "integrity": "sha512-dq9AtApgg5PGFtBzPFSBl3HZQjHok5gaQCM6zh2Yk0aSmDCs1CbnVI8/HgASQkNKsWFpseIO9beg5xxpYhbIfA==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "bindings": "^1.5.0",
+        "prebuild-install": "^7.1.1"
+      },
+      "engines": {
+        "node": "20.x || 22.x || 23.x || 24.x || 25.x || 26.x"
+      }
+    },
+    "node_modules/bidi-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",
+      "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==",
+      "license": "MIT",
+      "dependencies": {
+        "require-from-string": "^2.0.2"
+      }
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/bindings": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
+      "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==",
+      "license": "MIT",
+      "dependencies": {
+        "file-uri-to-path": "1.0.0"
+      }
+    },
+    "node_modules/birpc": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/birpc/-/birpc-4.0.0.tgz",
+      "integrity": "sha512-LShSxJP0KTmd101b6DRyGBj57LZxSDYWKitQNW/mi8GRMvZb078Uf9+pveax1DrVL89vm7mWe+TovdI/UDOuPw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/bl": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
+      "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer": "^5.5.0",
+        "inherits": "^2.0.4",
+        "readable-stream": "^3.4.0"
+      }
+    },
+    "node_modules/bluebird": {
+      "version": "3.7.2",
+      "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz",
+      "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==",
+      "license": "MIT"
+    },
+    "node_modules/bmp-ts": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/bmp-ts/-/bmp-ts-1.0.9.tgz",
+      "integrity": "sha512-cTEHk2jLrPyi+12M3dhpEbnnPOsaZuq7C45ylbbQIiWgDFZq4UVYPEY5mlqjvsj/6gJv9qX5sa+ebDzLXT28Vw==",
+      "license": "MIT"
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.5",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.5.tgz",
+      "integrity": "sha512-3grm+/2tUOvu2cjJkvsIxrv/wVpfXQW4PsQHYm7yk4vfpu7Ekl6nEsYBoJUL6qDwZUx8wUhQ8tR2qz+ad9c9OA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "~1.2.0",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "on-finished": "~2.4.1",
+        "qs": "~6.15.1",
+        "raw-body": "~2.5.3",
+        "type-is": "~1.6.18",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/body-parser/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/body-parser/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/body-parser/node_modules/raw-body": {
+      "version": "2.5.3",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz",
+      "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.4.24",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.1.tgz",
+      "integrity": "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/buffer": {
+      "version": "5.7.1",
+      "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+      "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "base64-js": "^1.3.1",
+        "ieee754": "^1.1.13"
+      }
+    },
+    "node_modules/buffer-crc32": {
+      "version": "0.2.13",
+      "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+      "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/buffer-equal-constant-time": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
+      "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "license": "MIT"
+    },
+    "node_modules/busboy": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/busboy/-/busboy-1.6.0.tgz",
+      "integrity": "sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==",
+      "dependencies": {
+        "streamsearch": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=10.16.0"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/camelcase": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
+      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001799",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001799.tgz",
+      "integrity": "sha512-hG1bReV+OUU+MOqK4t/ZWI0tZOyz3rqS9XuhOUz1cIcbwBKjOyJEJuw9ER5JuNyqxNk8u/JUVbGibBOL1yrjFw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/chai": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
+      "integrity": "sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/chokidar/node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/chownr": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz",
+      "integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==",
+      "license": "ISC"
+    },
+    "node_modules/cli-width": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-4.1.0.tgz",
+      "integrity": "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-convert/node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/component-emitter": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.1.tgz",
+      "integrity": "sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/compress-commons": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/compress-commons/-/compress-commons-5.0.3.tgz",
+      "integrity": "sha512-/UIcLWvwAQyVibgpQDPtfNM3SvqN7G9elAPAV7GM0L53EbNWwWiCsWtK8Fwed/APEbptPHXs5PuW+y8Bq8lFTA==",
+      "license": "MIT",
+      "dependencies": {
+        "crc-32": "^1.2.0",
+        "crc32-stream": "^5.0.0",
+        "normalize-path": "^3.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/concat-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-2.0.0.tgz",
+      "integrity": "sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==",
+      "engines": [
+        "node >= 6.0"
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "inherits": "^2.0.3",
+        "readable-stream": "^3.0.2",
+        "typedarray": "^0.0.6"
+      }
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-parser": {
+      "version": "1.4.7",
+      "resolved": "https://registry.npmjs.org/cookie-parser/-/cookie-parser-1.4.7.tgz",
+      "integrity": "sha512-nGUvgXnotP3BsjiLX2ypbQnWoGUPIIfHQNZkkC668ntrzGWEZVW70HDEB1qnNGMicPje6EttlIgzo51YSwNQGw==",
+      "license": "MIT",
+      "dependencies": {
+        "cookie": "0.7.2",
+        "cookie-signature": "1.0.6"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
+      "license": "MIT"
+    },
+    "node_modules/cookiejar": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.4.tgz",
+      "integrity": "sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/core-util-is": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
+      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+      "license": "MIT"
+    },
+    "node_modules/cors": {
+      "version": "2.8.6",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz",
+      "integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/crc-32": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz",
+      "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==",
+      "license": "Apache-2.0",
+      "bin": {
+        "crc32": "bin/crc32.njs"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/crc32-stream": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/crc32-stream/-/crc32-stream-5.0.1.tgz",
+      "integrity": "sha512-lO1dFui+CEUh/ztYIpgpKItKW9Bb4NWakCRJrnqAbFIYD+OZAwb2VfD5T5eXMw2FNcsDHkQcNl/Wh3iVXYwU6g==",
+      "license": "MIT",
+      "dependencies": {
+        "crc-32": "^1.2.0",
+        "readable-stream": "^3.4.0"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/css-tree": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.2.1.tgz",
+      "integrity": "sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==",
+      "license": "MIT",
+      "dependencies": {
+        "mdn-data": "2.27.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+      }
+    },
+    "node_modules/data-urls": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz",
+      "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^16.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decamelize": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
+      "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "license": "MIT"
+    },
+    "node_modules/decompress-response": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
+      "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
+      "license": "MIT",
+      "dependencies": {
+        "mimic-response": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/deep-extend": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz",
+      "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/defu": {
+      "version": "6.1.7",
+      "resolved": "https://registry.npmjs.org/defu/-/defu-6.1.7.tgz",
+      "integrity": "sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/dezalgo": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/dezalgo/-/dezalgo-1.0.4.tgz",
+      "integrity": "sha512-rXSP0bf+5n0Qonsb+SVVfNfIsimO4HEtmnIpPHY8Q1UCzKlQrDMfdobr8nJOOsRgWCyMRqeSBQzmWUMq7zvVig==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "asap": "^2.0.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/dijkstrajs": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/dijkstrajs/-/dijkstrajs-1.0.3.tgz",
+      "integrity": "sha512-qiSlmBq9+BCdCA/L46dw8Uy93mloxsPSbwnm5yrKn2vMPiy8KyAskTF6zuV/j5BMsmOGZDPs7KjU+mjb670kfA==",
+      "license": "MIT"
+    },
+    "node_modules/dompurify": {
+      "version": "3.4.10",
+      "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.4.10.tgz",
+      "integrity": "sha512-0xzNv0e7oYC6yyuOGZIABPM4qtg3QxLFniDNPP4ZP90wR8Yq3zgwpRbrNiT4N3IKqDbbYFEJLV+JWEs19aZ//w==",
+      "license": "(MPL-2.0 OR Apache-2.0)",
+      "optionalDependencies": {
+        "@types/trusted-types": "^2.0.7"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.6.1",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/dts-resolver": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/dts-resolver/-/dts-resolver-3.0.0.tgz",
+      "integrity": "sha512-1T1f+z+4tl9XD+m+0HBgWoL/nm0bOIffyWaUuUSBlFg/86IWvfx+wjNaO/ybU0AJzG9/Mi5hBUgGV6zCmWEN7Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.18.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sxzz"
+      },
+      "peerDependencies": {
+        "oxc-resolver": ">=11.0.0"
+      },
+      "peerDependenciesMeta": {
+        "oxc-resolver": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/duplexer2": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz",
+      "integrity": "sha512-asLFVfWWtJ90ZyOUHMqk7/S2w2guQKxUI2itj3d92ADHhxUSbCMGi1f1cBcJ7xM1To+pE/Khbwo1yuNbMEPKeA==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "readable-stream": "^2.0.2"
+      }
+    },
+    "node_modules/duplexer2/node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+      "license": "MIT"
+    },
+    "node_modules/duplexer2/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/duplexer2/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/duplexer2/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/ecdsa-sig-formatter": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
+      "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.373",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.373.tgz",
+      "integrity": "sha512-G2Hym8JIf/QreuseqkDibgH8Ci8KfJzqGDKdakbhSx9UltwRBH2cBLAWU/lBX0sCdv0TlhyxQyDCnSfxgMWsjA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/empathic": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/empathic/-/empathic-2.0.1.tgz",
+      "integrity": "sha512-YGRs8knHhKHVShLkFET/rWAU8kmHbOV5LwN938RHI0pljAJ1Gf6SzXsSmRaEzcXTtOOmVqJ5+WtQPL5uigY50Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/end-of-stream": {
+      "version": "1.4.5",
+      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+      "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+      "license": "MIT",
+      "dependencies": {
+        "once": "^1.4.0"
+      }
+    },
+    "node_modules/entities": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-8.0.0.tgz",
+      "integrity": "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-module-lexer": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.1.0.tgz",
+      "integrity": "sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
+      "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "10.5.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-10.5.0.tgz",
+      "integrity": "sha512-1y+7C+vi12bUK1IpZeaV3gsH9fHLBmPvYmPx42pvT/E9yG0IC8g3PUZZgp0+JLJl7ZDK0flc2gc+Aw9dpCvIsQ==",
+      "dev": true,
+      "license": "MIT",
+      "workspaces": [
+        "packages/*"
+      ],
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.8.0",
+        "@eslint-community/regexpp": "^4.12.2",
+        "@eslint/config-array": "^0.23.5",
+        "@eslint/config-helpers": "^0.6.0",
+        "@eslint/core": "^1.2.1",
+        "@eslint/plugin-kit": "^0.7.2",
+        "@humanfs/node": "^0.16.6",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@humanwhocodes/retry": "^0.4.2",
+        "@types/estree": "^1.0.6",
+        "ajv": "^6.14.0",
+        "cross-spawn": "^7.0.6",
+        "debug": "^4.3.2",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^9.1.2",
+        "eslint-visitor-keys": "^5.0.1",
+        "espree": "^11.2.0",
+        "esquery": "^1.7.0",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^8.0.0",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "minimatch": "^10.2.4",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "jiti": "*"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/eslint-config-flat-gitignore": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/eslint-config-flat-gitignore/-/eslint-config-flat-gitignore-2.3.0.tgz",
+      "integrity": "sha512-bg4ZLGgoARg1naWfsINUUb/52Ksw/K22K+T16D38Y8v+/sGwwIYrGvH/JBjOin+RQtxxC9tzNNiy4shnGtGyyQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint/compat": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      },
+      "peerDependencies": {
+        "eslint": "^9.5.0 || ^10.0.0"
+      }
+    },
+    "node_modules/eslint-config-prettier": {
+      "version": "10.1.8",
+      "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-10.1.8.tgz",
+      "integrity": "sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "eslint-config-prettier": "bin/cli.js"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint-config-prettier"
+      },
+      "peerDependencies": {
+        "eslint": ">=7.0.0"
+      }
+    },
+    "node_modules/eslint-plugin-prettier": {
+      "version": "5.5.6",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.5.6.tgz",
+      "integrity": "sha512-ifetmTcxWfz+4qRW3pH/ujdTq2jQIj59AxJMIN26K5avYgU8dxycUETQonWiW+wPrYXA0j3Try0l1CnwVQtDqQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prettier-linter-helpers": "^1.0.1",
+        "synckit": "^0.11.13"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint-plugin-prettier"
+      },
+      "peerDependencies": {
+        "@types/eslint": ">=8.0.0",
+        "eslint": ">=8.0.0",
+        "eslint-config-prettier": ">= 7.0.0 <10.0.0 || >=10.1.0",
+        "prettier": ">=3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/eslint": {
+          "optional": true
+        },
+        "eslint-config-prettier": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "9.1.2",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-9.1.2.tgz",
+      "integrity": "sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "@types/esrecurse": "^4.3.1",
+        "@types/estree": "^1.0.8",
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-5.0.1.tgz",
+      "integrity": "sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint/node_modules/ajv": {
+      "version": "6.15.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz",
+      "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/eslint/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/eslint/node_modules/brace-expansion": {
+      "version": "5.0.6",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
+      "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/eslint/node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/eslint/node_modules/minimatch": {
+      "version": "10.2.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
+      "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "brace-expansion": "^5.0.5"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/espree": {
+      "version": "11.2.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-11.2.0.tgz",
+      "integrity": "sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.16.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^5.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz",
+      "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/events-universal": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/events-universal/-/events-universal-1.0.1.tgz",
+      "integrity": "sha512-LUd5euvbMLpwOF8m6ivPCbhQeSiYVNb8Vs0fQ8QjXo0JTkEHpz8pxdQf0gStltaPpw0Cca8b39KxvK9cfKRiAw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "bare-events": "^2.7.0"
+      }
+    },
+    "node_modules/eventsource": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
+      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
+      "license": "MIT",
+      "dependencies": {
+        "eventsource-parser": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.1.0.tgz",
+      "integrity": "sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/exif-parser": {
+      "version": "0.1.12",
+      "resolved": "https://registry.npmjs.org/exif-parser/-/exif-parser-0.1.12.tgz",
+      "integrity": "sha512-c2bQfLNbMzLPmzQuOr8fy0csy84WmwnER81W88DzTp9CYNPJ6yzOj2EZAh9pywYpqHnshVLHQJ8WzldAyfY+Iw=="
+    },
+    "node_modules/expand-template": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz",
+      "integrity": "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==",
+      "license": "(MIT OR WTFPL)",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/expect-type": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
+      "integrity": "sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.22.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.22.2.tgz",
+      "integrity": "sha512-IuL+Elrou2ZvCFHs18/CIzy2Nzvo25nZ1/D2eIZlz7c+QUayAcYoiM2BthCjs+EBHVpjYjcuLDAiCWgeIX3X1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "~1.20.5",
+        "content-disposition": "~0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "~0.7.1",
+        "cookie-signature": "~1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "~1.3.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "~0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "~6.15.1",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "~0.19.0",
+        "serve-static": "~1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "~2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/express-rate-limit": {
+      "version": "8.5.2",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.5.2.tgz",
+      "integrity": "sha512-5Kb34ipNX694DH48vN9irak1Qx30nb0PLYHXfJgw4YEjiC3ZEmZJhwOp+VfiCYwFzvFTdB9QkArYS5kXa2cx2A==",
+      "license": "MIT",
+      "dependencies": {
+        "ip-address": "^10.2.0"
+      },
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/express-rate-limit"
+      },
+      "peerDependencies": {
+        "express": ">= 4.11"
+      }
+    },
+    "node_modules/express/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/express/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/express/node_modules/path-to-regexp": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.13.tgz",
+      "integrity": "sha512-A/AGNMFN3c8bOlvV9RreMdrv7jsmF9XIfDeCd87+I8RNg6s78BhJxMu69NEMHBSJFxKidViTEdruRwEk/WIKqA==",
+      "license": "MIT"
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT"
+    },
+    "node_modules/fast-diff": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.3.0.tgz",
+      "integrity": "sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/fast-fifo": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/fast-fifo/-/fast-fifo-1.3.2.tgz",
+      "integrity": "sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==",
+      "license": "MIT"
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-safe-stringify": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.1.1.tgz",
+      "integrity": "sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==",
+      "license": "MIT"
+    },
+    "node_modules/fast-string-truncated-width": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/fast-string-truncated-width/-/fast-string-truncated-width-3.0.3.tgz",
+      "integrity": "sha512-0jjjIEL6+0jag3l2XWWizO64/aZVtpiGE3t0Zgqxv0DPuxiMjvB3M24fCyhZUO4KomJQPj3LTSUnDP3GpdwC0g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/fast-string-width": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/fast-string-width/-/fast-string-width-3.0.2.tgz",
+      "integrity": "sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-string-truncated-width": "^3.0.2"
+      }
+    },
+    "node_modules/fast-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.2.tgz",
+      "integrity": "sha512-rVjf7ArG3LTk+FS6Yw81V1DLuZl1bRbNrev6Tmd/9RaroeeRRJhAt7jg/6YFxbvAQXUCavSoZhPPj6oOx+5KjQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/fast-wrap-ansi": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/fast-wrap-ansi/-/fast-wrap-ansi-0.2.2.tgz",
+      "integrity": "sha512-7F2Fl+TjRSenLqlU3UjSH0iyqopqoZIu7eZVpEirP2g1GtWa2G/ecEmBdgz31+Mxr+ELclgg6sokpSFIQiZ02Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-string-width": "^3.0.2"
+      }
+    },
+    "node_modules/fast-xml-builder": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.2.0.tgz",
+      "integrity": "sha512-00aAWieqff+ZJhsXA4g1g7M8k+7AYoMUUHF+/zFb5U6Uv/P0Vl4QZo84/IcufzYalLuEj9928bXN9PbbFzMF0Q==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "path-expression-matcher": "^1.5.0",
+        "xml-naming": "^0.1.0"
+      }
+    },
+    "node_modules/fast-xml-parser": {
+      "version": "5.9.0",
+      "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.9.0.tgz",
+      "integrity": "sha512-duBuXbyIhEeNO4GjFuVqr0nF047oNwr18aum+zJyqo0MUG/n7Afgs3Qv3D6VN3ONedUKxiuFlPiMGIa0Z11chA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@nodable/entities": "^2.2.0",
+        "fast-xml-builder": "^1.2.0",
+        "is-unsafe": "^1.0.1",
+        "path-expression-matcher": "^1.5.0",
+        "strnum": "^2.4.0",
+        "xml-naming": "^0.1.0"
+      },
+      "bin": {
+        "fxparser": "src/cli/cli.js"
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flat-cache": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/file-type": {
+      "version": "21.3.4",
+      "resolved": "https://registry.npmjs.org/file-type/-/file-type-21.3.4.tgz",
+      "integrity": "sha512-Ievi/yy8DS3ygGvT47PjSfdFoX+2isQueoYP1cntFW1JLYAuS4GD7NUPGg4zv2iZfV52uDyk5w5Z0TdpRS6Q1g==",
+      "license": "MIT",
+      "dependencies": {
+        "@tokenizer/inflate": "^0.4.1",
+        "strtok3": "^10.3.4",
+        "token-types": "^6.1.1",
+        "uint8array-extras": "^1.4.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/file-type?sponsor=1"
+      }
+    },
+    "node_modules/file-uri-to-path": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
+      "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==",
+      "license": "MIT"
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz",
+      "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "~2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "~2.0.2",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/finalhandler/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/finalhandler/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat-cache": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.4"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/flatted": {
+      "version": "3.4.2",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.2.tgz",
+      "integrity": "sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/form-data": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.6.tgz",
+      "integrity": "sha512-vKatAh4SlVfgbv+YtmhiRjhEMJsYpsG1Y2rMQtR+SVSbytsSD1YGzDIcrAJmdFec88u/+VoGmxnl+80gL1tRCQ==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.4",
+        "mime-types": "^2.1.35"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/formidable": {
+      "version": "3.5.4",
+      "resolved": "https://registry.npmjs.org/formidable/-/formidable-3.5.4.tgz",
+      "integrity": "sha512-YikH+7CUTOtP44ZTnUhR7Ic2UASBPOqmaRkRKxRbywPTe5VxF7RRCck4af9wutiZ/QKM5nME9Bie2fFaPz5Gug==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@paralleldrive/cuid2": "^2.2.2",
+        "dezalgo": "^1.0.4",
+        "once": "^1.4.0"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "funding": {
+        "url": "https://ko-fi.com/tunnckoCore/commissions"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fs-constants": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz",
+      "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==",
+      "license": "MIT"
+    },
+    "node_modules/fs-extra": {
+      "version": "11.3.5",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.5.tgz",
+      "integrity": "sha512-eKpRKAovdpZtR1WopLHxlBWvAgPny3c4gX1G5Jhwmmw4XJj0ifSD5qB5TOo8hmA0wlRKDAOAhEE1yVPgs6Fgcg==",
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=14.14"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "license": "ISC"
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/get-tsconfig": {
+      "version": "5.0.0-beta.5",
+      "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-5.0.0-beta.5.tgz",
+      "integrity": "sha512-/6gFNr0N04nob252sTQxyFLi3eKFRqIg1I87YcqAMT1i6SQrSF6KujUEQrtrjMV0H/eejTCltLdDSTEMzHbnsQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "resolve-pkg-maps": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=20.20.0"
+      },
+      "funding": {
+        "url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"
+      }
+    },
+    "node_modules/gifwrap": {
+      "version": "0.10.1",
+      "resolved": "https://registry.npmjs.org/gifwrap/-/gifwrap-0.10.1.tgz",
+      "integrity": "sha512-2760b1vpJHNmLzZ/ubTtNnEx5WApN/PYWJvXvgS+tL1egTTthayFYIQQNi136FLEDcN/IyEY2EcGpIITD6eYUw==",
+      "license": "MIT",
+      "dependencies": {
+        "image-q": "^4.0.0",
+        "omggif": "^1.0.10"
+      }
+    },
+    "node_modules/github-from-package": {
+      "version": "0.0.0",
+      "resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz",
+      "integrity": "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==",
+      "license": "MIT"
+    },
+    "node_modules/glob": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
+      "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me",
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^5.0.1",
+        "once": "^1.3.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/glob/node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/globals": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "license": "ISC"
+    },
+    "node_modules/graphql": {
+      "version": "16.14.2",
+      "resolved": "https://registry.npmjs.org/graphql/-/graphql-16.14.2.tgz",
+      "integrity": "sha512-Chq1s4CY7jmh8gO2qvLIJyfCDIN+EHLFW/9iShnp1z8FjBQMoodWP1kDC36VAMXXIvAjj4ARa7ntfAV2BrjsbA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/headers-polyfill": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/headers-polyfill/-/headers-polyfill-5.0.1.tgz",
+      "integrity": "sha512-1TJ6Fih/b8h5TIcv+1+Hw0PDQWJTKDKzFZzcKOiW1wJza3XoAQlkCuXLbymPYB8+ZQyw8mHvdw560e8zVFIWyA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/set-cookie-parser": "^2.4.10",
+        "set-cookie-parser": "^3.0.1"
+      }
+    },
+    "node_modules/helmet": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/helmet/-/helmet-8.2.0.tgz",
+      "integrity": "sha512-DRgTIUgnWcJ62KyarxxziuqYxKGnR6Rgg19BlbucN/dpmJbl1XOit6qvoOX0ZT+HhWe5OUVhU/a1zpGyc1xA0Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/EvanHahn"
+      }
+    },
+    "node_modules/hono": {
+      "version": "4.12.25",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.25.tgz",
+      "integrity": "sha512-2NFaIyNVgJmBs/ecmtGzlmluTFs5cHEWGTdu0t1HBwYzoGXOL5nUQBRMXsXWla5i4KkG//QMzVP88m1+I3fdAQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.9.0"
+      }
+    },
+    "node_modules/hookable": {
+      "version": "6.1.1",
+      "resolved": "https://registry.npmjs.org/hookable/-/hookable-6.1.1.tgz",
+      "integrity": "sha512-U9LYDy1CwhMCnprUfeAZWZGByVbhd54hwepegYTK7Pi5NvqEj63ifz5z+xukznehT7i6NIZRu89Ay1AZmRsLEQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/html-encoding-sniffer": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz",
+      "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==",
+      "license": "MIT",
+      "dependencies": {
+        "@exodus/bytes": "^1.6.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/html-escaper": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
+      "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
+      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "~2.0.0",
+        "inherits": "~2.0.4",
+        "setprototypeof": "~1.2.0",
+        "statuses": "~2.0.2",
+        "toidentifier": "~1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ieee754": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/ignore": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",
+      "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/ignore-by-default": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz",
+      "integrity": "sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/image-q": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/image-q/-/image-q-4.0.0.tgz",
+      "integrity": "sha512-PfJGVgIfKQJuq3s0tTDOKtztksibuUEbJQIYT3by6wctQo+Rdlh7ef4evJ5NCdxY4CfMbvFkocEwbl4BF8RlJw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "16.9.1"
+      }
+    },
+    "node_modules/image-q/node_modules/@types/node": {
+      "version": "16.9.1",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-16.9.1.tgz",
+      "integrity": "sha512-QpLcX9ZSsq3YYUUnD3nFDY8H7wctAhQj/TFKL8Ya8v5fMm3CFXxo8zStsLAl780ltoYoo1WvKUVGBQK+1ifr7g==",
+      "license": "MIT"
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+      "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/import-fresh/node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/import-without-cache": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/import-without-cache/-/import-without-cache-0.4.0.tgz",
+      "integrity": "sha512-NkJQA7oZ4YHQhd2+H3BoRFKF3d/XNsiKpHZCQEMH9pDX27hQQLsTyOocyRgaIVtf8gHX3Nt3LPkR4e5EdtPAGQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.18.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sxzz"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "license": "ISC",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/ini": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==",
+      "license": "ISC"
+    },
+    "node_modules/ip-address": {
+      "version": "10.2.0",
+      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.2.0.tgz",
+      "integrity": "sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-node-process": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/is-node-process/-/is-node-process-1.2.0.tgz",
+      "integrity": "sha512-Vg4o6/fqPxIjtxgUH5QLJhwZ7gW5diGCVlXpuUfELC62CuxM1iHcRe51f2W1FDy04Ai4KJkagKjx3XaqyfRKXw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+      "license": "MIT"
+    },
+    "node_modules/is-promise": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
+      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
+      "license": "MIT"
+    },
+    "node_modules/is-unsafe": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-unsafe/-/is-unsafe-1.0.1.tgz",
+      "integrity": "sha512-CLK2+VdgERgD96EYm5lUQssZYlRg2tkZnbsxZoacmSiRxiFJ4Nk4SzjCl+Ur+v3kXIY9dTIdb3IH22y1mZ56LA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "license": "ISC"
+    },
+    "node_modules/isomorphic-dompurify": {
+      "version": "3.17.0",
+      "resolved": "https://registry.npmjs.org/isomorphic-dompurify/-/isomorphic-dompurify-3.17.0.tgz",
+      "integrity": "sha512-++PY22SYWZv/kTWOr5WQ8rNznkIKj6I/SDUVZnXXM67EhRO7ScVLDdZYNxNgEsPAOA5sfpGBcqnnbLx8WJHO1g==",
+      "license": "MIT",
+      "dependencies": {
+        "dompurify": "^3.4.10",
+        "jsdom": "^29.1.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24.0.0"
+      }
+    },
+    "node_modules/istanbul-lib-coverage": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
+      "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-lib-report": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz",
+      "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "istanbul-lib-coverage": "^3.0.0",
+        "make-dir": "^4.0.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/istanbul-lib-report/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/istanbul-reports": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz",
+      "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "html-escaper": "^2.0.0",
+        "istanbul-lib-report": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/iterare": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/iterare/-/iterare-1.2.1.tgz",
+      "integrity": "sha512-RKYVTCjAnRthyJes037NX/IiqeidgN1xc3j1RjFfECFp28A1GVwK9nA+i0rJPaHqSZwygLzRnFlzUuHFoWWy+Q==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/javascript-natural-sort": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/javascript-natural-sort/-/javascript-natural-sort-0.7.1.tgz",
+      "integrity": "sha512-nO6jcEfZWQXDhOiBtG2KvKyEptz7RVbpGP4vTD2hLBdmNQSsCiicO2Ioinv6UI4y9ukqnBpy+XZ9H6uLNgJTlw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/jimp": {
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/jimp/-/jimp-1.6.1.tgz",
+      "integrity": "sha512-hNQh6rZtWfSVWSNVmvq87N5BPJsNH7k7I7qyrXf9DOma9xATQk3fsyHazCQe51nCjdkoWdTmh0vD7bjVSLoxxw==",
+      "license": "MIT",
+      "dependencies": {
+        "@jimp/core": "1.6.1",
+        "@jimp/diff": "1.6.1",
+        "@jimp/js-bmp": "1.6.1",
+        "@jimp/js-gif": "1.6.1",
+        "@jimp/js-jpeg": "1.6.1",
+        "@jimp/js-png": "1.6.1",
+        "@jimp/js-tiff": "1.6.1",
+        "@jimp/plugin-blit": "1.6.1",
+        "@jimp/plugin-blur": "1.6.1",
+        "@jimp/plugin-circle": "1.6.1",
+        "@jimp/plugin-color": "1.6.1",
+        "@jimp/plugin-contain": "1.6.1",
+        "@jimp/plugin-cover": "1.6.1",
+        "@jimp/plugin-crop": "1.6.1",
+        "@jimp/plugin-displace": "1.6.1",
+        "@jimp/plugin-dither": "1.6.1",
+        "@jimp/plugin-fisheye": "1.6.1",
+        "@jimp/plugin-flip": "1.6.1",
+        "@jimp/plugin-hash": "1.6.1",
+        "@jimp/plugin-mask": "1.6.1",
+        "@jimp/plugin-print": "1.6.1",
+        "@jimp/plugin-quantize": "1.6.1",
+        "@jimp/plugin-resize": "1.6.1",
+        "@jimp/plugin-rotate": "1.6.1",
+        "@jimp/plugin-threshold": "1.6.1",
+        "@jimp/types": "1.6.1",
+        "@jimp/utils": "1.6.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/jiti": {
+      "version": "1.21.7",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
+      "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jiti": "bin/jiti.js"
+      }
+    },
+    "node_modules/jose": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.3.tgz",
+      "integrity": "sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
+    "node_modules/jpeg-js": {
+      "version": "0.4.4",
+      "resolved": "https://registry.npmjs.org/jpeg-js/-/jpeg-js-0.4.4.tgz",
+      "integrity": "sha512-WZzeDOEtTOBK4Mdsar0IqEU5sMr3vSV2RqkAIzUEV2BHnUfKGyswWFPFwK5EeDo93K3FohSHbLAjj0s1Wzd+dg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/js-yaml": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.3.0.tgz",
+      "integrity": "sha512-1td788aAnnZ5qs7V2QIRl1owjtYpbKt749Y3xauqQgwIIGF/xXWz1wMTEBx5O3LK3lXLVuqXPdPxj2BoFHaW9Q==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/puzrin"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodeca"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/jsdom": {
+      "version": "29.1.1",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-29.1.1.tgz",
+      "integrity": "sha512-ECi4Fi2f7BdJtUKTflYRTiaMxIB0O6zfR1fX0GXpUrf6flp8QIYn1UT20YQqdSOfk2dfkCwS8LAFoJDEppNK5Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^5.1.11",
+        "@asamuzakjp/dom-selector": "^7.1.1",
+        "@bramus/specificity": "^2.4.2",
+        "@csstools/css-syntax-patches-for-csstree": "^1.1.3",
+        "@exodus/bytes": "^1.15.0",
+        "css-tree": "^3.2.1",
+        "data-urls": "^7.0.0",
+        "decimal.js": "^10.6.0",
+        "html-encoding-sniffer": "^6.0.0",
+        "is-potential-custom-element-name": "^1.0.1",
+        "lru-cache": "^11.3.5",
+        "parse5": "^8.0.1",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^6.0.1",
+        "undici": "^7.25.0",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^8.0.1",
+        "whatwg-mimetype": "^5.0.0",
+        "whatwg-url": "^16.0.1",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.13.0 || >=24.0.0"
+      },
+      "peerDependencies": {
+        "canvas": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jsdom/node_modules/lru-cache": {
+      "version": "11.5.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz",
+      "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==",
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+      "license": "MIT"
+    },
+    "node_modules/json-schema-typed": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/json-schema-typed/-/json-schema-typed-8.0.2.tgz",
+      "integrity": "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/jsonwebtoken": {
+      "version": "9.0.3",
+      "resolved": "https://registry.npmjs.org/jsonwebtoken/-/jsonwebtoken-9.0.3.tgz",
+      "integrity": "sha512-MT/xP0CrubFRNLNKvxJ2BYfy53Zkm++5bX9dtuPbqAeQpTVe0MQTFhao8+Cp//EmJp244xt6Drw/GVEGCUj40g==",
+      "license": "MIT",
+      "dependencies": {
+        "jws": "^4.0.1",
+        "lodash.includes": "^4.3.0",
+        "lodash.isboolean": "^3.0.3",
+        "lodash.isinteger": "^4.0.4",
+        "lodash.isnumber": "^3.0.3",
+        "lodash.isplainobject": "^4.0.6",
+        "lodash.isstring": "^4.0.1",
+        "lodash.once": "^4.0.0",
+        "ms": "^2.1.1",
+        "semver": "^7.5.4"
+      },
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      }
+    },
+    "node_modules/jwa": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz",
+      "integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-equal-constant-time": "^1.0.1",
+        "ecdsa-sig-formatter": "1.0.11",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/jws": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.1.tgz",
+      "integrity": "sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==",
+      "license": "MIT",
+      "dependencies": {
+        "jwa": "^2.0.1",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
+    },
+    "node_modules/lazystream": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/lazystream/-/lazystream-1.0.1.tgz",
+      "integrity": "sha512-b94GiNHQNy6JNTrt5w6zNyffMrNkXZb3KTkCZJb2V1xaEGCk093vkZ2jk3tpaeP33/OiXC+WvK9AxUebnf5nbw==",
+      "license": "MIT",
+      "dependencies": {
+        "readable-stream": "^2.0.5"
+      },
+      "engines": {
+        "node": ">= 0.6.3"
+      }
+    },
+    "node_modules/lazystream/node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+      "license": "MIT"
+    },
+    "node_modules/lazystream/node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
+    "node_modules/lazystream/node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
+    "node_modules/lazystream/node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/lightningcss": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
+      "integrity": "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==",
+      "dev": true,
+      "license": "MPL-2.0",
+      "dependencies": {
+        "detect-libc": "^2.0.3"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      },
+      "optionalDependencies": {
+        "lightningcss-android-arm64": "1.32.0",
+        "lightningcss-darwin-arm64": "1.32.0",
+        "lightningcss-darwin-x64": "1.32.0",
+        "lightningcss-freebsd-x64": "1.32.0",
+        "lightningcss-linux-arm-gnueabihf": "1.32.0",
+        "lightningcss-linux-arm64-gnu": "1.32.0",
+        "lightningcss-linux-arm64-musl": "1.32.0",
+        "lightningcss-linux-x64-gnu": "1.32.0",
+        "lightningcss-linux-x64-musl": "1.32.0",
+        "lightningcss-win32-arm64-msvc": "1.32.0",
+        "lightningcss-win32-x64-msvc": "1.32.0"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-gnu": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.32.0.tgz",
+      "integrity": "sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/lightningcss-linux-x64-musl": {
+      "version": "1.32.0",
+      "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.32.0.tgz",
+      "integrity": "sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MPL-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 12.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/parcel"
+      }
+    },
+    "node_modules/load-esm": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/load-esm/-/load-esm-1.0.3.tgz",
+      "integrity": "sha512-v5xlu8eHD1+6r8EHTg6hfmO97LN8ugKtiXcy5e6oN72iD2r6u0RPfLl6fxM+7Wnh2ZRq15o0russMst44WauPA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/Borewit"
+        },
+        {
+          "type": "buymeacoffee",
+          "url": "https://buymeacoffee.com/borewit"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=13.2.0"
+      }
+    },
+    "node_modules/load-tsconfig": {
+      "version": "0.2.5",
+      "resolved": "https://registry.npmjs.org/load-tsconfig/-/load-tsconfig-0.2.5.tgz",
+      "integrity": "sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      }
+    },
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/lodash": {
+      "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
+      "license": "MIT"
+    },
+    "node_modules/lodash-es": {
+      "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.18.1.tgz",
+      "integrity": "sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lodash.includes": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz",
+      "integrity": "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isboolean": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz",
+      "integrity": "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isinteger": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/lodash.isinteger/-/lodash.isinteger-4.0.4.tgz",
+      "integrity": "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isnumber": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/lodash.isnumber/-/lodash.isnumber-3.0.3.tgz",
+      "integrity": "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isplainobject": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
+      "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isstring": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/lodash.isstring/-/lodash.isstring-4.0.1.tgz",
+      "integrity": "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lodash.once": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/lodash.once/-/lodash.once-4.1.1.tgz",
+      "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==",
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.21",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz",
+      "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/magicast": {
+      "version": "0.5.3",
+      "resolved": "https://registry.npmjs.org/magicast/-/magicast-0.5.3.tgz",
+      "integrity": "sha512-pVKE4UdSQ7DvHzivsCIFx2BJn1mHG6KsyrFcaxFx6tONdneEuThrDx0Cj3AMg58KyN4pzYT+LHOotxDQDjNvkw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.3",
+        "@babel/types": "^7.29.0",
+        "source-map-js": "^1.2.1"
+      }
+    },
+    "node_modules/make-dir": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz",
+      "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/mdn-data": {
+      "version": "2.27.1",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.27.1.tgz",
+      "integrity": "sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==",
+      "license": "CC0-1.0"
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-3.0.0.tgz",
+      "integrity": "sha512-jSCU7/VB1loIWBZe14aEYHU/+1UMEHoaO7qxCOVJOw9GgH72VAWppxNcjU+x9a2k3GSIBXNKxXQFqRvvZ7vr3A==",
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mimic-response": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz",
+      "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "9.0.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+      "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/mkdirp-classic": {
+      "version": "0.5.3",
+      "resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz",
+      "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==",
+      "license": "MIT"
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/msw": {
+      "version": "2.14.6",
+      "resolved": "https://registry.npmjs.org/msw/-/msw-2.14.6.tgz",
+      "integrity": "sha512-ALe+N10S72cyx94cMcy3Zs4HhXCj35sgeAL4c+WTvKi0zWnbd8/h0lcFqv0mb2P+aSgAdD7p9HzvA0DiUPxsyg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "@inquirer/confirm": "^6.0.11",
+        "@mswjs/interceptors": "^0.41.3",
+        "@open-draft/deferred-promise": "^3.0.0",
+        "@types/statuses": "^2.0.6",
+        "cookie": "^1.1.1",
+        "graphql": "^16.13.2",
+        "headers-polyfill": "^5.0.1",
+        "is-node-process": "^1.2.0",
+        "outvariant": "^1.4.3",
+        "path-to-regexp": "^6.3.0",
+        "picocolors": "^1.1.1",
+        "rettime": "^0.11.11",
+        "statuses": "^2.0.2",
+        "strict-event-emitter": "^0.5.1",
+        "tough-cookie": "^6.0.1",
+        "type-fest": "^5.5.0",
+        "until-async": "^3.0.2",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "msw": "cli/index.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/mswjs"
+      },
+      "peerDependencies": {
+        "typescript": ">= 4.8.x"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/msw/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/msw/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/msw/node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/msw/node_modules/cookie": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.1.1.tgz",
+      "integrity": "sha512-ei8Aos7ja0weRpFzJnEA9UHJ/7XQmqglbRwnf2ATjcB9Wq874VKH9kfjjirM6UhU2/E5fFYadylyhFldcqSidQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/msw/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/msw/node_modules/path-to-regexp": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz",
+      "integrity": "sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/msw/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/msw/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/msw/node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/msw/node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/msw/node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/multer": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/multer/-/multer-2.2.0.tgz",
+      "integrity": "sha512-6rdyFg2kLrMh9Jee7/BMPuV9lEAd7lLW2YUpF9/YxR7njyoUwwQ0ZPh3TaIY50Sw6vlyD2HW3wGOkTS4P79xrQ==",
+      "license": "MIT",
+      "dependencies": {
+        "append-field": "^1.0.0",
+        "busboy": "^1.6.0",
+        "concat-stream": "^2.0.0",
+        "type-is": "^1.6.18"
+      },
+      "engines": {
+        "node": ">= 10.16.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/mute-stream": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-3.0.0.tgz",
+      "integrity": "sha512-dkEJPVvun4FryqBmZ5KhDo0K9iDXAwn08tMLDinNdRBNPcYEDiWYysLcc6k3mjTMlbP9KyylvRpd4wFtwrT9rw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^20.17.0 || >=22.9.0"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.12",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
+      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/napi-build-utils": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/napi-build-utils/-/napi-build-utils-2.0.0.tgz",
+      "integrity": "sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==",
+      "license": "MIT"
+    },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/node-abi": {
+      "version": "3.92.0",
+      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.92.0.tgz",
+      "integrity": "sha512-KdHvFWZjEKDf0cakgFjebl371GPsISX2oZHcuyKqM7DtogIsHrqKeLTo8wBHxaXRAQlY2PsPlZmfo+9ZCxEREQ==",
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.3.5"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/node-cron": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/node-cron/-/node-cron-4.2.1.tgz",
+      "integrity": "sha512-lgimEHPE/QDgFlywTd8yTR61ptugX3Qer29efeyWw2rv259HtGBNn1vZVmp8lB9uo9wC0t/AT4iGqXxia+CJFg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/node-int64": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz",
+      "integrity": "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==",
+      "license": "MIT"
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.47",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.47.tgz",
+      "integrity": "sha512-Uzmd6LXpouKo8EUK68IjH4+E01w/hXyV3R3g/geCJo+rXLNfh1xucB+LOzYEOQPSiUK3h/xZf0cQGcSsmyL2Og==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/nodemailer": {
+      "version": "8.0.11",
+      "resolved": "https://registry.npmjs.org/nodemailer/-/nodemailer-8.0.11.tgz",
+      "integrity": "sha512-nrO/pDAUKl+wXX+lx16tDLbnm0fW6sK/x8mgohaCpg+CdCEl482bD4tCuAZk2DyliruiNTIZxRCoWkDqJEnAiA==",
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/nodemon": {
+      "version": "3.1.14",
+      "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.14.tgz",
+      "integrity": "sha512-jakjZi93UtB3jHMWsXL68FXSAosbLfY0In5gtKq3niLSkrWznrVBzXFNOEMJUfc9+Ke7SHWoAZsiMkNP3vq6Jw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chokidar": "^3.5.2",
+        "debug": "^4",
+        "ignore-by-default": "^1.0.1",
+        "minimatch": "^10.2.1",
+        "pstree.remy": "^1.1.8",
+        "semver": "^7.5.3",
+        "simple-update-notifier": "^2.0.0",
+        "supports-color": "^5.5.0",
+        "touch": "^3.1.0",
+        "undefsafe": "^2.0.5"
+      },
+      "bin": {
+        "nodemon": "bin/nodemon.js"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/nodemon"
+      }
+    },
+    "node_modules/nodemon/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/nodemon/node_modules/brace-expansion": {
+      "version": "5.0.6",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
+      "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/nodemon/node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/nodemon/node_modules/minimatch": {
+      "version": "10.2.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
+      "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "brace-expansion": "^5.0.5"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/nodemon/node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/obug": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.3.tgz",
+      "integrity": "sha512-9miFgM2OFba7hB+pRgvtV84pYTBaoTHohvmIgiRt6dRIzbwEOIaNaP+dIlGs2fNFoB0SeISs0Jz5WFVRid6Xyg==",
+      "dev": true,
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/omggif": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/omggif/-/omggif-1.0.10.tgz",
+      "integrity": "sha512-LMJTtvgc/nugXj0Vcrrs68Mn2D1r0zf630VNtqtpI1FEO7e+O9FP4gqs9AcnBaSEeoHIPm28u6qgPR0oyEpGSw==",
+      "license": "MIT"
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "license": "ISC",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/otplib": {
+      "version": "12.0.1",
+      "resolved": "https://registry.npmjs.org/otplib/-/otplib-12.0.1.tgz",
+      "integrity": "sha512-xDGvUOQjop7RDgxTQ+o4pOol0/3xSZzawTiPKRrHnQWAy0WjhNs/5HdIDJCrqC4MBynmjXgULc6YfioaxZeFgg==",
+      "license": "MIT",
+      "dependencies": {
+        "@otplib/core": "^12.0.1",
+        "@otplib/preset-default": "^12.0.1",
+        "@otplib/preset-v11": "^12.0.1"
+      }
+    },
+    "node_modules/outvariant": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/outvariant/-/outvariant-1.4.3.tgz",
+      "integrity": "sha512-+Sl2UErvtsoajRDKCE5/dBz4DIvHXQQnAxtQTF04OJxY0+DyZXSo5P5Bb7XYWOh81syohlYL24hbDwxedPUJCA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-try": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz",
+      "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/pako": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
+      "license": "(MIT AND Zlib)"
+    },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/parse-bmfont-ascii": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/parse-bmfont-ascii/-/parse-bmfont-ascii-1.0.6.tgz",
+      "integrity": "sha512-U4RrVsUFCleIOBsIGYOMKjn9PavsGOXxbvYGtMOEfnId0SVNsgehXh1DxUdVPLoxd5mvcEtvmKs2Mmf0Mpa1ZA==",
+      "license": "MIT"
+    },
+    "node_modules/parse-bmfont-binary": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/parse-bmfont-binary/-/parse-bmfont-binary-1.0.6.tgz",
+      "integrity": "sha512-GxmsRea0wdGdYthjuUeWTMWPqm2+FAd4GI8vCvhgJsFnoGhTrLhXDDupwTo7rXVAgaLIGoVHDZS9p/5XbSqeWA==",
+      "license": "MIT"
+    },
+    "node_modules/parse-bmfont-xml": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/parse-bmfont-xml/-/parse-bmfont-xml-1.1.6.tgz",
+      "integrity": "sha512-0cEliVMZEhrFDwMh4SxIyVJpqYoOWDJ9P895tFuS+XuNzI5UBmBk5U5O4KuJdTnZpSBI4LFA2+ZiJaiwfSwlMA==",
+      "license": "MIT",
+      "dependencies": {
+        "xml-parse-from-string": "^1.0.0",
+        "xml2js": "^0.5.0"
+      }
+    },
+    "node_modules/parse-imports-exports": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/parse-imports-exports/-/parse-imports-exports-0.2.4.tgz",
+      "integrity": "sha512-4s6vd6dx1AotCx/RCI2m7t7GCh5bDRUtGNvRfHSP2wbBQdMi67pPe7mtzmgwcaQ8VKK/6IB7Glfyu3qdZJPybQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parse-statements": "1.0.11"
+      }
+    },
+    "node_modules/parse-statements": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/parse-statements/-/parse-statements-1.0.11.tgz",
+      "integrity": "sha512-HlsyYdMBnbPQ9Jr/VgJ1YF4scnldvJpJxCVx6KgqPL4dxppsWrJHCIIxQXMJrqGnsRkNPATbeMJ8Yxu7JMsYcA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/parse5": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.1.tgz",
+      "integrity": "sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==",
+      "license": "MIT",
+      "dependencies": {
+        "entities": "^8.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-expression-matcher": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.5.0.tgz",
+      "integrity": "sha512-cbrerZV+6rvdQrrD+iGMcZFEiiSrbv9Tfdkvnusy6y0x0GKBXREFg/Y65GhIfm0tnLntThhzCnfKwp1WRjeCyQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "8.4.2",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.4.2.tgz",
+      "integrity": "sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/pixelmatch": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/pixelmatch/-/pixelmatch-5.3.0.tgz",
+      "integrity": "sha512-o8mkY4E/+LNUf6LzX96ht6k6CEDi65k9G2rjMtBe9Oo+VPKSvl+0GKHuH/AlG+GA5LPG/i5hrekkxUc3s2HU+Q==",
+      "license": "ISC",
+      "dependencies": {
+        "pngjs": "^6.0.0"
+      },
+      "bin": {
+        "pixelmatch": "bin/pixelmatch"
+      }
+    },
+    "node_modules/pixelmatch/node_modules/pngjs": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/pngjs/-/pngjs-6.0.0.tgz",
+      "integrity": "sha512-TRzzuFRRmEoSW/p1KVAmiOgPco2Irlah+bGFCeNfJXxxYGwSw7YwAOAcd7X28K/m5bjBWKsC29KyoMfHbypayg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.13.0"
+      }
+    },
+    "node_modules/pkce-challenge": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.1.tgz",
+      "integrity": "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.20.0"
+      }
+    },
+    "node_modules/pngjs": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/pngjs/-/pngjs-7.0.0.tgz",
+      "integrity": "sha512-LKWqWJRhstyYo9pGvgor/ivk2w94eSjE3RGVuzLGlr3NmD8bf7RcYGze1mNdEHRP6TRP6rMuDHk5t44hnTRyow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.19.0"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.15",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
+      "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.12",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/prebuild-install": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.3.tgz",
+      "integrity": "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==",
+      "deprecated": "No longer maintained. Please contact the author of the relevant native addon; alternatives are available.",
+      "license": "MIT",
+      "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"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/prettier": {
+      "version": "3.8.4",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.8.4.tgz",
+      "integrity": "sha512-N2MylSdi48+5N/6S5j+maeHbUSIzzZ5uOcX5Hm4QpV8Dkb1HFjfAKTKX6yNPJQD9AhcT3ifHNB66tWTTJDi11Q==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
+    "node_modules/prettier-linter-helpers": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.1.tgz",
+      "integrity": "sha512-SxToR7P8Y2lWmv/kTzVLC1t/GDI2WGjMwNhLLE9qtH8Q13C+aEmuRlzDst4Up4s0Wc8sF2M+J57iB3cMLqftfg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-diff": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/prettier-plugin-organize-imports": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/prettier-plugin-organize-imports/-/prettier-plugin-organize-imports-4.3.0.tgz",
+      "integrity": "sha512-FxFz0qFhyBsGdIsb697f/EkvHzi5SZOhWAjxcx2dLt+Q532bAlhswcXGYB1yzjZ69kW8UoadFBw7TyNwlq96Iw==",
+      "dev": true,
+      "license": "MIT",
+      "peerDependencies": {
+        "prettier": ">=2.0",
+        "typescript": ">=2.9",
+        "vue-tsc": "^2.1.0 || 3"
+      },
+      "peerDependenciesMeta": {
+        "vue-tsc": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "license": "MIT"
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/pstree.remy": {
+      "version": "1.1.8",
+      "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz",
+      "integrity": "sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pump": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.4.tgz",
+      "integrity": "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==",
+      "license": "MIT",
+      "dependencies": {
+        "end-of-stream": "^1.1.0",
+        "once": "^1.3.1"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/pvtsutils": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.6.tgz",
+      "integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/pvutils": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/pvutils/-/pvutils-1.1.5.tgz",
+      "integrity": "sha512-KTqnxsgGiQ6ZAzZCVlJH5eOjSnvlyEgx1m8bkRJfOhmGRqfo5KLvmAlACQkrjEtOQ4B7wF9TdSLIs9O90MX9xA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/qrcode": {
+      "version": "1.5.4",
+      "resolved": "https://registry.npmjs.org/qrcode/-/qrcode-1.5.4.tgz",
+      "integrity": "sha512-1ca71Zgiu6ORjHqFBDpnSMTR2ReToX4l1Au1VFLyVeBTFavzQnv5JxMFr3ukHVKpSrSA2MCk0lNJSykjUfz7Zg==",
+      "license": "MIT",
+      "dependencies": {
+        "dijkstrajs": "^1.0.1",
+        "pngjs": "^5.0.0",
+        "yargs": "^15.3.1"
+      },
+      "bin": {
+        "qrcode": "bin/qrcode"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/qrcode/node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/qrcode/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/qrcode/node_modules/cliui": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-6.0.0.tgz",
+      "integrity": "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.0",
+        "wrap-ansi": "^6.2.0"
+      }
+    },
+    "node_modules/qrcode/node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/qrcode/node_modules/find-up": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz",
+      "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==",
+      "license": "MIT",
+      "dependencies": {
+        "locate-path": "^5.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/qrcode/node_modules/locate-path": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz",
+      "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==",
+      "license": "MIT",
+      "dependencies": {
+        "p-locate": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/qrcode/node_modules/p-limit": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
+      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
+      "license": "MIT",
+      "dependencies": {
+        "p-try": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/qrcode/node_modules/p-locate": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz",
+      "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==",
+      "license": "MIT",
+      "dependencies": {
+        "p-limit": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/qrcode/node_modules/pngjs": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/pngjs/-/pngjs-5.0.0.tgz",
+      "integrity": "sha512-40QW5YalBNfQo5yRYmiw7Yz6TKKVr3h6970B2YE+3fQpsWcrbj1PzJgxeJ19DRQjhMbKPIuMY8rFaXc8moolVw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/qrcode/node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/qrcode/node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/qrcode/node_modules/wrap-ansi": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz",
+      "integrity": "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/qrcode/node_modules/y18n": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz",
+      "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==",
+      "license": "ISC"
+    },
+    "node_modules/qrcode/node_modules/yargs": {
+      "version": "15.4.1",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-15.4.1.tgz",
+      "integrity": "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==",
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^6.0.0",
+        "decamelize": "^1.2.0",
+        "find-up": "^4.1.0",
+        "get-caller-file": "^2.0.1",
+        "require-directory": "^2.1.1",
+        "require-main-filename": "^2.0.0",
+        "set-blocking": "^2.0.0",
+        "string-width": "^4.2.0",
+        "which-module": "^2.0.0",
+        "y18n": "^4.0.0",
+        "yargs-parser": "^18.1.2"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/qrcode/node_modules/yargs-parser": {
+      "version": "18.1.3",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-18.1.3.tgz",
+      "integrity": "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==",
+      "license": "ISC",
+      "dependencies": {
+        "camelcase": "^5.0.0",
+        "decamelize": "^1.2.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/qs": {
+      "version": "6.15.2",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.2.tgz",
+      "integrity": "sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/quansync": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/quansync/-/quansync-1.0.0.tgz",
+      "integrity": "sha512-5xZacEEufv3HSTPQuchrvV6soaiACMFnq1H8wkVioctoH3TRha9Sz66lOxRwPK/qZj7HPiSveih9yAyh98gvqA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/antfu"
+        },
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/sxzz"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.2.tgz",
+      "integrity": "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.7.0",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/raw-body/node_modules/iconv-lite": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.2.tgz",
+      "integrity": "sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/rc": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz",
+      "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==",
+      "license": "(BSD-2-Clause OR MIT OR Apache-2.0)",
+      "dependencies": {
+        "deep-extend": "^0.6.0",
+        "ini": "~1.3.0",
+        "minimist": "^1.2.0",
+        "strip-json-comments": "~2.0.1"
+      },
+      "bin": {
+        "rc": "cli.js"
+      }
+    },
+    "node_modules/readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "license": "MIT",
+      "dependencies": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/readdir-glob": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/readdir-glob/-/readdir-glob-1.1.3.tgz",
+      "integrity": "sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "minimatch": "^5.1.0"
+      }
+    },
+    "node_modules/readdir-glob/node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/reflect-metadata": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
+      "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/require-main-filename": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz",
+      "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==",
+      "license": "ISC"
+    },
+    "node_modules/resolve-pkg-maps": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz",
+      "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"
+      }
+    },
+    "node_modules/rettime": {
+      "version": "0.11.11",
+      "resolved": "https://registry.npmjs.org/rettime/-/rettime-0.11.11.tgz",
+      "integrity": "sha512-ILJRqVWBCTlg9r42fFgwVZx1gnFAcQF8mRoMkbgQfIrjEDf9nbBFDFx00oloOa+Q869FUtaYDXZvEfnecQSCoQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/rolldown": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.3.tgz",
+      "integrity": "sha512-i00lAJ2ks1BYr7rjNjKC7BcqAS7nVfiT3QX1SI5aY+AFHblCmaUf9OE9dbdzDvW6dJxbi2ZCZiy9v3CcwOiX3g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@oxc-project/types": "=0.133.0",
+        "@rolldown/pluginutils": "^1.0.0"
+      },
+      "bin": {
+        "rolldown": "bin/cli.mjs"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "optionalDependencies": {
+        "@rolldown/binding-android-arm64": "1.0.3",
+        "@rolldown/binding-darwin-arm64": "1.0.3",
+        "@rolldown/binding-darwin-x64": "1.0.3",
+        "@rolldown/binding-freebsd-x64": "1.0.3",
+        "@rolldown/binding-linux-arm-gnueabihf": "1.0.3",
+        "@rolldown/binding-linux-arm64-gnu": "1.0.3",
+        "@rolldown/binding-linux-arm64-musl": "1.0.3",
+        "@rolldown/binding-linux-ppc64-gnu": "1.0.3",
+        "@rolldown/binding-linux-s390x-gnu": "1.0.3",
+        "@rolldown/binding-linux-x64-gnu": "1.0.3",
+        "@rolldown/binding-linux-x64-musl": "1.0.3",
+        "@rolldown/binding-openharmony-arm64": "1.0.3",
+        "@rolldown/binding-wasm32-wasi": "1.0.3",
+        "@rolldown/binding-win32-arm64-msvc": "1.0.3",
+        "@rolldown/binding-win32-x64-msvc": "1.0.3"
+      }
+    },
+    "node_modules/rolldown-plugin-dts": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/rolldown-plugin-dts/-/rolldown-plugin-dts-0.25.2.tgz",
+      "integrity": "sha512-nMhN/R+vmR8GM45ZW1FWMSjRTSDDn/6w4GTf8RNrEFCBdl8B1kySWrU1ixPtbwzXoRlcO+R/S88VgXuJQwfdDg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/generator": "8.0.0-rc.6",
+        "@babel/helper-validator-identifier": "8.0.0-rc.6",
+        "@babel/parser": "8.0.0-rc.6",
+        "ast-kit": "^3.0.0-beta.1",
+        "birpc": "^4.0.0",
+        "dts-resolver": "^3.0.0",
+        "get-tsconfig": "5.0.0-beta.5",
+        "obug": "^2.1.1"
+      },
+      "engines": {
+        "node": "^22.18.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sxzz"
+      },
+      "peerDependencies": {
+        "@ts-macro/tsc": "^0.3.6",
+        "@typescript/native-preview": ">=7.0.0-dev.20260325.1",
+        "rolldown": "^1.0.0",
+        "typescript": "^5.0.0 || ^6.0.0",
+        "vue-tsc": "~3.2.0"
+      },
+      "peerDependenciesMeta": {
+        "@ts-macro/tsc": {
+          "optional": true
+        },
+        "@typescript/native-preview": {
+          "optional": true
+        },
+        "typescript": {
+          "optional": true
+        },
+        "vue-tsc": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/rolldown-plugin-dts/node_modules/@babel/generator": {
+      "version": "8.0.0-rc.6",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-8.0.0-rc.6.tgz",
+      "integrity": "sha512-6mIzgVK8DgEzvIapoQwhXTMnnkuE4STQmVv9H03i/tZ2ml8oev3TRvZJgTenK2Bsq0YWNtzOrFdTyNzCMFtjJQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^8.0.0-rc.6",
+        "@babel/types": "^8.0.0-rc.6",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "@types/jsesc": "^2.5.0",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": "^22.18.0 || >=24.11.0"
+      }
+    },
+    "node_modules/rolldown-plugin-dts/node_modules/@babel/helper-string-parser": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-8.0.0.tgz",
+      "integrity": "sha512-6mJgmFFFIIO82vvoLt9XtRC7/TkzXfts1t/SpRX4IHSzMgqoPYCWesVu1udUPUWioAE/2fcG6WuI8zrkE1gwrg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.18.0 || >=24.11.0"
+      }
+    },
+    "node_modules/rolldown-plugin-dts/node_modules/@babel/helper-validator-identifier": {
+      "version": "8.0.0-rc.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-8.0.0-rc.6.tgz",
+      "integrity": "sha512-nVJ+1JcCgntv8d78rRo++o2wuODT0Irknx2BF8Np4Ft2CRgjLqIs4qzSZ8b66yGbBdMWGmZBO9WEZv1hhNiSpg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.18.0 || >=24.11.0"
+      }
+    },
+    "node_modules/rolldown-plugin-dts/node_modules/@babel/parser": {
+      "version": "8.0.0-rc.6",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-8.0.0-rc.6.tgz",
+      "integrity": "sha512-rOS8IpdO7mQELkTPlCsTgPejO0bFuZdEDCGQJouYbYf9e1FLTym7Fei2pEjq8q7MWbX0ravcd7QQYKs1TxOuog==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^8.0.0-rc.6"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": "^22.18.0 || >=24.11.0"
+      }
+    },
+    "node_modules/rolldown-plugin-dts/node_modules/@babel/types": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-8.0.0.tgz",
+      "integrity": "sha512-K8ponJDxBwDHigkeFqaqT5wLGl4bTlwMafR8k7b5CPxr6Ww+UG9ls8Yx6Tcpboxu97eeGVEEyKcHmEyOwN1vSw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^8.0.0",
+        "@babel/helper-validator-identifier": "^8.0.0"
+      },
+      "engines": {
+        "node": "^22.18.0 || >=24.11.0"
+      }
+    },
+    "node_modules/rolldown-plugin-dts/node_modules/@babel/types/node_modules/@babel/helper-validator-identifier": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-8.0.0.tgz",
+      "integrity": "sha512-kXxQVZHNOctSJJsqzmcbPSCEkM6oHNnDIkua7g9RCO9xRHj2eCiKvRx2KPdfWR9QxcGWnK/oArrtunmie3rL9g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^22.18.0 || >=24.11.0"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.62.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.62.0.tgz",
+      "integrity": "sha512-nc72Wgq62I7rtDV4izT5/aaS0zxy3kttkinf9586ApknY3jZO9NYsmtc24fUckA0X7Q2v+ML4a15pdUlV5V/jA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.9"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.62.0",
+        "@rollup/rollup-android-arm64": "4.62.0",
+        "@rollup/rollup-darwin-arm64": "4.62.0",
+        "@rollup/rollup-darwin-x64": "4.62.0",
+        "@rollup/rollup-freebsd-arm64": "4.62.0",
+        "@rollup/rollup-freebsd-x64": "4.62.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.62.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.62.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.62.0",
+        "@rollup/rollup-linux-arm64-musl": "4.62.0",
+        "@rollup/rollup-linux-loong64-gnu": "4.62.0",
+        "@rollup/rollup-linux-loong64-musl": "4.62.0",
+        "@rollup/rollup-linux-ppc64-gnu": "4.62.0",
+        "@rollup/rollup-linux-ppc64-musl": "4.62.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.62.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.62.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.62.0",
+        "@rollup/rollup-linux-x64-gnu": "4.62.0",
+        "@rollup/rollup-linux-x64-musl": "4.62.0",
+        "@rollup/rollup-openbsd-x64": "4.62.0",
+        "@rollup/rollup-openharmony-arm64": "4.62.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.62.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.62.0",
+        "@rollup/rollup-win32-x64-gnu": "4.62.0",
+        "@rollup/rollup-win32-x64-msvc": "4.62.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/router": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
+      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "depd": "^2.0.0",
+        "is-promise": "^4.0.0",
+        "parseurl": "^1.3.3",
+        "path-to-regexp": "^8.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/rxjs": {
+      "version": "7.8.2",
+      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz",
+      "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "tslib": "^2.1.0"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/sax": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz",
+      "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==",
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=11.0.0"
+      }
+    },
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+      "license": "ISC",
+      "dependencies": {
+        "xmlchars": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=v12.22.7"
+      }
+    },
+    "node_modules/semver": {
+      "version": "7.8.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.4.tgz",
+      "integrity": "sha512-rUCObTnP32Q08R2uuIrt7r9PlEonuTmtuXYcW6s5kjdlj3xbnwe+21yXptAUYcMAABLkYYTtnmzb3w3EDZfueA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/send": {
+      "version": "0.19.2",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz",
+      "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "~0.5.2",
+        "http-errors": "~2.0.1",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "~2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "~2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/send/node_modules/debug/node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/send/node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/serve-static": {
+      "version": "1.16.3",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz",
+      "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "~0.19.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==",
+      "license": "ISC"
+    },
+    "node_modules/set-cookie-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-3.1.0.tgz",
+      "integrity": "sha512-kjnC1DXBHcxaOaOXBHBeRtltsDG2nUiUni+jP92M9gYdW12rsmx92UsfpH7o5tDRs7I1ZZPSQJQGv3UaRfCiuw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz",
+      "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4",
+        "side-channel-list": "^1.0.1",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz",
+      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/simple-concat": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz",
+      "integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/simple-get": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-4.0.1.tgz",
+      "integrity": "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "decompress-response": "^6.0.0",
+        "once": "^1.3.1",
+        "simple-concat": "^1.0.0"
+      }
+    },
+    "node_modules/simple-update-notifier": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
+      "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/simple-xml-to-json": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/simple-xml-to-json/-/simple-xml-to-json-1.2.7.tgz",
+      "integrity": "sha512-mz9VXphOxQWX3eQ/uXCtm6upltoN0DLx8Zb5T4TFC4FHB7S9FDPGre8CfLWqPWQQH/GrQYd2AXhhVM5LDpYx6Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.12.2"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "node_modules/source-map-support/node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/std-env": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-4.1.0.tgz",
+      "integrity": "sha512-Rq7ybcX2RuC55r9oaPVEW7/xu3tj8u4GeBYHBWCychFtzMIr86A7e3PPEBPT37sHStKX3+TiX/Fr/ACmJLVlLQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/streamsearch": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/streamsearch/-/streamsearch-1.1.0.tgz",
+      "integrity": "sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/streamx": {
+      "version": "2.28.0",
+      "resolved": "https://registry.npmjs.org/streamx/-/streamx-2.28.0.tgz",
+      "integrity": "sha512-1Yowhzjf0ivGMrTIkY9hav5TxobO9qIVqUE41fiCGMGgc3CLlf4MY+9AHmZqBWgDTue0fY9zWjYFVyf6Diuobw==",
+      "license": "MIT",
+      "dependencies": {
+        "events-universal": "^1.0.0",
+        "fast-fifo": "^1.3.2",
+        "text-decoder": "^1.1.0"
+      }
+    },
+    "node_modules/strict-event-emitter": {
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/strict-event-emitter/-/strict-event-emitter-0.5.1.tgz",
+      "integrity": "sha512-vMgjE/GGEPEFnhFub6pa4FmJBRBVOLpIII2hvCZ8Kzb7K0hlHo7mQv6xYrBvCL2LtAIBwFUK8wvuJgTVSQ5MFQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
+    "node_modules/strip-bom": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
+      "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
+      "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/strnum": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.4.0.tgz",
+      "integrity": "sha512-sHrVyWWdq28RbhjuJdZsA1SnGRJV6NiXbk6AXBxDOsgAcA+lmpUZCYjOdLBxkXMwis6RRe7dlZt4VlIWFVzkmg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "anynum": "^1.0.0"
+      }
+    },
+    "node_modules/strtok3": {
+      "version": "10.3.5",
+      "resolved": "https://registry.npmjs.org/strtok3/-/strtok3-10.3.5.tgz",
+      "integrity": "sha512-ki4hZQfh5rX0QDLLkOCj+h+CVNkqmp/CMf8v8kZpkNVK6jGQooMytqzLZYUVYIZcFZ6yDB70EfD8POcFXiF5oA==",
+      "license": "MIT",
+      "dependencies": {
+        "@tokenizer/token": "^0.3.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Borewit"
+      }
+    },
+    "node_modules/superagent": {
+      "version": "10.3.0",
+      "resolved": "https://registry.npmjs.org/superagent/-/superagent-10.3.0.tgz",
+      "integrity": "sha512-B+4Ik7ROgVKrQsXTV0Jwp2u+PXYLSlqtDAhYnkkD+zn3yg8s/zjA2MeGayPoY/KICrbitwneDHrjSotxKL+0XQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "component-emitter": "^1.3.1",
+        "cookiejar": "^2.1.4",
+        "debug": "^4.3.7",
+        "fast-safe-stringify": "^2.1.1",
+        "form-data": "^4.0.5",
+        "formidable": "^3.5.4",
+        "methods": "^1.1.2",
+        "mime": "2.6.0",
+        "qs": "^6.14.1"
+      },
+      "engines": {
+        "node": ">=14.18.0"
+      }
+    },
+    "node_modules/superagent/node_modules/mime": {
+      "version": "2.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz",
+      "integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/supertest": {
+      "version": "7.2.2",
+      "resolved": "https://registry.npmjs.org/supertest/-/supertest-7.2.2.tgz",
+      "integrity": "sha512-oK8WG9diS3DlhdUkcFn4tkNIiIbBx9lI2ClF8K+b2/m8Eyv47LSawxUzZQSNKUrVb2KsqeTDCcjAAVPYaSLVTA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cookie-signature": "^1.2.2",
+        "methods": "^1.1.2",
+        "superagent": "^10.3.0"
+      },
+      "engines": {
+        "node": ">=14.18.0"
+      }
+    },
+    "node_modules/supertest/node_modules/cookie-signature": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
+      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.6.0"
+      }
+    },
+    "node_modules/swagger-ui-dist": {
+      "version": "5.32.8",
+      "resolved": "https://registry.npmjs.org/swagger-ui-dist/-/swagger-ui-dist-5.32.8.tgz",
+      "integrity": "sha512-dgMdWXIgnI4zX4OPhKEdWnlDODbgm8W3AX0Ivn/BBqcUh6xZsBxhZMnvk6DJyRz1BTrj8dPxtarmEGgkz30oyA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@scarf/scarf": "=1.4.0"
+      }
+    },
+    "node_modules/swagger-ui-express": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/swagger-ui-express/-/swagger-ui-express-5.0.1.tgz",
+      "integrity": "sha512-SrNU3RiBGTLLmFU8GIJdOdanJTl4TOmT27tt3bWWHppqYmAZ6IDuEuBvMU6nZq0zLEe6b/1rACXCgLZqO6ZfrA==",
+      "license": "MIT",
+      "dependencies": {
+        "swagger-ui-dist": ">=5.0.0"
+      },
+      "engines": {
+        "node": ">= v0.10.32"
+      },
+      "peerDependencies": {
+        "express": ">=4.0.0 || >=5.0.0-beta"
+      }
+    },
+    "node_modules/symbol-tree": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+      "license": "MIT"
+    },
+    "node_modules/synckit": {
+      "version": "0.11.13",
+      "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.11.13.tgz",
+      "integrity": "sha512-eNRKgb3z66Yp3D2CixVujOUvXLFUTij/zVnV8KRyvFdQwpz7I5DS8UfRkTeLzb64u+dkzDSdelE24izu+zSSUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@pkgr/core": "^0.3.6"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/synckit"
+      }
+    },
+    "node_modules/tagged-tag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/tagged-tag/-/tagged-tag-1.0.0.tgz",
+      "integrity": "sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/tar-fs": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.4.tgz",
+      "integrity": "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "chownr": "^1.1.1",
+        "mkdirp-classic": "^0.5.2",
+        "pump": "^3.0.0",
+        "tar-stream": "^2.1.4"
+      }
+    },
+    "node_modules/tar-fs/node_modules/tar-stream": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz",
+      "integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==",
+      "license": "MIT",
+      "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"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/tar-stream": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-3.2.0.tgz",
+      "integrity": "sha512-ojzvCvVaNp6aOTFmG7jaRD0meowIAuPc3cMMhSgKiVWws1GyHbGd/xvnyuRKcKlMpt3qvxx6r0hreCNITP9hIg==",
+      "license": "MIT",
+      "dependencies": {
+        "b4a": "^1.6.4",
+        "bare-fs": "^4.5.5",
+        "fast-fifo": "^1.2.0",
+        "streamx": "^2.15.0"
+      }
+    },
+    "node_modules/teex": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/teex/-/teex-1.0.1.tgz",
+      "integrity": "sha512-eYE6iEI62Ni1H8oIa7KlDU6uQBtqr4Eajni3wX7rpfXD8ysFx8z0+dri+KWEPWpBsxXfxu58x/0jvTVT1ekOSg==",
+      "license": "MIT",
+      "dependencies": {
+        "streamx": "^2.12.5"
+      }
+    },
+    "node_modules/terser": {
+      "version": "5.48.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.48.0.tgz",
+      "integrity": "sha512-J/9An6vs9Us6wKRriSFXBWdRZapREHqFzdNUKk0pmu804EMR6dr6winwo7e5JDxN4xahxQsuysyYFwlwj4XN/Q==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "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"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/terser/node_modules/commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/text-decoder": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/text-decoder/-/text-decoder-1.2.7.tgz",
+      "integrity": "sha512-vlLytXkeP4xvEq2otHeJfSQIRyWxo/oZGEbXrtEEF9Hnmrdly59sUbzZ/QgyWuLYHctCHxFF4tRQZNQ9k60ExQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "b4a": "^1.6.4"
+      }
+    },
+    "node_modules/thirty-two": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/thirty-two/-/thirty-two-1.0.2.tgz",
+      "integrity": "sha512-OEI0IWCe+Dw46019YLl6V10Us5bi574EvlJEOcAkB29IzQ/mYD1A6RyNHLjZPiHCmuodxvgF6U+vZO1L15lxVA==",
+      "engines": {
+        "node": ">=0.2.6"
+      }
+    },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinycolor2": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/tinycolor2/-/tinycolor2-1.6.0.tgz",
+      "integrity": "sha512-XPaBkWQJdsf3pLKJV9p4qN/S+fm2Oj8AIPo1BTUhg5oxkvm9+SVEGFdhyOz7tTdUTfvxMiAs4sp6/eZO2Ew+pw==",
+      "license": "MIT"
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.17",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
+      "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyglobby/node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tinyglobby/node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/tinyrainbow": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-3.1.0.tgz",
+      "integrity": "sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tldts": {
+      "version": "7.4.3",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.4.3.tgz",
+      "integrity": "sha512-A3BDQBeeukYPzB4QdQ1DtdlUmp4x2OCH8n5UVhEWbyANxNep8GavottKzd1xYKFJKjUgMyPT7EzOfnBO55s8Sg==",
+      "license": "MIT",
+      "dependencies": {
+        "tldts-core": "^7.4.3"
+      },
+      "bin": {
+        "tldts": "bin/cli.js"
+      }
+    },
+    "node_modules/tldts-core": {
+      "version": "7.4.3",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.4.3.tgz",
+      "integrity": "sha512-27ep5H9PzdBrNd5OFM/j3WCU8F3kPwM9D0BOaOf7uYfxMJfyr0K5Tjj69Gri+sZlh2WXd5buIm47NuPF29CDiw==",
+      "license": "MIT"
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/token-types": {
+      "version": "6.1.2",
+      "resolved": "https://registry.npmjs.org/token-types/-/token-types-6.1.2.tgz",
+      "integrity": "sha512-dRXchy+C0IgK8WPC6xvCHFRIWYUbqqdEIKPaKo/AcTUNzwLTK6AH7RjdLWsEZcAN/TBdtfUw3PYEgPr5VPr6ww==",
+      "license": "MIT",
+      "dependencies": {
+        "@borewit/text-codec": "^0.2.1",
+        "@tokenizer/token": "^0.3.0",
+        "ieee754": "^1.2.1"
+      },
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Borewit"
+      }
+    },
+    "node_modules/touch": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.1.tgz",
+      "integrity": "sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "nodetouch": "bin/nodetouch.js"
+      }
+    },
+    "node_modules/tough-cookie": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.1.tgz",
+      "integrity": "sha512-LktZQb3IeoUWB9lqR5EWTHgW/VTITCXg4D21M+lvybRVdylLrRMnqaIONLVb5mav8vM19m44HIcGq4qASeu2Qw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tldts": "^7.0.5"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
+      "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/tree-kill": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz",
+      "integrity": "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "tree-kill": "cli.js"
+      }
+    },
+    "node_modules/ts-api-utils": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.5.0.tgz",
+      "integrity": "sha512-OJ/ibxhPlqrMM0UiNHJ/0CKQkoKF243/AEmplt3qpRgkW8VG7IfOS41h7V8TjITqdByHzrjcS/2si+y4lIh8NA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.12"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.8.4"
+      }
+    },
+    "node_modules/tsconfig-paths": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz",
+      "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==",
+      "license": "MIT",
+      "dependencies": {
+        "json5": "^2.2.2",
+        "minimist": "^1.2.6",
+        "strip-bom": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "license": "0BSD"
+    },
+    "node_modules/tsx": {
+      "version": "4.22.4",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.22.4.tgz",
+      "integrity": "sha512-X8EX+XV4QR5xCsrgxaED954zTDfY8KqlDtskKEL0cHhyS/P8b4IFOvGDQpsC9Q1XnLq915wEfwwY/zzskCtmhg==",
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "~0.28.0"
+      },
+      "bin": {
+        "tsx": "dist/cli.mjs"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      }
+    },
+    "node_modules/tsx/node_modules/@esbuild/linux-x64": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz",
+      "integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/tsx/node_modules/esbuild": {
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz",
+      "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.28.1",
+        "@esbuild/android-arm": "0.28.1",
+        "@esbuild/android-arm64": "0.28.1",
+        "@esbuild/android-x64": "0.28.1",
+        "@esbuild/darwin-arm64": "0.28.1",
+        "@esbuild/darwin-x64": "0.28.1",
+        "@esbuild/freebsd-arm64": "0.28.1",
+        "@esbuild/freebsd-x64": "0.28.1",
+        "@esbuild/linux-arm": "0.28.1",
+        "@esbuild/linux-arm64": "0.28.1",
+        "@esbuild/linux-ia32": "0.28.1",
+        "@esbuild/linux-loong64": "0.28.1",
+        "@esbuild/linux-mips64el": "0.28.1",
+        "@esbuild/linux-ppc64": "0.28.1",
+        "@esbuild/linux-riscv64": "0.28.1",
+        "@esbuild/linux-s390x": "0.28.1",
+        "@esbuild/linux-x64": "0.28.1",
+        "@esbuild/netbsd-arm64": "0.28.1",
+        "@esbuild/netbsd-x64": "0.28.1",
+        "@esbuild/openbsd-arm64": "0.28.1",
+        "@esbuild/openbsd-x64": "0.28.1",
+        "@esbuild/openharmony-arm64": "0.28.1",
+        "@esbuild/sunos-x64": "0.28.1",
+        "@esbuild/win32-arm64": "0.28.1",
+        "@esbuild/win32-ia32": "0.28.1",
+        "@esbuild/win32-x64": "0.28.1"
+      }
+    },
+    "node_modules/tsyringe": {
+      "version": "4.10.0",
+      "resolved": "https://registry.npmjs.org/tsyringe/-/tsyringe-4.10.0.tgz",
+      "integrity": "sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^1.9.3"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/tsyringe/node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "license": "0BSD"
+    },
+    "node_modules/tunnel-agent": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz",
+      "integrity": "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "safe-buffer": "^5.0.1"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "prelude-ls": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/type-fest": {
+      "version": "5.7.0",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-5.7.0.tgz",
+      "integrity": "sha512-1URUxUqfHFM1c+zfSPsa3gnkO7Aq21qyH75SIduNYz4SzY964rn1X2vCMQaHSHhktiw+0kPa2iyb6PUpXqB6Vg==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "dependencies": {
+        "tagged-tag": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/typedarray": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
+      "integrity": "sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==",
+      "license": "MIT"
+    },
+    "node_modules/typescript": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.3.tgz",
+      "integrity": "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==",
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/typescript-eslint": {
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.61.1.tgz",
+      "integrity": "sha512-V7PayAfJokV3pEHgN7/v03D1SpujhRfQtYLbLIiBfDDncdg4PAiRBfoS4cnCANK4jmAPncczi59QO3afiXUlNw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@typescript-eslint/eslint-plugin": "8.61.1",
+        "@typescript-eslint/parser": "8.61.1",
+        "@typescript-eslint/typescript-estree": "8.61.1",
+        "@typescript-eslint/utils": "8.61.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/typescript-eslint"
+      },
+      "peerDependencies": {
+        "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
+        "typescript": ">=4.8.4 <6.1.0"
+      }
+    },
+    "node_modules/tz-lookup": {
+      "version": "6.1.25",
+      "resolved": "https://registry.npmjs.org/tz-lookup/-/tz-lookup-6.1.25.tgz",
+      "integrity": "sha512-fFewT9o1uDzsW1QnUU1ValqaihFnwiUiiHr1S79/fxOzKXYYvX+EHeRnpvQJ9B3Qg67wPXT6QF2Esc4pFOrvLg==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
+    "node_modules/uid": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/uid/-/uid-2.0.2.tgz",
+      "integrity": "sha512-u3xV3X7uzvi5b1MncmZo3i2Aw222Zk1keqLA1YkHldREkAhAqi65wuPfe7lHx8H/Wzy+8CE7S7uS3jekIM5s8g==",
+      "license": "MIT",
+      "dependencies": {
+        "@lukeed/csprng": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/uint8array-extras": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/uint8array-extras/-/uint8array-extras-1.5.0.tgz",
+      "integrity": "sha512-rvKSBiC5zqCCiDZ9kAOszZcDvdAHwwIKJG33Ykj43OKcWsnmcBRL09YTU4nOeHZ8Y2a7l1MgTd08SBe9A8Qj6A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/unconfig-core": {
+      "version": "7.5.0",
+      "resolved": "https://registry.npmjs.org/unconfig-core/-/unconfig-core-7.5.0.tgz",
+      "integrity": "sha512-Su3FauozOGP44ZmKdHy2oE6LPjk51M/TRRjHv2HNCWiDvfvCoxC2lno6jevMA91MYAdCdwP05QnWdWpSbncX/w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@quansync/fs": "^1.0.0",
+        "quansync": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/undefsafe": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.5.tgz",
+      "integrity": "sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/undici": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-7.28.0.tgz",
+      "integrity": "sha512-cRZYrTDwWznlnRiPjggAGxZXanty6M8RV1ff8Wm4LWXBp7/IG8v5DnOm74DtUBp9OONpK75YlPnIjQqX0dBDtA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.18.1"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.24.6",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.24.6.tgz",
+      "integrity": "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/unplugin": {
+      "version": "2.3.11",
+      "resolved": "https://registry.npmjs.org/unplugin/-/unplugin-2.3.11.tgz",
+      "integrity": "sha512-5uKD0nqiYVzlmCRs01Fhs2BdkEgBS3SAVP6ndrBsuK42iC2+JHyxM05Rm9G8+5mkmRtzMZGY8Ct5+mliZxU/Ww==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/remapping": "^2.3.5",
+        "acorn": "^8.15.0",
+        "picomatch": "^4.0.3",
+        "webpack-virtual-modules": "^0.6.2"
+      },
+      "engines": {
+        "node": ">=18.12.0"
+      }
+    },
+    "node_modules/unplugin-swc": {
+      "version": "1.5.9",
+      "resolved": "https://registry.npmjs.org/unplugin-swc/-/unplugin-swc-1.5.9.tgz",
+      "integrity": "sha512-RKwK3yf0M+MN17xZfF14bdKqfx0zMXYdtOdxLiE6jHAoidupKq3jGdJYANyIM1X/VmABhh1WpdO+/f4+Ol89+g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rollup/pluginutils": "^5.3.0",
+        "load-tsconfig": "^0.2.5",
+        "unplugin": "^2.3.11"
+      },
+      "peerDependencies": {
+        "@swc/core": "^1.2.108"
+      }
+    },
+    "node_modules/unplugin/node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/until-async": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/until-async/-/until-async-3.0.2.tgz",
+      "integrity": "sha512-IiSk4HlzAMqTUseHHe3VhIGyuFmN90zMTpD3Z3y8jeQbzLIq500MVM7Jq2vUAnTKAFPJrqwkzr6PoTcPhGcOiw==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/kettanaito"
+      }
+    },
+    "node_modules/unzipper": {
+      "version": "0.12.3",
+      "resolved": "https://registry.npmjs.org/unzipper/-/unzipper-0.12.3.tgz",
+      "integrity": "sha512-PZ8hTS+AqcGxsaQntl3IRBw65QrBI6lxzqDEL7IAo/XCEqRTKGfOX56Vea5TH9SZczRVxuzk1re04z/YjuYCJA==",
+      "license": "MIT",
+      "dependencies": {
+        "bluebird": "~3.7.2",
+        "duplexer2": "~0.1.4",
+        "fs-extra": "^11.2.0",
+        "graceful-fs": "^4.2.2",
+        "node-int64": "^0.4.0"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/utif2": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/utif2/-/utif2-4.1.0.tgz",
+      "integrity": "sha512-+oknB9FHrJ7oW7A2WZYajOcv4FcDR4CfoGB0dPNfxbi4GO05RRnFmt5oa23+9w32EanrYcSJWspUiJkLMs+37w==",
+      "license": "MIT",
+      "dependencies": {
+        "pako": "^1.0.11"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "license": "MIT"
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/uuid": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-14.0.0.tgz",
+      "integrity": "sha512-Qo+uWgilfSmAhXCMav1uYFynlQO7fMFiMVZsQqZRMIXp0O7rR7qjkj+cPvBHLgBqi960QCoo/PH2/6ZtVqKvrg==",
+      "funding": [
+        "https://github.com/sponsors/broofa",
+        "https://github.com/sponsors/ctavan"
+      ],
+      "license": "MIT",
+      "bin": {
+        "uuid": "dist-node/bin/uuid"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/vite": {
+      "version": "8.0.16",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.16.tgz",
+      "integrity": "sha512-h9bXPmJichP5fLmVQo3PyaGSDE2n3aPuomeAlVRm0JLmt4rY6zmPKd59HYI4LNW8oTK7tlTsuC7l/m7awx9Jcw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "lightningcss": "^1.32.0",
+        "picomatch": "^4.0.4",
+        "postcss": "^8.5.15",
+        "rolldown": "1.0.3",
+        "tinyglobby": "^0.2.17"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "@vitejs/devtools": "^0.1.18",
+        "esbuild": "^0.27.0 || ^0.28.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "@vitejs/devtools": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite/node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/vitest": {
+      "version": "4.1.9",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-4.1.9.tgz",
+      "integrity": "sha512-nE3/LEyc0z87uHYLZebqCUOaJr2hdtuPp7BQ4BosVFnfltxgAvMG08NyrSGlPpOUWvR27c5flSmYFTNr78L9GQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/expect": "4.1.9",
+        "@vitest/mocker": "4.1.9",
+        "@vitest/pretty-format": "4.1.9",
+        "@vitest/runner": "4.1.9",
+        "@vitest/snapshot": "4.1.9",
+        "@vitest/spy": "4.1.9",
+        "@vitest/utils": "4.1.9",
+        "es-module-lexer": "^2.0.0",
+        "expect-type": "^1.3.0",
+        "magic-string": "^0.30.21",
+        "obug": "^2.1.1",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.3",
+        "std-env": "^4.0.0-rc.1",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^1.0.2",
+        "tinyglobby": "^0.2.15",
+        "tinyrainbow": "^3.1.0",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^20.0.0 || ^22.0.0 || >=24.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@opentelemetry/api": "^1.9.0",
+        "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0",
+        "@vitest/browser-playwright": "4.1.9",
+        "@vitest/browser-preview": "4.1.9",
+        "@vitest/browser-webdriverio": "4.1.9",
+        "@vitest/coverage-istanbul": "4.1.9",
+        "@vitest/coverage-v8": "4.1.9",
+        "@vitest/ui": "4.1.9",
+        "happy-dom": "*",
+        "jsdom": "*",
+        "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@opentelemetry/api": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser-playwright": {
+          "optional": true
+        },
+        "@vitest/browser-preview": {
+          "optional": true
+        },
+        "@vitest/browser-webdriverio": {
+          "optional": true
+        },
+        "@vitest/coverage-istanbul": {
+          "optional": true
+        },
+        "@vitest/coverage-v8": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        },
+        "vite": {
+          "optional": false
+        }
+      }
+    },
+    "node_modules/vitest/node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/vitest/node_modules/tinyexec": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.2.4.tgz",
+      "integrity": "sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/w3c-xmlserializer": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+      "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
+      "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/webpack-virtual-modules": {
+      "version": "0.6.2",
+      "resolved": "https://registry.npmjs.org/webpack-virtual-modules/-/webpack-virtual-modules-0.6.2.tgz",
+      "integrity": "sha512-66/V2i5hQanC51vBQKPH4aI8NMAcBW59FVBs+rC7eGHupMyfn34q7rZIE+ETlJ+XTevqfUhVVBgSUNSW2flEUQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
+      "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "16.0.1",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.1.tgz",
+      "integrity": "sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==",
+      "license": "MIT",
+      "dependencies": {
+        "@exodus/bytes": "^1.11.0",
+        "tr46": "^6.0.0",
+        "webidl-conversions": "^8.0.1"
+      },
+      "engines": {
+        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/which-module": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.1.tgz",
+      "integrity": "sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==",
+      "license": "ISC"
+    },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "license": "ISC"
+    },
+    "node_modules/ws": {
+      "version": "8.21.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
+      "integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/xml-naming": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/xml-naming/-/xml-naming-0.1.0.tgz",
+      "integrity": "sha512-k8KO9hrMyNk6tUWqUfkTEZbezRRpONVOzUTnc97VnCvyj6Tf9lyUR9EDAIeiVLv56jsMcoXEwjW8Kv5yPY52lw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/xml-parse-from-string": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/xml-parse-from-string/-/xml-parse-from-string-1.0.1.tgz",
+      "integrity": "sha512-ErcKwJTF54uRzzNMXq2X5sMIy88zJvfN2DmdoQvy7PAFJ+tPRU6ydWuOKNMyfmOjdyBQTFREi60s0Y0SyI0G0g==",
+      "license": "MIT"
+    },
+    "node_modules/xml2js": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.5.0.tgz",
+      "integrity": "sha512-drPFnkQJik/O+uPKpqSgr22mpuFHqKdbS835iAQrUC73L2F5WkboIRd63ai/2Yg6I1jzifPFKH2NTK+cfglkIA==",
+      "license": "MIT",
+      "dependencies": {
+        "sax": ">=0.6.0",
+        "xmlbuilder": "~11.0.0"
+      },
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/xmlbuilder": {
+      "version": "11.0.1",
+      "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-11.0.1.tgz",
+      "integrity": "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "license": "MIT"
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/zip-stream": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/zip-stream/-/zip-stream-5.0.2.tgz",
+      "integrity": "sha512-LfOdrUvPB8ZoXtvOBz6DlNClfvi//b5d56mSWyJi7XbH/HfhOHfUhOqxhT/rUiR7yiktlunqRo+jY6y/cWC/5g==",
+      "license": "MIT",
+      "dependencies": {
+        "archiver-utils": "^4.0.1",
+        "compress-commons": "^5.0.1",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">= 12.0.0"
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
+      "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.25.2",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.2.tgz",
+      "integrity": "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==",
+      "license": "ISC",
+      "peerDependencies": {
+        "zod": "^3.25.28 || ^4"
+      }
+    },
+    "server": {
+      "name": "@trek/server",
+      "version": "3.1.0",
+      "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.28.0",
+        "@nestjs/common": "^11.1.24",
+        "@nestjs/core": "^11.1.24",
+        "@nestjs/platform-express": "^11.1.24",
+        "@nestjs/swagger": "^11.4.5",
+        "@simplewebauthn/server": "^13.1.2",
+        "@trek/shared": "*",
+        "archiver": "^6.0.1",
+        "bcryptjs": "^2.4.3",
+        "better-sqlite3": "^12.8.0",
+        "cookie-parser": "^1.4.7",
+        "cors": "^2.8.5",
+        "dotenv": "^16.4.1",
+        "express": "^4.18.3",
+        "fast-xml-parser": "^5.5.10",
+        "helmet": "^8.1.0",
+        "jimp": "^1.6.1",
+        "jsonwebtoken": "^9.0.2",
+        "multer": "^2.1.1",
+        "node-cron": "^4.2.1",
+        "nodemailer": "^8.0.5",
+        "otplib": "^12.0.1",
+        "qrcode": "^1.5.4",
+        "reflect-metadata": "^0.2.2",
+        "rxjs": "^7.8.2",
+        "semver": "^7.7.4",
+        "swagger-ui-express": "^5.0.1",
+        "tsconfig-paths": "^4.2.0",
+        "tsx": "^4.21.0",
+        "typescript": "^6.0.2",
+        "undici": "^7.0.0",
+        "unzipper": "^0.12.3",
+        "uuid": "^14.0.0",
+        "ws": "^8.21.0",
+        "zod": "^4.3.6"
+      },
+      "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "@nestjs/testing": "^11.1.24",
+        "@swc/core": "^1.15.40",
+        "@trivago/prettier-plugin-sort-imports": "^6.0.2",
+        "@types/archiver": "^7.0.0",
+        "@types/bcryptjs": "^2.4.6",
+        "@types/better-sqlite3": "^7.6.13",
+        "@types/cookie-parser": "^1.4.10",
+        "@types/cors": "^2.8.19",
+        "@types/express": "^4.17.25",
+        "@types/jsonwebtoken": "^9.0.10",
+        "@types/multer": "^2.1.0",
+        "@types/node": "^25.5.0",
+        "@types/node-cron": "^3.0.11",
+        "@types/nodemailer": "^7.0.11",
+        "@types/qrcode": "^1.5.5",
+        "@types/semver": "^7.7.1",
+        "@types/supertest": "^6.0.3",
+        "@types/unzipper": "^0.10.11",
+        "@types/uuid": "^10.0.0",
+        "@types/ws": "^8.18.1",
+        "@vitest/coverage-istanbul": "^4.1.9",
+        "@vitest/coverage-v8": "^4.1.9",
+        "eslint": "^9.18.0",
+        "eslint-config-flat-gitignore": "^2.3.0",
+        "eslint-config-prettier": "^10.0.1",
+        "eslint-plugin-prettier": "^5.2.2",
+        "nodemon": "^3.1.0",
+        "prettier": "^3.8.3",
+        "prettier-plugin-organize-imports": "^4.3.0",
+        "supertest": "^7.2.2",
+        "typescript-eslint": "^8.58.2",
+        "tz-lookup": "^6.1.25",
+        "unplugin-swc": "^1.5.9",
+        "vitest": "^4.1.9"
+      }
+    },
+    "server/node_modules/@eslint/config-array": {
+      "version": "0.21.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.2.tgz",
+      "integrity": "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/object-schema": "^2.1.7",
+        "debug": "^4.3.1",
+        "minimatch": "^3.1.5"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "server/node_modules/@eslint/config-helpers": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz",
+      "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "server/node_modules/@eslint/core": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz",
+      "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@types/json-schema": "^7.0.15"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "server/node_modules/@eslint/object-schema": {
+      "version": "2.1.7",
+      "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz",
+      "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "server/node_modules/@eslint/plugin-kit": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz",
+      "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@eslint/core": "^0.17.0",
+        "levn": "^0.4.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "server/node_modules/ajv": {
+      "version": "6.15.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz",
+      "integrity": "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "server/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "server/node_modules/brace-expansion": {
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.15.tgz",
+      "integrity": "sha512-EwOCDEex4quD37XhqM3omwtMoJjr//isUZz1JopUNWms+4Z2ViyM/k1YIRePpoVNnQhENnxtFjLaxNHrT7xIUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "server/node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "server/node_modules/eslint": {
+      "version": "9.39.4",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.4.tgz",
+      "integrity": "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.8.0",
+        "@eslint-community/regexpp": "^4.12.1",
+        "@eslint/config-array": "^0.21.2",
+        "@eslint/config-helpers": "^0.4.2",
+        "@eslint/core": "^0.17.0",
+        "@eslint/eslintrc": "^3.3.5",
+        "@eslint/js": "9.39.4",
+        "@eslint/plugin-kit": "^0.4.1",
+        "@humanfs/node": "^0.16.6",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@humanwhocodes/retry": "^0.4.2",
+        "@types/estree": "^1.0.6",
+        "ajv": "^6.14.0",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.6",
+        "debug": "^4.3.2",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^8.4.0",
+        "eslint-visitor-keys": "^4.2.1",
+        "espree": "^10.4.0",
+        "esquery": "^1.5.0",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^8.0.0",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.5",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      },
+      "peerDependencies": {
+        "jiti": "*"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        }
+      }
+    },
+    "server/node_modules/eslint-scope": {
+      "version": "8.4.0",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz",
+      "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "server/node_modules/eslint-visitor-keys": {
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz",
+      "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "server/node_modules/eslint/node_modules/@eslint/js": {
+      "version": "9.39.4",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.4.tgz",
+      "integrity": "sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://eslint.org/donate"
+      }
+    },
+    "server/node_modules/espree": {
+      "version": "10.4.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz",
+      "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "acorn": "^8.15.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^4.2.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "server/node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "server/node_modules/minimatch": {
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "server/node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "shared": {
+      "name": "@trek/shared",
+      "version": "3.1.0",
+      "extraneous": true,
+      "dependencies": {
+        "isomorphic-dompurify": "^3.15.0",
+        "zod": "^4.3.6"
+      },
+      "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "@trivago/prettier-plugin-sort-imports": "^6.0.2",
+        "eslint": "^10.3.0",
+        "eslint-config-flat-gitignore": "^2.3.0",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-plugin-prettier": "^5.5.5",
+        "prettier": "3.8.3",
+        "prettier-plugin-organize-imports": "^4.3.0",
+        "tsdown": "^0.22.2",
+        "typescript": "^6.0.2",
+        "typescript-eslint": "^8.58.2",
+        "vitest": "^4.1.9"
+      }
+    }
+  }
+}
diff --git a/node_modules/@asamuzakjp/css-color/LICENSE b/node_modules/@asamuzakjp/css-color/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..0004c5272f5e80af40a8730c0e0af05d21b3e42d
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 asamuzaK (Kazz)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/@asamuzakjp/css-color/README.md b/node_modules/@asamuzakjp/css-color/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..715b6c356482c7d7fd0a1eaab124cea9e5569bcc
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/README.md
@@ -0,0 +1,316 @@
+# CSS color
+
+[![build](https://github.com/asamuzaK/cssColor/actions/workflows/node.js.yml/badge.svg)](https://github.com/asamuzaK/cssColor/actions/workflows/node.js.yml)
+[![CodeQL](https://github.com/asamuzaK/cssColor/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/asamuzaK/cssColor/actions/workflows/github-code-scanning/codeql)
+[![npm (scoped)](https://img.shields.io/npm/v/@asamuzakjp/css-color)](https://www.npmjs.com/package/@asamuzakjp/css-color)
+
+Resolve and convert CSS colors.
+
+## Install
+
+```console
+npm i @asamuzakjp/css-color
+```
+
+## Usage
+
+```javascript
+import { convert, resolve, utils } from '@asamuzakjp/css-color';
+
+const resolvedValue = resolve(
+  'color-mix(in oklab, lch(67.5345 42.5 258.2), color(srgb 0 0.5 0))'
+);
+// 'oklab(0.620754 -0.0931934 -0.00374881)'
+
+const convertedValue = convert.colorToHex('lab(46.2775% -47.5621 48.5837)');
+// '#008000'
+
+const result = utils.isColor('green');
+// true
+```
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+### resolve(color, opt)
+
+resolves CSS color
+
+#### Parameters
+
+- `color` **[string][133]** color value
+  - system colors are not supported
+- `opt` **[object][135]?** options (optional, default `{}`)
+  - `opt.currentColor` **[string][133]?**
+    - color to use for `currentcolor` keyword
+    - if omitted, it will be treated as a missing color,
+      i.e. `rgb(none none none / none)`
+  - `opt.customProperty` **[object][135]?**
+    - custom properties
+    - pair of `--` prefixed property name as a key and it's value,
+      e.g.
+      ```javascript
+      const opt = {
+        customProperty: {
+          '--some-color': '#008000',
+          '--some-length': '16px'
+        }
+      };
+      ```
+    - and/or `callback` function to get the value of the custom property,
+      e.g.
+      ```javascript
+      const node = document.getElementById('foo');
+      const opt = {
+        customProperty: {
+          callback: node.style.getPropertyValue
+        }
+      };
+      ```
+  - `opt.dimension` **[object][135]?**
+    - dimension, e.g. for converting relative length to pixels
+    - pair of unit as a key and number in pixels as it's value,
+      e.g. suppose `1em === 12px`, `1rem === 16px` and `100vw === 1024px`, then
+      ```javascript
+      const opt = {
+        dimension: {
+          em: 12,
+          rem: 16,
+          vw: 10.24
+        }
+      };
+      ```
+    - and/or `callback` function to get the value as a number in pixels,
+      e.g.
+      ```javascript
+      const opt = {
+        dimension: {
+          callback: unit => {
+            switch (unit) {
+              case 'em':
+                return 12;
+              case 'rem':
+                return 16;
+              case 'vw':
+                return 10.24;
+              default:
+                return;
+            }
+          }
+        }
+      };
+      ```
+  - `opt.format` **[string][133]?**
+    - output format, one of below
+      - `computedValue` (default), [computed value][139] of the color
+      - `specifiedValue`, [specified value][140] of the color
+      - `hex`, hex color notation, i.e. `#rrggbb`
+      - `hexAlpha`, hex color notation with alpha channel, i.e. `#rrggbbaa`
+
+Returns **[string][133]?** one of `rgba?()`, `#rrggbb(aa)?`, `color-name`, `color(color-space r g b / alpha)`, `color(color-space x y z / alpha)`, `(ok)?lab(l a b / alpha)`, `(ok)?lch(l c h / alpha)`, `'(empty-string)'`, `null`
+
+- in `computedValue`, values are numbers, however `rgb()` values are integers
+- in `specifiedValue`, returns `empty string` for unknown and/or invalid color
+- in `hex`, returns `null` for `transparent`, and also returns `null` if any of `r`, `g`, `b`, `alpha` is not a number
+- in `hexAlpha`, returns `#00000000` for `transparent`, however returns `null` if any of `r`, `g`, `b`, `alpha` is not a number
+
+### convert
+
+Contains various color conversion functions.
+
+### convert.numberToHex(value)
+
+convert number to hex string
+
+#### Parameters
+
+- `value` **[number][134]** color value
+
+Returns **[string][133]** hex string: 00..ff
+
+### convert.colorToHex(value, opt)
+
+convert color to hex
+
+#### Parameters
+
+- `value` **[string][133]** color value
+- `opt` **[object][135]?** options (optional, default `{}`)
+  - `opt.alpha` **[boolean][136]?** return in #rrggbbaa notation
+  - `opt.customProperty` **[object][135]?**
+    - custom properties, see `resolve()` function above
+  - `opt.dimension` **[object][135]?**
+    - dimension, see `resolve()` function above
+
+Returns **[string][133]** #rrggbb(aa)?
+
+### convert.colorToHsl(value, opt)
+
+convert color to hsl
+
+#### Parameters
+
+- `value` **[string][133]** color value
+- `opt` **[object][135]?** options (optional, default `{}`)
+  - `opt.customProperty` **[object][135]?**
+    - custom properties, see `resolve()` function above
+  - `opt.dimension` **[object][135]?**
+    - dimension, see `resolve()` function above
+
+Returns **[Array][137]<[number][134]>** \[h, s, l, alpha]
+
+### convert.colorToHwb(value, opt)
+
+convert color to hwb
+
+#### Parameters
+
+- `value` **[string][133]** color value
+- `opt` **[object][135]?** options (optional, default `{}`)
+  - `opt.customProperty` **[object][135]?**
+    - custom properties, see `resolve()` function above
+  - `opt.dimension` **[object][135]?**
+    - dimension, see `resolve()` function above
+
+Returns **[Array][137]<[number][134]>** \[h, w, b, alpha]
+
+### convert.colorToLab(value, opt)
+
+convert color to lab
+
+#### Parameters
+
+- `value` **[string][133]** color value
+- `opt` **[object][135]?** options (optional, default `{}`)
+  - `opt.customProperty` **[object][135]?**
+    - custom properties, see `resolve()` function above
+  - `opt.dimension` **[object][135]?**
+    - dimension, see `resolve()` function above
+
+Returns **[Array][137]<[number][134]>** \[l, a, b, alpha]
+
+### convert.colorToLch(value, opt)
+
+convert color to lch
+
+#### Parameters
+
+- `value` **[string][133]** color value
+- `opt` **[object][135]?** options (optional, default `{}`)
+  - `opt.customProperty` **[object][135]?**
+    - custom properties, see `resolve()` function above
+  - `opt.dimension` **[object][135]?**
+    - dimension, see `resolve()` function above
+
+Returns **[Array][137]<[number][134]>** \[l, c, h, alpha]
+
+### convert.colorToOklab(value, opt)
+
+convert color to oklab
+
+#### Parameters
+
+- `value` **[string][133]** color value
+- `opt` **[object][135]?** options (optional, default `{}`)
+  - `opt.customProperty` **[object][135]?**
+    - custom properties, see `resolve()` function above
+  - `opt.dimension` **[object][135]?**
+    - dimension, see `resolve()` function above
+
+Returns **[Array][137]<[number][134]>** \[l, a, b, alpha]
+
+### convert.colorToOklch(value, opt)
+
+convert color to oklch
+
+#### Parameters
+
+- `value` **[string][133]** color value
+- `opt` **[object][135]?** options (optional, default `{}`)
+  - `opt.customProperty` **[object][135]?**
+    - custom properties, see `resolve()` function above
+  - `opt.dimension` **[object][135]?**
+    - dimension, see `resolve()` function above
+
+Returns **[Array][137]<[number][134]>** \[l, c, h, alpha]
+
+### convert.colorToRgb(value, opt)
+
+convert color to rgb
+
+#### Parameters
+
+- `value` **[string][133]** color value
+- `opt` **[object][135]?** options (optional, default `{}`)
+  - `opt.customProperty` **[object][135]?**
+    - custom properties, see `resolve()` function above
+  - `opt.dimension` **[object][135]?**
+    - dimension, see `resolve()` function above
+
+Returns **[Array][137]<[number][134]>** \[r, g, b, alpha]
+
+### convert.colorToXyz(value, opt)
+
+convert color to xyz
+
+#### Parameters
+
+- `value` **[string][133]** color value
+- `opt` **[object][135]?** options (optional, default `{}`)
+  - `opt.customProperty` **[object][135]?**
+    - custom properties, see `resolve()` function above
+  - `opt.dimension` **[object][135]?**
+    - dimension, see `resolve()` function above
+  - `opt.d50` **[boolean][136]?** xyz in d50 white point
+
+Returns **[Array][137]<[number][134]>** \[x, y, z, alpha]
+
+### convert.colorToXyzD50(value, opt)
+
+convert color to xyz-d50
+
+#### Parameters
+
+- `value` **[string][133]** color value
+- `opt` **[object][135]?** options (optional, default `{}`)
+  - `opt.customProperty` **[object][135]?**
+    - custom properties, see `resolve()` function above
+  - `opt.dimension` **[object][135]?**
+    - dimension, see `resolve()` function above
+
+Returns **[Array][137]<[number][134]>** \[x, y, z, alpha]
+
+### utils
+
+Contains utility functions.
+
+### utils.isColor(color)
+
+is valid color type
+
+#### Parameters
+
+- `color` **[string][133]** color value
+  - system colors are not supported
+
+Returns **[boolean][136]**
+
+## Acknowledgments
+
+The following resources have been of great help in the development of the CSS color.
+
+- [csstools/postcss-plugins](https://github.com/csstools/postcss-plugins)
+- [lru-cache](https://github.com/isaacs/node-lru-cache)
+
+---
+
+Copyright (c) 2024 [asamuzaK (Kazz)](https://github.com/asamuzaK/)
+
+[133]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[134]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
+[135]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+[136]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+[137]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+[138]: https://w3c.github.io/csswg-drafts/css-color-4/#color-conversion-code
+[139]: https://developer.mozilla.org/en-US/docs/Web/CSS/computed_value
+[140]: https://developer.mozilla.org/en-US/docs/Web/CSS/specified_value
+[141]: https://www.npmjs.com/package/@csstools/css-calc
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/index.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..189905df6b6a078d02bdcdf61b555bf093f13417
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/index.d.ts
@@ -0,0 +1,20 @@
+/*!
+ * CSS color - Resolve, parse, convert CSS color.
+ * @license MIT
+ * @copyright asamuzaK (Kazz)
+ * @see {@link https://github.com/asamuzaK/cssColor/blob/main/LICENSE}
+ */
+export { convert } from './js/convert.js';
+export { resolve } from './js/resolve.js';
+export declare const utils: {
+    cssCalc: (value: string, opt?: import('./js/typedef.js').Options) => string;
+    cssVar: (value: string, opt?: import('./js/typedef.js').Options) => string;
+    extractDashedIdent: (value: string) => string[];
+    isAbsoluteFontSize: (css: unknown) => boolean;
+    isAbsoluteSizeOrLength: (value: number | string, unit: string | undefined) => boolean;
+    isColor: (value: unknown, opt?: import('./js/typedef.js').Options) => boolean;
+    isGradient: (value: string, opt?: import('./js/typedef.js').Options) => boolean;
+    resolveGradient: (value: string, opt?: import('./js/typedef.js').Options) => string;
+    resolveLengthInPixels: (value: number | string, unit: string | undefined, opt?: import('./js/typedef.js').Options) => number;
+    splitValue: (value: string, opt?: import('./js/typedef.js').Options) => string[];
+};
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/index.js b/node_modules/@asamuzakjp/css-color/dist/esm/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..6abd9606ef9da1e108494d5c980dbbc86f678e8b
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/index.js
@@ -0,0 +1,29 @@
+import { resolve } from "./js/resolve.js";
+import { extractDashedIdent, isAbsoluteFontSize, isAbsoluteSizeOrLength, isColor, resolveLengthInPixels, splitValue } from "./js/util.js";
+import { cssVar } from "./js/css-var.js";
+import { cssCalc } from "./js/css-calc.js";
+import { isGradient, resolveGradient } from "./js/css-gradient.js";
+import { convert } from "./js/convert.js";
+//#region src/index.ts
+/*!
+* CSS color - Resolve, parse, convert CSS color.
+* @license MIT
+* @copyright asamuzaK (Kazz)
+* @see {@link https://github.com/asamuzaK/cssColor/blob/main/LICENSE}
+*/
+var utils = {
+	cssCalc,
+	cssVar,
+	extractDashedIdent,
+	isAbsoluteFontSize,
+	isAbsoluteSizeOrLength,
+	isColor,
+	isGradient,
+	resolveGradient,
+	resolveLengthInPixels,
+	splitValue
+};
+//#endregion
+export { convert, resolve, utils };
+
+//# sourceMappingURL=index.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/index.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/index.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..bc1aa81f1ef62b8af7122ec64947fc6a6425361d
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/index.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/index.ts"],"sourcesContent":["/*!\n * CSS color - Resolve, parse, convert CSS color.\n * @license MIT\n * @copyright asamuzaK (Kazz)\n * @see {@link https://github.com/asamuzaK/cssColor/blob/main/LICENSE}\n */\n\nimport { cssCalc } from './js/css-calc';\nimport { isGradient, resolveGradient } from './js/css-gradient';\nimport { cssVar } from './js/css-var';\nimport {\n  extractDashedIdent,\n  isAbsoluteFontSize,\n  isAbsoluteSizeOrLength,\n  isColor,\n  resolveLengthInPixels,\n  splitValue\n} from './js/util';\n\nexport { convert } from './js/convert';\nexport { resolve } from './js/resolve';\n/* utils */\nexport const utils = {\n  cssCalc,\n  cssVar,\n  extractDashedIdent,\n  isAbsoluteFontSize,\n  isAbsoluteSizeOrLength,\n  isColor,\n  isGradient,\n  resolveGradient,\n  resolveLengthInPixels,\n  splitValue\n};\n"],"mappings":";;;;;;;;;;;;;AAsBA,IAAa,QAAQ;CACnB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/cache.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/cache.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ae09b0166ca5ba20e985a67c775d304f0bda1670
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/cache.d.ts
@@ -0,0 +1,38 @@
+import { GenerationalCache } from '@asamuzakjp/generational-cache';
+import { Options } from './typedef.js';
+/**
+ * CacheItem
+ */
+export declare class CacheItem {
+    #private;
+    constructor(item: unknown, isNull?: boolean);
+    get item(): unknown;
+    get isNull(): boolean;
+}
+/**
+ * NullObject
+ */
+export declare class NullObject extends CacheItem {
+    constructor();
+}
+export declare const genCache: GenerationalCache<string, CacheItem>;
+/**
+ * set cache
+ * @param key - cache key
+ * @param value - value to cache
+ * @returns void
+ */
+export declare const setCache: (key: string, value: unknown) => void;
+/**
+ * get cache
+ * @param key - cache key
+ * @returns cached item or false otherwise
+ */
+export declare const getCache: (key: string) => CacheItem | false;
+/**
+ * create cache key
+ * @param keyData - key data
+ * @param [opt] - options
+ * @returns cache key
+ */
+export declare const createCacheKey: (keyData: Record<string, string>, opt?: Options) => string;
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/cache.js b/node_modules/@asamuzakjp/css-color/dist/esm/js/cache.js
new file mode 100644
index 0000000000000000000000000000000000000000..28a2a911d2da1a2b790a946168cc46949bcad72a
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/cache.js
@@ -0,0 +1,90 @@
+import { GenerationalCache } from "@asamuzakjp/generational-cache";
+//#region src/js/cache.ts
+/**
+* cache
+*/
+var CACHE_SIZE = 2048;
+/**
+* CacheItem
+*/
+var CacheItem = class {
+	#isNull;
+	#item;
+	constructor(item, isNull = false) {
+		this.#item = item;
+		this.#isNull = !!isNull;
+	}
+	get item() {
+		return this.#item;
+	}
+	get isNull() {
+		return this.#isNull;
+	}
+};
+/**
+* NullObject
+*/
+var NullObject = class extends CacheItem {
+	constructor() {
+		super(Symbol("null"), true);
+	}
+};
+var genCache = new GenerationalCache(CACHE_SIZE);
+/**
+* shared null object
+*/
+var sharedNullObject = new NullObject();
+/**
+* set cache
+* @param key - cache key
+* @param value - value to cache
+* @returns void
+*/
+var setCache = (key, value) => {
+	if (!key) return;
+	if (value === null) genCache.set(key, sharedNullObject);
+	else if (value instanceof CacheItem) genCache.set(key, value);
+	else genCache.set(key, new CacheItem(value));
+};
+/**
+* get cache
+* @param key - cache key
+* @returns cached item or false otherwise
+*/
+var getCache = (key) => {
+	if (!key) return false;
+	const item = genCache.get(key);
+	if (item !== void 0) return item;
+	return false;
+};
+/**
+* helper function to sort object keys alphabetically
+* @param obj - Object
+* @returns stringified JSON
+*/
+var stringifySorted = (obj) => {
+	const keys = Object.keys(obj);
+	if (keys.length === 0) return "";
+	keys.sort();
+	let result = "";
+	for (const key of keys) result += `${key}:${JSON.stringify(obj[key])};`;
+	return result;
+};
+/**
+* create cache key
+* @param keyData - key data
+* @param [opt] - options
+* @returns cache key
+*/
+var createCacheKey = (keyData, opt = {}) => {
+	if (!keyData || opt.customProperty && typeof opt.customProperty.callback === "function" || opt.dimension && typeof opt.dimension.callback === "function") return "";
+	const namespace = keyData.namespace || "";
+	const name = keyData.name || "";
+	const value = keyData.value || "";
+	if (!namespace && !name && !value) return "";
+	return `${`${namespace}:${name}:${value}`}::${`${opt.format || ""}|${opt.colorSpace || ""}|${opt.colorScheme || ""}|${opt.currentColor || ""}|${opt.d50 ? "1" : "0"}|${opt.nullable ? "1" : "0"}|${opt.preserveComment ? "1" : "0"}|${opt.delimiter || ""}`}::${opt.customProperty ? stringifySorted(opt.customProperty) : ""}::${opt.dimension ? stringifySorted(opt.dimension) : ""}`;
+};
+//#endregion
+export { CacheItem, NullObject, createCacheKey, getCache, setCache };
+
+//# sourceMappingURL=cache.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/cache.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/js/cache.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..816021e0d210b5a9b519a69ea41005bf6255bb78
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/cache.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","names":["#item","#isNull"],"sources":["../../../src/js/cache.ts"],"sourcesContent":["/**\n * cache\n */\n\nimport { GenerationalCache } from '@asamuzakjp/generational-cache';\nimport { Options } from './typedef';\n\n/* constants */\nconst CACHE_SIZE = 2048;\n\n/**\n * CacheItem\n */\nexport class CacheItem {\n  /* private */\n  #isNull: boolean;\n  #item: unknown;\n\n  constructor(item: unknown, isNull: boolean = false) {\n    this.#item = item;\n    this.#isNull = !!isNull;\n  }\n\n  get item() {\n    return this.#item;\n  }\n\n  get isNull() {\n    return this.#isNull;\n  }\n}\n\n/**\n * NullObject\n */\nexport class NullObject extends CacheItem {\n  constructor() {\n    super(Symbol('null'), true);\n  }\n}\n\n/*\n * generational cache instance\n */\nexport const genCache = new GenerationalCache<string, CacheItem>(CACHE_SIZE);\n\n/**\n * shared null object\n */\nconst sharedNullObject = new NullObject();\n\n/**\n * set cache\n * @param key - cache key\n * @param value - value to cache\n * @returns void\n */\nexport const setCache = (key: string, value: unknown): void => {\n  if (!key) {\n    return;\n  }\n  if (value === null) {\n    genCache.set(key, sharedNullObject);\n  } else if (value instanceof CacheItem) {\n    genCache.set(key, value);\n  } else {\n    genCache.set(key, new CacheItem(value));\n  }\n};\n\n/**\n * get cache\n * @param key - cache key\n * @returns cached item or false otherwise\n */\nexport const getCache = (key: string): CacheItem | false => {\n  if (!key) {\n    return false;\n  }\n  const item = genCache.get(key);\n  if (item !== undefined) {\n    return item as CacheItem;\n  }\n  return false;\n};\n\n/**\n * helper function to sort object keys alphabetically\n * @param obj - Object\n * @returns stringified JSON\n */\nconst stringifySorted = (obj: Record<string, unknown>): string => {\n  const keys = Object.keys(obj);\n  if (keys.length === 0) {\n    return '';\n  }\n  keys.sort();\n  let result = '';\n  for (const key of keys) {\n    result += `${key}:${JSON.stringify(obj[key])};`;\n  }\n  return result;\n};\n\n/**\n * create cache key\n * @param keyData - key data\n * @param [opt] - options\n * @returns cache key\n */\nexport const createCacheKey = (\n  keyData: Record<string, string>,\n  opt: Options = {}\n): string => {\n  if (\n    !keyData ||\n    (opt.customProperty && typeof opt.customProperty.callback === 'function') ||\n    (opt.dimension && typeof opt.dimension.callback === 'function')\n  ) {\n    return '';\n  }\n  const namespace = keyData.namespace || '';\n  const name = keyData.name || '';\n  const value = keyData.value || '';\n  if (!namespace && !name && !value) {\n    return '';\n  }\n  const baseKey = `${namespace}:${name}:${value}`;\n  const optStr = `${opt.format || ''}|${opt.colorSpace || ''}|${opt.colorScheme || ''}|${opt.currentColor || ''}|${opt.d50 ? '1' : '0'}|${opt.nullable ? '1' : '0'}|${opt.preserveComment ? '1' : '0'}|${opt.delimiter || ''}`;\n  const customPropStr = opt.customProperty\n    ? stringifySorted(opt.customProperty as Record<string, unknown>)\n    : '';\n  const dimStr = opt.dimension\n    ? stringifySorted(opt.dimension as Record<string, unknown>)\n    : '';\n  return `${baseKey}::${optStr}::${customPropStr}::${dimStr}`;\n};\n"],"mappings":";;;;;AAQA,IAAM,aAAa;;;;AAKnB,IAAa,YAAb,MAAuB;CAErB;CACA;CAEA,YAAY,MAAe,SAAkB,OAAO;AAClD,QAAA,OAAa;AACb,QAAA,SAAe,CAAC,CAAC;;CAGnB,IAAI,OAAO;AACT,SAAO,MAAA;;CAGT,IAAI,SAAS;AACX,SAAO,MAAA;;;;;;AAOX,IAAa,aAAb,cAAgC,UAAU;CACxC,cAAc;AACZ,QAAM,OAAO,OAAO,EAAE,KAAK;;;AAO/B,IAAa,WAAW,IAAI,kBAAqC,WAAW;;;;AAK5E,IAAM,mBAAmB,IAAI,YAAY;;;;;;;AAQzC,IAAa,YAAY,KAAa,UAAyB;AAC7D,KAAI,CAAC,IACH;AAEF,KAAI,UAAU,KACZ,UAAS,IAAI,KAAK,iBAAiB;UAC1B,iBAAiB,UAC1B,UAAS,IAAI,KAAK,MAAM;KAExB,UAAS,IAAI,KAAK,IAAI,UAAU,MAAM,CAAC;;;;;;;AAS3C,IAAa,YAAY,QAAmC;AAC1D,KAAI,CAAC,IACH,QAAO;CAET,MAAM,OAAO,SAAS,IAAI,IAAI;AAC9B,KAAI,SAAS,KAAA,EACX,QAAO;AAET,QAAO;;;;;;;AAQT,IAAM,mBAAmB,QAAyC;CAChE,MAAM,OAAO,OAAO,KAAK,IAAI;AAC7B,KAAI,KAAK,WAAW,EAClB,QAAO;AAET,MAAK,MAAM;CACX,IAAI,SAAS;AACb,MAAK,MAAM,OAAO,KAChB,WAAU,GAAG,IAAI,GAAG,KAAK,UAAU,IAAI,KAAK,CAAC;AAE/C,QAAO;;;;;;;;AAST,IAAa,kBACX,SACA,MAAe,EAAE,KACN;AACX,KACE,CAAC,WACA,IAAI,kBAAkB,OAAO,IAAI,eAAe,aAAa,cAC7D,IAAI,aAAa,OAAO,IAAI,UAAU,aAAa,WAEpD,QAAO;CAET,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,QAAQ,QAAQ,SAAS;AAC/B,KAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAC1B,QAAO;AAUT,QAAO,GARS,GAAG,UAAU,GAAG,KAAK,GAAG,QAQtB,IAPH,GAAG,IAAI,UAAU,GAAG,GAAG,IAAI,cAAc,GAAG,GAAG,IAAI,eAAe,GAAG,GAAG,IAAI,gBAAgB,GAAG,GAAG,IAAI,MAAM,MAAM,IAAI,GAAG,IAAI,WAAW,MAAM,IAAI,GAAG,IAAI,kBAAkB,MAAM,IAAI,GAAG,IAAI,aAAa,KAO3L,IANP,IAAI,iBACtB,gBAAgB,IAAI,eAA0C,GAC9D,GAI2C,IAHhC,IAAI,YACf,gBAAgB,IAAI,UAAqC,GACzD"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/color.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/color.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9a1a0e22f2f46b6c5a8be725fd460ea870513e46
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/color.d.ts
@@ -0,0 +1,537 @@
+import { NullObject } from './cache.js';
+import { ColorChannels, Options, SpecifiedColorChannels } from './typedef.js';
+/**
+ * @type TriColorChannels - color channels without alpha
+ */
+type TriColorChannels = [x: number, y: number, z: number];
+/**
+ * @type ColorMatrix - color matrix
+ */
+type ColorMatrix = [
+    r1: TriColorChannels,
+    r2: TriColorChannels,
+    r3: TriColorChannels
+];
+/**
+ * named colors
+ */
+export declare const NAMED_COLORS: {
+    readonly aliceblue: [240, 248, 255];
+    readonly antiquewhite: [250, 235, 215];
+    readonly aqua: [0, 255, 255];
+    readonly aquamarine: [127, 255, 212];
+    readonly azure: [240, 255, 255];
+    readonly beige: [245, 245, 220];
+    readonly bisque: [255, 228, 196];
+    readonly black: [0, 0, 0];
+    readonly blanchedalmond: [255, 235, 205];
+    readonly blue: [0, 0, 255];
+    readonly blueviolet: [138, 43, 226];
+    readonly brown: [165, 42, 42];
+    readonly burlywood: [222, 184, 135];
+    readonly cadetblue: [95, 158, 160];
+    readonly chartreuse: [127, 255, 0];
+    readonly chocolate: [210, 105, 30];
+    readonly coral: [255, 127, 80];
+    readonly cornflowerblue: [100, 149, 237];
+    readonly cornsilk: [255, 248, 220];
+    readonly crimson: [220, 20, 60];
+    readonly cyan: [0, 255, 255];
+    readonly darkblue: [0, 0, 139];
+    readonly darkcyan: [0, 139, 139];
+    readonly darkgoldenrod: [184, 134, 11];
+    readonly darkgray: [169, 169, 169];
+    readonly darkgreen: [0, 100, 0];
+    readonly darkgrey: [169, 169, 169];
+    readonly darkkhaki: [189, 183, 107];
+    readonly darkmagenta: [139, 0, 139];
+    readonly darkolivegreen: [85, 107, 47];
+    readonly darkorange: [255, 140, 0];
+    readonly darkorchid: [153, 50, 204];
+    readonly darkred: [139, 0, 0];
+    readonly darksalmon: [233, 150, 122];
+    readonly darkseagreen: [143, 188, 143];
+    readonly darkslateblue: [72, 61, 139];
+    readonly darkslategray: [47, 79, 79];
+    readonly darkslategrey: [47, 79, 79];
+    readonly darkturquoise: [0, 206, 209];
+    readonly darkviolet: [148, 0, 211];
+    readonly deeppink: [255, 20, 147];
+    readonly deepskyblue: [0, 191, 255];
+    readonly dimgray: [105, 105, 105];
+    readonly dimgrey: [105, 105, 105];
+    readonly dodgerblue: [30, 144, 255];
+    readonly firebrick: [178, 34, 34];
+    readonly floralwhite: [255, 250, 240];
+    readonly forestgreen: [34, 139, 34];
+    readonly fuchsia: [255, 0, 255];
+    readonly gainsboro: [220, 220, 220];
+    readonly ghostwhite: [248, 248, 255];
+    readonly gold: [255, 215, 0];
+    readonly goldenrod: [218, 165, 32];
+    readonly gray: [128, 128, 128];
+    readonly green: [0, 128, 0];
+    readonly greenyellow: [173, 255, 47];
+    readonly grey: [128, 128, 128];
+    readonly honeydew: [240, 255, 240];
+    readonly hotpink: [255, 105, 180];
+    readonly indianred: [205, 92, 92];
+    readonly indigo: [75, 0, 130];
+    readonly ivory: [255, 255, 240];
+    readonly khaki: [240, 230, 140];
+    readonly lavender: [230, 230, 250];
+    readonly lavenderblush: [255, 240, 245];
+    readonly lawngreen: [124, 252, 0];
+    readonly lemonchiffon: [255, 250, 205];
+    readonly lightblue: [173, 216, 230];
+    readonly lightcoral: [240, 128, 128];
+    readonly lightcyan: [224, 255, 255];
+    readonly lightgoldenrodyellow: [250, 250, 210];
+    readonly lightgray: [211, 211, 211];
+    readonly lightgreen: [144, 238, 144];
+    readonly lightgrey: [211, 211, 211];
+    readonly lightpink: [255, 182, 193];
+    readonly lightsalmon: [255, 160, 122];
+    readonly lightseagreen: [32, 178, 170];
+    readonly lightskyblue: [135, 206, 250];
+    readonly lightslategray: [119, 136, 153];
+    readonly lightslategrey: [119, 136, 153];
+    readonly lightsteelblue: [176, 196, 222];
+    readonly lightyellow: [255, 255, 224];
+    readonly lime: [0, 255, 0];
+    readonly limegreen: [50, 205, 50];
+    readonly linen: [250, 240, 230];
+    readonly magenta: [255, 0, 255];
+    readonly maroon: [128, 0, 0];
+    readonly mediumaquamarine: [102, 205, 170];
+    readonly mediumblue: [0, 0, 205];
+    readonly mediumorchid: [186, 85, 211];
+    readonly mediumpurple: [147, 112, 219];
+    readonly mediumseagreen: [60, 179, 113];
+    readonly mediumslateblue: [123, 104, 238];
+    readonly mediumspringgreen: [0, 250, 154];
+    readonly mediumturquoise: [72, 209, 204];
+    readonly mediumvioletred: [199, 21, 133];
+    readonly midnightblue: [25, 25, 112];
+    readonly mintcream: [245, 255, 250];
+    readonly mistyrose: [255, 228, 225];
+    readonly moccasin: [255, 228, 181];
+    readonly navajowhite: [255, 222, 173];
+    readonly navy: [0, 0, 128];
+    readonly oldlace: [253, 245, 230];
+    readonly olive: [128, 128, 0];
+    readonly olivedrab: [107, 142, 35];
+    readonly orange: [255, 165, 0];
+    readonly orangered: [255, 69, 0];
+    readonly orchid: [218, 112, 214];
+    readonly palegoldenrod: [238, 232, 170];
+    readonly palegreen: [152, 251, 152];
+    readonly paleturquoise: [175, 238, 238];
+    readonly palevioletred: [219, 112, 147];
+    readonly papayawhip: [255, 239, 213];
+    readonly peachpuff: [255, 218, 185];
+    readonly peru: [205, 133, 63];
+    readonly pink: [255, 192, 203];
+    readonly plum: [221, 160, 221];
+    readonly powderblue: [176, 224, 230];
+    readonly purple: [128, 0, 128];
+    readonly rebeccapurple: [102, 51, 153];
+    readonly red: [255, 0, 0];
+    readonly rosybrown: [188, 143, 143];
+    readonly royalblue: [65, 105, 225];
+    readonly saddlebrown: [139, 69, 19];
+    readonly salmon: [250, 128, 114];
+    readonly sandybrown: [244, 164, 96];
+    readonly seagreen: [46, 139, 87];
+    readonly seashell: [255, 245, 238];
+    readonly sienna: [160, 82, 45];
+    readonly silver: [192, 192, 192];
+    readonly skyblue: [135, 206, 235];
+    readonly slateblue: [106, 90, 205];
+    readonly slategray: [112, 128, 144];
+    readonly slategrey: [112, 128, 144];
+    readonly snow: [255, 250, 250];
+    readonly springgreen: [0, 255, 127];
+    readonly steelblue: [70, 130, 180];
+    readonly tan: [210, 180, 140];
+    readonly teal: [0, 128, 128];
+    readonly thistle: [216, 191, 216];
+    readonly tomato: [255, 99, 71];
+    readonly turquoise: [64, 224, 208];
+    readonly violet: [238, 130, 238];
+    readonly wheat: [245, 222, 179];
+    readonly white: [255, 255, 255];
+    readonly whitesmoke: [245, 245, 245];
+    readonly yellow: [255, 255, 0];
+    readonly yellowgreen: [154, 205, 50];
+};
+/**
+ * cache invalid color value
+ * @param key - cache key
+ * @param nullable - is nullable
+ * @returns cached value
+ */
+export declare const cacheInvalidColorValue: (cacheKey: string, format: string, nullable?: boolean) => SpecifiedColorChannels | string | NullObject;
+/**
+ * resolve invalid color value
+ * @param format - output format
+ * @param nullable - is nullable
+ * @returns resolved value
+ */
+export declare const resolveInvalidColorValue: (format: string, nullable?: boolean) => SpecifiedColorChannels | string | NullObject;
+/**
+ * validate color components
+ * @param arr - color components
+ * @param [opt] - options
+ * @param [opt.alpha] - alpha channel
+ * @param [opt.minLength] - min length
+ * @param [opt.maxLength] - max length
+ * @param [opt.minRange] - min range
+ * @param [opt.maxRange] - max range
+ * @param [opt.validateRange] - validate range
+ * @returns result - validated color components
+ */
+export declare const validateColorComponents: (arr: ColorChannels | TriColorChannels, opt?: {
+    alpha?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    minRange?: number;
+    maxRange?: number;
+    validateRange?: boolean;
+}) => ColorChannels | TriColorChannels;
+/**
+ * transform matrix
+ * @param mtx - 3 * 3 matrix
+ * @param vct - vector
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [p1, p2, p3]
+ */
+export declare const transformMatrix: (mtx: ColorMatrix, vct: TriColorChannels, skip?: boolean) => TriColorChannels;
+/**
+ * normalize color components
+ * @param colorA - color components [v1, v2, v3, v4]
+ * @param colorB - color components [v1, v2, v3, v4]
+ * @param [skip] - skip validate
+ * @returns result - [colorA, colorB]
+ */
+export declare const normalizeColorComponents: (colorA: [number | string, number | string, number | string, number | string], colorB: [number | string, number | string, number | string, number | string], skip?: boolean) => [ColorChannels, ColorChannels];
+/**
+ * number to hex string
+ * @param value - numeric value
+ * @returns hex string
+ */
+export declare const numberToHexString: (value: number) => string;
+/**
+ * angle to deg
+ * @param angle
+ * @returns deg: 0..360
+ */
+export declare const angleToDeg: (angle: string) => number;
+/**
+ * parse alpha
+ * @param [alpha] - alpha value
+ * @returns alpha: 0..1
+ */
+export declare const parseAlpha: (alpha?: string) => number;
+/**
+ * parse hex alpha
+ * @param value - alpha value in hex string
+ * @returns alpha: 0..1
+ */
+export declare const parseHexAlpha: (value: string) => number;
+/**
+ * transform rgb to linear rgb
+ * @param rgb - [r, g, b] r|g|b: 0..255
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [r, g, b] r|g|b: 0..1
+ */
+export declare const transformRgbToLinearRgb: (rgb: TriColorChannels, skip?: boolean) => TriColorChannels;
+/**
+ * transform rgb to xyz
+ * @param rgb - [r, g, b] r|g|b: 0..255
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [x, y, z]
+ */
+export declare const transformRgbToXyz: (rgb: TriColorChannels, skip?: boolean) => TriColorChannels;
+/**
+ * transform rgb to xyz-d50
+ * @param rgb - [r, g, b] r|g|b: 0..255 alpha: 0..1
+ * @returns TriColorChannels - [x, y, z]
+ */
+export declare const transformRgbToXyzD50: (rgb: TriColorChannels) => TriColorChannels;
+/**
+ * transform linear rgb to rgb
+ * @param rgb - [r, g, b] r|g|b: 0..1
+ * @param [round] - round result
+ * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
+ */
+export declare const transformLinearRgbToRgb: (rgb: TriColorChannels, round?: boolean) => TriColorChannels;
+/**
+ * transform xyz to rgb
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
+ */
+export declare const transformXyzToRgb: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
+/**
+ * transform xyz to xyz-d50
+ * @param xyz - [x, y, z]
+ * @returns TriColorChannels - [x, y, z]
+ */
+export declare const transformXyzToXyzD50: (xyz: TriColorChannels) => TriColorChannels;
+/**
+ * transform xyz to hsl
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [h, s, l]
+ */
+export declare const transformXyzToHsl: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
+/**
+ * transform xyz to hwb
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [h, w, b]
+ */
+export declare const transformXyzToHwb: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
+/**
+ * transform xyz to oklab
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [l, a, b]
+ */
+export declare const transformXyzToOklab: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
+/**
+ * transform xyz to oklch
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [l, c, h]
+ */
+export declare const transformXyzToOklch: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
+/**
+ * transform xyz D50 to rgb
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
+ */
+export declare const transformXyzD50ToRgb: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
+/**
+ * transform xyz-d50 to lab
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [l, a, b]
+ */
+export declare const transformXyzD50ToLab: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
+/**
+ * transform xyz-d50 to lch
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [l, c, h]
+ */
+export declare const transformXyzD50ToLch: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
+/**
+ * convert rgb to hex color
+ * @param rgb - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
+ * @returns hex color
+ */
+export declare const convertRgbToHex: (rgb: ColorChannels) => string;
+/**
+ * convert linear rgb to hex color
+ * @param rgb - [r, g, b, alpha] r|g|b|alpha: 0..1
+ * @param [skip] - skip validate
+ * @returns hex color
+ */
+export declare const convertLinearRgbToHex: (rgb: ColorChannels, skip?: boolean) => string;
+/**
+ * convert xyz to hex color
+ * @param xyz - [x, y, z, alpha]
+ * @returns hex color
+ */
+export declare const convertXyzToHex: (xyz: ColorChannels) => string;
+/**
+ * convert xyz D50 to hex color
+ * @param xyz - [x, y, z, alpha]
+ * @returns hex color
+ */
+export declare const convertXyzD50ToHex: (xyz: ColorChannels) => string;
+/**
+ * convert hex color to rgb
+ * @param value - hex color value
+ * @returns ColorChannels - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
+ */
+export declare const convertHexToRgb: (value: string) => ColorChannels;
+/**
+ * convert hex color to linear rgb
+ * @param value - hex color value
+ * @returns ColorChannels - [r, g, b, alpha] r|g|b|alpha: 0..1
+ */
+export declare const convertHexToLinearRgb: (value: string) => ColorChannels;
+/**
+ * convert hex color to xyz
+ * @param value - hex color value
+ * @returns ColorChannels - [x, y, z, alpha]
+ */
+export declare const convertHexToXyz: (value: string) => ColorChannels;
+/**
+ * parse rgb()
+ * @param value - rgb color value
+ * @param [opt] - options
+ * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
+ */
+export declare const parseRgb: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+/**
+ * parse hsl()
+ * @param value - hsl color value
+ * @param [opt] - options
+ * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
+ */
+export declare const parseHsl: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+/**
+ * parse hwb()
+ * @param value - hwb color value
+ * @param [opt] - options
+ * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
+ */
+export declare const parseHwb: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+/**
+ * parse lab()
+ * @param value - lab color value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - [xyz-d50, x, y, z, alpha], ['lab', l, a, b, alpha], '(empty)', NullObject
+ */
+export declare const parseLab: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+/**
+ * parse lch()
+ * @param value - lch color value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - ['xyz-d50', x, y, z, alpha], ['lch', l, c, h, alpha]
+ *   - '(empty)', NullObject
+ */
+export declare const parseLch: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+/**
+ * parse oklab()
+ * @param value - oklab color value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - ['xyz-d65', x, y, z, alpha], ['oklab', l, a, b, alpha]
+ *   - '(empty)', NullObject
+ */
+export declare const parseOklab: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+/**
+ * parse oklch()
+ * @param value - oklch color value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - ['xyz-d65', x, y, z, alpha], ['oklch', l, c, h, alpha]
+ *   - '(empty)', NullObject
+ */
+export declare const parseOklch: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+/**
+ * parse color()
+ * @param value - color function value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - ['xyz-(d50|d65)', x, y, z, alpha], [cs, r, g, b, alpha]
+ *   - '(empty)', NullObject
+ */
+export declare const parseColorFunc: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+/**
+ * parse color value
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - ['xyz-(d50|d65)', x, y, z, alpha], ['rgb', r, g, b, alpha]
+ *   - value, '(empty)', NullObject
+ */
+export declare const parseColorValue: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+/**
+ * resolve color value
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns resolved color
+ *   - [cs, v1, v2, v3, alpha], value, '(empty)', NullObject
+ */
+export declare const resolveColorValue: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+/**
+ * resolve color()
+ * @param value - color function value
+ * @param [opt] - options
+ * @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)', NullObject
+ */
+export declare const resolveColorFunc: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+/**
+ * convert color value to linear rgb
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [r, g, b, alpha] r|g|b|alpha: 0..1
+ */
+export declare const convertColorToLinearRgb: (value: string, opt?: {
+    colorSpace?: string;
+    format?: string;
+}) => ColorChannels | NullObject;
+/**
+ * convert color value to rgb
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject
+ *   - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
+ */
+export declare const convertColorToRgb: (value: string, opt?: Options) => ColorChannels | NullObject;
+/**
+ * convert color value to xyz
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [x, y, z, alpha]
+ */
+export declare const convertColorToXyz: (value: string, opt?: Options) => ColorChannels | NullObject;
+/**
+ * convert color value to hsl
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [h, s, l, alpha], hue may be powerless
+ */
+export declare const convertColorToHsl: (value: string, opt?: Options) => ColorChannels | [number | string, number, number, number] | NullObject;
+/**
+ * convert color value to hwb
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [h, w, b, alpha], hue may be powerless
+ */
+export declare const convertColorToHwb: (value: string, opt?: Options) => ColorChannels | [number | string, number, number, number] | NullObject;
+/**
+ * convert color value to lab
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [l, a, b, alpha]
+ */
+export declare const convertColorToLab: (value: string, opt?: Options) => ColorChannels | NullObject;
+/**
+ * convert color value to lch
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless
+ */
+export declare const convertColorToLch: (value: string, opt?: Options) => ColorChannels | [number, number, number | string, number] | NullObject;
+/**
+ * convert color value to oklab
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [l, a, b, alpha]
+ */
+export declare const convertColorToOklab: (value: string, opt?: Options) => ColorChannels | NullObject;
+/**
+ * convert color value to oklch
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless
+ */
+export declare const convertColorToOklch: (value: string, opt?: Options) => ColorChannels | [number, number, number | string, number] | NullObject;
+/**
+ * resolve color-mix()
+ * @param value - color-mix color value
+ * @param [opt] - options
+ * @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)'
+ */
+export declare const resolveColorMix: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
+export {};
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/color.js b/node_modules/@asamuzakjp/css-color/dist/esm/js/color.js
new file mode 100644
index 0000000000000000000000000000000000000000..14e882da434b961c8d72c319d5c5db2a026b8bb7
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/color.js
@@ -0,0 +1,3534 @@
+import { CacheItem, NullObject, createCacheKey, getCache, setCache } from "./cache.js";
+import { isString } from "./common.js";
+import { ANGLE, CS_HUE_CAPT, CS_MIX, CS_RGB, CS_XYZ, FN_MIX, NONE, NUM, PCT, SYN_COLOR_TYPE, SYN_FN_COLOR, SYN_HSL, SYN_HSL_LV3, SYN_LCH, SYN_MIX, SYN_MIX_CAPT, SYN_MIX_PART, SYN_MOD, SYN_RGB_LV3, VAL_COMP, VAL_MIX, VAL_SPEC } from "./constant.js";
+import { resolveColor } from "./resolve.js";
+import { interpolateHue, roundToPrecision, splitValue } from "./util.js";
+//#region src/js/color.ts
+/**
+* color
+*
+* Ref: CSS Color Module Level 4
+*      Sample code for Color Conversions
+*      https://w3c.github.io/csswg-drafts/css-color-4/#color-conversion-code
+*/
+var NAMESPACE = "color";
+var PPTH = .001;
+var HALF = .5;
+var DUO = 2;
+var TRIA = 3;
+var QUAD = 4;
+var OCT = 8;
+var DEC = 10;
+var DOZ = 12;
+var HEX = 16;
+var SEXA = 60;
+var DEG_HALF = 180;
+var DEG = 360;
+var MAX_PCT = 100;
+var MAX_RGB = 255;
+var POW_SQR = 2;
+var POW_CUBE = 3;
+var POW_LINEAR = 2.4;
+var LINEAR_COEF = 12.92;
+var LINEAR_OFFSET = .055;
+var LAB_L = 116;
+var LAB_A = 500;
+var LAB_B = 200;
+var LAB_EPSILON = 216 / 24389;
+var LAB_KAPPA = 24389 / 27;
+var D50 = [
+	.3457 / .3585,
+	1,
+	.2958 / .3585
+];
+var MATRIX_D50_TO_D65 = [
+	[
+		.955473421488075,
+		-.02309845494876471,
+		.06325924320057072
+	],
+	[
+		-.0283697093338637,
+		1.0099953980813041,
+		.021041441191917323
+	],
+	[
+		.012314014864481998,
+		-.020507649298898964,
+		1.330365926242124
+	]
+];
+var MATRIX_D65_TO_D50 = [
+	[
+		1.0479297925449969,
+		.022946870601609652,
+		-.05019226628920524
+	],
+	[
+		.02962780877005599,
+		.9904344267538799,
+		-.017073799063418826
+	],
+	[
+		-.009243040646204504,
+		.015055191490298152,
+		.7518742814281371
+	]
+];
+var MATRIX_L_RGB_TO_XYZ = [
+	[
+		506752 / 1228815,
+		87881 / 245763,
+		12673 / 70218
+	],
+	[
+		87098 / 409605,
+		175762 / 245763,
+		12673 / 175545
+	],
+	[
+		7918 / 409605,
+		87881 / 737289,
+		1001167 / 1053270
+	]
+];
+var MATRIX_XYZ_TO_L_RGB = [
+	[
+		12831 / 3959,
+		-329 / 214,
+		-1974 / 3959
+	],
+	[
+		-851781 / 878810,
+		1648619 / 878810,
+		36519 / 878810
+	],
+	[
+		705 / 12673,
+		-2585 / 12673,
+		705 / 667
+	]
+];
+var MATRIX_XYZ_TO_LMS = [
+	[
+		.819022437996703,
+		.3619062600528904,
+		-.1288737815209879
+	],
+	[
+		.0329836539323885,
+		.9292868615863434,
+		.0361446663506424
+	],
+	[
+		.0481771893596242,
+		.2642395317527308,
+		.6335478284694309
+	]
+];
+var MATRIX_LMS_TO_XYZ = [
+	[
+		1.2268798758459243,
+		-.5578149944602171,
+		.2813910456659647
+	],
+	[
+		-.0405757452148008,
+		1.112286803280317,
+		-.0717110580655164
+	],
+	[
+		-.0763729366746601,
+		-.4214933324022432,
+		1.5869240198367816
+	]
+];
+var MATRIX_OKLAB_TO_LMS = [
+	[
+		1,
+		.3963377773761749,
+		.2158037573099136
+	],
+	[
+		1,
+		-.1055613458156586,
+		-.0638541728258133
+	],
+	[
+		1,
+		-.0894841775298119,
+		-1.2914855480194092
+	]
+];
+var MATRIX_LMS_TO_OKLAB = [
+	[
+		.210454268309314,
+		.7936177747023054,
+		-.0040720430116193
+	],
+	[
+		1.9779985324311684,
+		-2.42859224204858,
+		.450593709617411
+	],
+	[
+		.0259040424655478,
+		.7827717124575296,
+		-.8086757549230774
+	]
+];
+var MATRIX_P3_TO_XYZ = [
+	[
+		608311 / 1250200,
+		189793 / 714400,
+		198249 / 1000160
+	],
+	[
+		35783 / 156275,
+		247089 / 357200,
+		198249 / 2500400
+	],
+	[
+		0 / 1,
+		32229 / 714400,
+		5220557 / 5000800
+	]
+];
+var MATRIX_REC2020_TO_XYZ = [
+	[
+		63426534 / 99577255,
+		20160776 / 139408157,
+		47086771 / 278816314
+	],
+	[
+		26158966 / 99577255,
+		472592308 / 697040785,
+		8267143 / 139408157
+	],
+	[
+		0 / 1,
+		19567812 / 697040785,
+		295819943 / 278816314
+	]
+];
+var MATRIX_A98_TO_XYZ = [
+	[
+		573536 / 994567,
+		263643 / 1420810,
+		187206 / 994567
+	],
+	[
+		591459 / 1989134,
+		6239551 / 9945670,
+		374412 / 4972835
+	],
+	[
+		53769 / 1989134,
+		351524 / 4972835,
+		4929758 / 4972835
+	]
+];
+var MATRIX_PROPHOTO_TO_XYZ_D50 = [
+	[
+		.7977666449006423,
+		.13518129740053308,
+		.0313477341283922
+	],
+	[
+		.2880748288194013,
+		.711835234241873,
+		8993693872564e-17
+	],
+	[
+		0,
+		0,
+		.8251046025104602
+	]
+];
+var REG_COLOR = new RegExp(`^(?:${SYN_COLOR_TYPE})$`);
+var REG_CS_HUE = new RegExp(`^${CS_HUE_CAPT}$`);
+var REG_CS_XYZ = /^xyz(?:-d(?:50|65))?$/;
+var REG_CURRENT = /^currentColor$/i;
+var REG_FN_COLOR = new RegExp(`^color\\(\\s*(${SYN_FN_COLOR})\\s*\\)$`);
+var REG_HSL = new RegExp(`^hsla?\\(\\s*(${SYN_HSL}|${SYN_HSL_LV3})\\s*\\)$`);
+var REG_HWB = new RegExp(`^hwb\\(\\s*(${SYN_HSL})\\s*\\)$`);
+var REG_LAB = new RegExp(`^lab\\(\\s*(${SYN_MOD})\\s*\\)$`);
+var REG_LCH = new RegExp(`^lch\\(\\s*(${SYN_LCH})\\s*\\)$`);
+var REG_MIX = new RegExp(`^${SYN_MIX}$`);
+var REG_MIX_CAPT = new RegExp(`^${SYN_MIX_CAPT}$`);
+var REG_MIX_NEST = new RegExp(`${SYN_MIX}`, "g");
+var REG_OKLAB = new RegExp(`^oklab\\(\\s*(${SYN_MOD})\\s*\\)$`);
+var REG_OKLCH = new RegExp(`^oklch\\(\\s*(${SYN_LCH})\\s*\\)$`);
+var REG_SPEC = /^(?:specifi|comput)edValue$/;
+var REG_ANGLE_TO_DEG = new RegExp(`^(${NUM})(${ANGLE})?$`);
+var REG_PARSE_RGB = new RegExp(`^rgba?\\(\\s*(${SYN_MOD}|${SYN_RGB_LV3})\\s*\\)$`);
+var REG_MIX_CS_RGB_XYZ = new RegExp(`^(?:${CS_RGB}|${CS_XYZ})$`);
+var REG_MIX_IN_CS = new RegExp(`in\\s+(${CS_MIX})`);
+var REG_MIX_START = new RegExp(`^color-mix\\(\\s*in\\s+(${CS_MIX})\\s*,`);
+var REG_MIX_COLOR_PART = new RegExp(`^(${SYN_COLOR_TYPE})(?:\\s+(${PCT}))?$`);
+/**
+* named colors
+*/
+var NAMED_COLORS = {
+	aliceblue: [
+		240,
+		248,
+		255
+	],
+	antiquewhite: [
+		250,
+		235,
+		215
+	],
+	aqua: [
+		0,
+		255,
+		255
+	],
+	aquamarine: [
+		127,
+		255,
+		212
+	],
+	azure: [
+		240,
+		255,
+		255
+	],
+	beige: [
+		245,
+		245,
+		220
+	],
+	bisque: [
+		255,
+		228,
+		196
+	],
+	black: [
+		0,
+		0,
+		0
+	],
+	blanchedalmond: [
+		255,
+		235,
+		205
+	],
+	blue: [
+		0,
+		0,
+		255
+	],
+	blueviolet: [
+		138,
+		43,
+		226
+	],
+	brown: [
+		165,
+		42,
+		42
+	],
+	burlywood: [
+		222,
+		184,
+		135
+	],
+	cadetblue: [
+		95,
+		158,
+		160
+	],
+	chartreuse: [
+		127,
+		255,
+		0
+	],
+	chocolate: [
+		210,
+		105,
+		30
+	],
+	coral: [
+		255,
+		127,
+		80
+	],
+	cornflowerblue: [
+		100,
+		149,
+		237
+	],
+	cornsilk: [
+		255,
+		248,
+		220
+	],
+	crimson: [
+		220,
+		20,
+		60
+	],
+	cyan: [
+		0,
+		255,
+		255
+	],
+	darkblue: [
+		0,
+		0,
+		139
+	],
+	darkcyan: [
+		0,
+		139,
+		139
+	],
+	darkgoldenrod: [
+		184,
+		134,
+		11
+	],
+	darkgray: [
+		169,
+		169,
+		169
+	],
+	darkgreen: [
+		0,
+		100,
+		0
+	],
+	darkgrey: [
+		169,
+		169,
+		169
+	],
+	darkkhaki: [
+		189,
+		183,
+		107
+	],
+	darkmagenta: [
+		139,
+		0,
+		139
+	],
+	darkolivegreen: [
+		85,
+		107,
+		47
+	],
+	darkorange: [
+		255,
+		140,
+		0
+	],
+	darkorchid: [
+		153,
+		50,
+		204
+	],
+	darkred: [
+		139,
+		0,
+		0
+	],
+	darksalmon: [
+		233,
+		150,
+		122
+	],
+	darkseagreen: [
+		143,
+		188,
+		143
+	],
+	darkslateblue: [
+		72,
+		61,
+		139
+	],
+	darkslategray: [
+		47,
+		79,
+		79
+	],
+	darkslategrey: [
+		47,
+		79,
+		79
+	],
+	darkturquoise: [
+		0,
+		206,
+		209
+	],
+	darkviolet: [
+		148,
+		0,
+		211
+	],
+	deeppink: [
+		255,
+		20,
+		147
+	],
+	deepskyblue: [
+		0,
+		191,
+		255
+	],
+	dimgray: [
+		105,
+		105,
+		105
+	],
+	dimgrey: [
+		105,
+		105,
+		105
+	],
+	dodgerblue: [
+		30,
+		144,
+		255
+	],
+	firebrick: [
+		178,
+		34,
+		34
+	],
+	floralwhite: [
+		255,
+		250,
+		240
+	],
+	forestgreen: [
+		34,
+		139,
+		34
+	],
+	fuchsia: [
+		255,
+		0,
+		255
+	],
+	gainsboro: [
+		220,
+		220,
+		220
+	],
+	ghostwhite: [
+		248,
+		248,
+		255
+	],
+	gold: [
+		255,
+		215,
+		0
+	],
+	goldenrod: [
+		218,
+		165,
+		32
+	],
+	gray: [
+		128,
+		128,
+		128
+	],
+	green: [
+		0,
+		128,
+		0
+	],
+	greenyellow: [
+		173,
+		255,
+		47
+	],
+	grey: [
+		128,
+		128,
+		128
+	],
+	honeydew: [
+		240,
+		255,
+		240
+	],
+	hotpink: [
+		255,
+		105,
+		180
+	],
+	indianred: [
+		205,
+		92,
+		92
+	],
+	indigo: [
+		75,
+		0,
+		130
+	],
+	ivory: [
+		255,
+		255,
+		240
+	],
+	khaki: [
+		240,
+		230,
+		140
+	],
+	lavender: [
+		230,
+		230,
+		250
+	],
+	lavenderblush: [
+		255,
+		240,
+		245
+	],
+	lawngreen: [
+		124,
+		252,
+		0
+	],
+	lemonchiffon: [
+		255,
+		250,
+		205
+	],
+	lightblue: [
+		173,
+		216,
+		230
+	],
+	lightcoral: [
+		240,
+		128,
+		128
+	],
+	lightcyan: [
+		224,
+		255,
+		255
+	],
+	lightgoldenrodyellow: [
+		250,
+		250,
+		210
+	],
+	lightgray: [
+		211,
+		211,
+		211
+	],
+	lightgreen: [
+		144,
+		238,
+		144
+	],
+	lightgrey: [
+		211,
+		211,
+		211
+	],
+	lightpink: [
+		255,
+		182,
+		193
+	],
+	lightsalmon: [
+		255,
+		160,
+		122
+	],
+	lightseagreen: [
+		32,
+		178,
+		170
+	],
+	lightskyblue: [
+		135,
+		206,
+		250
+	],
+	lightslategray: [
+		119,
+		136,
+		153
+	],
+	lightslategrey: [
+		119,
+		136,
+		153
+	],
+	lightsteelblue: [
+		176,
+		196,
+		222
+	],
+	lightyellow: [
+		255,
+		255,
+		224
+	],
+	lime: [
+		0,
+		255,
+		0
+	],
+	limegreen: [
+		50,
+		205,
+		50
+	],
+	linen: [
+		250,
+		240,
+		230
+	],
+	magenta: [
+		255,
+		0,
+		255
+	],
+	maroon: [
+		128,
+		0,
+		0
+	],
+	mediumaquamarine: [
+		102,
+		205,
+		170
+	],
+	mediumblue: [
+		0,
+		0,
+		205
+	],
+	mediumorchid: [
+		186,
+		85,
+		211
+	],
+	mediumpurple: [
+		147,
+		112,
+		219
+	],
+	mediumseagreen: [
+		60,
+		179,
+		113
+	],
+	mediumslateblue: [
+		123,
+		104,
+		238
+	],
+	mediumspringgreen: [
+		0,
+		250,
+		154
+	],
+	mediumturquoise: [
+		72,
+		209,
+		204
+	],
+	mediumvioletred: [
+		199,
+		21,
+		133
+	],
+	midnightblue: [
+		25,
+		25,
+		112
+	],
+	mintcream: [
+		245,
+		255,
+		250
+	],
+	mistyrose: [
+		255,
+		228,
+		225
+	],
+	moccasin: [
+		255,
+		228,
+		181
+	],
+	navajowhite: [
+		255,
+		222,
+		173
+	],
+	navy: [
+		0,
+		0,
+		128
+	],
+	oldlace: [
+		253,
+		245,
+		230
+	],
+	olive: [
+		128,
+		128,
+		0
+	],
+	olivedrab: [
+		107,
+		142,
+		35
+	],
+	orange: [
+		255,
+		165,
+		0
+	],
+	orangered: [
+		255,
+		69,
+		0
+	],
+	orchid: [
+		218,
+		112,
+		214
+	],
+	palegoldenrod: [
+		238,
+		232,
+		170
+	],
+	palegreen: [
+		152,
+		251,
+		152
+	],
+	paleturquoise: [
+		175,
+		238,
+		238
+	],
+	palevioletred: [
+		219,
+		112,
+		147
+	],
+	papayawhip: [
+		255,
+		239,
+		213
+	],
+	peachpuff: [
+		255,
+		218,
+		185
+	],
+	peru: [
+		205,
+		133,
+		63
+	],
+	pink: [
+		255,
+		192,
+		203
+	],
+	plum: [
+		221,
+		160,
+		221
+	],
+	powderblue: [
+		176,
+		224,
+		230
+	],
+	purple: [
+		128,
+		0,
+		128
+	],
+	rebeccapurple: [
+		102,
+		51,
+		153
+	],
+	red: [
+		255,
+		0,
+		0
+	],
+	rosybrown: [
+		188,
+		143,
+		143
+	],
+	royalblue: [
+		65,
+		105,
+		225
+	],
+	saddlebrown: [
+		139,
+		69,
+		19
+	],
+	salmon: [
+		250,
+		128,
+		114
+	],
+	sandybrown: [
+		244,
+		164,
+		96
+	],
+	seagreen: [
+		46,
+		139,
+		87
+	],
+	seashell: [
+		255,
+		245,
+		238
+	],
+	sienna: [
+		160,
+		82,
+		45
+	],
+	silver: [
+		192,
+		192,
+		192
+	],
+	skyblue: [
+		135,
+		206,
+		235
+	],
+	slateblue: [
+		106,
+		90,
+		205
+	],
+	slategray: [
+		112,
+		128,
+		144
+	],
+	slategrey: [
+		112,
+		128,
+		144
+	],
+	snow: [
+		255,
+		250,
+		250
+	],
+	springgreen: [
+		0,
+		255,
+		127
+	],
+	steelblue: [
+		70,
+		130,
+		180
+	],
+	tan: [
+		210,
+		180,
+		140
+	],
+	teal: [
+		0,
+		128,
+		128
+	],
+	thistle: [
+		216,
+		191,
+		216
+	],
+	tomato: [
+		255,
+		99,
+		71
+	],
+	turquoise: [
+		64,
+		224,
+		208
+	],
+	violet: [
+		238,
+		130,
+		238
+	],
+	wheat: [
+		245,
+		222,
+		179
+	],
+	white: [
+		255,
+		255,
+		255
+	],
+	whitesmoke: [
+		245,
+		245,
+		245
+	],
+	yellow: [
+		255,
+		255,
+		0
+	],
+	yellowgreen: [
+		154,
+		205,
+		50
+	]
+};
+/**
+* cache invalid color value
+* @param key - cache key
+* @param nullable - is nullable
+* @returns cached value
+*/
+var cacheInvalidColorValue = (cacheKey, format, nullable = false) => {
+	if (format === "specifiedValue") {
+		const res = "";
+		setCache(cacheKey, res);
+		return res;
+	}
+	if (nullable) {
+		setCache(cacheKey, null);
+		return new NullObject();
+	}
+	const res = [
+		"rgb",
+		0,
+		0,
+		0,
+		0
+	];
+	setCache(cacheKey, res);
+	return res;
+};
+/**
+* resolve invalid color value
+* @param format - output format
+* @param nullable - is nullable
+* @returns resolved value
+*/
+var resolveInvalidColorValue = (format, nullable = false) => {
+	switch (format) {
+		case "hsl":
+		case "hwb":
+		case VAL_MIX: return new NullObject();
+		case VAL_SPEC: return "";
+		default:
+			if (nullable) return new NullObject();
+			return [
+				"rgb",
+				0,
+				0,
+				0,
+				0
+			];
+	}
+};
+/**
+* validate color components
+* @param arr - color components
+* @param [opt] - options
+* @param [opt.alpha] - alpha channel
+* @param [opt.minLength] - min length
+* @param [opt.maxLength] - max length
+* @param [opt.minRange] - min range
+* @param [opt.maxRange] - max range
+* @param [opt.validateRange] - validate range
+* @returns result - validated color components
+*/
+var validateColorComponents = (arr, opt = {}) => {
+	if (!Array.isArray(arr)) throw new TypeError(`${arr} is not an array.`);
+	const { alpha = false, minLength = TRIA, maxLength = QUAD, minRange = 0, maxRange = 1, validateRange = true } = opt;
+	if (!Number.isFinite(minLength)) throw new TypeError(`${minLength} is not a number.`);
+	if (!Number.isFinite(maxLength)) throw new TypeError(`${maxLength} is not a number.`);
+	if (!Number.isFinite(minRange)) throw new TypeError(`${minRange} is not a number.`);
+	if (!Number.isFinite(maxRange)) throw new TypeError(`${maxRange} is not a number.`);
+	const l = arr.length;
+	if (l < minLength || l > maxLength) throw new Error(`Unexpected array length ${l}.`);
+	let i = 0;
+	while (i < l) {
+		const v = arr[i];
+		if (!Number.isFinite(v)) throw new TypeError(`${v} is not a number.`);
+		else if (i < TRIA && validateRange && (v < minRange || v > maxRange)) throw new RangeError(`${v} is not between ${minRange} and ${maxRange}.`);
+		else if (i === TRIA && (v < 0 || v > 1)) throw new RangeError(`${v} is not between 0 and 1.`);
+		i++;
+	}
+	if (alpha && l === TRIA) arr.push(1);
+	return arr;
+};
+/**
+* transform matrix
+* @param mtx - 3 * 3 matrix
+* @param vct - vector
+* @param [skip] - skip validate
+* @returns TriColorChannels - [p1, p2, p3]
+*/
+var transformMatrix = (mtx, vct, skip = false) => {
+	if (!Array.isArray(mtx)) throw new TypeError(`${mtx} is not an array.`);
+	else if (mtx.length !== TRIA) throw new Error(`Unexpected array length ${mtx.length}.`);
+	else if (!skip) for (let i of mtx) i = validateColorComponents(i, {
+		maxLength: TRIA,
+		validateRange: false
+	});
+	const [[r1c1, r1c2, r1c3], [r2c1, r2c2, r2c3], [r3c1, r3c2, r3c3]] = mtx;
+	let v1, v2, v3;
+	if (skip) [v1, v2, v3] = vct;
+	else [v1, v2, v3] = validateColorComponents(vct, {
+		maxLength: TRIA,
+		validateRange: false
+	});
+	return [
+		r1c1 * v1 + r1c2 * v2 + r1c3 * v3,
+		r2c1 * v1 + r2c2 * v2 + r2c3 * v3,
+		r3c1 * v1 + r3c2 * v2 + r3c3 * v3
+	];
+};
+/**
+* normalize color components
+* @param colorA - color components [v1, v2, v3, v4]
+* @param colorB - color components [v1, v2, v3, v4]
+* @param [skip] - skip validate
+* @returns result - [colorA, colorB]
+*/
+var normalizeColorComponents = (colorA, colorB, skip = false) => {
+	if (!Array.isArray(colorA)) throw new TypeError(`${colorA} is not an array.`);
+	else if (colorA.length !== QUAD) throw new Error(`Unexpected array length ${colorA.length}.`);
+	if (!Array.isArray(colorB)) throw new TypeError(`${colorB} is not an array.`);
+	else if (colorB.length !== QUAD) throw new Error(`Unexpected array length ${colorB.length}.`);
+	let i = 0;
+	while (i < QUAD) {
+		if (colorA[i] === "none" && colorB[i] === "none") {
+			colorA[i] = 0;
+			colorB[i] = 0;
+		} else if (colorA[i] === "none") colorA[i] = colorB[i];
+		else if (colorB[i] === "none") colorB[i] = colorA[i];
+		i++;
+	}
+	if (skip) return [colorA, colorB];
+	return [validateColorComponents(colorA, {
+		minLength: QUAD,
+		validateRange: false
+	}), validateColorComponents(colorB, {
+		minLength: QUAD,
+		validateRange: false
+	})];
+};
+/**
+* number to hex string
+* @param value - numeric value
+* @returns hex string
+*/
+var numberToHexString = (value) => {
+	if (!Number.isFinite(value)) throw new TypeError(`${value} is not a number.`);
+	else {
+		value = Math.round(value);
+		if (value < 0 || value > MAX_RGB) throw new RangeError(`${value} is not between 0 and ${MAX_RGB}.`);
+	}
+	let hex = value.toString(HEX);
+	if (hex.length === 1) hex = `0${hex}`;
+	return hex;
+};
+/**
+* angle to deg
+* @param angle
+* @returns deg: 0..360
+*/
+var angleToDeg = (angle) => {
+	if (isString(angle)) angle = angle.trim();
+	else throw new TypeError(`${angle} is not a string.`);
+	const GRAD = DEG / 400;
+	const RAD = DEG / (Math.PI * DUO);
+	if (!REG_ANGLE_TO_DEG.test(angle)) throw new SyntaxError(`Invalid property value: ${angle}`);
+	const [, value, unit] = angle.match(REG_ANGLE_TO_DEG);
+	let deg;
+	switch (unit) {
+		case "grad":
+			deg = parseFloat(value) * GRAD;
+			break;
+		case "rad":
+			deg = parseFloat(value) * RAD;
+			break;
+		case "turn":
+			deg = parseFloat(value) * DEG;
+			break;
+		default: deg = parseFloat(value);
+	}
+	deg %= DEG;
+	if (deg < 0) deg += DEG;
+	else if (Object.is(deg, -0)) deg = 0;
+	return deg;
+};
+/**
+* parse alpha
+* @param [alpha] - alpha value
+* @returns alpha: 0..1
+*/
+var parseAlpha = (alpha = "") => {
+	if (isString(alpha)) {
+		alpha = alpha.trim();
+		if (!alpha) alpha = "1";
+		else if (alpha === "none") alpha = "0";
+		else {
+			let a;
+			if (alpha.endsWith("%")) a = parseFloat(alpha) / MAX_PCT;
+			else a = parseFloat(alpha);
+			if (!Number.isFinite(a)) throw new TypeError(`${a} is not a finite number.`);
+			if (a < PPTH) alpha = "0";
+			else if (a > 1) alpha = "1";
+			else alpha = a.toFixed(TRIA);
+		}
+	} else alpha = "1";
+	return parseFloat(alpha);
+};
+/**
+* parse hex alpha
+* @param value - alpha value in hex string
+* @returns alpha: 0..1
+*/
+var parseHexAlpha = (value) => {
+	if (isString(value)) {
+		if (value === "") throw new SyntaxError("Invalid property value: (empty string)");
+		value = value.trim();
+	} else throw new TypeError(`${value} is not a string.`);
+	let alpha = parseInt(value, HEX);
+	if (alpha <= 0) return 0;
+	if (alpha >= MAX_RGB) return 1;
+	const alphaMap = /* @__PURE__ */ new Map();
+	for (let i = 1; i < MAX_PCT; i++) alphaMap.set(Math.round(i * MAX_RGB / MAX_PCT), i);
+	if (alphaMap.has(alpha)) alpha = alphaMap.get(alpha) / MAX_PCT;
+	else alpha = Math.round(alpha / MAX_RGB / PPTH) * PPTH;
+	return parseFloat(alpha.toFixed(TRIA));
+};
+/**
+* transform rgb to linear rgb
+* @param rgb - [r, g, b] r|g|b: 0..255
+* @param [skip] - skip validate
+* @returns TriColorChannels - [r, g, b] r|g|b: 0..1
+*/
+var transformRgbToLinearRgb = (rgb, skip = false) => {
+	let rr, gg, bb;
+	if (skip) [rr, gg, bb] = rgb;
+	else [rr, gg, bb] = validateColorComponents(rgb, {
+		maxLength: TRIA,
+		maxRange: MAX_RGB
+	});
+	let r = rr / MAX_RGB;
+	let g = gg / MAX_RGB;
+	let b = bb / MAX_RGB;
+	const COND_POW = .04045;
+	if (r > COND_POW) r = Math.pow((r + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
+	else r /= LINEAR_COEF;
+	if (g > COND_POW) g = Math.pow((g + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
+	else g /= LINEAR_COEF;
+	if (b > COND_POW) b = Math.pow((b + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
+	else b /= LINEAR_COEF;
+	return [
+		r,
+		g,
+		b
+	];
+};
+/**
+* transform rgb to xyz
+* @param rgb - [r, g, b] r|g|b: 0..255
+* @param [skip] - skip validate
+* @returns TriColorChannels - [x, y, z]
+*/
+var transformRgbToXyz = (rgb, skip = false) => {
+	if (!skip) rgb = validateColorComponents(rgb, {
+		maxLength: TRIA,
+		maxRange: MAX_RGB
+	});
+	rgb = transformRgbToLinearRgb(rgb, true);
+	return transformMatrix(MATRIX_L_RGB_TO_XYZ, rgb, true);
+};
+/**
+* transform linear rgb to rgb
+* @param rgb - [r, g, b] r|g|b: 0..1
+* @param [round] - round result
+* @returns TriColorChannels - [r, g, b] r|g|b: 0..255
+*/
+var transformLinearRgbToRgb = (rgb, round = false) => {
+	let [r, g, b] = validateColorComponents(rgb, { maxLength: TRIA });
+	const COND_POW = 809 / 258400;
+	if (r > COND_POW) r = Math.pow(r, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
+	else r *= LINEAR_COEF;
+	r *= MAX_RGB;
+	if (g > COND_POW) g = Math.pow(g, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
+	else g *= LINEAR_COEF;
+	g *= MAX_RGB;
+	if (b > COND_POW) b = Math.pow(b, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
+	else b *= LINEAR_COEF;
+	b *= MAX_RGB;
+	return [
+		round ? Math.round(r) : r,
+		round ? Math.round(g) : g,
+		round ? Math.round(b) : b
+	];
+};
+/**
+* transform xyz to rgb
+* @param xyz - [x, y, z]
+* @param [skip] - skip validate
+* @returns TriColorChannels - [r, g, b] r|g|b: 0..255
+*/
+var transformXyzToRgb = (xyz, skip = false) => {
+	if (!skip) xyz = validateColorComponents(xyz, {
+		maxLength: TRIA,
+		validateRange: false
+	});
+	let [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, xyz, true);
+	[r, g, b] = transformLinearRgbToRgb([
+		Math.min(Math.max(r, 0), 1),
+		Math.min(Math.max(g, 0), 1),
+		Math.min(Math.max(b, 0), 1)
+	], true);
+	return [
+		r,
+		g,
+		b
+	];
+};
+/**
+* transform xyz to hsl
+* @param xyz - [x, y, z]
+* @param [skip] - skip validate
+* @returns TriColorChannels - [h, s, l]
+*/
+var transformXyzToHsl = (xyz, skip = false) => {
+	const [rr, gg, bb] = transformXyzToRgb(xyz, skip);
+	const r = rr / MAX_RGB;
+	const g = gg / MAX_RGB;
+	const b = bb / MAX_RGB;
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const d = max - min;
+	const l = (max + min) * HALF * MAX_PCT;
+	let h, s;
+	if (Math.round(l) === 0 || Math.round(l) === MAX_PCT) {
+		h = 0;
+		s = 0;
+	} else {
+		s = d / (1 - Math.abs(max + min - 1)) * MAX_PCT;
+		if (s === 0) h = 0;
+		else {
+			switch (max) {
+				case r:
+					h = (g - b) / d;
+					break;
+				case g:
+					h = (b - r) / d + DUO;
+					break;
+				case b:
+				default:
+					h = (r - g) / d + QUAD;
+					break;
+			}
+			h = h * SEXA % DEG;
+			if (h < 0) h += DEG;
+		}
+	}
+	return [
+		h,
+		s,
+		l
+	];
+};
+/**
+* transform xyz to hwb
+* @param xyz - [x, y, z]
+* @param [skip] - skip validate
+* @returns TriColorChannels - [h, w, b]
+*/
+var transformXyzToHwb = (xyz, skip = false) => {
+	const [r, g, b] = transformXyzToRgb(xyz, skip);
+	const wh = Math.min(r, g, b) / MAX_RGB;
+	const bk = 1 - Math.max(r, g, b) / MAX_RGB;
+	let h;
+	if (wh + bk === 1) h = 0;
+	else [h] = transformXyzToHsl(xyz);
+	return [
+		h,
+		wh * MAX_PCT,
+		bk * MAX_PCT
+	];
+};
+/**
+* transform xyz to oklab
+* @param xyz - [x, y, z]
+* @param [skip] - skip validate
+* @returns TriColorChannels - [l, a, b]
+*/
+var transformXyzToOklab = (xyz, skip = false) => {
+	if (!skip) xyz = validateColorComponents(xyz, {
+		maxLength: TRIA,
+		validateRange: false
+	});
+	let [l, a, b] = transformMatrix(MATRIX_LMS_TO_OKLAB, transformMatrix(MATRIX_XYZ_TO_LMS, xyz, true).map((c) => Math.cbrt(c)), true);
+	l = Math.min(Math.max(l, 0), 1);
+	const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);
+	if (lPct === 0 || lPct === MAX_PCT) {
+		a = 0;
+		b = 0;
+	}
+	return [
+		l,
+		a,
+		b
+	];
+};
+/**
+* transform xyz to oklch
+* @param xyz - [x, y, z]
+* @param [skip] - skip validate
+* @returns TriColorChannels - [l, c, h]
+*/
+var transformXyzToOklch = (xyz, skip = false) => {
+	const [l, a, b] = transformXyzToOklab(xyz, skip);
+	let c, h;
+	const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);
+	if (lPct === 0 || lPct === MAX_PCT) {
+		c = 0;
+		h = 0;
+	} else {
+		c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);
+		if (parseFloat(c.toFixed(QUAD)) === 0) h = 0;
+		else {
+			h = Math.atan2(b, a) * DEG_HALF / Math.PI;
+			if (h < 0) h += DEG;
+		}
+	}
+	return [
+		l,
+		c,
+		h
+	];
+};
+/**
+* transform xyz D50 to rgb
+* @param xyz - [x, y, z]
+* @param [skip] - skip validate
+* @returns TriColorChannels - [r, g, b] r|g|b: 0..255
+*/
+var transformXyzD50ToRgb = (xyz, skip = false) => {
+	if (!skip) xyz = validateColorComponents(xyz, {
+		maxLength: TRIA,
+		validateRange: false
+	});
+	return transformXyzToRgb(transformMatrix(MATRIX_D50_TO_D65, xyz, true), true);
+};
+/**
+* transform xyz-d50 to lab
+* @param xyz - [x, y, z]
+* @param [skip] - skip validate
+* @returns TriColorChannels - [l, a, b]
+*/
+var transformXyzD50ToLab = (xyz, skip = false) => {
+	if (!skip) xyz = validateColorComponents(xyz, {
+		maxLength: TRIA,
+		validateRange: false
+	});
+	const [f0, f1, f2] = xyz.map((val, i) => val / D50[i]).map((val) => val > LAB_EPSILON ? Math.cbrt(val) : (val * LAB_KAPPA + HEX) / LAB_L);
+	const l = Math.min(Math.max(LAB_L * f1 - HEX, 0), MAX_PCT);
+	let a, b;
+	if (l === 0 || l === MAX_PCT) {
+		a = 0;
+		b = 0;
+	} else {
+		a = (f0 - f1) * LAB_A;
+		b = (f1 - f2) * LAB_B;
+	}
+	return [
+		l,
+		a,
+		b
+	];
+};
+/**
+* transform xyz-d50 to lch
+* @param xyz - [x, y, z]
+* @param [skip] - skip validate
+* @returns TriColorChannels - [l, c, h]
+*/
+var transformXyzD50ToLch = (xyz, skip = false) => {
+	const [l, a, b] = transformXyzD50ToLab(xyz, skip);
+	let c, h;
+	if (l === 0 || l === MAX_PCT) {
+		c = 0;
+		h = 0;
+	} else {
+		c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);
+		h = Math.atan2(b, a) * DEG_HALF / Math.PI;
+		if (h < 0) h += DEG;
+	}
+	return [
+		l,
+		c,
+		h
+	];
+};
+/**
+* convert rgb to hex color
+* @param rgb - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
+* @returns hex color
+*/
+var convertRgbToHex = (rgb) => {
+	const [r, g, b, alpha] = validateColorComponents(rgb, {
+		alpha: true,
+		maxRange: MAX_RGB
+	});
+	const rr = numberToHexString(r);
+	const gg = numberToHexString(g);
+	const bb = numberToHexString(b);
+	const aa = numberToHexString(alpha * MAX_RGB);
+	let hex;
+	if (aa === "ff") hex = `#${rr}${gg}${bb}`;
+	else hex = `#${rr}${gg}${bb}${aa}`;
+	return hex;
+};
+/**
+* convert hex color to rgb
+* @param value - hex color value
+* @returns ColorChannels - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
+*/
+var convertHexToRgb = (value) => {
+	if (isString(value)) value = value.toLowerCase().trim();
+	else throw new TypeError(`${value} is not a string.`);
+	if (!(/^#[\da-f]{6}$/.test(value) || /^#[\da-f]{3}$/.test(value) || /^#[\da-f]{8}$/.test(value) || /^#[\da-f]{4}$/.test(value))) throw new SyntaxError(`Invalid property value: ${value}`);
+	const arr = [];
+	if (/^#[\da-f]{3}$/.test(value)) {
+		const [, r, g, b] = value.match(/^#([\da-f])([\da-f])([\da-f])$/);
+		arr.push(parseInt(`${r}${r}`, HEX), parseInt(`${g}${g}`, HEX), parseInt(`${b}${b}`, HEX), 1);
+	} else if (/^#[\da-f]{4}$/.test(value)) {
+		const [, r, g, b, alpha] = value.match(/^#([\da-f])([\da-f])([\da-f])([\da-f])$/);
+		arr.push(parseInt(`${r}${r}`, HEX), parseInt(`${g}${g}`, HEX), parseInt(`${b}${b}`, HEX), parseHexAlpha(`${alpha}${alpha}`));
+	} else if (/^#[\da-f]{8}$/.test(value)) {
+		const [, r, g, b, alpha] = value.match(/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})$/);
+		arr.push(parseInt(r, HEX), parseInt(g, HEX), parseInt(b, HEX), parseHexAlpha(alpha));
+	} else {
+		const [, r, g, b] = value.match(/^#([\da-f]{2})([\da-f]{2})([\da-f]{2})$/);
+		arr.push(parseInt(r, HEX), parseInt(g, HEX), parseInt(b, HEX), 1);
+	}
+	return arr;
+};
+/**
+* convert hex color to linear rgb
+* @param value - hex color value
+* @returns ColorChannels - [r, g, b, alpha] r|g|b|alpha: 0..1
+*/
+var convertHexToLinearRgb = (value) => {
+	const [rr, gg, bb, alpha] = convertHexToRgb(value);
+	const [r, g, b] = transformRgbToLinearRgb([
+		rr,
+		gg,
+		bb
+	], true);
+	return [
+		r,
+		g,
+		b,
+		alpha
+	];
+};
+/**
+* convert hex color to xyz
+* @param value - hex color value
+* @returns ColorChannels - [x, y, z, alpha]
+*/
+var convertHexToXyz = (value) => {
+	const [r, g, b, alpha] = convertHexToLinearRgb(value);
+	const [x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [
+		r,
+		g,
+		b
+	], true);
+	return [
+		x,
+		y,
+		z,
+		alpha
+	];
+};
+/**
+* parse rgb()
+* @param value - rgb color value
+* @param [opt] - options
+* @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
+*/
+var parseRgb = (value, opt = {}) => {
+	if (isString(value)) value = value.toLowerCase().trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "", nullable = false } = opt;
+	if (!REG_PARSE_RGB.test(value)) {
+		const res = resolveInvalidColorValue(format, nullable);
+		if (res instanceof NullObject) return res;
+		if (isString(res)) return res;
+		return res;
+	}
+	const [, val] = value.match(REG_PARSE_RGB);
+	const [v1, v2, v3, v4 = ""] = val.match(/[^\s,/]+/g);
+	let r, g, b;
+	if (v1 === "none") r = 0;
+	else {
+		if (v1.endsWith("%")) r = parseFloat(v1) * MAX_RGB / MAX_PCT;
+		else r = parseFloat(v1);
+		r = Math.min(Math.max(roundToPrecision(r, OCT), 0), MAX_RGB);
+	}
+	if (v2 === "none") g = 0;
+	else {
+		if (v2.endsWith("%")) g = parseFloat(v2) * MAX_RGB / MAX_PCT;
+		else g = parseFloat(v2);
+		g = Math.min(Math.max(roundToPrecision(g, OCT), 0), MAX_RGB);
+	}
+	if (v3 === "none") b = 0;
+	else {
+		if (v3.endsWith("%")) b = parseFloat(v3) * MAX_RGB / MAX_PCT;
+		else b = parseFloat(v3);
+		b = Math.min(Math.max(roundToPrecision(b, OCT), 0), MAX_RGB);
+	}
+	const alpha = parseAlpha(v4);
+	return [
+		"rgb",
+		r,
+		g,
+		b,
+		format === "mixValue" && v4 === "none" ? NONE : alpha
+	];
+};
+/**
+* parse hsl()
+* @param value - hsl color value
+* @param [opt] - options
+* @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
+*/
+var parseHsl = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "", nullable = false } = opt;
+	if (!REG_HSL.test(value)) {
+		const res = resolveInvalidColorValue(format, nullable);
+		if (res instanceof NullObject) return res;
+		if (isString(res)) return res;
+		return res;
+	}
+	const [, val] = value.match(REG_HSL);
+	const [v1, v2, v3, v4 = ""] = val.match(/[^\s,/]+/g);
+	let h, s, l;
+	if (v1 === "none") h = 0;
+	else h = angleToDeg(v1);
+	if (v2 === "none") s = 0;
+	else s = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT);
+	if (v3 === "none") l = 0;
+	else l = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT);
+	const alpha = parseAlpha(v4);
+	if (format === "hsl") return [
+		format,
+		v1 === "none" ? v1 : h,
+		v2 === "none" ? v2 : s,
+		v3 === "none" ? v3 : l,
+		v4 === "none" ? v4 : alpha
+	];
+	h = h / DEG * DOZ;
+	l /= MAX_PCT;
+	const sa = s / MAX_PCT * Math.min(l, 1 - l);
+	const rk = h % DOZ;
+	const gk = (8 + h) % DOZ;
+	const bk = (4 + h) % DOZ;
+	const r = l - sa * Math.max(-1, Math.min(rk - TRIA, TRIA ** POW_SQR - rk, 1));
+	const g = l - sa * Math.max(-1, Math.min(gk - TRIA, TRIA ** POW_SQR - gk, 1));
+	const b = l - sa * Math.max(-1, Math.min(bk - TRIA, TRIA ** POW_SQR - bk, 1));
+	return [
+		"rgb",
+		Math.min(Math.max(roundToPrecision(r * MAX_RGB, OCT), 0), MAX_RGB),
+		Math.min(Math.max(roundToPrecision(g * MAX_RGB, OCT), 0), MAX_RGB),
+		Math.min(Math.max(roundToPrecision(b * MAX_RGB, OCT), 0), MAX_RGB),
+		alpha
+	];
+};
+/**
+* parse hwb()
+* @param value - hwb color value
+* @param [opt] - options
+* @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
+*/
+var parseHwb = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "", nullable = false } = opt;
+	if (!REG_HWB.test(value)) {
+		const res = resolveInvalidColorValue(format, nullable);
+		if (res instanceof NullObject) return res;
+		if (isString(res)) return res;
+		return res;
+	}
+	const [, val] = value.match(REG_HWB);
+	const [v1, v2, v3, v4 = ""] = val.match(/[^\s,/]+/g);
+	let h, wh, bk;
+	if (v1 === "none") h = 0;
+	else h = angleToDeg(v1);
+	if (v2 === "none") wh = 0;
+	else wh = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT) / MAX_PCT;
+	if (v3 === "none") bk = 0;
+	else bk = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT) / MAX_PCT;
+	const alpha = parseAlpha(v4);
+	if (format === "hwb") return [
+		format,
+		v1 === "none" ? v1 : h,
+		v2 === "none" ? v2 : wh * MAX_PCT,
+		v3 === "none" ? v3 : bk * MAX_PCT,
+		v4 === "none" ? v4 : alpha
+	];
+	if (wh + bk >= 1) {
+		const v = roundToPrecision(wh / (wh + bk) * MAX_RGB, OCT);
+		return [
+			"rgb",
+			v,
+			v,
+			v,
+			alpha
+		];
+	}
+	const factor = (1 - wh - bk) / MAX_RGB;
+	let [, r, g, b] = parseHsl(`hsl(${h} 100 50)`);
+	r = roundToPrecision((r * factor + wh) * MAX_RGB, OCT);
+	g = roundToPrecision((g * factor + wh) * MAX_RGB, OCT);
+	b = roundToPrecision((b * factor + wh) * MAX_RGB, OCT);
+	return [
+		"rgb",
+		Math.min(Math.max(r, 0), MAX_RGB),
+		Math.min(Math.max(g, 0), MAX_RGB),
+		Math.min(Math.max(b, 0), MAX_RGB),
+		alpha
+	];
+};
+/**
+* parse lab()
+* @param value - lab color value
+* @param [opt] - options
+* @returns parsed color
+*   - [xyz-d50, x, y, z, alpha], ['lab', l, a, b, alpha], '(empty)', NullObject
+*/
+var parseLab = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "", nullable = false } = opt;
+	if (!REG_LAB.test(value)) {
+		const res = resolveInvalidColorValue(format, nullable);
+		if (res instanceof NullObject) return res;
+		if (isString(res)) return res;
+		return res;
+	}
+	const COEF_PCT = 1.25;
+	const COND_POW = 8;
+	const [, val] = value.match(REG_LAB);
+	const [v1, v2, v3, v4 = ""] = val.match(/[^\s,/]+/g);
+	let l, a, b;
+	if (v1 === "none") l = 0;
+	else {
+		if (v1.endsWith("%")) {
+			l = parseFloat(v1);
+			if (l > MAX_PCT) l = MAX_PCT;
+		} else l = parseFloat(v1);
+		if (l < 0) l = 0;
+	}
+	if (v2 === "none") a = 0;
+	else a = v2.endsWith("%") ? parseFloat(v2) * COEF_PCT : parseFloat(v2);
+	if (v3 === "none") b = 0;
+	else b = v3.endsWith("%") ? parseFloat(v3) * COEF_PCT : parseFloat(v3);
+	const alpha = parseAlpha(v4);
+	if (REG_SPEC.test(format)) return [
+		"lab",
+		v1 === "none" ? v1 : roundToPrecision(l, HEX),
+		v2 === "none" ? v2 : roundToPrecision(a, HEX),
+		v3 === "none" ? v3 : roundToPrecision(b, HEX),
+		v4 === "none" ? v4 : alpha
+	];
+	const fl = (l + HEX) / LAB_L;
+	const fa = a / LAB_A + fl;
+	const fb = fl - b / LAB_B;
+	const powFl = Math.pow(fl, POW_CUBE);
+	const powFa = Math.pow(fa, POW_CUBE);
+	const powFb = Math.pow(fb, POW_CUBE);
+	const [x, y, z] = [
+		powFa > LAB_EPSILON ? powFa : (fa * LAB_L - HEX) / LAB_KAPPA,
+		l > COND_POW ? powFl : l / LAB_KAPPA,
+		powFb > LAB_EPSILON ? powFb : (fb * LAB_L - HEX) / LAB_KAPPA
+	].map((val, i) => val * D50[i]);
+	return [
+		"xyz-d50",
+		roundToPrecision(x, HEX),
+		roundToPrecision(y, HEX),
+		roundToPrecision(z, HEX),
+		alpha
+	];
+};
+/**
+* parse lch()
+* @param value - lch color value
+* @param [opt] - options
+* @returns parsed color
+*   - ['xyz-d50', x, y, z, alpha], ['lch', l, c, h, alpha]
+*   - '(empty)', NullObject
+*/
+var parseLch = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "", nullable = false } = opt;
+	if (!REG_LCH.test(value)) {
+		const res = resolveInvalidColorValue(format, nullable);
+		if (res instanceof NullObject) return res;
+		if (isString(res)) return res;
+		return res;
+	}
+	const COEF_PCT = 1.5;
+	const [, val] = value.match(REG_LCH);
+	const [v1, v2, v3, v4 = ""] = val.match(/[^\s,/]+/g);
+	let l, c, h;
+	if (v1 === "none") l = 0;
+	else {
+		l = parseFloat(v1);
+		if (l < 0) l = 0;
+	}
+	if (v2 === "none") c = 0;
+	else c = v2.endsWith("%") ? parseFloat(v2) * COEF_PCT : parseFloat(v2);
+	if (v3 === "none") h = 0;
+	else h = angleToDeg(v3);
+	const alpha = parseAlpha(v4);
+	if (REG_SPEC.test(format)) return [
+		"lch",
+		v1 === "none" ? v1 : roundToPrecision(l, HEX),
+		v2 === "none" ? v2 : roundToPrecision(c, HEX),
+		v3 === "none" ? v3 : roundToPrecision(h, HEX),
+		v4 === "none" ? v4 : alpha
+	];
+	const a = c * Math.cos(h * Math.PI / DEG_HALF);
+	const b = c * Math.sin(h * Math.PI / DEG_HALF);
+	const [, x, y, z] = parseLab(`lab(${l} ${a} ${b})`);
+	return [
+		"xyz-d50",
+		roundToPrecision(x, HEX),
+		roundToPrecision(y, HEX),
+		roundToPrecision(z, HEX),
+		alpha
+	];
+};
+/**
+* parse oklab()
+* @param value - oklab color value
+* @param [opt] - options
+* @returns parsed color
+*   - ['xyz-d65', x, y, z, alpha], ['oklab', l, a, b, alpha]
+*   - '(empty)', NullObject
+*/
+var parseOklab = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "", nullable = false } = opt;
+	if (!REG_OKLAB.test(value)) {
+		const res = resolveInvalidColorValue(format, nullable);
+		if (res instanceof NullObject) return res;
+		if (isString(res)) return res;
+		return res;
+	}
+	const COEF_PCT = .4;
+	const [, val] = value.match(REG_OKLAB);
+	const [v1, v2, v3, v4 = ""] = val.match(/[^\s,/]+/g);
+	let l, a, b;
+	if (v1 === "none") l = 0;
+	else {
+		l = v1.endsWith("%") ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
+		if (l < 0) l = 0;
+	}
+	if (v2 === "none") a = 0;
+	else if (v2.endsWith("%")) a = parseFloat(v2) * COEF_PCT / MAX_PCT;
+	else a = parseFloat(v2);
+	if (v3 === "none") b = 0;
+	else if (v3.endsWith("%")) b = parseFloat(v3) * COEF_PCT / MAX_PCT;
+	else b = parseFloat(v3);
+	const alpha = parseAlpha(v4);
+	if (REG_SPEC.test(format)) return [
+		"oklab",
+		v1 === "none" ? v1 : roundToPrecision(l, HEX),
+		v2 === "none" ? v2 : roundToPrecision(a, HEX),
+		v3 === "none" ? v3 : roundToPrecision(b, HEX),
+		v4 === "none" ? v4 : alpha
+	];
+	const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, transformMatrix(MATRIX_OKLAB_TO_LMS, [
+		l,
+		a,
+		b
+	]).map((c) => Math.pow(c, POW_CUBE)), true);
+	return [
+		"xyz-d65",
+		roundToPrecision(x, HEX),
+		roundToPrecision(y, HEX),
+		roundToPrecision(z, HEX),
+		alpha
+	];
+};
+/**
+* parse oklch()
+* @param value - oklch color value
+* @param [opt] - options
+* @returns parsed color
+*   - ['xyz-d65', x, y, z, alpha], ['oklch', l, c, h, alpha]
+*   - '(empty)', NullObject
+*/
+var parseOklch = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "", nullable = false } = opt;
+	if (!REG_OKLCH.test(value)) {
+		const res = resolveInvalidColorValue(format, nullable);
+		if (res instanceof NullObject) return res;
+		if (isString(res)) return res;
+		return res;
+	}
+	const COEF_PCT = .4;
+	const [, val] = value.match(REG_OKLCH);
+	const [v1, v2, v3, v4 = ""] = val.match(/[^\s,/]+/g);
+	let l, c, h;
+	if (v1 === "none") l = 0;
+	else {
+		l = v1.endsWith("%") ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
+		if (l < 0) l = 0;
+	}
+	if (v2 === "none") c = 0;
+	else {
+		if (v2.endsWith("%")) c = parseFloat(v2) * COEF_PCT / MAX_PCT;
+		else c = parseFloat(v2);
+		if (c < 0) c = 0;
+	}
+	if (v3 === "none") h = 0;
+	else h = angleToDeg(v3);
+	const alpha = parseAlpha(v4);
+	if (REG_SPEC.test(format)) return [
+		"oklch",
+		v1 === "none" ? v1 : roundToPrecision(l, HEX),
+		v2 === "none" ? v2 : roundToPrecision(c, HEX),
+		v3 === "none" ? v3 : roundToPrecision(h, HEX),
+		v4 === "none" ? v4 : alpha
+	];
+	const a = c * Math.cos(h * Math.PI / DEG_HALF);
+	const b = c * Math.sin(h * Math.PI / DEG_HALF);
+	const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, transformMatrix(MATRIX_OKLAB_TO_LMS, [
+		l,
+		a,
+		b
+	]).map((cc) => Math.pow(cc, POW_CUBE)), true);
+	return [
+		"xyz-d65",
+		roundToPrecision(x, HEX),
+		roundToPrecision(y, HEX),
+		roundToPrecision(z, HEX),
+		alpha
+	];
+};
+/**
+* parse color()
+* @param value - color function value
+* @param [opt] - options
+* @returns parsed color
+*   - ['xyz-(d50|d65)', x, y, z, alpha], [cs, r, g, b, alpha]
+*   - '(empty)', NullObject
+*/
+var parseColorFunc = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { colorSpace = "", d50 = false, format = "", nullable = false } = opt;
+	if (!REG_FN_COLOR.test(value)) {
+		const res = resolveInvalidColorValue(format, nullable);
+		if (res instanceof NullObject) return res;
+		if (isString(res)) return res;
+		return res;
+	}
+	const [, val] = value.match(REG_FN_COLOR);
+	let [cs, v1, v2, v3, v4 = ""] = val.match(/[^\s,/]+/g);
+	let r, g, b;
+	if (cs === "xyz") cs = "xyz-d65";
+	if (v1 === "none") r = 0;
+	else r = v1.endsWith("%") ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
+	if (v2 === "none") g = 0;
+	else g = v2.endsWith("%") ? parseFloat(v2) / MAX_PCT : parseFloat(v2);
+	if (v3 === "none") b = 0;
+	else b = v3.endsWith("%") ? parseFloat(v3) / MAX_PCT : parseFloat(v3);
+	const alpha = parseAlpha(v4);
+	if (REG_SPEC.test(format) || format === "mixValue" && cs === colorSpace) return [
+		cs,
+		v1 === "none" ? v1 : roundToPrecision(r, DEC),
+		v2 === "none" ? v2 : roundToPrecision(g, DEC),
+		v3 === "none" ? v3 : roundToPrecision(b, DEC),
+		v4 === "none" ? v4 : alpha
+	];
+	let x = 0;
+	let y = 0;
+	let z = 0;
+	if (cs === "srgb-linear") {
+		[x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [
+			r,
+			g,
+			b
+		]);
+		if (d50) [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [
+			x,
+			y,
+			z
+		], true);
+	} else if (cs === "display-p3") {
+		const linearRgb = transformRgbToLinearRgb([
+			r * MAX_RGB,
+			g * MAX_RGB,
+			b * MAX_RGB
+		]);
+		[x, y, z] = transformMatrix(MATRIX_P3_TO_XYZ, linearRgb);
+		if (d50) [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [
+			x,
+			y,
+			z
+		], true);
+	} else if (cs === "rec2020") {
+		const ALPHA = 1.09929682680944;
+		const BETA = .018053968510807;
+		const REC_COEF = .45;
+		const rgb = [
+			r,
+			g,
+			b
+		].map((c) => {
+			let cl;
+			if (c < BETA * REC_COEF * DEC) cl = c / (REC_COEF * DEC);
+			else cl = Math.pow((c + ALPHA - 1) / ALPHA, 1 / REC_COEF);
+			return cl;
+		});
+		[x, y, z] = transformMatrix(MATRIX_REC2020_TO_XYZ, rgb);
+		if (d50) [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [
+			x,
+			y,
+			z
+		], true);
+	} else if (cs === "a98-rgb") {
+		const POW_A98 = 563 / 256;
+		const rgb = [
+			r,
+			g,
+			b
+		].map((c) => {
+			return Math.pow(c, POW_A98);
+		});
+		[x, y, z] = transformMatrix(MATRIX_A98_TO_XYZ, rgb);
+		if (d50) [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [
+			x,
+			y,
+			z
+		], true);
+	} else if (cs === "prophoto-rgb") {
+		const POW_PROPHOTO = 1.8;
+		const rgb = [
+			r,
+			g,
+			b
+		].map((c) => {
+			let cl;
+			if (c > 1 / (HEX * DUO)) cl = Math.pow(c, POW_PROPHOTO);
+			else cl = c / HEX;
+			return cl;
+		});
+		[x, y, z] = transformMatrix(MATRIX_PROPHOTO_TO_XYZ_D50, rgb);
+		if (!d50) [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [
+			x,
+			y,
+			z
+		], true);
+	} else if (/^xyz(?:-d(?:50|65))?$/.test(cs)) {
+		[x, y, z] = [
+			r,
+			g,
+			b
+		];
+		if (cs === "xyz-d50") {
+			if (!d50) [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [
+				x,
+				y,
+				z
+			]);
+		} else if (d50) [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [
+			x,
+			y,
+			z
+		], true);
+	} else {
+		[x, y, z] = transformRgbToXyz([
+			r * MAX_RGB,
+			g * MAX_RGB,
+			b * MAX_RGB
+		]);
+		if (d50) [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [
+			x,
+			y,
+			z
+		], true);
+	}
+	return [
+		d50 ? "xyz-d50" : "xyz-d65",
+		roundToPrecision(x, HEX),
+		roundToPrecision(y, HEX),
+		roundToPrecision(z, HEX),
+		format === "mixValue" && v4 === "none" ? v4 : alpha
+	];
+};
+/**
+* parse color value
+* @param value - CSS color value
+* @param [opt] - options
+* @returns parsed color
+*   - ['xyz-(d50|d65)', x, y, z, alpha], ['rgb', r, g, b, alpha]
+*   - value, '(empty)', NullObject
+*/
+var parseColorValue = (value, opt = {}) => {
+	if (isString(value)) value = value.toLowerCase().trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { d50 = false, format = "", nullable = false } = opt;
+	if (!REG_COLOR.test(value)) {
+		const res = resolveInvalidColorValue(format, nullable);
+		if (res instanceof NullObject) return res;
+		if (isString(res)) return res;
+		return res;
+	}
+	let x = 0;
+	let y = 0;
+	let z = 0;
+	let alpha = 0;
+	if (REG_CURRENT.test(value)) {
+		if (format === "computedValue") return [
+			"rgb",
+			0,
+			0,
+			0,
+			0
+		];
+		if (format === "specifiedValue") return value;
+	} else if (/^[a-z]+$/.test(value)) if (Object.hasOwn(NAMED_COLORS, value)) {
+		if (format === "specifiedValue") return value;
+		const [r, g, b] = NAMED_COLORS[value];
+		alpha = 1;
+		if (format === "computedValue") return [
+			"rgb",
+			r,
+			g,
+			b,
+			alpha
+		];
+		[x, y, z] = transformRgbToXyz([
+			r,
+			g,
+			b
+		], true);
+		if (d50) [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [
+			x,
+			y,
+			z
+		], true);
+	} else switch (format) {
+		case VAL_COMP:
+			if (nullable && value !== "transparent") return new NullObject();
+			return [
+				"rgb",
+				0,
+				0,
+				0,
+				0
+			];
+		case VAL_SPEC:
+			if (value === "transparent") return value;
+			return "";
+		case VAL_MIX:
+			if (value === "transparent") return [
+				"rgb",
+				0,
+				0,
+				0,
+				0
+			];
+			return new NullObject();
+		default:
+	}
+	else if (value[0] === "#") {
+		if (REG_SPEC.test(format)) return ["rgb", ...convertHexToRgb(value)];
+		[x, y, z, alpha] = convertHexToXyz(value);
+		if (d50) [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [
+			x,
+			y,
+			z
+		], true);
+	} else if (value.startsWith("lab")) {
+		if (REG_SPEC.test(format)) return parseLab(value, opt);
+		[, x, y, z, alpha] = parseLab(value);
+		if (!d50) [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [
+			x,
+			y,
+			z
+		], true);
+	} else if (value.startsWith("lch")) {
+		if (REG_SPEC.test(format)) return parseLch(value, opt);
+		[, x, y, z, alpha] = parseLch(value);
+		if (!d50) [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [
+			x,
+			y,
+			z
+		], true);
+	} else if (value.startsWith("oklab")) {
+		if (REG_SPEC.test(format)) return parseOklab(value, opt);
+		[, x, y, z, alpha] = parseOklab(value);
+		if (d50) [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [
+			x,
+			y,
+			z
+		], true);
+	} else if (value.startsWith("oklch")) {
+		if (REG_SPEC.test(format)) return parseOklch(value, opt);
+		[, x, y, z, alpha] = parseOklch(value);
+		if (d50) [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [
+			x,
+			y,
+			z
+		], true);
+	} else {
+		let r, g, b;
+		if (value.startsWith("hsl")) [, r, g, b, alpha] = parseHsl(value);
+		else if (value.startsWith("hwb")) [, r, g, b, alpha] = parseHwb(value);
+		else [, r, g, b, alpha] = parseRgb(value, opt);
+		if (REG_SPEC.test(format)) return [
+			"rgb",
+			Math.round(r),
+			Math.round(g),
+			Math.round(b),
+			alpha
+		];
+		[x, y, z] = transformRgbToXyz([
+			r,
+			g,
+			b
+		]);
+		if (d50) [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [
+			x,
+			y,
+			z
+		], true);
+	}
+	return [
+		d50 ? "xyz-d50" : "xyz-d65",
+		roundToPrecision(x, HEX),
+		roundToPrecision(y, HEX),
+		roundToPrecision(z, HEX),
+		alpha
+	];
+};
+/**
+* resolve color value
+* @param value - CSS color value
+* @param [opt] - options
+* @returns resolved color
+*   - [cs, v1, v2, v3, alpha], value, '(empty)', NullObject
+*/
+var resolveColorValue = (value, opt = {}) => {
+	if (isString(value)) value = value.toLowerCase().trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { colorSpace = "", format = "", nullable = false } = opt;
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "resolveColorValue",
+		value
+	}, opt);
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) {
+		if (cachedResult.isNull) return cachedResult;
+		const cachedItem = cachedResult.item;
+		if (isString(cachedItem)) return cachedItem;
+		return cachedItem;
+	}
+	if (!REG_COLOR.test(value)) {
+		const res = resolveInvalidColorValue(format, nullable);
+		if (res instanceof NullObject) {
+			setCache(cacheKey, null);
+			return res;
+		}
+		setCache(cacheKey, res);
+		if (isString(res)) return res;
+		return res;
+	}
+	let cs = "";
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	let alpha = 0;
+	if (REG_CURRENT.test(value)) {
+		if (format === "specifiedValue") {
+			setCache(cacheKey, value);
+			return value;
+		}
+	} else if (/^[a-z]+$/.test(value)) if (Object.hasOwn(NAMED_COLORS, value)) {
+		if (format === "specifiedValue") {
+			setCache(cacheKey, value);
+			return value;
+		}
+		[r, g, b] = NAMED_COLORS[value];
+		alpha = 1;
+	} else switch (format) {
+		case VAL_SPEC: {
+			if (value === "transparent") {
+				setCache(cacheKey, value);
+				return value;
+			}
+			const res = "";
+			setCache(cacheKey, res);
+			return res;
+		}
+		case VAL_MIX:
+			if (value === "transparent") {
+				const res = [
+					"rgb",
+					0,
+					0,
+					0,
+					0
+				];
+				setCache(cacheKey, res);
+				return res;
+			}
+			setCache(cacheKey, null);
+			return new NullObject();
+		case VAL_COMP:
+		default: {
+			if (nullable && value !== "transparent") {
+				setCache(cacheKey, null);
+				return new NullObject();
+			}
+			const res = [
+				"rgb",
+				0,
+				0,
+				0,
+				0
+			];
+			setCache(cacheKey, res);
+			return res;
+		}
+	}
+	else if (value[0] === "#") [r, g, b, alpha] = convertHexToRgb(value);
+	else if (value.startsWith("hsl")) [, r, g, b, alpha] = parseHsl(value, opt);
+	else if (value.startsWith("hwb")) [, r, g, b, alpha] = parseHwb(value, opt);
+	else if (/^l(?:ab|ch)/.test(value)) {
+		let x, y, z;
+		if (value.startsWith("lab")) [cs, x, y, z, alpha] = parseLab(value, opt);
+		else [cs, x, y, z, alpha] = parseLch(value, opt);
+		if (REG_SPEC.test(format)) {
+			const res = [
+				cs,
+				x,
+				y,
+				z,
+				alpha
+			];
+			setCache(cacheKey, res);
+			return res;
+		}
+		[r, g, b] = transformXyzD50ToRgb([
+			x,
+			y,
+			z
+		]);
+	} else if (/^okl(?:ab|ch)/.test(value)) {
+		let x, y, z;
+		if (value.startsWith("oklab")) [cs, x, y, z, alpha] = parseOklab(value, opt);
+		else [cs, x, y, z, alpha] = parseOklch(value, opt);
+		if (REG_SPEC.test(format)) {
+			const res = [
+				cs,
+				x,
+				y,
+				z,
+				alpha
+			];
+			setCache(cacheKey, res);
+			return res;
+		}
+		[r, g, b] = transformXyzToRgb([
+			x,
+			y,
+			z
+		]);
+	} else [, r, g, b, alpha] = parseRgb(value, opt);
+	if (format === "mixValue" && colorSpace === "srgb") {
+		const res = [
+			"srgb",
+			r / MAX_RGB,
+			g / MAX_RGB,
+			b / MAX_RGB,
+			alpha
+		];
+		setCache(cacheKey, res);
+		return res;
+	}
+	const res = [
+		"rgb",
+		Math.round(r),
+		Math.round(g),
+		Math.round(b),
+		alpha
+	];
+	setCache(cacheKey, res);
+	return res;
+};
+/**
+* resolve color()
+* @param value - color function value
+* @param [opt] - options
+* @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)', NullObject
+*/
+var resolveColorFunc = (value, opt = {}) => {
+	if (isString(value)) value = value.toLowerCase().trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { colorSpace = "", format = "", nullable = false } = opt;
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "resolveColorFunc",
+		value
+	}, opt);
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) {
+		if (cachedResult.isNull) return cachedResult;
+		const cachedItem = cachedResult.item;
+		if (isString(cachedItem)) return cachedItem;
+		return cachedItem;
+	}
+	if (!REG_FN_COLOR.test(value)) {
+		const res = resolveInvalidColorValue(format, nullable);
+		if (res instanceof NullObject) {
+			setCache(cacheKey, null);
+			return res;
+		}
+		setCache(cacheKey, res);
+		if (isString(res)) return res;
+		return res;
+	}
+	const [cs, v1, v2, v3, v4] = parseColorFunc(value, opt);
+	if (REG_SPEC.test(format) || format === "mixValue" && cs === colorSpace) {
+		const res = [
+			cs,
+			v1,
+			v2,
+			v3,
+			v4
+		];
+		setCache(cacheKey, res);
+		return res;
+	}
+	const x = parseFloat(`${v1}`);
+	const y = parseFloat(`${v2}`);
+	const z = parseFloat(`${v3}`);
+	const alpha = parseAlpha(`${v4}`);
+	const [r, g, b] = transformXyzToRgb([
+		x,
+		y,
+		z
+	], true);
+	const res = [
+		"rgb",
+		r,
+		g,
+		b,
+		alpha
+	];
+	setCache(cacheKey, res);
+	return res;
+};
+/**
+* convert color value to linear rgb
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels | NullObject - [r, g, b, alpha] r|g|b|alpha: 0..1
+*/
+var convertColorToLinearRgb = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { colorSpace = "", format = "" } = opt;
+	let cs = "";
+	let r, g, b, alpha, x, y, z;
+	if (format === "mixValue") {
+		let xyz;
+		if (value.startsWith("color(")) xyz = parseColorFunc(value, opt);
+		else xyz = parseColorValue(value, opt);
+		if (xyz instanceof NullObject) return xyz;
+		[cs, x, y, z, alpha] = xyz;
+		if (cs === colorSpace) return [
+			x,
+			y,
+			z,
+			alpha
+		];
+		[r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [
+			x,
+			y,
+			z
+		], true);
+	} else if (value.startsWith("color(")) {
+		const [, val] = value.match(REG_FN_COLOR);
+		const [cs] = val.match(/[^\s,/]+/g);
+		if (cs === "srgb-linear") [, r, g, b, alpha] = resolveColorFunc(value, { format: VAL_COMP });
+		else {
+			[, x, y, z, alpha] = parseColorFunc(value);
+			[r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [
+				x,
+				y,
+				z
+			], true);
+		}
+	} else {
+		[, x, y, z, alpha] = parseColorValue(value);
+		[r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [
+			x,
+			y,
+			z
+		], true);
+	}
+	return [
+		Math.min(Math.max(r, 0), 1),
+		Math.min(Math.max(g, 0), 1),
+		Math.min(Math.max(b, 0), 1),
+		alpha
+	];
+};
+/**
+* convert color value to rgb
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels | NullObject
+*   - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
+*/
+var convertColorToRgb = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "" } = opt;
+	let r, g, b, alpha;
+	if (format === "mixValue") {
+		let rgb;
+		if (value.startsWith("color(")) rgb = resolveColorFunc(value, opt);
+		else rgb = resolveColorValue(value, opt);
+		if (rgb instanceof NullObject) return rgb;
+		[, r, g, b, alpha] = rgb;
+	} else if (value.startsWith("color(")) {
+		const [, val] = value.match(REG_FN_COLOR);
+		const [cs] = val.match(/[^\s,/]+/g);
+		if (cs === "srgb") {
+			[, r, g, b, alpha] = resolveColorFunc(value, { format: VAL_COMP });
+			r *= MAX_RGB;
+			g *= MAX_RGB;
+			b *= MAX_RGB;
+		} else [, r, g, b, alpha] = resolveColorFunc(value);
+	} else if (/^(?:ok)?l(?:ab|ch)/.test(value)) {
+		[r, g, b, alpha] = convertColorToLinearRgb(value);
+		[r, g, b] = transformLinearRgbToRgb([
+			r,
+			g,
+			b
+		]);
+	} else [, r, g, b, alpha] = resolveColorValue(value, { format: VAL_COMP });
+	return [
+		r,
+		g,
+		b,
+		alpha
+	];
+};
+/**
+* convert color value to xyz
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels | NullObject - [x, y, z, alpha]
+*/
+var convertColorToXyz = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { d50 = false, format = "" } = opt;
+	let x, y, z, alpha;
+	if (format === "mixValue") {
+		let xyz;
+		if (value.startsWith("color(")) xyz = parseColorFunc(value, opt);
+		else xyz = parseColorValue(value, opt);
+		if (xyz instanceof NullObject) return xyz;
+		[, x, y, z, alpha] = xyz;
+	} else if (value.startsWith("color(")) {
+		const [, val] = value.match(REG_FN_COLOR);
+		const [cs] = val.match(/[^\s,/]+/g);
+		if (d50) if (cs === "xyz-d50") [, x, y, z, alpha] = resolveColorFunc(value, { format: VAL_COMP });
+		else [, x, y, z, alpha] = parseColorFunc(value, opt);
+		else if (/^xyz(?:-d65)?$/.test(cs)) [, x, y, z, alpha] = resolveColorFunc(value, { format: VAL_COMP });
+		else [, x, y, z, alpha] = parseColorFunc(value);
+	} else [, x, y, z, alpha] = parseColorValue(value, opt);
+	return [
+		x,
+		y,
+		z,
+		alpha
+	];
+};
+/**
+* convert color value to hsl
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels | NullObject - [h, s, l, alpha], hue may be powerless
+*/
+var convertColorToHsl = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "" } = opt;
+	let h, s, l, alpha;
+	if (REG_HSL.test(value)) {
+		[, h, s, l, alpha] = parseHsl(value, { format: "hsl" });
+		if (format === "hsl") return [
+			Math.round(h),
+			Math.round(s),
+			Math.round(l),
+			alpha
+		];
+		return [
+			h,
+			s,
+			l,
+			alpha
+		];
+	}
+	let x, y, z;
+	if (format === "mixValue") {
+		let xyz;
+		if (value.startsWith("color(")) xyz = parseColorFunc(value, opt);
+		else xyz = parseColorValue(value, opt);
+		if (xyz instanceof NullObject) return xyz;
+		[, x, y, z, alpha] = xyz;
+	} else if (value.startsWith("color(")) [, x, y, z, alpha] = parseColorFunc(value);
+	else [, x, y, z, alpha] = parseColorValue(value);
+	[h, s, l] = transformXyzToHsl([
+		x,
+		y,
+		z
+	], true);
+	if (format === "hsl") return [
+		Math.round(h),
+		Math.round(s),
+		Math.round(l),
+		alpha
+	];
+	return [
+		format === "mixValue" && s === 0 ? NONE : h,
+		s,
+		l,
+		alpha
+	];
+};
+/**
+* convert color value to hwb
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels | NullObject - [h, w, b, alpha], hue may be powerless
+*/
+var convertColorToHwb = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "" } = opt;
+	let h, w, b, alpha;
+	if (REG_HWB.test(value)) {
+		[, h, w, b, alpha] = parseHwb(value, { format: "hwb" });
+		if (format === "hwb") return [
+			Math.round(h),
+			Math.round(w),
+			Math.round(b),
+			alpha
+		];
+		return [
+			h,
+			w,
+			b,
+			alpha
+		];
+	}
+	let x, y, z;
+	if (format === "mixValue") {
+		let xyz;
+		if (value.startsWith("color(")) xyz = parseColorFunc(value, opt);
+		else xyz = parseColorValue(value, opt);
+		if (xyz instanceof NullObject) return xyz;
+		[, x, y, z, alpha] = xyz;
+	} else if (value.startsWith("color(")) [, x, y, z, alpha] = parseColorFunc(value);
+	else [, x, y, z, alpha] = parseColorValue(value);
+	[h, w, b] = transformXyzToHwb([
+		x,
+		y,
+		z
+	], true);
+	if (format === "hwb") return [
+		Math.round(h),
+		Math.round(w),
+		Math.round(b),
+		alpha
+	];
+	return [
+		format === "mixValue" && w + b >= 100 ? NONE : h,
+		w,
+		b,
+		alpha
+	];
+};
+/**
+* convert color value to lab
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels | NullObject - [l, a, b, alpha]
+*/
+var convertColorToLab = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "" } = opt;
+	let l, a, b, alpha;
+	if (REG_LAB.test(value)) {
+		[, l, a, b, alpha] = parseLab(value, { format: VAL_COMP });
+		return [
+			l,
+			a,
+			b,
+			alpha
+		];
+	}
+	let x, y, z;
+	if (format === "mixValue") {
+		let xyz;
+		opt.d50 = true;
+		if (value.startsWith("color(")) xyz = parseColorFunc(value, opt);
+		else xyz = parseColorValue(value, opt);
+		if (xyz instanceof NullObject) return xyz;
+		[, x, y, z, alpha] = xyz;
+	} else if (value.startsWith("color(")) [, x, y, z, alpha] = parseColorFunc(value, { d50: true });
+	else [, x, y, z, alpha] = parseColorValue(value, { d50: true });
+	[l, a, b] = transformXyzD50ToLab([
+		x,
+		y,
+		z
+	], true);
+	return [
+		l,
+		a,
+		b,
+		alpha
+	];
+};
+/**
+* convert color value to lch
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless
+*/
+var convertColorToLch = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "" } = opt;
+	let l, c, h, alpha;
+	if (REG_LCH.test(value)) {
+		[, l, c, h, alpha] = parseLch(value, { format: VAL_COMP });
+		return [
+			l,
+			c,
+			h,
+			alpha
+		];
+	}
+	let x, y, z;
+	if (format === "mixValue") {
+		let xyz;
+		opt.d50 = true;
+		if (value.startsWith("color(")) xyz = parseColorFunc(value, opt);
+		else xyz = parseColorValue(value, opt);
+		if (xyz instanceof NullObject) return xyz;
+		[, x, y, z, alpha] = xyz;
+	} else if (value.startsWith("color(")) [, x, y, z, alpha] = parseColorFunc(value, { d50: true });
+	else [, x, y, z, alpha] = parseColorValue(value, { d50: true });
+	[l, c, h] = transformXyzD50ToLch([
+		x,
+		y,
+		z
+	], true);
+	return [
+		l,
+		c,
+		format === "mixValue" && c === 0 ? NONE : h,
+		alpha
+	];
+};
+/**
+* convert color value to oklab
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels | NullObject - [l, a, b, alpha]
+*/
+var convertColorToOklab = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "" } = opt;
+	let l, a, b, alpha;
+	if (REG_OKLAB.test(value)) {
+		[, l, a, b, alpha] = parseOklab(value, { format: VAL_COMP });
+		return [
+			l,
+			a,
+			b,
+			alpha
+		];
+	}
+	let x, y, z;
+	if (format === "mixValue") {
+		let xyz;
+		if (value.startsWith("color(")) xyz = parseColorFunc(value, opt);
+		else xyz = parseColorValue(value, opt);
+		if (xyz instanceof NullObject) return xyz;
+		[, x, y, z, alpha] = xyz;
+	} else if (value.startsWith("color(")) [, x, y, z, alpha] = parseColorFunc(value);
+	else [, x, y, z, alpha] = parseColorValue(value);
+	[l, a, b] = transformXyzToOklab([
+		x,
+		y,
+		z
+	], true);
+	return [
+		l,
+		a,
+		b,
+		alpha
+	];
+};
+/**
+* convert color value to oklch
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless
+*/
+var convertColorToOklch = (value, opt = {}) => {
+	if (isString(value)) value = value.trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "" } = opt;
+	let l, c, h, alpha;
+	if (REG_OKLCH.test(value)) {
+		[, l, c, h, alpha] = parseOklch(value, { format: VAL_COMP });
+		return [
+			l,
+			c,
+			h,
+			alpha
+		];
+	}
+	let x, y, z;
+	if (format === "mixValue") {
+		let xyz;
+		if (value.startsWith("color(")) xyz = parseColorFunc(value, opt);
+		else xyz = parseColorValue(value, opt);
+		if (xyz instanceof NullObject) return xyz;
+		[, x, y, z, alpha] = xyz;
+	} else if (value.startsWith("color(")) [, x, y, z, alpha] = parseColorFunc(value);
+	else [, x, y, z, alpha] = parseColorValue(value);
+	[l, c, h] = transformXyzToOklch([
+		x,
+		y,
+		z
+	], true);
+	return [
+		l,
+		c,
+		format === "mixValue" && c === 0 ? NONE : h,
+		alpha
+	];
+};
+/**
+* resolve color-mix()
+* @param value - color-mix color value
+* @param [opt] - options
+* @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)'
+*/
+var resolveColorMix = (value, opt = {}) => {
+	if (isString(value)) value = value.toLowerCase().trim();
+	else throw new TypeError(`${value} is not a string.`);
+	const { format = "", nullable = false } = opt;
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "resolveColorMix",
+		value
+	}, opt);
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) {
+		if (cachedResult.isNull) return cachedResult;
+		const cachedItem = cachedResult.item;
+		if (isString(cachedItem)) return cachedItem;
+		return cachedItem;
+	}
+	const nestedItems = [];
+	let colorSpace = "";
+	let hueArc = "";
+	let colorA = "";
+	let pctA = "";
+	let colorB = "";
+	let pctB = "";
+	let parsed = false;
+	if (!REG_MIX.test(value)) if (value.startsWith("color-mix(") && REG_MIX_NEST.test(value)) {
+		const items = value.match(REG_MIX_NEST);
+		for (const item of items) if (item) {
+			let val = resolveColorMix(item, { format: format === "specifiedValue" ? format : VAL_COMP });
+			if (Array.isArray(val)) {
+				const [cs, v1, v2, v3, v4] = val;
+				if (v1 === 0 && v2 === 0 && v3 === 0 && v4 === 0) {
+					value = "";
+					break;
+				}
+				if (REG_MIX_CS_RGB_XYZ.test(cs)) if (v4 === 1) val = `color(${cs} ${v1} ${v2} ${v3})`;
+				else val = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
+				else if (v4 === 1) val = `${cs}(${v1} ${v2} ${v3})`;
+				else val = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
+			} else if (!REG_MIX.test(val)) {
+				value = "";
+				break;
+			}
+			nestedItems.push(val);
+			value = value.replace(item, val);
+		}
+		if (!value) return cacheInvalidColorValue(cacheKey, format, nullable);
+	} else if (value.startsWith("color-mix(") && value.endsWith(")") && value.includes("light-dark(")) {
+		const [csPart = "", partA = "", partB = ""] = splitValue(value.replace(FN_MIX, "").replace(/\)$/, ""), { delimiter: "," });
+		const [colorPartA = "", pctPartA = ""] = splitValue(partA);
+		const [colorPartB = "", pctPartB = ""] = splitValue(partB);
+		const specifiedColorA = resolveColor(colorPartA, { format: VAL_SPEC });
+		const specifiedColorB = resolveColor(colorPartB, { format: VAL_SPEC });
+		if (REG_MIX_IN_CS.test(csPart) && specifiedColorA && specifiedColorB) if (format === "specifiedValue") {
+			const [, cs] = csPart.match(REG_MIX_IN_CS);
+			if (REG_CS_HUE.test(cs)) [, colorSpace, hueArc] = cs.match(REG_CS_HUE);
+			else colorSpace = cs;
+			colorA = specifiedColorA;
+			if (pctPartA) pctA = pctPartA;
+			colorB = specifiedColorB;
+			if (pctPartB) pctB = pctPartB;
+			value = value.replace(colorPartA, specifiedColorA).replace(colorPartB, specifiedColorB);
+			parsed = true;
+		} else {
+			const resolvedColorA = resolveColor(colorPartA, opt);
+			const resolvedColorB = resolveColor(colorPartB, opt);
+			if (isString(resolvedColorA) && isString(resolvedColorB)) value = value.replace(colorPartA, resolvedColorA).replace(colorPartB, resolvedColorB);
+		}
+		else return cacheInvalidColorValue(cacheKey, format, nullable);
+	} else return cacheInvalidColorValue(cacheKey, format, nullable);
+	if (nestedItems.length && format === "specifiedValue") {
+		const [, cs] = value.match(REG_MIX_START);
+		if (REG_CS_HUE.test(cs)) [, colorSpace, hueArc] = cs.match(REG_CS_HUE);
+		else colorSpace = cs;
+		if (nestedItems.length === 2) {
+			let [itemA, itemB] = nestedItems;
+			itemA = itemA.replace(/(?=[()])/g, "\\");
+			itemB = itemB.replace(/(?=[()])/g, "\\");
+			const regA = new RegExp(`(${itemA})(?:\\s+(${PCT}))?`);
+			const regB = new RegExp(`(${itemB})(?:\\s+(${PCT}))?`);
+			[, colorA, pctA] = value.match(regA);
+			[, colorB, pctB] = value.match(regB);
+		} else {
+			let [item] = nestedItems;
+			item = item.replace(/(?=[()])/g, "\\");
+			const itemPart = `${item}(?:\\s+${PCT})?`;
+			const itemPartCapt = `(${item})(?:\\s+(${PCT}))?`;
+			const regItemPart = new RegExp(`^${itemPartCapt}$`);
+			if (new RegExp(`${itemPartCapt}\\s*\\)$`).test(value)) {
+				const reg = new RegExp(`(${SYN_MIX_PART})\\s*,\\s*(${itemPart})\\s*\\)$`);
+				const [, colorPartA, colorPartB] = value.match(reg);
+				[, colorA, pctA] = colorPartA.match(REG_MIX_COLOR_PART);
+				[, colorB, pctB] = colorPartB.match(regItemPart);
+			} else {
+				const reg = new RegExp(`(${itemPart})\\s*,\\s*(${SYN_MIX_PART})\\s*\\)$`);
+				const [, colorPartA, colorPartB] = value.match(reg);
+				[, colorA, pctA] = colorPartA.match(regItemPart);
+				[, colorB, pctB] = colorPartB.match(REG_MIX_COLOR_PART);
+			}
+		}
+	} else if (!parsed) {
+		const [, cs, colorPartA, colorPartB] = value.match(REG_MIX_CAPT);
+		[, colorA, pctA] = colorPartA.match(REG_MIX_COLOR_PART);
+		[, colorB, pctB] = colorPartB.match(REG_MIX_COLOR_PART);
+		if (REG_CS_HUE.test(cs)) [, colorSpace, hueArc] = cs.match(REG_CS_HUE);
+		else colorSpace = cs;
+	}
+	let pA, pB, m;
+	if (pctA && pctB) {
+		const p1 = parseFloat(pctA) / MAX_PCT;
+		const p2 = parseFloat(pctB) / MAX_PCT;
+		if (p1 < 0 || p1 > 1 || p2 < 0 || p2 > 1 || p1 === 0 && p2 === 0) return cacheInvalidColorValue(cacheKey, format, nullable);
+		const factor = p1 + p2;
+		pA = p1 / factor;
+		pB = p2 / factor;
+		m = factor < 1 ? factor : 1;
+	} else {
+		if (pctA) {
+			pA = parseFloat(pctA) / MAX_PCT;
+			if (pA < 0 || pA > 1) return cacheInvalidColorValue(cacheKey, format, nullable);
+			pB = 1 - pA;
+		} else if (pctB) {
+			pB = parseFloat(pctB) / MAX_PCT;
+			if (pB < 0 || pB > 1) return cacheInvalidColorValue(cacheKey, format, nullable);
+			pA = 1 - pB;
+		} else {
+			pA = HALF;
+			pB = HALF;
+		}
+		m = 1;
+	}
+	if (colorSpace === "xyz") colorSpace = "xyz-d65";
+	if (format === "specifiedValue") {
+		let valueA = "";
+		let valueB = "";
+		if (colorA.startsWith("color-mix(") || colorA.startsWith("light-dark(")) valueA = colorA;
+		else if (colorA.startsWith("color(")) {
+			const [cs, v1, v2, v3, v4] = parseColorFunc(colorA, opt);
+			if (v4 === 1) valueA = `color(${cs} ${v1} ${v2} ${v3})`;
+			else valueA = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
+		} else {
+			const val = parseColorValue(colorA, opt);
+			if (Array.isArray(val)) {
+				const [cs, v1, v2, v3, v4] = val;
+				if (v4 === 1) if (cs === "rgb") valueA = `${cs}(${v1}, ${v2}, ${v3})`;
+				else valueA = `${cs}(${v1} ${v2} ${v3})`;
+				else if (cs === "rgb") valueA = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;
+				else valueA = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
+			} else {
+				if (!isString(val) || !val) {
+					setCache(cacheKey, "");
+					return "";
+				}
+				valueA = val;
+			}
+		}
+		if (colorB.startsWith("color-mix(") || colorB.startsWith("light-dark(")) valueB = colorB;
+		else if (colorB.startsWith("color(")) {
+			const [cs, v1, v2, v3, v4] = parseColorFunc(colorB, opt);
+			if (v4 === 1) valueB = `color(${cs} ${v1} ${v2} ${v3})`;
+			else valueB = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
+		} else {
+			const val = parseColorValue(colorB, opt);
+			if (Array.isArray(val)) {
+				const [cs, v1, v2, v3, v4] = val;
+				if (v4 === 1) if (cs === "rgb") valueB = `${cs}(${v1}, ${v2}, ${v3})`;
+				else valueB = `${cs}(${v1} ${v2} ${v3})`;
+				else if (cs === "rgb") valueB = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;
+				else valueB = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
+			} else {
+				if (!isString(val) || !val) {
+					setCache(cacheKey, "");
+					return "";
+				}
+				valueB = val;
+			}
+		}
+		if (pctA && pctB) {
+			valueA += ` ${parseFloat(pctA)}%`;
+			valueB += ` ${parseFloat(pctB)}%`;
+		} else if (pctA) {
+			const pA = parseFloat(pctA);
+			if (pA !== MAX_PCT * HALF) valueA += ` ${pA}%`;
+		} else if (pctB) {
+			const pA = MAX_PCT - parseFloat(pctB);
+			if (pA !== MAX_PCT * HALF) valueA += ` ${pA}%`;
+		}
+		if (hueArc) {
+			const res = `color-mix(in ${colorSpace} ${hueArc} hue, ${valueA}, ${valueB})`;
+			setCache(cacheKey, res);
+			return res;
+		} else {
+			const res = `color-mix(in ${colorSpace}, ${valueA}, ${valueB})`;
+			setCache(cacheKey, res);
+			return res;
+		}
+	}
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	let alpha = 0;
+	if (/^srgb(?:-linear)?$/.test(colorSpace)) {
+		let rgbA, rgbB;
+		if (colorSpace === "srgb") {
+			if (REG_CURRENT.test(colorA)) rgbA = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else rgbA = convertColorToRgb(colorA, {
+				colorSpace,
+				format: VAL_MIX
+			});
+			if (REG_CURRENT.test(colorB)) rgbB = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else rgbB = convertColorToRgb(colorB, {
+				colorSpace,
+				format: VAL_MIX
+			});
+		} else {
+			if (REG_CURRENT.test(colorA)) rgbA = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else rgbA = convertColorToLinearRgb(colorA, {
+				colorSpace,
+				format: VAL_MIX
+			});
+			if (REG_CURRENT.test(colorB)) rgbB = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else rgbB = convertColorToLinearRgb(colorB, {
+				colorSpace,
+				format: VAL_MIX
+			});
+		}
+		if (rgbA instanceof NullObject || rgbB instanceof NullObject) return cacheInvalidColorValue(cacheKey, format, nullable);
+		const [rrA, ggA, bbA, aaA] = rgbA;
+		const [rrB, ggB, bbB, aaB] = rgbB;
+		const rNone = rrA === "none" && rrB === "none";
+		const gNone = ggA === "none" && ggB === "none";
+		const bNone = bbA === "none" && bbB === "none";
+		const alphaNone = aaA === "none" && aaB === "none";
+		const [[rA, gA, bA, alphaA], [rB, gB, bB, alphaB]] = normalizeColorComponents([
+			rrA,
+			ggA,
+			bbA,
+			aaA
+		], [
+			rrB,
+			ggB,
+			bbB,
+			aaB
+		], true);
+		const factorA = alphaA * pA;
+		const factorB = alphaB * pB;
+		alpha = factorA + factorB;
+		if (alpha === 0) {
+			r = rA * pA + rB * pB;
+			g = gA * pA + gB * pB;
+			b = bA * pA + bB * pB;
+		} else {
+			r = (rA * factorA + rB * factorB) / alpha;
+			g = (gA * factorA + gB * factorB) / alpha;
+			b = (bA * factorA + bB * factorB) / alpha;
+			alpha = parseFloat(alpha.toFixed(3));
+		}
+		if (format === "computedValue") {
+			const res = [
+				colorSpace,
+				rNone ? NONE : roundToPrecision(r, HEX),
+				gNone ? NONE : roundToPrecision(g, HEX),
+				bNone ? NONE : roundToPrecision(b, HEX),
+				alphaNone ? NONE : alpha * m
+			];
+			setCache(cacheKey, res);
+			return res;
+		}
+		r *= MAX_RGB;
+		g *= MAX_RGB;
+		b *= MAX_RGB;
+	} else if (REG_CS_XYZ.test(colorSpace)) {
+		let xyzA, xyzB;
+		if (REG_CURRENT.test(colorA)) xyzA = [
+			NONE,
+			NONE,
+			NONE,
+			NONE
+		];
+		else xyzA = convertColorToXyz(colorA, {
+			colorSpace,
+			d50: colorSpace === "xyz-d50",
+			format: VAL_MIX
+		});
+		if (REG_CURRENT.test(colorB)) xyzB = [
+			NONE,
+			NONE,
+			NONE,
+			NONE
+		];
+		else xyzB = convertColorToXyz(colorB, {
+			colorSpace,
+			d50: colorSpace === "xyz-d50",
+			format: VAL_MIX
+		});
+		if (xyzA instanceof NullObject || xyzB instanceof NullObject) return cacheInvalidColorValue(cacheKey, format, nullable);
+		const [xxA, yyA, zzA, aaA] = xyzA;
+		const [xxB, yyB, zzB, aaB] = xyzB;
+		const xNone = xxA === "none" && xxB === "none";
+		const yNone = yyA === "none" && yyB === "none";
+		const zNone = zzA === "none" && zzB === "none";
+		const alphaNone = aaA === "none" && aaB === "none";
+		const [[xA, yA, zA, alphaA], [xB, yB, zB, alphaB]] = normalizeColorComponents([
+			xxA,
+			yyA,
+			zzA,
+			aaA
+		], [
+			xxB,
+			yyB,
+			zzB,
+			aaB
+		], true);
+		const factorA = alphaA * pA;
+		const factorB = alphaB * pB;
+		alpha = factorA + factorB;
+		let x, y, z;
+		if (alpha === 0) {
+			x = xA * pA + xB * pB;
+			y = yA * pA + yB * pB;
+			z = zA * pA + zB * pB;
+		} else {
+			x = (xA * factorA + xB * factorB) / alpha;
+			y = (yA * factorA + yB * factorB) / alpha;
+			z = (zA * factorA + zB * factorB) / alpha;
+			alpha = parseFloat(alpha.toFixed(3));
+		}
+		if (format === "computedValue") {
+			const res = [
+				colorSpace,
+				xNone ? NONE : roundToPrecision(x, HEX),
+				yNone ? NONE : roundToPrecision(y, HEX),
+				zNone ? NONE : roundToPrecision(z, HEX),
+				alphaNone ? NONE : alpha * m
+			];
+			setCache(cacheKey, res);
+			return res;
+		}
+		if (colorSpace === "xyz-d50") [r, g, b] = transformXyzD50ToRgb([
+			x,
+			y,
+			z
+		], true);
+		else [r, g, b] = transformXyzToRgb([
+			x,
+			y,
+			z
+		], true);
+	} else if (/^h(?:sl|wb)$/.test(colorSpace)) {
+		let hslA, hslB;
+		if (colorSpace === "hsl") {
+			if (REG_CURRENT.test(colorA)) hslA = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else hslA = convertColorToHsl(colorA, {
+				colorSpace,
+				format: VAL_MIX
+			});
+			if (REG_CURRENT.test(colorB)) hslB = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else hslB = convertColorToHsl(colorB, {
+				colorSpace,
+				format: VAL_MIX
+			});
+		} else {
+			if (REG_CURRENT.test(colorA)) hslA = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else hslA = convertColorToHwb(colorA, {
+				colorSpace,
+				format: VAL_MIX
+			});
+			if (REG_CURRENT.test(colorB)) hslB = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else hslB = convertColorToHwb(colorB, {
+				colorSpace,
+				format: VAL_MIX
+			});
+		}
+		if (hslA instanceof NullObject || hslB instanceof NullObject) return cacheInvalidColorValue(cacheKey, format, nullable);
+		const [hhA, ssA, llA, aaA] = hslA;
+		const [hhB, ssB, llB, aaB] = hslB;
+		const alphaNone = aaA === "none" && aaB === "none";
+		let [[hA, sA, lA, alphaA], [hB, sB, lB, alphaB]] = normalizeColorComponents([
+			hhA,
+			ssA,
+			llA,
+			aaA
+		], [
+			hhB,
+			ssB,
+			llB,
+			aaB
+		], true);
+		if (hueArc) [hA, hB] = interpolateHue(hA, hB, hueArc);
+		const factorA = alphaA * pA;
+		const factorB = alphaB * pB;
+		alpha = factorA + factorB;
+		const h = (hA * pA + hB * pB) % DEG;
+		let s, l;
+		if (alpha === 0) {
+			s = sA * pA + sB * pB;
+			l = lA * pA + lB * pB;
+		} else {
+			s = (sA * factorA + sB * factorB) / alpha;
+			l = (lA * factorA + lB * factorB) / alpha;
+			alpha = parseFloat(alpha.toFixed(3));
+		}
+		[r, g, b] = convertColorToRgb(`${colorSpace}(${h} ${s} ${l})`);
+		if (format === "computedValue") {
+			const res = [
+				"srgb",
+				roundToPrecision(r / MAX_RGB, HEX),
+				roundToPrecision(g / MAX_RGB, HEX),
+				roundToPrecision(b / MAX_RGB, HEX),
+				alphaNone ? NONE : alpha * m
+			];
+			setCache(cacheKey, res);
+			return res;
+		}
+	} else if (/^(?:ok)?lch$/.test(colorSpace)) {
+		let lchA, lchB;
+		if (colorSpace === "lch") {
+			if (REG_CURRENT.test(colorA)) lchA = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else lchA = convertColorToLch(colorA, {
+				colorSpace,
+				format: VAL_MIX
+			});
+			if (REG_CURRENT.test(colorB)) lchB = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else lchB = convertColorToLch(colorB, {
+				colorSpace,
+				format: VAL_MIX
+			});
+		} else {
+			if (REG_CURRENT.test(colorA)) lchA = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else lchA = convertColorToOklch(colorA, {
+				colorSpace,
+				format: VAL_MIX
+			});
+			if (REG_CURRENT.test(colorB)) lchB = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else lchB = convertColorToOklch(colorB, {
+				colorSpace,
+				format: VAL_MIX
+			});
+		}
+		if (lchA instanceof NullObject || lchB instanceof NullObject) return cacheInvalidColorValue(cacheKey, format, nullable);
+		const [llA, ccA, hhA, aaA] = lchA;
+		const [llB, ccB, hhB, aaB] = lchB;
+		const lNone = llA === "none" && llB === "none";
+		const cNone = ccA === "none" && ccB === "none";
+		const hNone = hhA === "none" && hhB === "none";
+		const alphaNone = aaA === "none" && aaB === "none";
+		let [[lA, cA, hA, alphaA], [lB, cB, hB, alphaB]] = normalizeColorComponents([
+			llA,
+			ccA,
+			hhA,
+			aaA
+		], [
+			llB,
+			ccB,
+			hhB,
+			aaB
+		], true);
+		if (hueArc) [hA, hB] = interpolateHue(hA, hB, hueArc);
+		const factorA = alphaA * pA;
+		const factorB = alphaB * pB;
+		alpha = factorA + factorB;
+		const h = (hA * pA + hB * pB) % DEG;
+		let l, c;
+		if (alpha === 0) {
+			l = lA * pA + lB * pB;
+			c = cA * pA + cB * pB;
+		} else {
+			l = (lA * factorA + lB * factorB) / alpha;
+			c = (cA * factorA + cB * factorB) / alpha;
+			alpha = parseFloat(alpha.toFixed(3));
+		}
+		if (format === "computedValue") {
+			const res = [
+				colorSpace,
+				lNone ? NONE : roundToPrecision(l, HEX),
+				cNone ? NONE : roundToPrecision(c, HEX),
+				hNone ? NONE : roundToPrecision(h, HEX),
+				alphaNone ? NONE : alpha * m
+			];
+			setCache(cacheKey, res);
+			return res;
+		}
+		[, r, g, b] = resolveColorValue(`${colorSpace}(${l} ${c} ${h})`);
+	} else {
+		let labA, labB;
+		if (colorSpace === "lab") {
+			if (REG_CURRENT.test(colorA)) labA = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else labA = convertColorToLab(colorA, {
+				colorSpace,
+				format: VAL_MIX
+			});
+			if (REG_CURRENT.test(colorB)) labB = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else labB = convertColorToLab(colorB, {
+				colorSpace,
+				format: VAL_MIX
+			});
+		} else {
+			if (REG_CURRENT.test(colorA)) labA = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else labA = convertColorToOklab(colorA, {
+				colorSpace,
+				format: VAL_MIX
+			});
+			if (REG_CURRENT.test(colorB)) labB = [
+				NONE,
+				NONE,
+				NONE,
+				NONE
+			];
+			else labB = convertColorToOklab(colorB, {
+				colorSpace,
+				format: VAL_MIX
+			});
+		}
+		if (labA instanceof NullObject || labB instanceof NullObject) return cacheInvalidColorValue(cacheKey, format, nullable);
+		const [llA, aaA, bbA, alA] = labA;
+		const [llB, aaB, bbB, alB] = labB;
+		const lNone = llA === "none" && llB === "none";
+		const aNone = aaA === "none" && aaB === "none";
+		const bNone = bbA === "none" && bbB === "none";
+		const alphaNone = alA === "none" && alB === "none";
+		const [[lA, aA, bA, alphaA], [lB, aB, bB, alphaB]] = normalizeColorComponents([
+			llA,
+			aaA,
+			bbA,
+			alA
+		], [
+			llB,
+			aaB,
+			bbB,
+			alB
+		], true);
+		const factorA = alphaA * pA;
+		const factorB = alphaB * pB;
+		alpha = factorA + factorB;
+		let l, aO, bO;
+		if (alpha === 0) {
+			l = lA * pA + lB * pB;
+			aO = aA * pA + aB * pB;
+			bO = bA * pA + bB * pB;
+		} else {
+			l = (lA * factorA + lB * factorB) / alpha;
+			aO = (aA * factorA + aB * factorB) / alpha;
+			bO = (bA * factorA + bB * factorB) / alpha;
+			alpha = parseFloat(alpha.toFixed(3));
+		}
+		if (format === "computedValue") {
+			const res = [
+				colorSpace,
+				lNone ? NONE : roundToPrecision(l, HEX),
+				aNone ? NONE : roundToPrecision(aO, HEX),
+				bNone ? NONE : roundToPrecision(bO, HEX),
+				alphaNone ? NONE : alpha * m
+			];
+			setCache(cacheKey, res);
+			return res;
+		}
+		[, r, g, b] = resolveColorValue(`${colorSpace}(${l} ${aO} ${bO})`);
+	}
+	const res = [
+		"rgb",
+		Math.round(r),
+		Math.round(g),
+		Math.round(b),
+		parseFloat((alpha * m).toFixed(3))
+	];
+	setCache(cacheKey, res);
+	return res;
+};
+//#endregion
+export { NAMED_COLORS, convertColorToHsl, convertColorToHwb, convertColorToLab, convertColorToLch, convertColorToOklab, convertColorToOklch, convertColorToRgb, convertRgbToHex, numberToHexString, parseColorFunc, parseColorValue, resolveColorFunc, resolveColorMix, resolveColorValue };
+
+//# sourceMappingURL=color.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/color.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/js/color.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..40a1df05ad86b897e6a9f81598086f45679b8e51
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/color.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"color.js","names":[],"sources":["../../../src/js/color.ts"],"sourcesContent":["/**\n * color\n *\n * Ref: CSS Color Module Level 4\n *      Sample code for Color Conversions\n *      https://w3c.github.io/csswg-drafts/css-color-4/#color-conversion-code\n */\n\nimport {\n  CacheItem,\n  NullObject,\n  createCacheKey,\n  getCache,\n  setCache\n} from './cache';\nimport { isString } from './common';\nimport { resolveColor } from './resolve';\nimport { interpolateHue, roundToPrecision, splitValue } from './util';\nimport {\n  ColorChannels,\n  ComputedColorChannels,\n  Options,\n  MatchedRegExp,\n  SpecifiedColorChannels,\n  StringColorChannels,\n  StringColorSpacedChannels\n} from './typedef';\n\n/* constants */\nimport {\n  ANGLE,\n  CS_HUE_CAPT,\n  CS_MIX,\n  CS_RGB,\n  CS_XYZ,\n  FN_COLOR,\n  FN_LIGHT_DARK,\n  FN_MIX,\n  NONE,\n  NUM,\n  PCT,\n  SYN_COLOR_TYPE,\n  SYN_FN_COLOR,\n  SYN_HSL,\n  SYN_HSL_LV3,\n  SYN_LCH,\n  SYN_MIX,\n  SYN_MIX_CAPT,\n  SYN_MIX_PART,\n  SYN_MOD,\n  SYN_RGB_LV3,\n  VAL_COMP,\n  VAL_MIX,\n  VAL_SPEC\n} from './constant';\nconst NAMESPACE = 'color';\n\n/* numeric constants */\nconst PPTH = 0.001;\nconst HALF = 0.5;\nconst DUO = 2;\nconst TRIA = 3;\nconst QUAD = 4;\nconst OCT = 8;\nconst DEC = 10;\nconst DOZ = 12;\nconst HEX = 16;\nconst SEXA = 60;\nconst DEG_HALF = 180;\nconst DEG = 360;\nconst MAX_PCT = 100;\nconst MAX_RGB = 255;\nconst POW_SQR = 2;\nconst POW_CUBE = 3;\nconst POW_LINEAR = 2.4;\nconst LINEAR_COEF = 12.92;\nconst LINEAR_OFFSET = 0.055;\nconst LAB_L = 116;\nconst LAB_A = 500;\nconst LAB_B = 200;\nconst LAB_EPSILON = 216 / 24389;\nconst LAB_KAPPA = 24389 / 27;\n\n/* type definitions */\n/**\n * @type NumStrColorChannels - string or numeric color channels\n */\ntype NumStrColorChannels = [\n  x: number | string,\n  y: number | string,\n  z: number | string,\n  alpha: number | string\n];\n\n/**\n * @type TriColorChannels - color channels without alpha\n */\ntype TriColorChannels = [x: number, y: number, z: number];\n\n/**\n * @type ColorMatrix - color matrix\n */\ntype ColorMatrix = [\n  r1: TriColorChannels,\n  r2: TriColorChannels,\n  r3: TriColorChannels\n];\n\n/* white point */\nconst D50: TriColorChannels = [\n  0.3457 / 0.3585,\n  1.0,\n  (1.0 - 0.3457 - 0.3585) / 0.3585\n];\nconst MATRIX_D50_TO_D65: ColorMatrix = [\n  [0.955473421488075, -0.02309845494876471, 0.06325924320057072],\n  [-0.0283697093338637, 1.0099953980813041, 0.021041441191917323],\n  [0.012314014864481998, -0.020507649298898964, 1.330365926242124]\n];\nconst MATRIX_D65_TO_D50: ColorMatrix = [\n  [1.0479297925449969, 0.022946870601609652, -0.05019226628920524],\n  [0.02962780877005599, 0.9904344267538799, -0.017073799063418826],\n  [-0.009243040646204504, 0.015055191490298152, 0.7518742814281371]\n];\n\n/* color space */\nconst MATRIX_L_RGB_TO_XYZ: ColorMatrix = [\n  [506752 / 1228815, 87881 / 245763, 12673 / 70218],\n  [87098 / 409605, 175762 / 245763, 12673 / 175545],\n  [7918 / 409605, 87881 / 737289, 1001167 / 1053270]\n];\nconst MATRIX_XYZ_TO_L_RGB: ColorMatrix = [\n  [12831 / 3959, -329 / 214, -1974 / 3959],\n  [-851781 / 878810, 1648619 / 878810, 36519 / 878810],\n  [705 / 12673, -2585 / 12673, 705 / 667]\n];\nconst MATRIX_XYZ_TO_LMS: ColorMatrix = [\n  [0.819022437996703, 0.3619062600528904, -0.1288737815209879],\n  [0.0329836539323885, 0.9292868615863434, 0.0361446663506424],\n  [0.0481771893596242, 0.2642395317527308, 0.6335478284694309]\n];\nconst MATRIX_LMS_TO_XYZ: ColorMatrix = [\n  [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],\n  [-0.0405757452148008, 1.112286803280317, -0.0717110580655164],\n  [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816]\n];\nconst MATRIX_OKLAB_TO_LMS: ColorMatrix = [\n  [1.0, 0.3963377773761749, 0.2158037573099136],\n  [1.0, -0.1055613458156586, -0.0638541728258133],\n  [1.0, -0.0894841775298119, -1.2914855480194092]\n];\nconst MATRIX_LMS_TO_OKLAB: ColorMatrix = [\n  [0.210454268309314, 0.7936177747023054, -0.0040720430116193],\n  [1.9779985324311684, -2.4285922420485799, 0.450593709617411],\n  [0.0259040424655478, 0.7827717124575296, -0.8086757549230774]\n];\nconst MATRIX_P3_TO_XYZ: ColorMatrix = [\n  [608311 / 1250200, 189793 / 714400, 198249 / 1000160],\n  [35783 / 156275, 247089 / 357200, 198249 / 2500400],\n  [0 / 1, 32229 / 714400, 5220557 / 5000800]\n];\nconst MATRIX_REC2020_TO_XYZ: ColorMatrix = [\n  [63426534 / 99577255, 20160776 / 139408157, 47086771 / 278816314],\n  [26158966 / 99577255, 472592308 / 697040785, 8267143 / 139408157],\n  [0 / 1, 19567812 / 697040785, 295819943 / 278816314]\n];\nconst MATRIX_A98_TO_XYZ: ColorMatrix = [\n  [573536 / 994567, 263643 / 1420810, 187206 / 994567],\n  [591459 / 1989134, 6239551 / 9945670, 374412 / 4972835],\n  [53769 / 1989134, 351524 / 4972835, 4929758 / 4972835]\n];\nconst MATRIX_PROPHOTO_TO_XYZ_D50: ColorMatrix = [\n  [0.7977666449006423, 0.13518129740053308, 0.0313477341283922],\n  [0.2880748288194013, 0.711835234241873, 0.00008993693872564],\n  [0.0, 0.0, 0.8251046025104602]\n];\n\n/* regexp */\nconst REG_COLOR = new RegExp(`^(?:${SYN_COLOR_TYPE})$`);\nconst REG_CS_HUE = new RegExp(`^${CS_HUE_CAPT}$`);\nconst REG_CS_XYZ = /^xyz(?:-d(?:50|65))?$/;\nconst REG_CURRENT = /^currentColor$/i;\nconst REG_FN_COLOR = new RegExp(`^color\\\\(\\\\s*(${SYN_FN_COLOR})\\\\s*\\\\)$`);\nconst REG_HSL = new RegExp(`^hsla?\\\\(\\\\s*(${SYN_HSL}|${SYN_HSL_LV3})\\\\s*\\\\)$`);\nconst REG_HWB = new RegExp(`^hwb\\\\(\\\\s*(${SYN_HSL})\\\\s*\\\\)$`);\nconst REG_LAB = new RegExp(`^lab\\\\(\\\\s*(${SYN_MOD})\\\\s*\\\\)$`);\nconst REG_LCH = new RegExp(`^lch\\\\(\\\\s*(${SYN_LCH})\\\\s*\\\\)$`);\nconst REG_MIX = new RegExp(`^${SYN_MIX}$`);\nconst REG_MIX_CAPT = new RegExp(`^${SYN_MIX_CAPT}$`);\nconst REG_MIX_NEST = new RegExp(`${SYN_MIX}`, 'g');\nconst REG_OKLAB = new RegExp(`^oklab\\\\(\\\\s*(${SYN_MOD})\\\\s*\\\\)$`);\nconst REG_OKLCH = new RegExp(`^oklch\\\\(\\\\s*(${SYN_LCH})\\\\s*\\\\)$`);\nconst REG_SPEC = /^(?:specifi|comput)edValue$/;\nconst REG_ANGLE_TO_DEG = new RegExp(`^(${NUM})(${ANGLE})?$`);\nconst REG_PARSE_RGB = new RegExp(\n  `^rgba?\\\\(\\\\s*(${SYN_MOD}|${SYN_RGB_LV3})\\\\s*\\\\)$`\n);\nconst REG_MIX_CS_RGB_XYZ = new RegExp(`^(?:${CS_RGB}|${CS_XYZ})$`);\nconst REG_MIX_IN_CS = new RegExp(`in\\\\s+(${CS_MIX})`);\nconst REG_MIX_START = new RegExp(`^color-mix\\\\(\\\\s*in\\\\s+(${CS_MIX})\\\\s*,`);\nconst REG_MIX_COLOR_PART = new RegExp(`^(${SYN_COLOR_TYPE})(?:\\\\s+(${PCT}))?$`);\n\n/**\n * named colors\n */\nexport const NAMED_COLORS = {\n  aliceblue: [0xf0, 0xf8, 0xff],\n  antiquewhite: [0xfa, 0xeb, 0xd7],\n  aqua: [0x00, 0xff, 0xff],\n  aquamarine: [0x7f, 0xff, 0xd4],\n  azure: [0xf0, 0xff, 0xff],\n  beige: [0xf5, 0xf5, 0xdc],\n  bisque: [0xff, 0xe4, 0xc4],\n  black: [0x00, 0x00, 0x00],\n  blanchedalmond: [0xff, 0xeb, 0xcd],\n  blue: [0x00, 0x00, 0xff],\n  blueviolet: [0x8a, 0x2b, 0xe2],\n  brown: [0xa5, 0x2a, 0x2a],\n  burlywood: [0xde, 0xb8, 0x87],\n  cadetblue: [0x5f, 0x9e, 0xa0],\n  chartreuse: [0x7f, 0xff, 0x00],\n  chocolate: [0xd2, 0x69, 0x1e],\n  coral: [0xff, 0x7f, 0x50],\n  cornflowerblue: [0x64, 0x95, 0xed],\n  cornsilk: [0xff, 0xf8, 0xdc],\n  crimson: [0xdc, 0x14, 0x3c],\n  cyan: [0x00, 0xff, 0xff],\n  darkblue: [0x00, 0x00, 0x8b],\n  darkcyan: [0x00, 0x8b, 0x8b],\n  darkgoldenrod: [0xb8, 0x86, 0x0b],\n  darkgray: [0xa9, 0xa9, 0xa9],\n  darkgreen: [0x00, 0x64, 0x00],\n  darkgrey: [0xa9, 0xa9, 0xa9],\n  darkkhaki: [0xbd, 0xb7, 0x6b],\n  darkmagenta: [0x8b, 0x00, 0x8b],\n  darkolivegreen: [0x55, 0x6b, 0x2f],\n  darkorange: [0xff, 0x8c, 0x00],\n  darkorchid: [0x99, 0x32, 0xcc],\n  darkred: [0x8b, 0x00, 0x00],\n  darksalmon: [0xe9, 0x96, 0x7a],\n  darkseagreen: [0x8f, 0xbc, 0x8f],\n  darkslateblue: [0x48, 0x3d, 0x8b],\n  darkslategray: [0x2f, 0x4f, 0x4f],\n  darkslategrey: [0x2f, 0x4f, 0x4f],\n  darkturquoise: [0x00, 0xce, 0xd1],\n  darkviolet: [0x94, 0x00, 0xd3],\n  deeppink: [0xff, 0x14, 0x93],\n  deepskyblue: [0x00, 0xbf, 0xff],\n  dimgray: [0x69, 0x69, 0x69],\n  dimgrey: [0x69, 0x69, 0x69],\n  dodgerblue: [0x1e, 0x90, 0xff],\n  firebrick: [0xb2, 0x22, 0x22],\n  floralwhite: [0xff, 0xfa, 0xf0],\n  forestgreen: [0x22, 0x8b, 0x22],\n  fuchsia: [0xff, 0x00, 0xff],\n  gainsboro: [0xdc, 0xdc, 0xdc],\n  ghostwhite: [0xf8, 0xf8, 0xff],\n  gold: [0xff, 0xd7, 0x00],\n  goldenrod: [0xda, 0xa5, 0x20],\n  gray: [0x80, 0x80, 0x80],\n  green: [0x00, 0x80, 0x00],\n  greenyellow: [0xad, 0xff, 0x2f],\n  grey: [0x80, 0x80, 0x80],\n  honeydew: [0xf0, 0xff, 0xf0],\n  hotpink: [0xff, 0x69, 0xb4],\n  indianred: [0xcd, 0x5c, 0x5c],\n  indigo: [0x4b, 0x00, 0x82],\n  ivory: [0xff, 0xff, 0xf0],\n  khaki: [0xf0, 0xe6, 0x8c],\n  lavender: [0xe6, 0xe6, 0xfa],\n  lavenderblush: [0xff, 0xf0, 0xf5],\n  lawngreen: [0x7c, 0xfc, 0x00],\n  lemonchiffon: [0xff, 0xfa, 0xcd],\n  lightblue: [0xad, 0xd8, 0xe6],\n  lightcoral: [0xf0, 0x80, 0x80],\n  lightcyan: [0xe0, 0xff, 0xff],\n  lightgoldenrodyellow: [0xfa, 0xfa, 0xd2],\n  lightgray: [0xd3, 0xd3, 0xd3],\n  lightgreen: [0x90, 0xee, 0x90],\n  lightgrey: [0xd3, 0xd3, 0xd3],\n  lightpink: [0xff, 0xb6, 0xc1],\n  lightsalmon: [0xff, 0xa0, 0x7a],\n  lightseagreen: [0x20, 0xb2, 0xaa],\n  lightskyblue: [0x87, 0xce, 0xfa],\n  lightslategray: [0x77, 0x88, 0x99],\n  lightslategrey: [0x77, 0x88, 0x99],\n  lightsteelblue: [0xb0, 0xc4, 0xde],\n  lightyellow: [0xff, 0xff, 0xe0],\n  lime: [0x00, 0xff, 0x00],\n  limegreen: [0x32, 0xcd, 0x32],\n  linen: [0xfa, 0xf0, 0xe6],\n  magenta: [0xff, 0x00, 0xff],\n  maroon: [0x80, 0x00, 0x00],\n  mediumaquamarine: [0x66, 0xcd, 0xaa],\n  mediumblue: [0x00, 0x00, 0xcd],\n  mediumorchid: [0xba, 0x55, 0xd3],\n  mediumpurple: [0x93, 0x70, 0xdb],\n  mediumseagreen: [0x3c, 0xb3, 0x71],\n  mediumslateblue: [0x7b, 0x68, 0xee],\n  mediumspringgreen: [0x00, 0xfa, 0x9a],\n  mediumturquoise: [0x48, 0xd1, 0xcc],\n  mediumvioletred: [0xc7, 0x15, 0x85],\n  midnightblue: [0x19, 0x19, 0x70],\n  mintcream: [0xf5, 0xff, 0xfa],\n  mistyrose: [0xff, 0xe4, 0xe1],\n  moccasin: [0xff, 0xe4, 0xb5],\n  navajowhite: [0xff, 0xde, 0xad],\n  navy: [0x00, 0x00, 0x80],\n  oldlace: [0xfd, 0xf5, 0xe6],\n  olive: [0x80, 0x80, 0x00],\n  olivedrab: [0x6b, 0x8e, 0x23],\n  orange: [0xff, 0xa5, 0x00],\n  orangered: [0xff, 0x45, 0x00],\n  orchid: [0xda, 0x70, 0xd6],\n  palegoldenrod: [0xee, 0xe8, 0xaa],\n  palegreen: [0x98, 0xfb, 0x98],\n  paleturquoise: [0xaf, 0xee, 0xee],\n  palevioletred: [0xdb, 0x70, 0x93],\n  papayawhip: [0xff, 0xef, 0xd5],\n  peachpuff: [0xff, 0xda, 0xb9],\n  peru: [0xcd, 0x85, 0x3f],\n  pink: [0xff, 0xc0, 0xcb],\n  plum: [0xdd, 0xa0, 0xdd],\n  powderblue: [0xb0, 0xe0, 0xe6],\n  purple: [0x80, 0x00, 0x80],\n  rebeccapurple: [0x66, 0x33, 0x99],\n  red: [0xff, 0x00, 0x00],\n  rosybrown: [0xbc, 0x8f, 0x8f],\n  royalblue: [0x41, 0x69, 0xe1],\n  saddlebrown: [0x8b, 0x45, 0x13],\n  salmon: [0xfa, 0x80, 0x72],\n  sandybrown: [0xf4, 0xa4, 0x60],\n  seagreen: [0x2e, 0x8b, 0x57],\n  seashell: [0xff, 0xf5, 0xee],\n  sienna: [0xa0, 0x52, 0x2d],\n  silver: [0xc0, 0xc0, 0xc0],\n  skyblue: [0x87, 0xce, 0xeb],\n  slateblue: [0x6a, 0x5a, 0xcd],\n  slategray: [0x70, 0x80, 0x90],\n  slategrey: [0x70, 0x80, 0x90],\n  snow: [0xff, 0xfa, 0xfa],\n  springgreen: [0x00, 0xff, 0x7f],\n  steelblue: [0x46, 0x82, 0xb4],\n  tan: [0xd2, 0xb4, 0x8c],\n  teal: [0x00, 0x80, 0x80],\n  thistle: [0xd8, 0xbf, 0xd8],\n  tomato: [0xff, 0x63, 0x47],\n  turquoise: [0x40, 0xe0, 0xd0],\n  violet: [0xee, 0x82, 0xee],\n  wheat: [0xf5, 0xde, 0xb3],\n  white: [0xff, 0xff, 0xff],\n  whitesmoke: [0xf5, 0xf5, 0xf5],\n  yellow: [0xff, 0xff, 0x00],\n  yellowgreen: [0x9a, 0xcd, 0x32]\n} as const satisfies {\n  [key: string]: TriColorChannels;\n};\n\n/**\n * cache invalid color value\n * @param key - cache key\n * @param nullable - is nullable\n * @returns cached value\n */\nexport const cacheInvalidColorValue = (\n  cacheKey: string,\n  format: string,\n  nullable: boolean = false\n): SpecifiedColorChannels | string | NullObject => {\n  if (format === VAL_SPEC) {\n    const res = '';\n    setCache(cacheKey, res);\n    return res;\n  }\n  if (nullable) {\n    setCache(cacheKey, null);\n    return new NullObject();\n  }\n  const res: SpecifiedColorChannels = ['rgb', 0, 0, 0, 0];\n  setCache(cacheKey, res);\n  return res;\n};\n\n/**\n * resolve invalid color value\n * @param format - output format\n * @param nullable - is nullable\n * @returns resolved value\n */\nexport const resolveInvalidColorValue = (\n  format: string,\n  nullable: boolean = false\n): SpecifiedColorChannels | string | NullObject => {\n  switch (format) {\n    case 'hsl':\n    case 'hwb':\n    case VAL_MIX: {\n      return new NullObject();\n    }\n    case VAL_SPEC: {\n      return '';\n    }\n    default: {\n      if (nullable) {\n        return new NullObject();\n      }\n      return ['rgb', 0, 0, 0, 0] as SpecifiedColorChannels;\n    }\n  }\n};\n\n/**\n * validate color components\n * @param arr - color components\n * @param [opt] - options\n * @param [opt.alpha] - alpha channel\n * @param [opt.minLength] - min length\n * @param [opt.maxLength] - max length\n * @param [opt.minRange] - min range\n * @param [opt.maxRange] - max range\n * @param [opt.validateRange] - validate range\n * @returns result - validated color components\n */\nexport const validateColorComponents = (\n  arr: ColorChannels | TriColorChannels,\n  opt: {\n    alpha?: boolean;\n    minLength?: number;\n    maxLength?: number;\n    minRange?: number;\n    maxRange?: number;\n    validateRange?: boolean;\n  } = {}\n): ColorChannels | TriColorChannels => {\n  if (!Array.isArray(arr)) {\n    throw new TypeError(`${arr} is not an array.`);\n  }\n  const {\n    alpha = false,\n    minLength = TRIA,\n    maxLength = QUAD,\n    minRange = 0,\n    maxRange = 1,\n    validateRange = true\n  } = opt;\n  if (!Number.isFinite(minLength)) {\n    throw new TypeError(`${minLength} is not a number.`);\n  }\n  if (!Number.isFinite(maxLength)) {\n    throw new TypeError(`${maxLength} is not a number.`);\n  }\n  if (!Number.isFinite(minRange)) {\n    throw new TypeError(`${minRange} is not a number.`);\n  }\n  if (!Number.isFinite(maxRange)) {\n    throw new TypeError(`${maxRange} is not a number.`);\n  }\n  const l = arr.length;\n  if (l < minLength || l > maxLength) {\n    throw new Error(`Unexpected array length ${l}.`);\n  }\n  let i = 0;\n  while (i < l) {\n    const v = arr[i] as number;\n    if (!Number.isFinite(v)) {\n      throw new TypeError(`${v} is not a number.`);\n    } else if (i < TRIA && validateRange && (v < minRange || v > maxRange)) {\n      throw new RangeError(`${v} is not between ${minRange} and ${maxRange}.`);\n    } else if (i === TRIA && (v < 0 || v > 1)) {\n      throw new RangeError(`${v} is not between 0 and 1.`);\n    }\n    i++;\n  }\n  if (alpha && l === TRIA) {\n    arr.push(1);\n  }\n  return arr;\n};\n\n/**\n * transform matrix\n * @param mtx - 3 * 3 matrix\n * @param vct - vector\n * @param [skip] - skip validate\n * @returns TriColorChannels - [p1, p2, p3]\n */\nexport const transformMatrix = (\n  mtx: ColorMatrix,\n  vct: TriColorChannels,\n  skip: boolean = false\n): TriColorChannels => {\n  if (!Array.isArray(mtx)) {\n    throw new TypeError(`${mtx} is not an array.`);\n  } else if (mtx.length !== TRIA) {\n    throw new Error(`Unexpected array length ${mtx.length}.`);\n  } else if (!skip) {\n    for (let i of mtx) {\n      i = validateColorComponents(i as TriColorChannels, {\n        maxLength: TRIA,\n        validateRange: false\n      }) as TriColorChannels;\n    }\n  }\n  const [[r1c1, r1c2, r1c3], [r2c1, r2c2, r2c3], [r3c1, r3c2, r3c3]] = mtx;\n  let v1, v2, v3;\n  if (skip) {\n    [v1, v2, v3] = vct;\n  } else {\n    [v1, v2, v3] = validateColorComponents(vct, {\n      maxLength: TRIA,\n      validateRange: false\n    });\n  }\n  const p1 = r1c1 * v1 + r1c2 * v2 + r1c3 * v3;\n  const p2 = r2c1 * v1 + r2c2 * v2 + r2c3 * v3;\n  const p3 = r3c1 * v1 + r3c2 * v2 + r3c3 * v3;\n  return [p1, p2, p3];\n};\n\n/**\n * normalize color components\n * @param colorA - color components [v1, v2, v3, v4]\n * @param colorB - color components [v1, v2, v3, v4]\n * @param [skip] - skip validate\n * @returns result - [colorA, colorB]\n */\nexport const normalizeColorComponents = (\n  colorA: [number | string, number | string, number | string, number | string],\n  colorB: [number | string, number | string, number | string, number | string],\n  skip: boolean = false\n): [ColorChannels, ColorChannels] => {\n  if (!Array.isArray(colorA)) {\n    throw new TypeError(`${colorA} is not an array.`);\n  } else if (colorA.length !== QUAD) {\n    throw new Error(`Unexpected array length ${colorA.length}.`);\n  }\n  if (!Array.isArray(colorB)) {\n    throw new TypeError(`${colorB} is not an array.`);\n  } else if (colorB.length !== QUAD) {\n    throw new Error(`Unexpected array length ${colorB.length}.`);\n  }\n  let i = 0;\n  while (i < QUAD) {\n    if (colorA[i] === NONE && colorB[i] === NONE) {\n      colorA[i] = 0;\n      colorB[i] = 0;\n    } else if (colorA[i] === NONE) {\n      colorA[i] = colorB[i] as number;\n    } else if (colorB[i] === NONE) {\n      colorB[i] = colorA[i] as number;\n    }\n    i++;\n  }\n  if (skip) {\n    return [colorA as ColorChannels, colorB as ColorChannels];\n  }\n  const validatedColorA = validateColorComponents(colorA as ColorChannels, {\n    minLength: QUAD,\n    validateRange: false\n  });\n  const validatedColorB = validateColorComponents(colorB as ColorChannels, {\n    minLength: QUAD,\n    validateRange: false\n  });\n  return [validatedColorA as ColorChannels, validatedColorB as ColorChannels];\n};\n\n/**\n * number to hex string\n * @param value - numeric value\n * @returns hex string\n */\nexport const numberToHexString = (value: number): string => {\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`${value} is not a number.`);\n  } else {\n    value = Math.round(value);\n    if (value < 0 || value > MAX_RGB) {\n      throw new RangeError(`${value} is not between 0 and ${MAX_RGB}.`);\n    }\n  }\n  let hex = value.toString(HEX);\n  if (hex.length === 1) {\n    hex = `0${hex}`;\n  }\n  return hex;\n};\n\n/**\n * angle to deg\n * @param angle\n * @returns deg: 0..360\n */\nexport const angleToDeg = (angle: string): number => {\n  if (isString(angle)) {\n    angle = angle.trim();\n  } else {\n    throw new TypeError(`${angle} is not a string.`);\n  }\n  const GRAD = DEG / 400;\n  const RAD = DEG / (Math.PI * DUO);\n  if (!REG_ANGLE_TO_DEG.test(angle)) {\n    throw new SyntaxError(`Invalid property value: ${angle}`);\n  }\n  const [, value, unit] = angle.match(REG_ANGLE_TO_DEG) as MatchedRegExp;\n  let deg;\n  switch (unit) {\n    case 'grad':\n      deg = parseFloat(value) * GRAD;\n      break;\n    case 'rad':\n      deg = parseFloat(value) * RAD;\n      break;\n    case 'turn':\n      deg = parseFloat(value) * DEG;\n      break;\n    default:\n      deg = parseFloat(value);\n  }\n  deg %= DEG;\n  if (deg < 0) {\n    deg += DEG;\n  } else if (Object.is(deg, -0)) {\n    deg = 0;\n  }\n  return deg;\n};\n\n/**\n * parse alpha\n * @param [alpha] - alpha value\n * @returns alpha: 0..1\n */\nexport const parseAlpha = (alpha: string = ''): number => {\n  if (isString(alpha)) {\n    alpha = alpha.trim();\n    if (!alpha) {\n      alpha = '1';\n    } else if (alpha === NONE) {\n      alpha = '0';\n    } else {\n      let a;\n      if (alpha.endsWith('%')) {\n        a = parseFloat(alpha) / MAX_PCT;\n      } else {\n        a = parseFloat(alpha);\n      }\n      if (!Number.isFinite(a)) {\n        throw new TypeError(`${a} is not a finite number.`);\n      }\n      if (a < PPTH) {\n        alpha = '0';\n      } else if (a > 1) {\n        alpha = '1';\n      } else {\n        alpha = a.toFixed(TRIA);\n      }\n    }\n  } else {\n    alpha = '1';\n  }\n  return parseFloat(alpha);\n};\n\n/**\n * parse hex alpha\n * @param value - alpha value in hex string\n * @returns alpha: 0..1\n */\nexport const parseHexAlpha = (value: string): number => {\n  if (isString(value)) {\n    if (value === '') {\n      throw new SyntaxError('Invalid property value: (empty string)');\n    }\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  let alpha = parseInt(value, HEX);\n  if (alpha <= 0) {\n    return 0;\n  }\n  if (alpha >= MAX_RGB) {\n    return 1;\n  }\n  const alphaMap = new Map();\n  for (let i = 1; i < MAX_PCT; i++) {\n    alphaMap.set(Math.round((i * MAX_RGB) / MAX_PCT), i);\n  }\n  if (alphaMap.has(alpha)) {\n    alpha = alphaMap.get(alpha) / MAX_PCT;\n  } else {\n    alpha = Math.round(alpha / MAX_RGB / PPTH) * PPTH;\n  }\n  return parseFloat(alpha.toFixed(TRIA));\n};\n\n/**\n * transform rgb to linear rgb\n * @param rgb - [r, g, b] r|g|b: 0..255\n * @param [skip] - skip validate\n * @returns TriColorChannels - [r, g, b] r|g|b: 0..1\n */\nexport const transformRgbToLinearRgb = (\n  rgb: TriColorChannels,\n  skip: boolean = false\n): TriColorChannels => {\n  let rr, gg, bb;\n  if (skip) {\n    [rr, gg, bb] = rgb;\n  } else {\n    [rr, gg, bb] = validateColorComponents(rgb, {\n      maxLength: TRIA,\n      maxRange: MAX_RGB\n    });\n  }\n  let r = rr / MAX_RGB;\n  let g = gg / MAX_RGB;\n  let b = bb / MAX_RGB;\n  const COND_POW = 0.04045;\n  if (r > COND_POW) {\n    r = Math.pow((r + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);\n  } else {\n    r /= LINEAR_COEF;\n  }\n  if (g > COND_POW) {\n    g = Math.pow((g + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);\n  } else {\n    g /= LINEAR_COEF;\n  }\n  if (b > COND_POW) {\n    b = Math.pow((b + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);\n  } else {\n    b /= LINEAR_COEF;\n  }\n  return [r, g, b];\n};\n\n/**\n * transform rgb to xyz\n * @param rgb - [r, g, b] r|g|b: 0..255\n * @param [skip] - skip validate\n * @returns TriColorChannels - [x, y, z]\n */\nexport const transformRgbToXyz = (\n  rgb: TriColorChannels,\n  skip: boolean = false\n): TriColorChannels => {\n  if (!skip) {\n    rgb = validateColorComponents(rgb, {\n      maxLength: TRIA,\n      maxRange: MAX_RGB\n    }) as TriColorChannels;\n  }\n  rgb = transformRgbToLinearRgb(rgb, true);\n  const xyz = transformMatrix(MATRIX_L_RGB_TO_XYZ, rgb, true);\n  return xyz;\n};\n\n/**\n * transform rgb to xyz-d50\n * @param rgb - [r, g, b] r|g|b: 0..255 alpha: 0..1\n * @returns TriColorChannels - [x, y, z]\n */\nexport const transformRgbToXyzD50 = (\n  rgb: TriColorChannels\n): TriColorChannels => {\n  let xyz = transformRgbToXyz(rgb);\n  xyz = transformMatrix(MATRIX_D65_TO_D50, xyz, true);\n  return xyz;\n};\n\n/**\n * transform linear rgb to rgb\n * @param rgb - [r, g, b] r|g|b: 0..1\n * @param [round] - round result\n * @returns TriColorChannels - [r, g, b] r|g|b: 0..255\n */\nexport const transformLinearRgbToRgb = (\n  rgb: TriColorChannels,\n  round: boolean = false\n): TriColorChannels => {\n  let [r, g, b] = validateColorComponents(rgb, {\n    maxLength: TRIA\n  });\n  const COND_POW = 809 / 258400;\n  if (r > COND_POW) {\n    r = Math.pow(r, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;\n  } else {\n    r *= LINEAR_COEF;\n  }\n  r *= MAX_RGB;\n  if (g > COND_POW) {\n    g = Math.pow(g, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;\n  } else {\n    g *= LINEAR_COEF;\n  }\n  g *= MAX_RGB;\n  if (b > COND_POW) {\n    b = Math.pow(b, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;\n  } else {\n    b *= LINEAR_COEF;\n  }\n  b *= MAX_RGB;\n  return [\n    round ? Math.round(r) : r,\n    round ? Math.round(g) : g,\n    round ? Math.round(b) : b\n  ];\n};\n\n/**\n * transform xyz to rgb\n * @param xyz - [x, y, z]\n * @param [skip] - skip validate\n * @returns TriColorChannels - [r, g, b] r|g|b: 0..255\n */\nexport const transformXyzToRgb = (\n  xyz: TriColorChannels,\n  skip: boolean = false\n): TriColorChannels => {\n  if (!skip) {\n    xyz = validateColorComponents(xyz, {\n      maxLength: TRIA,\n      validateRange: false\n    }) as TriColorChannels;\n  }\n  let [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, xyz, true);\n  [r, g, b] = transformLinearRgbToRgb(\n    [\n      Math.min(Math.max(r, 0), 1),\n      Math.min(Math.max(g, 0), 1),\n      Math.min(Math.max(b, 0), 1)\n    ],\n    true\n  );\n  return [r, g, b];\n};\n\n/**\n * transform xyz to xyz-d50\n * @param xyz - [x, y, z]\n * @returns TriColorChannels - [x, y, z]\n */\nexport const transformXyzToXyzD50 = (\n  xyz: TriColorChannels\n): TriColorChannels => {\n  xyz = validateColorComponents(xyz, {\n    maxLength: TRIA,\n    validateRange: false\n  }) as TriColorChannels;\n  xyz = transformMatrix(MATRIX_D65_TO_D50, xyz, true);\n  return xyz;\n};\n\n/**\n * transform xyz to hsl\n * @param xyz - [x, y, z]\n * @param [skip] - skip validate\n * @returns TriColorChannels - [h, s, l]\n */\nexport const transformXyzToHsl = (\n  xyz: TriColorChannels,\n  skip: boolean = false\n): TriColorChannels => {\n  const [rr, gg, bb] = transformXyzToRgb(xyz, skip);\n  const r = rr / MAX_RGB;\n  const g = gg / MAX_RGB;\n  const b = bb / MAX_RGB;\n  const max = Math.max(r, g, b);\n  const min = Math.min(r, g, b);\n  const d = max - min;\n  const l = (max + min) * HALF * MAX_PCT;\n  let h, s;\n  if (Math.round(l) === 0 || Math.round(l) === MAX_PCT) {\n    h = 0;\n    s = 0;\n  } else {\n    s = (d / (1 - Math.abs(max + min - 1))) * MAX_PCT;\n    if (s === 0) {\n      h = 0;\n    } else {\n      switch (max) {\n        case r:\n          h = (g - b) / d;\n          break;\n        case g:\n          h = (b - r) / d + DUO;\n          break;\n        case b:\n        default:\n          h = (r - g) / d + QUAD;\n          break;\n      }\n      h = (h * SEXA) % DEG;\n      if (h < 0) {\n        h += DEG;\n      }\n    }\n  }\n  return [h, s, l];\n};\n\n/**\n * transform xyz to hwb\n * @param xyz - [x, y, z]\n * @param [skip] - skip validate\n * @returns TriColorChannels - [h, w, b]\n */\nexport const transformXyzToHwb = (\n  xyz: TriColorChannels,\n  skip: boolean = false\n): TriColorChannels => {\n  const [r, g, b] = transformXyzToRgb(xyz, skip);\n  const wh = Math.min(r, g, b) / MAX_RGB;\n  const bk = 1 - Math.max(r, g, b) / MAX_RGB;\n  let h;\n  if (wh + bk === 1) {\n    h = 0;\n  } else {\n    [h] = transformXyzToHsl(xyz);\n  }\n  return [h, wh * MAX_PCT, bk * MAX_PCT];\n};\n\n/**\n * transform xyz to oklab\n * @param xyz - [x, y, z]\n * @param [skip] - skip validate\n * @returns TriColorChannels - [l, a, b]\n */\nexport const transformXyzToOklab = (\n  xyz: TriColorChannels,\n  skip: boolean = false\n): TriColorChannels => {\n  if (!skip) {\n    xyz = validateColorComponents(xyz, {\n      maxLength: TRIA,\n      validateRange: false\n    }) as TriColorChannels;\n  }\n  const lms = transformMatrix(MATRIX_XYZ_TO_LMS, xyz, true);\n  const xyzLms = lms.map(c => Math.cbrt(c)) as TriColorChannels;\n  let [l, a, b] = transformMatrix(MATRIX_LMS_TO_OKLAB, xyzLms, true);\n  l = Math.min(Math.max(l, 0), 1);\n  const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);\n  if (lPct === 0 || lPct === MAX_PCT) {\n    a = 0;\n    b = 0;\n  }\n  return [l, a, b];\n};\n\n/**\n * transform xyz to oklch\n * @param xyz - [x, y, z]\n * @param [skip] - skip validate\n * @returns TriColorChannels - [l, c, h]\n */\nexport const transformXyzToOklch = (\n  xyz: TriColorChannels,\n  skip: boolean = false\n): TriColorChannels => {\n  const [l, a, b] = transformXyzToOklab(xyz, skip);\n  let c, h;\n  const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);\n  if (lPct === 0 || lPct === MAX_PCT) {\n    c = 0;\n    h = 0;\n  } else {\n    c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);\n    if (parseFloat(c.toFixed(QUAD)) === 0) {\n      h = 0;\n    } else {\n      h = (Math.atan2(b, a) * DEG_HALF) / Math.PI;\n      if (h < 0) {\n        h += DEG;\n      }\n    }\n  }\n  return [l, c, h];\n};\n\n/**\n * transform xyz D50 to rgb\n * @param xyz - [x, y, z]\n * @param [skip] - skip validate\n * @returns TriColorChannels - [r, g, b] r|g|b: 0..255\n */\nexport const transformXyzD50ToRgb = (\n  xyz: TriColorChannels,\n  skip: boolean = false\n): TriColorChannels => {\n  if (!skip) {\n    xyz = validateColorComponents(xyz, {\n      maxLength: TRIA,\n      validateRange: false\n    }) as TriColorChannels;\n  }\n  const xyzD65 = transformMatrix(MATRIX_D50_TO_D65, xyz, true);\n  const rgb = transformXyzToRgb(xyzD65, true);\n  return rgb;\n};\n\n/**\n * transform xyz-d50 to lab\n * @param xyz - [x, y, z]\n * @param [skip] - skip validate\n * @returns TriColorChannels - [l, a, b]\n */\nexport const transformXyzD50ToLab = (\n  xyz: TriColorChannels,\n  skip: boolean = false\n): TriColorChannels => {\n  if (!skip) {\n    xyz = validateColorComponents(xyz, {\n      maxLength: TRIA,\n      validateRange: false\n    }) as TriColorChannels;\n  }\n  const xyzD50 = xyz.map((val, i) => val / (D50[i] as number));\n  const [f0, f1, f2] = xyzD50.map(val =>\n    val > LAB_EPSILON ? Math.cbrt(val) : (val * LAB_KAPPA + HEX) / LAB_L\n  ) as TriColorChannels;\n  const l = Math.min(Math.max(LAB_L * f1 - HEX, 0), MAX_PCT);\n  let a, b;\n  if (l === 0 || l === MAX_PCT) {\n    a = 0;\n    b = 0;\n  } else {\n    a = (f0 - f1) * LAB_A;\n    b = (f1 - f2) * LAB_B;\n  }\n  return [l, a, b];\n};\n\n/**\n * transform xyz-d50 to lch\n * @param xyz - [x, y, z]\n * @param [skip] - skip validate\n * @returns TriColorChannels - [l, c, h]\n */\nexport const transformXyzD50ToLch = (\n  xyz: TriColorChannels,\n  skip: boolean = false\n): TriColorChannels => {\n  const [l, a, b] = transformXyzD50ToLab(xyz, skip);\n  let c, h;\n  if (l === 0 || l === MAX_PCT) {\n    c = 0;\n    h = 0;\n  } else {\n    c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);\n    h = (Math.atan2(b, a) * DEG_HALF) / Math.PI;\n    if (h < 0) {\n      h += DEG;\n    }\n  }\n  return [l, c, h];\n};\n\n/**\n * convert rgb to hex color\n * @param rgb - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1\n * @returns hex color\n */\nexport const convertRgbToHex = (rgb: ColorChannels): string => {\n  const [r, g, b, alpha] = validateColorComponents(rgb, {\n    alpha: true,\n    maxRange: MAX_RGB\n  }) as ColorChannels;\n  const rr = numberToHexString(r);\n  const gg = numberToHexString(g);\n  const bb = numberToHexString(b);\n  const aa = numberToHexString(alpha * MAX_RGB);\n  let hex;\n  if (aa === 'ff') {\n    hex = `#${rr}${gg}${bb}`;\n  } else {\n    hex = `#${rr}${gg}${bb}${aa}`;\n  }\n  return hex;\n};\n\n/**\n * convert linear rgb to hex color\n * @param rgb - [r, g, b, alpha] r|g|b|alpha: 0..1\n * @param [skip] - skip validate\n * @returns hex color\n */\nexport const convertLinearRgbToHex = (\n  rgb: ColorChannels,\n  skip: boolean = false\n): string => {\n  let r, g, b, alpha;\n  if (skip) {\n    [r, g, b, alpha] = rgb;\n  } else {\n    [r, g, b, alpha] = validateColorComponents(rgb, {\n      minLength: QUAD\n    }) as ColorChannels;\n  }\n  [r, g, b] = transformLinearRgbToRgb([r, g, b], true);\n  const rr = numberToHexString(r);\n  const gg = numberToHexString(g);\n  const bb = numberToHexString(b);\n  const aa = numberToHexString(alpha * MAX_RGB);\n  let hex;\n  if (aa === 'ff') {\n    hex = `#${rr}${gg}${bb}`;\n  } else {\n    hex = `#${rr}${gg}${bb}${aa}`;\n  }\n  return hex;\n};\n\n/**\n * convert xyz to hex color\n * @param xyz - [x, y, z, alpha]\n * @returns hex color\n */\nexport const convertXyzToHex = (xyz: ColorChannels): string => {\n  const [x, y, z, alpha] = validateColorComponents(xyz, {\n    minLength: QUAD,\n    validateRange: false\n  }) as ColorChannels;\n  const [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);\n  const hex = convertLinearRgbToHex(\n    [\n      Math.min(Math.max(r, 0), 1),\n      Math.min(Math.max(g, 0), 1),\n      Math.min(Math.max(b, 0), 1),\n      alpha\n    ],\n    true\n  );\n  return hex;\n};\n\n/**\n * convert xyz D50 to hex color\n * @param xyz - [x, y, z, alpha]\n * @returns hex color\n */\nexport const convertXyzD50ToHex = (xyz: ColorChannels): string => {\n  const [x, y, z, alpha] = validateColorComponents(xyz, {\n    minLength: QUAD,\n    validateRange: false\n  }) as ColorChannels;\n  const xyzD65 = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);\n  const [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, xyzD65, true);\n  const hex = convertLinearRgbToHex([\n    Math.min(Math.max(r, 0), 1),\n    Math.min(Math.max(g, 0), 1),\n    Math.min(Math.max(b, 0), 1),\n    alpha\n  ]);\n  return hex;\n};\n\n/**\n * convert hex color to rgb\n * @param value - hex color value\n * @returns ColorChannels - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1\n */\nexport const convertHexToRgb = (value: string): ColorChannels => {\n  if (isString(value)) {\n    value = value.toLowerCase().trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  if (\n    !(\n      /^#[\\da-f]{6}$/.test(value) ||\n      /^#[\\da-f]{3}$/.test(value) ||\n      /^#[\\da-f]{8}$/.test(value) ||\n      /^#[\\da-f]{4}$/.test(value)\n    )\n  ) {\n    throw new SyntaxError(`Invalid property value: ${value}`);\n  }\n  const arr: number[] = [];\n  if (/^#[\\da-f]{3}$/.test(value)) {\n    const [, r, g, b] = value.match(\n      /^#([\\da-f])([\\da-f])([\\da-f])$/\n    ) as MatchedRegExp;\n    arr.push(\n      parseInt(`${r}${r}`, HEX),\n      parseInt(`${g}${g}`, HEX),\n      parseInt(`${b}${b}`, HEX),\n      1\n    );\n  } else if (/^#[\\da-f]{4}$/.test(value)) {\n    const [, r, g, b, alpha] = value.match(\n      /^#([\\da-f])([\\da-f])([\\da-f])([\\da-f])$/\n    ) as MatchedRegExp;\n    arr.push(\n      parseInt(`${r}${r}`, HEX),\n      parseInt(`${g}${g}`, HEX),\n      parseInt(`${b}${b}`, HEX),\n      parseHexAlpha(`${alpha}${alpha}`)\n    );\n  } else if (/^#[\\da-f]{8}$/.test(value)) {\n    const [, r, g, b, alpha] = value.match(\n      /^#([\\da-f]{2})([\\da-f]{2})([\\da-f]{2})([\\da-f]{2})$/\n    ) as MatchedRegExp;\n    arr.push(\n      parseInt(r, HEX),\n      parseInt(g, HEX),\n      parseInt(b, HEX),\n      parseHexAlpha(alpha)\n    );\n  } else {\n    const [, r, g, b] = value.match(\n      /^#([\\da-f]{2})([\\da-f]{2})([\\da-f]{2})$/\n    ) as MatchedRegExp;\n    arr.push(parseInt(r, HEX), parseInt(g, HEX), parseInt(b, HEX), 1);\n  }\n  return arr as ColorChannels;\n};\n\n/**\n * convert hex color to linear rgb\n * @param value - hex color value\n * @returns ColorChannels - [r, g, b, alpha] r|g|b|alpha: 0..1\n */\nexport const convertHexToLinearRgb = (value: string): ColorChannels => {\n  const [rr, gg, bb, alpha] = convertHexToRgb(value);\n  const [r, g, b] = transformRgbToLinearRgb([rr, gg, bb], true);\n  return [r, g, b, alpha];\n};\n\n/**\n * convert hex color to xyz\n * @param value - hex color value\n * @returns ColorChannels - [x, y, z, alpha]\n */\nexport const convertHexToXyz = (value: string): ColorChannels => {\n  const [r, g, b, alpha] = convertHexToLinearRgb(value);\n  const [x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [r, g, b], true);\n  return [x, y, z, alpha];\n};\n\n/**\n * parse rgb()\n * @param value - rgb color value\n * @param [opt] - options\n * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject\n */\nexport const parseRgb = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.toLowerCase().trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '', nullable = false } = opt;\n  if (!REG_PARSE_RGB.test(value)) {\n    const res = resolveInvalidColorValue(format, nullable);\n    if (res instanceof NullObject) {\n      return res;\n    }\n    if (isString(res)) {\n      return res as string;\n    }\n    return res as SpecifiedColorChannels;\n  }\n  const [, val] = value.match(REG_PARSE_RGB) as MatchedRegExp;\n  const [v1, v2, v3, v4 = ''] = val.match(/[^\\s,/]+/g) as StringColorChannels;\n  let r, g, b;\n  if (v1 === NONE) {\n    r = 0;\n  } else {\n    if (v1.endsWith('%')) {\n      r = (parseFloat(v1) * MAX_RGB) / MAX_PCT;\n    } else {\n      r = parseFloat(v1);\n    }\n    r = Math.min(Math.max(roundToPrecision(r, OCT), 0), MAX_RGB);\n  }\n  if (v2 === NONE) {\n    g = 0;\n  } else {\n    if (v2.endsWith('%')) {\n      g = (parseFloat(v2) * MAX_RGB) / MAX_PCT;\n    } else {\n      g = parseFloat(v2);\n    }\n    g = Math.min(Math.max(roundToPrecision(g, OCT), 0), MAX_RGB);\n  }\n  if (v3 === NONE) {\n    b = 0;\n  } else {\n    if (v3.endsWith('%')) {\n      b = (parseFloat(v3) * MAX_RGB) / MAX_PCT;\n    } else {\n      b = parseFloat(v3);\n    }\n    b = Math.min(Math.max(roundToPrecision(b, OCT), 0), MAX_RGB);\n  }\n  const alpha = parseAlpha(v4);\n  return ['rgb', r, g, b, format === VAL_MIX && v4 === NONE ? NONE : alpha];\n};\n\n/**\n * parse hsl()\n * @param value - hsl color value\n * @param [opt] - options\n * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject\n */\nexport const parseHsl = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '', nullable = false } = opt;\n  if (!REG_HSL.test(value)) {\n    const res = resolveInvalidColorValue(format, nullable);\n    if (res instanceof NullObject) {\n      return res;\n    }\n    if (isString(res)) {\n      return res as string;\n    }\n    return res as SpecifiedColorChannels;\n  }\n  const [, val] = value.match(REG_HSL) as MatchedRegExp;\n  const [v1, v2, v3, v4 = ''] = val.match(/[^\\s,/]+/g) as StringColorChannels;\n  let h, s, l;\n  if (v1 === NONE) {\n    h = 0;\n  } else {\n    h = angleToDeg(v1);\n  }\n  if (v2 === NONE) {\n    s = 0;\n  } else {\n    s = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT);\n  }\n  if (v3 === NONE) {\n    l = 0;\n  } else {\n    l = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT);\n  }\n  const alpha = parseAlpha(v4);\n  if (format === 'hsl') {\n    return [\n      format,\n      v1 === NONE ? v1 : h,\n      v2 === NONE ? v2 : s,\n      v3 === NONE ? v3 : l,\n      v4 === NONE ? v4 : alpha\n    ];\n  }\n  h = (h / DEG) * DOZ;\n  l /= MAX_PCT;\n  const sa = (s / MAX_PCT) * Math.min(l, 1 - l);\n  const rk = h % DOZ;\n  const gk = (8 + h) % DOZ;\n  const bk = (4 + h) % DOZ;\n  const r = l - sa * Math.max(-1, Math.min(rk - TRIA, TRIA ** POW_SQR - rk, 1));\n  const g = l - sa * Math.max(-1, Math.min(gk - TRIA, TRIA ** POW_SQR - gk, 1));\n  const b = l - sa * Math.max(-1, Math.min(bk - TRIA, TRIA ** POW_SQR - bk, 1));\n  return [\n    'rgb',\n    Math.min(Math.max(roundToPrecision(r * MAX_RGB, OCT), 0), MAX_RGB),\n    Math.min(Math.max(roundToPrecision(g * MAX_RGB, OCT), 0), MAX_RGB),\n    Math.min(Math.max(roundToPrecision(b * MAX_RGB, OCT), 0), MAX_RGB),\n    alpha\n  ];\n};\n\n/**\n * parse hwb()\n * @param value - hwb color value\n * @param [opt] - options\n * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject\n */\nexport const parseHwb = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '', nullable = false } = opt;\n  if (!REG_HWB.test(value)) {\n    const res = resolveInvalidColorValue(format, nullable);\n    if (res instanceof NullObject) {\n      return res;\n    }\n    if (isString(res)) {\n      return res as string;\n    }\n    return res as SpecifiedColorChannels;\n  }\n  const [, val] = value.match(REG_HWB) as MatchedRegExp;\n  const [v1, v2, v3, v4 = ''] = val.match(/[^\\s,/]+/g) as StringColorChannels;\n  let h, wh, bk;\n  if (v1 === NONE) {\n    h = 0;\n  } else {\n    h = angleToDeg(v1);\n  }\n  if (v2 === NONE) {\n    wh = 0;\n  } else {\n    wh = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT) / MAX_PCT;\n  }\n  if (v3 === NONE) {\n    bk = 0;\n  } else {\n    bk = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT) / MAX_PCT;\n  }\n  const alpha = parseAlpha(v4);\n  if (format === 'hwb') {\n    return [\n      format,\n      v1 === NONE ? v1 : h,\n      v2 === NONE ? v2 : wh * MAX_PCT,\n      v3 === NONE ? v3 : bk * MAX_PCT,\n      v4 === NONE ? v4 : alpha\n    ];\n  }\n  if (wh + bk >= 1) {\n    const v = roundToPrecision((wh / (wh + bk)) * MAX_RGB, OCT);\n    return ['rgb', v, v, v, alpha];\n  }\n  const factor = (1 - wh - bk) / MAX_RGB;\n  let [, r, g, b] = parseHsl(`hsl(${h} 100 50)`) as ComputedColorChannels;\n  r = roundToPrecision((r * factor + wh) * MAX_RGB, OCT);\n  g = roundToPrecision((g * factor + wh) * MAX_RGB, OCT);\n  b = roundToPrecision((b * factor + wh) * MAX_RGB, OCT);\n  return [\n    'rgb',\n    Math.min(Math.max(r, 0), MAX_RGB),\n    Math.min(Math.max(g, 0), MAX_RGB),\n    Math.min(Math.max(b, 0), MAX_RGB),\n    alpha\n  ];\n};\n\n/**\n * parse lab()\n * @param value - lab color value\n * @param [opt] - options\n * @returns parsed color\n *   - [xyz-d50, x, y, z, alpha], ['lab', l, a, b, alpha], '(empty)', NullObject\n */\nexport const parseLab = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '', nullable = false } = opt;\n  if (!REG_LAB.test(value)) {\n    const res = resolveInvalidColorValue(format, nullable);\n    if (res instanceof NullObject) {\n      return res;\n    }\n    if (isString(res)) {\n      return res as string;\n    }\n    return res as SpecifiedColorChannels;\n  }\n  const COEF_PCT = 1.25;\n  const COND_POW = 8;\n  const [, val] = value.match(REG_LAB) as MatchedRegExp;\n  const [v1, v2, v3, v4 = ''] = val.match(/[^\\s,/]+/g) as StringColorChannels;\n  let l, a, b;\n  if (v1 === NONE) {\n    l = 0;\n  } else {\n    if (v1.endsWith('%')) {\n      l = parseFloat(v1);\n      if (l > MAX_PCT) {\n        l = MAX_PCT;\n      }\n    } else {\n      l = parseFloat(v1);\n    }\n    if (l < 0) {\n      l = 0;\n    }\n  }\n  if (v2 === NONE) {\n    a = 0;\n  } else {\n    a = v2.endsWith('%') ? parseFloat(v2) * COEF_PCT : parseFloat(v2);\n  }\n  if (v3 === NONE) {\n    b = 0;\n  } else {\n    b = v3.endsWith('%') ? parseFloat(v3) * COEF_PCT : parseFloat(v3);\n  }\n  const alpha = parseAlpha(v4);\n  if (REG_SPEC.test(format)) {\n    return [\n      'lab',\n      v1 === NONE ? v1 : roundToPrecision(l, HEX),\n      v2 === NONE ? v2 : roundToPrecision(a, HEX),\n      v3 === NONE ? v3 : roundToPrecision(b, HEX),\n      v4 === NONE ? v4 : alpha\n    ];\n  }\n  const fl = (l + HEX) / LAB_L;\n  const fa = a / LAB_A + fl;\n  const fb = fl - b / LAB_B;\n  const powFl = Math.pow(fl, POW_CUBE);\n  const powFa = Math.pow(fa, POW_CUBE);\n  const powFb = Math.pow(fb, POW_CUBE);\n  const xyz = [\n    powFa > LAB_EPSILON ? powFa : (fa * LAB_L - HEX) / LAB_KAPPA,\n    l > COND_POW ? powFl : l / LAB_KAPPA,\n    powFb > LAB_EPSILON ? powFb : (fb * LAB_L - HEX) / LAB_KAPPA\n  ];\n  const [x, y, z] = xyz.map(\n    (val, i) => val * (D50[i] as number)\n  ) as TriColorChannels;\n  return [\n    'xyz-d50',\n    roundToPrecision(x, HEX),\n    roundToPrecision(y, HEX),\n    roundToPrecision(z, HEX),\n    alpha\n  ];\n};\n\n/**\n * parse lch()\n * @param value - lch color value\n * @param [opt] - options\n * @returns parsed color\n *   - ['xyz-d50', x, y, z, alpha], ['lch', l, c, h, alpha]\n *   - '(empty)', NullObject\n */\nexport const parseLch = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '', nullable = false } = opt;\n  if (!REG_LCH.test(value)) {\n    const res = resolveInvalidColorValue(format, nullable);\n    if (res instanceof NullObject) {\n      return res;\n    }\n    if (isString(res)) {\n      return res as string;\n    }\n    return res as SpecifiedColorChannels;\n  }\n  const COEF_PCT = 1.5;\n  const [, val] = value.match(REG_LCH) as MatchedRegExp;\n  const [v1, v2, v3, v4 = ''] = val.match(/[^\\s,/]+/g) as StringColorChannels;\n  let l, c, h;\n  if (v1 === NONE) {\n    l = 0;\n  } else {\n    l = parseFloat(v1);\n    if (l < 0) {\n      l = 0;\n    }\n  }\n  if (v2 === NONE) {\n    c = 0;\n  } else {\n    c = v2.endsWith('%') ? parseFloat(v2) * COEF_PCT : parseFloat(v2);\n  }\n  if (v3 === NONE) {\n    h = 0;\n  } else {\n    h = angleToDeg(v3);\n  }\n  const alpha = parseAlpha(v4);\n  if (REG_SPEC.test(format)) {\n    return [\n      'lch',\n      v1 === NONE ? v1 : roundToPrecision(l, HEX),\n      v2 === NONE ? v2 : roundToPrecision(c, HEX),\n      v3 === NONE ? v3 : roundToPrecision(h, HEX),\n      v4 === NONE ? v4 : alpha\n    ];\n  }\n  const a = c * Math.cos((h * Math.PI) / DEG_HALF);\n  const b = c * Math.sin((h * Math.PI) / DEG_HALF);\n  const [, x, y, z] = parseLab(`lab(${l} ${a} ${b})`) as ComputedColorChannels;\n  return [\n    'xyz-d50',\n    roundToPrecision(x, HEX),\n    roundToPrecision(y, HEX),\n    roundToPrecision(z, HEX),\n    alpha as number\n  ];\n};\n\n/**\n * parse oklab()\n * @param value - oklab color value\n * @param [opt] - options\n * @returns parsed color\n *   - ['xyz-d65', x, y, z, alpha], ['oklab', l, a, b, alpha]\n *   - '(empty)', NullObject\n */\nexport const parseOklab = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '', nullable = false } = opt;\n  if (!REG_OKLAB.test(value)) {\n    const res = resolveInvalidColorValue(format, nullable);\n    if (res instanceof NullObject) {\n      return res;\n    }\n    if (isString(res)) {\n      return res as string;\n    }\n    return res as SpecifiedColorChannels;\n  }\n  const COEF_PCT = 0.4;\n  const [, val] = value.match(REG_OKLAB) as MatchedRegExp;\n  const [v1, v2, v3, v4 = ''] = val.match(/[^\\s,/]+/g) as StringColorChannels;\n  let l, a, b;\n  if (v1 === NONE) {\n    l = 0;\n  } else {\n    l = v1.endsWith('%') ? parseFloat(v1) / MAX_PCT : parseFloat(v1);\n    if (l < 0) {\n      l = 0;\n    }\n  }\n  if (v2 === NONE) {\n    a = 0;\n  } else if (v2.endsWith('%')) {\n    a = (parseFloat(v2) * COEF_PCT) / MAX_PCT;\n  } else {\n    a = parseFloat(v2);\n  }\n  if (v3 === NONE) {\n    b = 0;\n  } else if (v3.endsWith('%')) {\n    b = (parseFloat(v3) * COEF_PCT) / MAX_PCT;\n  } else {\n    b = parseFloat(v3);\n  }\n  const alpha = parseAlpha(v4);\n  if (REG_SPEC.test(format)) {\n    return [\n      'oklab',\n      v1 === NONE ? v1 : roundToPrecision(l, HEX),\n      v2 === NONE ? v2 : roundToPrecision(a, HEX),\n      v3 === NONE ? v3 : roundToPrecision(b, HEX),\n      v4 === NONE ? v4 : alpha\n    ];\n  }\n  const lms = transformMatrix(MATRIX_OKLAB_TO_LMS, [l, a, b]);\n  const xyzLms = lms.map(c => Math.pow(c, POW_CUBE)) as TriColorChannels;\n  const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, xyzLms, true);\n  return [\n    'xyz-d65',\n    roundToPrecision(x, HEX),\n    roundToPrecision(y, HEX),\n    roundToPrecision(z, HEX),\n    alpha as number\n  ];\n};\n\n/**\n * parse oklch()\n * @param value - oklch color value\n * @param [opt] - options\n * @returns parsed color\n *   - ['xyz-d65', x, y, z, alpha], ['oklch', l, c, h, alpha]\n *   - '(empty)', NullObject\n */\nexport const parseOklch = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '', nullable = false } = opt;\n  if (!REG_OKLCH.test(value)) {\n    const res = resolveInvalidColorValue(format, nullable);\n    if (res instanceof NullObject) {\n      return res;\n    }\n    if (isString(res)) {\n      return res as string;\n    }\n    return res as SpecifiedColorChannels;\n  }\n  const COEF_PCT = 0.4;\n  const [, val] = value.match(REG_OKLCH) as MatchedRegExp;\n  const [v1, v2, v3, v4 = ''] = val.match(/[^\\s,/]+/g) as StringColorChannels;\n  let l, c, h;\n  if (v1 === NONE) {\n    l = 0;\n  } else {\n    l = v1.endsWith('%') ? parseFloat(v1) / MAX_PCT : parseFloat(v1);\n    if (l < 0) {\n      l = 0;\n    }\n  }\n  if (v2 === NONE) {\n    c = 0;\n  } else {\n    if (v2.endsWith('%')) {\n      c = (parseFloat(v2) * COEF_PCT) / MAX_PCT;\n    } else {\n      c = parseFloat(v2);\n    }\n    if (c < 0) {\n      c = 0;\n    }\n  }\n  if (v3 === NONE) {\n    h = 0;\n  } else {\n    h = angleToDeg(v3);\n  }\n  const alpha = parseAlpha(v4);\n  if (REG_SPEC.test(format)) {\n    return [\n      'oklch',\n      v1 === NONE ? v1 : roundToPrecision(l, HEX),\n      v2 === NONE ? v2 : roundToPrecision(c, HEX),\n      v3 === NONE ? v3 : roundToPrecision(h, HEX),\n      v4 === NONE ? v4 : alpha\n    ];\n  }\n  const a = c * Math.cos((h * Math.PI) / DEG_HALF);\n  const b = c * Math.sin((h * Math.PI) / DEG_HALF);\n  const lms = transformMatrix(MATRIX_OKLAB_TO_LMS, [l, a, b]);\n  const xyzLms = lms.map(cc => Math.pow(cc, POW_CUBE)) as TriColorChannels;\n  const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, xyzLms, true);\n  return [\n    'xyz-d65',\n    roundToPrecision(x, HEX),\n    roundToPrecision(y, HEX),\n    roundToPrecision(z, HEX),\n    alpha\n  ];\n};\n\n/**\n * parse color()\n * @param value - color function value\n * @param [opt] - options\n * @returns parsed color\n *   - ['xyz-(d50|d65)', x, y, z, alpha], [cs, r, g, b, alpha]\n *   - '(empty)', NullObject\n */\nexport const parseColorFunc = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { colorSpace = '', d50 = false, format = '', nullable = false } = opt;\n  if (!REG_FN_COLOR.test(value)) {\n    const res = resolveInvalidColorValue(format, nullable);\n    if (res instanceof NullObject) {\n      return res;\n    }\n    if (isString(res)) {\n      return res as string;\n    }\n    return res as SpecifiedColorChannels;\n  }\n  const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;\n  let [cs, v1, v2, v3, v4 = ''] = val.match(\n    /[^\\s,/]+/g\n  ) as StringColorSpacedChannels;\n  let r, g, b;\n  if (cs === 'xyz') {\n    cs = 'xyz-d65';\n  }\n  if (v1 === NONE) {\n    r = 0;\n  } else {\n    r = v1.endsWith('%') ? parseFloat(v1) / MAX_PCT : parseFloat(v1);\n  }\n  if (v2 === NONE) {\n    g = 0;\n  } else {\n    g = v2.endsWith('%') ? parseFloat(v2) / MAX_PCT : parseFloat(v2);\n  }\n  if (v3 === NONE) {\n    b = 0;\n  } else {\n    b = v3.endsWith('%') ? parseFloat(v3) / MAX_PCT : parseFloat(v3);\n  }\n  const alpha = parseAlpha(v4);\n  if (REG_SPEC.test(format) || (format === VAL_MIX && cs === colorSpace)) {\n    return [\n      cs,\n      v1 === NONE ? v1 : roundToPrecision(r, DEC),\n      v2 === NONE ? v2 : roundToPrecision(g, DEC),\n      v3 === NONE ? v3 : roundToPrecision(b, DEC),\n      v4 === NONE ? v4 : alpha\n    ];\n  }\n  let x = 0;\n  let y = 0;\n  let z = 0;\n  // srgb-linear\n  if (cs === 'srgb-linear') {\n    [x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [r, g, b]);\n    if (d50) {\n      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);\n    }\n    // display-p3\n  } else if (cs === 'display-p3') {\n    const linearRgb = transformRgbToLinearRgb([\n      r * MAX_RGB,\n      g * MAX_RGB,\n      b * MAX_RGB\n    ]);\n    [x, y, z] = transformMatrix(MATRIX_P3_TO_XYZ, linearRgb);\n    if (d50) {\n      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);\n    }\n    // rec2020\n  } else if (cs === 'rec2020') {\n    const ALPHA = 1.09929682680944;\n    const BETA = 0.018053968510807;\n    const REC_COEF = 0.45;\n    const rgb = [r, g, b].map(c => {\n      let cl;\n      if (c < BETA * REC_COEF * DEC) {\n        cl = c / (REC_COEF * DEC);\n      } else {\n        cl = Math.pow((c + ALPHA - 1) / ALPHA, 1 / REC_COEF);\n      }\n      return cl;\n    }) as TriColorChannels;\n    [x, y, z] = transformMatrix(MATRIX_REC2020_TO_XYZ, rgb);\n    if (d50) {\n      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);\n    }\n    // a98-rgb\n  } else if (cs === 'a98-rgb') {\n    const POW_A98 = 563 / 256;\n    const rgb = [r, g, b].map(c => {\n      const cl = Math.pow(c, POW_A98);\n      return cl;\n    }) as TriColorChannels;\n    [x, y, z] = transformMatrix(MATRIX_A98_TO_XYZ, rgb);\n    if (d50) {\n      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);\n    }\n    // prophoto-rgb\n  } else if (cs === 'prophoto-rgb') {\n    const POW_PROPHOTO = 1.8;\n    const rgb = [r, g, b].map(c => {\n      let cl;\n      if (c > 1 / (HEX * DUO)) {\n        cl = Math.pow(c, POW_PROPHOTO);\n      } else {\n        cl = c / HEX;\n      }\n      return cl;\n    }) as TriColorChannels;\n    [x, y, z] = transformMatrix(MATRIX_PROPHOTO_TO_XYZ_D50, rgb);\n    if (!d50) {\n      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);\n    }\n    // xyz, xyz-d50, xyz-d65\n  } else if (/^xyz(?:-d(?:50|65))?$/.test(cs)) {\n    [x, y, z] = [r, g, b];\n    if (cs === 'xyz-d50') {\n      if (!d50) {\n        [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z]);\n      }\n    } else if (d50) {\n      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);\n    }\n    // srgb\n  } else {\n    [x, y, z] = transformRgbToXyz([r * MAX_RGB, g * MAX_RGB, b * MAX_RGB]);\n    if (d50) {\n      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);\n    }\n  }\n  return [\n    d50 ? 'xyz-d50' : 'xyz-d65',\n    roundToPrecision(x, HEX),\n    roundToPrecision(y, HEX),\n    roundToPrecision(z, HEX),\n    format === VAL_MIX && v4 === NONE ? v4 : alpha\n  ];\n};\n\n/**\n * parse color value\n * @param value - CSS color value\n * @param [opt] - options\n * @returns parsed color\n *   - ['xyz-(d50|d65)', x, y, z, alpha], ['rgb', r, g, b, alpha]\n *   - value, '(empty)', NullObject\n */\nexport const parseColorValue = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.toLowerCase().trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { d50 = false, format = '', nullable = false } = opt;\n  if (!REG_COLOR.test(value)) {\n    const res = resolveInvalidColorValue(format, nullable);\n    if (res instanceof NullObject) {\n      return res;\n    }\n    if (isString(res)) {\n      return res as string;\n    }\n    return res as SpecifiedColorChannels;\n  }\n  let x = 0;\n  let y = 0;\n  let z = 0;\n  let alpha = 0;\n  // complement currentcolor as a missing color\n  if (REG_CURRENT.test(value)) {\n    if (format === VAL_COMP) {\n      return ['rgb', 0, 0, 0, 0];\n    }\n    if (format === VAL_SPEC) {\n      return value;\n    }\n    // named-color\n  } else if (/^[a-z]+$/.test(value)) {\n    if (Object.hasOwn(NAMED_COLORS, value)) {\n      if (format === VAL_SPEC) {\n        return value;\n      }\n      const [r, g, b] = NAMED_COLORS[\n        value as keyof typeof NAMED_COLORS\n      ] as TriColorChannels;\n      alpha = 1;\n      if (format === VAL_COMP) {\n        return ['rgb', r, g, b, alpha];\n      }\n      [x, y, z] = transformRgbToXyz([r, g, b], true);\n      if (d50) {\n        [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);\n      }\n    } else {\n      switch (format) {\n        case VAL_COMP: {\n          if (nullable && value !== 'transparent') {\n            return new NullObject();\n          }\n          return ['rgb', 0, 0, 0, 0];\n        }\n        case VAL_SPEC: {\n          if (value === 'transparent') {\n            return value;\n          }\n          return '';\n        }\n        case VAL_MIX: {\n          if (value === 'transparent') {\n            return ['rgb', 0, 0, 0, 0];\n          }\n          return new NullObject();\n        }\n        default:\n      }\n    }\n    // hex-color\n  } else if (value[0] === '#') {\n    if (REG_SPEC.test(format)) {\n      const rgb = convertHexToRgb(value);\n      return ['rgb', ...rgb];\n    }\n    [x, y, z, alpha] = convertHexToXyz(value);\n    if (d50) {\n      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);\n    }\n    // lab()\n  } else if (value.startsWith('lab')) {\n    if (REG_SPEC.test(format)) {\n      return parseLab(value, opt);\n    }\n    [, x, y, z, alpha] = parseLab(value) as ComputedColorChannels;\n    if (!d50) {\n      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);\n    }\n    // lch()\n  } else if (value.startsWith('lch')) {\n    if (REG_SPEC.test(format)) {\n      return parseLch(value, opt);\n    }\n    [, x, y, z, alpha] = parseLch(value) as ComputedColorChannels;\n    if (!d50) {\n      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);\n    }\n    // oklab()\n  } else if (value.startsWith('oklab')) {\n    if (REG_SPEC.test(format)) {\n      return parseOklab(value, opt);\n    }\n    [, x, y, z, alpha] = parseOklab(value) as ComputedColorChannels;\n    if (d50) {\n      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);\n    }\n    // oklch()\n  } else if (value.startsWith('oklch')) {\n    if (REG_SPEC.test(format)) {\n      return parseOklch(value, opt);\n    }\n    [, x, y, z, alpha] = parseOklch(value) as ComputedColorChannels;\n    if (d50) {\n      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);\n    }\n  } else {\n    let r, g, b;\n    // hsl()\n    if (value.startsWith('hsl')) {\n      [, r, g, b, alpha] = parseHsl(value) as ComputedColorChannels;\n      // hwb()\n    } else if (value.startsWith('hwb')) {\n      [, r, g, b, alpha] = parseHwb(value) as ComputedColorChannels;\n      // rgb()\n    } else {\n      [, r, g, b, alpha] = parseRgb(value, opt) as ComputedColorChannels;\n    }\n    if (REG_SPEC.test(format)) {\n      return ['rgb', Math.round(r), Math.round(g), Math.round(b), alpha];\n    }\n    [x, y, z] = transformRgbToXyz([r, g, b]);\n    if (d50) {\n      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);\n    }\n  }\n  return [\n    d50 ? 'xyz-d50' : 'xyz-d65',\n    roundToPrecision(x, HEX),\n    roundToPrecision(y, HEX),\n    roundToPrecision(z, HEX),\n    alpha\n  ];\n};\n\n/**\n * resolve color value\n * @param value - CSS color value\n * @param [opt] - options\n * @returns resolved color\n *   - [cs, v1, v2, v3, alpha], value, '(empty)', NullObject\n */\nexport const resolveColorValue = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.toLowerCase().trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { colorSpace = '', format = '', nullable = false } = opt;\n  const cacheKey: string = createCacheKey(\n    {\n      namespace: NAMESPACE,\n      name: 'resolveColorValue',\n      value\n    },\n    opt\n  );\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    if (cachedResult.isNull) {\n      return cachedResult as NullObject;\n    }\n    const cachedItem = cachedResult.item;\n    if (isString(cachedItem)) {\n      return cachedItem as string;\n    }\n    return cachedItem as SpecifiedColorChannels;\n  }\n  if (!REG_COLOR.test(value)) {\n    const res = resolveInvalidColorValue(format, nullable);\n    if (res instanceof NullObject) {\n      setCache(cacheKey, null);\n      return res;\n    }\n    setCache(cacheKey, res);\n    if (isString(res)) {\n      return res as string;\n    }\n    return res as SpecifiedColorChannels;\n  }\n  let cs = '';\n  let r = 0;\n  let g = 0;\n  let b = 0;\n  let alpha = 0;\n  // complement currentcolor as a missing color\n  if (REG_CURRENT.test(value)) {\n    if (format === VAL_SPEC) {\n      setCache(cacheKey, value);\n      return value;\n    }\n    // named-color\n  } else if (/^[a-z]+$/.test(value)) {\n    if (Object.hasOwn(NAMED_COLORS, value)) {\n      if (format === VAL_SPEC) {\n        setCache(cacheKey, value);\n        return value;\n      }\n      [r, g, b] = NAMED_COLORS[\n        value as keyof typeof NAMED_COLORS\n      ] as TriColorChannels;\n      alpha = 1;\n    } else {\n      switch (format) {\n        case VAL_SPEC: {\n          if (value === 'transparent') {\n            setCache(cacheKey, value);\n            return value;\n          }\n          const res = '';\n          setCache(cacheKey, res);\n          return res;\n        }\n        case VAL_MIX: {\n          if (value === 'transparent') {\n            const res: SpecifiedColorChannels = ['rgb', 0, 0, 0, 0];\n            setCache(cacheKey, res);\n            return res;\n          }\n          setCache(cacheKey, null);\n          return new NullObject();\n        }\n        case VAL_COMP:\n        default: {\n          if (nullable && value !== 'transparent') {\n            setCache(cacheKey, null);\n            return new NullObject();\n          }\n          const res: SpecifiedColorChannels = ['rgb', 0, 0, 0, 0];\n          setCache(cacheKey, res);\n          return res;\n        }\n      }\n    }\n    // hex-color\n  } else if (value[0] === '#') {\n    [r, g, b, alpha] = convertHexToRgb(value);\n    // hsl()\n  } else if (value.startsWith('hsl')) {\n    [, r, g, b, alpha] = parseHsl(value, opt) as ComputedColorChannels;\n    // hwb()\n  } else if (value.startsWith('hwb')) {\n    [, r, g, b, alpha] = parseHwb(value, opt) as ComputedColorChannels;\n    // lab(), lch()\n  } else if (/^l(?:ab|ch)/.test(value)) {\n    let x, y, z;\n    if (value.startsWith('lab')) {\n      [cs, x, y, z, alpha] = parseLab(value, opt) as ComputedColorChannels;\n    } else {\n      [cs, x, y, z, alpha] = parseLch(value, opt) as ComputedColorChannels;\n    }\n    if (REG_SPEC.test(format)) {\n      const res: SpecifiedColorChannels = [cs, x, y, z, alpha];\n      setCache(cacheKey, res);\n      return res;\n    }\n    [r, g, b] = transformXyzD50ToRgb([x, y, z]);\n    // oklab(), oklch()\n  } else if (/^okl(?:ab|ch)/.test(value)) {\n    let x, y, z;\n    if (value.startsWith('oklab')) {\n      [cs, x, y, z, alpha] = parseOklab(value, opt) as ComputedColorChannels;\n    } else {\n      [cs, x, y, z, alpha] = parseOklch(value, opt) as ComputedColorChannels;\n    }\n    if (REG_SPEC.test(format)) {\n      const res: SpecifiedColorChannels = [cs, x, y, z, alpha];\n      setCache(cacheKey, res);\n      return res;\n    }\n    [r, g, b] = transformXyzToRgb([x, y, z]);\n    // rgb()\n  } else {\n    [, r, g, b, alpha] = parseRgb(value, opt) as ComputedColorChannels;\n  }\n  if (format === VAL_MIX && colorSpace === 'srgb') {\n    const res: SpecifiedColorChannels = [\n      'srgb',\n      r / MAX_RGB,\n      g / MAX_RGB,\n      b / MAX_RGB,\n      alpha\n    ];\n    setCache(cacheKey, res);\n    return res;\n  }\n  const res: SpecifiedColorChannels = [\n    'rgb',\n    Math.round(r),\n    Math.round(g),\n    Math.round(b),\n    alpha\n  ];\n  setCache(cacheKey, res);\n  return res;\n};\n\n/**\n * resolve color()\n * @param value - color function value\n * @param [opt] - options\n * @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)', NullObject\n */\nexport const resolveColorFunc = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.toLowerCase().trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { colorSpace = '', format = '', nullable = false } = opt;\n  const cacheKey: string = createCacheKey(\n    {\n      namespace: NAMESPACE,\n      name: 'resolveColorFunc',\n      value\n    },\n    opt\n  );\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    if (cachedResult.isNull) {\n      return cachedResult as NullObject;\n    }\n    const cachedItem = cachedResult.item;\n    if (isString(cachedItem)) {\n      return cachedItem as string;\n    }\n    return cachedItem as SpecifiedColorChannels;\n  }\n  if (!REG_FN_COLOR.test(value)) {\n    const res = resolveInvalidColorValue(format, nullable);\n    if (res instanceof NullObject) {\n      setCache(cacheKey, null);\n      return res;\n    }\n    setCache(cacheKey, res);\n    if (isString(res)) {\n      return res as string;\n    }\n    return res as SpecifiedColorChannels;\n  }\n  const [cs, v1, v2, v3, v4] = parseColorFunc(\n    value,\n    opt\n  ) as SpecifiedColorChannels;\n  if (REG_SPEC.test(format) || (format === VAL_MIX && cs === colorSpace)) {\n    const res: SpecifiedColorChannels = [cs, v1, v2, v3, v4];\n    setCache(cacheKey, res);\n    return res;\n  }\n  const x = parseFloat(`${v1}`);\n  const y = parseFloat(`${v2}`);\n  const z = parseFloat(`${v3}`);\n  const alpha = parseAlpha(`${v4}`);\n  const [r, g, b] = transformXyzToRgb([x, y, z], true);\n  const res: SpecifiedColorChannels = ['rgb', r, g, b, alpha];\n  setCache(cacheKey, res);\n  return res;\n};\n\n/**\n * convert color value to linear rgb\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels | NullObject - [r, g, b, alpha] r|g|b|alpha: 0..1\n */\nexport const convertColorToLinearRgb = (\n  value: string,\n  opt: {\n    colorSpace?: string;\n    format?: string;\n  } = {}\n): ColorChannels | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { colorSpace = '', format = '' } = opt;\n  let cs = '';\n  let r, g, b, alpha, x, y, z;\n  if (format === VAL_MIX) {\n    let xyz;\n    if (value.startsWith(FN_COLOR)) {\n      xyz = parseColorFunc(value, opt);\n    } else {\n      xyz = parseColorValue(value, opt);\n    }\n    if (xyz instanceof NullObject) {\n      return xyz;\n    }\n    [cs, x, y, z, alpha] = xyz as ComputedColorChannels;\n    if (cs === colorSpace) {\n      return [x, y, z, alpha];\n    }\n    [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);\n  } else if (value.startsWith(FN_COLOR)) {\n    const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;\n    const [cs] = val.match(/[^\\s,/]+/g) as StringColorSpacedChannels;\n    if (cs === 'srgb-linear') {\n      [, r, g, b, alpha] = resolveColorFunc(value, {\n        format: VAL_COMP\n      }) as ComputedColorChannels;\n    } else {\n      [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;\n      [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);\n    }\n  } else {\n    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;\n    [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);\n  }\n  return [\n    Math.min(Math.max(r, 0), 1),\n    Math.min(Math.max(g, 0), 1),\n    Math.min(Math.max(b, 0), 1),\n    alpha\n  ];\n};\n\n/**\n * convert color value to rgb\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels | NullObject\n *   - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1\n */\nexport const convertColorToRgb = (\n  value: string,\n  opt: Options = {}\n): ColorChannels | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '' } = opt;\n  let r, g, b, alpha;\n  if (format === VAL_MIX) {\n    let rgb;\n    if (value.startsWith(FN_COLOR)) {\n      rgb = resolveColorFunc(value, opt);\n    } else {\n      rgb = resolveColorValue(value, opt);\n    }\n    if (rgb instanceof NullObject) {\n      return rgb;\n    }\n    [, r, g, b, alpha] = rgb as ComputedColorChannels;\n  } else if (value.startsWith(FN_COLOR)) {\n    const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;\n    const [cs] = val.match(/[^\\s,/]+/g) as StringColorSpacedChannels;\n    if (cs === 'srgb') {\n      [, r, g, b, alpha] = resolveColorFunc(value, {\n        format: VAL_COMP\n      }) as ComputedColorChannels;\n      r *= MAX_RGB;\n      g *= MAX_RGB;\n      b *= MAX_RGB;\n    } else {\n      [, r, g, b, alpha] = resolveColorFunc(value) as ComputedColorChannels;\n    }\n  } else if (/^(?:ok)?l(?:ab|ch)/.test(value)) {\n    [r, g, b, alpha] = convertColorToLinearRgb(value) as ColorChannels;\n    [r, g, b] = transformLinearRgbToRgb([r, g, b]);\n  } else {\n    [, r, g, b, alpha] = resolveColorValue(value, {\n      format: VAL_COMP\n    }) as ComputedColorChannels;\n  }\n  return [r, g, b, alpha];\n};\n\n/**\n * convert color value to xyz\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels | NullObject - [x, y, z, alpha]\n */\nexport const convertColorToXyz = (\n  value: string,\n  opt: Options = {}\n): ColorChannels | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { d50 = false, format = '' } = opt;\n  let x, y, z, alpha;\n  if (format === VAL_MIX) {\n    let xyz;\n    if (value.startsWith(FN_COLOR)) {\n      xyz = parseColorFunc(value, opt);\n    } else {\n      xyz = parseColorValue(value, opt);\n    }\n    if (xyz instanceof NullObject) {\n      return xyz;\n    }\n    [, x, y, z, alpha] = xyz as ComputedColorChannels;\n  } else if (value.startsWith(FN_COLOR)) {\n    const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;\n    const [cs] = val.match(/[^\\s,/]+/g) as StringColorSpacedChannels;\n    if (d50) {\n      if (cs === 'xyz-d50') {\n        [, x, y, z, alpha] = resolveColorFunc(value, {\n          format: VAL_COMP\n        }) as ComputedColorChannels;\n      } else {\n        [, x, y, z, alpha] = parseColorFunc(\n          value,\n          opt\n        ) as ComputedColorChannels;\n      }\n    } else if (/^xyz(?:-d65)?$/.test(cs)) {\n      [, x, y, z, alpha] = resolveColorFunc(value, {\n        format: VAL_COMP\n      }) as ComputedColorChannels;\n    } else {\n      [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;\n    }\n  } else {\n    [, x, y, z, alpha] = parseColorValue(value, opt) as ComputedColorChannels;\n  }\n  return [x, y, z, alpha];\n};\n\n/**\n * convert color value to hsl\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels | NullObject - [h, s, l, alpha], hue may be powerless\n */\nexport const convertColorToHsl = (\n  value: string,\n  opt: Options = {}\n): ColorChannels | [number | string, number, number, number] | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '' } = opt;\n  let h, s, l, alpha;\n  if (REG_HSL.test(value)) {\n    [, h, s, l, alpha] = parseHsl(value, {\n      format: 'hsl'\n    }) as ComputedColorChannels;\n    if (format === 'hsl') {\n      return [Math.round(h), Math.round(s), Math.round(l), alpha];\n    }\n    return [h, s, l, alpha];\n  }\n  let x, y, z;\n  if (format === VAL_MIX) {\n    let xyz;\n    if (value.startsWith(FN_COLOR)) {\n      xyz = parseColorFunc(value, opt);\n    } else {\n      xyz = parseColorValue(value, opt);\n    }\n    if (xyz instanceof NullObject) {\n      return xyz;\n    }\n    [, x, y, z, alpha] = xyz as ComputedColorChannels;\n  } else if (value.startsWith(FN_COLOR)) {\n    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;\n  } else {\n    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;\n  }\n  [h, s, l] = transformXyzToHsl([x, y, z], true) as TriColorChannels;\n  if (format === 'hsl') {\n    return [Math.round(h), Math.round(s), Math.round(l), alpha];\n  }\n  return [format === VAL_MIX && s === 0 ? NONE : h, s, l, alpha];\n};\n\n/**\n * convert color value to hwb\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels | NullObject - [h, w, b, alpha], hue may be powerless\n */\nexport const convertColorToHwb = (\n  value: string,\n  opt: Options = {}\n): ColorChannels | [number | string, number, number, number] | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '' } = opt;\n  let h, w, b, alpha;\n  if (REG_HWB.test(value)) {\n    [, h, w, b, alpha] = parseHwb(value, {\n      format: 'hwb'\n    }) as ComputedColorChannels;\n    if (format === 'hwb') {\n      return [Math.round(h), Math.round(w), Math.round(b), alpha];\n    }\n    return [h, w, b, alpha];\n  }\n  let x, y, z;\n  if (format === VAL_MIX) {\n    let xyz;\n    if (value.startsWith(FN_COLOR)) {\n      xyz = parseColorFunc(value, opt);\n    } else {\n      xyz = parseColorValue(value, opt);\n    }\n    if (xyz instanceof NullObject) {\n      return xyz;\n    }\n    [, x, y, z, alpha] = xyz as ComputedColorChannels;\n  } else if (value.startsWith(FN_COLOR)) {\n    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;\n  } else {\n    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;\n  }\n  [h, w, b] = transformXyzToHwb([x, y, z], true) as TriColorChannels;\n  if (format === 'hwb') {\n    return [Math.round(h), Math.round(w), Math.round(b), alpha];\n  }\n  return [format === VAL_MIX && w + b >= 100 ? NONE : h, w, b, alpha];\n};\n\n/**\n * convert color value to lab\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels | NullObject - [l, a, b, alpha]\n */\nexport const convertColorToLab = (\n  value: string,\n  opt: Options = {}\n): ColorChannels | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '' } = opt;\n  let l, a, b, alpha;\n  if (REG_LAB.test(value)) {\n    [, l, a, b, alpha] = parseLab(value, {\n      format: VAL_COMP\n    }) as ComputedColorChannels;\n    return [l, a, b, alpha];\n  }\n  let x, y, z;\n  if (format === VAL_MIX) {\n    let xyz;\n    opt.d50 = true;\n    if (value.startsWith(FN_COLOR)) {\n      xyz = parseColorFunc(value, opt);\n    } else {\n      xyz = parseColorValue(value, opt);\n    }\n    if (xyz instanceof NullObject) {\n      return xyz;\n    }\n    [, x, y, z, alpha] = xyz as ComputedColorChannels;\n  } else if (value.startsWith(FN_COLOR)) {\n    [, x, y, z, alpha] = parseColorFunc(value, {\n      d50: true\n    }) as ComputedColorChannels;\n  } else {\n    [, x, y, z, alpha] = parseColorValue(value, {\n      d50: true\n    }) as ComputedColorChannels;\n  }\n  [l, a, b] = transformXyzD50ToLab([x, y, z], true);\n  return [l, a, b, alpha];\n};\n\n/**\n * convert color value to lch\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless\n */\nexport const convertColorToLch = (\n  value: string,\n  opt: Options = {}\n): ColorChannels | [number, number, number | string, number] | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '' } = opt;\n  let l, c, h, alpha;\n  if (REG_LCH.test(value)) {\n    [, l, c, h, alpha] = parseLch(value, {\n      format: VAL_COMP\n    }) as ComputedColorChannels;\n    return [l, c, h, alpha];\n  }\n  let x, y, z;\n  if (format === VAL_MIX) {\n    let xyz;\n    opt.d50 = true;\n    if (value.startsWith(FN_COLOR)) {\n      xyz = parseColorFunc(value, opt);\n    } else {\n      xyz = parseColorValue(value, opt);\n    }\n    if (xyz instanceof NullObject) {\n      return xyz;\n    }\n    [, x, y, z, alpha] = xyz as ComputedColorChannels;\n  } else if (value.startsWith(FN_COLOR)) {\n    [, x, y, z, alpha] = parseColorFunc(value, {\n      d50: true\n    }) as ComputedColorChannels;\n  } else {\n    [, x, y, z, alpha] = parseColorValue(value, {\n      d50: true\n    }) as ComputedColorChannels;\n  }\n  [l, c, h] = transformXyzD50ToLch([x, y, z], true);\n  return [l, c, format === VAL_MIX && c === 0 ? NONE : h, alpha];\n};\n\n/**\n * convert color value to oklab\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels | NullObject - [l, a, b, alpha]\n */\nexport const convertColorToOklab = (\n  value: string,\n  opt: Options = {}\n): ColorChannels | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '' } = opt;\n  let l, a, b, alpha;\n  if (REG_OKLAB.test(value)) {\n    [, l, a, b, alpha] = parseOklab(value, {\n      format: VAL_COMP\n    }) as ComputedColorChannels;\n    return [l, a, b, alpha];\n  }\n  let x, y, z;\n  if (format === VAL_MIX) {\n    let xyz;\n    if (value.startsWith(FN_COLOR)) {\n      xyz = parseColorFunc(value, opt);\n    } else {\n      xyz = parseColorValue(value, opt);\n    }\n    if (xyz instanceof NullObject) {\n      return xyz;\n    }\n    [, x, y, z, alpha] = xyz as ComputedColorChannels;\n  } else if (value.startsWith(FN_COLOR)) {\n    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;\n  } else {\n    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;\n  }\n  [l, a, b] = transformXyzToOklab([x, y, z], true);\n  return [l, a, b, alpha];\n};\n\n/**\n * convert color value to oklch\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless\n */\nexport const convertColorToOklch = (\n  value: string,\n  opt: Options = {}\n): ColorChannels | [number, number, number | string, number] | NullObject => {\n  if (isString(value)) {\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '' } = opt;\n  let l, c, h, alpha;\n  if (REG_OKLCH.test(value)) {\n    [, l, c, h, alpha] = parseOklch(value, {\n      format: VAL_COMP\n    }) as ComputedColorChannels;\n    return [l, c, h, alpha];\n  }\n  let x, y, z;\n  if (format === VAL_MIX) {\n    let xyz;\n    if (value.startsWith(FN_COLOR)) {\n      xyz = parseColorFunc(value, opt);\n    } else {\n      xyz = parseColorValue(value, opt);\n    }\n    if (xyz instanceof NullObject) {\n      return xyz;\n    }\n    [, x, y, z, alpha] = xyz as ComputedColorChannels;\n  } else if (value.startsWith(FN_COLOR)) {\n    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;\n  } else {\n    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;\n  }\n  [l, c, h] = transformXyzToOklch([x, y, z], true) as TriColorChannels;\n  return [l, c, format === VAL_MIX && c === 0 ? NONE : h, alpha];\n};\n\n/**\n * resolve color-mix()\n * @param value - color-mix color value\n * @param [opt] - options\n * @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)'\n */\nexport const resolveColorMix = (\n  value: string,\n  opt: Options = {}\n): SpecifiedColorChannels | string | NullObject => {\n  if (isString(value)) {\n    value = value.toLowerCase().trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const { format = '', nullable = false } = opt;\n  const cacheKey: string = createCacheKey(\n    {\n      namespace: NAMESPACE,\n      name: 'resolveColorMix',\n      value\n    },\n    opt\n  );\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    if (cachedResult.isNull) {\n      return cachedResult as NullObject;\n    }\n    const cachedItem = cachedResult.item;\n    if (isString(cachedItem)) {\n      return cachedItem as string;\n    }\n    return cachedItem as SpecifiedColorChannels;\n  }\n  const nestedItems = [];\n  let colorSpace = '';\n  let hueArc = '';\n  let colorA = '';\n  let pctA = '';\n  let colorB = '';\n  let pctB = '';\n  let parsed = false;\n  if (!REG_MIX.test(value)) {\n    // nested color-mix()\n    if (value.startsWith(FN_MIX) && REG_MIX_NEST.test(value)) {\n      const items = value.match(REG_MIX_NEST) as RegExpMatchArray;\n      for (const item of items) {\n        if (item) {\n          let val = resolveColorMix(item, {\n            format: format === VAL_SPEC ? format : VAL_COMP\n          }) as ComputedColorChannels | string;\n          // computed value\n          if (Array.isArray(val)) {\n            const [cs, v1, v2, v3, v4] = val as ComputedColorChannels;\n            if (v1 === 0 && v2 === 0 && v3 === 0 && v4 === 0) {\n              value = '';\n              break;\n            }\n            if (REG_MIX_CS_RGB_XYZ.test(cs)) {\n              if (v4 === 1) {\n                val = `color(${cs} ${v1} ${v2} ${v3})`;\n              } else {\n                val = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;\n              }\n            } else if (v4 === 1) {\n              val = `${cs}(${v1} ${v2} ${v3})`;\n            } else {\n              val = `${cs}(${v1} ${v2} ${v3} / ${v4})`;\n            }\n          } else if (!REG_MIX.test(val)) {\n            value = '';\n            break;\n          }\n          nestedItems.push(val);\n          value = value.replace(item, val);\n        }\n      }\n      if (!value) {\n        const res = cacheInvalidColorValue(cacheKey, format, nullable);\n        return res;\n      }\n      // contains light-dark()\n    } else if (\n      value.startsWith(FN_MIX) &&\n      value.endsWith(')') &&\n      value.includes(FN_LIGHT_DARK)\n    ) {\n      const colorParts = value.replace(FN_MIX, '').replace(/\\)$/, '');\n      const [csPart = '', partA = '', partB = ''] = splitValue(colorParts, {\n        delimiter: ','\n      });\n      const [colorPartA = '', pctPartA = ''] = splitValue(partA);\n      const [colorPartB = '', pctPartB = ''] = splitValue(partB);\n      const specifiedColorA = resolveColor(colorPartA, {\n        format: VAL_SPEC\n      }) as string;\n      const specifiedColorB = resolveColor(colorPartB, {\n        format: VAL_SPEC\n      }) as string;\n      if (REG_MIX_IN_CS.test(csPart) && specifiedColorA && specifiedColorB) {\n        if (format === VAL_SPEC) {\n          const [, cs] = csPart.match(REG_MIX_IN_CS) as MatchedRegExp;\n          if (REG_CS_HUE.test(cs)) {\n            [, colorSpace, hueArc] = cs.match(REG_CS_HUE) as MatchedRegExp;\n          } else {\n            colorSpace = cs;\n          }\n          colorA = specifiedColorA;\n          if (pctPartA) {\n            pctA = pctPartA;\n          }\n          colorB = specifiedColorB;\n          if (pctPartB) {\n            pctB = pctPartB;\n          }\n          value = value\n            .replace(colorPartA, specifiedColorA)\n            .replace(colorPartB, specifiedColorB);\n          parsed = true;\n        } else {\n          const resolvedColorA = resolveColor(colorPartA, opt);\n          const resolvedColorB = resolveColor(colorPartB, opt);\n          if (isString(resolvedColorA) && isString(resolvedColorB)) {\n            value = value\n              .replace(colorPartA, resolvedColorA)\n              .replace(colorPartB, resolvedColorB);\n          }\n        }\n      } else {\n        const res = cacheInvalidColorValue(cacheKey, format, nullable);\n        return res;\n      }\n    } else {\n      const res = cacheInvalidColorValue(cacheKey, format, nullable);\n      return res;\n    }\n  }\n  if (nestedItems.length && format === VAL_SPEC) {\n    const [, cs] = value.match(REG_MIX_START) as MatchedRegExp;\n    if (REG_CS_HUE.test(cs)) {\n      [, colorSpace, hueArc] = cs.match(REG_CS_HUE) as MatchedRegExp;\n    } else {\n      colorSpace = cs;\n    }\n    if (nestedItems.length === 2) {\n      let [itemA, itemB] = nestedItems as [string, string];\n      itemA = itemA.replace(/(?=[()])/g, '\\\\');\n      itemB = itemB.replace(/(?=[()])/g, '\\\\');\n      const regA = new RegExp(`(${itemA})(?:\\\\s+(${PCT}))?`);\n      const regB = new RegExp(`(${itemB})(?:\\\\s+(${PCT}))?`);\n      [, colorA, pctA] = value.match(regA) as MatchedRegExp;\n      [, colorB, pctB] = value.match(regB) as MatchedRegExp;\n    } else {\n      let [item] = nestedItems as [string];\n      item = item.replace(/(?=[()])/g, '\\\\');\n      const itemPart = `${item}(?:\\\\s+${PCT})?`;\n      const itemPartCapt = `(${item})(?:\\\\s+(${PCT}))?`;\n      const regItemPart = new RegExp(`^${itemPartCapt}$`);\n      const regLastItem = new RegExp(`${itemPartCapt}\\\\s*\\\\)$`);\n      // item is at the end\n      if (regLastItem.test(value)) {\n        const reg = new RegExp(\n          `(${SYN_MIX_PART})\\\\s*,\\\\s*(${itemPart})\\\\s*\\\\)$`\n        );\n        const [, colorPartA, colorPartB] = value.match(reg) as MatchedRegExp;\n        [, colorA, pctA] = colorPartA.match(\n          REG_MIX_COLOR_PART\n        ) as MatchedRegExp;\n        [, colorB, pctB] = colorPartB.match(regItemPart) as MatchedRegExp;\n      } else {\n        const reg = new RegExp(\n          `(${itemPart})\\\\s*,\\\\s*(${SYN_MIX_PART})\\\\s*\\\\)$`\n        );\n        const [, colorPartA, colorPartB] = value.match(reg) as MatchedRegExp;\n        [, colorA, pctA] = colorPartA.match(regItemPart) as MatchedRegExp;\n        [, colorB, pctB] = colorPartB.match(\n          REG_MIX_COLOR_PART\n        ) as MatchedRegExp;\n      }\n    }\n  } else if (!parsed) {\n    const [, cs, colorPartA, colorPartB] = value.match(\n      REG_MIX_CAPT\n    ) as MatchedRegExp;\n    [, colorA, pctA] = colorPartA.match(REG_MIX_COLOR_PART) as MatchedRegExp;\n    [, colorB, pctB] = colorPartB.match(REG_MIX_COLOR_PART) as MatchedRegExp;\n    if (REG_CS_HUE.test(cs)) {\n      [, colorSpace, hueArc] = cs.match(REG_CS_HUE) as MatchedRegExp;\n    } else {\n      colorSpace = cs;\n    }\n  }\n  // normalize percentages and set multipler\n  let pA, pB, m;\n  if (pctA && pctB) {\n    const p1 = parseFloat(pctA) / MAX_PCT;\n    const p2 = parseFloat(pctB) / MAX_PCT;\n    if (p1 < 0 || p1 > 1 || p2 < 0 || p2 > 1 || (p1 === 0 && p2 === 0)) {\n      const res = cacheInvalidColorValue(cacheKey, format, nullable);\n      return res;\n    }\n    const factor = p1 + p2;\n    pA = p1 / factor;\n    pB = p2 / factor;\n    m = factor < 1 ? factor : 1;\n  } else {\n    if (pctA) {\n      pA = parseFloat(pctA) / MAX_PCT;\n      if (pA < 0 || pA > 1) {\n        const res = cacheInvalidColorValue(cacheKey, format, nullable);\n        return res;\n      }\n      pB = 1 - pA;\n    } else if (pctB) {\n      pB = parseFloat(pctB) / MAX_PCT;\n      if (pB < 0 || pB > 1) {\n        const res = cacheInvalidColorValue(cacheKey, format, nullable);\n        return res;\n      }\n      pA = 1 - pB;\n    } else {\n      pA = HALF;\n      pB = HALF;\n    }\n    m = 1;\n  }\n  if (colorSpace === 'xyz') {\n    colorSpace = 'xyz-d65';\n  }\n  // specified value\n  if (format === VAL_SPEC) {\n    let valueA = '';\n    let valueB = '';\n    if (colorA.startsWith(FN_MIX) || colorA.startsWith(FN_LIGHT_DARK)) {\n      valueA = colorA;\n    } else if (colorA.startsWith(FN_COLOR)) {\n      const [cs, v1, v2, v3, v4] = parseColorFunc(\n        colorA,\n        opt\n      ) as SpecifiedColorChannels;\n      if (v4 === 1) {\n        valueA = `color(${cs} ${v1} ${v2} ${v3})`;\n      } else {\n        valueA = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;\n      }\n    } else {\n      const val = parseColorValue(colorA, opt);\n      if (Array.isArray(val)) {\n        const [cs, v1, v2, v3, v4] = val;\n        if (v4 === 1) {\n          if (cs === 'rgb') {\n            valueA = `${cs}(${v1}, ${v2}, ${v3})`;\n          } else {\n            valueA = `${cs}(${v1} ${v2} ${v3})`;\n          }\n        } else if (cs === 'rgb') {\n          valueA = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;\n        } else {\n          valueA = `${cs}(${v1} ${v2} ${v3} / ${v4})`;\n        }\n      } else {\n        if (!isString(val) || !val) {\n          setCache(cacheKey, '');\n          return '';\n        }\n        valueA = val;\n      }\n    }\n    if (colorB.startsWith(FN_MIX) || colorB.startsWith(FN_LIGHT_DARK)) {\n      valueB = colorB;\n    } else if (colorB.startsWith(FN_COLOR)) {\n      const [cs, v1, v2, v3, v4] = parseColorFunc(\n        colorB,\n        opt\n      ) as SpecifiedColorChannels;\n      if (v4 === 1) {\n        valueB = `color(${cs} ${v1} ${v2} ${v3})`;\n      } else {\n        valueB = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;\n      }\n    } else {\n      const val = parseColorValue(colorB, opt);\n      if (Array.isArray(val)) {\n        const [cs, v1, v2, v3, v4] = val;\n        if (v4 === 1) {\n          if (cs === 'rgb') {\n            valueB = `${cs}(${v1}, ${v2}, ${v3})`;\n          } else {\n            valueB = `${cs}(${v1} ${v2} ${v3})`;\n          }\n        } else if (cs === 'rgb') {\n          valueB = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;\n        } else {\n          valueB = `${cs}(${v1} ${v2} ${v3} / ${v4})`;\n        }\n      } else {\n        if (!isString(val) || !val) {\n          setCache(cacheKey, '');\n          return '';\n        }\n        valueB = val;\n      }\n    }\n    if (pctA && pctB) {\n      valueA += ` ${parseFloat(pctA)}%`;\n      valueB += ` ${parseFloat(pctB)}%`;\n    } else if (pctA) {\n      const pA = parseFloat(pctA);\n      if (pA !== MAX_PCT * HALF) {\n        valueA += ` ${pA}%`;\n      }\n    } else if (pctB) {\n      const pA = MAX_PCT - parseFloat(pctB);\n      if (pA !== MAX_PCT * HALF) {\n        valueA += ` ${pA}%`;\n      }\n    }\n    if (hueArc) {\n      const res = `color-mix(in ${colorSpace} ${hueArc} hue, ${valueA}, ${valueB})`;\n      setCache(cacheKey, res);\n      return res;\n    } else {\n      const res = `color-mix(in ${colorSpace}, ${valueA}, ${valueB})`;\n      setCache(cacheKey, res);\n      return res;\n    }\n  }\n  let r = 0;\n  let g = 0;\n  let b = 0;\n  let alpha = 0;\n  // in srgb, srgb-linear\n  if (/^srgb(?:-linear)?$/.test(colorSpace)) {\n    let rgbA, rgbB;\n    if (colorSpace === 'srgb') {\n      if (REG_CURRENT.test(colorA)) {\n        rgbA = [NONE, NONE, NONE, NONE];\n      } else {\n        rgbA = convertColorToRgb(colorA, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n      if (REG_CURRENT.test(colorB)) {\n        rgbB = [NONE, NONE, NONE, NONE];\n      } else {\n        rgbB = convertColorToRgb(colorB, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n    } else {\n      if (REG_CURRENT.test(colorA)) {\n        rgbA = [NONE, NONE, NONE, NONE];\n      } else {\n        rgbA = convertColorToLinearRgb(colorA, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n      if (REG_CURRENT.test(colorB)) {\n        rgbB = [NONE, NONE, NONE, NONE];\n      } else {\n        rgbB = convertColorToLinearRgb(colorB, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n    }\n    if (rgbA instanceof NullObject || rgbB instanceof NullObject) {\n      const res = cacheInvalidColorValue(cacheKey, format, nullable);\n      return res;\n    }\n    const [rrA, ggA, bbA, aaA] = rgbA as NumStrColorChannels;\n    const [rrB, ggB, bbB, aaB] = rgbB as NumStrColorChannels;\n    const rNone = rrA === NONE && rrB === NONE;\n    const gNone = ggA === NONE && ggB === NONE;\n    const bNone = bbA === NONE && bbB === NONE;\n    const alphaNone = aaA === NONE && aaB === NONE;\n    const [[rA, gA, bA, alphaA], [rB, gB, bB, alphaB]] =\n      normalizeColorComponents(\n        [rrA, ggA, bbA, aaA],\n        [rrB, ggB, bbB, aaB],\n        true\n      );\n    const factorA = alphaA * pA;\n    const factorB = alphaB * pB;\n    alpha = factorA + factorB;\n    if (alpha === 0) {\n      r = rA * pA + rB * pB;\n      g = gA * pA + gB * pB;\n      b = bA * pA + bB * pB;\n    } else {\n      r = (rA * factorA + rB * factorB) / alpha;\n      g = (gA * factorA + gB * factorB) / alpha;\n      b = (bA * factorA + bB * factorB) / alpha;\n      alpha = parseFloat(alpha.toFixed(3));\n    }\n    if (format === VAL_COMP) {\n      const res: SpecifiedColorChannels = [\n        colorSpace,\n        rNone ? NONE : roundToPrecision(r, HEX),\n        gNone ? NONE : roundToPrecision(g, HEX),\n        bNone ? NONE : roundToPrecision(b, HEX),\n        alphaNone ? NONE : alpha * m\n      ];\n      setCache(cacheKey, res);\n      return res;\n    }\n    r *= MAX_RGB;\n    g *= MAX_RGB;\n    b *= MAX_RGB;\n    // in xyz, xyz-d65, xyz-d50\n  } else if (REG_CS_XYZ.test(colorSpace)) {\n    let xyzA, xyzB;\n    if (REG_CURRENT.test(colorA)) {\n      xyzA = [NONE, NONE, NONE, NONE];\n    } else {\n      xyzA = convertColorToXyz(colorA, {\n        colorSpace,\n        d50: colorSpace === 'xyz-d50',\n        format: VAL_MIX\n      });\n    }\n    if (REG_CURRENT.test(colorB)) {\n      xyzB = [NONE, NONE, NONE, NONE];\n    } else {\n      xyzB = convertColorToXyz(colorB, {\n        colorSpace,\n        d50: colorSpace === 'xyz-d50',\n        format: VAL_MIX\n      });\n    }\n    if (xyzA instanceof NullObject || xyzB instanceof NullObject) {\n      const res = cacheInvalidColorValue(cacheKey, format, nullable);\n      return res;\n    }\n    const [xxA, yyA, zzA, aaA] = xyzA;\n    const [xxB, yyB, zzB, aaB] = xyzB;\n    const xNone = xxA === NONE && xxB === NONE;\n    const yNone = yyA === NONE && yyB === NONE;\n    const zNone = zzA === NONE && zzB === NONE;\n    const alphaNone = aaA === NONE && aaB === NONE;\n    const [[xA, yA, zA, alphaA], [xB, yB, zB, alphaB]] =\n      normalizeColorComponents(\n        [xxA, yyA, zzA, aaA],\n        [xxB, yyB, zzB, aaB],\n        true\n      );\n    const factorA = alphaA * pA;\n    const factorB = alphaB * pB;\n    alpha = factorA + factorB;\n    let x, y, z;\n    if (alpha === 0) {\n      x = xA * pA + xB * pB;\n      y = yA * pA + yB * pB;\n      z = zA * pA + zB * pB;\n    } else {\n      x = (xA * factorA + xB * factorB) / alpha;\n      y = (yA * factorA + yB * factorB) / alpha;\n      z = (zA * factorA + zB * factorB) / alpha;\n      alpha = parseFloat(alpha.toFixed(3));\n    }\n    if (format === VAL_COMP) {\n      const res: SpecifiedColorChannels = [\n        colorSpace,\n        xNone ? NONE : roundToPrecision(x, HEX),\n        yNone ? NONE : roundToPrecision(y, HEX),\n        zNone ? NONE : roundToPrecision(z, HEX),\n        alphaNone ? NONE : alpha * m\n      ];\n      setCache(cacheKey, res);\n      return res;\n    }\n    if (colorSpace === 'xyz-d50') {\n      [r, g, b] = transformXyzD50ToRgb([x, y, z], true);\n    } else {\n      [r, g, b] = transformXyzToRgb([x, y, z], true);\n    }\n    // in hsl, hwb\n  } else if (/^h(?:sl|wb)$/.test(colorSpace)) {\n    let hslA, hslB;\n    if (colorSpace === 'hsl') {\n      if (REG_CURRENT.test(colorA)) {\n        hslA = [NONE, NONE, NONE, NONE];\n      } else {\n        hslA = convertColorToHsl(colorA, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n      if (REG_CURRENT.test(colorB)) {\n        hslB = [NONE, NONE, NONE, NONE];\n      } else {\n        hslB = convertColorToHsl(colorB, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n    } else {\n      if (REG_CURRENT.test(colorA)) {\n        hslA = [NONE, NONE, NONE, NONE];\n      } else {\n        hslA = convertColorToHwb(colorA, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n      if (REG_CURRENT.test(colorB)) {\n        hslB = [NONE, NONE, NONE, NONE];\n      } else {\n        hslB = convertColorToHwb(colorB, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n    }\n    if (hslA instanceof NullObject || hslB instanceof NullObject) {\n      const res = cacheInvalidColorValue(cacheKey, format, nullable);\n      return res;\n    }\n    const [hhA, ssA, llA, aaA] = hslA;\n    const [hhB, ssB, llB, aaB] = hslB;\n    const alphaNone = aaA === NONE && aaB === NONE;\n    let [[hA, sA, lA, alphaA], [hB, sB, lB, alphaB]] = normalizeColorComponents(\n      [hhA, ssA, llA, aaA],\n      [hhB, ssB, llB, aaB],\n      true\n    );\n    if (hueArc) {\n      [hA, hB] = interpolateHue(hA, hB, hueArc);\n    }\n    const factorA = alphaA * pA;\n    const factorB = alphaB * pB;\n    alpha = factorA + factorB;\n    const h = (hA * pA + hB * pB) % DEG;\n    let s, l;\n    if (alpha === 0) {\n      s = sA * pA + sB * pB;\n      l = lA * pA + lB * pB;\n    } else {\n      s = (sA * factorA + sB * factorB) / alpha;\n      l = (lA * factorA + lB * factorB) / alpha;\n      alpha = parseFloat(alpha.toFixed(3));\n    }\n    [r, g, b] = convertColorToRgb(\n      `${colorSpace}(${h} ${s} ${l})`\n    ) as ColorChannels;\n    if (format === VAL_COMP) {\n      const res: SpecifiedColorChannels = [\n        'srgb',\n        roundToPrecision(r / MAX_RGB, HEX),\n        roundToPrecision(g / MAX_RGB, HEX),\n        roundToPrecision(b / MAX_RGB, HEX),\n        alphaNone ? NONE : alpha * m\n      ];\n      setCache(cacheKey, res);\n      return res;\n    }\n    // in lch, oklch\n  } else if (/^(?:ok)?lch$/.test(colorSpace)) {\n    let lchA, lchB;\n    if (colorSpace === 'lch') {\n      if (REG_CURRENT.test(colorA)) {\n        lchA = [NONE, NONE, NONE, NONE];\n      } else {\n        lchA = convertColorToLch(colorA, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n      if (REG_CURRENT.test(colorB)) {\n        lchB = [NONE, NONE, NONE, NONE];\n      } else {\n        lchB = convertColorToLch(colorB, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n    } else {\n      if (REG_CURRENT.test(colorA)) {\n        lchA = [NONE, NONE, NONE, NONE];\n      } else {\n        lchA = convertColorToOklch(colorA, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n      if (REG_CURRENT.test(colorB)) {\n        lchB = [NONE, NONE, NONE, NONE];\n      } else {\n        lchB = convertColorToOklch(colorB, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n    }\n    if (lchA instanceof NullObject || lchB instanceof NullObject) {\n      const res = cacheInvalidColorValue(cacheKey, format, nullable);\n      return res;\n    }\n    const [llA, ccA, hhA, aaA] = lchA;\n    const [llB, ccB, hhB, aaB] = lchB;\n    const lNone = llA === NONE && llB === NONE;\n    const cNone = ccA === NONE && ccB === NONE;\n    const hNone = hhA === NONE && hhB === NONE;\n    const alphaNone = aaA === NONE && aaB === NONE;\n    let [[lA, cA, hA, alphaA], [lB, cB, hB, alphaB]] = normalizeColorComponents(\n      [llA, ccA, hhA, aaA],\n      [llB, ccB, hhB, aaB],\n      true\n    );\n    if (hueArc) {\n      [hA, hB] = interpolateHue(hA, hB, hueArc);\n    }\n    const factorA = alphaA * pA;\n    const factorB = alphaB * pB;\n    alpha = factorA + factorB;\n    const h = (hA * pA + hB * pB) % DEG;\n    let l, c;\n    if (alpha === 0) {\n      l = lA * pA + lB * pB;\n      c = cA * pA + cB * pB;\n    } else {\n      l = (lA * factorA + lB * factorB) / alpha;\n      c = (cA * factorA + cB * factorB) / alpha;\n      alpha = parseFloat(alpha.toFixed(3));\n    }\n    if (format === VAL_COMP) {\n      const res: SpecifiedColorChannels = [\n        colorSpace,\n        lNone ? NONE : roundToPrecision(l, HEX),\n        cNone ? NONE : roundToPrecision(c, HEX),\n        hNone ? NONE : roundToPrecision(h, HEX),\n        alphaNone ? NONE : alpha * m\n      ];\n      setCache(cacheKey, res);\n      return res;\n    }\n    [, r, g, b] = resolveColorValue(\n      `${colorSpace}(${l} ${c} ${h})`\n    ) as ComputedColorChannels;\n    // in lab, oklab\n  } else {\n    let labA, labB;\n    if (colorSpace === 'lab') {\n      if (REG_CURRENT.test(colorA)) {\n        labA = [NONE, NONE, NONE, NONE];\n      } else {\n        labA = convertColorToLab(colorA, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n      if (REG_CURRENT.test(colorB)) {\n        labB = [NONE, NONE, NONE, NONE];\n      } else {\n        labB = convertColorToLab(colorB, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n    } else {\n      if (REG_CURRENT.test(colorA)) {\n        labA = [NONE, NONE, NONE, NONE];\n      } else {\n        labA = convertColorToOklab(colorA, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n      if (REG_CURRENT.test(colorB)) {\n        labB = [NONE, NONE, NONE, NONE];\n      } else {\n        labB = convertColorToOklab(colorB, {\n          colorSpace,\n          format: VAL_MIX\n        });\n      }\n    }\n    if (labA instanceof NullObject || labB instanceof NullObject) {\n      const res = cacheInvalidColorValue(cacheKey, format, nullable);\n      return res;\n    }\n    const [llA, aaA, bbA, alA] = labA;\n    const [llB, aaB, bbB, alB] = labB;\n    const lNone = llA === NONE && llB === NONE;\n    const aNone = aaA === NONE && aaB === NONE;\n    const bNone = bbA === NONE && bbB === NONE;\n    const alphaNone = alA === NONE && alB === NONE;\n    const [[lA, aA, bA, alphaA], [lB, aB, bB, alphaB]] =\n      normalizeColorComponents(\n        [llA, aaA, bbA, alA],\n        [llB, aaB, bbB, alB],\n        true\n      );\n    const factorA = alphaA * pA;\n    const factorB = alphaB * pB;\n    alpha = factorA + factorB;\n    let l, aO, bO;\n    if (alpha === 0) {\n      l = lA * pA + lB * pB;\n      aO = aA * pA + aB * pB;\n      bO = bA * pA + bB * pB;\n    } else {\n      l = (lA * factorA + lB * factorB) / alpha;\n      aO = (aA * factorA + aB * factorB) / alpha;\n      bO = (bA * factorA + bB * factorB) / alpha;\n      alpha = parseFloat(alpha.toFixed(3));\n    }\n    if (format === VAL_COMP) {\n      const res: SpecifiedColorChannels = [\n        colorSpace,\n        lNone ? NONE : roundToPrecision(l, HEX),\n        aNone ? NONE : roundToPrecision(aO, HEX),\n        bNone ? NONE : roundToPrecision(bO, HEX),\n        alphaNone ? NONE : alpha * m\n      ];\n      setCache(cacheKey, res);\n      return res;\n    }\n    [, r, g, b] = resolveColorValue(\n      `${colorSpace}(${l} ${aO} ${bO})`\n    ) as ComputedColorChannels;\n  }\n  const res: SpecifiedColorChannels = [\n    'rgb',\n    Math.round(r),\n    Math.round(g),\n    Math.round(b),\n    parseFloat((alpha * m).toFixed(3))\n  ];\n  setCache(cacheKey, res);\n  return res;\n};\n"],"mappings":"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"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/common.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/common.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6039ef34009d879c2c6986b1778c940d8f914a6b
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/common.d.ts
@@ -0,0 +1,21 @@
+/**
+ * common
+ */
+/**
+ * get type
+ * @param o - object to check
+ * @returns type of object
+ */
+export declare const getType: (o: unknown) => string;
+/**
+ * is string
+ * @param o - object to check
+ * @returns result
+ */
+export declare const isString: (o: unknown) => o is string;
+/**
+ * is string or number
+ * @param o - object to check
+ * @returns result
+ */
+export declare const isStringOrNumber: (o: unknown) => boolean;
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/common.js b/node_modules/@asamuzakjp/css-color/dist/esm/js/common.js
new file mode 100644
index 0000000000000000000000000000000000000000..dec91c64bacfb34954fadf55403c5e8425f3c77b
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/common.js
@@ -0,0 +1,17 @@
+//#region src/js/common.ts
+/**
+* is string
+* @param o - object to check
+* @returns result
+*/
+var isString = (o) => typeof o === "string" || o instanceof String;
+/**
+* is string or number
+* @param o - object to check
+* @returns result
+*/
+var isStringOrNumber = (o) => isString(o) || typeof o === "number";
+//#endregion
+export { isString, isStringOrNumber };
+
+//# sourceMappingURL=common.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/common.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/js/common.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..0a8abaac6a81d118f6d3e5e84c7b7254374e6d6d
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/common.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"common.js","names":[],"sources":["../../../src/js/common.ts"],"sourcesContent":["/**\n * common\n */\n\n/* numeric constants */\nconst TYPE_FROM = 8;\nconst TYPE_TO = -1;\n\n/**\n * get type\n * @param o - object to check\n * @returns type of object\n */\nexport const getType = (o: unknown): string =>\n  Object.prototype.toString.call(o).slice(TYPE_FROM, TYPE_TO);\n\n/**\n * is string\n * @param o - object to check\n * @returns result\n */\nexport const isString = (o: unknown): o is string =>\n  typeof o === 'string' || o instanceof String;\n\n/**\n * is string or number\n * @param o - object to check\n * @returns result\n */\nexport const isStringOrNumber = (o: unknown): boolean =>\n  isString(o) || typeof o === 'number';\n"],"mappings":";;;;;;AAqBA,IAAa,YAAY,MACvB,OAAO,MAAM,YAAY,aAAa;;;;;;AAOxC,IAAa,oBAAoB,MAC/B,SAAS,EAAE,IAAI,OAAO,MAAM"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/constant.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/constant.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..287e617c035dcabcddcf9729515bbeb309fe3c7d
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/constant.d.ts
@@ -0,0 +1,43 @@
+/**
+ * constant
+ */
+export declare const ANGLE = "deg|g?rad|turn";
+export declare const LENGTH = "[cm]m|[dls]?v(?:[bhiw]|max|min)|in|p[ctx]|q|r?(?:[cl]h|cap|e[mx]|ic)";
+export declare const NUM = "[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?";
+export declare const NUM_POSITIVE = "\\+?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?";
+export declare const NONE = "none";
+export declare const PCT = "[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%";
+export declare const SYN_FN_CALC = "^(?:calc|clamp|max|min|exp|hypot|log|pow|sqrt|abs|sign|mod|rem|round|a?(?:cos|sin|tan)|atan2)\\(|(?<=[*\\/\\s\\(])(?:calc|clamp|max|min|exp|hypot|log|pow|sqrt|abs|sign|mod|rem|round|a?(?:cos|sin|tan)|atan2)\\(";
+export declare const SYN_FN_MATH_START = "^(?:clamp|max|min|exp|hypot|log|pow|sqrt|abs|sign|mod|rem|round|a?(?:cos|sin|tan)|atan2)\\($";
+export declare const SYN_FN_VAR = "^var\\(|(?<=[*\\/\\s\\(])var\\(";
+export declare const SYN_FN_VAR_START = "^(?:var|calc|clamp|max|min|exp|hypot|log|pow|sqrt|abs|sign|mod|rem|round|a?(?:cos|sin|tan)|atan2)\\(";
+export declare const CS_HUE = "(?:(?:ok)?lch|hsl|hwb)(?:\\s(?:(?:de|in)creasing|longer|shorter)\\shue)?";
+export declare const CS_HUE_CAPT = "((?:ok)?lch|hsl|hwb)(?:\\s((?:de|in)creasing|longer|shorter)\\shue)?";
+export declare const CS_LAB = "(?:ok)?lab";
+export declare const CS_LCH = "(?:ok)?lch";
+export declare const CS_SRGB = "srgb(?:-linear)?";
+export declare const CS_RGB = "(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?";
+export declare const CS_XYZ = "xyz(?:-d(?:50|65))?";
+export declare const CS_RECT = "(?:ok)?lab|(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?|xyz(?:-d(?:50|65))?";
+export declare const CS_MIX = "(?:(?:ok)?lch|hsl|hwb)(?:\\s(?:(?:de|in)creasing|longer|shorter)\\shue)?|(?:ok)?lab|(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?|xyz(?:-d(?:50|65))?";
+export declare const FN_COLOR = "color(";
+export declare const FN_LIGHT_DARK = "light-dark(";
+export declare const FN_MIX = "color-mix(";
+export declare const FN_REL = "(?:(?:ok)?l(?:ab|ch)|color|hsla?|hwb|rgba?)\\(\\s*from\\s+";
+export declare const FN_REL_CAPT = "((?:ok)?l(?:ab|ch)|color|hsla?|hwb|rgba?)\\(\\s*from\\s+";
+export declare const FN_VAR = "var(";
+export declare const SYN_FN_COLOR = "(?:(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?|xyz(?:-d(?:50|65))?)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){3}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?";
+export declare const SYN_FN_LIGHT_DARK = "^light-dark\\(";
+export declare const SYN_FN_REL = "^(?:(?:ok)?l(?:ab|ch)|color|hsla?|hwb|rgba?)\\(\\s*from\\s+|(?<=[\\s])(?:(?:ok)?l(?:ab|ch)|color|hsla?|hwb|rgba?)\\(\\s*from\\s+";
+export declare const SYN_HSL = "(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?";
+export declare const SYN_HSL_LV3 = "[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2}(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?";
+export declare const SYN_LCH = "(?:(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)\\s+){2}(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?";
+export declare const SYN_MOD = "(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?";
+export declare const SYN_RGB_LV3 = "(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?){2}|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2})(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?";
+export declare const SYN_COLOR_TYPE = "[a-z]+|#[\\da-f]{3}|#[\\da-f]{4}|#[\\da-f]{6}|#[\\da-f]{8}|hsla?\\(\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2}(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|rgba?\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?){2}|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2})(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|(?:hsla?|hwb)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:(?:ok)?lab|rgba?)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:ok)?lch\\(\\s*(?:(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)\\s+){2}(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|color\\(\\s*(?:(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?|xyz(?:-d(?:50|65))?)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){3}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)";
+export declare const SYN_MIX_PART = "(?:[a-z]+|#[\\da-f]{3}|#[\\da-f]{4}|#[\\da-f]{6}|#[\\da-f]{8}|hsla?\\(\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2}(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|rgba?\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?){2}|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2})(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|(?:hsla?|hwb)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:(?:ok)?lab|rgba?)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:ok)?lch\\(\\s*(?:(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)\\s+){2}(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|color\\(\\s*(?:(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?|xyz(?:-d(?:50|65))?)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){3}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\))(?:\\s+[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%)?";
+export declare const SYN_MIX = "color-mix\\(\\s*in\\s+(?:(?:(?:ok)?lch|hsl|hwb)(?:\\s(?:(?:de|in)creasing|longer|shorter)\\shue)?|(?:ok)?lab|(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?|xyz(?:-d(?:50|65))?)\\s*,\\s*(?:[a-z]+|#[\\da-f]{3}|#[\\da-f]{4}|#[\\da-f]{6}|#[\\da-f]{8}|hsla?\\(\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2}(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|rgba?\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?){2}|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2})(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|(?:hsla?|hwb)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:(?:ok)?lab|rgba?)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:ok)?lch\\(\\s*(?:(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)\\s+){2}(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|color\\(\\s*(?:(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?|xyz(?:-d(?:50|65))?)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){3}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\))(?:\\s+[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%)?\\s*,\\s*(?:[a-z]+|#[\\da-f]{3}|#[\\da-f]{4}|#[\\da-f]{6}|#[\\da-f]{8}|hsla?\\(\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2}(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|rgba?\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?){2}|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2})(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|(?:hsla?|hwb)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:(?:ok)?lab|rgba?)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:ok)?lch\\(\\s*(?:(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)\\s+){2}(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|color\\(\\s*(?:(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?|xyz(?:-d(?:50|65))?)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){3}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\))(?:\\s+[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%)?\\s*\\)";
+export declare const SYN_MIX_CAPT = "color-mix\\(\\s*in\\s+((?:(?:ok)?lch|hsl|hwb)(?:\\s(?:(?:de|in)creasing|longer|shorter)\\shue)?|(?:ok)?lab|(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?|xyz(?:-d(?:50|65))?)\\s*,\\s*((?:[a-z]+|#[\\da-f]{3}|#[\\da-f]{4}|#[\\da-f]{6}|#[\\da-f]{8}|hsla?\\(\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2}(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|rgba?\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?){2}|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2})(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|(?:hsla?|hwb)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:(?:ok)?lab|rgba?)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:ok)?lch\\(\\s*(?:(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)\\s+){2}(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|color\\(\\s*(?:(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?|xyz(?:-d(?:50|65))?)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){3}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\))(?:\\s+[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%)?)\\s*,\\s*((?:[a-z]+|#[\\da-f]{3}|#[\\da-f]{4}|#[\\da-f]{6}|#[\\da-f]{8}|hsla?\\(\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2}(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|rgba?\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?){2}|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%(?:\\s*,\\s*[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%){2})(?:\\s*,\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%))?\\s*\\)|(?:hsla?|hwb)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:(?:ok)?lab|rgba?)\\(\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){2}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|(?:ok)?lch\\(\\s*(?:(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)\\s+){2}(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?(?:deg|g?rad|turn)?|none)(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\)|color\\(\\s*(?:(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?|xyz(?:-d(?:50|65))?)(?:\\s+(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none)){3}(?:\\s*\\/\\s*(?:[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?|[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%|none))?\\s*\\))(?:\\s+[+-]?(?:(?:0|[1-9]\\d*)(?:\\.\\d*)?|\\.\\d+)(?:e-?(?:0|[1-9]\\d*))?%)?)\\s*\\)";
+export declare const VAL_COMP = "computedValue";
+export declare const VAL_MIX = "mixValue";
+export declare const VAL_SPEC = "specifiedValue";
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/constant.js b/node_modules/@asamuzakjp/css-color/dist/esm/js/constant.js
new file mode 100644
index 0000000000000000000000000000000000000000..6fed58c036bcbf83726a130f00c394ce776fc862
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/constant.js
@@ -0,0 +1,60 @@
+//#region src/js/constant.ts
+/**
+* constant
+*/
+var _DIGIT = "(?:0|[1-9]\\d*)";
+var _MATH = `clamp|max|min|exp|hypot|log|pow|sqrt|abs|sign|mod|rem|round|a?(?:cos|sin|tan)|atan2`;
+var _CALC = `calc|${_MATH}`;
+var _VAR = `var|${_CALC}`;
+var ANGLE = "deg|g?rad|turn";
+var LENGTH = "[cm]m|[dls]?v(?:[bhiw]|max|min)|in|p[ctx]|q|r?(?:[cl]h|cap|e[mx]|ic)";
+var NUM = `[+-]?(?:${_DIGIT}(?:\\.\\d*)?|\\.\\d+)(?:e-?${_DIGIT})?`;
+var NUM_POSITIVE = `\\+?(?:${_DIGIT}(?:\\.\\d*)?|\\.\\d+)(?:e-?${_DIGIT})?`;
+var NONE = "none";
+var PCT = `${NUM}%`;
+var SYN_FN_CALC = `^(?:${_CALC})\\(|(?<=[*\\/\\s\\(])(?:${_CALC})\\(`;
+var SYN_FN_MATH_START = `^(?:${_MATH})\\($`;
+var SYN_FN_VAR = "^var\\(|(?<=[*\\/\\s\\(])var\\(";
+var SYN_FN_VAR_START = `^(?:${_VAR})\\(`;
+var _ALPHA = `(?:\\s*\\/\\s*(?:${NUM}|${PCT}|${NONE}))?`;
+var _ALPHA_LV3 = `(?:\\s*,\\s*(?:${NUM}|${PCT}))?`;
+var _COLOR_FUNC = "(?:ok)?l(?:ab|ch)|color|hsla?|hwb|rgba?";
+var _COLOR_KEY = "[a-z]+|#[\\da-f]{3}|#[\\da-f]{4}|#[\\da-f]{6}|#[\\da-f]{8}";
+var _CS_HUE = "(?:ok)?lch|hsl|hwb";
+var _CS_HUE_ARC = "(?:de|in)creasing|longer|shorter";
+var _NUM_ANGLE = `${NUM}(?:${ANGLE})?`;
+var _NUM_ANGLE_NONE = `(?:${NUM}(?:${ANGLE})?|${NONE})`;
+var _NUM_PCT_NONE = `(?:${NUM}|${PCT}|${NONE})`;
+var CS_HUE = `(?:${_CS_HUE})(?:\\s(?:${_CS_HUE_ARC})\\shue)?`;
+var CS_HUE_CAPT = `(${_CS_HUE})(?:\\s(${_CS_HUE_ARC})\\shue)?`;
+var CS_LAB = "(?:ok)?lab";
+var CS_LCH = "(?:ok)?lch";
+var CS_RGB = `(?:a98|prophoto)-rgb|display-p3|rec2020|srgb(?:-linear)?`;
+var CS_XYZ = "xyz(?:-d(?:50|65))?";
+var CS_RECT = `${CS_LAB}|${CS_RGB}|${CS_XYZ}`;
+var CS_MIX = `${CS_HUE}|${CS_RECT}`;
+var FN_COLOR = "color(";
+var FN_LIGHT_DARK = "light-dark(";
+var FN_MIX = "color-mix(";
+var FN_REL = `(?:${_COLOR_FUNC})\\(\\s*from\\s+`;
+var FN_REL_CAPT = `(${_COLOR_FUNC})\\(\\s*from\\s+`;
+var FN_VAR = "var(";
+var SYN_FN_COLOR = `(?:${CS_RGB}|${CS_XYZ})(?:\\s+${_NUM_PCT_NONE}){3}${_ALPHA}`;
+var SYN_FN_LIGHT_DARK = "^light-dark\\(";
+var SYN_FN_REL = `^${FN_REL}|(?<=[\\s])${FN_REL}`;
+var SYN_HSL = `${_NUM_ANGLE_NONE}(?:\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;
+var SYN_HSL_LV3 = `${_NUM_ANGLE}(?:\\s*,\\s*${PCT}){2}${_ALPHA_LV3}`;
+var SYN_LCH = `(?:${_NUM_PCT_NONE}\\s+){2}${_NUM_ANGLE_NONE}${_ALPHA}`;
+var SYN_MOD = `${_NUM_PCT_NONE}(?:\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;
+var SYN_RGB_LV3 = `(?:${NUM}(?:\\s*,\\s*${NUM}){2}|${PCT}(?:\\s*,\\s*${PCT}){2})${_ALPHA_LV3}`;
+var SYN_COLOR_TYPE = `${_COLOR_KEY}|hsla?\\(\\s*${SYN_HSL_LV3}\\s*\\)|rgba?\\(\\s*${SYN_RGB_LV3}\\s*\\)|(?:hsla?|hwb)\\(\\s*${SYN_HSL}\\s*\\)|(?:(?:ok)?lab|rgba?)\\(\\s*${SYN_MOD}\\s*\\)|(?:ok)?lch\\(\\s*${SYN_LCH}\\s*\\)|color\\(\\s*${SYN_FN_COLOR}\\s*\\)`;
+var SYN_MIX_PART = `(?:${SYN_COLOR_TYPE})(?:\\s+${PCT})?`;
+var SYN_MIX = `color-mix\\(\\s*in\\s+(?:${CS_MIX})\\s*,\\s*${SYN_MIX_PART}\\s*,\\s*${SYN_MIX_PART}\\s*\\)`;
+var SYN_MIX_CAPT = `color-mix\\(\\s*in\\s+(${CS_MIX})\\s*,\\s*(${SYN_MIX_PART})\\s*,\\s*(${SYN_MIX_PART})\\s*\\)`;
+var VAL_COMP = "computedValue";
+var VAL_MIX = "mixValue";
+var VAL_SPEC = "specifiedValue";
+//#endregion
+export { ANGLE, CS_HUE, CS_HUE_CAPT, CS_LAB, CS_LCH, CS_MIX, CS_RECT, CS_RGB, CS_XYZ, FN_COLOR, FN_LIGHT_DARK, FN_MIX, FN_REL, FN_REL_CAPT, FN_VAR, LENGTH, NONE, NUM, NUM_POSITIVE, PCT, SYN_COLOR_TYPE, SYN_FN_CALC, SYN_FN_COLOR, SYN_FN_LIGHT_DARK, SYN_FN_MATH_START, SYN_FN_REL, SYN_FN_VAR, SYN_FN_VAR_START, SYN_HSL, SYN_HSL_LV3, SYN_LCH, SYN_MIX, SYN_MIX_CAPT, SYN_MIX_PART, SYN_MOD, SYN_RGB_LV3, VAL_COMP, VAL_MIX, VAL_SPEC };
+
+//# sourceMappingURL=constant.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/constant.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/js/constant.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..c540ed0cbbfbd22f7f78c3656553c8e0b484d9b0
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/constant.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"constant.js","names":[],"sources":["../../../src/js/constant.ts"],"sourcesContent":["/**\n * constant\n */\n\n/* values and units */\nconst _DIGIT = '(?:0|[1-9]\\\\d*)';\nconst _COMPARE = 'clamp|max|min';\nconst _EXPO = 'exp|hypot|log|pow|sqrt';\nconst _SIGN = 'abs|sign';\nconst _STEP = 'mod|rem|round';\nconst _TRIG = 'a?(?:cos|sin|tan)|atan2';\nconst _MATH = `${_COMPARE}|${_EXPO}|${_SIGN}|${_STEP}|${_TRIG}`;\nconst _CALC = `calc|${_MATH}`;\nconst _VAR = `var|${_CALC}`;\nexport const ANGLE = 'deg|g?rad|turn';\nexport const LENGTH =\n  '[cm]m|[dls]?v(?:[bhiw]|max|min)|in|p[ctx]|q|r?(?:[cl]h|cap|e[mx]|ic)';\nexport const NUM = `[+-]?(?:${_DIGIT}(?:\\\\.\\\\d*)?|\\\\.\\\\d+)(?:e-?${_DIGIT})?`;\nexport const NUM_POSITIVE = `\\\\+?(?:${_DIGIT}(?:\\\\.\\\\d*)?|\\\\.\\\\d+)(?:e-?${_DIGIT})?`;\nexport const NONE = 'none';\nexport const PCT = `${NUM}%`;\nexport const SYN_FN_CALC = `^(?:${_CALC})\\\\(|(?<=[*\\\\/\\\\s\\\\(])(?:${_CALC})\\\\(`;\nexport const SYN_FN_MATH_START = `^(?:${_MATH})\\\\($`;\nexport const SYN_FN_VAR = '^var\\\\(|(?<=[*\\\\/\\\\s\\\\(])var\\\\(';\nexport const SYN_FN_VAR_START = `^(?:${_VAR})\\\\(`;\n\n/* colors */\nconst _ALPHA = `(?:\\\\s*\\\\/\\\\s*(?:${NUM}|${PCT}|${NONE}))?`;\nconst _ALPHA_LV3 = `(?:\\\\s*,\\\\s*(?:${NUM}|${PCT}))?`;\nconst _COLOR_FUNC = '(?:ok)?l(?:ab|ch)|color|hsla?|hwb|rgba?';\nconst _COLOR_KEY = '[a-z]+|#[\\\\da-f]{3}|#[\\\\da-f]{4}|#[\\\\da-f]{6}|#[\\\\da-f]{8}';\nconst _CS_HUE = '(?:ok)?lch|hsl|hwb';\nconst _CS_HUE_ARC = '(?:de|in)creasing|longer|shorter';\nconst _NUM_ANGLE = `${NUM}(?:${ANGLE})?`;\nconst _NUM_ANGLE_NONE = `(?:${NUM}(?:${ANGLE})?|${NONE})`;\nconst _NUM_PCT_NONE = `(?:${NUM}|${PCT}|${NONE})`;\nexport const CS_HUE = `(?:${_CS_HUE})(?:\\\\s(?:${_CS_HUE_ARC})\\\\shue)?`;\nexport const CS_HUE_CAPT = `(${_CS_HUE})(?:\\\\s(${_CS_HUE_ARC})\\\\shue)?`;\nexport const CS_LAB = '(?:ok)?lab';\nexport const CS_LCH = '(?:ok)?lch';\nexport const CS_SRGB = 'srgb(?:-linear)?';\nexport const CS_RGB = `(?:a98|prophoto)-rgb|display-p3|rec2020|${CS_SRGB}`;\nexport const CS_XYZ = 'xyz(?:-d(?:50|65))?';\nexport const CS_RECT = `${CS_LAB}|${CS_RGB}|${CS_XYZ}`;\nexport const CS_MIX = `${CS_HUE}|${CS_RECT}`;\nexport const FN_COLOR = 'color(';\nexport const FN_LIGHT_DARK = 'light-dark(';\nexport const FN_MIX = 'color-mix(';\nexport const FN_REL = `(?:${_COLOR_FUNC})\\\\(\\\\s*from\\\\s+`;\nexport const FN_REL_CAPT = `(${_COLOR_FUNC})\\\\(\\\\s*from\\\\s+`;\nexport const FN_VAR = 'var(';\nexport const SYN_FN_COLOR = `(?:${CS_RGB}|${CS_XYZ})(?:\\\\s+${_NUM_PCT_NONE}){3}${_ALPHA}`;\nexport const SYN_FN_LIGHT_DARK = '^light-dark\\\\(';\nexport const SYN_FN_REL = `^${FN_REL}|(?<=[\\\\s])${FN_REL}`;\nexport const SYN_HSL = `${_NUM_ANGLE_NONE}(?:\\\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;\nexport const SYN_HSL_LV3 = `${_NUM_ANGLE}(?:\\\\s*,\\\\s*${PCT}){2}${_ALPHA_LV3}`;\nexport const SYN_LCH = `(?:${_NUM_PCT_NONE}\\\\s+){2}${_NUM_ANGLE_NONE}${_ALPHA}`;\nexport const SYN_MOD = `${_NUM_PCT_NONE}(?:\\\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;\nexport const SYN_RGB_LV3 = `(?:${NUM}(?:\\\\s*,\\\\s*${NUM}){2}|${PCT}(?:\\\\s*,\\\\s*${PCT}){2})${_ALPHA_LV3}`;\nexport const SYN_COLOR_TYPE = `${_COLOR_KEY}|hsla?\\\\(\\\\s*${SYN_HSL_LV3}\\\\s*\\\\)|rgba?\\\\(\\\\s*${SYN_RGB_LV3}\\\\s*\\\\)|(?:hsla?|hwb)\\\\(\\\\s*${SYN_HSL}\\\\s*\\\\)|(?:(?:ok)?lab|rgba?)\\\\(\\\\s*${SYN_MOD}\\\\s*\\\\)|(?:ok)?lch\\\\(\\\\s*${SYN_LCH}\\\\s*\\\\)|color\\\\(\\\\s*${SYN_FN_COLOR}\\\\s*\\\\)`;\nexport const SYN_MIX_PART = `(?:${SYN_COLOR_TYPE})(?:\\\\s+${PCT})?`;\nexport const SYN_MIX = `color-mix\\\\(\\\\s*in\\\\s+(?:${CS_MIX})\\\\s*,\\\\s*${SYN_MIX_PART}\\\\s*,\\\\s*${SYN_MIX_PART}\\\\s*\\\\)`;\nexport const SYN_MIX_CAPT = `color-mix\\\\(\\\\s*in\\\\s+(${CS_MIX})\\\\s*,\\\\s*(${SYN_MIX_PART})\\\\s*,\\\\s*(${SYN_MIX_PART})\\\\s*\\\\)`;\n\n/* formats */\nexport const VAL_COMP = 'computedValue';\nexport const VAL_MIX = 'mixValue';\nexport const VAL_SPEC = 'specifiedValue';\n"],"mappings":";;;;AAKA,IAAM,SAAS;AAMf,IAAM,QAAQ;AACd,IAAM,QAAQ,QAAQ;AACtB,IAAM,OAAO,OAAO;AACpB,IAAa,QAAQ;AACrB,IAAa,SACX;AACF,IAAa,MAAM,WAAW,OAAO,6BAA6B,OAAO;AACzE,IAAa,eAAe,UAAU,OAAO,6BAA6B,OAAO;AACjF,IAAa,OAAO;AACpB,IAAa,MAAM,GAAG,IAAI;AAC1B,IAAa,cAAc,OAAO,MAAM,2BAA2B,MAAM;AACzE,IAAa,oBAAoB,OAAO,MAAM;AAC9C,IAAa,aAAa;AAC1B,IAAa,mBAAmB,OAAO,KAAK;AAG5C,IAAM,SAAS,oBAAoB,IAAI,GAAG,IAAI,GAAG,KAAK;AACtD,IAAM,aAAa,kBAAkB,IAAI,GAAG,IAAI;AAChD,IAAM,cAAc;AACpB,IAAM,aAAa;AACnB,IAAM,UAAU;AAChB,IAAM,cAAc;AACpB,IAAM,aAAa,GAAG,IAAI,KAAK,MAAM;AACrC,IAAM,kBAAkB,MAAM,IAAI,KAAK,MAAM,KAAK,KAAK;AACvD,IAAM,gBAAgB,MAAM,IAAI,GAAG,IAAI,GAAG,KAAK;AAC/C,IAAa,SAAS,MAAM,QAAQ,YAAY,YAAY;AAC5D,IAAa,cAAc,IAAI,QAAQ,UAAU,YAAY;AAC7D,IAAa,SAAS;AACtB,IAAa,SAAS;AAEtB,IAAa,SAAS;AACtB,IAAa,SAAS;AACtB,IAAa,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG;AAC9C,IAAa,SAAS,GAAG,OAAO,GAAG;AACnC,IAAa,WAAW;AACxB,IAAa,gBAAgB;AAC7B,IAAa,SAAS;AACtB,IAAa,SAAS,MAAM,YAAY;AACxC,IAAa,cAAc,IAAI,YAAY;AAC3C,IAAa,SAAS;AACtB,IAAa,eAAe,MAAM,OAAO,GAAG,OAAO,UAAU,cAAc,MAAM;AACjF,IAAa,oBAAoB;AACjC,IAAa,aAAa,IAAI,OAAO,aAAa;AAClD,IAAa,UAAU,GAAG,gBAAgB,SAAS,cAAc,MAAM;AACvE,IAAa,cAAc,GAAG,WAAW,cAAc,IAAI,MAAM;AACjE,IAAa,UAAU,MAAM,cAAc,UAAU,kBAAkB;AACvE,IAAa,UAAU,GAAG,cAAc,SAAS,cAAc,MAAM;AACrE,IAAa,cAAc,MAAM,IAAI,cAAc,IAAI,OAAO,IAAI,cAAc,IAAI,OAAO;AAC3F,IAAa,iBAAiB,GAAG,WAAW,eAAe,YAAY,sBAAsB,YAAY,8BAA8B,QAAQ,qCAAqC,QAAQ,2BAA2B,QAAQ,sBAAsB,aAAa;AAClQ,IAAa,eAAe,MAAM,eAAe,UAAU,IAAI;AAC/D,IAAa,UAAU,4BAA4B,OAAO,YAAY,aAAa,WAAW,aAAa;AAC3G,IAAa,eAAe,0BAA0B,OAAO,aAAa,aAAa,aAAa,aAAa;AAGjH,IAAa,WAAW;AACxB,IAAa,UAAU;AACvB,IAAa,WAAW"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/convert.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/convert.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fe97f7fc841e180509e9c6e64b453b21517a81b1
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/convert.d.ts
@@ -0,0 +1,99 @@
+import { NullObject } from './cache.js';
+import { ColorChannels, Options } from './typedef.js';
+/**
+ * pre process
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns value
+ */
+export declare const preProcess: (value: string, opt?: Options) => string | NullObject;
+/**
+ * convert number to hex string
+ * @param value - numeric value
+ * @returns hex string: 00..ff
+ */
+export declare const numberToHex: (value: number) => string;
+/**
+ * convert color to hex
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @param [opt.alpha] - enable alpha channel
+ * @returns #rrggbb | #rrggbbaa | null
+ */
+export declare const colorToHex: (value: string, opt?: Options) => string | null;
+/**
+ * convert color to hsl
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [h, s, l, alpha]
+ */
+export declare const colorToHsl: (value: string, opt?: Options) => ColorChannels;
+/**
+ * convert color to hwb
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [h, w, b, alpha]
+ */
+export declare const colorToHwb: (value: string, opt?: Options) => ColorChannels;
+/**
+ * convert color to lab
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [l, a, b, alpha]
+ */
+export declare const colorToLab: (value: string, opt?: Options) => ColorChannels;
+/**
+ * convert color to lch
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [l, c, h, alpha]
+ */
+export declare const colorToLch: (value: string, opt?: Options) => ColorChannels;
+/**
+ * convert color to oklab
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [l, a, b, alpha]
+ */
+export declare const colorToOklab: (value: string, opt?: Options) => ColorChannels;
+/**
+ * convert color to oklch
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [l, c, h, alpha]
+ */
+export declare const colorToOklch: (value: string, opt?: Options) => ColorChannels;
+/**
+ * convert color to rgb
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [r, g, b, alpha]
+ */
+export declare const colorToRgb: (value: string, opt?: Options) => ColorChannels;
+/**
+ * convert color to xyz
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [x, y, z, alpha]
+ */
+export declare const colorToXyz: (value: string, opt?: Options) => ColorChannels;
+/**
+ * convert color to xyz-d50
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [x, y, z, alpha]
+ */
+export declare const colorToXyzD50: (value: string, opt?: Options) => ColorChannels;
+export declare const convert: {
+    colorToHex: (value: string, opt?: Options) => string | null;
+    colorToHsl: (value: string, opt?: Options) => ColorChannels;
+    colorToHwb: (value: string, opt?: Options) => ColorChannels;
+    colorToLab: (value: string, opt?: Options) => ColorChannels;
+    colorToLch: (value: string, opt?: Options) => ColorChannels;
+    colorToOklab: (value: string, opt?: Options) => ColorChannels;
+    colorToOklch: (value: string, opt?: Options) => ColorChannels;
+    colorToRgb: (value: string, opt?: Options) => ColorChannels;
+    colorToXyz: (value: string, opt?: Options) => ColorChannels;
+    colorToXyzD50: (value: string, opt?: Options) => ColorChannels;
+    numberToHex: (value: number) => string;
+};
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/convert.js b/node_modules/@asamuzakjp/css-color/dist/esm/js/convert.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d90899d142795fcd1b9ad60fc7b58b3a86ccd2e
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/convert.js
@@ -0,0 +1,245 @@
+import { CacheItem, NullObject, createCacheKey, getCache, setCache } from "./cache.js";
+import { isString } from "./common.js";
+import { SYN_FN_CALC, SYN_FN_REL, SYN_FN_VAR, VAL_COMP } from "./constant.js";
+import { convertColorToHsl, convertColorToHwb, convertColorToLab, convertColorToLch, convertColorToOklab, convertColorToOklch, convertColorToRgb, numberToHexString, parseColorFunc, parseColorValue } from "./color.js";
+import { resolveRelativeColor } from "./relative-color.js";
+import { resolveColor } from "./resolve.js";
+import { resolveVar } from "./css-var.js";
+import { cssCalc } from "./css-calc.js";
+//#region src/js/convert.ts
+/**
+* convert
+*/
+var NAMESPACE = "convert";
+var REG_FN_CALC = new RegExp(SYN_FN_CALC);
+var REG_FN_REL = new RegExp(SYN_FN_REL);
+var REG_FN_VAR = new RegExp(SYN_FN_VAR);
+/**
+* pre process
+* @param value - CSS color value
+* @param [opt] - options
+* @returns value
+*/
+var preProcess = (value, opt = {}) => {
+	if (!isString(value)) return new NullObject();
+	value = value.trim();
+	if (!value) return new NullObject();
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "preProcess",
+		value
+	}, opt);
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) {
+		if (cachedResult.isNull) return cachedResult;
+		return cachedResult.item;
+	}
+	let res = value;
+	if (REG_FN_VAR.test(value)) {
+		const resolved = resolveVar(value, opt);
+		if (isString(resolved)) res = resolved;
+		else {
+			setCache(cacheKey, null);
+			return new NullObject();
+		}
+	}
+	if (isString(res)) {
+		if (REG_FN_REL.test(res)) {
+			const resolved = resolveRelativeColor(res, opt);
+			if (isString(resolved)) res = resolved;
+			else {
+				setCache(cacheKey, null);
+				return new NullObject();
+			}
+		} else if (REG_FN_CALC.test(res)) res = cssCalc(res, opt);
+	}
+	if (isString(res)) {
+		if (res.startsWith("color-mix")) res = resolveColor(res, {
+			...opt,
+			format: VAL_COMP,
+			nullable: true
+		});
+	}
+	setCache(cacheKey, res);
+	return res;
+};
+/**
+* converter factory to reduce boilerplate
+* @param name - function name for cache
+* @param format - color format
+* @param convertFn - conversion function
+* @returns color converter function
+*/
+var createColorConverter = (name, format, convertFn) => {
+	const colorConverterFn = (value, opt = {}) => {
+		if (!isString(value)) throw new TypeError(`${value} is not a string.`);
+		const resolved = preProcess(value, opt);
+		if (resolved instanceof NullObject) return [
+			0,
+			0,
+			0,
+			0
+		];
+		const val = resolved.toLowerCase();
+		const cacheKey = createCacheKey({
+			namespace: NAMESPACE,
+			name,
+			value: val
+		}, opt);
+		const cached = getCache(cacheKey);
+		if (cached instanceof CacheItem) return cached.item;
+		const result = convertFn(val, {
+			...opt,
+			format
+		});
+		setCache(cacheKey, result);
+		return result;
+	};
+	return colorConverterFn;
+};
+/**
+* convert number to hex string
+* @param value - numeric value
+* @returns hex string: 00..ff
+*/
+var numberToHex = (value) => numberToHexString(value);
+/**
+* convert color to hex
+* @param value - CSS color value
+* @param [opt] - options
+* @param [opt.alpha] - enable alpha channel
+* @returns #rrggbb | #rrggbbaa | null
+*/
+var colorToHex = (value, opt = {}) => {
+	if (!isString(value)) throw new TypeError(`${value} is not a string.`);
+	const resolved = preProcess(value, opt);
+	if (resolved instanceof NullObject) return null;
+	const val = resolved.toLowerCase();
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "colorToHex",
+		value: val
+	}, opt);
+	const cached = getCache(cacheKey);
+	if (cached instanceof CacheItem) {
+		if (cached.isNull) return null;
+		return cached.item;
+	}
+	const hex = resolveColor(val, {
+		...opt,
+		nullable: true,
+		format: opt.alpha ? "hexAlpha" : "hex"
+	});
+	if (isString(hex)) {
+		setCache(cacheKey, hex);
+		return hex;
+	}
+	setCache(cacheKey, null);
+	return null;
+};
+/**
+* convert color to hsl
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels - [h, s, l, alpha]
+*/
+var colorToHsl = createColorConverter("colorToHsl", "hsl", convertColorToHsl);
+/**
+* convert color to hwb
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels - [h, w, b, alpha]
+*/
+var colorToHwb = createColorConverter("colorToHwb", "hwb", convertColorToHwb);
+/**
+* convert color to lab
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels - [l, a, b, alpha]
+*/
+var colorToLab = createColorConverter("colorToLab", "lab", convertColorToLab);
+/**
+* convert color to lch
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels - [l, c, h, alpha]
+*/
+var colorToLch = createColorConverter("colorToLch", "lch", convertColorToLch);
+/**
+* convert color to oklab
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels - [l, a, b, alpha]
+*/
+var colorToOklab = createColorConverter("colorToOklab", "oklab", convertColorToOklab);
+/**
+* convert color to oklch
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels - [l, c, h, alpha]
+*/
+var colorToOklch = createColorConverter("colorToOklch", "oklch", convertColorToOklch);
+/**
+* convert color to rgb
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels - [r, g, b, alpha]
+*/
+var colorToRgb = createColorConverter("colorToRgb", "rgb", convertColorToRgb);
+/**
+* convert color to xyz
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels - [x, y, z, alpha]
+*/
+var colorToXyz = (value, opt = {}) => {
+	if (!isString(value)) throw new TypeError(`${value} is not a string.`);
+	const resolved = preProcess(value, opt);
+	if (resolved instanceof NullObject) return [
+		0,
+		0,
+		0,
+		0
+	];
+	const val = resolved.toLowerCase();
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "colorToXyz",
+		value: val
+	}, opt);
+	const cached = getCache(cacheKey);
+	if (cached instanceof CacheItem) return cached.item;
+	let parsed;
+	if (val.startsWith("color(")) parsed = parseColorFunc(val, opt);
+	else parsed = parseColorValue(val, opt);
+	const [, ...xyz] = parsed;
+	setCache(cacheKey, xyz);
+	return xyz;
+};
+/**
+* convert color to xyz-d50
+* @param value - CSS color value
+* @param [opt] - options
+* @returns ColorChannels - [x, y, z, alpha]
+*/
+var colorToXyzD50 = (value, opt = {}) => {
+	opt.d50 = true;
+	return colorToXyz(value, opt);
+};
+var convert = {
+	colorToHex,
+	colorToHsl,
+	colorToHwb,
+	colorToLab,
+	colorToLch,
+	colorToOklab,
+	colorToOklch,
+	colorToRgb,
+	colorToXyz,
+	colorToXyzD50,
+	numberToHex
+};
+//#endregion
+export { convert };
+
+//# sourceMappingURL=convert.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/convert.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/js/convert.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..c13e89af24f9001ebfc2b959eff3e0fc816918f8
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/convert.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"convert.js","names":[],"sources":["../../../src/js/convert.ts"],"sourcesContent":["/**\n * convert\n */\n\nimport {\n  CacheItem,\n  NullObject,\n  createCacheKey,\n  getCache,\n  setCache\n} from './cache';\nimport {\n  convertColorToHsl,\n  convertColorToHwb,\n  convertColorToLab,\n  convertColorToLch,\n  convertColorToOklab,\n  convertColorToOklch,\n  convertColorToRgb,\n  numberToHexString,\n  parseColorFunc,\n  parseColorValue\n} from './color';\nimport { isString } from './common';\nimport { cssCalc } from './css-calc';\nimport { resolveVar } from './css-var';\nimport { resolveRelativeColor } from './relative-color';\nimport { resolveColor } from './resolve';\nimport { ColorChannels, ComputedColorChannels, Options } from './typedef';\n\n/* constants */\nimport { SYN_FN_CALC, SYN_FN_REL, SYN_FN_VAR, VAL_COMP } from './constant';\nconst NAMESPACE = 'convert';\n\n/* regexp */\nconst REG_FN_CALC = new RegExp(SYN_FN_CALC);\nconst REG_FN_REL = new RegExp(SYN_FN_REL);\nconst REG_FN_VAR = new RegExp(SYN_FN_VAR);\n\n/**\n * pre process\n * @param value - CSS color value\n * @param [opt] - options\n * @returns value\n */\nexport const preProcess = (\n  value: string,\n  opt: Options = {}\n): string | NullObject => {\n  if (!isString(value)) {\n    return new NullObject();\n  }\n  value = value.trim();\n  if (!value) {\n    return new NullObject();\n  }\n  const cacheKey: string = createCacheKey(\n    { namespace: NAMESPACE, name: 'preProcess', value },\n    opt\n  );\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    if (cachedResult.isNull) {\n      return cachedResult as NullObject;\n    }\n    return cachedResult.item as string;\n  }\n  let res: string | NullObject = value;\n  if (REG_FN_VAR.test(value)) {\n    const resolved = resolveVar(value, opt);\n    if (isString(resolved)) {\n      res = resolved;\n    } else {\n      setCache(cacheKey, null);\n      return new NullObject();\n    }\n  }\n  if (isString(res)) {\n    if (REG_FN_REL.test(res)) {\n      const resolved = resolveRelativeColor(res, opt);\n      if (isString(resolved)) {\n        res = resolved;\n      } else {\n        setCache(cacheKey, null);\n        return new NullObject();\n      }\n    } else if (REG_FN_CALC.test(res)) {\n      res = cssCalc(res, opt);\n    }\n  }\n  if (isString(res)) {\n    if (res.startsWith('color-mix')) {\n      res = resolveColor(res, { ...opt, format: VAL_COMP, nullable: true });\n    }\n  }\n  setCache(cacheKey, res);\n  return res;\n};\n\n/**\n * converter factory to reduce boilerplate\n * @param name - function name for cache\n * @param format - color format\n * @param convertFn - conversion function\n * @returns color converter function\n */\nconst createColorConverter = (\n  name: string,\n  format: string,\n  convertFn: Function\n) => {\n  const colorConverterFn = (\n    value: string,\n    opt: Options = {}\n  ): ColorChannels => {\n    if (!isString(value)) {\n      throw new TypeError(`${value} is not a string.`);\n    }\n    const resolved = preProcess(value, opt);\n    if (resolved instanceof NullObject) {\n      return [0, 0, 0, 0];\n    }\n    const val = resolved.toLowerCase();\n    const cacheKey = createCacheKey(\n      { namespace: NAMESPACE, name, value: val },\n      opt\n    );\n    const cached = getCache(cacheKey);\n    if (cached instanceof CacheItem) {\n      return cached.item as ColorChannels;\n    }\n    const result = convertFn(val, { ...opt, format }) as ColorChannels;\n    setCache(cacheKey, result);\n    return result;\n  };\n  return colorConverterFn;\n};\n\n/**\n * convert number to hex string\n * @param value - numeric value\n * @returns hex string: 00..ff\n */\nexport const numberToHex = (value: number): string => numberToHexString(value);\n\n/**\n * convert color to hex\n * @param value - CSS color value\n * @param [opt] - options\n * @param [opt.alpha] - enable alpha channel\n * @returns #rrggbb | #rrggbbaa | null\n */\nexport const colorToHex = (value: string, opt: Options = {}): string | null => {\n  if (!isString(value)) {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const resolved = preProcess(value, opt);\n  if (resolved instanceof NullObject) {\n    return null;\n  }\n  const val = resolved.toLowerCase();\n  const cacheKey = createCacheKey(\n    { namespace: NAMESPACE, name: 'colorToHex', value: val },\n    opt\n  );\n  const cached = getCache(cacheKey);\n  if (cached instanceof CacheItem) {\n    if (cached.isNull) {\n      return null;\n    }\n    return cached.item as string;\n  }\n  const hex = resolveColor(val, {\n    ...opt,\n    nullable: true,\n    format: opt.alpha ? 'hexAlpha' : 'hex'\n  });\n  if (isString(hex)) {\n    setCache(cacheKey, hex);\n    return hex;\n  }\n  setCache(cacheKey, null);\n  return null;\n};\n\n/**\n * convert color to hsl\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels - [h, s, l, alpha]\n */\nexport const colorToHsl = createColorConverter(\n  'colorToHsl',\n  'hsl',\n  convertColorToHsl\n);\n\n/**\n * convert color to hwb\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels - [h, w, b, alpha]\n */\nexport const colorToHwb = createColorConverter(\n  'colorToHwb',\n  'hwb',\n  convertColorToHwb\n);\n\n/**\n * convert color to lab\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels - [l, a, b, alpha]\n */\nexport const colorToLab = createColorConverter(\n  'colorToLab',\n  'lab',\n  convertColorToLab\n);\n\n/**\n * convert color to lch\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels - [l, c, h, alpha]\n */\nexport const colorToLch = createColorConverter(\n  'colorToLch',\n  'lch',\n  convertColorToLch\n);\n\n/**\n * convert color to oklab\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels - [l, a, b, alpha]\n */\nexport const colorToOklab = createColorConverter(\n  'colorToOklab',\n  'oklab',\n  convertColorToOklab\n);\n\n/**\n * convert color to oklch\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels - [l, c, h, alpha]\n */\nexport const colorToOklch = createColorConverter(\n  'colorToOklch',\n  'oklch',\n  convertColorToOklch\n);\n\n/**\n * convert color to rgb\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels - [r, g, b, alpha]\n */\nexport const colorToRgb = createColorConverter(\n  'colorToRgb',\n  'rgb',\n  convertColorToRgb\n);\n\n/**\n * convert color to xyz\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels - [x, y, z, alpha]\n */\nexport const colorToXyz = (value: string, opt: Options = {}): ColorChannels => {\n  if (!isString(value)) {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const resolved = preProcess(value, opt);\n  if (resolved instanceof NullObject) {\n    return [0, 0, 0, 0];\n  }\n  const val = resolved.toLowerCase();\n  const cacheKey = createCacheKey(\n    { namespace: NAMESPACE, name: 'colorToXyz', value: val },\n    opt\n  );\n  const cached = getCache(cacheKey);\n  if (cached instanceof CacheItem) {\n    return cached.item as ColorChannels;\n  }\n  let parsed;\n  if (val.startsWith('color(')) {\n    parsed = parseColorFunc(val, opt);\n  } else {\n    parsed = parseColorValue(val, opt);\n  }\n  const [, ...xyz] = parsed as ComputedColorChannels;\n  setCache(cacheKey, xyz);\n  return xyz as ColorChannels;\n};\n\n/**\n * convert color to xyz-d50\n * @param value - CSS color value\n * @param [opt] - options\n * @returns ColorChannels - [x, y, z, alpha]\n */\nexport const colorToXyzD50 = (\n  value: string,\n  opt: Options = {}\n): ColorChannels => {\n  opt.d50 = true;\n  return colorToXyz(value, opt);\n};\n\n/* convert */\nexport const convert = {\n  colorToHex,\n  colorToHsl,\n  colorToHwb,\n  colorToLab,\n  colorToLch,\n  colorToOklab,\n  colorToOklch,\n  colorToRgb,\n  colorToXyz,\n  colorToXyzD50,\n  numberToHex\n};\n"],"mappings":"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"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/css-calc.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-calc.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..265e284cf3b49c4bcda91772db3805a0d4bebb5a
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-calc.d.ts
@@ -0,0 +1,89 @@
+import { CSSToken } from '@csstools/css-tokenizer';
+import { NullObject } from './cache.js';
+import { Options } from './typedef.js';
+/**
+ * Calclator
+ */
+export declare class Calculator {
+    #private;
+    /**
+     * constructor
+     */
+    constructor();
+    get hasNum(): boolean;
+    set hasNum(value: boolean);
+    get numSum(): number[];
+    get numMul(): number[];
+    get hasPct(): boolean;
+    set hasPct(value: boolean);
+    get pctSum(): number[];
+    get pctMul(): number[];
+    get hasDim(): boolean;
+    set hasDim(value: boolean);
+    get dimSum(): string[];
+    get dimSub(): string[];
+    get dimMul(): string[];
+    get dimDiv(): string[];
+    get hasEtc(): boolean;
+    set hasEtc(value: boolean);
+    get etcSum(): string[];
+    get etcSub(): string[];
+    get etcMul(): string[];
+    get etcDiv(): string[];
+    /**
+     * clear values
+     * @returns void
+     */
+    clear(): void;
+    /**
+     * sort values
+     * @param values - values
+     * @returns sorted values
+     */
+    sort(values?: string[]): string[];
+    /**
+     * multiply values
+     * @returns resolved value
+     */
+    multiply(): string;
+    /**
+     * sum values
+     * @returns resolved value
+     */
+    sum(): string;
+}
+/**
+ * sort calc values
+ * @param values - values to sort
+ * @param [finalize] - finalize values
+ * @returns sorted values
+ */
+export declare const sortCalcValues: (values?: (number | string)[], finalize?: boolean) => string;
+/**
+ * serialize calc
+ * @param value - CSS value
+ * @param [opt] - options
+ * @returns serialized value
+ */
+export declare const serializeCalc: (value: string, opt?: Options) => string;
+/**
+ * resolve dimension
+ * @param token - CSS token
+ * @param [opt] - options
+ * @returns resolved value
+ */
+export declare const resolveDimension: (token: CSSToken, opt?: Options) => string | NullObject;
+/**
+ * parse tokens
+ * @param tokens - CSS tokens
+ * @param [opt] - options
+ * @returns parsed tokens
+ */
+export declare const parseTokens: (tokens: CSSToken[], opt?: Options) => string[];
+/**
+ * CSS calc()
+ * @param value - CSS value including calc()
+ * @param [opt] - options
+ * @returns resolved value
+ */
+export declare const cssCalc: (value: string, opt?: Options) => string;
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/css-calc.js b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-calc.js
new file mode 100644
index 0000000000000000000000000000000000000000..1fd25a8a3d3c52501978d72d47f507dbcb3248cf
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-calc.js
@@ -0,0 +1,636 @@
+import { CacheItem, NullObject, createCacheKey, getCache, setCache } from "./cache.js";
+import { isString, isStringOrNumber } from "./common.js";
+import { ANGLE, LENGTH, NUM, SYN_FN_CALC, SYN_FN_MATH_START, SYN_FN_VAR, SYN_FN_VAR_START } from "./constant.js";
+import { resolveLengthInPixels, roundToPrecision } from "./util.js";
+import { resolveVar } from "./css-var.js";
+import { calc } from "@csstools/css-calc";
+import { TokenType, tokenize } from "@csstools/css-tokenizer";
+//#region src/js/css-calc.ts
+/**
+* css-calc
+*/
+var { CloseParen: PAREN_CLOSE, Comment: COMMENT, Dimension: DIM, EOF, Function: FUNC, OpenParen: PAREN_OPEN, Whitespace: W_SPACE } = TokenType;
+var NAMESPACE = "css-calc";
+var TRIA = 3;
+var HEX = 16;
+var MAX_PCT = 100;
+var REG_FN_CALC = new RegExp(SYN_FN_CALC);
+var REG_FN_CALC_NUM = new RegExp(`^calc\\((${NUM})\\)$`);
+var REG_FN_MATH_START = new RegExp(SYN_FN_MATH_START);
+var REG_FN_VAR = new RegExp(SYN_FN_VAR);
+var REG_FN_VAR_START = new RegExp(SYN_FN_VAR_START);
+var REG_OPERATOR = /\s[*+/-]\s/;
+var REG_PAREN_OPEN = /\($/;
+var REG_TYPE_DIM = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH})$`);
+var REG_TYPE_DIM_PCT = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH}|%)$`);
+var REG_TYPE_PCT = new RegExp(`^(${NUM})%$`);
+/**
+* Calclator
+*/
+var Calculator = class {
+	#hasNum;
+	#numSum;
+	#numMul;
+	#hasPct;
+	#pctSum;
+	#pctMul;
+	#hasDim;
+	#dimSum;
+	#dimSub;
+	#dimMul;
+	#dimDiv;
+	#hasEtc;
+	#etcSum;
+	#etcSub;
+	#etcMul;
+	#etcDiv;
+	#calcOpts;
+	/**
+	* constructor
+	*/
+	constructor() {
+		this.#hasNum = false;
+		this.#numSum = [];
+		this.#numMul = [];
+		this.#hasPct = false;
+		this.#pctSum = [];
+		this.#pctMul = [];
+		this.#hasDim = false;
+		this.#dimSum = [];
+		this.#dimSub = [];
+		this.#dimMul = [];
+		this.#dimDiv = [];
+		this.#hasEtc = false;
+		this.#etcSum = [];
+		this.#etcSub = [];
+		this.#etcMul = [];
+		this.#etcDiv = [];
+		this.#calcOpts = { toCanonicalUnits: true };
+	}
+	get hasNum() {
+		return this.#hasNum;
+	}
+	set hasNum(value) {
+		this.#hasNum = !!value;
+	}
+	get numSum() {
+		return this.#numSum;
+	}
+	get numMul() {
+		return this.#numMul;
+	}
+	get hasPct() {
+		return this.#hasPct;
+	}
+	set hasPct(value) {
+		this.#hasPct = !!value;
+	}
+	get pctSum() {
+		return this.#pctSum;
+	}
+	get pctMul() {
+		return this.#pctMul;
+	}
+	get hasDim() {
+		return this.#hasDim;
+	}
+	set hasDim(value) {
+		this.#hasDim = !!value;
+	}
+	get dimSum() {
+		return this.#dimSum;
+	}
+	get dimSub() {
+		return this.#dimSub;
+	}
+	get dimMul() {
+		return this.#dimMul;
+	}
+	get dimDiv() {
+		return this.#dimDiv;
+	}
+	get hasEtc() {
+		return this.#hasEtc;
+	}
+	set hasEtc(value) {
+		this.#hasEtc = !!value;
+	}
+	get etcSum() {
+		return this.#etcSum;
+	}
+	get etcSub() {
+		return this.#etcSub;
+	}
+	get etcMul() {
+		return this.#etcMul;
+	}
+	get etcDiv() {
+		return this.#etcDiv;
+	}
+	/**
+	* clear values
+	* @returns void
+	*/
+	clear() {
+		this.#hasNum = false;
+		this.#numSum.length = 0;
+		this.#numMul.length = 0;
+		this.#hasPct = false;
+		this.#pctSum.length = 0;
+		this.#pctMul.length = 0;
+		this.#hasDim = false;
+		this.#dimSum.length = 0;
+		this.#dimSub.length = 0;
+		this.#dimMul.length = 0;
+		this.#dimDiv.length = 0;
+		this.#hasEtc = false;
+		this.#etcSum.length = 0;
+		this.#etcSub.length = 0;
+		this.#etcMul.length = 0;
+		this.#etcDiv.length = 0;
+	}
+	/**
+	* sort values
+	* @param values - values
+	* @returns sorted values
+	*/
+	sort(values = []) {
+		const arr = [...values];
+		if (arr.length > 1) arr.sort((a, b) => {
+			let res;
+			if (REG_TYPE_DIM_PCT.test(a) && REG_TYPE_DIM_PCT.test(b)) {
+				const [, valA, unitA] = a.match(REG_TYPE_DIM_PCT);
+				const [, valB, unitB] = b.match(REG_TYPE_DIM_PCT);
+				if (unitA === unitB) if (Number(valA) === Number(valB)) res = 0;
+				else if (Number(valA) > Number(valB)) res = 1;
+				else res = -1;
+				else if (unitA > unitB) res = 1;
+				else res = -1;
+			} else if (a === b) res = 0;
+			else if (a > b) res = 1;
+			else res = -1;
+			return res;
+		});
+		return arr;
+	}
+	/**
+	* multiply values
+	* @returns resolved value
+	*/
+	multiply() {
+		const value = [];
+		let num;
+		if (this.#hasNum) {
+			num = 1;
+			for (const i of this.#numMul) {
+				num *= i;
+				if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) break;
+			}
+			if (!this.#hasPct && !this.#hasDim && !this.hasEtc) {
+				if (Number.isFinite(num)) num = roundToPrecision(num, HEX);
+				value.push(num);
+			}
+		}
+		if (this.#hasPct) {
+			if (typeof num !== "number") num = 1;
+			for (const i of this.#pctMul) {
+				num *= i;
+				if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) break;
+			}
+			if (Number.isFinite(num)) num = `${roundToPrecision(num, HEX)}%`;
+			if (!this.#hasDim && !this.hasEtc) value.push(num);
+		}
+		if (this.#hasDim) {
+			let dim = "";
+			let mul = "";
+			let div = "";
+			if (this.#dimMul.length) if (this.#dimMul.length === 1) [mul] = this.#dimMul;
+			else mul = `${this.sort(this.#dimMul).join(" * ")}`;
+			if (this.#dimDiv.length) if (this.#dimDiv.length === 1) [div] = this.#dimDiv;
+			else div = `${this.sort(this.#dimDiv).join(" * ")}`;
+			if (Number.isFinite(num)) {
+				if (mul) if (div) if (div.includes("*")) dim = calc(`calc(${num} * ${mul} / (${div}))`, this.#calcOpts);
+				else dim = calc(`calc(${num} * ${mul} / ${div})`, this.#calcOpts);
+				else dim = calc(`calc(${num} * ${mul})`, this.#calcOpts);
+				else if (div.includes("*")) dim = calc(`calc(${num} / (${div}))`, this.#calcOpts);
+				else dim = calc(`calc(${num} / ${div})`, this.#calcOpts);
+				value.push(dim.replace(/^calc/, ""));
+			} else {
+				if (!value.length && num !== void 0) value.push(num);
+				if (mul) {
+					if (div) if (div.includes("*")) dim = calc(`calc(${mul} / (${div}))`, this.#calcOpts);
+					else dim = calc(`calc(${mul} / ${div})`, this.#calcOpts);
+					else dim = calc(`calc(${mul})`, this.#calcOpts);
+					if (value.length) value.push("*", dim.replace(/^calc/, ""));
+					else value.push(dim.replace(/^calc/, ""));
+				} else {
+					dim = calc(`calc(${div})`, this.#calcOpts);
+					if (value.length) value.push("/", dim.replace(/^calc/, ""));
+					else value.push("1", "/", dim.replace(/^calc/, ""));
+				}
+			}
+		}
+		if (this.#hasEtc) {
+			if (this.#etcMul.length) {
+				if (!value.length && num !== void 0) value.push(num);
+				const mul = this.sort(this.#etcMul).join(" * ");
+				if (value.length) value.push(`* ${mul}`);
+				else value.push(`${mul}`);
+			}
+			if (this.#etcDiv.length) {
+				const div = this.sort(this.#etcDiv).join(" * ");
+				if (div.includes("*")) if (value.length) value.push(`/ (${div})`);
+				else value.push(`1 / (${div})`);
+				else if (value.length) value.push(`/ ${div}`);
+				else value.push(`1 / ${div}`);
+			}
+		}
+		if (value.length) return value.join(" ");
+		return "";
+	}
+	/**
+	* sum values
+	* @returns resolved value
+	*/
+	sum() {
+		const value = [];
+		if (this.#hasNum) {
+			let num = 0;
+			for (const i of this.#numSum) {
+				num += i;
+				if (!Number.isFinite(num) || Number.isNaN(num)) break;
+			}
+			value.push(num);
+		}
+		if (this.#hasPct) {
+			let num = 0;
+			for (const i of this.#pctSum) {
+				num += i;
+				if (!Number.isFinite(num)) break;
+			}
+			if (Number.isFinite(num)) num = `${num}%`;
+			if (value.length) value.push(`+ ${num}`);
+			else value.push(num);
+		}
+		if (this.#hasDim) {
+			let dim, sum, sub;
+			if (this.#dimSum.length) sum = this.sort(this.#dimSum).join(" + ");
+			if (this.#dimSub.length) sub = this.sort(this.#dimSub).join(" + ");
+			if (sum) if (sub) if (sub.includes("-")) dim = calc(`calc(${sum} - (${sub}))`, this.#calcOpts);
+			else dim = calc(`calc(${sum} - ${sub})`, this.#calcOpts);
+			else dim = calc(`calc(${sum})`, this.#calcOpts);
+			else dim = calc(`calc(-1 * (${sub}))`, this.#calcOpts);
+			if (value.length) value.push("+", dim.replace(/^calc/, ""));
+			else value.push(dim.replace(/^calc/, ""));
+		}
+		if (this.#hasEtc) {
+			if (this.#etcSum.length) {
+				const sum = this.sort(this.#etcSum).map((item) => {
+					let res;
+					if (REG_OPERATOR.test(item) && !item.startsWith("(") && !item.endsWith(")")) res = `(${item})`;
+					else res = item;
+					return res;
+				}).join(" + ");
+				if (value.length) if (this.#etcSum.length > 1) value.push(`+ (${sum})`);
+				else value.push(`+ ${sum}`);
+				else value.push(`${sum}`);
+			}
+			if (this.#etcSub.length) {
+				const sub = this.sort(this.#etcSub).map((item) => {
+					let res;
+					if (REG_OPERATOR.test(item) && !item.startsWith("(") && !item.endsWith(")")) res = `(${item})`;
+					else res = item;
+					return res;
+				}).join(" + ");
+				if (value.length) if (this.#etcSub.length > 1) value.push(`- (${sub})`);
+				else value.push(`- ${sub}`);
+				else if (this.#etcSub.length > 1) value.push(`-1 * (${sub})`);
+				else value.push(`-1 * ${sub}`);
+			}
+		}
+		if (value.length) return value.join(" ");
+		return "";
+	}
+};
+/**
+* sort calc values
+* @param values - values to sort
+* @param [finalize] - finalize values
+* @returns sorted values
+*/
+var sortCalcValues = (values = [], finalize = false) => {
+	if (values.length < TRIA) throw new Error(`Unexpected array length ${values.length}.`);
+	const start = values.shift();
+	if (!isString(start) || !start.endsWith("(")) throw new Error(`Unexpected token ${start}.`);
+	const end = values.pop();
+	if (end !== ")") throw new Error(`Unexpected token ${end}.`);
+	if (values.length === 1) {
+		const [value] = values;
+		if (!isStringOrNumber(value)) throw new Error(`Unexpected token ${value}.`);
+		return `${start}${value}${end}`;
+	}
+	const sortedValues = [];
+	const cal = new Calculator();
+	let operator = "";
+	const l = values.length;
+	let hasAddSub = false;
+	for (let i = 0; i < l; i++) {
+		const value = values[i];
+		if (!isStringOrNumber(value)) throw new Error(`Unexpected token ${value}.`);
+		if (value === "*" || value === "/") operator = value;
+		else if (value === "+" || value === "-") {
+			const sortedValue = cal.multiply();
+			if (sortedValue) sortedValues.push(sortedValue, value);
+			hasAddSub = true;
+			cal.clear();
+			operator = "";
+		} else {
+			const numValue = Number(value);
+			const strValue = `${value}`;
+			switch (operator) {
+				case "/":
+					if (Number.isFinite(numValue)) {
+						cal.hasNum = true;
+						cal.numMul.push(1 / numValue);
+					} else if (REG_TYPE_PCT.test(strValue)) {
+						const [, val] = strValue.match(REG_TYPE_PCT);
+						cal.hasPct = true;
+						cal.pctMul.push(MAX_PCT * MAX_PCT / Number(val));
+					} else if (REG_TYPE_DIM.test(strValue)) {
+						cal.hasDim = true;
+						cal.dimDiv.push(strValue);
+					} else {
+						cal.hasEtc = true;
+						cal.etcDiv.push(strValue);
+					}
+					break;
+				default: if (Number.isFinite(numValue)) {
+					cal.hasNum = true;
+					cal.numMul.push(numValue);
+				} else if (REG_TYPE_PCT.test(strValue)) {
+					const [, val] = strValue.match(REG_TYPE_PCT);
+					cal.hasPct = true;
+					cal.pctMul.push(Number(val));
+				} else if (REG_TYPE_DIM.test(strValue)) {
+					cal.hasDim = true;
+					cal.dimMul.push(strValue);
+				} else {
+					cal.hasEtc = true;
+					cal.etcMul.push(strValue);
+				}
+			}
+		}
+		if (i === l - 1) {
+			const sortedValue = cal.multiply();
+			if (sortedValue) sortedValues.push(sortedValue);
+			cal.clear();
+			operator = "";
+		}
+	}
+	let resolvedValue = "";
+	if (finalize && hasAddSub) {
+		const finalizedValues = [];
+		cal.clear();
+		operator = "";
+		const l = sortedValues.length;
+		for (let i = 0; i < l; i++) {
+			const value = sortedValues[i];
+			if (isStringOrNumber(value)) if (value === "+" || value === "-") operator = value;
+			else {
+				const numValue = Number(value);
+				const strValue = `${value}`;
+				switch (operator) {
+					case "-":
+						if (Number.isFinite(numValue)) {
+							cal.hasNum = true;
+							cal.numSum.push(-1 * numValue);
+						} else if (REG_TYPE_PCT.test(strValue)) {
+							const [, val] = strValue.match(REG_TYPE_PCT);
+							cal.hasPct = true;
+							cal.pctSum.push(-1 * Number(val));
+						} else if (REG_TYPE_DIM.test(strValue)) {
+							cal.hasDim = true;
+							cal.dimSub.push(strValue);
+						} else {
+							cal.hasEtc = true;
+							cal.etcSub.push(strValue);
+						}
+						break;
+					default: if (Number.isFinite(numValue)) {
+						cal.hasNum = true;
+						cal.numSum.push(numValue);
+					} else if (REG_TYPE_PCT.test(strValue)) {
+						const [, val] = strValue.match(REG_TYPE_PCT);
+						cal.hasPct = true;
+						cal.pctSum.push(Number(val));
+					} else if (REG_TYPE_DIM.test(strValue)) {
+						cal.hasDim = true;
+						cal.dimSum.push(strValue);
+					} else {
+						cal.hasEtc = true;
+						cal.etcSum.push(strValue);
+					}
+				}
+			}
+			if (i === l - 1) {
+				const sortedValue = cal.sum();
+				if (sortedValue) finalizedValues.push(sortedValue);
+				cal.clear();
+				operator = "";
+			}
+		}
+		resolvedValue = finalizedValues.join(" ").replace(/\+\s-/g, "- ");
+	} else resolvedValue = sortedValues.join(" ").replace(/\+\s-/g, "- ");
+	if (resolvedValue.startsWith("(") && resolvedValue.endsWith(")") && resolvedValue.lastIndexOf("(") === 0 && resolvedValue.indexOf(")") === resolvedValue.length - 1) resolvedValue = resolvedValue.substring(1, resolvedValue.length - 1);
+	return `${start}${resolvedValue}${end}`;
+};
+/**
+* resolve AST node
+* @param node - AST node
+* @param isRoot - is root node
+* @returns resolved value
+*/
+var resolveNode = (node, isRoot) => {
+	const flatItems = [];
+	for (const item of node) if (Array.isArray(item)) flatItems.push(resolveNode(item, false));
+	else flatItems.push(item);
+	if (isRoot) {
+		if (flatItems.length >= TRIA) return sortCalcValues(flatItems, true);
+		const joined = flatItems.join("");
+		return joined.startsWith("calc(") ? joined : `calc(${joined})`;
+	}
+	if (flatItems.length >= TRIA) {
+		let serialized = sortCalcValues(flatItems, false);
+		if (REG_FN_VAR_START.test(serialized)) serialized = calc(serialized, { toCanonicalUnits: true });
+		return serialized;
+	}
+	return flatItems.join("");
+};
+/**
+* serialize calc
+* @param value - CSS value
+* @param [opt] - options
+* @returns serialized value
+*/
+var serializeCalc = (value, opt = {}) => {
+	const { format = "" } = opt;
+	if (isString(value)) {
+		if (!REG_FN_VAR_START.test(value) || format !== "specifiedValue") return value;
+		value = value.toLowerCase().trim();
+	} else throw new TypeError(`${value} is not a string.`);
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "serializeCalc",
+		value
+	}, opt);
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) return cachedResult.item;
+	const items = tokenize({ css: value }).map((token) => {
+		const [type, val] = token;
+		let res = "";
+		if (type !== W_SPACE && type !== COMMENT) res = val;
+		return res;
+	}).filter((v) => v);
+	const stack = [[]];
+	for (const item of items) if (REG_PAREN_OPEN.test(item)) {
+		const newNode = [item];
+		const parent = stack[stack.length - 1];
+		if (parent) parent.push(newNode);
+		stack.push(newNode);
+	} else if (item === ")") if (stack.length > 1) {
+		const currentLevel = stack.pop();
+		if (currentLevel) currentLevel.push(item);
+	} else {
+		const root = stack[0];
+		if (root) root.push(item);
+	}
+	else {
+		const parent = stack[stack.length - 1];
+		if (parent) parent.push(item);
+	}
+	let serializedCalc = "";
+	const rootItems = stack[0];
+	if (rootItems) if (rootItems.length === 1 && Array.isArray(rootItems[0])) serializedCalc = resolveNode(rootItems[0], true);
+	else {
+		const flatItems = [];
+		for (const item of rootItems) if (Array.isArray(item)) flatItems.push(resolveNode(item, false));
+		else flatItems.push(item);
+		if (flatItems.length >= TRIA) serializedCalc = sortCalcValues(flatItems, true);
+		else {
+			const firstItem = flatItems[0] || "";
+			serializedCalc = isString(firstItem) && firstItem.startsWith("calc(") ? firstItem : `calc(${firstItem})`;
+		}
+	}
+	setCache(cacheKey, serializedCalc);
+	return serializedCalc;
+};
+/**
+* resolve dimension
+* @param token - CSS token
+* @param [opt] - options
+* @returns resolved value
+*/
+var resolveDimension = (token, opt = {}) => {
+	if (!Array.isArray(token)) throw new TypeError(`${token} is not an array.`);
+	const [, , , , detail = {}] = token;
+	const { unit, value } = detail;
+	if (unit === "px") return `${value}${unit}`;
+	const pixelValue = resolveLengthInPixels(Number(value), unit, opt);
+	if (Number.isFinite(pixelValue)) return `${roundToPrecision(pixelValue, HEX)}px`;
+	return new NullObject();
+};
+/**
+* parse tokens
+* @param tokens - CSS tokens
+* @param [opt] - options
+* @returns parsed tokens
+*/
+var parseTokens = (tokens, opt = {}) => {
+	if (!Array.isArray(tokens)) throw new TypeError(`${tokens} is not an array.`);
+	const { format = "" } = opt;
+	const mathFunc = /* @__PURE__ */ new Set();
+	let nest = 0;
+	const res = [];
+	for (const token of tokens) {
+		if (!Array.isArray(token)) throw new TypeError(`${token} is not an array.`);
+		const [type = "", value = ""] = token;
+		switch (type) {
+			case DIM:
+				if (format === "specifiedValue" && !mathFunc.has(nest)) res.push(value);
+				else {
+					const resolvedValue = resolveDimension(token, opt);
+					if (isString(resolvedValue)) res.push(resolvedValue);
+					else res.push(value);
+				}
+				break;
+			case FUNC:
+			case PAREN_OPEN:
+				res.push(value);
+				nest++;
+				if (REG_FN_MATH_START.test(value)) mathFunc.add(nest);
+				break;
+			case PAREN_CLOSE:
+				if (res.length) if (res[res.length - 1] === " ") res.splice(-1, 1, value);
+				else res.push(value);
+				else res.push(value);
+				if (mathFunc.has(nest)) mathFunc.delete(nest);
+				nest--;
+				break;
+			case W_SPACE:
+				if (res.length) {
+					const lastValue = res[res.length - 1];
+					if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") res.push(value);
+				}
+				break;
+			default: if (type !== COMMENT && type !== EOF) res.push(value);
+		}
+	}
+	return res;
+};
+/**
+* CSS calc()
+* @param value - CSS value including calc()
+* @param [opt] - options
+* @returns resolved value
+*/
+var cssCalc = (value, opt = {}) => {
+	const { format = "" } = opt;
+	if (isString(value)) {
+		if (REG_FN_VAR.test(value)) if (format === "specifiedValue") return value;
+		else {
+			const resolvedValue = resolveVar(value, opt);
+			if (isString(resolvedValue)) return resolvedValue;
+			else return "";
+		}
+		else if (!REG_FN_CALC.test(value)) return value;
+		value = value.toLowerCase().trim();
+	} else throw new TypeError(`${value} is not a string.`);
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "cssCalc",
+		value
+	}, opt);
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) return cachedResult.item;
+	let resolvedValue = calc(parseTokens(tokenize({ css: value }), opt).join(""), { toCanonicalUnits: true });
+	if (REG_FN_VAR_START.test(value)) {
+		if (REG_TYPE_DIM_PCT.test(resolvedValue)) {
+			const [, val, unit] = resolvedValue.match(REG_TYPE_DIM_PCT);
+			resolvedValue = `${roundToPrecision(Number(val), HEX)}${unit}`;
+		}
+		if (resolvedValue && !REG_FN_VAR_START.test(resolvedValue) && format === "specifiedValue") resolvedValue = `calc(${resolvedValue})`;
+	}
+	if (format === "specifiedValue") {
+		if (/\s[-+*/]\s/.test(resolvedValue) && !resolvedValue.includes("NaN")) resolvedValue = serializeCalc(resolvedValue, opt);
+		else if (REG_FN_CALC_NUM.test(resolvedValue)) {
+			const [, val] = resolvedValue.match(REG_FN_CALC_NUM);
+			resolvedValue = `calc(${roundToPrecision(Number(val), HEX)})`;
+		}
+	}
+	setCache(cacheKey, resolvedValue);
+	return resolvedValue;
+};
+//#endregion
+export { cssCalc, resolveDimension, serializeCalc };
+
+//# sourceMappingURL=css-calc.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/css-calc.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-calc.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..c0877aa90aa21b0d9fd2b79ea6e32b812c039401
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-calc.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"css-calc.js","names":["#hasNum","#numSum","#numMul","#hasPct","#pctSum","#pctMul","#hasDim","#dimSum","#dimSub","#dimMul","#dimDiv","#hasEtc","#etcSum","#etcSub","#etcMul","#etcDiv","#calcOpts"],"sources":["../../../src/js/css-calc.ts"],"sourcesContent":["/**\n * css-calc\n */\n\nimport { calc, conversionOptions as CalcOptions } from '@csstools/css-calc';\nimport { CSSToken, TokenType, tokenize } from '@csstools/css-tokenizer';\nimport {\n  CacheItem,\n  NullObject,\n  createCacheKey,\n  getCache,\n  setCache\n} from './cache';\nimport { isString, isStringOrNumber } from './common';\nimport { resolveVar } from './css-var';\nimport { resolveLengthInPixels, roundToPrecision } from './util';\nimport { MatchedRegExp, Options } from './typedef';\n\n/* constants */\nimport {\n  ANGLE,\n  LENGTH,\n  NUM,\n  SYN_FN_CALC,\n  SYN_FN_MATH_START,\n  SYN_FN_VAR,\n  SYN_FN_VAR_START,\n  VAL_SPEC\n} from './constant';\nconst {\n  CloseParen: PAREN_CLOSE,\n  Comment: COMMENT,\n  Dimension: DIM,\n  EOF,\n  Function: FUNC,\n  OpenParen: PAREN_OPEN,\n  Whitespace: W_SPACE\n} = TokenType;\nconst NAMESPACE = 'css-calc';\n\n/* numeric constants */\nconst TRIA = 3;\nconst HEX = 16;\nconst MAX_PCT = 100;\n\n/* regexp */\nconst REG_FN_CALC = new RegExp(SYN_FN_CALC);\nconst REG_FN_CALC_NUM = new RegExp(`^calc\\\\((${NUM})\\\\)$`);\nconst REG_FN_MATH_START = new RegExp(SYN_FN_MATH_START);\nconst REG_FN_VAR = new RegExp(SYN_FN_VAR);\nconst REG_FN_VAR_START = new RegExp(SYN_FN_VAR_START);\nconst REG_OPERATOR = /\\s[*+/-]\\s/;\nconst REG_PAREN_OPEN = /\\($/;\nconst REG_TYPE_DIM = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH})$`);\nconst REG_TYPE_DIM_PCT = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH}|%)$`);\nconst REG_TYPE_PCT = new RegExp(`^(${NUM})%$`);\n\n/**\n * Calclator\n */\nexport class Calculator {\n  /* private */\n  // number\n  #hasNum: boolean;\n  #numSum: number[];\n  #numMul: number[];\n  // percentage\n  #hasPct: boolean;\n  #pctSum: number[];\n  #pctMul: number[];\n  // dimension\n  #hasDim: boolean;\n  #dimSum: string[];\n  #dimSub: string[];\n  #dimMul: string[];\n  #dimDiv: string[];\n  // et cetra\n  #hasEtc: boolean;\n  #etcSum: string[];\n  #etcSub: string[];\n  #etcMul: string[];\n  #etcDiv: string[];\n  // calc options\n  #calcOpts: CalcOptions;\n\n  /**\n   * constructor\n   */\n  constructor() {\n    // number\n    this.#hasNum = false;\n    this.#numSum = [];\n    this.#numMul = [];\n    // percentage\n    this.#hasPct = false;\n    this.#pctSum = [];\n    this.#pctMul = [];\n    // dimension\n    this.#hasDim = false;\n    this.#dimSum = [];\n    this.#dimSub = [];\n    this.#dimMul = [];\n    this.#dimDiv = [];\n    // et cetra\n    this.#hasEtc = false;\n    this.#etcSum = [];\n    this.#etcSub = [];\n    this.#etcMul = [];\n    this.#etcDiv = [];\n    // calc options\n    this.#calcOpts = {\n      toCanonicalUnits: true\n    };\n  }\n\n  get hasNum() {\n    return this.#hasNum;\n  }\n\n  set hasNum(value: boolean) {\n    this.#hasNum = !!value;\n  }\n\n  get numSum() {\n    return this.#numSum;\n  }\n\n  get numMul() {\n    return this.#numMul;\n  }\n\n  get hasPct() {\n    return this.#hasPct;\n  }\n\n  set hasPct(value: boolean) {\n    this.#hasPct = !!value;\n  }\n\n  get pctSum() {\n    return this.#pctSum;\n  }\n\n  get pctMul() {\n    return this.#pctMul;\n  }\n\n  get hasDim() {\n    return this.#hasDim;\n  }\n\n  set hasDim(value: boolean) {\n    this.#hasDim = !!value;\n  }\n\n  get dimSum() {\n    return this.#dimSum;\n  }\n\n  get dimSub() {\n    return this.#dimSub;\n  }\n\n  get dimMul() {\n    return this.#dimMul;\n  }\n\n  get dimDiv() {\n    return this.#dimDiv;\n  }\n\n  get hasEtc() {\n    return this.#hasEtc;\n  }\n\n  set hasEtc(value: boolean) {\n    this.#hasEtc = !!value;\n  }\n\n  get etcSum() {\n    return this.#etcSum;\n  }\n\n  get etcSub() {\n    return this.#etcSub;\n  }\n\n  get etcMul() {\n    return this.#etcMul;\n  }\n\n  get etcDiv() {\n    return this.#etcDiv;\n  }\n\n  /**\n   * clear values\n   * @returns void\n   */\n  clear() {\n    // number\n    this.#hasNum = false;\n    this.#numSum.length = 0;\n    this.#numMul.length = 0;\n    // percentage\n    this.#hasPct = false;\n    this.#pctSum.length = 0;\n    this.#pctMul.length = 0;\n    // dimension\n    this.#hasDim = false;\n    this.#dimSum.length = 0;\n    this.#dimSub.length = 0;\n    this.#dimMul.length = 0;\n    this.#dimDiv.length = 0;\n    // et cetra\n    this.#hasEtc = false;\n    this.#etcSum.length = 0;\n    this.#etcSub.length = 0;\n    this.#etcMul.length = 0;\n    this.#etcDiv.length = 0;\n  }\n\n  /**\n   * sort values\n   * @param values - values\n   * @returns sorted values\n   */\n  sort(values: string[] = []): string[] {\n    const arr = [...values];\n    if (arr.length > 1) {\n      arr.sort((a, b) => {\n        let res;\n        if (REG_TYPE_DIM_PCT.test(a) && REG_TYPE_DIM_PCT.test(b)) {\n          const [, valA, unitA] = a.match(REG_TYPE_DIM_PCT) as MatchedRegExp;\n          const [, valB, unitB] = b.match(REG_TYPE_DIM_PCT) as MatchedRegExp;\n          if (unitA === unitB) {\n            if (Number(valA) === Number(valB)) {\n              res = 0;\n            } else if (Number(valA) > Number(valB)) {\n              res = 1;\n            } else {\n              res = -1;\n            }\n          } else if (unitA > unitB) {\n            res = 1;\n          } else {\n            res = -1;\n          }\n        } else {\n          if (a === b) {\n            res = 0;\n          } else if (a > b) {\n            res = 1;\n          } else {\n            res = -1;\n          }\n        }\n        return res;\n      });\n    }\n    return arr;\n  }\n\n  /**\n   * multiply values\n   * @returns resolved value\n   */\n  multiply(): string {\n    const value = [];\n    let num;\n    if (this.#hasNum) {\n      num = 1;\n      for (const i of this.#numMul) {\n        num *= i;\n        if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) {\n          break;\n        }\n      }\n      if (!this.#hasPct && !this.#hasDim && !this.hasEtc) {\n        if (Number.isFinite(num)) {\n          num = roundToPrecision(num, HEX);\n        }\n        value.push(num);\n      }\n    }\n    if (this.#hasPct) {\n      if (typeof num !== 'number') {\n        num = 1;\n      }\n      for (const i of this.#pctMul) {\n        num *= i;\n        if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) {\n          break;\n        }\n      }\n      if (Number.isFinite(num)) {\n        num = `${roundToPrecision(num, HEX)}%`;\n      }\n      if (!this.#hasDim && !this.hasEtc) {\n        value.push(num);\n      }\n    }\n    if (this.#hasDim) {\n      let dim = '';\n      let mul = '';\n      let div = '';\n      if (this.#dimMul.length) {\n        if (this.#dimMul.length === 1) {\n          [mul] = this.#dimMul as [string];\n        } else {\n          mul = `${this.sort(this.#dimMul).join(' * ')}`;\n        }\n      }\n      if (this.#dimDiv.length) {\n        if (this.#dimDiv.length === 1) {\n          [div] = this.#dimDiv as [string];\n        } else {\n          div = `${this.sort(this.#dimDiv).join(' * ')}`;\n        }\n      }\n      if (Number.isFinite(num)) {\n        if (mul) {\n          if (div) {\n            if (div.includes('*')) {\n              dim = calc(`calc(${num} * ${mul} / (${div}))`, this.#calcOpts);\n            } else {\n              dim = calc(`calc(${num} * ${mul} / ${div})`, this.#calcOpts);\n            }\n          } else {\n            dim = calc(`calc(${num} * ${mul})`, this.#calcOpts);\n          }\n        } else if (div.includes('*')) {\n          dim = calc(`calc(${num} / (${div}))`, this.#calcOpts);\n        } else {\n          dim = calc(`calc(${num} / ${div})`, this.#calcOpts);\n        }\n        value.push(dim.replace(/^calc/, ''));\n      } else {\n        if (!value.length && num !== undefined) {\n          value.push(num);\n        }\n        if (mul) {\n          if (div) {\n            if (div.includes('*')) {\n              dim = calc(`calc(${mul} / (${div}))`, this.#calcOpts);\n            } else {\n              dim = calc(`calc(${mul} / ${div})`, this.#calcOpts);\n            }\n          } else {\n            dim = calc(`calc(${mul})`, this.#calcOpts);\n          }\n          if (value.length) {\n            value.push('*', dim.replace(/^calc/, ''));\n          } else {\n            value.push(dim.replace(/^calc/, ''));\n          }\n        } else {\n          dim = calc(`calc(${div})`, this.#calcOpts);\n          if (value.length) {\n            value.push('/', dim.replace(/^calc/, ''));\n          } else {\n            value.push('1', '/', dim.replace(/^calc/, ''));\n          }\n        }\n      }\n    }\n    if (this.#hasEtc) {\n      if (this.#etcMul.length) {\n        if (!value.length && num !== undefined) {\n          value.push(num);\n        }\n        const mul = this.sort(this.#etcMul).join(' * ');\n        if (value.length) {\n          value.push(`* ${mul}`);\n        } else {\n          value.push(`${mul}`);\n        }\n      }\n      if (this.#etcDiv.length) {\n        const div = this.sort(this.#etcDiv).join(' * ');\n        if (div.includes('*')) {\n          if (value.length) {\n            value.push(`/ (${div})`);\n          } else {\n            value.push(`1 / (${div})`);\n          }\n        } else if (value.length) {\n          value.push(`/ ${div}`);\n        } else {\n          value.push(`1 / ${div}`);\n        }\n      }\n    }\n    if (value.length) {\n      return value.join(' ');\n    }\n    return '';\n  }\n\n  /**\n   * sum values\n   * @returns resolved value\n   */\n  sum(): string {\n    const value = [];\n    if (this.#hasNum) {\n      let num = 0;\n      for (const i of this.#numSum) {\n        num += i;\n        if (!Number.isFinite(num) || Number.isNaN(num)) {\n          break;\n        }\n      }\n      value.push(num);\n    }\n    if (this.#hasPct) {\n      let num: number | string = 0;\n      for (const i of this.#pctSum) {\n        num += i;\n        if (!Number.isFinite(num)) {\n          break;\n        }\n      }\n      if (Number.isFinite(num)) {\n        num = `${num}%`;\n      }\n      if (value.length) {\n        value.push(`+ ${num}`);\n      } else {\n        value.push(num);\n      }\n    }\n    if (this.#hasDim) {\n      let dim, sum, sub;\n      if (this.#dimSum.length) {\n        sum = this.sort(this.#dimSum).join(' + ');\n      }\n      if (this.#dimSub.length) {\n        sub = this.sort(this.#dimSub).join(' + ');\n      }\n      if (sum) {\n        if (sub) {\n          if (sub.includes('-')) {\n            dim = calc(`calc(${sum} - (${sub}))`, this.#calcOpts);\n          } else {\n            dim = calc(`calc(${sum} - ${sub})`, this.#calcOpts);\n          }\n        } else {\n          dim = calc(`calc(${sum})`, this.#calcOpts);\n        }\n      } else {\n        dim = calc(`calc(-1 * (${sub}))`, this.#calcOpts);\n      }\n      if (value.length) {\n        value.push('+', dim.replace(/^calc/, ''));\n      } else {\n        value.push(dim.replace(/^calc/, ''));\n      }\n    }\n    if (this.#hasEtc) {\n      if (this.#etcSum.length) {\n        const sum = this.sort(this.#etcSum)\n          .map(item => {\n            let res;\n            if (\n              REG_OPERATOR.test(item) &&\n              !item.startsWith('(') &&\n              !item.endsWith(')')\n            ) {\n              res = `(${item})`;\n            } else {\n              res = item;\n            }\n            return res;\n          })\n          .join(' + ');\n        if (value.length) {\n          if (this.#etcSum.length > 1) {\n            value.push(`+ (${sum})`);\n          } else {\n            value.push(`+ ${sum}`);\n          }\n        } else {\n          value.push(`${sum}`);\n        }\n      }\n      if (this.#etcSub.length) {\n        const sub = this.sort(this.#etcSub)\n          .map(item => {\n            let res;\n            if (\n              REG_OPERATOR.test(item) &&\n              !item.startsWith('(') &&\n              !item.endsWith(')')\n            ) {\n              res = `(${item})`;\n            } else {\n              res = item;\n            }\n            return res;\n          })\n          .join(' + ');\n        if (value.length) {\n          if (this.#etcSub.length > 1) {\n            value.push(`- (${sub})`);\n          } else {\n            value.push(`- ${sub}`);\n          }\n        } else if (this.#etcSub.length > 1) {\n          value.push(`-1 * (${sub})`);\n        } else {\n          value.push(`-1 * ${sub}`);\n        }\n      }\n    }\n    if (value.length) {\n      return value.join(' ');\n    }\n    return '';\n  }\n}\n\n/**\n * sort calc values\n * @param values - values to sort\n * @param [finalize] - finalize values\n * @returns sorted values\n */\nexport const sortCalcValues = (\n  values: (number | string)[] = [],\n  finalize: boolean = false\n): string => {\n  if (values.length < TRIA) {\n    throw new Error(`Unexpected array length ${values.length}.`);\n  }\n  const start = values.shift();\n  if (!isString(start) || !start.endsWith('(')) {\n    throw new Error(`Unexpected token ${start}.`);\n  }\n  const end = values.pop();\n  if (end !== ')') {\n    throw new Error(`Unexpected token ${end}.`);\n  }\n  if (values.length === 1) {\n    const [value] = values;\n    if (!isStringOrNumber(value)) {\n      throw new Error(`Unexpected token ${value}.`);\n    }\n    return `${start}${value}${end}`;\n  }\n  const sortedValues = [];\n  const cal = new Calculator();\n  let operator: string = '';\n  const l = values.length;\n  // Array traversal optimization for operator check\n  let hasAddSub = false;\n  for (let i = 0; i < l; i++) {\n    const value = values[i];\n    if (!isStringOrNumber(value)) {\n      throw new Error(`Unexpected token ${value}.`);\n    }\n    if (value === '*' || value === '/') {\n      operator = value;\n    } else if (value === '+' || value === '-') {\n      const sortedValue = cal.multiply();\n      if (sortedValue) {\n        sortedValues.push(sortedValue, value);\n      }\n      // Mark presence of + or -\n      hasAddSub = true;\n      cal.clear();\n      operator = '';\n    } else {\n      const numValue = Number(value);\n      const strValue = `${value}`;\n      switch (operator) {\n        case '/': {\n          if (Number.isFinite(numValue)) {\n            cal.hasNum = true;\n            cal.numMul.push(1 / numValue);\n          } else if (REG_TYPE_PCT.test(strValue)) {\n            const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;\n            cal.hasPct = true;\n            cal.pctMul.push((MAX_PCT * MAX_PCT) / Number(val));\n          } else if (REG_TYPE_DIM.test(strValue)) {\n            cal.hasDim = true;\n            cal.dimDiv.push(strValue);\n          } else {\n            cal.hasEtc = true;\n            cal.etcDiv.push(strValue);\n          }\n          break;\n        }\n        case '*':\n        default: {\n          if (Number.isFinite(numValue)) {\n            cal.hasNum = true;\n            cal.numMul.push(numValue);\n          } else if (REG_TYPE_PCT.test(strValue)) {\n            const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;\n            cal.hasPct = true;\n            cal.pctMul.push(Number(val));\n          } else if (REG_TYPE_DIM.test(strValue)) {\n            cal.hasDim = true;\n            cal.dimMul.push(strValue);\n          } else {\n            cal.hasEtc = true;\n            cal.etcMul.push(strValue);\n          }\n        }\n      }\n    }\n    if (i === l - 1) {\n      const sortedValue = cal.multiply();\n      if (sortedValue) {\n        sortedValues.push(sortedValue);\n      }\n      cal.clear();\n      operator = '';\n    }\n  }\n  let resolvedValue = '';\n  if (finalize && hasAddSub) {\n    const finalizedValues = [];\n    cal.clear();\n    operator = '';\n    const l = sortedValues.length;\n    for (let i = 0; i < l; i++) {\n      const value = sortedValues[i];\n      if (isStringOrNumber(value)) {\n        if (value === '+' || value === '-') {\n          operator = value;\n        } else {\n          const numValue = Number(value);\n          const strValue = `${value}`;\n          switch (operator) {\n            case '-': {\n              if (Number.isFinite(numValue)) {\n                cal.hasNum = true;\n                cal.numSum.push(-1 * numValue);\n              } else if (REG_TYPE_PCT.test(strValue)) {\n                const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;\n                cal.hasPct = true;\n                cal.pctSum.push(-1 * Number(val));\n              } else if (REG_TYPE_DIM.test(strValue)) {\n                cal.hasDim = true;\n                cal.dimSub.push(strValue);\n              } else {\n                cal.hasEtc = true;\n                cal.etcSub.push(strValue);\n              }\n              break;\n            }\n            case '+':\n            default: {\n              if (Number.isFinite(numValue)) {\n                cal.hasNum = true;\n                cal.numSum.push(numValue);\n              } else if (REG_TYPE_PCT.test(strValue)) {\n                const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;\n                cal.hasPct = true;\n                cal.pctSum.push(Number(val));\n              } else if (REG_TYPE_DIM.test(strValue)) {\n                cal.hasDim = true;\n                cal.dimSum.push(strValue);\n              } else {\n                cal.hasEtc = true;\n                cal.etcSum.push(strValue);\n              }\n            }\n          }\n        }\n      }\n      if (i === l - 1) {\n        const sortedValue = cal.sum();\n        if (sortedValue) {\n          finalizedValues.push(sortedValue);\n        }\n        cal.clear();\n        operator = '';\n      }\n    }\n    resolvedValue = finalizedValues.join(' ').replace(/\\+\\s-/g, '- ');\n  } else {\n    resolvedValue = sortedValues.join(' ').replace(/\\+\\s-/g, '- ');\n  }\n  if (\n    resolvedValue.startsWith('(') &&\n    resolvedValue.endsWith(')') &&\n    resolvedValue.lastIndexOf('(') === 0 &&\n    resolvedValue.indexOf(')') === resolvedValue.length - 1\n  ) {\n    resolvedValue = resolvedValue.substring(1, resolvedValue.length - 1);\n  }\n  return `${start}${resolvedValue}${end}`;\n};\n\n/**\n * resolve AST node\n * @param node - AST node\n * @param isRoot - is root node\n * @returns resolved value\n */\nconst resolveNode = (node: any[], isRoot: boolean): string => {\n  const flatItems: string[] = [];\n  for (const item of node) {\n    if (Array.isArray(item)) {\n      flatItems.push(resolveNode(item, false));\n    } else {\n      flatItems.push(item as string);\n    }\n  }\n  if (isRoot) {\n    if (flatItems.length >= TRIA) {\n      return sortCalcValues(flatItems, true);\n    }\n    const joined = flatItems.join('');\n    return joined.startsWith('calc(') ? joined : `calc(${joined})`;\n  }\n  if (flatItems.length >= TRIA) {\n    let serialized = sortCalcValues(flatItems, false);\n    if (REG_FN_VAR_START.test(serialized)) {\n      serialized = calc(serialized, { toCanonicalUnits: true });\n    }\n    return serialized;\n  }\n  return flatItems.join('');\n};\n\n/**\n * serialize calc\n * @param value - CSS value\n * @param [opt] - options\n * @returns serialized value\n */\nexport const serializeCalc = (value: string, opt: Options = {}): string => {\n  const { format = '' } = opt;\n  if (isString(value)) {\n    if (!REG_FN_VAR_START.test(value) || format !== VAL_SPEC) {\n      return value;\n    }\n    value = value.toLowerCase().trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const cacheKey: string = createCacheKey(\n    {\n      namespace: NAMESPACE,\n      name: 'serializeCalc',\n      value\n    },\n    opt\n  );\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    return cachedResult.item as string;\n  }\n  const items: string[] = tokenize({ css: value })\n    .map((token: CSSToken): string => {\n      const [type, val] = token as [TokenType, string];\n      let res = '';\n      if (type !== W_SPACE && type !== COMMENT) {\n        res = val;\n      }\n      return res;\n    })\n    .filter(v => v);\n  const stack: any[][] = [[]];\n  for (const item of items) {\n    if (REG_PAREN_OPEN.test(item)) {\n      const newNode = [item];\n      const parent = stack[stack.length - 1];\n      if (parent) {\n        parent.push(newNode);\n      }\n      stack.push(newNode);\n    } else if (item === ')') {\n      if (stack.length > 1) {\n        const currentLevel = stack.pop();\n        if (currentLevel) {\n          currentLevel.push(item);\n        }\n      } else {\n        const root = stack[0];\n        if (root) {\n          root.push(item);\n        }\n      }\n    } else {\n      const parent = stack[stack.length - 1];\n      if (parent) {\n        parent.push(item);\n      }\n    }\n  }\n  let serializedCalc = '';\n  const rootItems = stack[0];\n  if (rootItems) {\n    if (rootItems.length === 1 && Array.isArray(rootItems[0])) {\n      serializedCalc = resolveNode(rootItems[0], true);\n    } else {\n      const flatItems: string[] = [];\n      for (const item of rootItems) {\n        if (Array.isArray(item)) {\n          flatItems.push(resolveNode(item, false));\n        } else {\n          flatItems.push(item as string);\n        }\n      }\n      if (flatItems.length >= TRIA) {\n        serializedCalc = sortCalcValues(flatItems, true);\n      } else {\n        const firstItem = flatItems[0] || '';\n        serializedCalc =\n          isString(firstItem) && firstItem.startsWith('calc(')\n            ? firstItem\n            : `calc(${firstItem})`;\n      }\n    }\n  }\n  setCache(cacheKey, serializedCalc);\n  return serializedCalc;\n};\n\n/**\n * resolve dimension\n * @param token - CSS token\n * @param [opt] - options\n * @returns resolved value\n */\nexport const resolveDimension = (\n  token: CSSToken,\n  opt: Options = {}\n): string | NullObject => {\n  if (!Array.isArray(token)) {\n    throw new TypeError(`${token} is not an array.`);\n  }\n  const [, , , , detail = {}] = token;\n  const { unit, value } = detail as {\n    unit: string;\n    value: number;\n  };\n  if (unit === 'px') {\n    return `${value}${unit}`;\n  }\n  const pixelValue = resolveLengthInPixels(Number(value), unit, opt);\n  if (Number.isFinite(pixelValue)) {\n    return `${roundToPrecision(pixelValue, HEX)}px`;\n  }\n  return new NullObject();\n};\n\n/**\n * parse tokens\n * @param tokens - CSS tokens\n * @param [opt] - options\n * @returns parsed tokens\n */\nexport const parseTokens = (\n  tokens: CSSToken[],\n  opt: Options = {}\n): string[] => {\n  if (!Array.isArray(tokens)) {\n    throw new TypeError(`${tokens} is not an array.`);\n  }\n  const { format = '' } = opt;\n  const mathFunc = new Set();\n  let nest = 0;\n  const res: string[] = [];\n  for (const token of tokens) {\n    if (!Array.isArray(token)) {\n      throw new TypeError(`${token} is not an array.`);\n    }\n    const [type = '', value = ''] = token as [TokenType, string];\n    switch (type) {\n      case DIM: {\n        if (format === VAL_SPEC && !mathFunc.has(nest)) {\n          res.push(value);\n        } else {\n          const resolvedValue = resolveDimension(token, opt);\n          if (isString(resolvedValue)) {\n            res.push(resolvedValue);\n          } else {\n            res.push(value);\n          }\n        }\n        break;\n      }\n      case FUNC:\n      case PAREN_OPEN: {\n        res.push(value);\n        nest++;\n        if (REG_FN_MATH_START.test(value)) {\n          mathFunc.add(nest);\n        }\n        break;\n      }\n      case PAREN_CLOSE: {\n        if (res.length) {\n          const lastValue = res[res.length - 1];\n          if (lastValue === ' ') {\n            res.splice(-1, 1, value);\n          } else {\n            res.push(value);\n          }\n        } else {\n          res.push(value);\n        }\n        if (mathFunc.has(nest)) {\n          mathFunc.delete(nest);\n        }\n        nest--;\n        break;\n      }\n      case W_SPACE: {\n        if (res.length) {\n          const lastValue = res[res.length - 1];\n          if (\n            isString(lastValue) &&\n            !lastValue.endsWith('(') &&\n            lastValue !== ' '\n          ) {\n            res.push(value);\n          }\n        }\n        break;\n      }\n      default: {\n        if (type !== COMMENT && type !== EOF) {\n          res.push(value);\n        }\n      }\n    }\n  }\n  return res;\n};\n\n/**\n * CSS calc()\n * @param value - CSS value including calc()\n * @param [opt] - options\n * @returns resolved value\n */\nexport const cssCalc = (value: string, opt: Options = {}): string => {\n  const { format = '' } = opt;\n  if (isString(value)) {\n    if (REG_FN_VAR.test(value)) {\n      if (format === VAL_SPEC) {\n        return value;\n      } else {\n        const resolvedValue = resolveVar(value, opt);\n        if (isString(resolvedValue)) {\n          return resolvedValue;\n        } else {\n          return '';\n        }\n      }\n    } else if (!REG_FN_CALC.test(value)) {\n      return value;\n    }\n    value = value.toLowerCase().trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const cacheKey: string = createCacheKey(\n    {\n      namespace: NAMESPACE,\n      name: 'cssCalc',\n      value\n    },\n    opt\n  );\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    return cachedResult.item as string;\n  }\n  const tokens = tokenize({ css: value });\n  const values = parseTokens(tokens, opt);\n  let resolvedValue: string = calc(values.join(''), {\n    toCanonicalUnits: true\n  });\n  if (REG_FN_VAR_START.test(value)) {\n    if (REG_TYPE_DIM_PCT.test(resolvedValue)) {\n      const [, val, unit] = resolvedValue.match(\n        REG_TYPE_DIM_PCT\n      ) as MatchedRegExp;\n      resolvedValue = `${roundToPrecision(Number(val), HEX)}${unit}`;\n    }\n    // wrap with `calc()`\n    if (\n      resolvedValue &&\n      !REG_FN_VAR_START.test(resolvedValue) &&\n      format === VAL_SPEC\n    ) {\n      resolvedValue = `calc(${resolvedValue})`;\n    }\n  }\n  if (format === VAL_SPEC) {\n    if (/\\s[-+*/]\\s/.test(resolvedValue) && !resolvedValue.includes('NaN')) {\n      resolvedValue = serializeCalc(resolvedValue, opt);\n    } else if (REG_FN_CALC_NUM.test(resolvedValue)) {\n      const [, val] = resolvedValue.match(REG_FN_CALC_NUM) as MatchedRegExp;\n      resolvedValue = `calc(${roundToPrecision(Number(val), HEX)})`;\n    }\n  }\n  setCache(cacheKey, resolvedValue);\n  return resolvedValue;\n};\n"],"mappings":"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"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/css-gradient.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-gradient.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cf0b891a5a178fa1573c283ee28e32acc68258ae
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-gradient.d.ts
@@ -0,0 +1,79 @@
+import { Options } from './typedef.js';
+/**
+ * @type ColorStopList - list of color stops
+ */
+type ColorStopList = [string, string, ...string[]];
+/**
+ * @typedef ValidateGradientLine - validate gradient line
+ * @property line - gradient line
+ * @property valid - result
+ */
+interface ValidateGradientLine {
+    line: string;
+    valid: boolean;
+}
+/**
+ * @typedef ValidateColorStops - validate color stops
+ * @property colorStops - list of color stops
+ * @property valid - result
+ */
+interface ValidateColorStops {
+    colorStops: string[];
+    valid: boolean;
+}
+/**
+ * @typedef Gradient - parsed CSS gradient
+ * @property value - input value
+ * @property type - gradient type
+ * @property [gradientLine] - gradient line
+ * @property colorStopList - list of color stops
+ */
+interface Gradient {
+    value: string;
+    type: string;
+    gradientLine?: string;
+    colorStopList: ColorStopList;
+}
+/**
+ * get gradient type
+ * @param value - gradient value
+ * @returns gradient type
+ */
+export declare const getGradientType: (value: string) => string;
+/**
+ * validate gradient line
+ * @param value - gradient line value
+ * @param type - gradient type
+ * @returns result
+ */
+export declare const validateGradientLine: (value: string, type: string) => ValidateGradientLine;
+/**
+ * validate color stop list
+ * @param list
+ * @param type
+ * @param [opt]
+ * @returns result
+ */
+export declare const validateColorStopList: (list: string[], type: string, opt?: Options) => ValidateColorStops;
+/**
+ * parse CSS gradient
+ * @param value - gradient value
+ * @param [opt] - options
+ * @returns parsed result
+ */
+export declare const parseGradient: (value: string, opt?: Options) => Gradient | null;
+/**
+ * resolve CSS gradient
+ * @param value - CSS value
+ * @param [opt] - options
+ * @returns result
+ */
+export declare const resolveGradient: (value: string, opt?: Options) => string;
+/**
+ * is CSS gradient
+ * @param value - CSS value
+ * @param [opt] - options
+ * @returns result
+ */
+export declare const isGradient: (value: string, opt?: Options) => boolean;
+export {};
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/css-gradient.js b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-gradient.js
new file mode 100644
index 0000000000000000000000000000000000000000..6067ff5867cc5a7946075a44fac8a9c91f64d5f2
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-gradient.js
@@ -0,0 +1,291 @@
+import { CacheItem, createCacheKey, getCache, setCache } from "./cache.js";
+import { isString } from "./common.js";
+import { ANGLE, CS_HUE, CS_RECT, LENGTH, NUM, NUM_POSITIVE, PCT, VAL_COMP } from "./constant.js";
+import { resolveColor } from "./resolve.js";
+import { isColor, splitValue } from "./util.js";
+//#region src/js/css-gradient.ts
+/**
+* css-gradient
+*/
+var NAMESPACE = "css-gradient";
+var DIM_ANGLE = `${NUM}(?:${ANGLE})`;
+var DIM_ANGLE_PCT = `${DIM_ANGLE}|${PCT}`;
+var DIM_LEN_PCT = `${`${NUM}(?:${LENGTH})|0`}|${PCT}`;
+var DIM_LEN_PCT_POSI = `${NUM_POSITIVE}(?:${LENGTH}|%)|0`;
+var DIM_LEN_POSI = `${NUM_POSITIVE}(?:${LENGTH})|0`;
+var CTR = "center";
+var L_R = "left|right";
+var T_B = "top|bottom";
+var S_E = "start|end";
+var AXIS_X = `${L_R}|x-(?:${S_E})`;
+var AXIS_Y = `${T_B}|y-(?:${S_E})`;
+var BLOCK = `block-(?:${S_E})`;
+var INLINE = `inline-(?:${S_E})`;
+var POS_1 = `${CTR}|${AXIS_X}|${AXIS_Y}|${BLOCK}|${INLINE}|${DIM_LEN_PCT}`;
+var POS_2 = [
+	`(?:${CTR}|${AXIS_X})\\s+(?:${CTR}|${AXIS_Y})`,
+	`(?:${CTR}|${AXIS_Y})\\s+(?:${CTR}|${AXIS_X})`,
+	`(?:${CTR}|${AXIS_X}|${DIM_LEN_PCT})\\s+(?:${CTR}|${AXIS_Y}|${DIM_LEN_PCT})`,
+	`(?:${CTR}|${BLOCK})\\s+(?:${CTR}|${INLINE})`,
+	`(?:${CTR}|${INLINE})\\s+(?:${CTR}|${BLOCK})`,
+	`(?:${CTR}|${S_E})\\s+(?:${CTR}|${S_E})`
+].join("|");
+var POS_4 = [
+	`(?:${AXIS_X})\\s+(?:${DIM_LEN_PCT})\\s+(?:${AXIS_Y})\\s+(?:${DIM_LEN_PCT})`,
+	`(?:${AXIS_Y})\\s+(?:${DIM_LEN_PCT})\\s+(?:${AXIS_X})\\s+(?:${DIM_LEN_PCT})`,
+	`(?:${BLOCK})\\s+(?:${DIM_LEN_PCT})\\s+(?:${INLINE})\\s+(?:${DIM_LEN_PCT})`,
+	`(?:${INLINE})\\s+(?:${DIM_LEN_PCT})\\s+(?:${BLOCK})\\s+(?:${DIM_LEN_PCT})`,
+	`(?:${S_E})\\s+(?:${DIM_LEN_PCT})\\s+(?:${S_E})\\s+(?:${DIM_LEN_PCT})`
+].join("|");
+var RAD_EXTENT = "(?:clos|farth)est-(?:corner|side)";
+var RAD_SIZE = [
+	`${RAD_EXTENT}(?:\\s+${RAD_EXTENT})?`,
+	`${DIM_LEN_POSI}`,
+	`(?:${DIM_LEN_PCT_POSI})\\s+(?:${DIM_LEN_PCT_POSI})`
+].join("|");
+var RAD_SHAPE = "circle|ellipse";
+var FROM_ANGLE = `from\\s+${DIM_ANGLE}`;
+var AT_POSITION = `at\\s+(?:${POS_1}|${POS_2}|${POS_4})`;
+var TO_SIDE_CORNER = `to\\s+(?:(?:${L_R})(?:\\s(?:${T_B}))?|(?:${T_B})(?:\\s(?:${L_R}))?)`;
+var IN_COLOR_SPACE = `in\\s+(?:${CS_RECT}|${CS_HUE})`;
+var LINE_SYNTAX_LINEAR = [`(?:${DIM_ANGLE}|${TO_SIDE_CORNER})(?:\\s+${IN_COLOR_SPACE})?`, `${IN_COLOR_SPACE}(?:\\s+(?:${DIM_ANGLE}|${TO_SIDE_CORNER}))?`].join("|");
+var LINE_SYNTAX_RADIAL = [
+	`(?:${RAD_SHAPE})(?:\\s+(?:${RAD_SIZE}))?(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
+	`(?:${RAD_SIZE})(?:\\s+(?:${RAD_SHAPE}))?(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
+	`${AT_POSITION}(?:\\s+${IN_COLOR_SPACE})?`,
+	`${IN_COLOR_SPACE}(?:\\s+${RAD_SHAPE})(?:\\s+(?:${RAD_SIZE}))?(?:\\s+${AT_POSITION})?`,
+	`${IN_COLOR_SPACE}(?:\\s+${RAD_SIZE})(?:\\s+(?:${RAD_SHAPE}))?(?:\\s+${AT_POSITION})?`,
+	`${IN_COLOR_SPACE}(?:\\s+${AT_POSITION})?`
+].join("|");
+var LINE_SYNTAX_CONIC = [
+	`${FROM_ANGLE}(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
+	`${AT_POSITION}(?:\\s+${IN_COLOR_SPACE})?`,
+	`${IN_COLOR_SPACE}(?:\\s+${FROM_ANGLE})?(?:\\s+${AT_POSITION})?`
+].join("|");
+var DEFAULT_LINEAR = [/to\s+bottom/];
+var DEFAULT_RADIAL = [
+	/ellipse/,
+	/farthest-corner/,
+	/at\s+center/
+];
+var DEFAULT_CONIC = [/at\s+center/];
+var IS_CONIC = /^(?:repeating-)?conic-gradient$/;
+var IS_LINEAR = /^(?:repeating-)?linear-gradient$/;
+var IS_RADIAL = /^(?:repeating-)?radial-gradient$/;
+var REG_COLOR_HINT_CONIC = new RegExp(`^(?:${DIM_ANGLE_PCT})$`);
+var REG_COLOR_HINT_NON_CONIC = new RegExp(`^(?:${DIM_LEN_PCT})$`);
+var REG_DIM_CONIC = new RegExp(`(?:\\s+(?:${DIM_ANGLE_PCT})){1,2}$`);
+var REG_DIM_NON_CONIC = new RegExp(`(?:\\s+(?:${DIM_LEN_PCT})){1,2}$`);
+var REG_GRAD = /^(?:repeating-)?(?:conic|linear|radial)-gradient\(/;
+var REG_GRAD_CAPT = /^((?:repeating-)?(?:conic|linear|radial)-gradient)\(/;
+var REG_LINE_CONIC = new RegExp(`^(?:${LINE_SYNTAX_CONIC})$`);
+var REG_LINE_LINEAR = new RegExp(`^(?:${LINE_SYNTAX_LINEAR})$`);
+var REG_LINE_RADIAL = new RegExp(`^(?:${LINE_SYNTAX_RADIAL})$`);
+/**
+* get gradient type
+* @param value - gradient value
+* @returns gradient type
+*/
+var getGradientType = (value) => {
+	if (isString(value)) {
+		value = value.trim();
+		if (REG_GRAD.test(value)) {
+			const [, type] = value.match(REG_GRAD_CAPT);
+			return type;
+		}
+	}
+	return "";
+};
+/**
+* validate gradient line
+* @param value - gradient line value
+* @param type - gradient type
+* @returns result
+*/
+var validateGradientLine = (value, type) => {
+	if (isString(value) && isString(type)) {
+		value = value.trim();
+		type = type.trim();
+		let reg = null;
+		let defaultValues = [];
+		if (IS_LINEAR.test(type)) {
+			reg = REG_LINE_LINEAR;
+			defaultValues = DEFAULT_LINEAR;
+		} else if (IS_RADIAL.test(type)) {
+			reg = REG_LINE_RADIAL;
+			defaultValues = DEFAULT_RADIAL;
+		} else if (IS_CONIC.test(type)) {
+			reg = REG_LINE_CONIC;
+			defaultValues = DEFAULT_CONIC;
+		}
+		if (reg) {
+			const valid = reg.test(value);
+			if (valid) {
+				let line = value;
+				for (const defaultValue of defaultValues) line = line.replace(defaultValue, "");
+				line = line.replace(/\s{2,}/g, " ").trim();
+				return {
+					line,
+					valid
+				};
+			}
+			return {
+				valid,
+				line: value
+			};
+		}
+	}
+	return {
+		line: value,
+		valid: false
+	};
+};
+/**
+* validate color stop list
+* @param list
+* @param type
+* @param [opt]
+* @returns result
+*/
+var validateColorStopList = (list, type, opt = {}) => {
+	if (Array.isArray(list) && list.length > 1) {
+		const isConic = IS_CONIC.test(type);
+		const regColorHint = isConic ? REG_COLOR_HINT_CONIC : REG_COLOR_HINT_NON_CONIC;
+		const regDimension = isConic ? REG_DIM_CONIC : REG_DIM_NON_CONIC;
+		const valueList = [];
+		let prevType = "";
+		for (let i = 0; i < list.length; i++) {
+			const item = list[i];
+			if (isString(item)) if (regColorHint.test(item)) {
+				if (i === 0 || prevType === "hint") return {
+					colorStops: list,
+					valid: false
+				};
+				prevType = "hint";
+				valueList.push(item);
+			} else {
+				const itemColor = item.replace(regDimension, "");
+				if (isColor(itemColor, { format: "specifiedValue" })) {
+					const resolvedColor = resolveColor(itemColor, opt);
+					prevType = "color";
+					valueList.push(item.replace(itemColor, resolvedColor));
+				} else return {
+					colorStops: list,
+					valid: false
+				};
+			}
+			else return {
+				colorStops: list,
+				valid: false
+			};
+		}
+		if (prevType !== "color") return {
+			colorStops: list,
+			valid: false
+		};
+		return {
+			valid: true,
+			colorStops: valueList
+		};
+	}
+	return {
+		colorStops: list,
+		valid: false
+	};
+};
+/**
+* parse CSS gradient
+* @param value - gradient value
+* @param [opt] - options
+* @returns parsed result
+*/
+var parseGradient = (value, opt = {}) => {
+	if (isString(value)) {
+		value = value.trim();
+		const cacheKey = createCacheKey({
+			namespace: NAMESPACE,
+			name: "parseGradient",
+			value
+		}, opt);
+		const cachedResult = getCache(cacheKey);
+		if (cachedResult instanceof CacheItem) {
+			if (cachedResult.isNull) return null;
+			return cachedResult.item;
+		}
+		const type = getGradientType(value);
+		const gradValue = value.replace(REG_GRAD, "").replace(/\)$/, "");
+		if (type && gradValue) {
+			const [lineOrColorStop = "", ...itemList] = splitValue(gradValue, { delimiter: "," });
+			const regDimension = IS_CONIC.test(type) ? REG_DIM_CONIC : REG_DIM_NON_CONIC;
+			let colorStop = "";
+			if (regDimension.test(lineOrColorStop)) {
+				const itemColor = lineOrColorStop.replace(regDimension, "");
+				if (isColor(itemColor, { format: "specifiedValue" })) {
+					const resolvedColor = resolveColor(itemColor, opt);
+					colorStop = lineOrColorStop.replace(itemColor, resolvedColor);
+				}
+			} else if (isColor(lineOrColorStop, { format: "specifiedValue" })) colorStop = resolveColor(lineOrColorStop, opt);
+			if (colorStop) {
+				itemList.unshift(colorStop);
+				const { colorStops, valid } = validateColorStopList(itemList, type, opt);
+				if (valid) {
+					const res = {
+						value,
+						type,
+						colorStopList: colorStops
+					};
+					setCache(cacheKey, res);
+					return res;
+				}
+			} else if (itemList.length > 1) {
+				const { line: gradientLine, valid: validLine } = validateGradientLine(lineOrColorStop, type);
+				const { colorStops, valid: validColorStops } = validateColorStopList(itemList, type, opt);
+				if (validLine && validColorStops) {
+					const res = {
+						value,
+						type,
+						gradientLine,
+						colorStopList: colorStops
+					};
+					setCache(cacheKey, res);
+					return res;
+				}
+			}
+		}
+		setCache(cacheKey, null);
+		return null;
+	}
+	return null;
+};
+/**
+* resolve CSS gradient
+* @param value - CSS value
+* @param [opt] - options
+* @returns result
+*/
+var resolveGradient = (value, opt = {}) => {
+	const { format = VAL_COMP } = opt;
+	const gradient = parseGradient(value, opt);
+	if (gradient) {
+		const { type = "", gradientLine = "", colorStopList = [] } = gradient;
+		if (type && Array.isArray(colorStopList) && colorStopList.length > 1) {
+			if (gradientLine) return `${type}(${gradientLine}, ${colorStopList.join(", ")})`;
+			return `${type}(${colorStopList.join(", ")})`;
+		}
+	}
+	if (format === "specifiedValue") return "";
+	return "none";
+};
+/**
+* is CSS gradient
+* @param value - CSS value
+* @param [opt] - options
+* @returns result
+*/
+var isGradient = (value, opt = {}) => {
+	return parseGradient(value, opt) !== null;
+};
+//#endregion
+export { isGradient, resolveGradient };
+
+//# sourceMappingURL=css-gradient.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/css-gradient.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-gradient.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..6d30ccecbd8fec844327ce6d0f166a99196aaae1
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-gradient.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"css-gradient.js","names":[],"sources":["../../../src/js/css-gradient.ts"],"sourcesContent":["/**\n * css-gradient\n */\n\nimport { CacheItem, createCacheKey, getCache, setCache } from './cache';\nimport { resolveColor } from './resolve';\nimport { isString } from './common';\nimport { MatchedRegExp, Options } from './typedef';\nimport { isColor, splitValue } from './util';\n\n/* constants */\nimport {\n  ANGLE,\n  CS_HUE,\n  CS_RECT,\n  LENGTH,\n  NUM,\n  NUM_POSITIVE,\n  PCT,\n  VAL_COMP,\n  VAL_SPEC\n} from './constant';\nconst NAMESPACE = 'css-gradient';\nconst DIM_ANGLE = `${NUM}(?:${ANGLE})`;\nconst DIM_ANGLE_PCT = `${DIM_ANGLE}|${PCT}`;\nconst DIM_LEN = `${NUM}(?:${LENGTH})|0`;\nconst DIM_LEN_PCT = `${DIM_LEN}|${PCT}`;\nconst DIM_LEN_PCT_POSI = `${NUM_POSITIVE}(?:${LENGTH}|%)|0`;\nconst DIM_LEN_POSI = `${NUM_POSITIVE}(?:${LENGTH})|0`;\nconst CTR = 'center';\nconst L_R = 'left|right';\nconst T_B = 'top|bottom';\nconst S_E = 'start|end';\nconst AXIS_X = `${L_R}|x-(?:${S_E})`;\nconst AXIS_Y = `${T_B}|y-(?:${S_E})`;\nconst BLOCK = `block-(?:${S_E})`;\nconst INLINE = `inline-(?:${S_E})`;\nconst POS_1 = `${CTR}|${AXIS_X}|${AXIS_Y}|${BLOCK}|${INLINE}|${DIM_LEN_PCT}`;\nconst POS_2 = [\n  `(?:${CTR}|${AXIS_X})\\\\s+(?:${CTR}|${AXIS_Y})`,\n  `(?:${CTR}|${AXIS_Y})\\\\s+(?:${CTR}|${AXIS_X})`,\n  `(?:${CTR}|${AXIS_X}|${DIM_LEN_PCT})\\\\s+(?:${CTR}|${AXIS_Y}|${DIM_LEN_PCT})`,\n  `(?:${CTR}|${BLOCK})\\\\s+(?:${CTR}|${INLINE})`,\n  `(?:${CTR}|${INLINE})\\\\s+(?:${CTR}|${BLOCK})`,\n  `(?:${CTR}|${S_E})\\\\s+(?:${CTR}|${S_E})`\n].join('|');\nconst POS_4 = [\n  `(?:${AXIS_X})\\\\s+(?:${DIM_LEN_PCT})\\\\s+(?:${AXIS_Y})\\\\s+(?:${DIM_LEN_PCT})`,\n  `(?:${AXIS_Y})\\\\s+(?:${DIM_LEN_PCT})\\\\s+(?:${AXIS_X})\\\\s+(?:${DIM_LEN_PCT})`,\n  `(?:${BLOCK})\\\\s+(?:${DIM_LEN_PCT})\\\\s+(?:${INLINE})\\\\s+(?:${DIM_LEN_PCT})`,\n  `(?:${INLINE})\\\\s+(?:${DIM_LEN_PCT})\\\\s+(?:${BLOCK})\\\\s+(?:${DIM_LEN_PCT})`,\n  `(?:${S_E})\\\\s+(?:${DIM_LEN_PCT})\\\\s+(?:${S_E})\\\\s+(?:${DIM_LEN_PCT})`\n].join('|');\nconst RAD_EXTENT = '(?:clos|farth)est-(?:corner|side)';\nconst RAD_SIZE = [\n  `${RAD_EXTENT}(?:\\\\s+${RAD_EXTENT})?`,\n  `${DIM_LEN_POSI}`,\n  `(?:${DIM_LEN_PCT_POSI})\\\\s+(?:${DIM_LEN_PCT_POSI})`\n].join('|');\nconst RAD_SHAPE = 'circle|ellipse';\nconst FROM_ANGLE = `from\\\\s+${DIM_ANGLE}`;\nconst AT_POSITION = `at\\\\s+(?:${POS_1}|${POS_2}|${POS_4})`;\nconst TO_SIDE_CORNER = `to\\\\s+(?:(?:${L_R})(?:\\\\s(?:${T_B}))?|(?:${T_B})(?:\\\\s(?:${L_R}))?)`;\nconst IN_COLOR_SPACE = `in\\\\s+(?:${CS_RECT}|${CS_HUE})`;\nconst LINE_SYNTAX_LINEAR = [\n  `(?:${DIM_ANGLE}|${TO_SIDE_CORNER})(?:\\\\s+${IN_COLOR_SPACE})?`,\n  `${IN_COLOR_SPACE}(?:\\\\s+(?:${DIM_ANGLE}|${TO_SIDE_CORNER}))?`\n].join('|');\nconst LINE_SYNTAX_RADIAL = [\n  `(?:${RAD_SHAPE})(?:\\\\s+(?:${RAD_SIZE}))?(?:\\\\s+${AT_POSITION})?(?:\\\\s+${IN_COLOR_SPACE})?`,\n  `(?:${RAD_SIZE})(?:\\\\s+(?:${RAD_SHAPE}))?(?:\\\\s+${AT_POSITION})?(?:\\\\s+${IN_COLOR_SPACE})?`,\n  `${AT_POSITION}(?:\\\\s+${IN_COLOR_SPACE})?`,\n  `${IN_COLOR_SPACE}(?:\\\\s+${RAD_SHAPE})(?:\\\\s+(?:${RAD_SIZE}))?(?:\\\\s+${AT_POSITION})?`,\n  `${IN_COLOR_SPACE}(?:\\\\s+${RAD_SIZE})(?:\\\\s+(?:${RAD_SHAPE}))?(?:\\\\s+${AT_POSITION})?`,\n  `${IN_COLOR_SPACE}(?:\\\\s+${AT_POSITION})?`\n].join('|');\nconst LINE_SYNTAX_CONIC = [\n  `${FROM_ANGLE}(?:\\\\s+${AT_POSITION})?(?:\\\\s+${IN_COLOR_SPACE})?`,\n  `${AT_POSITION}(?:\\\\s+${IN_COLOR_SPACE})?`,\n  `${IN_COLOR_SPACE}(?:\\\\s+${FROM_ANGLE})?(?:\\\\s+${AT_POSITION})?`\n].join('|');\nconst DEFAULT_LINEAR = [/to\\s+bottom/];\nconst DEFAULT_RADIAL = [/ellipse/, /farthest-corner/, /at\\s+center/];\nconst DEFAULT_CONIC = [/at\\s+center/];\n\n/* type definitions */\n/**\n * @type ColorStopList - list of color stops\n */\ntype ColorStopList = [string, string, ...string[]];\n\n/**\n * @typedef ValidateGradientLine - validate gradient line\n * @property line - gradient line\n * @property valid - result\n */\ninterface ValidateGradientLine {\n  line: string;\n  valid: boolean;\n}\n\n/**\n * @typedef ValidateColorStops - validate color stops\n * @property colorStops - list of color stops\n * @property valid - result\n */\ninterface ValidateColorStops {\n  colorStops: string[];\n  valid: boolean;\n}\n\n/**\n * @typedef Gradient - parsed CSS gradient\n * @property value - input value\n * @property type - gradient type\n * @property [gradientLine] - gradient line\n * @property colorStopList - list of color stops\n */\ninterface Gradient {\n  value: string;\n  type: string;\n  gradientLine?: string;\n  colorStopList: ColorStopList;\n}\n\n/* regexp */\nconst IS_CONIC = /^(?:repeating-)?conic-gradient$/;\nconst IS_LINEAR = /^(?:repeating-)?linear-gradient$/;\nconst IS_RADIAL = /^(?:repeating-)?radial-gradient$/;\nconst REG_COLOR_HINT_CONIC = new RegExp(`^(?:${DIM_ANGLE_PCT})$`);\nconst REG_COLOR_HINT_NON_CONIC = new RegExp(`^(?:${DIM_LEN_PCT})$`);\nconst REG_DIM_CONIC = new RegExp(`(?:\\\\s+(?:${DIM_ANGLE_PCT})){1,2}$`);\nconst REG_DIM_NON_CONIC = new RegExp(`(?:\\\\s+(?:${DIM_LEN_PCT})){1,2}$`);\nconst REG_GRAD = /^(?:repeating-)?(?:conic|linear|radial)-gradient\\(/;\nconst REG_GRAD_CAPT = /^((?:repeating-)?(?:conic|linear|radial)-gradient)\\(/;\nconst REG_LINE_CONIC = new RegExp(`^(?:${LINE_SYNTAX_CONIC})$`);\nconst REG_LINE_LINEAR = new RegExp(`^(?:${LINE_SYNTAX_LINEAR})$`);\nconst REG_LINE_RADIAL = new RegExp(`^(?:${LINE_SYNTAX_RADIAL})$`);\n\n/**\n * get gradient type\n * @param value - gradient value\n * @returns gradient type\n */\nexport const getGradientType = (value: string): string => {\n  if (isString(value)) {\n    value = value.trim();\n    if (REG_GRAD.test(value)) {\n      const [, type] = value.match(REG_GRAD_CAPT) as MatchedRegExp;\n      return type;\n    }\n  }\n  return '';\n};\n\n/**\n * validate gradient line\n * @param value - gradient line value\n * @param type - gradient type\n * @returns result\n */\nexport const validateGradientLine = (\n  value: string,\n  type: string\n): ValidateGradientLine => {\n  if (isString(value) && isString(type)) {\n    value = value.trim();\n    type = type.trim();\n    let reg: RegExp | null = null;\n    let defaultValues: RegExp[] = [];\n\n    if (IS_LINEAR.test(type)) {\n      reg = REG_LINE_LINEAR;\n      defaultValues = DEFAULT_LINEAR;\n    } else if (IS_RADIAL.test(type)) {\n      reg = REG_LINE_RADIAL;\n      defaultValues = DEFAULT_RADIAL;\n    } else if (IS_CONIC.test(type)) {\n      reg = REG_LINE_CONIC;\n      defaultValues = DEFAULT_CONIC;\n    }\n    if (reg) {\n      const valid = reg.test(value);\n      if (valid) {\n        let line = value;\n        for (const defaultValue of defaultValues) {\n          line = line.replace(defaultValue, '');\n        }\n        line = line.replace(/\\s{2,}/g, ' ').trim();\n        return { line, valid };\n      }\n      return { valid, line: value };\n    }\n  }\n  return { line: value, valid: false };\n};\n\n/**\n * validate color stop list\n * @param list\n * @param type\n * @param [opt]\n * @returns result\n */\nexport const validateColorStopList = (\n  list: string[],\n  type: string,\n  opt: Options = {}\n): ValidateColorStops => {\n  if (Array.isArray(list) && list.length > 1) {\n    const isConic = IS_CONIC.test(type);\n    const regColorHint = isConic\n      ? REG_COLOR_HINT_CONIC\n      : REG_COLOR_HINT_NON_CONIC;\n    const regDimension = isConic ? REG_DIM_CONIC : REG_DIM_NON_CONIC;\n    const valueList: string[] = [];\n    // State tracker: 'color' or 'hint'\n    let prevType = '';\n    for (let i = 0; i < list.length; i++) {\n      const item = list[i];\n      if (isString(item)) {\n        if (regColorHint.test(item)) {\n          // Hints cannot be the first item, and two hints cannot be adjacent\n          if (i === 0 || prevType === 'hint') {\n            return { colorStops: list, valid: false };\n          }\n          prevType = 'hint';\n          valueList.push(item);\n        } else {\n          const itemColor = item.replace(regDimension, '');\n          if (isColor(itemColor, { format: VAL_SPEC })) {\n            const resolvedColor = resolveColor(itemColor, opt) as string;\n            prevType = 'color';\n            valueList.push(item.replace(itemColor, resolvedColor));\n          } else {\n            return { colorStops: list, valid: false };\n          }\n        }\n      } else {\n        return { colorStops: list, valid: false };\n      }\n    }\n    // The last item must be a color, not a hint\n    if (prevType !== 'color') {\n      return { colorStops: list, valid: false };\n    }\n    return { valid: true, colorStops: valueList };\n  }\n  return { colorStops: list, valid: false };\n};\n\n/**\n * parse CSS gradient\n * @param value - gradient value\n * @param [opt] - options\n * @returns parsed result\n */\nexport const parseGradient = (\n  value: string,\n  opt: Options = {}\n): Gradient | null => {\n  if (isString(value)) {\n    value = value.trim();\n    const cacheKey: string = createCacheKey(\n      {\n        namespace: NAMESPACE,\n        name: 'parseGradient',\n        value\n      },\n      opt\n    );\n    const cachedResult = getCache(cacheKey);\n    if (cachedResult instanceof CacheItem) {\n      if (cachedResult.isNull) {\n        return null;\n      }\n      return cachedResult.item as Gradient;\n    }\n    const type = getGradientType(value);\n    const gradValue = value.replace(REG_GRAD, '').replace(/\\)$/, '');\n    if (type && gradValue) {\n      const [lineOrColorStop = '', ...itemList] = splitValue(gradValue, {\n        delimiter: ','\n      });\n      const isConic = IS_CONIC.test(type);\n      const regDimension = isConic ? REG_DIM_CONIC : REG_DIM_NON_CONIC;\n      let colorStop = '';\n      if (regDimension.test(lineOrColorStop)) {\n        const itemColor = lineOrColorStop.replace(regDimension, '');\n        if (isColor(itemColor, { format: VAL_SPEC })) {\n          const resolvedColor = resolveColor(itemColor, opt) as string;\n          colorStop = lineOrColorStop.replace(itemColor, resolvedColor);\n        }\n      } else if (isColor(lineOrColorStop, { format: VAL_SPEC })) {\n        colorStop = resolveColor(lineOrColorStop, opt) as string;\n      }\n      if (colorStop) {\n        itemList.unshift(colorStop);\n        const { colorStops, valid } = validateColorStopList(\n          itemList,\n          type,\n          opt\n        );\n        if (valid) {\n          const res: Gradient = {\n            value,\n            type,\n            colorStopList: colorStops as ColorStopList\n          };\n          setCache(cacheKey, res);\n          return res;\n        }\n      } else if (itemList.length > 1) {\n        const { line: gradientLine, valid: validLine } = validateGradientLine(\n          lineOrColorStop,\n          type\n        );\n        const { colorStops, valid: validColorStops } = validateColorStopList(\n          itemList,\n          type,\n          opt\n        );\n        if (validLine && validColorStops) {\n          const res: Gradient = {\n            value,\n            type,\n            gradientLine,\n            colorStopList: colorStops as ColorStopList\n          };\n          setCache(cacheKey, res);\n          return res;\n        }\n      }\n    }\n    setCache(cacheKey, null);\n    return null;\n  }\n  return null;\n};\n\n/**\n * resolve CSS gradient\n * @param value - CSS value\n * @param [opt] - options\n * @returns result\n */\nexport const resolveGradient = (value: string, opt: Options = {}): string => {\n  const { format = VAL_COMP } = opt;\n  const gradient = parseGradient(value, opt);\n  if (gradient) {\n    const { type = '', gradientLine = '', colorStopList = [] } = gradient;\n    if (type && Array.isArray(colorStopList) && colorStopList.length > 1) {\n      if (gradientLine) {\n        return `${type}(${gradientLine}, ${colorStopList.join(', ')})`;\n      }\n      return `${type}(${colorStopList.join(', ')})`;\n    }\n  }\n  if (format === VAL_SPEC) {\n    return '';\n  }\n  return 'none';\n};\n\n/**\n * is CSS gradient\n * @param value - CSS value\n * @param [opt] - options\n * @returns result\n */\nexport const isGradient = (value: string, opt: Options = {}): boolean => {\n  const gradient = parseGradient(value, opt);\n  return gradient !== null;\n};\n"],"mappings":"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"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/css-var.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-var.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..90723536e9c857a0b9e8da27653a91a3730b839f
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-var.d.ts
@@ -0,0 +1,31 @@
+import { CSSToken } from '@csstools/css-tokenizer';
+import { NullObject } from './cache.js';
+import { Options } from './typedef.js';
+/**
+ * resolve custom property
+ * @param tokens - CSS tokens
+ * @param [opt] - options
+ * @returns result - [tokens, resolvedValue]
+ */
+export declare function resolveCustomProperty(tokens: CSSToken[], opt?: Options): [CSSToken[], string];
+/**
+ * parse tokens
+ * @param tokens - CSS tokens
+ * @param [opt] - options
+ * @returns parsed tokens
+ */
+export declare function parseTokens(tokens: CSSToken[], opt?: Options): string[] | NullObject;
+/**
+ * resolve CSS var()
+ * @param value - CSS value including var()
+ * @param [opt] - options
+ * @returns resolved value
+ */
+export declare function resolveVar(value: string, opt?: Options): string | NullObject;
+/**
+ * CSS var()
+ * @param value - CSS value including var()
+ * @param [opt] - options
+ * @returns resolved value
+ */
+export declare const cssVar: (value: string, opt?: Options) => string;
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/css-var.js b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-var.js
new file mode 100644
index 0000000000000000000000000000000000000000..b61c9f9918314f011c4add1b8ef2a2e448611899
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-var.js
@@ -0,0 +1,144 @@
+import { CacheItem, NullObject, createCacheKey, getCache, setCache } from "./cache.js";
+import { isString } from "./common.js";
+import { SYN_FN_CALC, SYN_FN_VAR } from "./constant.js";
+import { isColor } from "./util.js";
+import { cssCalc } from "./css-calc.js";
+import { TokenType, tokenize } from "@csstools/css-tokenizer";
+//#region src/js/css-var.ts
+/**
+* css-var
+*/
+var { CloseParen: PAREN_CLOSE, Comment: COMMENT, EOF, Ident: IDENT, Whitespace: W_SPACE } = TokenType;
+var NAMESPACE = "css-var";
+var REG_FN_CALC = new RegExp(SYN_FN_CALC);
+var REG_FN_VAR = new RegExp(SYN_FN_VAR);
+var REG_CSS_WIDE_KEYWORD = /^(?:inherit|initial|revert(?:-layer)?|unset)$/;
+/**
+* resolve custom property
+* @param tokens - CSS tokens
+* @param [opt] - options
+* @returns result - [tokens, resolvedValue]
+*/
+function resolveCustomProperty(tokens, opt = {}) {
+	if (!Array.isArray(tokens)) throw new TypeError(`${tokens} is not an array.`);
+	const { customProperty = {} } = opt;
+	const items = [];
+	while (tokens.length) {
+		const token = tokens.shift();
+		if (!token) break;
+		if (!Array.isArray(token)) throw new TypeError(`${token} is not an array.`);
+		const [type, value] = token;
+		if (type === PAREN_CLOSE) break;
+		if (value === "var(") {
+			const [, item] = resolveCustomProperty(tokens, opt);
+			if (item) items.push(item);
+		} else if (type === IDENT) {
+			if (value.startsWith("--")) {
+				let item;
+				if (Object.hasOwn(customProperty, value)) item = customProperty[value];
+				else if (typeof customProperty.callback === "function") item = customProperty.callback(value);
+				if (item) items.push(item);
+			} else if (value) items.push(value);
+		}
+	}
+	let resolveAsColor = false;
+	if (items.length > 1) resolveAsColor = isColor(items[items.length - 1]);
+	let resolvedValue = "";
+	for (let item of items) {
+		item = item.trim();
+		if (REG_FN_VAR.test(item)) {
+			const resolvedItem = resolveVar(item, opt);
+			if (isString(resolvedItem)) {
+				if (!resolveAsColor || isColor(resolvedItem)) resolvedValue = resolvedItem;
+			}
+		} else if (REG_FN_CALC.test(item)) {
+			item = cssCalc(item, opt);
+			if (!resolveAsColor || isColor(item)) resolvedValue = item;
+		} else if (item && !REG_CSS_WIDE_KEYWORD.test(item)) {
+			if (!resolveAsColor || isColor(item)) resolvedValue = item;
+		}
+		if (resolvedValue) break;
+	}
+	return [tokens, resolvedValue];
+}
+/**
+* parse tokens
+* @param tokens - CSS tokens
+* @param [opt] - options
+* @returns parsed tokens
+*/
+function parseTokens(tokens, opt = {}) {
+	const res = [];
+	while (tokens.length) {
+		const token = tokens.shift();
+		if (!token) break;
+		const [type = "", value = ""] = token;
+		if (value === "var(") {
+			const [, resolvedValue] = resolveCustomProperty(tokens, opt);
+			if (!resolvedValue) return new NullObject();
+			res.push(resolvedValue);
+		} else switch (type) {
+			case PAREN_CLOSE:
+				if (res.length) if (res[res.length - 1] === " ") res[res.length - 1] = value;
+				else res.push(value);
+				else res.push(value);
+				break;
+			case W_SPACE:
+				if (res.length) {
+					const lastValue = res[res.length - 1];
+					if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") res.push(value);
+				}
+				break;
+			default: if (type !== COMMENT && type !== EOF) res.push(value);
+		}
+	}
+	return res;
+}
+/**
+* resolve CSS var()
+* @param value - CSS value including var()
+* @param [opt] - options
+* @returns resolved value
+*/
+function resolveVar(value, opt = {}) {
+	const { format = "" } = opt;
+	if (isString(value)) {
+		if (!REG_FN_VAR.test(value) || format === "specifiedValue") return value;
+		value = value.trim();
+	} else throw new TypeError(`${value} is not a string.`);
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "resolveVar",
+		value
+	}, opt);
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) {
+		if (cachedResult.isNull) return cachedResult;
+		return cachedResult.item;
+	}
+	const values = parseTokens(tokenize({ css: value }), opt);
+	if (Array.isArray(values)) {
+		let color = values.join("");
+		if (REG_FN_CALC.test(color)) color = cssCalc(color, opt);
+		setCache(cacheKey, color);
+		return color;
+	} else {
+		setCache(cacheKey, null);
+		return new NullObject();
+	}
+}
+/**
+* CSS var()
+* @param value - CSS value including var()
+* @param [opt] - options
+* @returns resolved value
+*/
+var cssVar = (value, opt = {}) => {
+	const resolvedValue = resolveVar(value, opt);
+	if (isString(resolvedValue)) return resolvedValue;
+	return "";
+};
+//#endregion
+export { cssVar, resolveVar };
+
+//# sourceMappingURL=css-var.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/css-var.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-var.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..c03de04ac4feb4ec510c4e4f790f3ac48f309d62
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/css-var.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"css-var.js","names":[],"sources":["../../../src/js/css-var.ts"],"sourcesContent":["/**\n * css-var\n */\n\nimport { CSSToken, TokenType, tokenize } from '@csstools/css-tokenizer';\nimport {\n  CacheItem,\n  NullObject,\n  createCacheKey,\n  getCache,\n  setCache\n} from './cache';\nimport { isString } from './common';\nimport { cssCalc } from './css-calc';\nimport { isColor } from './util';\nimport { Options } from './typedef';\n\n/* constants */\nimport { FN_VAR, SYN_FN_CALC, SYN_FN_VAR, VAL_SPEC } from './constant';\nconst {\n  CloseParen: PAREN_CLOSE,\n  Comment: COMMENT,\n  EOF,\n  Ident: IDENT,\n  Whitespace: W_SPACE\n} = TokenType;\nconst NAMESPACE = 'css-var';\n\n/* regexp */\nconst REG_FN_CALC = new RegExp(SYN_FN_CALC);\nconst REG_FN_VAR = new RegExp(SYN_FN_VAR);\nconst REG_CSS_WIDE_KEYWORD = /^(?:inherit|initial|revert(?:-layer)?|unset)$/;\n\n/**\n * resolve custom property\n * @param tokens - CSS tokens\n * @param [opt] - options\n * @returns result - [tokens, resolvedValue]\n */\nexport function resolveCustomProperty(\n  tokens: CSSToken[],\n  opt: Options = {}\n): [CSSToken[], string] {\n  if (!Array.isArray(tokens)) {\n    throw new TypeError(`${tokens} is not an array.`);\n  }\n  const { customProperty = {} } = opt;\n  const items: string[] = [];\n  while (tokens.length) {\n    const token = tokens.shift();\n    if (!token) {\n      break;\n    }\n    if (!Array.isArray(token)) {\n      throw new TypeError(`${token} is not an array.`);\n    }\n    const [type, value] = token as [TokenType, string];\n    // end of var()\n    if (type === PAREN_CLOSE) {\n      break;\n    }\n    // nested var()\n    if (value === FN_VAR) {\n      const [, item] = resolveCustomProperty(tokens, opt);\n      if (item) {\n        items.push(item);\n      }\n    } else if (type === IDENT) {\n      if (value.startsWith('--')) {\n        let item;\n        if (Object.hasOwn(customProperty, value)) {\n          item = customProperty[value] as string;\n        } else if (typeof customProperty.callback === 'function') {\n          item = customProperty.callback(value);\n        }\n        if (item) {\n          items.push(item);\n        }\n      } else if (value) {\n        items.push(value);\n      }\n    }\n  }\n  let resolveAsColor = false;\n  if (items.length > 1) {\n    resolveAsColor = isColor(items[items.length - 1]);\n  }\n  let resolvedValue = '';\n  for (let item of items) {\n    item = item.trim();\n    if (REG_FN_VAR.test(item)) {\n      // recurse resolveVar()\n      const resolvedItem = resolveVar(item, opt);\n      if (isString(resolvedItem)) {\n        if (!resolveAsColor || isColor(resolvedItem)) {\n          resolvedValue = resolvedItem;\n        }\n      }\n    } else if (REG_FN_CALC.test(item)) {\n      item = cssCalc(item, opt);\n      if (!resolveAsColor || isColor(item)) {\n        resolvedValue = item;\n      }\n    } else if (item && !REG_CSS_WIDE_KEYWORD.test(item)) {\n      if (!resolveAsColor || isColor(item)) {\n        resolvedValue = item;\n      }\n    }\n    if (resolvedValue) {\n      break;\n    }\n  }\n  return [tokens, resolvedValue];\n}\n\n/**\n * parse tokens\n * @param tokens - CSS tokens\n * @param [opt] - options\n * @returns parsed tokens\n */\nexport function parseTokens(\n  tokens: CSSToken[],\n  opt: Options = {}\n): string[] | NullObject {\n  const res: string[] = [];\n  while (tokens.length) {\n    const token = tokens.shift();\n    if (!token) break;\n    const [type = '', value = ''] = token as [TokenType, string];\n    if (value === FN_VAR) {\n      const [, resolvedValue] = resolveCustomProperty(tokens, opt);\n      if (!resolvedValue) {\n        return new NullObject();\n      }\n      res.push(resolvedValue);\n    } else {\n      switch (type) {\n        case PAREN_CLOSE: {\n          if (res.length) {\n            if (res[res.length - 1] === ' ') {\n              res[res.length - 1] = value;\n            } else {\n              res.push(value);\n            }\n          } else {\n            res.push(value);\n          }\n          break;\n        }\n        case W_SPACE: {\n          if (res.length) {\n            const lastValue = res[res.length - 1];\n            if (\n              isString(lastValue) &&\n              !lastValue.endsWith('(') &&\n              lastValue !== ' '\n            ) {\n              res.push(value);\n            }\n          }\n          break;\n        }\n        default: {\n          if (type !== COMMENT && type !== EOF) {\n            res.push(value);\n          }\n        }\n      }\n    }\n  }\n  return res;\n}\n\n/**\n * resolve CSS var()\n * @param value - CSS value including var()\n * @param [opt] - options\n * @returns resolved value\n */\nexport function resolveVar(\n  value: string,\n  opt: Options = {}\n): string | NullObject {\n  const { format = '' } = opt;\n  if (isString(value)) {\n    if (!REG_FN_VAR.test(value) || format === VAL_SPEC) {\n      return value;\n    }\n    value = value.trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const cacheKey: string = createCacheKey(\n    {\n      namespace: NAMESPACE,\n      name: 'resolveVar',\n      value\n    },\n    opt\n  );\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    if (cachedResult.isNull) {\n      return cachedResult as NullObject;\n    }\n    return cachedResult.item as string;\n  }\n  const tokens = tokenize({ css: value });\n  const values = parseTokens(tokens, opt);\n  if (Array.isArray(values)) {\n    let color = values.join('');\n    if (REG_FN_CALC.test(color)) {\n      color = cssCalc(color, opt);\n    }\n    setCache(cacheKey, color);\n    return color;\n  } else {\n    setCache(cacheKey, null);\n    return new NullObject();\n  }\n}\n\n/**\n * CSS var()\n * @param value - CSS value including var()\n * @param [opt] - options\n * @returns resolved value\n */\nexport const cssVar = (value: string, opt: Options = {}): string => {\n  const resolvedValue = resolveVar(value, opt);\n  if (isString(resolvedValue)) {\n    return resolvedValue;\n  }\n  return '';\n};\n"],"mappings":"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"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/relative-color.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/relative-color.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ca8a089c6a6927e80f9063715b0d5904b13b69f3
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/relative-color.d.ts
@@ -0,0 +1,65 @@
+import { CSSToken } from '@csstools/css-tokenizer';
+import { NullObject } from './cache.js';
+import { ColorChannels, Options, StringColorChannels } from './typedef.js';
+/**
+ * @type NumberOrStringColorChannels - color channel
+ */
+type NumberOrStringColorChannels = ColorChannels & StringColorChannels;
+/**
+ * resolve relative color channels
+ * @param value
+ *   - CSS color value
+ *   - system colors are not supported
+ * @param [opt] - options
+ * @param [opt.currentColor]
+ *   - color to use for `currentcolor` keyword
+ *   - if omitted, it will be treated as a missing color
+ *     i.e. `rgb(none none none / none)`
+ * @param [opt.customProperty]
+ *   - custom properties
+ *   - pair of `--` prefixed property name and value,
+ *     e.g. `customProperty: { '--some-color': '#0000ff' }`
+ *   - and/or `callback` function to get the value of the custom property,
+ *     e.g. `customProperty: { callback: someDeclaration.getPropertyValue }`
+ * @param [opt.dimension]
+ *   - dimension, convert relative length to pixels
+ *   - pair of unit and it's value as a number in pixels,
+ *     e.g. `dimension: { em: 12, rem: 16, vw: 10.26 }`
+ *   - and/or `callback` function to get the value as a number in pixels,
+ *     e.g. `dimension: { callback: convertUnitToPixel }`
+ * @param [opt.format]
+ *   - output format, one of below
+ *   - `computedValue` (default), [computed value][139] of the color
+ *   - `specifiedValue`, [specified value][140] of the color
+ *   - `hex`, hex color notation, i.e. `rrggbb`
+ *   - `hexAlpha`, hex color notation with alpha channel, i.e. `#rrggbbaa`
+ * @returns
+ *   - one of rgba?(), #rrggbb(aa)?, color-name, '(empty-string)',
+ *     color(color-space r g b / alpha), color(color-space x y z / alpha),
+ *     lab(l a b / alpha), lch(l c h / alpha), oklab(l a b / alpha),
+ *     oklch(l c h / alpha), null
+ *   - in `computedValue`, values are numbers, however `rgb()` values are
+ *     integers
+ *   - in `specifiedValue`, returns `empty string` for unknown and/or invalid
+ *     color
+ *   - in `hex`, returns `null` for `transparent`, and also returns `null` if
+ *     any of `r`, `g`, `b`, `alpha` is not a number
+ *   - in `hexAlpha`, returns `#00000000` for `transparent`,
+ *     however returns `null` if any of `r`, `g`, `b`, `alpha` is not a number
+ */
+export declare function resolveColorChannels(tokens: CSSToken[], opt?: Options): NumberOrStringColorChannels | NullObject;
+/**
+ * extract origin color
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns origin color value
+ */
+export declare function extractOriginColor(value: string, opt?: Options): string | NullObject;
+/**
+ * resolve relative color
+ * @param value - CSS relative color value
+ * @param [opt] - options
+ * @returns resolved value
+ */
+export declare function resolveRelativeColor(value: string, opt?: Options): string | NullObject;
+export {};
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/relative-color.js b/node_modules/@asamuzakjp/css-color/dist/esm/js/relative-color.js
new file mode 100644
index 0000000000000000000000000000000000000000..68db1ec47b333ee69999e9da938bc18630e91719
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/relative-color.js
@@ -0,0 +1,451 @@
+import { CacheItem, NullObject, createCacheKey, getCache, setCache } from "./cache.js";
+import { isString, isStringOrNumber } from "./common.js";
+import { CS_LAB, CS_LCH, FN_REL, FN_REL_CAPT, FN_VAR, NONE, SYN_COLOR_TYPE, SYN_FN_MATH_START, SYN_FN_VAR, SYN_MIX, VAL_SPEC } from "./constant.js";
+import { NAMED_COLORS, convertColorToRgb } from "./color.js";
+import { resolveColor } from "./resolve.js";
+import { roundToPrecision, splitValue } from "./util.js";
+import { resolveDimension, serializeCalc } from "./css-calc.js";
+import { TokenType, tokenize } from "@csstools/css-tokenizer";
+import { SyntaxFlag, color } from "@csstools/css-color-parser";
+import { parseComponentValue } from "@csstools/css-parser-algorithms";
+//#region src/js/relative-color.ts
+/**
+* relative-color
+*/
+var { CloseParen: PAREN_CLOSE, Comment: COMMENT, Delim: DELIM, Dimension: DIM, EOF, Function: FUNC, Ident: IDENT, Number: NUM, OpenParen: PAREN_OPEN, Percentage: PCT, Whitespace: W_SPACE } = TokenType;
+var { HasNoneKeywords: KEY_NONE } = SyntaxFlag;
+var NAMESPACE = "relative-color";
+var OCT = 8;
+var DEC = 10;
+var HEX = 16;
+var MAX_PCT = 100;
+var MAX_RGB = 255;
+var COLOR_CHANNELS = new Map([
+	["color", [
+		"r",
+		"g",
+		"b",
+		"alpha"
+	]],
+	["hsl", [
+		"h",
+		"s",
+		"l",
+		"alpha"
+	]],
+	["hsla", [
+		"h",
+		"s",
+		"l",
+		"alpha"
+	]],
+	["hwb", [
+		"h",
+		"w",
+		"b",
+		"alpha"
+	]],
+	["lab", [
+		"l",
+		"a",
+		"b",
+		"alpha"
+	]],
+	["lch", [
+		"l",
+		"c",
+		"h",
+		"alpha"
+	]],
+	["oklab", [
+		"l",
+		"a",
+		"b",
+		"alpha"
+	]],
+	["oklch", [
+		"l",
+		"c",
+		"h",
+		"alpha"
+	]],
+	["rgb", [
+		"r",
+		"g",
+		"b",
+		"alpha"
+	]],
+	["rgba", [
+		"r",
+		"g",
+		"b",
+		"alpha"
+	]]
+]);
+var REG_COLOR_CAPT = new RegExp(`^${FN_REL}(${SYN_COLOR_TYPE}|${SYN_MIX})\\s+`);
+var REG_CS_HSL = /(?:hsla?|hwb)$/;
+var REG_CS_CIE = new RegExp(`^(?:${CS_LAB}|${CS_LCH})$`);
+var REG_FN_CALC_SUM = /^(?:abs|sig?n|cos|tan)\(/;
+var REG_FN_MATH_START = new RegExp(SYN_FN_MATH_START);
+var REG_FN_REL = new RegExp(FN_REL);
+var REG_FN_REL_CAPT = new RegExp(`^${FN_REL_CAPT}`);
+var REG_FN_REL_START = new RegExp(`^${FN_REL}`);
+var REG_FN_VAR = new RegExp(SYN_FN_VAR);
+/**
+* resolve relative color channels
+* @param value
+*   - CSS color value
+*   - system colors are not supported
+* @param [opt] - options
+* @param [opt.currentColor]
+*   - color to use for `currentcolor` keyword
+*   - if omitted, it will be treated as a missing color
+*     i.e. `rgb(none none none / none)`
+* @param [opt.customProperty]
+*   - custom properties
+*   - pair of `--` prefixed property name and value,
+*     e.g. `customProperty: { '--some-color': '#0000ff' }`
+*   - and/or `callback` function to get the value of the custom property,
+*     e.g. `customProperty: { callback: someDeclaration.getPropertyValue }`
+* @param [opt.dimension]
+*   - dimension, convert relative length to pixels
+*   - pair of unit and it's value as a number in pixels,
+*     e.g. `dimension: { em: 12, rem: 16, vw: 10.26 }`
+*   - and/or `callback` function to get the value as a number in pixels,
+*     e.g. `dimension: { callback: convertUnitToPixel }`
+* @param [opt.format]
+*   - output format, one of below
+*   - `computedValue` (default), [computed value][139] of the color
+*   - `specifiedValue`, [specified value][140] of the color
+*   - `hex`, hex color notation, i.e. `rrggbb`
+*   - `hexAlpha`, hex color notation with alpha channel, i.e. `#rrggbbaa`
+* @returns
+*   - one of rgba?(), #rrggbb(aa)?, color-name, '(empty-string)',
+*     color(color-space r g b / alpha), color(color-space x y z / alpha),
+*     lab(l a b / alpha), lch(l c h / alpha), oklab(l a b / alpha),
+*     oklch(l c h / alpha), null
+*   - in `computedValue`, values are numbers, however `rgb()` values are
+*     integers
+*   - in `specifiedValue`, returns `empty string` for unknown and/or invalid
+*     color
+*   - in `hex`, returns `null` for `transparent`, and also returns `null` if
+*     any of `r`, `g`, `b`, `alpha` is not a number
+*   - in `hexAlpha`, returns `#00000000` for `transparent`,
+*     however returns `null` if any of `r`, `g`, `b`, `alpha` is not a number
+*/
+function resolveColorChannels(tokens, opt = {}) {
+	if (!Array.isArray(tokens)) throw new TypeError(`${tokens} is not an array.`);
+	const { colorSpace = "", format = "" } = opt;
+	const colorChannel = COLOR_CHANNELS.get(colorSpace);
+	if (!colorChannel) return new NullObject();
+	const mathFunc = /* @__PURE__ */ new Set();
+	const channels = [
+		[],
+		[],
+		[],
+		[]
+	];
+	let i = 0;
+	let nest = 0;
+	let func = "";
+	let precededPct = false;
+	for (const token of tokens) {
+		if (!Array.isArray(token)) throw new TypeError(`${token} is not an array.`);
+		const [type, value, , , detail] = token;
+		const channel = channels[i];
+		if (Array.isArray(channel)) switch (type) {
+			case DELIM:
+				if (func) {
+					if ((value === "+" || value === "-") && precededPct && !REG_FN_CALC_SUM.test(func)) return new NullObject();
+					precededPct = false;
+					channel.push(value);
+				}
+				break;
+			case DIM: {
+				if (!func || !REG_FN_CALC_SUM.test(func)) return new NullObject();
+				const resolvedValue = resolveDimension(token, opt);
+				if (isString(resolvedValue)) channel.push(resolvedValue);
+				else channel.push(value);
+				break;
+			}
+			case FUNC:
+				channel.push(value);
+				func = value;
+				nest++;
+				if (REG_FN_MATH_START.test(value)) mathFunc.add(nest);
+				break;
+			case IDENT:
+				if (!colorChannel.includes(value)) return new NullObject();
+				channel.push(value);
+				if (!func) i++;
+				break;
+			case NUM:
+				channel.push(Number(detail?.value));
+				if (!func) i++;
+				break;
+			case PAREN_OPEN:
+				channel.push(value);
+				nest++;
+				break;
+			case PAREN_CLOSE:
+				if (func) {
+					if (channel[channel.length - 1] === " ") channel[channel.length - 1] = value;
+					else channel.push(value);
+					if (mathFunc.has(nest)) mathFunc.delete(nest);
+					nest--;
+					if (nest === 0) {
+						func = "";
+						i++;
+					}
+				}
+				break;
+			case PCT:
+				if (!func) return new NullObject();
+				else if (!REG_FN_CALC_SUM.test(func)) {
+					let lastValue;
+					for (let j = channel.length - 1; j >= 0; j--) if (channel[j] !== " ") {
+						lastValue = channel[j];
+						break;
+					}
+					if (lastValue === "+" || lastValue === "-") return new NullObject();
+					else if (lastValue === "*" || lastValue === "/") precededPct = false;
+					else precededPct = true;
+				}
+				channel.push(Number(detail?.value) / MAX_PCT);
+				break;
+			case W_SPACE:
+				if (channel.length && func) {
+					const lastValue = channel[channel.length - 1];
+					if (typeof lastValue === "number") channel.push(value);
+					else if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") channel.push(value);
+				}
+				break;
+			default: if (type !== COMMENT && type !== EOF && func) channel.push(value);
+		}
+	}
+	const channelValues = [];
+	for (const channel of channels) if (channel.length === 1) {
+		const [resolvedValue] = channel;
+		if (isStringOrNumber(resolvedValue)) channelValues.push(resolvedValue);
+	} else if (channel.length) {
+		const resolvedValue = serializeCalc(channel.join(""), { format });
+		channelValues.push(resolvedValue);
+	}
+	return channelValues;
+}
+/**
+* extract origin color
+* @param value - CSS color value
+* @param [opt] - options
+* @returns origin color value
+*/
+function extractOriginColor(value, opt = {}) {
+	const { colorScheme = "normal", currentColor = "", format = "" } = opt;
+	if (isString(value)) {
+		value = value.toLowerCase().trim();
+		if (!value) return new NullObject();
+		if (!REG_FN_REL_START.test(value)) return value;
+	} else return new NullObject();
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "extractOriginColor",
+		value
+	}, opt);
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) {
+		if (cachedResult.isNull) return cachedResult;
+		return cachedResult.item;
+	}
+	if (/currentcolor/.test(value)) if (currentColor) value = value.replace(/currentcolor/g, currentColor);
+	else {
+		setCache(cacheKey, null);
+		return new NullObject();
+	}
+	let colorSpace = "";
+	if (REG_FN_REL_CAPT.test(value)) [, colorSpace] = value.match(REG_FN_REL_CAPT);
+	opt.colorSpace = colorSpace;
+	if (value.includes("light-dark(")) {
+		const [, originColor = ""] = splitValue(value.replace(new RegExp(`^${colorSpace}\\(`), "").replace(/\)$/, ""));
+		const specifiedOriginColor = resolveColor(originColor, {
+			colorScheme,
+			format: VAL_SPEC
+		});
+		if (specifiedOriginColor === "") {
+			setCache(cacheKey, null);
+			return new NullObject();
+		}
+		if (format === "specifiedValue") value = value.replace(originColor, specifiedOriginColor);
+		else {
+			const resolvedOriginColor = resolveColor(specifiedOriginColor, opt);
+			if (isString(resolvedOriginColor)) value = value.replace(originColor, resolvedOriginColor);
+		}
+	}
+	if (REG_COLOR_CAPT.test(value)) {
+		const [, originColor] = value.match(REG_COLOR_CAPT);
+		const [, restValue] = value.split(originColor);
+		if (/^[a-z]+$/.test(originColor)) {
+			if (!/^transparent$/.test(originColor) && !Object.hasOwn(NAMED_COLORS, originColor)) {
+				setCache(cacheKey, null);
+				return new NullObject();
+			}
+		} else if (format === "specifiedValue") {
+			const resolvedOriginColor = resolveColor(originColor, opt);
+			if (isString(resolvedOriginColor)) value = value.replace(originColor, resolvedOriginColor);
+		}
+		if (format === "specifiedValue") {
+			const channelValues = resolveColorChannels(tokenize({ css: restValue }), opt);
+			if (channelValues instanceof NullObject) {
+				setCache(cacheKey, null);
+				return channelValues;
+			}
+			const [v1, v2, v3, v4] = channelValues;
+			let channelValue = "";
+			if (isStringOrNumber(v4)) channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;
+			else channelValue = ` ${channelValues.join(" ")})`;
+			if (restValue !== channelValue) value = value.replace(restValue, channelValue);
+		}
+	} else {
+		const [, restValue] = value.split(REG_FN_REL_START);
+		const tokens = tokenize({ css: restValue });
+		const originColor = [];
+		let nest = 0;
+		let tokenIndex = 0;
+		for (const [type, tokenValue] of tokens) {
+			tokenIndex++;
+			switch (type) {
+				case FUNC:
+				case PAREN_OPEN:
+					originColor.push(tokenValue);
+					nest++;
+					break;
+				case PAREN_CLOSE: {
+					const lastValue = originColor[originColor.length - 1];
+					if (lastValue === " ") originColor[originColor.length - 1] = tokenValue;
+					else if (isString(lastValue)) originColor.push(tokenValue);
+					nest--;
+					break;
+				}
+				case W_SPACE: {
+					const lastValue = originColor[originColor.length - 1];
+					if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") originColor.push(tokenValue);
+					break;
+				}
+				default: if (type !== COMMENT && type !== EOF) originColor.push(tokenValue);
+			}
+			if (nest === 0) break;
+		}
+		const resolvedOriginColor = resolveRelativeColor(originColor.join("").trim(), opt);
+		if (resolvedOriginColor instanceof NullObject) {
+			setCache(cacheKey, null);
+			return resolvedOriginColor;
+		}
+		const channelValues = resolveColorChannels(tokens.slice(tokenIndex), opt);
+		if (channelValues instanceof NullObject) {
+			setCache(cacheKey, null);
+			return channelValues;
+		}
+		const [v1, v2, v3, v4] = channelValues;
+		let channelValue = "";
+		if (isStringOrNumber(v4)) channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;
+		else channelValue = ` ${channelValues.join(" ")})`;
+		value = value.replace(restValue, `${resolvedOriginColor}${channelValue}`);
+	}
+	setCache(cacheKey, value);
+	return value;
+}
+/**
+* resolve relative color
+* @param value - CSS relative color value
+* @param [opt] - options
+* @returns resolved value
+*/
+function resolveRelativeColor(value, opt = {}) {
+	const { format = "" } = opt;
+	if (isString(value)) {
+		if (REG_FN_VAR.test(value)) {
+			if (format !== "specifiedValue") throw new SyntaxError(`Unexpected token ${FN_VAR} found.`);
+			return value;
+		} else if (!REG_FN_REL.test(value)) return value;
+		value = value.toLowerCase().trim();
+	} else throw new TypeError(`${value} is not a string.`);
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "resolveRelativeColor",
+		value
+	}, opt);
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) {
+		if (cachedResult.isNull) return cachedResult;
+		return cachedResult.item;
+	}
+	const originColor = extractOriginColor(value, opt);
+	if (originColor instanceof NullObject) {
+		setCache(cacheKey, null);
+		return originColor;
+	}
+	value = originColor;
+	if (format === "specifiedValue") {
+		if (value.startsWith("rgba(")) value = value.replace("rgba(", "rgb(");
+		else if (value.startsWith("hsla(")) value = value.replace("hsla(", "hsl(");
+		return value;
+	}
+	const parsedComponents = color(parseComponentValue(tokenize({ css: value })));
+	if (!parsedComponents) {
+		setCache(cacheKey, null);
+		return new NullObject();
+	}
+	const { alpha: alphaComponent, channels: channelsComponent, colorNotation, syntaxFlags } = parsedComponents;
+	let alpha;
+	if (Number.isNaN(Number(alphaComponent))) if (syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE)) alpha = NONE;
+	else alpha = 0;
+	else alpha = roundToPrecision(Number(alphaComponent), OCT);
+	let v1;
+	let v2;
+	let v3;
+	[v1, v2, v3] = channelsComponent;
+	let resolvedValue;
+	if (REG_CS_CIE.test(colorNotation)) {
+		const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);
+		if (Number.isNaN(v1)) if (hasNone) v1 = NONE;
+		else v1 = 0;
+		else v1 = roundToPrecision(v1, HEX);
+		if (Number.isNaN(v2)) if (hasNone) v2 = NONE;
+		else v2 = 0;
+		else v2 = roundToPrecision(v2, HEX);
+		if (Number.isNaN(v3)) if (hasNone) v3 = NONE;
+		else v3 = 0;
+		else v3 = roundToPrecision(v3, HEX);
+		if (alpha === 1) resolvedValue = `${colorNotation}(${v1} ${v2} ${v3})`;
+		else resolvedValue = `${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`;
+	} else if (REG_CS_HSL.test(colorNotation)) {
+		if (Number.isNaN(v1)) v1 = 0;
+		if (Number.isNaN(v2)) v2 = 0;
+		if (Number.isNaN(v3)) v3 = 0;
+		let [r, g, b] = convertColorToRgb(`${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`);
+		r = roundToPrecision(r / MAX_RGB, DEC);
+		g = roundToPrecision(g / MAX_RGB, DEC);
+		b = roundToPrecision(b / MAX_RGB, DEC);
+		if (alpha === 1) resolvedValue = `color(srgb ${r} ${g} ${b})`;
+		else resolvedValue = `color(srgb ${r} ${g} ${b} / ${alpha})`;
+	} else {
+		const cs = colorNotation === "rgb" ? "srgb" : colorNotation;
+		const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);
+		if (Number.isNaN(v1)) if (hasNone) v1 = NONE;
+		else v1 = 0;
+		else v1 = roundToPrecision(v1, DEC);
+		if (Number.isNaN(v2)) if (hasNone) v2 = NONE;
+		else v2 = 0;
+		else v2 = roundToPrecision(v2, DEC);
+		if (Number.isNaN(v3)) if (hasNone) v3 = NONE;
+		else v3 = 0;
+		else v3 = roundToPrecision(v3, DEC);
+		if (alpha === 1) resolvedValue = `color(${cs} ${v1} ${v2} ${v3})`;
+		else resolvedValue = `color(${cs} ${v1} ${v2} ${v3} / ${alpha})`;
+	}
+	setCache(cacheKey, resolvedValue);
+	return resolvedValue;
+}
+//#endregion
+export { resolveRelativeColor };
+
+//# sourceMappingURL=relative-color.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/relative-color.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/js/relative-color.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..e838fdf7e0a2d202c395cb6b0a1cacc92707f398
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/relative-color.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"relative-color.js","names":[],"sources":["../../../src/js/relative-color.ts"],"sourcesContent":["/**\n * relative-color\n */\n\nimport { SyntaxFlag, color as colorParser } from '@csstools/css-color-parser';\nimport {\n  ComponentValue,\n  parseComponentValue\n} from '@csstools/css-parser-algorithms';\nimport { CSSToken, TokenType, tokenize } from '@csstools/css-tokenizer';\nimport {\n  CacheItem,\n  NullObject,\n  createCacheKey,\n  getCache,\n  setCache\n} from './cache';\nimport { NAMED_COLORS, convertColorToRgb } from './color';\nimport { isString, isStringOrNumber } from './common';\nimport { resolveDimension, serializeCalc } from './css-calc';\nimport { resolveColor } from './resolve';\nimport { roundToPrecision, splitValue } from './util';\nimport {\n  ColorChannels,\n  MatchedRegExp,\n  Options,\n  StringColorChannels\n} from './typedef';\n\n/* constants */\nimport {\n  CS_LAB,\n  CS_LCH,\n  FN_LIGHT_DARK,\n  FN_REL,\n  FN_REL_CAPT,\n  FN_VAR,\n  NONE,\n  SYN_COLOR_TYPE,\n  SYN_FN_MATH_START,\n  SYN_FN_VAR,\n  SYN_MIX,\n  VAL_SPEC\n} from './constant';\nconst {\n  CloseParen: PAREN_CLOSE,\n  Comment: COMMENT,\n  Delim: DELIM,\n  Dimension: DIM,\n  EOF,\n  Function: FUNC,\n  Ident: IDENT,\n  Number: NUM,\n  OpenParen: PAREN_OPEN,\n  Percentage: PCT,\n  Whitespace: W_SPACE\n} = TokenType;\nconst { HasNoneKeywords: KEY_NONE } = SyntaxFlag;\nconst NAMESPACE = 'relative-color';\n\n/* constants */\nconst OCT = 8;\nconst DEC = 10;\nconst HEX = 16;\nconst MAX_PCT = 100;\nconst MAX_RGB = 255;\nconst COLOR_CHANNELS = new Map([\n  ['color', ['r', 'g', 'b', 'alpha']],\n  ['hsl', ['h', 's', 'l', 'alpha']],\n  ['hsla', ['h', 's', 'l', 'alpha']],\n  ['hwb', ['h', 'w', 'b', 'alpha']],\n  ['lab', ['l', 'a', 'b', 'alpha']],\n  ['lch', ['l', 'c', 'h', 'alpha']],\n  ['oklab', ['l', 'a', 'b', 'alpha']],\n  ['oklch', ['l', 'c', 'h', 'alpha']],\n  ['rgb', ['r', 'g', 'b', 'alpha']],\n  ['rgba', ['r', 'g', 'b', 'alpha']]\n]);\n\n/* type definitions */\n/**\n * @type NumberOrStringColorChannels - color channel\n */\ntype NumberOrStringColorChannels = ColorChannels & StringColorChannels;\n\n/* regexp */\nconst REG_COLOR_CAPT = new RegExp(\n  `^${FN_REL}(${SYN_COLOR_TYPE}|${SYN_MIX})\\\\s+`\n);\nconst REG_CS_HSL = /(?:hsla?|hwb)$/;\nconst REG_CS_CIE = new RegExp(`^(?:${CS_LAB}|${CS_LCH})$`);\nconst REG_FN_CALC_SUM = /^(?:abs|sig?n|cos|tan)\\(/;\nconst REG_FN_MATH_START = new RegExp(SYN_FN_MATH_START);\nconst REG_FN_REL = new RegExp(FN_REL);\nconst REG_FN_REL_CAPT = new RegExp(`^${FN_REL_CAPT}`);\nconst REG_FN_REL_START = new RegExp(`^${FN_REL}`);\nconst REG_FN_VAR = new RegExp(SYN_FN_VAR);\n\n/**\n * resolve relative color channels\n * @param value\n *   - CSS color value\n *   - system colors are not supported\n * @param [opt] - options\n * @param [opt.currentColor]\n *   - color to use for `currentcolor` keyword\n *   - if omitted, it will be treated as a missing color\n *     i.e. `rgb(none none none / none)`\n * @param [opt.customProperty]\n *   - custom properties\n *   - pair of `--` prefixed property name and value,\n *     e.g. `customProperty: { '--some-color': '#0000ff' }`\n *   - and/or `callback` function to get the value of the custom property,\n *     e.g. `customProperty: { callback: someDeclaration.getPropertyValue }`\n * @param [opt.dimension]\n *   - dimension, convert relative length to pixels\n *   - pair of unit and it's value as a number in pixels,\n *     e.g. `dimension: { em: 12, rem: 16, vw: 10.26 }`\n *   - and/or `callback` function to get the value as a number in pixels,\n *     e.g. `dimension: { callback: convertUnitToPixel }`\n * @param [opt.format]\n *   - output format, one of below\n *   - `computedValue` (default), [computed value][139] of the color\n *   - `specifiedValue`, [specified value][140] of the color\n *   - `hex`, hex color notation, i.e. `rrggbb`\n *   - `hexAlpha`, hex color notation with alpha channel, i.e. `#rrggbbaa`\n * @returns\n *   - one of rgba?(), #rrggbb(aa)?, color-name, '(empty-string)',\n *     color(color-space r g b / alpha), color(color-space x y z / alpha),\n *     lab(l a b / alpha), lch(l c h / alpha), oklab(l a b / alpha),\n *     oklch(l c h / alpha), null\n *   - in `computedValue`, values are numbers, however `rgb()` values are\n *     integers\n *   - in `specifiedValue`, returns `empty string` for unknown and/or invalid\n *     color\n *   - in `hex`, returns `null` for `transparent`, and also returns `null` if\n *     any of `r`, `g`, `b`, `alpha` is not a number\n *   - in `hexAlpha`, returns `#00000000` for `transparent`,\n *     however returns `null` if any of `r`, `g`, `b`, `alpha` is not a number\n */\nexport function resolveColorChannels(\n  tokens: CSSToken[],\n  opt: Options = {}\n): NumberOrStringColorChannels | NullObject {\n  if (!Array.isArray(tokens)) {\n    throw new TypeError(`${tokens} is not an array.`);\n  }\n  const { colorSpace = '', format = '' } = opt;\n  const colorChannel = COLOR_CHANNELS.get(colorSpace);\n  // invalid color channel\n  if (!colorChannel) {\n    return new NullObject();\n  }\n  const mathFunc = new Set();\n  const channels: [\n    (number | string)[],\n    (number | string)[],\n    (number | string)[],\n    (number | string)[]\n  ] = [[], [], [], []];\n  let i = 0;\n  let nest = 0;\n  let func = '';\n  let precededPct = false;\n  for (const token of tokens) {\n    if (!Array.isArray(token)) {\n      throw new TypeError(`${token} is not an array.`);\n    }\n    const [type, value, , , detail] = token as [\n      TokenType,\n      string,\n      number,\n      number,\n      { value: string | number } | undefined\n    ];\n    const channel = channels[i];\n    if (Array.isArray(channel)) {\n      switch (type) {\n        case DELIM: {\n          if (func) {\n            if (\n              (value === '+' || value === '-') &&\n              precededPct &&\n              !REG_FN_CALC_SUM.test(func)\n            ) {\n              return new NullObject();\n            }\n            precededPct = false;\n            channel.push(value);\n          }\n          break;\n        }\n        case DIM: {\n          if (!func || !REG_FN_CALC_SUM.test(func)) {\n            return new NullObject();\n          }\n          const resolvedValue = resolveDimension(token, opt);\n          if (isString(resolvedValue)) {\n            channel.push(resolvedValue);\n          } else {\n            channel.push(value);\n          }\n          break;\n        }\n        case FUNC: {\n          channel.push(value);\n          func = value;\n          nest++;\n          if (REG_FN_MATH_START.test(value)) {\n            mathFunc.add(nest);\n          }\n          break;\n        }\n        case IDENT: {\n          // invalid channel key\n          if (!colorChannel.includes(value)) {\n            return new NullObject();\n          }\n          channel.push(value);\n          if (!func) {\n            i++;\n          }\n          break;\n        }\n        case NUM: {\n          channel.push(Number(detail?.value));\n          if (!func) {\n            i++;\n          }\n          break;\n        }\n        case PAREN_OPEN: {\n          channel.push(value);\n          nest++;\n          break;\n        }\n        case PAREN_CLOSE: {\n          if (func) {\n            const lastValue = channel[channel.length - 1];\n            if (lastValue === ' ') {\n              channel[channel.length - 1] = value;\n            } else {\n              channel.push(value);\n            }\n            if (mathFunc.has(nest)) {\n              mathFunc.delete(nest);\n            }\n            nest--;\n            if (nest === 0) {\n              func = '';\n              i++;\n            }\n          }\n          break;\n        }\n        case PCT: {\n          if (!func) {\n            return new NullObject();\n          } else if (!REG_FN_CALC_SUM.test(func)) {\n            let lastValue: string | number | undefined;\n            for (let j = channel.length - 1; j >= 0; j--) {\n              if (channel[j] !== ' ') {\n                lastValue = channel[j];\n                break;\n              }\n            }\n            if (lastValue === '+' || lastValue === '-') {\n              return new NullObject();\n            } else if (lastValue === '*' || lastValue === '/') {\n              precededPct = false;\n            } else {\n              precededPct = true;\n            }\n          }\n          channel.push(Number(detail?.value) / MAX_PCT);\n          break;\n        }\n        case W_SPACE: {\n          if (channel.length && func) {\n            const lastValue = channel[channel.length - 1];\n            if (typeof lastValue === 'number') {\n              channel.push(value);\n            } else if (\n              isString(lastValue) &&\n              !lastValue.endsWith('(') &&\n              lastValue !== ' '\n            ) {\n              channel.push(value);\n            }\n          }\n          break;\n        }\n        default: {\n          if (type !== COMMENT && type !== EOF && func) {\n            channel.push(value);\n          }\n        }\n      }\n    }\n  }\n  const channelValues = [];\n  for (const channel of channels) {\n    if (channel.length === 1) {\n      const [resolvedValue] = channel;\n      if (isStringOrNumber(resolvedValue)) {\n        channelValues.push(resolvedValue);\n      }\n    } else if (channel.length) {\n      const resolvedValue = serializeCalc(channel.join(''), {\n        format\n      });\n      channelValues.push(resolvedValue);\n    }\n  }\n  return channelValues as NumberOrStringColorChannels;\n}\n\n/**\n * extract origin color\n * @param value - CSS color value\n * @param [opt] - options\n * @returns origin color value\n */\nexport function extractOriginColor(\n  value: string,\n  opt: Options = {}\n): string | NullObject {\n  const { colorScheme = 'normal', currentColor = '', format = '' } = opt;\n  if (isString(value)) {\n    value = value.toLowerCase().trim();\n    if (!value) {\n      return new NullObject();\n    }\n    if (!REG_FN_REL_START.test(value)) {\n      return value;\n    }\n  } else {\n    return new NullObject();\n  }\n  const cacheKey: string = createCacheKey(\n    {\n      namespace: NAMESPACE,\n      name: 'extractOriginColor',\n      value\n    },\n    opt\n  );\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    if (cachedResult.isNull) {\n      return cachedResult as NullObject;\n    }\n    return cachedResult.item as string;\n  }\n  if (/currentcolor/.test(value)) {\n    if (currentColor) {\n      value = value.replace(/currentcolor/g, currentColor);\n    } else {\n      setCache(cacheKey, null);\n      return new NullObject();\n    }\n  }\n  let colorSpace = '';\n  if (REG_FN_REL_CAPT.test(value)) {\n    [, colorSpace] = value.match(REG_FN_REL_CAPT) as MatchedRegExp;\n  }\n  opt.colorSpace = colorSpace;\n  if (value.includes(FN_LIGHT_DARK)) {\n    const colorParts = value\n      .replace(new RegExp(`^${colorSpace}\\\\(`), '')\n      .replace(/\\)$/, '');\n    const [, originColor = ''] = splitValue(colorParts);\n    const specifiedOriginColor = resolveColor(originColor, {\n      colorScheme,\n      format: VAL_SPEC\n    }) as string;\n    if (specifiedOriginColor === '') {\n      setCache(cacheKey, null);\n      return new NullObject();\n    }\n    if (format === VAL_SPEC) {\n      value = value.replace(originColor, specifiedOriginColor);\n    } else {\n      const resolvedOriginColor = resolveColor(specifiedOriginColor, opt);\n      if (isString(resolvedOriginColor)) {\n        value = value.replace(originColor, resolvedOriginColor);\n      }\n    }\n  }\n  if (REG_COLOR_CAPT.test(value)) {\n    const [, originColor] = value.match(REG_COLOR_CAPT) as MatchedRegExp;\n    const [, restValue] = value.split(originColor) as MatchedRegExp;\n    if (/^[a-z]+$/.test(originColor)) {\n      if (\n        !/^transparent$/.test(originColor) &&\n        !Object.hasOwn(NAMED_COLORS, originColor)\n      ) {\n        setCache(cacheKey, null);\n        return new NullObject();\n      }\n    } else if (format === VAL_SPEC) {\n      const resolvedOriginColor = resolveColor(originColor, opt);\n      if (isString(resolvedOriginColor)) {\n        value = value.replace(originColor, resolvedOriginColor);\n      }\n    }\n    if (format === VAL_SPEC) {\n      const tokens = tokenize({ css: restValue });\n      const channelValues = resolveColorChannels(tokens, opt);\n      if (channelValues instanceof NullObject) {\n        setCache(cacheKey, null);\n        return channelValues;\n      }\n      const [v1, v2, v3, v4] = channelValues;\n      let channelValue = '';\n      if (isStringOrNumber(v4)) {\n        channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;\n      } else {\n        channelValue = ` ${channelValues.join(' ')})`;\n      }\n      if (restValue !== channelValue) {\n        value = value.replace(restValue, channelValue);\n      }\n    }\n  } else {\n    // nested relative color\n    const [, restValue] = value.split(REG_FN_REL_START) as MatchedRegExp;\n    const tokens = tokenize({ css: restValue });\n    const originColor: string[] = [];\n    let nest = 0;\n    let tokenIndex = 0;\n    for (const [type, tokenValue] of tokens) {\n      tokenIndex++;\n      switch (type) {\n        case FUNC:\n        case PAREN_OPEN: {\n          originColor.push(tokenValue);\n          nest++;\n          break;\n        }\n        case PAREN_CLOSE: {\n          const lastValue = originColor[originColor.length - 1];\n          if (lastValue === ' ') {\n            originColor[originColor.length - 1] = tokenValue;\n          } else if (isString(lastValue)) {\n            originColor.push(tokenValue);\n          }\n          nest--;\n          break;\n        }\n        case W_SPACE: {\n          const lastValue = originColor[originColor.length - 1];\n          if (\n            isString(lastValue) &&\n            !lastValue.endsWith('(') &&\n            lastValue !== ' '\n          ) {\n            originColor.push(tokenValue);\n          }\n          break;\n        }\n        default: {\n          if (type !== COMMENT && type !== EOF) {\n            originColor.push(tokenValue);\n          }\n        }\n      }\n      if (nest === 0) {\n        break;\n      }\n    }\n    const resolvedOriginColor = resolveRelativeColor(\n      originColor.join('').trim(),\n      opt\n    );\n    if (resolvedOriginColor instanceof NullObject) {\n      setCache(cacheKey, null);\n      return resolvedOriginColor;\n    }\n    const channelValues = resolveColorChannels(tokens.slice(tokenIndex), opt);\n    if (channelValues instanceof NullObject) {\n      setCache(cacheKey, null);\n      return channelValues;\n    }\n    const [v1, v2, v3, v4] = channelValues;\n    let channelValue = '';\n    if (isStringOrNumber(v4)) {\n      channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;\n    } else {\n      channelValue = ` ${channelValues.join(' ')})`;\n    }\n    value = value.replace(restValue, `${resolvedOriginColor}${channelValue}`);\n  }\n  setCache(cacheKey, value);\n  return value;\n}\n\n/**\n * resolve relative color\n * @param value - CSS relative color value\n * @param [opt] - options\n * @returns resolved value\n */\nexport function resolveRelativeColor(\n  value: string,\n  opt: Options = {}\n): string | NullObject {\n  const { format = '' } = opt;\n  if (isString(value)) {\n    if (REG_FN_VAR.test(value)) {\n      // var() must be resolved before resolveRelativeColor()\n      if (format !== VAL_SPEC) {\n        throw new SyntaxError(`Unexpected token ${FN_VAR} found.`);\n      }\n      return value;\n    } else if (!REG_FN_REL.test(value)) {\n      return value;\n    }\n    value = value.toLowerCase().trim();\n  } else {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const cacheKey: string = createCacheKey(\n    {\n      namespace: NAMESPACE,\n      name: 'resolveRelativeColor',\n      value\n    },\n    opt\n  );\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    if (cachedResult.isNull) {\n      return cachedResult as NullObject;\n    }\n    return cachedResult.item as string;\n  }\n  const originColor = extractOriginColor(value, opt);\n  if (originColor instanceof NullObject) {\n    setCache(cacheKey, null);\n    return originColor;\n  }\n  value = originColor;\n  if (format === VAL_SPEC) {\n    if (value.startsWith('rgba(')) {\n      value = value.replace('rgba(', 'rgb(');\n    } else if (value.startsWith('hsla(')) {\n      value = value.replace('hsla(', 'hsl(');\n    }\n    return value;\n  }\n  const tokens = tokenize({ css: value });\n  const components = parseComponentValue(tokens) as ComponentValue;\n  const parsedComponents = colorParser(components);\n  if (!parsedComponents) {\n    setCache(cacheKey, null);\n    return new NullObject();\n  }\n  const {\n    alpha: alphaComponent,\n    channels: channelsComponent,\n    colorNotation,\n    syntaxFlags\n  } = parsedComponents;\n  let alpha: number | string;\n  if (Number.isNaN(Number(alphaComponent))) {\n    if (syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE)) {\n      alpha = NONE;\n    } else {\n      alpha = 0;\n    }\n  } else {\n    alpha = roundToPrecision(Number(alphaComponent), OCT);\n  }\n  let v1: number | string;\n  let v2: number | string;\n  let v3: number | string;\n  [v1, v2, v3] = channelsComponent;\n  let resolvedValue;\n  if (REG_CS_CIE.test(colorNotation)) {\n    const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);\n    if (Number.isNaN(v1)) {\n      if (hasNone) {\n        v1 = NONE;\n      } else {\n        v1 = 0;\n      }\n    } else {\n      v1 = roundToPrecision(v1, HEX);\n    }\n    if (Number.isNaN(v2)) {\n      if (hasNone) {\n        v2 = NONE;\n      } else {\n        v2 = 0;\n      }\n    } else {\n      v2 = roundToPrecision(v2, HEX);\n    }\n    if (Number.isNaN(v3)) {\n      if (hasNone) {\n        v3 = NONE;\n      } else {\n        v3 = 0;\n      }\n    } else {\n      v3 = roundToPrecision(v3, HEX);\n    }\n    if (alpha === 1) {\n      resolvedValue = `${colorNotation}(${v1} ${v2} ${v3})`;\n    } else {\n      resolvedValue = `${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`;\n    }\n  } else if (REG_CS_HSL.test(colorNotation)) {\n    if (Number.isNaN(v1)) {\n      v1 = 0;\n    }\n    if (Number.isNaN(v2)) {\n      v2 = 0;\n    }\n    if (Number.isNaN(v3)) {\n      v3 = 0;\n    }\n    let [r, g, b] = convertColorToRgb(\n      `${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`\n    ) as ColorChannels;\n    r = roundToPrecision(r / MAX_RGB, DEC);\n    g = roundToPrecision(g / MAX_RGB, DEC);\n    b = roundToPrecision(b / MAX_RGB, DEC);\n    if (alpha === 1) {\n      resolvedValue = `color(srgb ${r} ${g} ${b})`;\n    } else {\n      resolvedValue = `color(srgb ${r} ${g} ${b} / ${alpha})`;\n    }\n  } else {\n    const cs = colorNotation === 'rgb' ? 'srgb' : colorNotation;\n    const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);\n    if (Number.isNaN(v1)) {\n      if (hasNone) {\n        v1 = NONE;\n      } else {\n        v1 = 0;\n      }\n    } else {\n      v1 = roundToPrecision(v1, DEC);\n    }\n    if (Number.isNaN(v2)) {\n      if (hasNone) {\n        v2 = NONE;\n      } else {\n        v2 = 0;\n      }\n    } else {\n      v2 = roundToPrecision(v2, DEC);\n    }\n    if (Number.isNaN(v3)) {\n      if (hasNone) {\n        v3 = NONE;\n      } else {\n        v3 = 0;\n      }\n    } else {\n      v3 = roundToPrecision(v3, DEC);\n    }\n    if (alpha === 1) {\n      resolvedValue = `color(${cs} ${v1} ${v2} ${v3})`;\n    } else {\n      resolvedValue = `color(${cs} ${v1} ${v2} ${v3} / ${alpha})`;\n    }\n  }\n  setCache(cacheKey, resolvedValue);\n  return resolvedValue;\n}\n"],"mappings":"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"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/resolve.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/resolve.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..429627db750343fe50c2db36ff9f46cf57f0bcd9
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/resolve.d.ts
@@ -0,0 +1,15 @@
+import { NullObject } from './cache.js';
+import { Options } from './typedef.js';
+/**
+ * resolve color
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns resolved color
+ */
+export declare const resolveColor: (value: string, opt?: Options) => string | NullObject;
+/**
+ * resolve CSS color
+ * @param value - CSS color value. system colors are not supported
+ * @param [opt] - options
+ */
+export declare const resolve: (value: string, opt?: Options) => string | null;
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/resolve.js b/node_modules/@asamuzakjp/css-color/dist/esm/js/resolve.js
new file mode 100644
index 0000000000000000000000000000000000000000..f28636abca9de0fcca42a06d96615620d23a710d
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/resolve.js
@@ -0,0 +1,210 @@
+import { CacheItem, NullObject, createCacheKey, getCache, setCache } from "./cache.js";
+import { isString } from "./common.js";
+import { SYN_FN_CALC, SYN_FN_LIGHT_DARK, SYN_FN_REL, SYN_FN_VAR, VAL_COMP, VAL_SPEC } from "./constant.js";
+import { convertRgbToHex, resolveColorFunc, resolveColorMix, resolveColorValue } from "./color.js";
+import { resolveRelativeColor } from "./relative-color.js";
+import { splitValue } from "./util.js";
+import { resolveVar } from "./css-var.js";
+import { cssCalc } from "./css-calc.js";
+//#region src/js/resolve.ts
+/**
+* resolve
+*/
+var NAMESPACE = "resolve";
+var RGB_TRANSPARENT = "rgba(0, 0, 0, 0)";
+var REG_FN_CALC = new RegExp(SYN_FN_CALC);
+var REG_FN_LIGHT_DARK = new RegExp(SYN_FN_LIGHT_DARK);
+var REG_FN_REL = new RegExp(SYN_FN_REL);
+var REG_FN_VAR = new RegExp(SYN_FN_VAR);
+/**
+* resolve color
+* @param value - CSS color value
+* @param [opt] - options
+* @returns resolved color
+*/
+var resolveColor = (value, opt = {}) => {
+	if (!isString(value)) throw new TypeError(`${value} is not a string.`);
+	value = value.trim();
+	const { colorScheme = "normal", currentColor = "", format = VAL_COMP, nullable = false } = opt;
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "resolve",
+		value
+	}, opt);
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) {
+		if (cachedResult.isNull) return cachedResult;
+		return cachedResult.item;
+	}
+	if (REG_FN_VAR.test(value)) {
+		if (format === "specifiedValue") {
+			setCache(cacheKey, value);
+			return value;
+		}
+		const resolvedVar = resolveVar(value, opt);
+		if (resolvedVar instanceof NullObject) {
+			const res = format === "hex" || format === "hexAlpha" || nullable ? resolvedVar : RGB_TRANSPARENT;
+			setCache(cacheKey, res);
+			return res;
+		}
+		value = resolvedVar;
+	}
+	if (opt.format !== format) opt.format = format;
+	value = value.toLowerCase();
+	if (REG_FN_LIGHT_DARK.test(value) && value.endsWith(")")) {
+		const [light = "", dark = ""] = splitValue(value.replace(REG_FN_LIGHT_DARK, "").replace(/\)$/, ""), { delimiter: "," });
+		if (light && dark) {
+			if (format === "specifiedValue") {
+				const lightColor = resolveColor(light, opt);
+				const darkColor = resolveColor(dark, opt);
+				const res = lightColor && darkColor ? `light-dark(${lightColor}, ${darkColor})` : "";
+				setCache(cacheKey, res);
+				return res;
+			}
+			const resolved = resolveColor(colorScheme === "dark" ? dark : light, opt);
+			const res = resolved instanceof NullObject && !nullable ? RGB_TRANSPARENT : resolved;
+			setCache(cacheKey, res);
+			return res;
+		}
+		const invalidRes = format === "specifiedValue" ? "" : format === "hex" || format === "hexAlpha" ? new NullObject() : RGB_TRANSPARENT;
+		setCache(cacheKey, invalidRes);
+		return invalidRes;
+	}
+	if (REG_FN_REL.test(value)) {
+		const resolvedRel = resolveRelativeColor(value, opt);
+		if (format === "computedValue") {
+			const res = resolvedRel instanceof NullObject && !nullable ? RGB_TRANSPARENT : resolvedRel;
+			setCache(cacheKey, res);
+			return res;
+		}
+		if (format === "specifiedValue") {
+			const res = resolvedRel instanceof NullObject ? "" : resolvedRel;
+			setCache(cacheKey, res);
+			return res;
+		}
+		value = resolvedRel instanceof NullObject ? "" : resolvedRel;
+	}
+	if (REG_FN_CALC.test(value)) value = cssCalc(value, opt);
+	let cs = "";
+	let r = NaN;
+	let g = NaN;
+	let b = NaN;
+	let alpha = NaN;
+	if (value === "transparent") {
+		let res;
+		switch (format) {
+			case VAL_SPEC:
+				res = value;
+				break;
+			case "hex":
+				res = new NullObject();
+				break;
+			case "hexAlpha":
+				res = "#00000000";
+				break;
+			default: res = RGB_TRANSPARENT;
+		}
+		setCache(cacheKey, res);
+		return res;
+	}
+	if (value === "currentcolor") {
+		if (format === "specifiedValue") {
+			setCache(cacheKey, value);
+			return value;
+		}
+		if (currentColor) {
+			let resolvedCurrent;
+			if (currentColor.startsWith("color-mix(")) resolvedCurrent = resolveColorMix(currentColor, opt);
+			else if (currentColor.startsWith("color(")) resolvedCurrent = resolveColorFunc(currentColor, opt);
+			else resolvedCurrent = resolveColorValue(currentColor, opt);
+			if (resolvedCurrent instanceof NullObject) {
+				setCache(cacheKey, resolvedCurrent);
+				return resolvedCurrent;
+			}
+			[cs, r, g, b, alpha] = resolvedCurrent;
+		} else {
+			const res = format === "computedValue" ? RGB_TRANSPARENT : value;
+			if (format === "computedValue") {
+				setCache(cacheKey, res);
+				return res;
+			}
+		}
+	} else if (format === "specifiedValue") {
+		let res = "";
+		if (value.startsWith("color-mix(")) res = resolveColorMix(value, opt);
+		else if (value.startsWith("color(")) {
+			const [scs, rr, gg, bb, aa] = resolveColorFunc(value, opt);
+			res = aa === 1 ? `color(${scs} ${rr} ${gg} ${bb})` : `color(${scs} ${rr} ${gg} ${bb} / ${aa})`;
+		} else {
+			const rgb = resolveColorValue(value, opt);
+			if (isString(rgb)) res = rgb;
+			else {
+				const [scs, rr, gg, bb, aa] = rgb;
+				if (scs === "rgb") res = aa === 1 ? `${scs}(${rr}, ${gg}, ${bb})` : `${scs}a(${rr}, ${gg}, ${bb}, ${aa})`;
+				else res = aa === 1 ? `${scs}(${rr} ${gg} ${bb})` : `${scs}(${rr} ${gg} ${bb} / ${aa})`;
+			}
+		}
+		setCache(cacheKey, res);
+		return res;
+	} else if (value.startsWith("color-mix(")) {
+		if (currentColor) value = value.replace(/currentcolor/g, currentColor);
+		value = value.replace(/transparent/g, RGB_TRANSPARENT);
+		const resolvedMix = resolveColorMix(value, opt);
+		if (resolvedMix instanceof NullObject) {
+			setCache(cacheKey, resolvedMix);
+			return resolvedMix;
+		}
+		[cs, r, g, b, alpha] = resolvedMix;
+	} else if (value.startsWith("color(")) {
+		const resolvedFunc = resolveColorFunc(value, opt);
+		if (resolvedFunc instanceof NullObject) {
+			setCache(cacheKey, resolvedFunc);
+			return resolvedFunc;
+		}
+		[cs, r, g, b, alpha] = resolvedFunc;
+	} else if (value) {
+		const resolvedVal = resolveColorValue(value, opt);
+		if (resolvedVal instanceof NullObject) {
+			setCache(cacheKey, resolvedVal);
+			return resolvedVal;
+		}
+		[cs, r, g, b, alpha] = resolvedVal;
+	}
+	let finalRes = "";
+	switch (format) {
+		case "hex":
+		case "hexAlpha":
+			if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(alpha) || format === "hex" && alpha === 0) finalRes = new NullObject();
+			else finalRes = convertRgbToHex([
+				r,
+				g,
+				b,
+				format === "hex" ? 1 : alpha
+			]);
+			break;
+		default: if (cs === "rgb") finalRes = alpha === 1 ? `${cs}(${r}, ${g}, ${b})` : `${cs}a(${r}, ${g}, ${b}, ${alpha})`;
+		else if ([
+			"lab",
+			"lch",
+			"oklab",
+			"oklch"
+		].includes(cs)) finalRes = alpha === 1 ? `${cs}(${r} ${g} ${b})` : `${cs}(${r} ${g} ${b} / ${alpha})`;
+		else finalRes = alpha === 1 ? `color(${cs} ${r} ${g} ${b})` : `color(${cs} ${r} ${g} ${b} / ${alpha})`;
+	}
+	setCache(cacheKey, finalRes);
+	return finalRes;
+};
+/**
+* resolve CSS color
+* @param value - CSS color value. system colors are not supported
+* @param [opt] - options
+*/
+var resolve = (value, opt = {}) => {
+	opt.nullable = false;
+	const resolvedValue = resolveColor(value, opt);
+	return resolvedValue instanceof NullObject ? null : resolvedValue;
+};
+//#endregion
+export { resolve, resolveColor };
+
+//# sourceMappingURL=resolve.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/resolve.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/js/resolve.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..a2cb6a7b4c7f14f85388a142a6c5e778831bbb45
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/resolve.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"resolve.js","names":[],"sources":["../../../src/js/resolve.ts"],"sourcesContent":["/**\n * resolve\n */\n\nimport {\n  CacheItem,\n  NullObject,\n  createCacheKey,\n  getCache,\n  setCache\n} from './cache';\nimport {\n  convertRgbToHex,\n  resolveColorFunc,\n  resolveColorMix,\n  resolveColorValue\n} from './color';\nimport { isString } from './common';\nimport { cssCalc } from './css-calc';\nimport { resolveVar } from './css-var';\nimport { resolveRelativeColor } from './relative-color';\nimport { splitValue } from './util';\nimport {\n  ComputedColorChannels,\n  Options,\n  SpecifiedColorChannels\n} from './typedef';\n\n/* constants */\nimport {\n  FN_COLOR,\n  FN_MIX,\n  SYN_FN_CALC,\n  SYN_FN_LIGHT_DARK,\n  SYN_FN_REL,\n  SYN_FN_VAR,\n  VAL_COMP,\n  VAL_SPEC\n} from './constant';\nconst NAMESPACE = 'resolve';\nconst RGB_TRANSPARENT = 'rgba(0, 0, 0, 0)';\n\n/* regexp */\nconst REG_FN_CALC = new RegExp(SYN_FN_CALC);\nconst REG_FN_LIGHT_DARK = new RegExp(SYN_FN_LIGHT_DARK);\nconst REG_FN_REL = new RegExp(SYN_FN_REL);\nconst REG_FN_VAR = new RegExp(SYN_FN_VAR);\n\n/**\n * resolve color\n * @param value - CSS color value\n * @param [opt] - options\n * @returns resolved color\n */\nexport const resolveColor = (\n  value: string,\n  opt: Options = {}\n): string | NullObject => {\n  if (!isString(value)) {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  value = value.trim();\n  const {\n    colorScheme = 'normal',\n    currentColor = '',\n    format = VAL_COMP,\n    nullable = false\n  } = opt;\n  const cacheKey: string = createCacheKey(\n    { namespace: NAMESPACE, name: 'resolve', value },\n    opt\n  );\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    if (cachedResult.isNull) {\n      return cachedResult as NullObject;\n    }\n    return cachedResult.item as string;\n  }\n  // 1. var() resolution\n  if (REG_FN_VAR.test(value)) {\n    if (format === VAL_SPEC) {\n      setCache(cacheKey, value);\n      return value;\n    }\n    const resolvedVar = resolveVar(value, opt);\n    if (resolvedVar instanceof NullObject) {\n      const res =\n        format === 'hex' || format === 'hexAlpha' || nullable\n          ? resolvedVar\n          : RGB_TRANSPARENT;\n      setCache(cacheKey, res);\n      return res;\n    }\n    value = resolvedVar;\n  }\n  if (opt.format !== format) {\n    opt.format = format;\n  }\n  value = value.toLowerCase();\n  // 2. light-dark() resolution\n  if (REG_FN_LIGHT_DARK.test(value) && value.endsWith(')')) {\n    const colorParts = value.replace(REG_FN_LIGHT_DARK, '').replace(/\\)$/, '');\n    const [light = '', dark = ''] = splitValue(colorParts, { delimiter: ',' });\n    if (light && dark) {\n      if (format === VAL_SPEC) {\n        const lightColor = resolveColor(light, opt);\n        const darkColor = resolveColor(dark, opt);\n        const res =\n          lightColor && darkColor\n            ? `light-dark(${lightColor}, ${darkColor})`\n            : '';\n        setCache(cacheKey, res);\n        return res;\n      }\n      const chosen = colorScheme === 'dark' ? dark : light;\n      const resolved = resolveColor(chosen, opt);\n      const res =\n        resolved instanceof NullObject && !nullable\n          ? RGB_TRANSPARENT\n          : resolved;\n      setCache(cacheKey, res);\n      return res;\n    }\n    // fallback for invalid light-dark\n    const invalidRes =\n      format === VAL_SPEC\n        ? ''\n        : format === 'hex' || format === 'hexAlpha'\n          ? new NullObject()\n          : RGB_TRANSPARENT;\n    setCache(cacheKey, invalidRes);\n    return invalidRes;\n  }\n  // 3. Relative Color resolution\n  if (REG_FN_REL.test(value)) {\n    const resolvedRel = resolveRelativeColor(value, opt);\n    if (format === VAL_COMP) {\n      const res =\n        resolvedRel instanceof NullObject && !nullable\n          ? RGB_TRANSPARENT\n          : resolvedRel;\n      setCache(cacheKey, res);\n      return res;\n    }\n    if (format === VAL_SPEC) {\n      const res = resolvedRel instanceof NullObject ? '' : resolvedRel;\n      setCache(cacheKey, res);\n      return res;\n    }\n    value = resolvedRel instanceof NullObject ? '' : resolvedRel;\n  }\n  // 4. calc() resolution\n  if (REG_FN_CALC.test(value)) {\n    value = cssCalc(value, opt);\n  }\n  // 5. Keyword & Color-space resolution\n  let cs = '';\n  let r = NaN;\n  let g = NaN;\n  let b = NaN;\n  let alpha = NaN;\n  if (value === 'transparent') {\n    let res: string | NullObject;\n    switch (format) {\n      case VAL_SPEC: {\n        res = value;\n        break;\n      }\n      case 'hex': {\n        res = new NullObject();\n        break;\n      }\n      case 'hexAlpha': {\n        res = '#00000000';\n        break;\n      }\n      default: {\n        res = RGB_TRANSPARENT;\n      }\n    }\n    setCache(cacheKey, res);\n    return res;\n  }\n  if (value === 'currentcolor') {\n    if (format === VAL_SPEC) {\n      setCache(cacheKey, value);\n      return value;\n    }\n    if (currentColor) {\n      let resolvedCurrent;\n      if (currentColor.startsWith(FN_MIX)) {\n        resolvedCurrent = resolveColorMix(currentColor, opt);\n      } else if (currentColor.startsWith(FN_COLOR)) {\n        resolvedCurrent = resolveColorFunc(currentColor, opt);\n      } else {\n        resolvedCurrent = resolveColorValue(currentColor, opt);\n      }\n      if (resolvedCurrent instanceof NullObject) {\n        setCache(cacheKey, resolvedCurrent);\n        return resolvedCurrent;\n      }\n      [cs, r, g, b, alpha] = resolvedCurrent as ComputedColorChannels;\n    } else {\n      // value is handled below if not VAL_COMP\n      const res = format === VAL_COMP ? RGB_TRANSPARENT : value;\n      if (format === VAL_COMP) {\n        setCache(cacheKey, res);\n        return res;\n      }\n    }\n  } else if (format === VAL_SPEC) {\n    let res = '';\n    if (value.startsWith(FN_MIX)) {\n      res = resolveColorMix(value, opt) as string;\n    } else if (value.startsWith(FN_COLOR)) {\n      const [scs, rr, gg, bb, aa] = resolveColorFunc(\n        value,\n        opt\n      ) as SpecifiedColorChannels;\n      res =\n        aa === 1\n          ? `color(${scs} ${rr} ${gg} ${bb})`\n          : `color(${scs} ${rr} ${gg} ${bb} / ${aa})`;\n    } else {\n      const rgb = resolveColorValue(value, opt);\n      if (isString(rgb)) {\n        res = rgb;\n      } else {\n        const [scs, rr, gg, bb, aa] = rgb as SpecifiedColorChannels;\n        if (scs === 'rgb') {\n          res =\n            aa === 1\n              ? `${scs}(${rr}, ${gg}, ${bb})`\n              : `${scs}a(${rr}, ${gg}, ${bb}, ${aa})`;\n        } else {\n          res =\n            aa === 1\n              ? `${scs}(${rr} ${gg} ${bb})`\n              : `${scs}(${rr} ${gg} ${bb} / ${aa})`;\n        }\n      }\n    }\n    setCache(cacheKey, res);\n    return res;\n  } else if (value.startsWith(FN_MIX)) {\n    if (currentColor) {\n      value = value.replace(/currentcolor/g, currentColor);\n    }\n    value = value.replace(/transparent/g, RGB_TRANSPARENT);\n    const resolvedMix = resolveColorMix(value, opt);\n    if (resolvedMix instanceof NullObject) {\n      setCache(cacheKey, resolvedMix);\n      return resolvedMix;\n    }\n    [cs, r, g, b, alpha] = resolvedMix as ComputedColorChannels;\n  } else if (value.startsWith(FN_COLOR)) {\n    const resolvedFunc = resolveColorFunc(value, opt);\n    if (resolvedFunc instanceof NullObject) {\n      setCache(cacheKey, resolvedFunc);\n      return resolvedFunc;\n    }\n    [cs, r, g, b, alpha] = resolvedFunc as ComputedColorChannels;\n  } else if (value) {\n    const resolvedVal = resolveColorValue(value, opt);\n    if (resolvedVal instanceof NullObject) {\n      setCache(cacheKey, resolvedVal);\n      return resolvedVal;\n    }\n    [cs, r, g, b, alpha] = resolvedVal as ComputedColorChannels;\n  }\n  // 6. Format Finalization\n  let finalRes: string | NullObject = '';\n  switch (format) {\n    case 'hex':\n    case 'hexAlpha': {\n      if (\n        Number.isNaN(r) ||\n        Number.isNaN(g) ||\n        Number.isNaN(b) ||\n        Number.isNaN(alpha) ||\n        (format === 'hex' && alpha === 0)\n      ) {\n        finalRes = new NullObject();\n      } else {\n        finalRes = convertRgbToHex([r, g, b, format === 'hex' ? 1 : alpha]);\n      }\n      break;\n    }\n    default: {\n      if (cs === 'rgb') {\n        finalRes =\n          alpha === 1\n            ? `${cs}(${r}, ${g}, ${b})`\n            : `${cs}a(${r}, ${g}, ${b}, ${alpha})`;\n      } else if (['lab', 'lch', 'oklab', 'oklch'].includes(cs)) {\n        finalRes =\n          alpha === 1\n            ? `${cs}(${r} ${g} ${b})`\n            : `${cs}(${r} ${g} ${b} / ${alpha})`;\n      } else {\n        finalRes =\n          alpha === 1\n            ? `color(${cs} ${r} ${g} ${b})`\n            : `color(${cs} ${r} ${g} ${b} / ${alpha})`;\n      }\n    }\n  }\n  setCache(cacheKey, finalRes);\n  return finalRes;\n};\n\n/**\n * resolve CSS color\n * @param value - CSS color value. system colors are not supported\n * @param [opt] - options\n */\nexport const resolve = (value: string, opt: Options = {}): string | null => {\n  opt.nullable = false;\n  const resolvedValue = resolveColor(value, opt);\n  return resolvedValue instanceof NullObject ? null : (resolvedValue as string);\n};\n"],"mappings":"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"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/typedef.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/typedef.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..51303772d94c2422347fb55c1443cc6c5722c2ba
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/typedef.d.ts
@@ -0,0 +1,80 @@
+/**
+ * typedef
+ */
+/**
+ * @typedef Options - options
+ * @property [alpha] - enable alpha
+ * @property [colorSpace] - color space
+ * @property [currentColor] - color for currentcolor
+ * @property [customProperty] - custom properties
+ * @property [d50] - white point in d50
+ * @property [dimension] - dimension
+ * @property [format] - output format
+ * @property [key] - key
+ */
+export interface Options {
+    alpha?: boolean;
+    colorScheme?: string;
+    colorSpace?: string;
+    currentColor?: string;
+    customProperty?: Record<string, string | ((K: string) => string)>;
+    d50?: boolean;
+    delimiter?: string | string[];
+    dimension?: Record<string, number | ((K: string) => number)>;
+    format?: string;
+    nullable?: boolean;
+    preserveComment?: boolean;
+}
+/**
+ * @type ColorChannels - color channels
+ */
+export type ColorChannels = [x: number, y: number, z: number, alpha: number];
+/**
+ * @type StringColorChannels - color channels
+ */
+export type StringColorChannels = [
+    x: string,
+    y: string,
+    z: string,
+    alpha: string | undefined
+];
+/**
+ * @type StringColorSpacedChannels - specified value
+ */
+export type StringColorSpacedChannels = [
+    cs: string,
+    x: string,
+    y: string,
+    z: string,
+    alpha: string | undefined
+];
+/**
+ * @type ComputedColorChannels - computed value
+ */
+export type ComputedColorChannels = [
+    cs: string,
+    x: number,
+    y: number,
+    z: number,
+    alpha: number
+];
+/**
+ * @type SpecifiedColorChannels - specified value
+ */
+export type SpecifiedColorChannels = [
+    cs: string,
+    x: number | string,
+    y: number | string,
+    z: number | string,
+    alpha: number | string
+];
+/**
+ * @type MatchedRegExp - matched regexp array
+ */
+export type MatchedRegExp = [
+    match: string,
+    gr1: string,
+    gr2: string,
+    gr3: string,
+    gr4: string
+];
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/util.d.ts b/node_modules/@asamuzakjp/css-color/dist/esm/js/util.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..3c095db0e592497927cc7e2a8524cec73f07f03c
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/util.d.ts
@@ -0,0 +1,59 @@
+import { Options } from './typedef.js';
+/**
+ * split value
+ * NOTE: comments are stripped, it can be preserved if, in the options param,
+ * `delimiter` is either ',' or '/' and with `preserveComment` set to `true`
+ * @param value - CSS value
+ * @param [opt] - options
+ * @returns array of values
+ */
+export declare const splitValue: (value: string, opt?: Options) => string[];
+/**
+ * extract dashed-ident tokens
+ * @param value - CSS value
+ * @returns array of dashed-ident tokens
+ */
+export declare const extractDashedIdent: (value: string) => string[];
+/**
+ * is color
+ * @param value - CSS value
+ * @param [opt] - options
+ * @returns result
+ */
+export declare const isColor: (value: unknown, opt?: Options) => boolean;
+/**
+ * round to specified precision
+ * @param value - numeric value
+ * @param bit - minimum bits
+ * @returns rounded value
+ */
+export declare const roundToPrecision: (value: number, bit?: number) => number;
+/**
+ * interpolate hue
+ * @param hueA - hue value
+ * @param hueB - hue value
+ * @param arc - shorter | longer | increasing | decreasing
+ * @returns result - [hueA, hueB]
+ */
+export declare const interpolateHue: (hueA: number, hueB: number, arc?: string) => [number, number];
+/**
+ * resolve length in pixels
+ * @param value - value
+ * @param unit - unit
+ * @param [opt] - options
+ * @returns pixelated value
+ */
+export declare const resolveLengthInPixels: (value: number | string, unit: string | undefined, opt?: Options) => number;
+/**
+ * is absolute size or length
+ * @param value - value
+ * @param unit - unit
+ * @returns result
+ */
+export declare const isAbsoluteSizeOrLength: (value: number | string, unit: string | undefined) => boolean;
+/**
+ * is absolute font size
+ * @param css - css
+ * @returns result
+ */
+export declare const isAbsoluteFontSize: (css: unknown) => boolean;
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/util.js b/node_modules/@asamuzakjp/css-color/dist/esm/js/util.js
new file mode 100644
index 0000000000000000000000000000000000000000..be90d9f2e9a5ed778179d669b6085009e201bd7c
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/util.js
@@ -0,0 +1,274 @@
+import { CacheItem, createCacheKey, getCache, setCache } from "./cache.js";
+import { isString } from "./common.js";
+import { SYN_COLOR_TYPE, SYN_MIX, VAL_SPEC } from "./constant.js";
+import { NAMED_COLORS } from "./color.js";
+import { resolveColor } from "./resolve.js";
+import { TokenType, tokenize } from "@csstools/css-tokenizer";
+//#region src/js/util.ts
+/**
+* util
+*/
+var { CloseParen: PAREN_CLOSE, Comma: COMMA, Comment: COMMENT, Delim: DELIM, EOF, Function: FUNC, OpenParen: PAREN_OPEN, Whitespace: W_SPACE } = TokenType;
+var NAMESPACE = "util";
+var DEC = 10;
+var HEX = 16;
+var DEG = 360;
+var DEG_HALF = 180;
+var REG_COLOR = new RegExp(`^(?:${SYN_COLOR_TYPE})$`);
+var REG_DIMENSION = /^([+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)([a-z]*)$/i;
+var REG_FN_COLOR = /^(?:(?:ok)?l(?:ab|ch)|color(?:-mix)?|hsla?|hwb|rgba?|var)\(/;
+var REG_MIX = new RegExp(SYN_MIX);
+var REG_DASHED_IDENT = /--[\w-]+/g;
+var REG_COMMA = /^,$/;
+var REG_SLASH = /^\/$/;
+var REG_WHITESPACE = /^\s+$/;
+/**
+* split value
+* NOTE: comments are stripped, it can be preserved if, in the options param,
+* `delimiter` is either ',' or '/' and with `preserveComment` set to `true`
+* @param value - CSS value
+* @param [opt] - options
+* @returns array of values
+*/
+var splitValue = (value, opt = {}) => {
+	if (!isString(value)) throw new TypeError(`${value} is not a string.`);
+	const strValue = value.trim();
+	const { delimiter = " ", preserveComment = false } = opt;
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "splitValue",
+		value: strValue
+	}, {
+		delimiter,
+		preserveComment
+	});
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) return cachedResult.item;
+	let regDelimiter;
+	switch (delimiter) {
+		case ",":
+			regDelimiter = REG_COMMA;
+			break;
+		case "/":
+			regDelimiter = REG_SLASH;
+			break;
+		default: regDelimiter = REG_WHITESPACE;
+	}
+	const tokens = tokenize({ css: strValue });
+	let nest = 0;
+	let currentStr = "";
+	const res = [];
+	for (const [type, val] of tokens) switch (type) {
+		case COMMA:
+		case DELIM:
+			if (nest === 0 && regDelimiter.test(val)) {
+				res.push(currentStr.trim());
+				currentStr = "";
+			} else currentStr += val;
+			break;
+		case COMMENT:
+			if (preserveComment && (delimiter === "," || delimiter === "/")) currentStr += val;
+			break;
+		case FUNC:
+		case PAREN_OPEN:
+			currentStr += val;
+			nest++;
+			break;
+		case PAREN_CLOSE:
+			currentStr += val;
+			nest--;
+			break;
+		case W_SPACE:
+			if (regDelimiter.test(val)) if (nest === 0) {
+				if (currentStr) {
+					res.push(currentStr.trim());
+					currentStr = "";
+				}
+			} else currentStr += " ";
+			else if (!currentStr.endsWith(" ")) currentStr += " ";
+			break;
+		default: if (type === EOF) {
+			res.push(currentStr.trim());
+			currentStr = "";
+		} else currentStr += val;
+	}
+	setCache(cacheKey, res);
+	return res;
+};
+/**
+* extract dashed-ident tokens
+* @param value - CSS value
+* @returns array of dashed-ident tokens
+*/
+var extractDashedIdent = (value) => {
+	if (!isString(value)) throw new TypeError(`${value} is not a string.`);
+	const strValue = value.trim();
+	const cacheKey = createCacheKey({
+		namespace: NAMESPACE,
+		name: "extractDashedIdent",
+		value: strValue
+	});
+	const cachedResult = getCache(cacheKey);
+	if (cachedResult instanceof CacheItem) return cachedResult.item;
+	const matches = strValue.match(REG_DASHED_IDENT);
+	const res = matches ? [...new Set(matches)] : [];
+	setCache(cacheKey, res);
+	return res;
+};
+/**
+* is color
+* @param value - CSS value
+* @param [opt] - options
+* @returns result
+*/
+var isColor = (value, opt = {}) => {
+	if (!isString(value)) return false;
+	const str = value.toLowerCase().trim();
+	if (!str) return false;
+	if (/^[a-z]+$/.test(str)) return str === "currentcolor" || str === "transparent" || Object.hasOwn(NAMED_COLORS, str);
+	if (REG_COLOR.test(str) || REG_MIX.test(str)) return true;
+	if (REG_FN_COLOR.test(str)) {
+		const colorOpt = {
+			...opt,
+			nullable: true
+		};
+		if (!colorOpt.format) colorOpt.format = VAL_SPEC;
+		return !!resolveColor(str, colorOpt);
+	}
+	return false;
+};
+/**
+* round to specified precision
+* @param value - numeric value
+* @param bit - minimum bits
+* @returns rounded value
+*/
+var roundToPrecision = (value, bit = 0) => {
+	if (!Number.isFinite(value)) throw new TypeError(`${value} is not a finite number.`);
+	if (!Number.isFinite(bit)) throw new TypeError(`${bit} is not a finite number.`);
+	if (bit < 0 || bit > HEX) throw new RangeError(`${bit} is not between 0 and ${HEX}.`);
+	if (bit === 0) return Math.round(value);
+	const precision = bit === HEX ? 6 : bit < DEC ? 4 : 5;
+	return parseFloat(value.toPrecision(precision));
+};
+/**
+* interpolate hue
+* @param hueA - hue value
+* @param hueB - hue value
+* @param arc - shorter | longer | increasing | decreasing
+* @returns result - [hueA, hueB]
+*/
+var interpolateHue = (hueA, hueB, arc = "shorter") => {
+	if (!Number.isFinite(hueA)) throw new TypeError(`${hueA} is not a finite number.`);
+	if (!Number.isFinite(hueB)) throw new TypeError(`${hueB} is not a finite number.`);
+	let a = hueA;
+	let b = hueB;
+	switch (arc) {
+		case "decreasing":
+			if (b > a) a += DEG;
+			break;
+		case "increasing":
+			if (b < a) b += DEG;
+			break;
+		case "longer":
+			if (b > a && b < a + DEG_HALF) a += DEG;
+			else if (b > a - DEG_HALF && b <= a) b += DEG;
+			break;
+		default: if (b > a + DEG_HALF) a += DEG;
+		else if (b < a - DEG_HALF) b += DEG;
+	}
+	return [a, b];
+};
+var absoluteFontSize = new Map([
+	["xx-small", 9 / 16],
+	["x-small", 5 / 8],
+	["small", 13 / 16],
+	["medium", 1],
+	["large", 9 / 8],
+	["x-large", 3 / 2],
+	["xx-large", 2],
+	["xxx-large", 3]
+]);
+var relativeFontSize = new Map([["smaller", 1 / 1.2], ["larger", 1.2]]);
+var absoluteLength = new Map([
+	["cm", 96 / 2.54],
+	["mm", 96 / 25.4],
+	["q", 96 / 101.6],
+	["in", 96],
+	["pc", 16],
+	["pt", 96 / 72],
+	["px", 1]
+]);
+var relativeLength = new Map([
+	["rcap", 1],
+	["rch", .5],
+	["rem", 1],
+	["rex", .5],
+	["ric", 1],
+	["rlh", 1.2]
+]);
+/**
+* resolve length in pixels
+* @param value - value
+* @param unit - unit
+* @param [opt] - options
+* @returns pixelated value
+*/
+var resolveLengthInPixels = (value, unit, opt = {}) => {
+	const { dimension = {} } = opt;
+	const { callback, em, rem, vh, vw } = dimension;
+	if (isString(value)) {
+		const str = value.toLowerCase().trim();
+		const ratio = absoluteFontSize.get(str);
+		if (ratio !== void 0) return ratio * rem;
+		const relRatio = relativeFontSize.get(str);
+		if (relRatio !== void 0) return relRatio * em;
+		return NaN;
+	}
+	if (Number.isFinite(value) && unit) {
+		const u = unit.toLowerCase();
+		if (Object.hasOwn(dimension, u)) return value * Number(dimension[u]);
+		if (typeof callback === "function") return value * (callback(u) ?? NaN);
+		const absRatio = absoluteLength.get(u);
+		if (absRatio !== void 0) return value * absRatio;
+		const relRatio = relativeLength.get(u);
+		if (relRatio !== void 0) return value * relRatio * rem;
+		const rUnitRatio = relativeLength.get(`r${u}`);
+		if (rUnitRatio !== void 0) return value * rUnitRatio * em;
+		switch (u) {
+			case "vb":
+			case "vi": return value * vw;
+			case "vmax": return value * Math.max(vh, vw);
+			case "vmin": return value * Math.min(vh, vw);
+			default:
+		}
+	}
+	return NaN;
+};
+/**
+* is absolute size or length
+* @param value - value
+* @param unit - unit
+* @returns result
+*/
+var isAbsoluteSizeOrLength = (value, unit) => {
+	if (isString(value)) return absoluteFontSize.has(value.toLowerCase().trim());
+	if (isString(unit)) return absoluteLength.has(unit.toLowerCase().trim());
+	return value === 0;
+};
+/**
+* is absolute font size
+* @param css - css
+* @returns result
+*/
+var isAbsoluteFontSize = (css) => {
+	if (!isString(css)) return false;
+	const str = css.trim();
+	if (isAbsoluteSizeOrLength(str, void 0)) return true;
+	const match = str.match(REG_DIMENSION);
+	return match ? isAbsoluteSizeOrLength(Number(match[1]), match[2] || void 0) : false;
+};
+//#endregion
+export { extractDashedIdent, interpolateHue, isAbsoluteFontSize, isAbsoluteSizeOrLength, isColor, resolveLengthInPixels, roundToPrecision, splitValue };
+
+//# sourceMappingURL=util.js.map
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/dist/esm/js/util.js.map b/node_modules/@asamuzakjp/css-color/dist/esm/js/util.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..03ef78f6f8e2455ec438fc70c9b70936834012b4
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/dist/esm/js/util.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"util.js","names":[],"sources":["../../../src/js/util.ts"],"sourcesContent":["/**\n * util\n */\n\nimport { TokenType, tokenize } from '@csstools/css-tokenizer';\nimport { CacheItem, createCacheKey, getCache, setCache } from './cache';\nimport { isString } from './common';\nimport { resolveColor } from './resolve';\nimport { Options } from './typedef';\n\n/* constants */\nimport { NAMED_COLORS } from './color';\nimport { SYN_COLOR_TYPE, SYN_MIX, VAL_SPEC } from './constant';\nconst {\n  CloseParen: PAREN_CLOSE,\n  Comma: COMMA,\n  Comment: COMMENT,\n  Delim: DELIM,\n  EOF,\n  Function: FUNC,\n  OpenParen: PAREN_OPEN,\n  Whitespace: W_SPACE\n} = TokenType;\nconst NAMESPACE = 'util';\n\n/* numeric constants */\nconst DEC = 10;\nconst HEX = 16;\nconst DEG = 360;\nconst DEG_HALF = 180;\n\n/* regexp */\nconst REG_COLOR = new RegExp(`^(?:${SYN_COLOR_TYPE})$`);\nconst REG_DIMENSION = /^([+-]?(?:\\d+(?:\\.\\d+)?|\\.\\d+)(?:e[+-]?\\d+)?)([a-z]*)$/i;\nconst REG_FN_COLOR =\n  /^(?:(?:ok)?l(?:ab|ch)|color(?:-mix)?|hsla?|hwb|rgba?|var)\\(/;\nconst REG_MIX = new RegExp(SYN_MIX);\nconst REG_DASHED_IDENT = /--[\\w-]+/g;\nconst REG_COMMA = /^,$/;\nconst REG_SLASH = /^\\/$/;\nconst REG_WHITESPACE = /^\\s+$/;\n\n/**\n * split value\n * NOTE: comments are stripped, it can be preserved if, in the options param,\n * `delimiter` is either ',' or '/' and with `preserveComment` set to `true`\n * @param value - CSS value\n * @param [opt] - options\n * @returns array of values\n */\nexport const splitValue = (value: string, opt: Options = {}): string[] => {\n  if (!isString(value)) {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const strValue = value.trim();\n  const { delimiter = ' ', preserveComment = false } = opt;\n  const cacheKey: string = createCacheKey(\n    {\n      namespace: NAMESPACE,\n      name: 'splitValue',\n      value: strValue\n    },\n    { delimiter, preserveComment }\n  );\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    return cachedResult.item as string[];\n  }\n  let regDelimiter;\n  switch (delimiter) {\n    case ',': {\n      regDelimiter = REG_COMMA;\n      break;\n    }\n    case '/': {\n      regDelimiter = REG_SLASH;\n      break;\n    }\n    default: {\n      regDelimiter = REG_WHITESPACE;\n    }\n  }\n  const tokens = tokenize({ css: strValue });\n  let nest = 0;\n  let currentStr = '';\n  const res: string[] = [];\n  for (const [type, val] of tokens) {\n    switch (type) {\n      case COMMA:\n      case DELIM: {\n        if (nest === 0 && regDelimiter.test(val)) {\n          res.push(currentStr.trim());\n          currentStr = '';\n        } else {\n          currentStr += val;\n        }\n        break;\n      }\n      case COMMENT: {\n        if (preserveComment && (delimiter === ',' || delimiter === '/')) {\n          currentStr += val;\n        }\n        break;\n      }\n      case FUNC:\n      case PAREN_OPEN: {\n        currentStr += val;\n        nest++;\n        break;\n      }\n      case PAREN_CLOSE: {\n        currentStr += val;\n        nest--;\n        break;\n      }\n      case W_SPACE: {\n        if (regDelimiter.test(val)) {\n          if (nest === 0) {\n            if (currentStr) {\n              res.push(currentStr.trim());\n              currentStr = '';\n            }\n          } else {\n            currentStr += ' ';\n          }\n        } else if (!currentStr.endsWith(' ')) {\n          currentStr += ' ';\n        }\n        break;\n      }\n      default: {\n        if (type === EOF) {\n          res.push(currentStr.trim());\n          currentStr = '';\n        } else {\n          currentStr += val;\n        }\n      }\n    }\n  }\n  setCache(cacheKey, res);\n  return res;\n};\n\n/**\n * extract dashed-ident tokens\n * @param value - CSS value\n * @returns array of dashed-ident tokens\n */\nexport const extractDashedIdent = (value: string): string[] => {\n  if (!isString(value)) {\n    throw new TypeError(`${value} is not a string.`);\n  }\n  const strValue = value.trim();\n  const cacheKey: string = createCacheKey({\n    namespace: NAMESPACE,\n    name: 'extractDashedIdent',\n    value: strValue\n  });\n  const cachedResult = getCache(cacheKey);\n  if (cachedResult instanceof CacheItem) {\n    return cachedResult.item as string[];\n  }\n  const matches = strValue.match(REG_DASHED_IDENT);\n  const res = matches ? [...new Set(matches)] : [];\n  setCache(cacheKey, res);\n  return res;\n};\n\n/**\n * is color\n * @param value - CSS value\n * @param [opt] - options\n * @returns result\n */\nexport const isColor = (value: unknown, opt: Options = {}): boolean => {\n  if (!isString(value)) {\n    return false;\n  }\n  const str = value.toLowerCase().trim();\n  if (!str) {\n    return false;\n  }\n  if (/^[a-z]+$/.test(str)) {\n    return (\n      str === 'currentcolor' ||\n      str === 'transparent' ||\n      Object.hasOwn(NAMED_COLORS, str)\n    );\n  }\n  if (REG_COLOR.test(str) || REG_MIX.test(str)) {\n    return true;\n  }\n  if (REG_FN_COLOR.test(str)) {\n    const colorOpt = { ...opt, nullable: true };\n    if (!colorOpt.format) colorOpt.format = VAL_SPEC;\n    return !!resolveColor(str, colorOpt);\n  }\n  return false;\n};\n\n/**\n * round to specified precision\n * @param value - numeric value\n * @param bit - minimum bits\n * @returns rounded value\n */\nexport const roundToPrecision = (value: number, bit: number = 0): number => {\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`${value} is not a finite number.`);\n  }\n  if (!Number.isFinite(bit)) {\n    throw new TypeError(`${bit} is not a finite number.`);\n  }\n  if (bit < 0 || bit > HEX) {\n    throw new RangeError(`${bit} is not between 0 and ${HEX}.`);\n  }\n  if (bit === 0) {\n    return Math.round(value);\n  }\n  const precision = bit === HEX ? 6 : bit < DEC ? 4 : 5;\n  return parseFloat(value.toPrecision(precision));\n};\n\n/**\n * interpolate hue\n * @param hueA - hue value\n * @param hueB - hue value\n * @param arc - shorter | longer | increasing | decreasing\n * @returns result - [hueA, hueB]\n */\nexport const interpolateHue = (\n  hueA: number,\n  hueB: number,\n  arc: string = 'shorter'\n): [number, number] => {\n  if (!Number.isFinite(hueA)) {\n    throw new TypeError(`${hueA} is not a finite number.`);\n  }\n  if (!Number.isFinite(hueB)) {\n    throw new TypeError(`${hueB} is not a finite number.`);\n  }\n  let a = hueA;\n  let b = hueB;\n  switch (arc) {\n    case 'decreasing': {\n      if (b > a) {\n        a += DEG;\n      }\n      break;\n    }\n    case 'increasing': {\n      if (b < a) {\n        b += DEG;\n      }\n      break;\n    }\n    case 'longer': {\n      if (b > a && b < a + DEG_HALF) {\n        a += DEG;\n      } else if (b > a - DEG_HALF && b <= a) {\n        b += DEG;\n      }\n      break;\n    }\n    case 'shorter':\n    default: {\n      if (b > a + DEG_HALF) {\n        a += DEG;\n      } else if (b < a - DEG_HALF) {\n        b += DEG;\n      }\n    }\n  }\n  return [a, b];\n};\n\n/* absolute font size to pixel ratio */\nconst absoluteFontSize = new Map([\n  ['xx-small', 9 / 16],\n  ['x-small', 5 / 8],\n  ['small', 13 / 16],\n  ['medium', 1],\n  ['large', 9 / 8],\n  ['x-large', 3 / 2],\n  ['xx-large', 2],\n  ['xxx-large', 3]\n]);\n\n/* relative font size to pixel ratio */\nconst relativeFontSize = new Map([\n  ['smaller', 1 / 1.2],\n  ['larger', 1.2]\n]);\n\n/* absolute length to pixel ratio */\nconst absoluteLength = new Map([\n  ['cm', 96 / 2.54],\n  ['mm', 96 / 25.4],\n  ['q', 96 / 101.6],\n  ['in', 96],\n  ['pc', 16],\n  ['pt', 96 / 72],\n  ['px', 1]\n]);\n\n/* relative length to pixel ratio */\nconst relativeLength = new Map([\n  ['rcap', 1],\n  ['rch', 0.5],\n  ['rem', 1],\n  ['rex', 0.5],\n  ['ric', 1],\n  ['rlh', 1.2]\n]);\n\n/**\n * resolve length in pixels\n * @param value - value\n * @param unit - unit\n * @param [opt] - options\n * @returns pixelated value\n */\nexport const resolveLengthInPixels = (\n  value: number | string,\n  unit: string | undefined,\n  opt: Options = {}\n): number => {\n  const { dimension = {} } = opt;\n  const { callback, em, rem, vh, vw } = dimension as {\n    callback: (K: string) => number;\n    em: number;\n    rem: number;\n    vh: number;\n    vw: number;\n  };\n  if (isString(value)) {\n    const str = value.toLowerCase().trim();\n    const ratio = absoluteFontSize.get(str);\n    if (ratio !== undefined) {\n      return ratio * rem;\n    }\n    const relRatio = relativeFontSize.get(str);\n    if (relRatio !== undefined) {\n      return relRatio * em;\n    }\n    return Number.NaN;\n  }\n  if (Number.isFinite(value) && unit) {\n    const u = unit.toLowerCase();\n    if (Object.hasOwn(dimension, u)) {\n      return value * Number(dimension[u]);\n    }\n    if (typeof callback === 'function') {\n      return value * (callback(u) ?? Number.NaN);\n    }\n    const absRatio = absoluteLength.get(u);\n    if (absRatio !== undefined) {\n      return value * absRatio;\n    }\n    const relRatio = relativeLength.get(u);\n    if (relRatio !== undefined) {\n      return value * relRatio * rem;\n    }\n    const rUnitRatio = relativeLength.get(`r${u}`);\n    if (rUnitRatio !== undefined) {\n      return value * rUnitRatio * em;\n    }\n    switch (u) {\n      case 'vb':\n      case 'vi': {\n        return value * vw;\n      }\n      case 'vmax': {\n        return value * Math.max(vh, vw);\n      }\n      case 'vmin': {\n        return value * Math.min(vh, vw);\n      }\n      default:\n    }\n  }\n  // unsupported or invalid value\n  return Number.NaN;\n};\n\n/**\n * is absolute size or length\n * @param value - value\n * @param unit - unit\n * @returns result\n */\nexport const isAbsoluteSizeOrLength = (\n  value: number | string,\n  unit: string | undefined\n): boolean => {\n  if (isString(value)) {\n    return absoluteFontSize.has(value.toLowerCase().trim());\n  }\n  if (isString(unit)) {\n    return absoluteLength.has(unit.toLowerCase().trim());\n  }\n  return value === 0;\n};\n\n/**\n * is absolute font size\n * @param css - css\n * @returns result\n */\nexport const isAbsoluteFontSize = (css: unknown): boolean => {\n  if (!isString(css)) {\n    return false;\n  }\n  const str = css.trim();\n  if (isAbsoluteSizeOrLength(str, undefined)) {\n    return true;\n  }\n  const match = str.match(REG_DIMENSION);\n  return match\n    ? isAbsoluteSizeOrLength(Number(match[1]), match[2] || undefined)\n    : false;\n};\n"],"mappings":"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"}
\ No newline at end of file
diff --git a/node_modules/@asamuzakjp/css-color/package.json b/node_modules/@asamuzakjp/css-color/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..e8a0d753fd186aa1cb3fd7d234f7f959d3b7419a
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/package.json
@@ -0,0 +1,89 @@
+{
+  "name": "@asamuzakjp/css-color",
+  "description": "CSS color - Resolve and convert CSS colors.",
+  "author": "asamuzaK",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/asamuzaK/cssColor.git"
+  },
+  "homepage": "https://github.com/asamuzaK/cssColor#readme",
+  "bugs": {
+    "url": "https://github.com/asamuzaK/cssColor/issues"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "default": "./dist/esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@asamuzakjp/generational-cache": "^1.0.1",
+    "@csstools/css-calc": "^3.2.0",
+    "@csstools/css-color-parser": "^4.1.0",
+    "@csstools/css-parser-algorithms": "^4.0.0",
+    "@csstools/css-tokenizer": "^4.0.0"
+  },
+  "devDependencies": {
+    "@tanstack/vite-config": "^0.5.2",
+    "@types/node": "^25.6.0",
+    "@vitest/coverage-istanbul": "^4.1.4",
+    "esbuild": "^0.27.7",
+    "eslint": "^9.39.4",
+    "eslint-plugin-regexp": "^3.1.0",
+    "globals": "^17.5.0",
+    "knip": "^6.4.1",
+    "mitata": "^1.0.34",
+    "neostandard": "^0.13.0",
+    "prettier": "^3.8.3",
+    "publint": "^0.3.18",
+    "rimraf": "^6.1.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vite": "^8.0.8",
+    "vitest": "^4.1.4"
+  },
+  "packageManager": "pnpm@10.33.0",
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild",
+      "oxc-resolver",
+      "unrs-resolver"
+    ],
+    "overrides": {
+      "ajv": "^8.18.0",
+      "@eslint/eslintrc>ajv": "^6.14.0",
+      "eslint>ajv": "^6.14.0",
+      "brace-expansion": "^5.0.4",
+      "minimatch": "^3.1.5",
+      "@typescript-eslint/typescript-estree>minimatch": "^9.0.9",
+      "@vue/language-core>minimatch": "^9.0.9",
+      "eslint-plugin-import-x>minimatch": "^10.2.4",
+      "glob>minimatch": "^10.2.4",
+      "lodash@>=4.0.0 <=4.17.23": ">=4.18.0",
+      "lodash@<=4.17.23": ">=4.18.0"
+    }
+  },
+  "scripts": {
+    "bench:color": "npx tsx --expose-gc ./benchmark/bench-color.ts",
+    "build": "pnpm run clean && pnpm run test && pnpm run knip && vite build && pnpm run publint",
+    "clean": "rimraf ./coverage ./dist",
+    "knip": "knip",
+    "prettier": "prettier . --ignore-unknown --write",
+    "publint": "publint --strict",
+    "test": "pnpm run prettier && pnpm run --stream \"/^test:.*/\"",
+    "test:eslint": "eslint ./src ./test --fix",
+    "test:types": "tsc",
+    "test:unit": "vitest"
+  },
+  "engines": {
+    "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+  },
+  "version": "5.1.11"
+}
diff --git a/node_modules/@asamuzakjp/css-color/src/index.ts b/node_modules/@asamuzakjp/css-color/src/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ff2ab2d7259e30d37be09bbeb2bca01c55494d6d
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/index.ts
@@ -0,0 +1,34 @@
+/*!
+ * CSS color - Resolve, parse, convert CSS color.
+ * @license MIT
+ * @copyright asamuzaK (Kazz)
+ * @see {@link https://github.com/asamuzaK/cssColor/blob/main/LICENSE}
+ */
+
+import { cssCalc } from './js/css-calc';
+import { isGradient, resolveGradient } from './js/css-gradient';
+import { cssVar } from './js/css-var';
+import {
+  extractDashedIdent,
+  isAbsoluteFontSize,
+  isAbsoluteSizeOrLength,
+  isColor,
+  resolveLengthInPixels,
+  splitValue
+} from './js/util';
+
+export { convert } from './js/convert';
+export { resolve } from './js/resolve';
+/* utils */
+export const utils = {
+  cssCalc,
+  cssVar,
+  extractDashedIdent,
+  isAbsoluteFontSize,
+  isAbsoluteSizeOrLength,
+  isColor,
+  isGradient,
+  resolveGradient,
+  resolveLengthInPixels,
+  splitValue
+};
diff --git a/node_modules/@asamuzakjp/css-color/src/js/cache.ts b/node_modules/@asamuzakjp/css-color/src/js/cache.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4eb065d7a53c87b55d0b674613b0d4688133f7b7
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/cache.ts
@@ -0,0 +1,137 @@
+/**
+ * cache
+ */
+
+import { GenerationalCache } from '@asamuzakjp/generational-cache';
+import { Options } from './typedef';
+
+/* constants */
+const CACHE_SIZE = 2048;
+
+/**
+ * CacheItem
+ */
+export class CacheItem {
+  /* private */
+  #isNull: boolean;
+  #item: unknown;
+
+  constructor(item: unknown, isNull: boolean = false) {
+    this.#item = item;
+    this.#isNull = !!isNull;
+  }
+
+  get item() {
+    return this.#item;
+  }
+
+  get isNull() {
+    return this.#isNull;
+  }
+}
+
+/**
+ * NullObject
+ */
+export class NullObject extends CacheItem {
+  constructor() {
+    super(Symbol('null'), true);
+  }
+}
+
+/*
+ * generational cache instance
+ */
+export const genCache = new GenerationalCache<string, CacheItem>(CACHE_SIZE);
+
+/**
+ * shared null object
+ */
+const sharedNullObject = new NullObject();
+
+/**
+ * set cache
+ * @param key - cache key
+ * @param value - value to cache
+ * @returns void
+ */
+export const setCache = (key: string, value: unknown): void => {
+  if (!key) {
+    return;
+  }
+  if (value === null) {
+    genCache.set(key, sharedNullObject);
+  } else if (value instanceof CacheItem) {
+    genCache.set(key, value);
+  } else {
+    genCache.set(key, new CacheItem(value));
+  }
+};
+
+/**
+ * get cache
+ * @param key - cache key
+ * @returns cached item or false otherwise
+ */
+export const getCache = (key: string): CacheItem | false => {
+  if (!key) {
+    return false;
+  }
+  const item = genCache.get(key);
+  if (item !== undefined) {
+    return item as CacheItem;
+  }
+  return false;
+};
+
+/**
+ * helper function to sort object keys alphabetically
+ * @param obj - Object
+ * @returns stringified JSON
+ */
+const stringifySorted = (obj: Record<string, unknown>): string => {
+  const keys = Object.keys(obj);
+  if (keys.length === 0) {
+    return '';
+  }
+  keys.sort();
+  let result = '';
+  for (const key of keys) {
+    result += `${key}:${JSON.stringify(obj[key])};`;
+  }
+  return result;
+};
+
+/**
+ * create cache key
+ * @param keyData - key data
+ * @param [opt] - options
+ * @returns cache key
+ */
+export const createCacheKey = (
+  keyData: Record<string, string>,
+  opt: Options = {}
+): string => {
+  if (
+    !keyData ||
+    (opt.customProperty && typeof opt.customProperty.callback === 'function') ||
+    (opt.dimension && typeof opt.dimension.callback === 'function')
+  ) {
+    return '';
+  }
+  const namespace = keyData.namespace || '';
+  const name = keyData.name || '';
+  const value = keyData.value || '';
+  if (!namespace && !name && !value) {
+    return '';
+  }
+  const baseKey = `${namespace}:${name}:${value}`;
+  const optStr = `${opt.format || ''}|${opt.colorSpace || ''}|${opt.colorScheme || ''}|${opt.currentColor || ''}|${opt.d50 ? '1' : '0'}|${opt.nullable ? '1' : '0'}|${opt.preserveComment ? '1' : '0'}|${opt.delimiter || ''}`;
+  const customPropStr = opt.customProperty
+    ? stringifySorted(opt.customProperty as Record<string, unknown>)
+    : '';
+  const dimStr = opt.dimension
+    ? stringifySorted(opt.dimension as Record<string, unknown>)
+    : '';
+  return `${baseKey}::${optStr}::${customPropStr}::${dimStr}`;
+};
diff --git a/node_modules/@asamuzakjp/css-color/src/js/color.ts b/node_modules/@asamuzakjp/css-color/src/js/color.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d935eb26a5ab9fd7b1deccde3ebe9e3b8a5e67d1
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/color.ts
@@ -0,0 +1,3496 @@
+/**
+ * color
+ *
+ * Ref: CSS Color Module Level 4
+ *      Sample code for Color Conversions
+ *      https://w3c.github.io/csswg-drafts/css-color-4/#color-conversion-code
+ */
+
+import {
+  CacheItem,
+  NullObject,
+  createCacheKey,
+  getCache,
+  setCache
+} from './cache';
+import { isString } from './common';
+import { resolveColor } from './resolve';
+import { interpolateHue, roundToPrecision, splitValue } from './util';
+import {
+  ColorChannels,
+  ComputedColorChannels,
+  Options,
+  MatchedRegExp,
+  SpecifiedColorChannels,
+  StringColorChannels,
+  StringColorSpacedChannels
+} from './typedef';
+
+/* constants */
+import {
+  ANGLE,
+  CS_HUE_CAPT,
+  CS_MIX,
+  CS_RGB,
+  CS_XYZ,
+  FN_COLOR,
+  FN_LIGHT_DARK,
+  FN_MIX,
+  NONE,
+  NUM,
+  PCT,
+  SYN_COLOR_TYPE,
+  SYN_FN_COLOR,
+  SYN_HSL,
+  SYN_HSL_LV3,
+  SYN_LCH,
+  SYN_MIX,
+  SYN_MIX_CAPT,
+  SYN_MIX_PART,
+  SYN_MOD,
+  SYN_RGB_LV3,
+  VAL_COMP,
+  VAL_MIX,
+  VAL_SPEC
+} from './constant';
+const NAMESPACE = 'color';
+
+/* numeric constants */
+const PPTH = 0.001;
+const HALF = 0.5;
+const DUO = 2;
+const TRIA = 3;
+const QUAD = 4;
+const OCT = 8;
+const DEC = 10;
+const DOZ = 12;
+const HEX = 16;
+const SEXA = 60;
+const DEG_HALF = 180;
+const DEG = 360;
+const MAX_PCT = 100;
+const MAX_RGB = 255;
+const POW_SQR = 2;
+const POW_CUBE = 3;
+const POW_LINEAR = 2.4;
+const LINEAR_COEF = 12.92;
+const LINEAR_OFFSET = 0.055;
+const LAB_L = 116;
+const LAB_A = 500;
+const LAB_B = 200;
+const LAB_EPSILON = 216 / 24389;
+const LAB_KAPPA = 24389 / 27;
+
+/* type definitions */
+/**
+ * @type NumStrColorChannels - string or numeric color channels
+ */
+type NumStrColorChannels = [
+  x: number | string,
+  y: number | string,
+  z: number | string,
+  alpha: number | string
+];
+
+/**
+ * @type TriColorChannels - color channels without alpha
+ */
+type TriColorChannels = [x: number, y: number, z: number];
+
+/**
+ * @type ColorMatrix - color matrix
+ */
+type ColorMatrix = [
+  r1: TriColorChannels,
+  r2: TriColorChannels,
+  r3: TriColorChannels
+];
+
+/* white point */
+const D50: TriColorChannels = [
+  0.3457 / 0.3585,
+  1.0,
+  (1.0 - 0.3457 - 0.3585) / 0.3585
+];
+const MATRIX_D50_TO_D65: ColorMatrix = [
+  [0.955473421488075, -0.02309845494876471, 0.06325924320057072],
+  [-0.0283697093338637, 1.0099953980813041, 0.021041441191917323],
+  [0.012314014864481998, -0.020507649298898964, 1.330365926242124]
+];
+const MATRIX_D65_TO_D50: ColorMatrix = [
+  [1.0479297925449969, 0.022946870601609652, -0.05019226628920524],
+  [0.02962780877005599, 0.9904344267538799, -0.017073799063418826],
+  [-0.009243040646204504, 0.015055191490298152, 0.7518742814281371]
+];
+
+/* color space */
+const MATRIX_L_RGB_TO_XYZ: ColorMatrix = [
+  [506752 / 1228815, 87881 / 245763, 12673 / 70218],
+  [87098 / 409605, 175762 / 245763, 12673 / 175545],
+  [7918 / 409605, 87881 / 737289, 1001167 / 1053270]
+];
+const MATRIX_XYZ_TO_L_RGB: ColorMatrix = [
+  [12831 / 3959, -329 / 214, -1974 / 3959],
+  [-851781 / 878810, 1648619 / 878810, 36519 / 878810],
+  [705 / 12673, -2585 / 12673, 705 / 667]
+];
+const MATRIX_XYZ_TO_LMS: ColorMatrix = [
+  [0.819022437996703, 0.3619062600528904, -0.1288737815209879],
+  [0.0329836539323885, 0.9292868615863434, 0.0361446663506424],
+  [0.0481771893596242, 0.2642395317527308, 0.6335478284694309]
+];
+const MATRIX_LMS_TO_XYZ: ColorMatrix = [
+  [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
+  [-0.0405757452148008, 1.112286803280317, -0.0717110580655164],
+  [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816]
+];
+const MATRIX_OKLAB_TO_LMS: ColorMatrix = [
+  [1.0, 0.3963377773761749, 0.2158037573099136],
+  [1.0, -0.1055613458156586, -0.0638541728258133],
+  [1.0, -0.0894841775298119, -1.2914855480194092]
+];
+const MATRIX_LMS_TO_OKLAB: ColorMatrix = [
+  [0.210454268309314, 0.7936177747023054, -0.0040720430116193],
+  [1.9779985324311684, -2.4285922420485799, 0.450593709617411],
+  [0.0259040424655478, 0.7827717124575296, -0.8086757549230774]
+];
+const MATRIX_P3_TO_XYZ: ColorMatrix = [
+  [608311 / 1250200, 189793 / 714400, 198249 / 1000160],
+  [35783 / 156275, 247089 / 357200, 198249 / 2500400],
+  [0 / 1, 32229 / 714400, 5220557 / 5000800]
+];
+const MATRIX_REC2020_TO_XYZ: ColorMatrix = [
+  [63426534 / 99577255, 20160776 / 139408157, 47086771 / 278816314],
+  [26158966 / 99577255, 472592308 / 697040785, 8267143 / 139408157],
+  [0 / 1, 19567812 / 697040785, 295819943 / 278816314]
+];
+const MATRIX_A98_TO_XYZ: ColorMatrix = [
+  [573536 / 994567, 263643 / 1420810, 187206 / 994567],
+  [591459 / 1989134, 6239551 / 9945670, 374412 / 4972835],
+  [53769 / 1989134, 351524 / 4972835, 4929758 / 4972835]
+];
+const MATRIX_PROPHOTO_TO_XYZ_D50: ColorMatrix = [
+  [0.7977666449006423, 0.13518129740053308, 0.0313477341283922],
+  [0.2880748288194013, 0.711835234241873, 0.00008993693872564],
+  [0.0, 0.0, 0.8251046025104602]
+];
+
+/* regexp */
+const REG_COLOR = new RegExp(`^(?:${SYN_COLOR_TYPE})$`);
+const REG_CS_HUE = new RegExp(`^${CS_HUE_CAPT}$`);
+const REG_CS_XYZ = /^xyz(?:-d(?:50|65))?$/;
+const REG_CURRENT = /^currentColor$/i;
+const REG_FN_COLOR = new RegExp(`^color\\(\\s*(${SYN_FN_COLOR})\\s*\\)$`);
+const REG_HSL = new RegExp(`^hsla?\\(\\s*(${SYN_HSL}|${SYN_HSL_LV3})\\s*\\)$`);
+const REG_HWB = new RegExp(`^hwb\\(\\s*(${SYN_HSL})\\s*\\)$`);
+const REG_LAB = new RegExp(`^lab\\(\\s*(${SYN_MOD})\\s*\\)$`);
+const REG_LCH = new RegExp(`^lch\\(\\s*(${SYN_LCH})\\s*\\)$`);
+const REG_MIX = new RegExp(`^${SYN_MIX}$`);
+const REG_MIX_CAPT = new RegExp(`^${SYN_MIX_CAPT}$`);
+const REG_MIX_NEST = new RegExp(`${SYN_MIX}`, 'g');
+const REG_OKLAB = new RegExp(`^oklab\\(\\s*(${SYN_MOD})\\s*\\)$`);
+const REG_OKLCH = new RegExp(`^oklch\\(\\s*(${SYN_LCH})\\s*\\)$`);
+const REG_SPEC = /^(?:specifi|comput)edValue$/;
+const REG_ANGLE_TO_DEG = new RegExp(`^(${NUM})(${ANGLE})?$`);
+const REG_PARSE_RGB = new RegExp(
+  `^rgba?\\(\\s*(${SYN_MOD}|${SYN_RGB_LV3})\\s*\\)$`
+);
+const REG_MIX_CS_RGB_XYZ = new RegExp(`^(?:${CS_RGB}|${CS_XYZ})$`);
+const REG_MIX_IN_CS = new RegExp(`in\\s+(${CS_MIX})`);
+const REG_MIX_START = new RegExp(`^color-mix\\(\\s*in\\s+(${CS_MIX})\\s*,`);
+const REG_MIX_COLOR_PART = new RegExp(`^(${SYN_COLOR_TYPE})(?:\\s+(${PCT}))?$`);
+
+/**
+ * named colors
+ */
+export const NAMED_COLORS = {
+  aliceblue: [0xf0, 0xf8, 0xff],
+  antiquewhite: [0xfa, 0xeb, 0xd7],
+  aqua: [0x00, 0xff, 0xff],
+  aquamarine: [0x7f, 0xff, 0xd4],
+  azure: [0xf0, 0xff, 0xff],
+  beige: [0xf5, 0xf5, 0xdc],
+  bisque: [0xff, 0xe4, 0xc4],
+  black: [0x00, 0x00, 0x00],
+  blanchedalmond: [0xff, 0xeb, 0xcd],
+  blue: [0x00, 0x00, 0xff],
+  blueviolet: [0x8a, 0x2b, 0xe2],
+  brown: [0xa5, 0x2a, 0x2a],
+  burlywood: [0xde, 0xb8, 0x87],
+  cadetblue: [0x5f, 0x9e, 0xa0],
+  chartreuse: [0x7f, 0xff, 0x00],
+  chocolate: [0xd2, 0x69, 0x1e],
+  coral: [0xff, 0x7f, 0x50],
+  cornflowerblue: [0x64, 0x95, 0xed],
+  cornsilk: [0xff, 0xf8, 0xdc],
+  crimson: [0xdc, 0x14, 0x3c],
+  cyan: [0x00, 0xff, 0xff],
+  darkblue: [0x00, 0x00, 0x8b],
+  darkcyan: [0x00, 0x8b, 0x8b],
+  darkgoldenrod: [0xb8, 0x86, 0x0b],
+  darkgray: [0xa9, 0xa9, 0xa9],
+  darkgreen: [0x00, 0x64, 0x00],
+  darkgrey: [0xa9, 0xa9, 0xa9],
+  darkkhaki: [0xbd, 0xb7, 0x6b],
+  darkmagenta: [0x8b, 0x00, 0x8b],
+  darkolivegreen: [0x55, 0x6b, 0x2f],
+  darkorange: [0xff, 0x8c, 0x00],
+  darkorchid: [0x99, 0x32, 0xcc],
+  darkred: [0x8b, 0x00, 0x00],
+  darksalmon: [0xe9, 0x96, 0x7a],
+  darkseagreen: [0x8f, 0xbc, 0x8f],
+  darkslateblue: [0x48, 0x3d, 0x8b],
+  darkslategray: [0x2f, 0x4f, 0x4f],
+  darkslategrey: [0x2f, 0x4f, 0x4f],
+  darkturquoise: [0x00, 0xce, 0xd1],
+  darkviolet: [0x94, 0x00, 0xd3],
+  deeppink: [0xff, 0x14, 0x93],
+  deepskyblue: [0x00, 0xbf, 0xff],
+  dimgray: [0x69, 0x69, 0x69],
+  dimgrey: [0x69, 0x69, 0x69],
+  dodgerblue: [0x1e, 0x90, 0xff],
+  firebrick: [0xb2, 0x22, 0x22],
+  floralwhite: [0xff, 0xfa, 0xf0],
+  forestgreen: [0x22, 0x8b, 0x22],
+  fuchsia: [0xff, 0x00, 0xff],
+  gainsboro: [0xdc, 0xdc, 0xdc],
+  ghostwhite: [0xf8, 0xf8, 0xff],
+  gold: [0xff, 0xd7, 0x00],
+  goldenrod: [0xda, 0xa5, 0x20],
+  gray: [0x80, 0x80, 0x80],
+  green: [0x00, 0x80, 0x00],
+  greenyellow: [0xad, 0xff, 0x2f],
+  grey: [0x80, 0x80, 0x80],
+  honeydew: [0xf0, 0xff, 0xf0],
+  hotpink: [0xff, 0x69, 0xb4],
+  indianred: [0xcd, 0x5c, 0x5c],
+  indigo: [0x4b, 0x00, 0x82],
+  ivory: [0xff, 0xff, 0xf0],
+  khaki: [0xf0, 0xe6, 0x8c],
+  lavender: [0xe6, 0xe6, 0xfa],
+  lavenderblush: [0xff, 0xf0, 0xf5],
+  lawngreen: [0x7c, 0xfc, 0x00],
+  lemonchiffon: [0xff, 0xfa, 0xcd],
+  lightblue: [0xad, 0xd8, 0xe6],
+  lightcoral: [0xf0, 0x80, 0x80],
+  lightcyan: [0xe0, 0xff, 0xff],
+  lightgoldenrodyellow: [0xfa, 0xfa, 0xd2],
+  lightgray: [0xd3, 0xd3, 0xd3],
+  lightgreen: [0x90, 0xee, 0x90],
+  lightgrey: [0xd3, 0xd3, 0xd3],
+  lightpink: [0xff, 0xb6, 0xc1],
+  lightsalmon: [0xff, 0xa0, 0x7a],
+  lightseagreen: [0x20, 0xb2, 0xaa],
+  lightskyblue: [0x87, 0xce, 0xfa],
+  lightslategray: [0x77, 0x88, 0x99],
+  lightslategrey: [0x77, 0x88, 0x99],
+  lightsteelblue: [0xb0, 0xc4, 0xde],
+  lightyellow: [0xff, 0xff, 0xe0],
+  lime: [0x00, 0xff, 0x00],
+  limegreen: [0x32, 0xcd, 0x32],
+  linen: [0xfa, 0xf0, 0xe6],
+  magenta: [0xff, 0x00, 0xff],
+  maroon: [0x80, 0x00, 0x00],
+  mediumaquamarine: [0x66, 0xcd, 0xaa],
+  mediumblue: [0x00, 0x00, 0xcd],
+  mediumorchid: [0xba, 0x55, 0xd3],
+  mediumpurple: [0x93, 0x70, 0xdb],
+  mediumseagreen: [0x3c, 0xb3, 0x71],
+  mediumslateblue: [0x7b, 0x68, 0xee],
+  mediumspringgreen: [0x00, 0xfa, 0x9a],
+  mediumturquoise: [0x48, 0xd1, 0xcc],
+  mediumvioletred: [0xc7, 0x15, 0x85],
+  midnightblue: [0x19, 0x19, 0x70],
+  mintcream: [0xf5, 0xff, 0xfa],
+  mistyrose: [0xff, 0xe4, 0xe1],
+  moccasin: [0xff, 0xe4, 0xb5],
+  navajowhite: [0xff, 0xde, 0xad],
+  navy: [0x00, 0x00, 0x80],
+  oldlace: [0xfd, 0xf5, 0xe6],
+  olive: [0x80, 0x80, 0x00],
+  olivedrab: [0x6b, 0x8e, 0x23],
+  orange: [0xff, 0xa5, 0x00],
+  orangered: [0xff, 0x45, 0x00],
+  orchid: [0xda, 0x70, 0xd6],
+  palegoldenrod: [0xee, 0xe8, 0xaa],
+  palegreen: [0x98, 0xfb, 0x98],
+  paleturquoise: [0xaf, 0xee, 0xee],
+  palevioletred: [0xdb, 0x70, 0x93],
+  papayawhip: [0xff, 0xef, 0xd5],
+  peachpuff: [0xff, 0xda, 0xb9],
+  peru: [0xcd, 0x85, 0x3f],
+  pink: [0xff, 0xc0, 0xcb],
+  plum: [0xdd, 0xa0, 0xdd],
+  powderblue: [0xb0, 0xe0, 0xe6],
+  purple: [0x80, 0x00, 0x80],
+  rebeccapurple: [0x66, 0x33, 0x99],
+  red: [0xff, 0x00, 0x00],
+  rosybrown: [0xbc, 0x8f, 0x8f],
+  royalblue: [0x41, 0x69, 0xe1],
+  saddlebrown: [0x8b, 0x45, 0x13],
+  salmon: [0xfa, 0x80, 0x72],
+  sandybrown: [0xf4, 0xa4, 0x60],
+  seagreen: [0x2e, 0x8b, 0x57],
+  seashell: [0xff, 0xf5, 0xee],
+  sienna: [0xa0, 0x52, 0x2d],
+  silver: [0xc0, 0xc0, 0xc0],
+  skyblue: [0x87, 0xce, 0xeb],
+  slateblue: [0x6a, 0x5a, 0xcd],
+  slategray: [0x70, 0x80, 0x90],
+  slategrey: [0x70, 0x80, 0x90],
+  snow: [0xff, 0xfa, 0xfa],
+  springgreen: [0x00, 0xff, 0x7f],
+  steelblue: [0x46, 0x82, 0xb4],
+  tan: [0xd2, 0xb4, 0x8c],
+  teal: [0x00, 0x80, 0x80],
+  thistle: [0xd8, 0xbf, 0xd8],
+  tomato: [0xff, 0x63, 0x47],
+  turquoise: [0x40, 0xe0, 0xd0],
+  violet: [0xee, 0x82, 0xee],
+  wheat: [0xf5, 0xde, 0xb3],
+  white: [0xff, 0xff, 0xff],
+  whitesmoke: [0xf5, 0xf5, 0xf5],
+  yellow: [0xff, 0xff, 0x00],
+  yellowgreen: [0x9a, 0xcd, 0x32]
+} as const satisfies {
+  [key: string]: TriColorChannels;
+};
+
+/**
+ * cache invalid color value
+ * @param key - cache key
+ * @param nullable - is nullable
+ * @returns cached value
+ */
+export const cacheInvalidColorValue = (
+  cacheKey: string,
+  format: string,
+  nullable: boolean = false
+): SpecifiedColorChannels | string | NullObject => {
+  if (format === VAL_SPEC) {
+    const res = '';
+    setCache(cacheKey, res);
+    return res;
+  }
+  if (nullable) {
+    setCache(cacheKey, null);
+    return new NullObject();
+  }
+  const res: SpecifiedColorChannels = ['rgb', 0, 0, 0, 0];
+  setCache(cacheKey, res);
+  return res;
+};
+
+/**
+ * resolve invalid color value
+ * @param format - output format
+ * @param nullable - is nullable
+ * @returns resolved value
+ */
+export const resolveInvalidColorValue = (
+  format: string,
+  nullable: boolean = false
+): SpecifiedColorChannels | string | NullObject => {
+  switch (format) {
+    case 'hsl':
+    case 'hwb':
+    case VAL_MIX: {
+      return new NullObject();
+    }
+    case VAL_SPEC: {
+      return '';
+    }
+    default: {
+      if (nullable) {
+        return new NullObject();
+      }
+      return ['rgb', 0, 0, 0, 0] as SpecifiedColorChannels;
+    }
+  }
+};
+
+/**
+ * validate color components
+ * @param arr - color components
+ * @param [opt] - options
+ * @param [opt.alpha] - alpha channel
+ * @param [opt.minLength] - min length
+ * @param [opt.maxLength] - max length
+ * @param [opt.minRange] - min range
+ * @param [opt.maxRange] - max range
+ * @param [opt.validateRange] - validate range
+ * @returns result - validated color components
+ */
+export const validateColorComponents = (
+  arr: ColorChannels | TriColorChannels,
+  opt: {
+    alpha?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    minRange?: number;
+    maxRange?: number;
+    validateRange?: boolean;
+  } = {}
+): ColorChannels | TriColorChannels => {
+  if (!Array.isArray(arr)) {
+    throw new TypeError(`${arr} is not an array.`);
+  }
+  const {
+    alpha = false,
+    minLength = TRIA,
+    maxLength = QUAD,
+    minRange = 0,
+    maxRange = 1,
+    validateRange = true
+  } = opt;
+  if (!Number.isFinite(minLength)) {
+    throw new TypeError(`${minLength} is not a number.`);
+  }
+  if (!Number.isFinite(maxLength)) {
+    throw new TypeError(`${maxLength} is not a number.`);
+  }
+  if (!Number.isFinite(minRange)) {
+    throw new TypeError(`${minRange} is not a number.`);
+  }
+  if (!Number.isFinite(maxRange)) {
+    throw new TypeError(`${maxRange} is not a number.`);
+  }
+  const l = arr.length;
+  if (l < minLength || l > maxLength) {
+    throw new Error(`Unexpected array length ${l}.`);
+  }
+  let i = 0;
+  while (i < l) {
+    const v = arr[i] as number;
+    if (!Number.isFinite(v)) {
+      throw new TypeError(`${v} is not a number.`);
+    } else if (i < TRIA && validateRange && (v < minRange || v > maxRange)) {
+      throw new RangeError(`${v} is not between ${minRange} and ${maxRange}.`);
+    } else if (i === TRIA && (v < 0 || v > 1)) {
+      throw new RangeError(`${v} is not between 0 and 1.`);
+    }
+    i++;
+  }
+  if (alpha && l === TRIA) {
+    arr.push(1);
+  }
+  return arr;
+};
+
+/**
+ * transform matrix
+ * @param mtx - 3 * 3 matrix
+ * @param vct - vector
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [p1, p2, p3]
+ */
+export const transformMatrix = (
+  mtx: ColorMatrix,
+  vct: TriColorChannels,
+  skip: boolean = false
+): TriColorChannels => {
+  if (!Array.isArray(mtx)) {
+    throw new TypeError(`${mtx} is not an array.`);
+  } else if (mtx.length !== TRIA) {
+    throw new Error(`Unexpected array length ${mtx.length}.`);
+  } else if (!skip) {
+    for (let i of mtx) {
+      i = validateColorComponents(i as TriColorChannels, {
+        maxLength: TRIA,
+        validateRange: false
+      }) as TriColorChannels;
+    }
+  }
+  const [[r1c1, r1c2, r1c3], [r2c1, r2c2, r2c3], [r3c1, r3c2, r3c3]] = mtx;
+  let v1, v2, v3;
+  if (skip) {
+    [v1, v2, v3] = vct;
+  } else {
+    [v1, v2, v3] = validateColorComponents(vct, {
+      maxLength: TRIA,
+      validateRange: false
+    });
+  }
+  const p1 = r1c1 * v1 + r1c2 * v2 + r1c3 * v3;
+  const p2 = r2c1 * v1 + r2c2 * v2 + r2c3 * v3;
+  const p3 = r3c1 * v1 + r3c2 * v2 + r3c3 * v3;
+  return [p1, p2, p3];
+};
+
+/**
+ * normalize color components
+ * @param colorA - color components [v1, v2, v3, v4]
+ * @param colorB - color components [v1, v2, v3, v4]
+ * @param [skip] - skip validate
+ * @returns result - [colorA, colorB]
+ */
+export const normalizeColorComponents = (
+  colorA: [number | string, number | string, number | string, number | string],
+  colorB: [number | string, number | string, number | string, number | string],
+  skip: boolean = false
+): [ColorChannels, ColorChannels] => {
+  if (!Array.isArray(colorA)) {
+    throw new TypeError(`${colorA} is not an array.`);
+  } else if (colorA.length !== QUAD) {
+    throw new Error(`Unexpected array length ${colorA.length}.`);
+  }
+  if (!Array.isArray(colorB)) {
+    throw new TypeError(`${colorB} is not an array.`);
+  } else if (colorB.length !== QUAD) {
+    throw new Error(`Unexpected array length ${colorB.length}.`);
+  }
+  let i = 0;
+  while (i < QUAD) {
+    if (colorA[i] === NONE && colorB[i] === NONE) {
+      colorA[i] = 0;
+      colorB[i] = 0;
+    } else if (colorA[i] === NONE) {
+      colorA[i] = colorB[i] as number;
+    } else if (colorB[i] === NONE) {
+      colorB[i] = colorA[i] as number;
+    }
+    i++;
+  }
+  if (skip) {
+    return [colorA as ColorChannels, colorB as ColorChannels];
+  }
+  const validatedColorA = validateColorComponents(colorA as ColorChannels, {
+    minLength: QUAD,
+    validateRange: false
+  });
+  const validatedColorB = validateColorComponents(colorB as ColorChannels, {
+    minLength: QUAD,
+    validateRange: false
+  });
+  return [validatedColorA as ColorChannels, validatedColorB as ColorChannels];
+};
+
+/**
+ * number to hex string
+ * @param value - numeric value
+ * @returns hex string
+ */
+export const numberToHexString = (value: number): string => {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`${value} is not a number.`);
+  } else {
+    value = Math.round(value);
+    if (value < 0 || value > MAX_RGB) {
+      throw new RangeError(`${value} is not between 0 and ${MAX_RGB}.`);
+    }
+  }
+  let hex = value.toString(HEX);
+  if (hex.length === 1) {
+    hex = `0${hex}`;
+  }
+  return hex;
+};
+
+/**
+ * angle to deg
+ * @param angle
+ * @returns deg: 0..360
+ */
+export const angleToDeg = (angle: string): number => {
+  if (isString(angle)) {
+    angle = angle.trim();
+  } else {
+    throw new TypeError(`${angle} is not a string.`);
+  }
+  const GRAD = DEG / 400;
+  const RAD = DEG / (Math.PI * DUO);
+  if (!REG_ANGLE_TO_DEG.test(angle)) {
+    throw new SyntaxError(`Invalid property value: ${angle}`);
+  }
+  const [, value, unit] = angle.match(REG_ANGLE_TO_DEG) as MatchedRegExp;
+  let deg;
+  switch (unit) {
+    case 'grad':
+      deg = parseFloat(value) * GRAD;
+      break;
+    case 'rad':
+      deg = parseFloat(value) * RAD;
+      break;
+    case 'turn':
+      deg = parseFloat(value) * DEG;
+      break;
+    default:
+      deg = parseFloat(value);
+  }
+  deg %= DEG;
+  if (deg < 0) {
+    deg += DEG;
+  } else if (Object.is(deg, -0)) {
+    deg = 0;
+  }
+  return deg;
+};
+
+/**
+ * parse alpha
+ * @param [alpha] - alpha value
+ * @returns alpha: 0..1
+ */
+export const parseAlpha = (alpha: string = ''): number => {
+  if (isString(alpha)) {
+    alpha = alpha.trim();
+    if (!alpha) {
+      alpha = '1';
+    } else if (alpha === NONE) {
+      alpha = '0';
+    } else {
+      let a;
+      if (alpha.endsWith('%')) {
+        a = parseFloat(alpha) / MAX_PCT;
+      } else {
+        a = parseFloat(alpha);
+      }
+      if (!Number.isFinite(a)) {
+        throw new TypeError(`${a} is not a finite number.`);
+      }
+      if (a < PPTH) {
+        alpha = '0';
+      } else if (a > 1) {
+        alpha = '1';
+      } else {
+        alpha = a.toFixed(TRIA);
+      }
+    }
+  } else {
+    alpha = '1';
+  }
+  return parseFloat(alpha);
+};
+
+/**
+ * parse hex alpha
+ * @param value - alpha value in hex string
+ * @returns alpha: 0..1
+ */
+export const parseHexAlpha = (value: string): number => {
+  if (isString(value)) {
+    if (value === '') {
+      throw new SyntaxError('Invalid property value: (empty string)');
+    }
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  let alpha = parseInt(value, HEX);
+  if (alpha <= 0) {
+    return 0;
+  }
+  if (alpha >= MAX_RGB) {
+    return 1;
+  }
+  const alphaMap = new Map();
+  for (let i = 1; i < MAX_PCT; i++) {
+    alphaMap.set(Math.round((i * MAX_RGB) / MAX_PCT), i);
+  }
+  if (alphaMap.has(alpha)) {
+    alpha = alphaMap.get(alpha) / MAX_PCT;
+  } else {
+    alpha = Math.round(alpha / MAX_RGB / PPTH) * PPTH;
+  }
+  return parseFloat(alpha.toFixed(TRIA));
+};
+
+/**
+ * transform rgb to linear rgb
+ * @param rgb - [r, g, b] r|g|b: 0..255
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [r, g, b] r|g|b: 0..1
+ */
+export const transformRgbToLinearRgb = (
+  rgb: TriColorChannels,
+  skip: boolean = false
+): TriColorChannels => {
+  let rr, gg, bb;
+  if (skip) {
+    [rr, gg, bb] = rgb;
+  } else {
+    [rr, gg, bb] = validateColorComponents(rgb, {
+      maxLength: TRIA,
+      maxRange: MAX_RGB
+    });
+  }
+  let r = rr / MAX_RGB;
+  let g = gg / MAX_RGB;
+  let b = bb / MAX_RGB;
+  const COND_POW = 0.04045;
+  if (r > COND_POW) {
+    r = Math.pow((r + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
+  } else {
+    r /= LINEAR_COEF;
+  }
+  if (g > COND_POW) {
+    g = Math.pow((g + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
+  } else {
+    g /= LINEAR_COEF;
+  }
+  if (b > COND_POW) {
+    b = Math.pow((b + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
+  } else {
+    b /= LINEAR_COEF;
+  }
+  return [r, g, b];
+};
+
+/**
+ * transform rgb to xyz
+ * @param rgb - [r, g, b] r|g|b: 0..255
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [x, y, z]
+ */
+export const transformRgbToXyz = (
+  rgb: TriColorChannels,
+  skip: boolean = false
+): TriColorChannels => {
+  if (!skip) {
+    rgb = validateColorComponents(rgb, {
+      maxLength: TRIA,
+      maxRange: MAX_RGB
+    }) as TriColorChannels;
+  }
+  rgb = transformRgbToLinearRgb(rgb, true);
+  const xyz = transformMatrix(MATRIX_L_RGB_TO_XYZ, rgb, true);
+  return xyz;
+};
+
+/**
+ * transform rgb to xyz-d50
+ * @param rgb - [r, g, b] r|g|b: 0..255 alpha: 0..1
+ * @returns TriColorChannels - [x, y, z]
+ */
+export const transformRgbToXyzD50 = (
+  rgb: TriColorChannels
+): TriColorChannels => {
+  let xyz = transformRgbToXyz(rgb);
+  xyz = transformMatrix(MATRIX_D65_TO_D50, xyz, true);
+  return xyz;
+};
+
+/**
+ * transform linear rgb to rgb
+ * @param rgb - [r, g, b] r|g|b: 0..1
+ * @param [round] - round result
+ * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
+ */
+export const transformLinearRgbToRgb = (
+  rgb: TriColorChannels,
+  round: boolean = false
+): TriColorChannels => {
+  let [r, g, b] = validateColorComponents(rgb, {
+    maxLength: TRIA
+  });
+  const COND_POW = 809 / 258400;
+  if (r > COND_POW) {
+    r = Math.pow(r, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
+  } else {
+    r *= LINEAR_COEF;
+  }
+  r *= MAX_RGB;
+  if (g > COND_POW) {
+    g = Math.pow(g, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
+  } else {
+    g *= LINEAR_COEF;
+  }
+  g *= MAX_RGB;
+  if (b > COND_POW) {
+    b = Math.pow(b, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
+  } else {
+    b *= LINEAR_COEF;
+  }
+  b *= MAX_RGB;
+  return [
+    round ? Math.round(r) : r,
+    round ? Math.round(g) : g,
+    round ? Math.round(b) : b
+  ];
+};
+
+/**
+ * transform xyz to rgb
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
+ */
+export const transformXyzToRgb = (
+  xyz: TriColorChannels,
+  skip: boolean = false
+): TriColorChannels => {
+  if (!skip) {
+    xyz = validateColorComponents(xyz, {
+      maxLength: TRIA,
+      validateRange: false
+    }) as TriColorChannels;
+  }
+  let [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, xyz, true);
+  [r, g, b] = transformLinearRgbToRgb(
+    [
+      Math.min(Math.max(r, 0), 1),
+      Math.min(Math.max(g, 0), 1),
+      Math.min(Math.max(b, 0), 1)
+    ],
+    true
+  );
+  return [r, g, b];
+};
+
+/**
+ * transform xyz to xyz-d50
+ * @param xyz - [x, y, z]
+ * @returns TriColorChannels - [x, y, z]
+ */
+export const transformXyzToXyzD50 = (
+  xyz: TriColorChannels
+): TriColorChannels => {
+  xyz = validateColorComponents(xyz, {
+    maxLength: TRIA,
+    validateRange: false
+  }) as TriColorChannels;
+  xyz = transformMatrix(MATRIX_D65_TO_D50, xyz, true);
+  return xyz;
+};
+
+/**
+ * transform xyz to hsl
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [h, s, l]
+ */
+export const transformXyzToHsl = (
+  xyz: TriColorChannels,
+  skip: boolean = false
+): TriColorChannels => {
+  const [rr, gg, bb] = transformXyzToRgb(xyz, skip);
+  const r = rr / MAX_RGB;
+  const g = gg / MAX_RGB;
+  const b = bb / MAX_RGB;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const d = max - min;
+  const l = (max + min) * HALF * MAX_PCT;
+  let h, s;
+  if (Math.round(l) === 0 || Math.round(l) === MAX_PCT) {
+    h = 0;
+    s = 0;
+  } else {
+    s = (d / (1 - Math.abs(max + min - 1))) * MAX_PCT;
+    if (s === 0) {
+      h = 0;
+    } else {
+      switch (max) {
+        case r:
+          h = (g - b) / d;
+          break;
+        case g:
+          h = (b - r) / d + DUO;
+          break;
+        case b:
+        default:
+          h = (r - g) / d + QUAD;
+          break;
+      }
+      h = (h * SEXA) % DEG;
+      if (h < 0) {
+        h += DEG;
+      }
+    }
+  }
+  return [h, s, l];
+};
+
+/**
+ * transform xyz to hwb
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [h, w, b]
+ */
+export const transformXyzToHwb = (
+  xyz: TriColorChannels,
+  skip: boolean = false
+): TriColorChannels => {
+  const [r, g, b] = transformXyzToRgb(xyz, skip);
+  const wh = Math.min(r, g, b) / MAX_RGB;
+  const bk = 1 - Math.max(r, g, b) / MAX_RGB;
+  let h;
+  if (wh + bk === 1) {
+    h = 0;
+  } else {
+    [h] = transformXyzToHsl(xyz);
+  }
+  return [h, wh * MAX_PCT, bk * MAX_PCT];
+};
+
+/**
+ * transform xyz to oklab
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [l, a, b]
+ */
+export const transformXyzToOklab = (
+  xyz: TriColorChannels,
+  skip: boolean = false
+): TriColorChannels => {
+  if (!skip) {
+    xyz = validateColorComponents(xyz, {
+      maxLength: TRIA,
+      validateRange: false
+    }) as TriColorChannels;
+  }
+  const lms = transformMatrix(MATRIX_XYZ_TO_LMS, xyz, true);
+  const xyzLms = lms.map(c => Math.cbrt(c)) as TriColorChannels;
+  let [l, a, b] = transformMatrix(MATRIX_LMS_TO_OKLAB, xyzLms, true);
+  l = Math.min(Math.max(l, 0), 1);
+  const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);
+  if (lPct === 0 || lPct === MAX_PCT) {
+    a = 0;
+    b = 0;
+  }
+  return [l, a, b];
+};
+
+/**
+ * transform xyz to oklch
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [l, c, h]
+ */
+export const transformXyzToOklch = (
+  xyz: TriColorChannels,
+  skip: boolean = false
+): TriColorChannels => {
+  const [l, a, b] = transformXyzToOklab(xyz, skip);
+  let c, h;
+  const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);
+  if (lPct === 0 || lPct === MAX_PCT) {
+    c = 0;
+    h = 0;
+  } else {
+    c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);
+    if (parseFloat(c.toFixed(QUAD)) === 0) {
+      h = 0;
+    } else {
+      h = (Math.atan2(b, a) * DEG_HALF) / Math.PI;
+      if (h < 0) {
+        h += DEG;
+      }
+    }
+  }
+  return [l, c, h];
+};
+
+/**
+ * transform xyz D50 to rgb
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
+ */
+export const transformXyzD50ToRgb = (
+  xyz: TriColorChannels,
+  skip: boolean = false
+): TriColorChannels => {
+  if (!skip) {
+    xyz = validateColorComponents(xyz, {
+      maxLength: TRIA,
+      validateRange: false
+    }) as TriColorChannels;
+  }
+  const xyzD65 = transformMatrix(MATRIX_D50_TO_D65, xyz, true);
+  const rgb = transformXyzToRgb(xyzD65, true);
+  return rgb;
+};
+
+/**
+ * transform xyz-d50 to lab
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [l, a, b]
+ */
+export const transformXyzD50ToLab = (
+  xyz: TriColorChannels,
+  skip: boolean = false
+): TriColorChannels => {
+  if (!skip) {
+    xyz = validateColorComponents(xyz, {
+      maxLength: TRIA,
+      validateRange: false
+    }) as TriColorChannels;
+  }
+  const xyzD50 = xyz.map((val, i) => val / (D50[i] as number));
+  const [f0, f1, f2] = xyzD50.map(val =>
+    val > LAB_EPSILON ? Math.cbrt(val) : (val * LAB_KAPPA + HEX) / LAB_L
+  ) as TriColorChannels;
+  const l = Math.min(Math.max(LAB_L * f1 - HEX, 0), MAX_PCT);
+  let a, b;
+  if (l === 0 || l === MAX_PCT) {
+    a = 0;
+    b = 0;
+  } else {
+    a = (f0 - f1) * LAB_A;
+    b = (f1 - f2) * LAB_B;
+  }
+  return [l, a, b];
+};
+
+/**
+ * transform xyz-d50 to lch
+ * @param xyz - [x, y, z]
+ * @param [skip] - skip validate
+ * @returns TriColorChannels - [l, c, h]
+ */
+export const transformXyzD50ToLch = (
+  xyz: TriColorChannels,
+  skip: boolean = false
+): TriColorChannels => {
+  const [l, a, b] = transformXyzD50ToLab(xyz, skip);
+  let c, h;
+  if (l === 0 || l === MAX_PCT) {
+    c = 0;
+    h = 0;
+  } else {
+    c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);
+    h = (Math.atan2(b, a) * DEG_HALF) / Math.PI;
+    if (h < 0) {
+      h += DEG;
+    }
+  }
+  return [l, c, h];
+};
+
+/**
+ * convert rgb to hex color
+ * @param rgb - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
+ * @returns hex color
+ */
+export const convertRgbToHex = (rgb: ColorChannels): string => {
+  const [r, g, b, alpha] = validateColorComponents(rgb, {
+    alpha: true,
+    maxRange: MAX_RGB
+  }) as ColorChannels;
+  const rr = numberToHexString(r);
+  const gg = numberToHexString(g);
+  const bb = numberToHexString(b);
+  const aa = numberToHexString(alpha * MAX_RGB);
+  let hex;
+  if (aa === 'ff') {
+    hex = `#${rr}${gg}${bb}`;
+  } else {
+    hex = `#${rr}${gg}${bb}${aa}`;
+  }
+  return hex;
+};
+
+/**
+ * convert linear rgb to hex color
+ * @param rgb - [r, g, b, alpha] r|g|b|alpha: 0..1
+ * @param [skip] - skip validate
+ * @returns hex color
+ */
+export const convertLinearRgbToHex = (
+  rgb: ColorChannels,
+  skip: boolean = false
+): string => {
+  let r, g, b, alpha;
+  if (skip) {
+    [r, g, b, alpha] = rgb;
+  } else {
+    [r, g, b, alpha] = validateColorComponents(rgb, {
+      minLength: QUAD
+    }) as ColorChannels;
+  }
+  [r, g, b] = transformLinearRgbToRgb([r, g, b], true);
+  const rr = numberToHexString(r);
+  const gg = numberToHexString(g);
+  const bb = numberToHexString(b);
+  const aa = numberToHexString(alpha * MAX_RGB);
+  let hex;
+  if (aa === 'ff') {
+    hex = `#${rr}${gg}${bb}`;
+  } else {
+    hex = `#${rr}${gg}${bb}${aa}`;
+  }
+  return hex;
+};
+
+/**
+ * convert xyz to hex color
+ * @param xyz - [x, y, z, alpha]
+ * @returns hex color
+ */
+export const convertXyzToHex = (xyz: ColorChannels): string => {
+  const [x, y, z, alpha] = validateColorComponents(xyz, {
+    minLength: QUAD,
+    validateRange: false
+  }) as ColorChannels;
+  const [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
+  const hex = convertLinearRgbToHex(
+    [
+      Math.min(Math.max(r, 0), 1),
+      Math.min(Math.max(g, 0), 1),
+      Math.min(Math.max(b, 0), 1),
+      alpha
+    ],
+    true
+  );
+  return hex;
+};
+
+/**
+ * convert xyz D50 to hex color
+ * @param xyz - [x, y, z, alpha]
+ * @returns hex color
+ */
+export const convertXyzD50ToHex = (xyz: ColorChannels): string => {
+  const [x, y, z, alpha] = validateColorComponents(xyz, {
+    minLength: QUAD,
+    validateRange: false
+  }) as ColorChannels;
+  const xyzD65 = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
+  const [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, xyzD65, true);
+  const hex = convertLinearRgbToHex([
+    Math.min(Math.max(r, 0), 1),
+    Math.min(Math.max(g, 0), 1),
+    Math.min(Math.max(b, 0), 1),
+    alpha
+  ]);
+  return hex;
+};
+
+/**
+ * convert hex color to rgb
+ * @param value - hex color value
+ * @returns ColorChannels - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
+ */
+export const convertHexToRgb = (value: string): ColorChannels => {
+  if (isString(value)) {
+    value = value.toLowerCase().trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  if (
+    !(
+      /^#[\da-f]{6}$/.test(value) ||
+      /^#[\da-f]{3}$/.test(value) ||
+      /^#[\da-f]{8}$/.test(value) ||
+      /^#[\da-f]{4}$/.test(value)
+    )
+  ) {
+    throw new SyntaxError(`Invalid property value: ${value}`);
+  }
+  const arr: number[] = [];
+  if (/^#[\da-f]{3}$/.test(value)) {
+    const [, r, g, b] = value.match(
+      /^#([\da-f])([\da-f])([\da-f])$/
+    ) as MatchedRegExp;
+    arr.push(
+      parseInt(`${r}${r}`, HEX),
+      parseInt(`${g}${g}`, HEX),
+      parseInt(`${b}${b}`, HEX),
+      1
+    );
+  } else if (/^#[\da-f]{4}$/.test(value)) {
+    const [, r, g, b, alpha] = value.match(
+      /^#([\da-f])([\da-f])([\da-f])([\da-f])$/
+    ) as MatchedRegExp;
+    arr.push(
+      parseInt(`${r}${r}`, HEX),
+      parseInt(`${g}${g}`, HEX),
+      parseInt(`${b}${b}`, HEX),
+      parseHexAlpha(`${alpha}${alpha}`)
+    );
+  } else if (/^#[\da-f]{8}$/.test(value)) {
+    const [, r, g, b, alpha] = value.match(
+      /^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})$/
+    ) as MatchedRegExp;
+    arr.push(
+      parseInt(r, HEX),
+      parseInt(g, HEX),
+      parseInt(b, HEX),
+      parseHexAlpha(alpha)
+    );
+  } else {
+    const [, r, g, b] = value.match(
+      /^#([\da-f]{2})([\da-f]{2})([\da-f]{2})$/
+    ) as MatchedRegExp;
+    arr.push(parseInt(r, HEX), parseInt(g, HEX), parseInt(b, HEX), 1);
+  }
+  return arr as ColorChannels;
+};
+
+/**
+ * convert hex color to linear rgb
+ * @param value - hex color value
+ * @returns ColorChannels - [r, g, b, alpha] r|g|b|alpha: 0..1
+ */
+export const convertHexToLinearRgb = (value: string): ColorChannels => {
+  const [rr, gg, bb, alpha] = convertHexToRgb(value);
+  const [r, g, b] = transformRgbToLinearRgb([rr, gg, bb], true);
+  return [r, g, b, alpha];
+};
+
+/**
+ * convert hex color to xyz
+ * @param value - hex color value
+ * @returns ColorChannels - [x, y, z, alpha]
+ */
+export const convertHexToXyz = (value: string): ColorChannels => {
+  const [r, g, b, alpha] = convertHexToLinearRgb(value);
+  const [x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [r, g, b], true);
+  return [x, y, z, alpha];
+};
+
+/**
+ * parse rgb()
+ * @param value - rgb color value
+ * @param [opt] - options
+ * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
+ */
+export const parseRgb = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.toLowerCase().trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '', nullable = false } = opt;
+  if (!REG_PARSE_RGB.test(value)) {
+    const res = resolveInvalidColorValue(format, nullable);
+    if (res instanceof NullObject) {
+      return res;
+    }
+    if (isString(res)) {
+      return res as string;
+    }
+    return res as SpecifiedColorChannels;
+  }
+  const [, val] = value.match(REG_PARSE_RGB) as MatchedRegExp;
+  const [v1, v2, v3, v4 = ''] = val.match(/[^\s,/]+/g) as StringColorChannels;
+  let r, g, b;
+  if (v1 === NONE) {
+    r = 0;
+  } else {
+    if (v1.endsWith('%')) {
+      r = (parseFloat(v1) * MAX_RGB) / MAX_PCT;
+    } else {
+      r = parseFloat(v1);
+    }
+    r = Math.min(Math.max(roundToPrecision(r, OCT), 0), MAX_RGB);
+  }
+  if (v2 === NONE) {
+    g = 0;
+  } else {
+    if (v2.endsWith('%')) {
+      g = (parseFloat(v2) * MAX_RGB) / MAX_PCT;
+    } else {
+      g = parseFloat(v2);
+    }
+    g = Math.min(Math.max(roundToPrecision(g, OCT), 0), MAX_RGB);
+  }
+  if (v3 === NONE) {
+    b = 0;
+  } else {
+    if (v3.endsWith('%')) {
+      b = (parseFloat(v3) * MAX_RGB) / MAX_PCT;
+    } else {
+      b = parseFloat(v3);
+    }
+    b = Math.min(Math.max(roundToPrecision(b, OCT), 0), MAX_RGB);
+  }
+  const alpha = parseAlpha(v4);
+  return ['rgb', r, g, b, format === VAL_MIX && v4 === NONE ? NONE : alpha];
+};
+
+/**
+ * parse hsl()
+ * @param value - hsl color value
+ * @param [opt] - options
+ * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
+ */
+export const parseHsl = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '', nullable = false } = opt;
+  if (!REG_HSL.test(value)) {
+    const res = resolveInvalidColorValue(format, nullable);
+    if (res instanceof NullObject) {
+      return res;
+    }
+    if (isString(res)) {
+      return res as string;
+    }
+    return res as SpecifiedColorChannels;
+  }
+  const [, val] = value.match(REG_HSL) as MatchedRegExp;
+  const [v1, v2, v3, v4 = ''] = val.match(/[^\s,/]+/g) as StringColorChannels;
+  let h, s, l;
+  if (v1 === NONE) {
+    h = 0;
+  } else {
+    h = angleToDeg(v1);
+  }
+  if (v2 === NONE) {
+    s = 0;
+  } else {
+    s = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT);
+  }
+  if (v3 === NONE) {
+    l = 0;
+  } else {
+    l = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT);
+  }
+  const alpha = parseAlpha(v4);
+  if (format === 'hsl') {
+    return [
+      format,
+      v1 === NONE ? v1 : h,
+      v2 === NONE ? v2 : s,
+      v3 === NONE ? v3 : l,
+      v4 === NONE ? v4 : alpha
+    ];
+  }
+  h = (h / DEG) * DOZ;
+  l /= MAX_PCT;
+  const sa = (s / MAX_PCT) * Math.min(l, 1 - l);
+  const rk = h % DOZ;
+  const gk = (8 + h) % DOZ;
+  const bk = (4 + h) % DOZ;
+  const r = l - sa * Math.max(-1, Math.min(rk - TRIA, TRIA ** POW_SQR - rk, 1));
+  const g = l - sa * Math.max(-1, Math.min(gk - TRIA, TRIA ** POW_SQR - gk, 1));
+  const b = l - sa * Math.max(-1, Math.min(bk - TRIA, TRIA ** POW_SQR - bk, 1));
+  return [
+    'rgb',
+    Math.min(Math.max(roundToPrecision(r * MAX_RGB, OCT), 0), MAX_RGB),
+    Math.min(Math.max(roundToPrecision(g * MAX_RGB, OCT), 0), MAX_RGB),
+    Math.min(Math.max(roundToPrecision(b * MAX_RGB, OCT), 0), MAX_RGB),
+    alpha
+  ];
+};
+
+/**
+ * parse hwb()
+ * @param value - hwb color value
+ * @param [opt] - options
+ * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
+ */
+export const parseHwb = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '', nullable = false } = opt;
+  if (!REG_HWB.test(value)) {
+    const res = resolveInvalidColorValue(format, nullable);
+    if (res instanceof NullObject) {
+      return res;
+    }
+    if (isString(res)) {
+      return res as string;
+    }
+    return res as SpecifiedColorChannels;
+  }
+  const [, val] = value.match(REG_HWB) as MatchedRegExp;
+  const [v1, v2, v3, v4 = ''] = val.match(/[^\s,/]+/g) as StringColorChannels;
+  let h, wh, bk;
+  if (v1 === NONE) {
+    h = 0;
+  } else {
+    h = angleToDeg(v1);
+  }
+  if (v2 === NONE) {
+    wh = 0;
+  } else {
+    wh = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT) / MAX_PCT;
+  }
+  if (v3 === NONE) {
+    bk = 0;
+  } else {
+    bk = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT) / MAX_PCT;
+  }
+  const alpha = parseAlpha(v4);
+  if (format === 'hwb') {
+    return [
+      format,
+      v1 === NONE ? v1 : h,
+      v2 === NONE ? v2 : wh * MAX_PCT,
+      v3 === NONE ? v3 : bk * MAX_PCT,
+      v4 === NONE ? v4 : alpha
+    ];
+  }
+  if (wh + bk >= 1) {
+    const v = roundToPrecision((wh / (wh + bk)) * MAX_RGB, OCT);
+    return ['rgb', v, v, v, alpha];
+  }
+  const factor = (1 - wh - bk) / MAX_RGB;
+  let [, r, g, b] = parseHsl(`hsl(${h} 100 50)`) as ComputedColorChannels;
+  r = roundToPrecision((r * factor + wh) * MAX_RGB, OCT);
+  g = roundToPrecision((g * factor + wh) * MAX_RGB, OCT);
+  b = roundToPrecision((b * factor + wh) * MAX_RGB, OCT);
+  return [
+    'rgb',
+    Math.min(Math.max(r, 0), MAX_RGB),
+    Math.min(Math.max(g, 0), MAX_RGB),
+    Math.min(Math.max(b, 0), MAX_RGB),
+    alpha
+  ];
+};
+
+/**
+ * parse lab()
+ * @param value - lab color value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - [xyz-d50, x, y, z, alpha], ['lab', l, a, b, alpha], '(empty)', NullObject
+ */
+export const parseLab = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '', nullable = false } = opt;
+  if (!REG_LAB.test(value)) {
+    const res = resolveInvalidColorValue(format, nullable);
+    if (res instanceof NullObject) {
+      return res;
+    }
+    if (isString(res)) {
+      return res as string;
+    }
+    return res as SpecifiedColorChannels;
+  }
+  const COEF_PCT = 1.25;
+  const COND_POW = 8;
+  const [, val] = value.match(REG_LAB) as MatchedRegExp;
+  const [v1, v2, v3, v4 = ''] = val.match(/[^\s,/]+/g) as StringColorChannels;
+  let l, a, b;
+  if (v1 === NONE) {
+    l = 0;
+  } else {
+    if (v1.endsWith('%')) {
+      l = parseFloat(v1);
+      if (l > MAX_PCT) {
+        l = MAX_PCT;
+      }
+    } else {
+      l = parseFloat(v1);
+    }
+    if (l < 0) {
+      l = 0;
+    }
+  }
+  if (v2 === NONE) {
+    a = 0;
+  } else {
+    a = v2.endsWith('%') ? parseFloat(v2) * COEF_PCT : parseFloat(v2);
+  }
+  if (v3 === NONE) {
+    b = 0;
+  } else {
+    b = v3.endsWith('%') ? parseFloat(v3) * COEF_PCT : parseFloat(v3);
+  }
+  const alpha = parseAlpha(v4);
+  if (REG_SPEC.test(format)) {
+    return [
+      'lab',
+      v1 === NONE ? v1 : roundToPrecision(l, HEX),
+      v2 === NONE ? v2 : roundToPrecision(a, HEX),
+      v3 === NONE ? v3 : roundToPrecision(b, HEX),
+      v4 === NONE ? v4 : alpha
+    ];
+  }
+  const fl = (l + HEX) / LAB_L;
+  const fa = a / LAB_A + fl;
+  const fb = fl - b / LAB_B;
+  const powFl = Math.pow(fl, POW_CUBE);
+  const powFa = Math.pow(fa, POW_CUBE);
+  const powFb = Math.pow(fb, POW_CUBE);
+  const xyz = [
+    powFa > LAB_EPSILON ? powFa : (fa * LAB_L - HEX) / LAB_KAPPA,
+    l > COND_POW ? powFl : l / LAB_KAPPA,
+    powFb > LAB_EPSILON ? powFb : (fb * LAB_L - HEX) / LAB_KAPPA
+  ];
+  const [x, y, z] = xyz.map(
+    (val, i) => val * (D50[i] as number)
+  ) as TriColorChannels;
+  return [
+    'xyz-d50',
+    roundToPrecision(x, HEX),
+    roundToPrecision(y, HEX),
+    roundToPrecision(z, HEX),
+    alpha
+  ];
+};
+
+/**
+ * parse lch()
+ * @param value - lch color value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - ['xyz-d50', x, y, z, alpha], ['lch', l, c, h, alpha]
+ *   - '(empty)', NullObject
+ */
+export const parseLch = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '', nullable = false } = opt;
+  if (!REG_LCH.test(value)) {
+    const res = resolveInvalidColorValue(format, nullable);
+    if (res instanceof NullObject) {
+      return res;
+    }
+    if (isString(res)) {
+      return res as string;
+    }
+    return res as SpecifiedColorChannels;
+  }
+  const COEF_PCT = 1.5;
+  const [, val] = value.match(REG_LCH) as MatchedRegExp;
+  const [v1, v2, v3, v4 = ''] = val.match(/[^\s,/]+/g) as StringColorChannels;
+  let l, c, h;
+  if (v1 === NONE) {
+    l = 0;
+  } else {
+    l = parseFloat(v1);
+    if (l < 0) {
+      l = 0;
+    }
+  }
+  if (v2 === NONE) {
+    c = 0;
+  } else {
+    c = v2.endsWith('%') ? parseFloat(v2) * COEF_PCT : parseFloat(v2);
+  }
+  if (v3 === NONE) {
+    h = 0;
+  } else {
+    h = angleToDeg(v3);
+  }
+  const alpha = parseAlpha(v4);
+  if (REG_SPEC.test(format)) {
+    return [
+      'lch',
+      v1 === NONE ? v1 : roundToPrecision(l, HEX),
+      v2 === NONE ? v2 : roundToPrecision(c, HEX),
+      v3 === NONE ? v3 : roundToPrecision(h, HEX),
+      v4 === NONE ? v4 : alpha
+    ];
+  }
+  const a = c * Math.cos((h * Math.PI) / DEG_HALF);
+  const b = c * Math.sin((h * Math.PI) / DEG_HALF);
+  const [, x, y, z] = parseLab(`lab(${l} ${a} ${b})`) as ComputedColorChannels;
+  return [
+    'xyz-d50',
+    roundToPrecision(x, HEX),
+    roundToPrecision(y, HEX),
+    roundToPrecision(z, HEX),
+    alpha as number
+  ];
+};
+
+/**
+ * parse oklab()
+ * @param value - oklab color value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - ['xyz-d65', x, y, z, alpha], ['oklab', l, a, b, alpha]
+ *   - '(empty)', NullObject
+ */
+export const parseOklab = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '', nullable = false } = opt;
+  if (!REG_OKLAB.test(value)) {
+    const res = resolveInvalidColorValue(format, nullable);
+    if (res instanceof NullObject) {
+      return res;
+    }
+    if (isString(res)) {
+      return res as string;
+    }
+    return res as SpecifiedColorChannels;
+  }
+  const COEF_PCT = 0.4;
+  const [, val] = value.match(REG_OKLAB) as MatchedRegExp;
+  const [v1, v2, v3, v4 = ''] = val.match(/[^\s,/]+/g) as StringColorChannels;
+  let l, a, b;
+  if (v1 === NONE) {
+    l = 0;
+  } else {
+    l = v1.endsWith('%') ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
+    if (l < 0) {
+      l = 0;
+    }
+  }
+  if (v2 === NONE) {
+    a = 0;
+  } else if (v2.endsWith('%')) {
+    a = (parseFloat(v2) * COEF_PCT) / MAX_PCT;
+  } else {
+    a = parseFloat(v2);
+  }
+  if (v3 === NONE) {
+    b = 0;
+  } else if (v3.endsWith('%')) {
+    b = (parseFloat(v3) * COEF_PCT) / MAX_PCT;
+  } else {
+    b = parseFloat(v3);
+  }
+  const alpha = parseAlpha(v4);
+  if (REG_SPEC.test(format)) {
+    return [
+      'oklab',
+      v1 === NONE ? v1 : roundToPrecision(l, HEX),
+      v2 === NONE ? v2 : roundToPrecision(a, HEX),
+      v3 === NONE ? v3 : roundToPrecision(b, HEX),
+      v4 === NONE ? v4 : alpha
+    ];
+  }
+  const lms = transformMatrix(MATRIX_OKLAB_TO_LMS, [l, a, b]);
+  const xyzLms = lms.map(c => Math.pow(c, POW_CUBE)) as TriColorChannels;
+  const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, xyzLms, true);
+  return [
+    'xyz-d65',
+    roundToPrecision(x, HEX),
+    roundToPrecision(y, HEX),
+    roundToPrecision(z, HEX),
+    alpha as number
+  ];
+};
+
+/**
+ * parse oklch()
+ * @param value - oklch color value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - ['xyz-d65', x, y, z, alpha], ['oklch', l, c, h, alpha]
+ *   - '(empty)', NullObject
+ */
+export const parseOklch = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '', nullable = false } = opt;
+  if (!REG_OKLCH.test(value)) {
+    const res = resolveInvalidColorValue(format, nullable);
+    if (res instanceof NullObject) {
+      return res;
+    }
+    if (isString(res)) {
+      return res as string;
+    }
+    return res as SpecifiedColorChannels;
+  }
+  const COEF_PCT = 0.4;
+  const [, val] = value.match(REG_OKLCH) as MatchedRegExp;
+  const [v1, v2, v3, v4 = ''] = val.match(/[^\s,/]+/g) as StringColorChannels;
+  let l, c, h;
+  if (v1 === NONE) {
+    l = 0;
+  } else {
+    l = v1.endsWith('%') ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
+    if (l < 0) {
+      l = 0;
+    }
+  }
+  if (v2 === NONE) {
+    c = 0;
+  } else {
+    if (v2.endsWith('%')) {
+      c = (parseFloat(v2) * COEF_PCT) / MAX_PCT;
+    } else {
+      c = parseFloat(v2);
+    }
+    if (c < 0) {
+      c = 0;
+    }
+  }
+  if (v3 === NONE) {
+    h = 0;
+  } else {
+    h = angleToDeg(v3);
+  }
+  const alpha = parseAlpha(v4);
+  if (REG_SPEC.test(format)) {
+    return [
+      'oklch',
+      v1 === NONE ? v1 : roundToPrecision(l, HEX),
+      v2 === NONE ? v2 : roundToPrecision(c, HEX),
+      v3 === NONE ? v3 : roundToPrecision(h, HEX),
+      v4 === NONE ? v4 : alpha
+    ];
+  }
+  const a = c * Math.cos((h * Math.PI) / DEG_HALF);
+  const b = c * Math.sin((h * Math.PI) / DEG_HALF);
+  const lms = transformMatrix(MATRIX_OKLAB_TO_LMS, [l, a, b]);
+  const xyzLms = lms.map(cc => Math.pow(cc, POW_CUBE)) as TriColorChannels;
+  const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, xyzLms, true);
+  return [
+    'xyz-d65',
+    roundToPrecision(x, HEX),
+    roundToPrecision(y, HEX),
+    roundToPrecision(z, HEX),
+    alpha
+  ];
+};
+
+/**
+ * parse color()
+ * @param value - color function value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - ['xyz-(d50|d65)', x, y, z, alpha], [cs, r, g, b, alpha]
+ *   - '(empty)', NullObject
+ */
+export const parseColorFunc = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { colorSpace = '', d50 = false, format = '', nullable = false } = opt;
+  if (!REG_FN_COLOR.test(value)) {
+    const res = resolveInvalidColorValue(format, nullable);
+    if (res instanceof NullObject) {
+      return res;
+    }
+    if (isString(res)) {
+      return res as string;
+    }
+    return res as SpecifiedColorChannels;
+  }
+  const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;
+  let [cs, v1, v2, v3, v4 = ''] = val.match(
+    /[^\s,/]+/g
+  ) as StringColorSpacedChannels;
+  let r, g, b;
+  if (cs === 'xyz') {
+    cs = 'xyz-d65';
+  }
+  if (v1 === NONE) {
+    r = 0;
+  } else {
+    r = v1.endsWith('%') ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
+  }
+  if (v2 === NONE) {
+    g = 0;
+  } else {
+    g = v2.endsWith('%') ? parseFloat(v2) / MAX_PCT : parseFloat(v2);
+  }
+  if (v3 === NONE) {
+    b = 0;
+  } else {
+    b = v3.endsWith('%') ? parseFloat(v3) / MAX_PCT : parseFloat(v3);
+  }
+  const alpha = parseAlpha(v4);
+  if (REG_SPEC.test(format) || (format === VAL_MIX && cs === colorSpace)) {
+    return [
+      cs,
+      v1 === NONE ? v1 : roundToPrecision(r, DEC),
+      v2 === NONE ? v2 : roundToPrecision(g, DEC),
+      v3 === NONE ? v3 : roundToPrecision(b, DEC),
+      v4 === NONE ? v4 : alpha
+    ];
+  }
+  let x = 0;
+  let y = 0;
+  let z = 0;
+  // srgb-linear
+  if (cs === 'srgb-linear') {
+    [x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [r, g, b]);
+    if (d50) {
+      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
+    }
+    // display-p3
+  } else if (cs === 'display-p3') {
+    const linearRgb = transformRgbToLinearRgb([
+      r * MAX_RGB,
+      g * MAX_RGB,
+      b * MAX_RGB
+    ]);
+    [x, y, z] = transformMatrix(MATRIX_P3_TO_XYZ, linearRgb);
+    if (d50) {
+      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
+    }
+    // rec2020
+  } else if (cs === 'rec2020') {
+    const ALPHA = 1.09929682680944;
+    const BETA = 0.018053968510807;
+    const REC_COEF = 0.45;
+    const rgb = [r, g, b].map(c => {
+      let cl;
+      if (c < BETA * REC_COEF * DEC) {
+        cl = c / (REC_COEF * DEC);
+      } else {
+        cl = Math.pow((c + ALPHA - 1) / ALPHA, 1 / REC_COEF);
+      }
+      return cl;
+    }) as TriColorChannels;
+    [x, y, z] = transformMatrix(MATRIX_REC2020_TO_XYZ, rgb);
+    if (d50) {
+      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
+    }
+    // a98-rgb
+  } else if (cs === 'a98-rgb') {
+    const POW_A98 = 563 / 256;
+    const rgb = [r, g, b].map(c => {
+      const cl = Math.pow(c, POW_A98);
+      return cl;
+    }) as TriColorChannels;
+    [x, y, z] = transformMatrix(MATRIX_A98_TO_XYZ, rgb);
+    if (d50) {
+      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
+    }
+    // prophoto-rgb
+  } else if (cs === 'prophoto-rgb') {
+    const POW_PROPHOTO = 1.8;
+    const rgb = [r, g, b].map(c => {
+      let cl;
+      if (c > 1 / (HEX * DUO)) {
+        cl = Math.pow(c, POW_PROPHOTO);
+      } else {
+        cl = c / HEX;
+      }
+      return cl;
+    }) as TriColorChannels;
+    [x, y, z] = transformMatrix(MATRIX_PROPHOTO_TO_XYZ_D50, rgb);
+    if (!d50) {
+      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
+    }
+    // xyz, xyz-d50, xyz-d65
+  } else if (/^xyz(?:-d(?:50|65))?$/.test(cs)) {
+    [x, y, z] = [r, g, b];
+    if (cs === 'xyz-d50') {
+      if (!d50) {
+        [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z]);
+      }
+    } else if (d50) {
+      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
+    }
+    // srgb
+  } else {
+    [x, y, z] = transformRgbToXyz([r * MAX_RGB, g * MAX_RGB, b * MAX_RGB]);
+    if (d50) {
+      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
+    }
+  }
+  return [
+    d50 ? 'xyz-d50' : 'xyz-d65',
+    roundToPrecision(x, HEX),
+    roundToPrecision(y, HEX),
+    roundToPrecision(z, HEX),
+    format === VAL_MIX && v4 === NONE ? v4 : alpha
+  ];
+};
+
+/**
+ * parse color value
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns parsed color
+ *   - ['xyz-(d50|d65)', x, y, z, alpha], ['rgb', r, g, b, alpha]
+ *   - value, '(empty)', NullObject
+ */
+export const parseColorValue = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.toLowerCase().trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { d50 = false, format = '', nullable = false } = opt;
+  if (!REG_COLOR.test(value)) {
+    const res = resolveInvalidColorValue(format, nullable);
+    if (res instanceof NullObject) {
+      return res;
+    }
+    if (isString(res)) {
+      return res as string;
+    }
+    return res as SpecifiedColorChannels;
+  }
+  let x = 0;
+  let y = 0;
+  let z = 0;
+  let alpha = 0;
+  // complement currentcolor as a missing color
+  if (REG_CURRENT.test(value)) {
+    if (format === VAL_COMP) {
+      return ['rgb', 0, 0, 0, 0];
+    }
+    if (format === VAL_SPEC) {
+      return value;
+    }
+    // named-color
+  } else if (/^[a-z]+$/.test(value)) {
+    if (Object.hasOwn(NAMED_COLORS, value)) {
+      if (format === VAL_SPEC) {
+        return value;
+      }
+      const [r, g, b] = NAMED_COLORS[
+        value as keyof typeof NAMED_COLORS
+      ] as TriColorChannels;
+      alpha = 1;
+      if (format === VAL_COMP) {
+        return ['rgb', r, g, b, alpha];
+      }
+      [x, y, z] = transformRgbToXyz([r, g, b], true);
+      if (d50) {
+        [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
+      }
+    } else {
+      switch (format) {
+        case VAL_COMP: {
+          if (nullable && value !== 'transparent') {
+            return new NullObject();
+          }
+          return ['rgb', 0, 0, 0, 0];
+        }
+        case VAL_SPEC: {
+          if (value === 'transparent') {
+            return value;
+          }
+          return '';
+        }
+        case VAL_MIX: {
+          if (value === 'transparent') {
+            return ['rgb', 0, 0, 0, 0];
+          }
+          return new NullObject();
+        }
+        default:
+      }
+    }
+    // hex-color
+  } else if (value[0] === '#') {
+    if (REG_SPEC.test(format)) {
+      const rgb = convertHexToRgb(value);
+      return ['rgb', ...rgb];
+    }
+    [x, y, z, alpha] = convertHexToXyz(value);
+    if (d50) {
+      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
+    }
+    // lab()
+  } else if (value.startsWith('lab')) {
+    if (REG_SPEC.test(format)) {
+      return parseLab(value, opt);
+    }
+    [, x, y, z, alpha] = parseLab(value) as ComputedColorChannels;
+    if (!d50) {
+      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
+    }
+    // lch()
+  } else if (value.startsWith('lch')) {
+    if (REG_SPEC.test(format)) {
+      return parseLch(value, opt);
+    }
+    [, x, y, z, alpha] = parseLch(value) as ComputedColorChannels;
+    if (!d50) {
+      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
+    }
+    // oklab()
+  } else if (value.startsWith('oklab')) {
+    if (REG_SPEC.test(format)) {
+      return parseOklab(value, opt);
+    }
+    [, x, y, z, alpha] = parseOklab(value) as ComputedColorChannels;
+    if (d50) {
+      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
+    }
+    // oklch()
+  } else if (value.startsWith('oklch')) {
+    if (REG_SPEC.test(format)) {
+      return parseOklch(value, opt);
+    }
+    [, x, y, z, alpha] = parseOklch(value) as ComputedColorChannels;
+    if (d50) {
+      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
+    }
+  } else {
+    let r, g, b;
+    // hsl()
+    if (value.startsWith('hsl')) {
+      [, r, g, b, alpha] = parseHsl(value) as ComputedColorChannels;
+      // hwb()
+    } else if (value.startsWith('hwb')) {
+      [, r, g, b, alpha] = parseHwb(value) as ComputedColorChannels;
+      // rgb()
+    } else {
+      [, r, g, b, alpha] = parseRgb(value, opt) as ComputedColorChannels;
+    }
+    if (REG_SPEC.test(format)) {
+      return ['rgb', Math.round(r), Math.round(g), Math.round(b), alpha];
+    }
+    [x, y, z] = transformRgbToXyz([r, g, b]);
+    if (d50) {
+      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
+    }
+  }
+  return [
+    d50 ? 'xyz-d50' : 'xyz-d65',
+    roundToPrecision(x, HEX),
+    roundToPrecision(y, HEX),
+    roundToPrecision(z, HEX),
+    alpha
+  ];
+};
+
+/**
+ * resolve color value
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns resolved color
+ *   - [cs, v1, v2, v3, alpha], value, '(empty)', NullObject
+ */
+export const resolveColorValue = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.toLowerCase().trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { colorSpace = '', format = '', nullable = false } = opt;
+  const cacheKey: string = createCacheKey(
+    {
+      namespace: NAMESPACE,
+      name: 'resolveColorValue',
+      value
+    },
+    opt
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    if (cachedResult.isNull) {
+      return cachedResult as NullObject;
+    }
+    const cachedItem = cachedResult.item;
+    if (isString(cachedItem)) {
+      return cachedItem as string;
+    }
+    return cachedItem as SpecifiedColorChannels;
+  }
+  if (!REG_COLOR.test(value)) {
+    const res = resolveInvalidColorValue(format, nullable);
+    if (res instanceof NullObject) {
+      setCache(cacheKey, null);
+      return res;
+    }
+    setCache(cacheKey, res);
+    if (isString(res)) {
+      return res as string;
+    }
+    return res as SpecifiedColorChannels;
+  }
+  let cs = '';
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let alpha = 0;
+  // complement currentcolor as a missing color
+  if (REG_CURRENT.test(value)) {
+    if (format === VAL_SPEC) {
+      setCache(cacheKey, value);
+      return value;
+    }
+    // named-color
+  } else if (/^[a-z]+$/.test(value)) {
+    if (Object.hasOwn(NAMED_COLORS, value)) {
+      if (format === VAL_SPEC) {
+        setCache(cacheKey, value);
+        return value;
+      }
+      [r, g, b] = NAMED_COLORS[
+        value as keyof typeof NAMED_COLORS
+      ] as TriColorChannels;
+      alpha = 1;
+    } else {
+      switch (format) {
+        case VAL_SPEC: {
+          if (value === 'transparent') {
+            setCache(cacheKey, value);
+            return value;
+          }
+          const res = '';
+          setCache(cacheKey, res);
+          return res;
+        }
+        case VAL_MIX: {
+          if (value === 'transparent') {
+            const res: SpecifiedColorChannels = ['rgb', 0, 0, 0, 0];
+            setCache(cacheKey, res);
+            return res;
+          }
+          setCache(cacheKey, null);
+          return new NullObject();
+        }
+        case VAL_COMP:
+        default: {
+          if (nullable && value !== 'transparent') {
+            setCache(cacheKey, null);
+            return new NullObject();
+          }
+          const res: SpecifiedColorChannels = ['rgb', 0, 0, 0, 0];
+          setCache(cacheKey, res);
+          return res;
+        }
+      }
+    }
+    // hex-color
+  } else if (value[0] === '#') {
+    [r, g, b, alpha] = convertHexToRgb(value);
+    // hsl()
+  } else if (value.startsWith('hsl')) {
+    [, r, g, b, alpha] = parseHsl(value, opt) as ComputedColorChannels;
+    // hwb()
+  } else if (value.startsWith('hwb')) {
+    [, r, g, b, alpha] = parseHwb(value, opt) as ComputedColorChannels;
+    // lab(), lch()
+  } else if (/^l(?:ab|ch)/.test(value)) {
+    let x, y, z;
+    if (value.startsWith('lab')) {
+      [cs, x, y, z, alpha] = parseLab(value, opt) as ComputedColorChannels;
+    } else {
+      [cs, x, y, z, alpha] = parseLch(value, opt) as ComputedColorChannels;
+    }
+    if (REG_SPEC.test(format)) {
+      const res: SpecifiedColorChannels = [cs, x, y, z, alpha];
+      setCache(cacheKey, res);
+      return res;
+    }
+    [r, g, b] = transformXyzD50ToRgb([x, y, z]);
+    // oklab(), oklch()
+  } else if (/^okl(?:ab|ch)/.test(value)) {
+    let x, y, z;
+    if (value.startsWith('oklab')) {
+      [cs, x, y, z, alpha] = parseOklab(value, opt) as ComputedColorChannels;
+    } else {
+      [cs, x, y, z, alpha] = parseOklch(value, opt) as ComputedColorChannels;
+    }
+    if (REG_SPEC.test(format)) {
+      const res: SpecifiedColorChannels = [cs, x, y, z, alpha];
+      setCache(cacheKey, res);
+      return res;
+    }
+    [r, g, b] = transformXyzToRgb([x, y, z]);
+    // rgb()
+  } else {
+    [, r, g, b, alpha] = parseRgb(value, opt) as ComputedColorChannels;
+  }
+  if (format === VAL_MIX && colorSpace === 'srgb') {
+    const res: SpecifiedColorChannels = [
+      'srgb',
+      r / MAX_RGB,
+      g / MAX_RGB,
+      b / MAX_RGB,
+      alpha
+    ];
+    setCache(cacheKey, res);
+    return res;
+  }
+  const res: SpecifiedColorChannels = [
+    'rgb',
+    Math.round(r),
+    Math.round(g),
+    Math.round(b),
+    alpha
+  ];
+  setCache(cacheKey, res);
+  return res;
+};
+
+/**
+ * resolve color()
+ * @param value - color function value
+ * @param [opt] - options
+ * @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)', NullObject
+ */
+export const resolveColorFunc = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.toLowerCase().trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { colorSpace = '', format = '', nullable = false } = opt;
+  const cacheKey: string = createCacheKey(
+    {
+      namespace: NAMESPACE,
+      name: 'resolveColorFunc',
+      value
+    },
+    opt
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    if (cachedResult.isNull) {
+      return cachedResult as NullObject;
+    }
+    const cachedItem = cachedResult.item;
+    if (isString(cachedItem)) {
+      return cachedItem as string;
+    }
+    return cachedItem as SpecifiedColorChannels;
+  }
+  if (!REG_FN_COLOR.test(value)) {
+    const res = resolveInvalidColorValue(format, nullable);
+    if (res instanceof NullObject) {
+      setCache(cacheKey, null);
+      return res;
+    }
+    setCache(cacheKey, res);
+    if (isString(res)) {
+      return res as string;
+    }
+    return res as SpecifiedColorChannels;
+  }
+  const [cs, v1, v2, v3, v4] = parseColorFunc(
+    value,
+    opt
+  ) as SpecifiedColorChannels;
+  if (REG_SPEC.test(format) || (format === VAL_MIX && cs === colorSpace)) {
+    const res: SpecifiedColorChannels = [cs, v1, v2, v3, v4];
+    setCache(cacheKey, res);
+    return res;
+  }
+  const x = parseFloat(`${v1}`);
+  const y = parseFloat(`${v2}`);
+  const z = parseFloat(`${v3}`);
+  const alpha = parseAlpha(`${v4}`);
+  const [r, g, b] = transformXyzToRgb([x, y, z], true);
+  const res: SpecifiedColorChannels = ['rgb', r, g, b, alpha];
+  setCache(cacheKey, res);
+  return res;
+};
+
+/**
+ * convert color value to linear rgb
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [r, g, b, alpha] r|g|b|alpha: 0..1
+ */
+export const convertColorToLinearRgb = (
+  value: string,
+  opt: {
+    colorSpace?: string;
+    format?: string;
+  } = {}
+): ColorChannels | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { colorSpace = '', format = '' } = opt;
+  let cs = '';
+  let r, g, b, alpha, x, y, z;
+  if (format === VAL_MIX) {
+    let xyz;
+    if (value.startsWith(FN_COLOR)) {
+      xyz = parseColorFunc(value, opt);
+    } else {
+      xyz = parseColorValue(value, opt);
+    }
+    if (xyz instanceof NullObject) {
+      return xyz;
+    }
+    [cs, x, y, z, alpha] = xyz as ComputedColorChannels;
+    if (cs === colorSpace) {
+      return [x, y, z, alpha];
+    }
+    [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
+  } else if (value.startsWith(FN_COLOR)) {
+    const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;
+    const [cs] = val.match(/[^\s,/]+/g) as StringColorSpacedChannels;
+    if (cs === 'srgb-linear') {
+      [, r, g, b, alpha] = resolveColorFunc(value, {
+        format: VAL_COMP
+      }) as ComputedColorChannels;
+    } else {
+      [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
+      [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
+    }
+  } else {
+    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;
+    [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
+  }
+  return [
+    Math.min(Math.max(r, 0), 1),
+    Math.min(Math.max(g, 0), 1),
+    Math.min(Math.max(b, 0), 1),
+    alpha
+  ];
+};
+
+/**
+ * convert color value to rgb
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject
+ *   - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
+ */
+export const convertColorToRgb = (
+  value: string,
+  opt: Options = {}
+): ColorChannels | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '' } = opt;
+  let r, g, b, alpha;
+  if (format === VAL_MIX) {
+    let rgb;
+    if (value.startsWith(FN_COLOR)) {
+      rgb = resolveColorFunc(value, opt);
+    } else {
+      rgb = resolveColorValue(value, opt);
+    }
+    if (rgb instanceof NullObject) {
+      return rgb;
+    }
+    [, r, g, b, alpha] = rgb as ComputedColorChannels;
+  } else if (value.startsWith(FN_COLOR)) {
+    const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;
+    const [cs] = val.match(/[^\s,/]+/g) as StringColorSpacedChannels;
+    if (cs === 'srgb') {
+      [, r, g, b, alpha] = resolveColorFunc(value, {
+        format: VAL_COMP
+      }) as ComputedColorChannels;
+      r *= MAX_RGB;
+      g *= MAX_RGB;
+      b *= MAX_RGB;
+    } else {
+      [, r, g, b, alpha] = resolveColorFunc(value) as ComputedColorChannels;
+    }
+  } else if (/^(?:ok)?l(?:ab|ch)/.test(value)) {
+    [r, g, b, alpha] = convertColorToLinearRgb(value) as ColorChannels;
+    [r, g, b] = transformLinearRgbToRgb([r, g, b]);
+  } else {
+    [, r, g, b, alpha] = resolveColorValue(value, {
+      format: VAL_COMP
+    }) as ComputedColorChannels;
+  }
+  return [r, g, b, alpha];
+};
+
+/**
+ * convert color value to xyz
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [x, y, z, alpha]
+ */
+export const convertColorToXyz = (
+  value: string,
+  opt: Options = {}
+): ColorChannels | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { d50 = false, format = '' } = opt;
+  let x, y, z, alpha;
+  if (format === VAL_MIX) {
+    let xyz;
+    if (value.startsWith(FN_COLOR)) {
+      xyz = parseColorFunc(value, opt);
+    } else {
+      xyz = parseColorValue(value, opt);
+    }
+    if (xyz instanceof NullObject) {
+      return xyz;
+    }
+    [, x, y, z, alpha] = xyz as ComputedColorChannels;
+  } else if (value.startsWith(FN_COLOR)) {
+    const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;
+    const [cs] = val.match(/[^\s,/]+/g) as StringColorSpacedChannels;
+    if (d50) {
+      if (cs === 'xyz-d50') {
+        [, x, y, z, alpha] = resolveColorFunc(value, {
+          format: VAL_COMP
+        }) as ComputedColorChannels;
+      } else {
+        [, x, y, z, alpha] = parseColorFunc(
+          value,
+          opt
+        ) as ComputedColorChannels;
+      }
+    } else if (/^xyz(?:-d65)?$/.test(cs)) {
+      [, x, y, z, alpha] = resolveColorFunc(value, {
+        format: VAL_COMP
+      }) as ComputedColorChannels;
+    } else {
+      [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
+    }
+  } else {
+    [, x, y, z, alpha] = parseColorValue(value, opt) as ComputedColorChannels;
+  }
+  return [x, y, z, alpha];
+};
+
+/**
+ * convert color value to hsl
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [h, s, l, alpha], hue may be powerless
+ */
+export const convertColorToHsl = (
+  value: string,
+  opt: Options = {}
+): ColorChannels | [number | string, number, number, number] | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '' } = opt;
+  let h, s, l, alpha;
+  if (REG_HSL.test(value)) {
+    [, h, s, l, alpha] = parseHsl(value, {
+      format: 'hsl'
+    }) as ComputedColorChannels;
+    if (format === 'hsl') {
+      return [Math.round(h), Math.round(s), Math.round(l), alpha];
+    }
+    return [h, s, l, alpha];
+  }
+  let x, y, z;
+  if (format === VAL_MIX) {
+    let xyz;
+    if (value.startsWith(FN_COLOR)) {
+      xyz = parseColorFunc(value, opt);
+    } else {
+      xyz = parseColorValue(value, opt);
+    }
+    if (xyz instanceof NullObject) {
+      return xyz;
+    }
+    [, x, y, z, alpha] = xyz as ComputedColorChannels;
+  } else if (value.startsWith(FN_COLOR)) {
+    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
+  } else {
+    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;
+  }
+  [h, s, l] = transformXyzToHsl([x, y, z], true) as TriColorChannels;
+  if (format === 'hsl') {
+    return [Math.round(h), Math.round(s), Math.round(l), alpha];
+  }
+  return [format === VAL_MIX && s === 0 ? NONE : h, s, l, alpha];
+};
+
+/**
+ * convert color value to hwb
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [h, w, b, alpha], hue may be powerless
+ */
+export const convertColorToHwb = (
+  value: string,
+  opt: Options = {}
+): ColorChannels | [number | string, number, number, number] | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '' } = opt;
+  let h, w, b, alpha;
+  if (REG_HWB.test(value)) {
+    [, h, w, b, alpha] = parseHwb(value, {
+      format: 'hwb'
+    }) as ComputedColorChannels;
+    if (format === 'hwb') {
+      return [Math.round(h), Math.round(w), Math.round(b), alpha];
+    }
+    return [h, w, b, alpha];
+  }
+  let x, y, z;
+  if (format === VAL_MIX) {
+    let xyz;
+    if (value.startsWith(FN_COLOR)) {
+      xyz = parseColorFunc(value, opt);
+    } else {
+      xyz = parseColorValue(value, opt);
+    }
+    if (xyz instanceof NullObject) {
+      return xyz;
+    }
+    [, x, y, z, alpha] = xyz as ComputedColorChannels;
+  } else if (value.startsWith(FN_COLOR)) {
+    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
+  } else {
+    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;
+  }
+  [h, w, b] = transformXyzToHwb([x, y, z], true) as TriColorChannels;
+  if (format === 'hwb') {
+    return [Math.round(h), Math.round(w), Math.round(b), alpha];
+  }
+  return [format === VAL_MIX && w + b >= 100 ? NONE : h, w, b, alpha];
+};
+
+/**
+ * convert color value to lab
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [l, a, b, alpha]
+ */
+export const convertColorToLab = (
+  value: string,
+  opt: Options = {}
+): ColorChannels | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '' } = opt;
+  let l, a, b, alpha;
+  if (REG_LAB.test(value)) {
+    [, l, a, b, alpha] = parseLab(value, {
+      format: VAL_COMP
+    }) as ComputedColorChannels;
+    return [l, a, b, alpha];
+  }
+  let x, y, z;
+  if (format === VAL_MIX) {
+    let xyz;
+    opt.d50 = true;
+    if (value.startsWith(FN_COLOR)) {
+      xyz = parseColorFunc(value, opt);
+    } else {
+      xyz = parseColorValue(value, opt);
+    }
+    if (xyz instanceof NullObject) {
+      return xyz;
+    }
+    [, x, y, z, alpha] = xyz as ComputedColorChannels;
+  } else if (value.startsWith(FN_COLOR)) {
+    [, x, y, z, alpha] = parseColorFunc(value, {
+      d50: true
+    }) as ComputedColorChannels;
+  } else {
+    [, x, y, z, alpha] = parseColorValue(value, {
+      d50: true
+    }) as ComputedColorChannels;
+  }
+  [l, a, b] = transformXyzD50ToLab([x, y, z], true);
+  return [l, a, b, alpha];
+};
+
+/**
+ * convert color value to lch
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless
+ */
+export const convertColorToLch = (
+  value: string,
+  opt: Options = {}
+): ColorChannels | [number, number, number | string, number] | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '' } = opt;
+  let l, c, h, alpha;
+  if (REG_LCH.test(value)) {
+    [, l, c, h, alpha] = parseLch(value, {
+      format: VAL_COMP
+    }) as ComputedColorChannels;
+    return [l, c, h, alpha];
+  }
+  let x, y, z;
+  if (format === VAL_MIX) {
+    let xyz;
+    opt.d50 = true;
+    if (value.startsWith(FN_COLOR)) {
+      xyz = parseColorFunc(value, opt);
+    } else {
+      xyz = parseColorValue(value, opt);
+    }
+    if (xyz instanceof NullObject) {
+      return xyz;
+    }
+    [, x, y, z, alpha] = xyz as ComputedColorChannels;
+  } else if (value.startsWith(FN_COLOR)) {
+    [, x, y, z, alpha] = parseColorFunc(value, {
+      d50: true
+    }) as ComputedColorChannels;
+  } else {
+    [, x, y, z, alpha] = parseColorValue(value, {
+      d50: true
+    }) as ComputedColorChannels;
+  }
+  [l, c, h] = transformXyzD50ToLch([x, y, z], true);
+  return [l, c, format === VAL_MIX && c === 0 ? NONE : h, alpha];
+};
+
+/**
+ * convert color value to oklab
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [l, a, b, alpha]
+ */
+export const convertColorToOklab = (
+  value: string,
+  opt: Options = {}
+): ColorChannels | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '' } = opt;
+  let l, a, b, alpha;
+  if (REG_OKLAB.test(value)) {
+    [, l, a, b, alpha] = parseOklab(value, {
+      format: VAL_COMP
+    }) as ComputedColorChannels;
+    return [l, a, b, alpha];
+  }
+  let x, y, z;
+  if (format === VAL_MIX) {
+    let xyz;
+    if (value.startsWith(FN_COLOR)) {
+      xyz = parseColorFunc(value, opt);
+    } else {
+      xyz = parseColorValue(value, opt);
+    }
+    if (xyz instanceof NullObject) {
+      return xyz;
+    }
+    [, x, y, z, alpha] = xyz as ComputedColorChannels;
+  } else if (value.startsWith(FN_COLOR)) {
+    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
+  } else {
+    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;
+  }
+  [l, a, b] = transformXyzToOklab([x, y, z], true);
+  return [l, a, b, alpha];
+};
+
+/**
+ * convert color value to oklch
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless
+ */
+export const convertColorToOklch = (
+  value: string,
+  opt: Options = {}
+): ColorChannels | [number, number, number | string, number] | NullObject => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '' } = opt;
+  let l, c, h, alpha;
+  if (REG_OKLCH.test(value)) {
+    [, l, c, h, alpha] = parseOklch(value, {
+      format: VAL_COMP
+    }) as ComputedColorChannels;
+    return [l, c, h, alpha];
+  }
+  let x, y, z;
+  if (format === VAL_MIX) {
+    let xyz;
+    if (value.startsWith(FN_COLOR)) {
+      xyz = parseColorFunc(value, opt);
+    } else {
+      xyz = parseColorValue(value, opt);
+    }
+    if (xyz instanceof NullObject) {
+      return xyz;
+    }
+    [, x, y, z, alpha] = xyz as ComputedColorChannels;
+  } else if (value.startsWith(FN_COLOR)) {
+    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
+  } else {
+    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;
+  }
+  [l, c, h] = transformXyzToOklch([x, y, z], true) as TriColorChannels;
+  return [l, c, format === VAL_MIX && c === 0 ? NONE : h, alpha];
+};
+
+/**
+ * resolve color-mix()
+ * @param value - color-mix color value
+ * @param [opt] - options
+ * @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)'
+ */
+export const resolveColorMix = (
+  value: string,
+  opt: Options = {}
+): SpecifiedColorChannels | string | NullObject => {
+  if (isString(value)) {
+    value = value.toLowerCase().trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { format = '', nullable = false } = opt;
+  const cacheKey: string = createCacheKey(
+    {
+      namespace: NAMESPACE,
+      name: 'resolveColorMix',
+      value
+    },
+    opt
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    if (cachedResult.isNull) {
+      return cachedResult as NullObject;
+    }
+    const cachedItem = cachedResult.item;
+    if (isString(cachedItem)) {
+      return cachedItem as string;
+    }
+    return cachedItem as SpecifiedColorChannels;
+  }
+  const nestedItems = [];
+  let colorSpace = '';
+  let hueArc = '';
+  let colorA = '';
+  let pctA = '';
+  let colorB = '';
+  let pctB = '';
+  let parsed = false;
+  if (!REG_MIX.test(value)) {
+    // nested color-mix()
+    if (value.startsWith(FN_MIX) && REG_MIX_NEST.test(value)) {
+      const items = value.match(REG_MIX_NEST) as RegExpMatchArray;
+      for (const item of items) {
+        if (item) {
+          let val = resolveColorMix(item, {
+            format: format === VAL_SPEC ? format : VAL_COMP
+          }) as ComputedColorChannels | string;
+          // computed value
+          if (Array.isArray(val)) {
+            const [cs, v1, v2, v3, v4] = val as ComputedColorChannels;
+            if (v1 === 0 && v2 === 0 && v3 === 0 && v4 === 0) {
+              value = '';
+              break;
+            }
+            if (REG_MIX_CS_RGB_XYZ.test(cs)) {
+              if (v4 === 1) {
+                val = `color(${cs} ${v1} ${v2} ${v3})`;
+              } else {
+                val = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
+              }
+            } else if (v4 === 1) {
+              val = `${cs}(${v1} ${v2} ${v3})`;
+            } else {
+              val = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
+            }
+          } else if (!REG_MIX.test(val)) {
+            value = '';
+            break;
+          }
+          nestedItems.push(val);
+          value = value.replace(item, val);
+        }
+      }
+      if (!value) {
+        const res = cacheInvalidColorValue(cacheKey, format, nullable);
+        return res;
+      }
+      // contains light-dark()
+    } else if (
+      value.startsWith(FN_MIX) &&
+      value.endsWith(')') &&
+      value.includes(FN_LIGHT_DARK)
+    ) {
+      const colorParts = value.replace(FN_MIX, '').replace(/\)$/, '');
+      const [csPart = '', partA = '', partB = ''] = splitValue(colorParts, {
+        delimiter: ','
+      });
+      const [colorPartA = '', pctPartA = ''] = splitValue(partA);
+      const [colorPartB = '', pctPartB = ''] = splitValue(partB);
+      const specifiedColorA = resolveColor(colorPartA, {
+        format: VAL_SPEC
+      }) as string;
+      const specifiedColorB = resolveColor(colorPartB, {
+        format: VAL_SPEC
+      }) as string;
+      if (REG_MIX_IN_CS.test(csPart) && specifiedColorA && specifiedColorB) {
+        if (format === VAL_SPEC) {
+          const [, cs] = csPart.match(REG_MIX_IN_CS) as MatchedRegExp;
+          if (REG_CS_HUE.test(cs)) {
+            [, colorSpace, hueArc] = cs.match(REG_CS_HUE) as MatchedRegExp;
+          } else {
+            colorSpace = cs;
+          }
+          colorA = specifiedColorA;
+          if (pctPartA) {
+            pctA = pctPartA;
+          }
+          colorB = specifiedColorB;
+          if (pctPartB) {
+            pctB = pctPartB;
+          }
+          value = value
+            .replace(colorPartA, specifiedColorA)
+            .replace(colorPartB, specifiedColorB);
+          parsed = true;
+        } else {
+          const resolvedColorA = resolveColor(colorPartA, opt);
+          const resolvedColorB = resolveColor(colorPartB, opt);
+          if (isString(resolvedColorA) && isString(resolvedColorB)) {
+            value = value
+              .replace(colorPartA, resolvedColorA)
+              .replace(colorPartB, resolvedColorB);
+          }
+        }
+      } else {
+        const res = cacheInvalidColorValue(cacheKey, format, nullable);
+        return res;
+      }
+    } else {
+      const res = cacheInvalidColorValue(cacheKey, format, nullable);
+      return res;
+    }
+  }
+  if (nestedItems.length && format === VAL_SPEC) {
+    const [, cs] = value.match(REG_MIX_START) as MatchedRegExp;
+    if (REG_CS_HUE.test(cs)) {
+      [, colorSpace, hueArc] = cs.match(REG_CS_HUE) as MatchedRegExp;
+    } else {
+      colorSpace = cs;
+    }
+    if (nestedItems.length === 2) {
+      let [itemA, itemB] = nestedItems as [string, string];
+      itemA = itemA.replace(/(?=[()])/g, '\\');
+      itemB = itemB.replace(/(?=[()])/g, '\\');
+      const regA = new RegExp(`(${itemA})(?:\\s+(${PCT}))?`);
+      const regB = new RegExp(`(${itemB})(?:\\s+(${PCT}))?`);
+      [, colorA, pctA] = value.match(regA) as MatchedRegExp;
+      [, colorB, pctB] = value.match(regB) as MatchedRegExp;
+    } else {
+      let [item] = nestedItems as [string];
+      item = item.replace(/(?=[()])/g, '\\');
+      const itemPart = `${item}(?:\\s+${PCT})?`;
+      const itemPartCapt = `(${item})(?:\\s+(${PCT}))?`;
+      const regItemPart = new RegExp(`^${itemPartCapt}$`);
+      const regLastItem = new RegExp(`${itemPartCapt}\\s*\\)$`);
+      // item is at the end
+      if (regLastItem.test(value)) {
+        const reg = new RegExp(
+          `(${SYN_MIX_PART})\\s*,\\s*(${itemPart})\\s*\\)$`
+        );
+        const [, colorPartA, colorPartB] = value.match(reg) as MatchedRegExp;
+        [, colorA, pctA] = colorPartA.match(
+          REG_MIX_COLOR_PART
+        ) as MatchedRegExp;
+        [, colorB, pctB] = colorPartB.match(regItemPart) as MatchedRegExp;
+      } else {
+        const reg = new RegExp(
+          `(${itemPart})\\s*,\\s*(${SYN_MIX_PART})\\s*\\)$`
+        );
+        const [, colorPartA, colorPartB] = value.match(reg) as MatchedRegExp;
+        [, colorA, pctA] = colorPartA.match(regItemPart) as MatchedRegExp;
+        [, colorB, pctB] = colorPartB.match(
+          REG_MIX_COLOR_PART
+        ) as MatchedRegExp;
+      }
+    }
+  } else if (!parsed) {
+    const [, cs, colorPartA, colorPartB] = value.match(
+      REG_MIX_CAPT
+    ) as MatchedRegExp;
+    [, colorA, pctA] = colorPartA.match(REG_MIX_COLOR_PART) as MatchedRegExp;
+    [, colorB, pctB] = colorPartB.match(REG_MIX_COLOR_PART) as MatchedRegExp;
+    if (REG_CS_HUE.test(cs)) {
+      [, colorSpace, hueArc] = cs.match(REG_CS_HUE) as MatchedRegExp;
+    } else {
+      colorSpace = cs;
+    }
+  }
+  // normalize percentages and set multipler
+  let pA, pB, m;
+  if (pctA && pctB) {
+    const p1 = parseFloat(pctA) / MAX_PCT;
+    const p2 = parseFloat(pctB) / MAX_PCT;
+    if (p1 < 0 || p1 > 1 || p2 < 0 || p2 > 1 || (p1 === 0 && p2 === 0)) {
+      const res = cacheInvalidColorValue(cacheKey, format, nullable);
+      return res;
+    }
+    const factor = p1 + p2;
+    pA = p1 / factor;
+    pB = p2 / factor;
+    m = factor < 1 ? factor : 1;
+  } else {
+    if (pctA) {
+      pA = parseFloat(pctA) / MAX_PCT;
+      if (pA < 0 || pA > 1) {
+        const res = cacheInvalidColorValue(cacheKey, format, nullable);
+        return res;
+      }
+      pB = 1 - pA;
+    } else if (pctB) {
+      pB = parseFloat(pctB) / MAX_PCT;
+      if (pB < 0 || pB > 1) {
+        const res = cacheInvalidColorValue(cacheKey, format, nullable);
+        return res;
+      }
+      pA = 1 - pB;
+    } else {
+      pA = HALF;
+      pB = HALF;
+    }
+    m = 1;
+  }
+  if (colorSpace === 'xyz') {
+    colorSpace = 'xyz-d65';
+  }
+  // specified value
+  if (format === VAL_SPEC) {
+    let valueA = '';
+    let valueB = '';
+    if (colorA.startsWith(FN_MIX) || colorA.startsWith(FN_LIGHT_DARK)) {
+      valueA = colorA;
+    } else if (colorA.startsWith(FN_COLOR)) {
+      const [cs, v1, v2, v3, v4] = parseColorFunc(
+        colorA,
+        opt
+      ) as SpecifiedColorChannels;
+      if (v4 === 1) {
+        valueA = `color(${cs} ${v1} ${v2} ${v3})`;
+      } else {
+        valueA = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
+      }
+    } else {
+      const val = parseColorValue(colorA, opt);
+      if (Array.isArray(val)) {
+        const [cs, v1, v2, v3, v4] = val;
+        if (v4 === 1) {
+          if (cs === 'rgb') {
+            valueA = `${cs}(${v1}, ${v2}, ${v3})`;
+          } else {
+            valueA = `${cs}(${v1} ${v2} ${v3})`;
+          }
+        } else if (cs === 'rgb') {
+          valueA = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;
+        } else {
+          valueA = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
+        }
+      } else {
+        if (!isString(val) || !val) {
+          setCache(cacheKey, '');
+          return '';
+        }
+        valueA = val;
+      }
+    }
+    if (colorB.startsWith(FN_MIX) || colorB.startsWith(FN_LIGHT_DARK)) {
+      valueB = colorB;
+    } else if (colorB.startsWith(FN_COLOR)) {
+      const [cs, v1, v2, v3, v4] = parseColorFunc(
+        colorB,
+        opt
+      ) as SpecifiedColorChannels;
+      if (v4 === 1) {
+        valueB = `color(${cs} ${v1} ${v2} ${v3})`;
+      } else {
+        valueB = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
+      }
+    } else {
+      const val = parseColorValue(colorB, opt);
+      if (Array.isArray(val)) {
+        const [cs, v1, v2, v3, v4] = val;
+        if (v4 === 1) {
+          if (cs === 'rgb') {
+            valueB = `${cs}(${v1}, ${v2}, ${v3})`;
+          } else {
+            valueB = `${cs}(${v1} ${v2} ${v3})`;
+          }
+        } else if (cs === 'rgb') {
+          valueB = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;
+        } else {
+          valueB = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
+        }
+      } else {
+        if (!isString(val) || !val) {
+          setCache(cacheKey, '');
+          return '';
+        }
+        valueB = val;
+      }
+    }
+    if (pctA && pctB) {
+      valueA += ` ${parseFloat(pctA)}%`;
+      valueB += ` ${parseFloat(pctB)}%`;
+    } else if (pctA) {
+      const pA = parseFloat(pctA);
+      if (pA !== MAX_PCT * HALF) {
+        valueA += ` ${pA}%`;
+      }
+    } else if (pctB) {
+      const pA = MAX_PCT - parseFloat(pctB);
+      if (pA !== MAX_PCT * HALF) {
+        valueA += ` ${pA}%`;
+      }
+    }
+    if (hueArc) {
+      const res = `color-mix(in ${colorSpace} ${hueArc} hue, ${valueA}, ${valueB})`;
+      setCache(cacheKey, res);
+      return res;
+    } else {
+      const res = `color-mix(in ${colorSpace}, ${valueA}, ${valueB})`;
+      setCache(cacheKey, res);
+      return res;
+    }
+  }
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let alpha = 0;
+  // in srgb, srgb-linear
+  if (/^srgb(?:-linear)?$/.test(colorSpace)) {
+    let rgbA, rgbB;
+    if (colorSpace === 'srgb') {
+      if (REG_CURRENT.test(colorA)) {
+        rgbA = [NONE, NONE, NONE, NONE];
+      } else {
+        rgbA = convertColorToRgb(colorA, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+      if (REG_CURRENT.test(colorB)) {
+        rgbB = [NONE, NONE, NONE, NONE];
+      } else {
+        rgbB = convertColorToRgb(colorB, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+    } else {
+      if (REG_CURRENT.test(colorA)) {
+        rgbA = [NONE, NONE, NONE, NONE];
+      } else {
+        rgbA = convertColorToLinearRgb(colorA, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+      if (REG_CURRENT.test(colorB)) {
+        rgbB = [NONE, NONE, NONE, NONE];
+      } else {
+        rgbB = convertColorToLinearRgb(colorB, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+    }
+    if (rgbA instanceof NullObject || rgbB instanceof NullObject) {
+      const res = cacheInvalidColorValue(cacheKey, format, nullable);
+      return res;
+    }
+    const [rrA, ggA, bbA, aaA] = rgbA as NumStrColorChannels;
+    const [rrB, ggB, bbB, aaB] = rgbB as NumStrColorChannels;
+    const rNone = rrA === NONE && rrB === NONE;
+    const gNone = ggA === NONE && ggB === NONE;
+    const bNone = bbA === NONE && bbB === NONE;
+    const alphaNone = aaA === NONE && aaB === NONE;
+    const [[rA, gA, bA, alphaA], [rB, gB, bB, alphaB]] =
+      normalizeColorComponents(
+        [rrA, ggA, bbA, aaA],
+        [rrB, ggB, bbB, aaB],
+        true
+      );
+    const factorA = alphaA * pA;
+    const factorB = alphaB * pB;
+    alpha = factorA + factorB;
+    if (alpha === 0) {
+      r = rA * pA + rB * pB;
+      g = gA * pA + gB * pB;
+      b = bA * pA + bB * pB;
+    } else {
+      r = (rA * factorA + rB * factorB) / alpha;
+      g = (gA * factorA + gB * factorB) / alpha;
+      b = (bA * factorA + bB * factorB) / alpha;
+      alpha = parseFloat(alpha.toFixed(3));
+    }
+    if (format === VAL_COMP) {
+      const res: SpecifiedColorChannels = [
+        colorSpace,
+        rNone ? NONE : roundToPrecision(r, HEX),
+        gNone ? NONE : roundToPrecision(g, HEX),
+        bNone ? NONE : roundToPrecision(b, HEX),
+        alphaNone ? NONE : alpha * m
+      ];
+      setCache(cacheKey, res);
+      return res;
+    }
+    r *= MAX_RGB;
+    g *= MAX_RGB;
+    b *= MAX_RGB;
+    // in xyz, xyz-d65, xyz-d50
+  } else if (REG_CS_XYZ.test(colorSpace)) {
+    let xyzA, xyzB;
+    if (REG_CURRENT.test(colorA)) {
+      xyzA = [NONE, NONE, NONE, NONE];
+    } else {
+      xyzA = convertColorToXyz(colorA, {
+        colorSpace,
+        d50: colorSpace === 'xyz-d50',
+        format: VAL_MIX
+      });
+    }
+    if (REG_CURRENT.test(colorB)) {
+      xyzB = [NONE, NONE, NONE, NONE];
+    } else {
+      xyzB = convertColorToXyz(colorB, {
+        colorSpace,
+        d50: colorSpace === 'xyz-d50',
+        format: VAL_MIX
+      });
+    }
+    if (xyzA instanceof NullObject || xyzB instanceof NullObject) {
+      const res = cacheInvalidColorValue(cacheKey, format, nullable);
+      return res;
+    }
+    const [xxA, yyA, zzA, aaA] = xyzA;
+    const [xxB, yyB, zzB, aaB] = xyzB;
+    const xNone = xxA === NONE && xxB === NONE;
+    const yNone = yyA === NONE && yyB === NONE;
+    const zNone = zzA === NONE && zzB === NONE;
+    const alphaNone = aaA === NONE && aaB === NONE;
+    const [[xA, yA, zA, alphaA], [xB, yB, zB, alphaB]] =
+      normalizeColorComponents(
+        [xxA, yyA, zzA, aaA],
+        [xxB, yyB, zzB, aaB],
+        true
+      );
+    const factorA = alphaA * pA;
+    const factorB = alphaB * pB;
+    alpha = factorA + factorB;
+    let x, y, z;
+    if (alpha === 0) {
+      x = xA * pA + xB * pB;
+      y = yA * pA + yB * pB;
+      z = zA * pA + zB * pB;
+    } else {
+      x = (xA * factorA + xB * factorB) / alpha;
+      y = (yA * factorA + yB * factorB) / alpha;
+      z = (zA * factorA + zB * factorB) / alpha;
+      alpha = parseFloat(alpha.toFixed(3));
+    }
+    if (format === VAL_COMP) {
+      const res: SpecifiedColorChannels = [
+        colorSpace,
+        xNone ? NONE : roundToPrecision(x, HEX),
+        yNone ? NONE : roundToPrecision(y, HEX),
+        zNone ? NONE : roundToPrecision(z, HEX),
+        alphaNone ? NONE : alpha * m
+      ];
+      setCache(cacheKey, res);
+      return res;
+    }
+    if (colorSpace === 'xyz-d50') {
+      [r, g, b] = transformXyzD50ToRgb([x, y, z], true);
+    } else {
+      [r, g, b] = transformXyzToRgb([x, y, z], true);
+    }
+    // in hsl, hwb
+  } else if (/^h(?:sl|wb)$/.test(colorSpace)) {
+    let hslA, hslB;
+    if (colorSpace === 'hsl') {
+      if (REG_CURRENT.test(colorA)) {
+        hslA = [NONE, NONE, NONE, NONE];
+      } else {
+        hslA = convertColorToHsl(colorA, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+      if (REG_CURRENT.test(colorB)) {
+        hslB = [NONE, NONE, NONE, NONE];
+      } else {
+        hslB = convertColorToHsl(colorB, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+    } else {
+      if (REG_CURRENT.test(colorA)) {
+        hslA = [NONE, NONE, NONE, NONE];
+      } else {
+        hslA = convertColorToHwb(colorA, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+      if (REG_CURRENT.test(colorB)) {
+        hslB = [NONE, NONE, NONE, NONE];
+      } else {
+        hslB = convertColorToHwb(colorB, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+    }
+    if (hslA instanceof NullObject || hslB instanceof NullObject) {
+      const res = cacheInvalidColorValue(cacheKey, format, nullable);
+      return res;
+    }
+    const [hhA, ssA, llA, aaA] = hslA;
+    const [hhB, ssB, llB, aaB] = hslB;
+    const alphaNone = aaA === NONE && aaB === NONE;
+    let [[hA, sA, lA, alphaA], [hB, sB, lB, alphaB]] = normalizeColorComponents(
+      [hhA, ssA, llA, aaA],
+      [hhB, ssB, llB, aaB],
+      true
+    );
+    if (hueArc) {
+      [hA, hB] = interpolateHue(hA, hB, hueArc);
+    }
+    const factorA = alphaA * pA;
+    const factorB = alphaB * pB;
+    alpha = factorA + factorB;
+    const h = (hA * pA + hB * pB) % DEG;
+    let s, l;
+    if (alpha === 0) {
+      s = sA * pA + sB * pB;
+      l = lA * pA + lB * pB;
+    } else {
+      s = (sA * factorA + sB * factorB) / alpha;
+      l = (lA * factorA + lB * factorB) / alpha;
+      alpha = parseFloat(alpha.toFixed(3));
+    }
+    [r, g, b] = convertColorToRgb(
+      `${colorSpace}(${h} ${s} ${l})`
+    ) as ColorChannels;
+    if (format === VAL_COMP) {
+      const res: SpecifiedColorChannels = [
+        'srgb',
+        roundToPrecision(r / MAX_RGB, HEX),
+        roundToPrecision(g / MAX_RGB, HEX),
+        roundToPrecision(b / MAX_RGB, HEX),
+        alphaNone ? NONE : alpha * m
+      ];
+      setCache(cacheKey, res);
+      return res;
+    }
+    // in lch, oklch
+  } else if (/^(?:ok)?lch$/.test(colorSpace)) {
+    let lchA, lchB;
+    if (colorSpace === 'lch') {
+      if (REG_CURRENT.test(colorA)) {
+        lchA = [NONE, NONE, NONE, NONE];
+      } else {
+        lchA = convertColorToLch(colorA, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+      if (REG_CURRENT.test(colorB)) {
+        lchB = [NONE, NONE, NONE, NONE];
+      } else {
+        lchB = convertColorToLch(colorB, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+    } else {
+      if (REG_CURRENT.test(colorA)) {
+        lchA = [NONE, NONE, NONE, NONE];
+      } else {
+        lchA = convertColorToOklch(colorA, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+      if (REG_CURRENT.test(colorB)) {
+        lchB = [NONE, NONE, NONE, NONE];
+      } else {
+        lchB = convertColorToOklch(colorB, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+    }
+    if (lchA instanceof NullObject || lchB instanceof NullObject) {
+      const res = cacheInvalidColorValue(cacheKey, format, nullable);
+      return res;
+    }
+    const [llA, ccA, hhA, aaA] = lchA;
+    const [llB, ccB, hhB, aaB] = lchB;
+    const lNone = llA === NONE && llB === NONE;
+    const cNone = ccA === NONE && ccB === NONE;
+    const hNone = hhA === NONE && hhB === NONE;
+    const alphaNone = aaA === NONE && aaB === NONE;
+    let [[lA, cA, hA, alphaA], [lB, cB, hB, alphaB]] = normalizeColorComponents(
+      [llA, ccA, hhA, aaA],
+      [llB, ccB, hhB, aaB],
+      true
+    );
+    if (hueArc) {
+      [hA, hB] = interpolateHue(hA, hB, hueArc);
+    }
+    const factorA = alphaA * pA;
+    const factorB = alphaB * pB;
+    alpha = factorA + factorB;
+    const h = (hA * pA + hB * pB) % DEG;
+    let l, c;
+    if (alpha === 0) {
+      l = lA * pA + lB * pB;
+      c = cA * pA + cB * pB;
+    } else {
+      l = (lA * factorA + lB * factorB) / alpha;
+      c = (cA * factorA + cB * factorB) / alpha;
+      alpha = parseFloat(alpha.toFixed(3));
+    }
+    if (format === VAL_COMP) {
+      const res: SpecifiedColorChannels = [
+        colorSpace,
+        lNone ? NONE : roundToPrecision(l, HEX),
+        cNone ? NONE : roundToPrecision(c, HEX),
+        hNone ? NONE : roundToPrecision(h, HEX),
+        alphaNone ? NONE : alpha * m
+      ];
+      setCache(cacheKey, res);
+      return res;
+    }
+    [, r, g, b] = resolveColorValue(
+      `${colorSpace}(${l} ${c} ${h})`
+    ) as ComputedColorChannels;
+    // in lab, oklab
+  } else {
+    let labA, labB;
+    if (colorSpace === 'lab') {
+      if (REG_CURRENT.test(colorA)) {
+        labA = [NONE, NONE, NONE, NONE];
+      } else {
+        labA = convertColorToLab(colorA, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+      if (REG_CURRENT.test(colorB)) {
+        labB = [NONE, NONE, NONE, NONE];
+      } else {
+        labB = convertColorToLab(colorB, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+    } else {
+      if (REG_CURRENT.test(colorA)) {
+        labA = [NONE, NONE, NONE, NONE];
+      } else {
+        labA = convertColorToOklab(colorA, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+      if (REG_CURRENT.test(colorB)) {
+        labB = [NONE, NONE, NONE, NONE];
+      } else {
+        labB = convertColorToOklab(colorB, {
+          colorSpace,
+          format: VAL_MIX
+        });
+      }
+    }
+    if (labA instanceof NullObject || labB instanceof NullObject) {
+      const res = cacheInvalidColorValue(cacheKey, format, nullable);
+      return res;
+    }
+    const [llA, aaA, bbA, alA] = labA;
+    const [llB, aaB, bbB, alB] = labB;
+    const lNone = llA === NONE && llB === NONE;
+    const aNone = aaA === NONE && aaB === NONE;
+    const bNone = bbA === NONE && bbB === NONE;
+    const alphaNone = alA === NONE && alB === NONE;
+    const [[lA, aA, bA, alphaA], [lB, aB, bB, alphaB]] =
+      normalizeColorComponents(
+        [llA, aaA, bbA, alA],
+        [llB, aaB, bbB, alB],
+        true
+      );
+    const factorA = alphaA * pA;
+    const factorB = alphaB * pB;
+    alpha = factorA + factorB;
+    let l, aO, bO;
+    if (alpha === 0) {
+      l = lA * pA + lB * pB;
+      aO = aA * pA + aB * pB;
+      bO = bA * pA + bB * pB;
+    } else {
+      l = (lA * factorA + lB * factorB) / alpha;
+      aO = (aA * factorA + aB * factorB) / alpha;
+      bO = (bA * factorA + bB * factorB) / alpha;
+      alpha = parseFloat(alpha.toFixed(3));
+    }
+    if (format === VAL_COMP) {
+      const res: SpecifiedColorChannels = [
+        colorSpace,
+        lNone ? NONE : roundToPrecision(l, HEX),
+        aNone ? NONE : roundToPrecision(aO, HEX),
+        bNone ? NONE : roundToPrecision(bO, HEX),
+        alphaNone ? NONE : alpha * m
+      ];
+      setCache(cacheKey, res);
+      return res;
+    }
+    [, r, g, b] = resolveColorValue(
+      `${colorSpace}(${l} ${aO} ${bO})`
+    ) as ComputedColorChannels;
+  }
+  const res: SpecifiedColorChannels = [
+    'rgb',
+    Math.round(r),
+    Math.round(g),
+    Math.round(b),
+    parseFloat((alpha * m).toFixed(3))
+  ];
+  setCache(cacheKey, res);
+  return res;
+};
diff --git a/node_modules/@asamuzakjp/css-color/src/js/common.ts b/node_modules/@asamuzakjp/css-color/src/js/common.ts
new file mode 100644
index 0000000000000000000000000000000000000000..32bf8bdcc54ecc77117cd8f0a63ea89b1d9b0687
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/common.ts
@@ -0,0 +1,31 @@
+/**
+ * common
+ */
+
+/* numeric constants */
+const TYPE_FROM = 8;
+const TYPE_TO = -1;
+
+/**
+ * get type
+ * @param o - object to check
+ * @returns type of object
+ */
+export const getType = (o: unknown): string =>
+  Object.prototype.toString.call(o).slice(TYPE_FROM, TYPE_TO);
+
+/**
+ * is string
+ * @param o - object to check
+ * @returns result
+ */
+export const isString = (o: unknown): o is string =>
+  typeof o === 'string' || o instanceof String;
+
+/**
+ * is string or number
+ * @param o - object to check
+ * @returns result
+ */
+export const isStringOrNumber = (o: unknown): boolean =>
+  isString(o) || typeof o === 'number';
diff --git a/node_modules/@asamuzakjp/css-color/src/js/constant.ts b/node_modules/@asamuzakjp/css-color/src/js/constant.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b33118146b8208412055be3f73b59c4e1ba3358f
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/constant.ts
@@ -0,0 +1,68 @@
+/**
+ * constant
+ */
+
+/* values and units */
+const _DIGIT = '(?:0|[1-9]\\d*)';
+const _COMPARE = 'clamp|max|min';
+const _EXPO = 'exp|hypot|log|pow|sqrt';
+const _SIGN = 'abs|sign';
+const _STEP = 'mod|rem|round';
+const _TRIG = 'a?(?:cos|sin|tan)|atan2';
+const _MATH = `${_COMPARE}|${_EXPO}|${_SIGN}|${_STEP}|${_TRIG}`;
+const _CALC = `calc|${_MATH}`;
+const _VAR = `var|${_CALC}`;
+export const ANGLE = 'deg|g?rad|turn';
+export const LENGTH =
+  '[cm]m|[dls]?v(?:[bhiw]|max|min)|in|p[ctx]|q|r?(?:[cl]h|cap|e[mx]|ic)';
+export const NUM = `[+-]?(?:${_DIGIT}(?:\\.\\d*)?|\\.\\d+)(?:e-?${_DIGIT})?`;
+export const NUM_POSITIVE = `\\+?(?:${_DIGIT}(?:\\.\\d*)?|\\.\\d+)(?:e-?${_DIGIT})?`;
+export const NONE = 'none';
+export const PCT = `${NUM}%`;
+export const SYN_FN_CALC = `^(?:${_CALC})\\(|(?<=[*\\/\\s\\(])(?:${_CALC})\\(`;
+export const SYN_FN_MATH_START = `^(?:${_MATH})\\($`;
+export const SYN_FN_VAR = '^var\\(|(?<=[*\\/\\s\\(])var\\(';
+export const SYN_FN_VAR_START = `^(?:${_VAR})\\(`;
+
+/* colors */
+const _ALPHA = `(?:\\s*\\/\\s*(?:${NUM}|${PCT}|${NONE}))?`;
+const _ALPHA_LV3 = `(?:\\s*,\\s*(?:${NUM}|${PCT}))?`;
+const _COLOR_FUNC = '(?:ok)?l(?:ab|ch)|color|hsla?|hwb|rgba?';
+const _COLOR_KEY = '[a-z]+|#[\\da-f]{3}|#[\\da-f]{4}|#[\\da-f]{6}|#[\\da-f]{8}';
+const _CS_HUE = '(?:ok)?lch|hsl|hwb';
+const _CS_HUE_ARC = '(?:de|in)creasing|longer|shorter';
+const _NUM_ANGLE = `${NUM}(?:${ANGLE})?`;
+const _NUM_ANGLE_NONE = `(?:${NUM}(?:${ANGLE})?|${NONE})`;
+const _NUM_PCT_NONE = `(?:${NUM}|${PCT}|${NONE})`;
+export const CS_HUE = `(?:${_CS_HUE})(?:\\s(?:${_CS_HUE_ARC})\\shue)?`;
+export const CS_HUE_CAPT = `(${_CS_HUE})(?:\\s(${_CS_HUE_ARC})\\shue)?`;
+export const CS_LAB = '(?:ok)?lab';
+export const CS_LCH = '(?:ok)?lch';
+export const CS_SRGB = 'srgb(?:-linear)?';
+export const CS_RGB = `(?:a98|prophoto)-rgb|display-p3|rec2020|${CS_SRGB}`;
+export const CS_XYZ = 'xyz(?:-d(?:50|65))?';
+export const CS_RECT = `${CS_LAB}|${CS_RGB}|${CS_XYZ}`;
+export const CS_MIX = `${CS_HUE}|${CS_RECT}`;
+export const FN_COLOR = 'color(';
+export const FN_LIGHT_DARK = 'light-dark(';
+export const FN_MIX = 'color-mix(';
+export const FN_REL = `(?:${_COLOR_FUNC})\\(\\s*from\\s+`;
+export const FN_REL_CAPT = `(${_COLOR_FUNC})\\(\\s*from\\s+`;
+export const FN_VAR = 'var(';
+export const SYN_FN_COLOR = `(?:${CS_RGB}|${CS_XYZ})(?:\\s+${_NUM_PCT_NONE}){3}${_ALPHA}`;
+export const SYN_FN_LIGHT_DARK = '^light-dark\\(';
+export const SYN_FN_REL = `^${FN_REL}|(?<=[\\s])${FN_REL}`;
+export const SYN_HSL = `${_NUM_ANGLE_NONE}(?:\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;
+export const SYN_HSL_LV3 = `${_NUM_ANGLE}(?:\\s*,\\s*${PCT}){2}${_ALPHA_LV3}`;
+export const SYN_LCH = `(?:${_NUM_PCT_NONE}\\s+){2}${_NUM_ANGLE_NONE}${_ALPHA}`;
+export const SYN_MOD = `${_NUM_PCT_NONE}(?:\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;
+export const SYN_RGB_LV3 = `(?:${NUM}(?:\\s*,\\s*${NUM}){2}|${PCT}(?:\\s*,\\s*${PCT}){2})${_ALPHA_LV3}`;
+export const SYN_COLOR_TYPE = `${_COLOR_KEY}|hsla?\\(\\s*${SYN_HSL_LV3}\\s*\\)|rgba?\\(\\s*${SYN_RGB_LV3}\\s*\\)|(?:hsla?|hwb)\\(\\s*${SYN_HSL}\\s*\\)|(?:(?:ok)?lab|rgba?)\\(\\s*${SYN_MOD}\\s*\\)|(?:ok)?lch\\(\\s*${SYN_LCH}\\s*\\)|color\\(\\s*${SYN_FN_COLOR}\\s*\\)`;
+export const SYN_MIX_PART = `(?:${SYN_COLOR_TYPE})(?:\\s+${PCT})?`;
+export const SYN_MIX = `color-mix\\(\\s*in\\s+(?:${CS_MIX})\\s*,\\s*${SYN_MIX_PART}\\s*,\\s*${SYN_MIX_PART}\\s*\\)`;
+export const SYN_MIX_CAPT = `color-mix\\(\\s*in\\s+(${CS_MIX})\\s*,\\s*(${SYN_MIX_PART})\\s*,\\s*(${SYN_MIX_PART})\\s*\\)`;
+
+/* formats */
+export const VAL_COMP = 'computedValue';
+export const VAL_MIX = 'mixValue';
+export const VAL_SPEC = 'specifiedValue';
diff --git a/node_modules/@asamuzakjp/css-color/src/js/convert.ts b/node_modules/@asamuzakjp/css-color/src/js/convert.ts
new file mode 100644
index 0000000000000000000000000000000000000000..104bf965d889b2e77d99546a25cc0903a18a518c
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/convert.ts
@@ -0,0 +1,331 @@
+/**
+ * convert
+ */
+
+import {
+  CacheItem,
+  NullObject,
+  createCacheKey,
+  getCache,
+  setCache
+} from './cache';
+import {
+  convertColorToHsl,
+  convertColorToHwb,
+  convertColorToLab,
+  convertColorToLch,
+  convertColorToOklab,
+  convertColorToOklch,
+  convertColorToRgb,
+  numberToHexString,
+  parseColorFunc,
+  parseColorValue
+} from './color';
+import { isString } from './common';
+import { cssCalc } from './css-calc';
+import { resolveVar } from './css-var';
+import { resolveRelativeColor } from './relative-color';
+import { resolveColor } from './resolve';
+import { ColorChannels, ComputedColorChannels, Options } from './typedef';
+
+/* constants */
+import { SYN_FN_CALC, SYN_FN_REL, SYN_FN_VAR, VAL_COMP } from './constant';
+const NAMESPACE = 'convert';
+
+/* regexp */
+const REG_FN_CALC = new RegExp(SYN_FN_CALC);
+const REG_FN_REL = new RegExp(SYN_FN_REL);
+const REG_FN_VAR = new RegExp(SYN_FN_VAR);
+
+/**
+ * pre process
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns value
+ */
+export const preProcess = (
+  value: string,
+  opt: Options = {}
+): string | NullObject => {
+  if (!isString(value)) {
+    return new NullObject();
+  }
+  value = value.trim();
+  if (!value) {
+    return new NullObject();
+  }
+  const cacheKey: string = createCacheKey(
+    { namespace: NAMESPACE, name: 'preProcess', value },
+    opt
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    if (cachedResult.isNull) {
+      return cachedResult as NullObject;
+    }
+    return cachedResult.item as string;
+  }
+  let res: string | NullObject = value;
+  if (REG_FN_VAR.test(value)) {
+    const resolved = resolveVar(value, opt);
+    if (isString(resolved)) {
+      res = resolved;
+    } else {
+      setCache(cacheKey, null);
+      return new NullObject();
+    }
+  }
+  if (isString(res)) {
+    if (REG_FN_REL.test(res)) {
+      const resolved = resolveRelativeColor(res, opt);
+      if (isString(resolved)) {
+        res = resolved;
+      } else {
+        setCache(cacheKey, null);
+        return new NullObject();
+      }
+    } else if (REG_FN_CALC.test(res)) {
+      res = cssCalc(res, opt);
+    }
+  }
+  if (isString(res)) {
+    if (res.startsWith('color-mix')) {
+      res = resolveColor(res, { ...opt, format: VAL_COMP, nullable: true });
+    }
+  }
+  setCache(cacheKey, res);
+  return res;
+};
+
+/**
+ * converter factory to reduce boilerplate
+ * @param name - function name for cache
+ * @param format - color format
+ * @param convertFn - conversion function
+ * @returns color converter function
+ */
+const createColorConverter = (
+  name: string,
+  format: string,
+  convertFn: Function
+) => {
+  const colorConverterFn = (
+    value: string,
+    opt: Options = {}
+  ): ColorChannels => {
+    if (!isString(value)) {
+      throw new TypeError(`${value} is not a string.`);
+    }
+    const resolved = preProcess(value, opt);
+    if (resolved instanceof NullObject) {
+      return [0, 0, 0, 0];
+    }
+    const val = resolved.toLowerCase();
+    const cacheKey = createCacheKey(
+      { namespace: NAMESPACE, name, value: val },
+      opt
+    );
+    const cached = getCache(cacheKey);
+    if (cached instanceof CacheItem) {
+      return cached.item as ColorChannels;
+    }
+    const result = convertFn(val, { ...opt, format }) as ColorChannels;
+    setCache(cacheKey, result);
+    return result;
+  };
+  return colorConverterFn;
+};
+
+/**
+ * convert number to hex string
+ * @param value - numeric value
+ * @returns hex string: 00..ff
+ */
+export const numberToHex = (value: number): string => numberToHexString(value);
+
+/**
+ * convert color to hex
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @param [opt.alpha] - enable alpha channel
+ * @returns #rrggbb | #rrggbbaa | null
+ */
+export const colorToHex = (value: string, opt: Options = {}): string | null => {
+  if (!isString(value)) {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const resolved = preProcess(value, opt);
+  if (resolved instanceof NullObject) {
+    return null;
+  }
+  const val = resolved.toLowerCase();
+  const cacheKey = createCacheKey(
+    { namespace: NAMESPACE, name: 'colorToHex', value: val },
+    opt
+  );
+  const cached = getCache(cacheKey);
+  if (cached instanceof CacheItem) {
+    if (cached.isNull) {
+      return null;
+    }
+    return cached.item as string;
+  }
+  const hex = resolveColor(val, {
+    ...opt,
+    nullable: true,
+    format: opt.alpha ? 'hexAlpha' : 'hex'
+  });
+  if (isString(hex)) {
+    setCache(cacheKey, hex);
+    return hex;
+  }
+  setCache(cacheKey, null);
+  return null;
+};
+
+/**
+ * convert color to hsl
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [h, s, l, alpha]
+ */
+export const colorToHsl = createColorConverter(
+  'colorToHsl',
+  'hsl',
+  convertColorToHsl
+);
+
+/**
+ * convert color to hwb
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [h, w, b, alpha]
+ */
+export const colorToHwb = createColorConverter(
+  'colorToHwb',
+  'hwb',
+  convertColorToHwb
+);
+
+/**
+ * convert color to lab
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [l, a, b, alpha]
+ */
+export const colorToLab = createColorConverter(
+  'colorToLab',
+  'lab',
+  convertColorToLab
+);
+
+/**
+ * convert color to lch
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [l, c, h, alpha]
+ */
+export const colorToLch = createColorConverter(
+  'colorToLch',
+  'lch',
+  convertColorToLch
+);
+
+/**
+ * convert color to oklab
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [l, a, b, alpha]
+ */
+export const colorToOklab = createColorConverter(
+  'colorToOklab',
+  'oklab',
+  convertColorToOklab
+);
+
+/**
+ * convert color to oklch
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [l, c, h, alpha]
+ */
+export const colorToOklch = createColorConverter(
+  'colorToOklch',
+  'oklch',
+  convertColorToOklch
+);
+
+/**
+ * convert color to rgb
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [r, g, b, alpha]
+ */
+export const colorToRgb = createColorConverter(
+  'colorToRgb',
+  'rgb',
+  convertColorToRgb
+);
+
+/**
+ * convert color to xyz
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [x, y, z, alpha]
+ */
+export const colorToXyz = (value: string, opt: Options = {}): ColorChannels => {
+  if (!isString(value)) {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const resolved = preProcess(value, opt);
+  if (resolved instanceof NullObject) {
+    return [0, 0, 0, 0];
+  }
+  const val = resolved.toLowerCase();
+  const cacheKey = createCacheKey(
+    { namespace: NAMESPACE, name: 'colorToXyz', value: val },
+    opt
+  );
+  const cached = getCache(cacheKey);
+  if (cached instanceof CacheItem) {
+    return cached.item as ColorChannels;
+  }
+  let parsed;
+  if (val.startsWith('color(')) {
+    parsed = parseColorFunc(val, opt);
+  } else {
+    parsed = parseColorValue(val, opt);
+  }
+  const [, ...xyz] = parsed as ComputedColorChannels;
+  setCache(cacheKey, xyz);
+  return xyz as ColorChannels;
+};
+
+/**
+ * convert color to xyz-d50
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns ColorChannels - [x, y, z, alpha]
+ */
+export const colorToXyzD50 = (
+  value: string,
+  opt: Options = {}
+): ColorChannels => {
+  opt.d50 = true;
+  return colorToXyz(value, opt);
+};
+
+/* convert */
+export const convert = {
+  colorToHex,
+  colorToHsl,
+  colorToHwb,
+  colorToLab,
+  colorToLch,
+  colorToOklab,
+  colorToOklch,
+  colorToRgb,
+  colorToXyz,
+  colorToXyzD50,
+  numberToHex
+};
diff --git a/node_modules/@asamuzakjp/css-color/src/js/css-calc.ts b/node_modules/@asamuzakjp/css-color/src/js/css-calc.ts
new file mode 100644
index 0000000000000000000000000000000000000000..62e9a23bd9e548e934748687baa9ce5028b405a3
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/css-calc.ts
@@ -0,0 +1,1008 @@
+/**
+ * css-calc
+ */
+
+import { calc, conversionOptions as CalcOptions } from '@csstools/css-calc';
+import { CSSToken, TokenType, tokenize } from '@csstools/css-tokenizer';
+import {
+  CacheItem,
+  NullObject,
+  createCacheKey,
+  getCache,
+  setCache
+} from './cache';
+import { isString, isStringOrNumber } from './common';
+import { resolveVar } from './css-var';
+import { resolveLengthInPixels, roundToPrecision } from './util';
+import { MatchedRegExp, Options } from './typedef';
+
+/* constants */
+import {
+  ANGLE,
+  LENGTH,
+  NUM,
+  SYN_FN_CALC,
+  SYN_FN_MATH_START,
+  SYN_FN_VAR,
+  SYN_FN_VAR_START,
+  VAL_SPEC
+} from './constant';
+const {
+  CloseParen: PAREN_CLOSE,
+  Comment: COMMENT,
+  Dimension: DIM,
+  EOF,
+  Function: FUNC,
+  OpenParen: PAREN_OPEN,
+  Whitespace: W_SPACE
+} = TokenType;
+const NAMESPACE = 'css-calc';
+
+/* numeric constants */
+const TRIA = 3;
+const HEX = 16;
+const MAX_PCT = 100;
+
+/* regexp */
+const REG_FN_CALC = new RegExp(SYN_FN_CALC);
+const REG_FN_CALC_NUM = new RegExp(`^calc\\((${NUM})\\)$`);
+const REG_FN_MATH_START = new RegExp(SYN_FN_MATH_START);
+const REG_FN_VAR = new RegExp(SYN_FN_VAR);
+const REG_FN_VAR_START = new RegExp(SYN_FN_VAR_START);
+const REG_OPERATOR = /\s[*+/-]\s/;
+const REG_PAREN_OPEN = /\($/;
+const REG_TYPE_DIM = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH})$`);
+const REG_TYPE_DIM_PCT = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH}|%)$`);
+const REG_TYPE_PCT = new RegExp(`^(${NUM})%$`);
+
+/**
+ * Calclator
+ */
+export class Calculator {
+  /* private */
+  // number
+  #hasNum: boolean;
+  #numSum: number[];
+  #numMul: number[];
+  // percentage
+  #hasPct: boolean;
+  #pctSum: number[];
+  #pctMul: number[];
+  // dimension
+  #hasDim: boolean;
+  #dimSum: string[];
+  #dimSub: string[];
+  #dimMul: string[];
+  #dimDiv: string[];
+  // et cetra
+  #hasEtc: boolean;
+  #etcSum: string[];
+  #etcSub: string[];
+  #etcMul: string[];
+  #etcDiv: string[];
+  // calc options
+  #calcOpts: CalcOptions;
+
+  /**
+   * constructor
+   */
+  constructor() {
+    // number
+    this.#hasNum = false;
+    this.#numSum = [];
+    this.#numMul = [];
+    // percentage
+    this.#hasPct = false;
+    this.#pctSum = [];
+    this.#pctMul = [];
+    // dimension
+    this.#hasDim = false;
+    this.#dimSum = [];
+    this.#dimSub = [];
+    this.#dimMul = [];
+    this.#dimDiv = [];
+    // et cetra
+    this.#hasEtc = false;
+    this.#etcSum = [];
+    this.#etcSub = [];
+    this.#etcMul = [];
+    this.#etcDiv = [];
+    // calc options
+    this.#calcOpts = {
+      toCanonicalUnits: true
+    };
+  }
+
+  get hasNum() {
+    return this.#hasNum;
+  }
+
+  set hasNum(value: boolean) {
+    this.#hasNum = !!value;
+  }
+
+  get numSum() {
+    return this.#numSum;
+  }
+
+  get numMul() {
+    return this.#numMul;
+  }
+
+  get hasPct() {
+    return this.#hasPct;
+  }
+
+  set hasPct(value: boolean) {
+    this.#hasPct = !!value;
+  }
+
+  get pctSum() {
+    return this.#pctSum;
+  }
+
+  get pctMul() {
+    return this.#pctMul;
+  }
+
+  get hasDim() {
+    return this.#hasDim;
+  }
+
+  set hasDim(value: boolean) {
+    this.#hasDim = !!value;
+  }
+
+  get dimSum() {
+    return this.#dimSum;
+  }
+
+  get dimSub() {
+    return this.#dimSub;
+  }
+
+  get dimMul() {
+    return this.#dimMul;
+  }
+
+  get dimDiv() {
+    return this.#dimDiv;
+  }
+
+  get hasEtc() {
+    return this.#hasEtc;
+  }
+
+  set hasEtc(value: boolean) {
+    this.#hasEtc = !!value;
+  }
+
+  get etcSum() {
+    return this.#etcSum;
+  }
+
+  get etcSub() {
+    return this.#etcSub;
+  }
+
+  get etcMul() {
+    return this.#etcMul;
+  }
+
+  get etcDiv() {
+    return this.#etcDiv;
+  }
+
+  /**
+   * clear values
+   * @returns void
+   */
+  clear() {
+    // number
+    this.#hasNum = false;
+    this.#numSum.length = 0;
+    this.#numMul.length = 0;
+    // percentage
+    this.#hasPct = false;
+    this.#pctSum.length = 0;
+    this.#pctMul.length = 0;
+    // dimension
+    this.#hasDim = false;
+    this.#dimSum.length = 0;
+    this.#dimSub.length = 0;
+    this.#dimMul.length = 0;
+    this.#dimDiv.length = 0;
+    // et cetra
+    this.#hasEtc = false;
+    this.#etcSum.length = 0;
+    this.#etcSub.length = 0;
+    this.#etcMul.length = 0;
+    this.#etcDiv.length = 0;
+  }
+
+  /**
+   * sort values
+   * @param values - values
+   * @returns sorted values
+   */
+  sort(values: string[] = []): string[] {
+    const arr = [...values];
+    if (arr.length > 1) {
+      arr.sort((a, b) => {
+        let res;
+        if (REG_TYPE_DIM_PCT.test(a) && REG_TYPE_DIM_PCT.test(b)) {
+          const [, valA, unitA] = a.match(REG_TYPE_DIM_PCT) as MatchedRegExp;
+          const [, valB, unitB] = b.match(REG_TYPE_DIM_PCT) as MatchedRegExp;
+          if (unitA === unitB) {
+            if (Number(valA) === Number(valB)) {
+              res = 0;
+            } else if (Number(valA) > Number(valB)) {
+              res = 1;
+            } else {
+              res = -1;
+            }
+          } else if (unitA > unitB) {
+            res = 1;
+          } else {
+            res = -1;
+          }
+        } else {
+          if (a === b) {
+            res = 0;
+          } else if (a > b) {
+            res = 1;
+          } else {
+            res = -1;
+          }
+        }
+        return res;
+      });
+    }
+    return arr;
+  }
+
+  /**
+   * multiply values
+   * @returns resolved value
+   */
+  multiply(): string {
+    const value = [];
+    let num;
+    if (this.#hasNum) {
+      num = 1;
+      for (const i of this.#numMul) {
+        num *= i;
+        if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) {
+          break;
+        }
+      }
+      if (!this.#hasPct && !this.#hasDim && !this.hasEtc) {
+        if (Number.isFinite(num)) {
+          num = roundToPrecision(num, HEX);
+        }
+        value.push(num);
+      }
+    }
+    if (this.#hasPct) {
+      if (typeof num !== 'number') {
+        num = 1;
+      }
+      for (const i of this.#pctMul) {
+        num *= i;
+        if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) {
+          break;
+        }
+      }
+      if (Number.isFinite(num)) {
+        num = `${roundToPrecision(num, HEX)}%`;
+      }
+      if (!this.#hasDim && !this.hasEtc) {
+        value.push(num);
+      }
+    }
+    if (this.#hasDim) {
+      let dim = '';
+      let mul = '';
+      let div = '';
+      if (this.#dimMul.length) {
+        if (this.#dimMul.length === 1) {
+          [mul] = this.#dimMul as [string];
+        } else {
+          mul = `${this.sort(this.#dimMul).join(' * ')}`;
+        }
+      }
+      if (this.#dimDiv.length) {
+        if (this.#dimDiv.length === 1) {
+          [div] = this.#dimDiv as [string];
+        } else {
+          div = `${this.sort(this.#dimDiv).join(' * ')}`;
+        }
+      }
+      if (Number.isFinite(num)) {
+        if (mul) {
+          if (div) {
+            if (div.includes('*')) {
+              dim = calc(`calc(${num} * ${mul} / (${div}))`, this.#calcOpts);
+            } else {
+              dim = calc(`calc(${num} * ${mul} / ${div})`, this.#calcOpts);
+            }
+          } else {
+            dim = calc(`calc(${num} * ${mul})`, this.#calcOpts);
+          }
+        } else if (div.includes('*')) {
+          dim = calc(`calc(${num} / (${div}))`, this.#calcOpts);
+        } else {
+          dim = calc(`calc(${num} / ${div})`, this.#calcOpts);
+        }
+        value.push(dim.replace(/^calc/, ''));
+      } else {
+        if (!value.length && num !== undefined) {
+          value.push(num);
+        }
+        if (mul) {
+          if (div) {
+            if (div.includes('*')) {
+              dim = calc(`calc(${mul} / (${div}))`, this.#calcOpts);
+            } else {
+              dim = calc(`calc(${mul} / ${div})`, this.#calcOpts);
+            }
+          } else {
+            dim = calc(`calc(${mul})`, this.#calcOpts);
+          }
+          if (value.length) {
+            value.push('*', dim.replace(/^calc/, ''));
+          } else {
+            value.push(dim.replace(/^calc/, ''));
+          }
+        } else {
+          dim = calc(`calc(${div})`, this.#calcOpts);
+          if (value.length) {
+            value.push('/', dim.replace(/^calc/, ''));
+          } else {
+            value.push('1', '/', dim.replace(/^calc/, ''));
+          }
+        }
+      }
+    }
+    if (this.#hasEtc) {
+      if (this.#etcMul.length) {
+        if (!value.length && num !== undefined) {
+          value.push(num);
+        }
+        const mul = this.sort(this.#etcMul).join(' * ');
+        if (value.length) {
+          value.push(`* ${mul}`);
+        } else {
+          value.push(`${mul}`);
+        }
+      }
+      if (this.#etcDiv.length) {
+        const div = this.sort(this.#etcDiv).join(' * ');
+        if (div.includes('*')) {
+          if (value.length) {
+            value.push(`/ (${div})`);
+          } else {
+            value.push(`1 / (${div})`);
+          }
+        } else if (value.length) {
+          value.push(`/ ${div}`);
+        } else {
+          value.push(`1 / ${div}`);
+        }
+      }
+    }
+    if (value.length) {
+      return value.join(' ');
+    }
+    return '';
+  }
+
+  /**
+   * sum values
+   * @returns resolved value
+   */
+  sum(): string {
+    const value = [];
+    if (this.#hasNum) {
+      let num = 0;
+      for (const i of this.#numSum) {
+        num += i;
+        if (!Number.isFinite(num) || Number.isNaN(num)) {
+          break;
+        }
+      }
+      value.push(num);
+    }
+    if (this.#hasPct) {
+      let num: number | string = 0;
+      for (const i of this.#pctSum) {
+        num += i;
+        if (!Number.isFinite(num)) {
+          break;
+        }
+      }
+      if (Number.isFinite(num)) {
+        num = `${num}%`;
+      }
+      if (value.length) {
+        value.push(`+ ${num}`);
+      } else {
+        value.push(num);
+      }
+    }
+    if (this.#hasDim) {
+      let dim, sum, sub;
+      if (this.#dimSum.length) {
+        sum = this.sort(this.#dimSum).join(' + ');
+      }
+      if (this.#dimSub.length) {
+        sub = this.sort(this.#dimSub).join(' + ');
+      }
+      if (sum) {
+        if (sub) {
+          if (sub.includes('-')) {
+            dim = calc(`calc(${sum} - (${sub}))`, this.#calcOpts);
+          } else {
+            dim = calc(`calc(${sum} - ${sub})`, this.#calcOpts);
+          }
+        } else {
+          dim = calc(`calc(${sum})`, this.#calcOpts);
+        }
+      } else {
+        dim = calc(`calc(-1 * (${sub}))`, this.#calcOpts);
+      }
+      if (value.length) {
+        value.push('+', dim.replace(/^calc/, ''));
+      } else {
+        value.push(dim.replace(/^calc/, ''));
+      }
+    }
+    if (this.#hasEtc) {
+      if (this.#etcSum.length) {
+        const sum = this.sort(this.#etcSum)
+          .map(item => {
+            let res;
+            if (
+              REG_OPERATOR.test(item) &&
+              !item.startsWith('(') &&
+              !item.endsWith(')')
+            ) {
+              res = `(${item})`;
+            } else {
+              res = item;
+            }
+            return res;
+          })
+          .join(' + ');
+        if (value.length) {
+          if (this.#etcSum.length > 1) {
+            value.push(`+ (${sum})`);
+          } else {
+            value.push(`+ ${sum}`);
+          }
+        } else {
+          value.push(`${sum}`);
+        }
+      }
+      if (this.#etcSub.length) {
+        const sub = this.sort(this.#etcSub)
+          .map(item => {
+            let res;
+            if (
+              REG_OPERATOR.test(item) &&
+              !item.startsWith('(') &&
+              !item.endsWith(')')
+            ) {
+              res = `(${item})`;
+            } else {
+              res = item;
+            }
+            return res;
+          })
+          .join(' + ');
+        if (value.length) {
+          if (this.#etcSub.length > 1) {
+            value.push(`- (${sub})`);
+          } else {
+            value.push(`- ${sub}`);
+          }
+        } else if (this.#etcSub.length > 1) {
+          value.push(`-1 * (${sub})`);
+        } else {
+          value.push(`-1 * ${sub}`);
+        }
+      }
+    }
+    if (value.length) {
+      return value.join(' ');
+    }
+    return '';
+  }
+}
+
+/**
+ * sort calc values
+ * @param values - values to sort
+ * @param [finalize] - finalize values
+ * @returns sorted values
+ */
+export const sortCalcValues = (
+  values: (number | string)[] = [],
+  finalize: boolean = false
+): string => {
+  if (values.length < TRIA) {
+    throw new Error(`Unexpected array length ${values.length}.`);
+  }
+  const start = values.shift();
+  if (!isString(start) || !start.endsWith('(')) {
+    throw new Error(`Unexpected token ${start}.`);
+  }
+  const end = values.pop();
+  if (end !== ')') {
+    throw new Error(`Unexpected token ${end}.`);
+  }
+  if (values.length === 1) {
+    const [value] = values;
+    if (!isStringOrNumber(value)) {
+      throw new Error(`Unexpected token ${value}.`);
+    }
+    return `${start}${value}${end}`;
+  }
+  const sortedValues = [];
+  const cal = new Calculator();
+  let operator: string = '';
+  const l = values.length;
+  // Array traversal optimization for operator check
+  let hasAddSub = false;
+  for (let i = 0; i < l; i++) {
+    const value = values[i];
+    if (!isStringOrNumber(value)) {
+      throw new Error(`Unexpected token ${value}.`);
+    }
+    if (value === '*' || value === '/') {
+      operator = value;
+    } else if (value === '+' || value === '-') {
+      const sortedValue = cal.multiply();
+      if (sortedValue) {
+        sortedValues.push(sortedValue, value);
+      }
+      // Mark presence of + or -
+      hasAddSub = true;
+      cal.clear();
+      operator = '';
+    } else {
+      const numValue = Number(value);
+      const strValue = `${value}`;
+      switch (operator) {
+        case '/': {
+          if (Number.isFinite(numValue)) {
+            cal.hasNum = true;
+            cal.numMul.push(1 / numValue);
+          } else if (REG_TYPE_PCT.test(strValue)) {
+            const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;
+            cal.hasPct = true;
+            cal.pctMul.push((MAX_PCT * MAX_PCT) / Number(val));
+          } else if (REG_TYPE_DIM.test(strValue)) {
+            cal.hasDim = true;
+            cal.dimDiv.push(strValue);
+          } else {
+            cal.hasEtc = true;
+            cal.etcDiv.push(strValue);
+          }
+          break;
+        }
+        case '*':
+        default: {
+          if (Number.isFinite(numValue)) {
+            cal.hasNum = true;
+            cal.numMul.push(numValue);
+          } else if (REG_TYPE_PCT.test(strValue)) {
+            const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;
+            cal.hasPct = true;
+            cal.pctMul.push(Number(val));
+          } else if (REG_TYPE_DIM.test(strValue)) {
+            cal.hasDim = true;
+            cal.dimMul.push(strValue);
+          } else {
+            cal.hasEtc = true;
+            cal.etcMul.push(strValue);
+          }
+        }
+      }
+    }
+    if (i === l - 1) {
+      const sortedValue = cal.multiply();
+      if (sortedValue) {
+        sortedValues.push(sortedValue);
+      }
+      cal.clear();
+      operator = '';
+    }
+  }
+  let resolvedValue = '';
+  if (finalize && hasAddSub) {
+    const finalizedValues = [];
+    cal.clear();
+    operator = '';
+    const l = sortedValues.length;
+    for (let i = 0; i < l; i++) {
+      const value = sortedValues[i];
+      if (isStringOrNumber(value)) {
+        if (value === '+' || value === '-') {
+          operator = value;
+        } else {
+          const numValue = Number(value);
+          const strValue = `${value}`;
+          switch (operator) {
+            case '-': {
+              if (Number.isFinite(numValue)) {
+                cal.hasNum = true;
+                cal.numSum.push(-1 * numValue);
+              } else if (REG_TYPE_PCT.test(strValue)) {
+                const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;
+                cal.hasPct = true;
+                cal.pctSum.push(-1 * Number(val));
+              } else if (REG_TYPE_DIM.test(strValue)) {
+                cal.hasDim = true;
+                cal.dimSub.push(strValue);
+              } else {
+                cal.hasEtc = true;
+                cal.etcSub.push(strValue);
+              }
+              break;
+            }
+            case '+':
+            default: {
+              if (Number.isFinite(numValue)) {
+                cal.hasNum = true;
+                cal.numSum.push(numValue);
+              } else if (REG_TYPE_PCT.test(strValue)) {
+                const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;
+                cal.hasPct = true;
+                cal.pctSum.push(Number(val));
+              } else if (REG_TYPE_DIM.test(strValue)) {
+                cal.hasDim = true;
+                cal.dimSum.push(strValue);
+              } else {
+                cal.hasEtc = true;
+                cal.etcSum.push(strValue);
+              }
+            }
+          }
+        }
+      }
+      if (i === l - 1) {
+        const sortedValue = cal.sum();
+        if (sortedValue) {
+          finalizedValues.push(sortedValue);
+        }
+        cal.clear();
+        operator = '';
+      }
+    }
+    resolvedValue = finalizedValues.join(' ').replace(/\+\s-/g, '- ');
+  } else {
+    resolvedValue = sortedValues.join(' ').replace(/\+\s-/g, '- ');
+  }
+  if (
+    resolvedValue.startsWith('(') &&
+    resolvedValue.endsWith(')') &&
+    resolvedValue.lastIndexOf('(') === 0 &&
+    resolvedValue.indexOf(')') === resolvedValue.length - 1
+  ) {
+    resolvedValue = resolvedValue.substring(1, resolvedValue.length - 1);
+  }
+  return `${start}${resolvedValue}${end}`;
+};
+
+/**
+ * resolve AST node
+ * @param node - AST node
+ * @param isRoot - is root node
+ * @returns resolved value
+ */
+const resolveNode = (node: any[], isRoot: boolean): string => {
+  const flatItems: string[] = [];
+  for (const item of node) {
+    if (Array.isArray(item)) {
+      flatItems.push(resolveNode(item, false));
+    } else {
+      flatItems.push(item as string);
+    }
+  }
+  if (isRoot) {
+    if (flatItems.length >= TRIA) {
+      return sortCalcValues(flatItems, true);
+    }
+    const joined = flatItems.join('');
+    return joined.startsWith('calc(') ? joined : `calc(${joined})`;
+  }
+  if (flatItems.length >= TRIA) {
+    let serialized = sortCalcValues(flatItems, false);
+    if (REG_FN_VAR_START.test(serialized)) {
+      serialized = calc(serialized, { toCanonicalUnits: true });
+    }
+    return serialized;
+  }
+  return flatItems.join('');
+};
+
+/**
+ * serialize calc
+ * @param value - CSS value
+ * @param [opt] - options
+ * @returns serialized value
+ */
+export const serializeCalc = (value: string, opt: Options = {}): string => {
+  const { format = '' } = opt;
+  if (isString(value)) {
+    if (!REG_FN_VAR_START.test(value) || format !== VAL_SPEC) {
+      return value;
+    }
+    value = value.toLowerCase().trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const cacheKey: string = createCacheKey(
+    {
+      namespace: NAMESPACE,
+      name: 'serializeCalc',
+      value
+    },
+    opt
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    return cachedResult.item as string;
+  }
+  const items: string[] = tokenize({ css: value })
+    .map((token: CSSToken): string => {
+      const [type, val] = token as [TokenType, string];
+      let res = '';
+      if (type !== W_SPACE && type !== COMMENT) {
+        res = val;
+      }
+      return res;
+    })
+    .filter(v => v);
+  const stack: any[][] = [[]];
+  for (const item of items) {
+    if (REG_PAREN_OPEN.test(item)) {
+      const newNode = [item];
+      const parent = stack[stack.length - 1];
+      if (parent) {
+        parent.push(newNode);
+      }
+      stack.push(newNode);
+    } else if (item === ')') {
+      if (stack.length > 1) {
+        const currentLevel = stack.pop();
+        if (currentLevel) {
+          currentLevel.push(item);
+        }
+      } else {
+        const root = stack[0];
+        if (root) {
+          root.push(item);
+        }
+      }
+    } else {
+      const parent = stack[stack.length - 1];
+      if (parent) {
+        parent.push(item);
+      }
+    }
+  }
+  let serializedCalc = '';
+  const rootItems = stack[0];
+  if (rootItems) {
+    if (rootItems.length === 1 && Array.isArray(rootItems[0])) {
+      serializedCalc = resolveNode(rootItems[0], true);
+    } else {
+      const flatItems: string[] = [];
+      for (const item of rootItems) {
+        if (Array.isArray(item)) {
+          flatItems.push(resolveNode(item, false));
+        } else {
+          flatItems.push(item as string);
+        }
+      }
+      if (flatItems.length >= TRIA) {
+        serializedCalc = sortCalcValues(flatItems, true);
+      } else {
+        const firstItem = flatItems[0] || '';
+        serializedCalc =
+          isString(firstItem) && firstItem.startsWith('calc(')
+            ? firstItem
+            : `calc(${firstItem})`;
+      }
+    }
+  }
+  setCache(cacheKey, serializedCalc);
+  return serializedCalc;
+};
+
+/**
+ * resolve dimension
+ * @param token - CSS token
+ * @param [opt] - options
+ * @returns resolved value
+ */
+export const resolveDimension = (
+  token: CSSToken,
+  opt: Options = {}
+): string | NullObject => {
+  if (!Array.isArray(token)) {
+    throw new TypeError(`${token} is not an array.`);
+  }
+  const [, , , , detail = {}] = token;
+  const { unit, value } = detail as {
+    unit: string;
+    value: number;
+  };
+  if (unit === 'px') {
+    return `${value}${unit}`;
+  }
+  const pixelValue = resolveLengthInPixels(Number(value), unit, opt);
+  if (Number.isFinite(pixelValue)) {
+    return `${roundToPrecision(pixelValue, HEX)}px`;
+  }
+  return new NullObject();
+};
+
+/**
+ * parse tokens
+ * @param tokens - CSS tokens
+ * @param [opt] - options
+ * @returns parsed tokens
+ */
+export const parseTokens = (
+  tokens: CSSToken[],
+  opt: Options = {}
+): string[] => {
+  if (!Array.isArray(tokens)) {
+    throw new TypeError(`${tokens} is not an array.`);
+  }
+  const { format = '' } = opt;
+  const mathFunc = new Set();
+  let nest = 0;
+  const res: string[] = [];
+  for (const token of tokens) {
+    if (!Array.isArray(token)) {
+      throw new TypeError(`${token} is not an array.`);
+    }
+    const [type = '', value = ''] = token as [TokenType, string];
+    switch (type) {
+      case DIM: {
+        if (format === VAL_SPEC && !mathFunc.has(nest)) {
+          res.push(value);
+        } else {
+          const resolvedValue = resolveDimension(token, opt);
+          if (isString(resolvedValue)) {
+            res.push(resolvedValue);
+          } else {
+            res.push(value);
+          }
+        }
+        break;
+      }
+      case FUNC:
+      case PAREN_OPEN: {
+        res.push(value);
+        nest++;
+        if (REG_FN_MATH_START.test(value)) {
+          mathFunc.add(nest);
+        }
+        break;
+      }
+      case PAREN_CLOSE: {
+        if (res.length) {
+          const lastValue = res[res.length - 1];
+          if (lastValue === ' ') {
+            res.splice(-1, 1, value);
+          } else {
+            res.push(value);
+          }
+        } else {
+          res.push(value);
+        }
+        if (mathFunc.has(nest)) {
+          mathFunc.delete(nest);
+        }
+        nest--;
+        break;
+      }
+      case W_SPACE: {
+        if (res.length) {
+          const lastValue = res[res.length - 1];
+          if (
+            isString(lastValue) &&
+            !lastValue.endsWith('(') &&
+            lastValue !== ' '
+          ) {
+            res.push(value);
+          }
+        }
+        break;
+      }
+      default: {
+        if (type !== COMMENT && type !== EOF) {
+          res.push(value);
+        }
+      }
+    }
+  }
+  return res;
+};
+
+/**
+ * CSS calc()
+ * @param value - CSS value including calc()
+ * @param [opt] - options
+ * @returns resolved value
+ */
+export const cssCalc = (value: string, opt: Options = {}): string => {
+  const { format = '' } = opt;
+  if (isString(value)) {
+    if (REG_FN_VAR.test(value)) {
+      if (format === VAL_SPEC) {
+        return value;
+      } else {
+        const resolvedValue = resolveVar(value, opt);
+        if (isString(resolvedValue)) {
+          return resolvedValue;
+        } else {
+          return '';
+        }
+      }
+    } else if (!REG_FN_CALC.test(value)) {
+      return value;
+    }
+    value = value.toLowerCase().trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const cacheKey: string = createCacheKey(
+    {
+      namespace: NAMESPACE,
+      name: 'cssCalc',
+      value
+    },
+    opt
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    return cachedResult.item as string;
+  }
+  const tokens = tokenize({ css: value });
+  const values = parseTokens(tokens, opt);
+  let resolvedValue: string = calc(values.join(''), {
+    toCanonicalUnits: true
+  });
+  if (REG_FN_VAR_START.test(value)) {
+    if (REG_TYPE_DIM_PCT.test(resolvedValue)) {
+      const [, val, unit] = resolvedValue.match(
+        REG_TYPE_DIM_PCT
+      ) as MatchedRegExp;
+      resolvedValue = `${roundToPrecision(Number(val), HEX)}${unit}`;
+    }
+    // wrap with `calc()`
+    if (
+      resolvedValue &&
+      !REG_FN_VAR_START.test(resolvedValue) &&
+      format === VAL_SPEC
+    ) {
+      resolvedValue = `calc(${resolvedValue})`;
+    }
+  }
+  if (format === VAL_SPEC) {
+    if (/\s[-+*/]\s/.test(resolvedValue) && !resolvedValue.includes('NaN')) {
+      resolvedValue = serializeCalc(resolvedValue, opt);
+    } else if (REG_FN_CALC_NUM.test(resolvedValue)) {
+      const [, val] = resolvedValue.match(REG_FN_CALC_NUM) as MatchedRegExp;
+      resolvedValue = `calc(${roundToPrecision(Number(val), HEX)})`;
+    }
+  }
+  setCache(cacheKey, resolvedValue);
+  return resolvedValue;
+};
diff --git a/node_modules/@asamuzakjp/css-color/src/js/css-gradient.ts b/node_modules/@asamuzakjp/css-color/src/js/css-gradient.ts
new file mode 100644
index 0000000000000000000000000000000000000000..76be1728082396f345cd1c8e17660cf2c1e51721
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/css-gradient.ts
@@ -0,0 +1,374 @@
+/**
+ * css-gradient
+ */
+
+import { CacheItem, createCacheKey, getCache, setCache } from './cache';
+import { resolveColor } from './resolve';
+import { isString } from './common';
+import { MatchedRegExp, Options } from './typedef';
+import { isColor, splitValue } from './util';
+
+/* constants */
+import {
+  ANGLE,
+  CS_HUE,
+  CS_RECT,
+  LENGTH,
+  NUM,
+  NUM_POSITIVE,
+  PCT,
+  VAL_COMP,
+  VAL_SPEC
+} from './constant';
+const NAMESPACE = 'css-gradient';
+const DIM_ANGLE = `${NUM}(?:${ANGLE})`;
+const DIM_ANGLE_PCT = `${DIM_ANGLE}|${PCT}`;
+const DIM_LEN = `${NUM}(?:${LENGTH})|0`;
+const DIM_LEN_PCT = `${DIM_LEN}|${PCT}`;
+const DIM_LEN_PCT_POSI = `${NUM_POSITIVE}(?:${LENGTH}|%)|0`;
+const DIM_LEN_POSI = `${NUM_POSITIVE}(?:${LENGTH})|0`;
+const CTR = 'center';
+const L_R = 'left|right';
+const T_B = 'top|bottom';
+const S_E = 'start|end';
+const AXIS_X = `${L_R}|x-(?:${S_E})`;
+const AXIS_Y = `${T_B}|y-(?:${S_E})`;
+const BLOCK = `block-(?:${S_E})`;
+const INLINE = `inline-(?:${S_E})`;
+const POS_1 = `${CTR}|${AXIS_X}|${AXIS_Y}|${BLOCK}|${INLINE}|${DIM_LEN_PCT}`;
+const POS_2 = [
+  `(?:${CTR}|${AXIS_X})\\s+(?:${CTR}|${AXIS_Y})`,
+  `(?:${CTR}|${AXIS_Y})\\s+(?:${CTR}|${AXIS_X})`,
+  `(?:${CTR}|${AXIS_X}|${DIM_LEN_PCT})\\s+(?:${CTR}|${AXIS_Y}|${DIM_LEN_PCT})`,
+  `(?:${CTR}|${BLOCK})\\s+(?:${CTR}|${INLINE})`,
+  `(?:${CTR}|${INLINE})\\s+(?:${CTR}|${BLOCK})`,
+  `(?:${CTR}|${S_E})\\s+(?:${CTR}|${S_E})`
+].join('|');
+const POS_4 = [
+  `(?:${AXIS_X})\\s+(?:${DIM_LEN_PCT})\\s+(?:${AXIS_Y})\\s+(?:${DIM_LEN_PCT})`,
+  `(?:${AXIS_Y})\\s+(?:${DIM_LEN_PCT})\\s+(?:${AXIS_X})\\s+(?:${DIM_LEN_PCT})`,
+  `(?:${BLOCK})\\s+(?:${DIM_LEN_PCT})\\s+(?:${INLINE})\\s+(?:${DIM_LEN_PCT})`,
+  `(?:${INLINE})\\s+(?:${DIM_LEN_PCT})\\s+(?:${BLOCK})\\s+(?:${DIM_LEN_PCT})`,
+  `(?:${S_E})\\s+(?:${DIM_LEN_PCT})\\s+(?:${S_E})\\s+(?:${DIM_LEN_PCT})`
+].join('|');
+const RAD_EXTENT = '(?:clos|farth)est-(?:corner|side)';
+const RAD_SIZE = [
+  `${RAD_EXTENT}(?:\\s+${RAD_EXTENT})?`,
+  `${DIM_LEN_POSI}`,
+  `(?:${DIM_LEN_PCT_POSI})\\s+(?:${DIM_LEN_PCT_POSI})`
+].join('|');
+const RAD_SHAPE = 'circle|ellipse';
+const FROM_ANGLE = `from\\s+${DIM_ANGLE}`;
+const AT_POSITION = `at\\s+(?:${POS_1}|${POS_2}|${POS_4})`;
+const TO_SIDE_CORNER = `to\\s+(?:(?:${L_R})(?:\\s(?:${T_B}))?|(?:${T_B})(?:\\s(?:${L_R}))?)`;
+const IN_COLOR_SPACE = `in\\s+(?:${CS_RECT}|${CS_HUE})`;
+const LINE_SYNTAX_LINEAR = [
+  `(?:${DIM_ANGLE}|${TO_SIDE_CORNER})(?:\\s+${IN_COLOR_SPACE})?`,
+  `${IN_COLOR_SPACE}(?:\\s+(?:${DIM_ANGLE}|${TO_SIDE_CORNER}))?`
+].join('|');
+const LINE_SYNTAX_RADIAL = [
+  `(?:${RAD_SHAPE})(?:\\s+(?:${RAD_SIZE}))?(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
+  `(?:${RAD_SIZE})(?:\\s+(?:${RAD_SHAPE}))?(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
+  `${AT_POSITION}(?:\\s+${IN_COLOR_SPACE})?`,
+  `${IN_COLOR_SPACE}(?:\\s+${RAD_SHAPE})(?:\\s+(?:${RAD_SIZE}))?(?:\\s+${AT_POSITION})?`,
+  `${IN_COLOR_SPACE}(?:\\s+${RAD_SIZE})(?:\\s+(?:${RAD_SHAPE}))?(?:\\s+${AT_POSITION})?`,
+  `${IN_COLOR_SPACE}(?:\\s+${AT_POSITION})?`
+].join('|');
+const LINE_SYNTAX_CONIC = [
+  `${FROM_ANGLE}(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
+  `${AT_POSITION}(?:\\s+${IN_COLOR_SPACE})?`,
+  `${IN_COLOR_SPACE}(?:\\s+${FROM_ANGLE})?(?:\\s+${AT_POSITION})?`
+].join('|');
+const DEFAULT_LINEAR = [/to\s+bottom/];
+const DEFAULT_RADIAL = [/ellipse/, /farthest-corner/, /at\s+center/];
+const DEFAULT_CONIC = [/at\s+center/];
+
+/* type definitions */
+/**
+ * @type ColorStopList - list of color stops
+ */
+type ColorStopList = [string, string, ...string[]];
+
+/**
+ * @typedef ValidateGradientLine - validate gradient line
+ * @property line - gradient line
+ * @property valid - result
+ */
+interface ValidateGradientLine {
+  line: string;
+  valid: boolean;
+}
+
+/**
+ * @typedef ValidateColorStops - validate color stops
+ * @property colorStops - list of color stops
+ * @property valid - result
+ */
+interface ValidateColorStops {
+  colorStops: string[];
+  valid: boolean;
+}
+
+/**
+ * @typedef Gradient - parsed CSS gradient
+ * @property value - input value
+ * @property type - gradient type
+ * @property [gradientLine] - gradient line
+ * @property colorStopList - list of color stops
+ */
+interface Gradient {
+  value: string;
+  type: string;
+  gradientLine?: string;
+  colorStopList: ColorStopList;
+}
+
+/* regexp */
+const IS_CONIC = /^(?:repeating-)?conic-gradient$/;
+const IS_LINEAR = /^(?:repeating-)?linear-gradient$/;
+const IS_RADIAL = /^(?:repeating-)?radial-gradient$/;
+const REG_COLOR_HINT_CONIC = new RegExp(`^(?:${DIM_ANGLE_PCT})$`);
+const REG_COLOR_HINT_NON_CONIC = new RegExp(`^(?:${DIM_LEN_PCT})$`);
+const REG_DIM_CONIC = new RegExp(`(?:\\s+(?:${DIM_ANGLE_PCT})){1,2}$`);
+const REG_DIM_NON_CONIC = new RegExp(`(?:\\s+(?:${DIM_LEN_PCT})){1,2}$`);
+const REG_GRAD = /^(?:repeating-)?(?:conic|linear|radial)-gradient\(/;
+const REG_GRAD_CAPT = /^((?:repeating-)?(?:conic|linear|radial)-gradient)\(/;
+const REG_LINE_CONIC = new RegExp(`^(?:${LINE_SYNTAX_CONIC})$`);
+const REG_LINE_LINEAR = new RegExp(`^(?:${LINE_SYNTAX_LINEAR})$`);
+const REG_LINE_RADIAL = new RegExp(`^(?:${LINE_SYNTAX_RADIAL})$`);
+
+/**
+ * get gradient type
+ * @param value - gradient value
+ * @returns gradient type
+ */
+export const getGradientType = (value: string): string => {
+  if (isString(value)) {
+    value = value.trim();
+    if (REG_GRAD.test(value)) {
+      const [, type] = value.match(REG_GRAD_CAPT) as MatchedRegExp;
+      return type;
+    }
+  }
+  return '';
+};
+
+/**
+ * validate gradient line
+ * @param value - gradient line value
+ * @param type - gradient type
+ * @returns result
+ */
+export const validateGradientLine = (
+  value: string,
+  type: string
+): ValidateGradientLine => {
+  if (isString(value) && isString(type)) {
+    value = value.trim();
+    type = type.trim();
+    let reg: RegExp | null = null;
+    let defaultValues: RegExp[] = [];
+
+    if (IS_LINEAR.test(type)) {
+      reg = REG_LINE_LINEAR;
+      defaultValues = DEFAULT_LINEAR;
+    } else if (IS_RADIAL.test(type)) {
+      reg = REG_LINE_RADIAL;
+      defaultValues = DEFAULT_RADIAL;
+    } else if (IS_CONIC.test(type)) {
+      reg = REG_LINE_CONIC;
+      defaultValues = DEFAULT_CONIC;
+    }
+    if (reg) {
+      const valid = reg.test(value);
+      if (valid) {
+        let line = value;
+        for (const defaultValue of defaultValues) {
+          line = line.replace(defaultValue, '');
+        }
+        line = line.replace(/\s{2,}/g, ' ').trim();
+        return { line, valid };
+      }
+      return { valid, line: value };
+    }
+  }
+  return { line: value, valid: false };
+};
+
+/**
+ * validate color stop list
+ * @param list
+ * @param type
+ * @param [opt]
+ * @returns result
+ */
+export const validateColorStopList = (
+  list: string[],
+  type: string,
+  opt: Options = {}
+): ValidateColorStops => {
+  if (Array.isArray(list) && list.length > 1) {
+    const isConic = IS_CONIC.test(type);
+    const regColorHint = isConic
+      ? REG_COLOR_HINT_CONIC
+      : REG_COLOR_HINT_NON_CONIC;
+    const regDimension = isConic ? REG_DIM_CONIC : REG_DIM_NON_CONIC;
+    const valueList: string[] = [];
+    // State tracker: 'color' or 'hint'
+    let prevType = '';
+    for (let i = 0; i < list.length; i++) {
+      const item = list[i];
+      if (isString(item)) {
+        if (regColorHint.test(item)) {
+          // Hints cannot be the first item, and two hints cannot be adjacent
+          if (i === 0 || prevType === 'hint') {
+            return { colorStops: list, valid: false };
+          }
+          prevType = 'hint';
+          valueList.push(item);
+        } else {
+          const itemColor = item.replace(regDimension, '');
+          if (isColor(itemColor, { format: VAL_SPEC })) {
+            const resolvedColor = resolveColor(itemColor, opt) as string;
+            prevType = 'color';
+            valueList.push(item.replace(itemColor, resolvedColor));
+          } else {
+            return { colorStops: list, valid: false };
+          }
+        }
+      } else {
+        return { colorStops: list, valid: false };
+      }
+    }
+    // The last item must be a color, not a hint
+    if (prevType !== 'color') {
+      return { colorStops: list, valid: false };
+    }
+    return { valid: true, colorStops: valueList };
+  }
+  return { colorStops: list, valid: false };
+};
+
+/**
+ * parse CSS gradient
+ * @param value - gradient value
+ * @param [opt] - options
+ * @returns parsed result
+ */
+export const parseGradient = (
+  value: string,
+  opt: Options = {}
+): Gradient | null => {
+  if (isString(value)) {
+    value = value.trim();
+    const cacheKey: string = createCacheKey(
+      {
+        namespace: NAMESPACE,
+        name: 'parseGradient',
+        value
+      },
+      opt
+    );
+    const cachedResult = getCache(cacheKey);
+    if (cachedResult instanceof CacheItem) {
+      if (cachedResult.isNull) {
+        return null;
+      }
+      return cachedResult.item as Gradient;
+    }
+    const type = getGradientType(value);
+    const gradValue = value.replace(REG_GRAD, '').replace(/\)$/, '');
+    if (type && gradValue) {
+      const [lineOrColorStop = '', ...itemList] = splitValue(gradValue, {
+        delimiter: ','
+      });
+      const isConic = IS_CONIC.test(type);
+      const regDimension = isConic ? REG_DIM_CONIC : REG_DIM_NON_CONIC;
+      let colorStop = '';
+      if (regDimension.test(lineOrColorStop)) {
+        const itemColor = lineOrColorStop.replace(regDimension, '');
+        if (isColor(itemColor, { format: VAL_SPEC })) {
+          const resolvedColor = resolveColor(itemColor, opt) as string;
+          colorStop = lineOrColorStop.replace(itemColor, resolvedColor);
+        }
+      } else if (isColor(lineOrColorStop, { format: VAL_SPEC })) {
+        colorStop = resolveColor(lineOrColorStop, opt) as string;
+      }
+      if (colorStop) {
+        itemList.unshift(colorStop);
+        const { colorStops, valid } = validateColorStopList(
+          itemList,
+          type,
+          opt
+        );
+        if (valid) {
+          const res: Gradient = {
+            value,
+            type,
+            colorStopList: colorStops as ColorStopList
+          };
+          setCache(cacheKey, res);
+          return res;
+        }
+      } else if (itemList.length > 1) {
+        const { line: gradientLine, valid: validLine } = validateGradientLine(
+          lineOrColorStop,
+          type
+        );
+        const { colorStops, valid: validColorStops } = validateColorStopList(
+          itemList,
+          type,
+          opt
+        );
+        if (validLine && validColorStops) {
+          const res: Gradient = {
+            value,
+            type,
+            gradientLine,
+            colorStopList: colorStops as ColorStopList
+          };
+          setCache(cacheKey, res);
+          return res;
+        }
+      }
+    }
+    setCache(cacheKey, null);
+    return null;
+  }
+  return null;
+};
+
+/**
+ * resolve CSS gradient
+ * @param value - CSS value
+ * @param [opt] - options
+ * @returns result
+ */
+export const resolveGradient = (value: string, opt: Options = {}): string => {
+  const { format = VAL_COMP } = opt;
+  const gradient = parseGradient(value, opt);
+  if (gradient) {
+    const { type = '', gradientLine = '', colorStopList = [] } = gradient;
+    if (type && Array.isArray(colorStopList) && colorStopList.length > 1) {
+      if (gradientLine) {
+        return `${type}(${gradientLine}, ${colorStopList.join(', ')})`;
+      }
+      return `${type}(${colorStopList.join(', ')})`;
+    }
+  }
+  if (format === VAL_SPEC) {
+    return '';
+  }
+  return 'none';
+};
+
+/**
+ * is CSS gradient
+ * @param value - CSS value
+ * @param [opt] - options
+ * @returns result
+ */
+export const isGradient = (value: string, opt: Options = {}): boolean => {
+  const gradient = parseGradient(value, opt);
+  return gradient !== null;
+};
diff --git a/node_modules/@asamuzakjp/css-color/src/js/css-var.ts b/node_modules/@asamuzakjp/css-color/src/js/css-var.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a488eddcbba268a98fb8129af6c0e356aab9e184
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/css-var.ts
@@ -0,0 +1,236 @@
+/**
+ * css-var
+ */
+
+import { CSSToken, TokenType, tokenize } from '@csstools/css-tokenizer';
+import {
+  CacheItem,
+  NullObject,
+  createCacheKey,
+  getCache,
+  setCache
+} from './cache';
+import { isString } from './common';
+import { cssCalc } from './css-calc';
+import { isColor } from './util';
+import { Options } from './typedef';
+
+/* constants */
+import { FN_VAR, SYN_FN_CALC, SYN_FN_VAR, VAL_SPEC } from './constant';
+const {
+  CloseParen: PAREN_CLOSE,
+  Comment: COMMENT,
+  EOF,
+  Ident: IDENT,
+  Whitespace: W_SPACE
+} = TokenType;
+const NAMESPACE = 'css-var';
+
+/* regexp */
+const REG_FN_CALC = new RegExp(SYN_FN_CALC);
+const REG_FN_VAR = new RegExp(SYN_FN_VAR);
+const REG_CSS_WIDE_KEYWORD = /^(?:inherit|initial|revert(?:-layer)?|unset)$/;
+
+/**
+ * resolve custom property
+ * @param tokens - CSS tokens
+ * @param [opt] - options
+ * @returns result - [tokens, resolvedValue]
+ */
+export function resolveCustomProperty(
+  tokens: CSSToken[],
+  opt: Options = {}
+): [CSSToken[], string] {
+  if (!Array.isArray(tokens)) {
+    throw new TypeError(`${tokens} is not an array.`);
+  }
+  const { customProperty = {} } = opt;
+  const items: string[] = [];
+  while (tokens.length) {
+    const token = tokens.shift();
+    if (!token) {
+      break;
+    }
+    if (!Array.isArray(token)) {
+      throw new TypeError(`${token} is not an array.`);
+    }
+    const [type, value] = token as [TokenType, string];
+    // end of var()
+    if (type === PAREN_CLOSE) {
+      break;
+    }
+    // nested var()
+    if (value === FN_VAR) {
+      const [, item] = resolveCustomProperty(tokens, opt);
+      if (item) {
+        items.push(item);
+      }
+    } else if (type === IDENT) {
+      if (value.startsWith('--')) {
+        let item;
+        if (Object.hasOwn(customProperty, value)) {
+          item = customProperty[value] as string;
+        } else if (typeof customProperty.callback === 'function') {
+          item = customProperty.callback(value);
+        }
+        if (item) {
+          items.push(item);
+        }
+      } else if (value) {
+        items.push(value);
+      }
+    }
+  }
+  let resolveAsColor = false;
+  if (items.length > 1) {
+    resolveAsColor = isColor(items[items.length - 1]);
+  }
+  let resolvedValue = '';
+  for (let item of items) {
+    item = item.trim();
+    if (REG_FN_VAR.test(item)) {
+      // recurse resolveVar()
+      const resolvedItem = resolveVar(item, opt);
+      if (isString(resolvedItem)) {
+        if (!resolveAsColor || isColor(resolvedItem)) {
+          resolvedValue = resolvedItem;
+        }
+      }
+    } else if (REG_FN_CALC.test(item)) {
+      item = cssCalc(item, opt);
+      if (!resolveAsColor || isColor(item)) {
+        resolvedValue = item;
+      }
+    } else if (item && !REG_CSS_WIDE_KEYWORD.test(item)) {
+      if (!resolveAsColor || isColor(item)) {
+        resolvedValue = item;
+      }
+    }
+    if (resolvedValue) {
+      break;
+    }
+  }
+  return [tokens, resolvedValue];
+}
+
+/**
+ * parse tokens
+ * @param tokens - CSS tokens
+ * @param [opt] - options
+ * @returns parsed tokens
+ */
+export function parseTokens(
+  tokens: CSSToken[],
+  opt: Options = {}
+): string[] | NullObject {
+  const res: string[] = [];
+  while (tokens.length) {
+    const token = tokens.shift();
+    if (!token) break;
+    const [type = '', value = ''] = token as [TokenType, string];
+    if (value === FN_VAR) {
+      const [, resolvedValue] = resolveCustomProperty(tokens, opt);
+      if (!resolvedValue) {
+        return new NullObject();
+      }
+      res.push(resolvedValue);
+    } else {
+      switch (type) {
+        case PAREN_CLOSE: {
+          if (res.length) {
+            if (res[res.length - 1] === ' ') {
+              res[res.length - 1] = value;
+            } else {
+              res.push(value);
+            }
+          } else {
+            res.push(value);
+          }
+          break;
+        }
+        case W_SPACE: {
+          if (res.length) {
+            const lastValue = res[res.length - 1];
+            if (
+              isString(lastValue) &&
+              !lastValue.endsWith('(') &&
+              lastValue !== ' '
+            ) {
+              res.push(value);
+            }
+          }
+          break;
+        }
+        default: {
+          if (type !== COMMENT && type !== EOF) {
+            res.push(value);
+          }
+        }
+      }
+    }
+  }
+  return res;
+}
+
+/**
+ * resolve CSS var()
+ * @param value - CSS value including var()
+ * @param [opt] - options
+ * @returns resolved value
+ */
+export function resolveVar(
+  value: string,
+  opt: Options = {}
+): string | NullObject {
+  const { format = '' } = opt;
+  if (isString(value)) {
+    if (!REG_FN_VAR.test(value) || format === VAL_SPEC) {
+      return value;
+    }
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const cacheKey: string = createCacheKey(
+    {
+      namespace: NAMESPACE,
+      name: 'resolveVar',
+      value
+    },
+    opt
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    if (cachedResult.isNull) {
+      return cachedResult as NullObject;
+    }
+    return cachedResult.item as string;
+  }
+  const tokens = tokenize({ css: value });
+  const values = parseTokens(tokens, opt);
+  if (Array.isArray(values)) {
+    let color = values.join('');
+    if (REG_FN_CALC.test(color)) {
+      color = cssCalc(color, opt);
+    }
+    setCache(cacheKey, color);
+    return color;
+  } else {
+    setCache(cacheKey, null);
+    return new NullObject();
+  }
+}
+
+/**
+ * CSS var()
+ * @param value - CSS value including var()
+ * @param [opt] - options
+ * @returns resolved value
+ */
+export const cssVar = (value: string, opt: Options = {}): string => {
+  const resolvedValue = resolveVar(value, opt);
+  if (isString(resolvedValue)) {
+    return resolvedValue;
+  }
+  return '';
+};
diff --git a/node_modules/@asamuzakjp/css-color/src/js/relative-color.ts b/node_modules/@asamuzakjp/css-color/src/js/relative-color.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dedee92f52ef3c573fbc826abddf928f811de3ec
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/relative-color.ts
@@ -0,0 +1,673 @@
+/**
+ * relative-color
+ */
+
+import { SyntaxFlag, color as colorParser } from '@csstools/css-color-parser';
+import {
+  ComponentValue,
+  parseComponentValue
+} from '@csstools/css-parser-algorithms';
+import { CSSToken, TokenType, tokenize } from '@csstools/css-tokenizer';
+import {
+  CacheItem,
+  NullObject,
+  createCacheKey,
+  getCache,
+  setCache
+} from './cache';
+import { NAMED_COLORS, convertColorToRgb } from './color';
+import { isString, isStringOrNumber } from './common';
+import { resolveDimension, serializeCalc } from './css-calc';
+import { resolveColor } from './resolve';
+import { roundToPrecision, splitValue } from './util';
+import {
+  ColorChannels,
+  MatchedRegExp,
+  Options,
+  StringColorChannels
+} from './typedef';
+
+/* constants */
+import {
+  CS_LAB,
+  CS_LCH,
+  FN_LIGHT_DARK,
+  FN_REL,
+  FN_REL_CAPT,
+  FN_VAR,
+  NONE,
+  SYN_COLOR_TYPE,
+  SYN_FN_MATH_START,
+  SYN_FN_VAR,
+  SYN_MIX,
+  VAL_SPEC
+} from './constant';
+const {
+  CloseParen: PAREN_CLOSE,
+  Comment: COMMENT,
+  Delim: DELIM,
+  Dimension: DIM,
+  EOF,
+  Function: FUNC,
+  Ident: IDENT,
+  Number: NUM,
+  OpenParen: PAREN_OPEN,
+  Percentage: PCT,
+  Whitespace: W_SPACE
+} = TokenType;
+const { HasNoneKeywords: KEY_NONE } = SyntaxFlag;
+const NAMESPACE = 'relative-color';
+
+/* constants */
+const OCT = 8;
+const DEC = 10;
+const HEX = 16;
+const MAX_PCT = 100;
+const MAX_RGB = 255;
+const COLOR_CHANNELS = new Map([
+  ['color', ['r', 'g', 'b', 'alpha']],
+  ['hsl', ['h', 's', 'l', 'alpha']],
+  ['hsla', ['h', 's', 'l', 'alpha']],
+  ['hwb', ['h', 'w', 'b', 'alpha']],
+  ['lab', ['l', 'a', 'b', 'alpha']],
+  ['lch', ['l', 'c', 'h', 'alpha']],
+  ['oklab', ['l', 'a', 'b', 'alpha']],
+  ['oklch', ['l', 'c', 'h', 'alpha']],
+  ['rgb', ['r', 'g', 'b', 'alpha']],
+  ['rgba', ['r', 'g', 'b', 'alpha']]
+]);
+
+/* type definitions */
+/**
+ * @type NumberOrStringColorChannels - color channel
+ */
+type NumberOrStringColorChannels = ColorChannels & StringColorChannels;
+
+/* regexp */
+const REG_COLOR_CAPT = new RegExp(
+  `^${FN_REL}(${SYN_COLOR_TYPE}|${SYN_MIX})\\s+`
+);
+const REG_CS_HSL = /(?:hsla?|hwb)$/;
+const REG_CS_CIE = new RegExp(`^(?:${CS_LAB}|${CS_LCH})$`);
+const REG_FN_CALC_SUM = /^(?:abs|sig?n|cos|tan)\(/;
+const REG_FN_MATH_START = new RegExp(SYN_FN_MATH_START);
+const REG_FN_REL = new RegExp(FN_REL);
+const REG_FN_REL_CAPT = new RegExp(`^${FN_REL_CAPT}`);
+const REG_FN_REL_START = new RegExp(`^${FN_REL}`);
+const REG_FN_VAR = new RegExp(SYN_FN_VAR);
+
+/**
+ * resolve relative color channels
+ * @param value
+ *   - CSS color value
+ *   - system colors are not supported
+ * @param [opt] - options
+ * @param [opt.currentColor]
+ *   - color to use for `currentcolor` keyword
+ *   - if omitted, it will be treated as a missing color
+ *     i.e. `rgb(none none none / none)`
+ * @param [opt.customProperty]
+ *   - custom properties
+ *   - pair of `--` prefixed property name and value,
+ *     e.g. `customProperty: { '--some-color': '#0000ff' }`
+ *   - and/or `callback` function to get the value of the custom property,
+ *     e.g. `customProperty: { callback: someDeclaration.getPropertyValue }`
+ * @param [opt.dimension]
+ *   - dimension, convert relative length to pixels
+ *   - pair of unit and it's value as a number in pixels,
+ *     e.g. `dimension: { em: 12, rem: 16, vw: 10.26 }`
+ *   - and/or `callback` function to get the value as a number in pixels,
+ *     e.g. `dimension: { callback: convertUnitToPixel }`
+ * @param [opt.format]
+ *   - output format, one of below
+ *   - `computedValue` (default), [computed value][139] of the color
+ *   - `specifiedValue`, [specified value][140] of the color
+ *   - `hex`, hex color notation, i.e. `rrggbb`
+ *   - `hexAlpha`, hex color notation with alpha channel, i.e. `#rrggbbaa`
+ * @returns
+ *   - one of rgba?(), #rrggbb(aa)?, color-name, '(empty-string)',
+ *     color(color-space r g b / alpha), color(color-space x y z / alpha),
+ *     lab(l a b / alpha), lch(l c h / alpha), oklab(l a b / alpha),
+ *     oklch(l c h / alpha), null
+ *   - in `computedValue`, values are numbers, however `rgb()` values are
+ *     integers
+ *   - in `specifiedValue`, returns `empty string` for unknown and/or invalid
+ *     color
+ *   - in `hex`, returns `null` for `transparent`, and also returns `null` if
+ *     any of `r`, `g`, `b`, `alpha` is not a number
+ *   - in `hexAlpha`, returns `#00000000` for `transparent`,
+ *     however returns `null` if any of `r`, `g`, `b`, `alpha` is not a number
+ */
+export function resolveColorChannels(
+  tokens: CSSToken[],
+  opt: Options = {}
+): NumberOrStringColorChannels | NullObject {
+  if (!Array.isArray(tokens)) {
+    throw new TypeError(`${tokens} is not an array.`);
+  }
+  const { colorSpace = '', format = '' } = opt;
+  const colorChannel = COLOR_CHANNELS.get(colorSpace);
+  // invalid color channel
+  if (!colorChannel) {
+    return new NullObject();
+  }
+  const mathFunc = new Set();
+  const channels: [
+    (number | string)[],
+    (number | string)[],
+    (number | string)[],
+    (number | string)[]
+  ] = [[], [], [], []];
+  let i = 0;
+  let nest = 0;
+  let func = '';
+  let precededPct = false;
+  for (const token of tokens) {
+    if (!Array.isArray(token)) {
+      throw new TypeError(`${token} is not an array.`);
+    }
+    const [type, value, , , detail] = token as [
+      TokenType,
+      string,
+      number,
+      number,
+      { value: string | number } | undefined
+    ];
+    const channel = channels[i];
+    if (Array.isArray(channel)) {
+      switch (type) {
+        case DELIM: {
+          if (func) {
+            if (
+              (value === '+' || value === '-') &&
+              precededPct &&
+              !REG_FN_CALC_SUM.test(func)
+            ) {
+              return new NullObject();
+            }
+            precededPct = false;
+            channel.push(value);
+          }
+          break;
+        }
+        case DIM: {
+          if (!func || !REG_FN_CALC_SUM.test(func)) {
+            return new NullObject();
+          }
+          const resolvedValue = resolveDimension(token, opt);
+          if (isString(resolvedValue)) {
+            channel.push(resolvedValue);
+          } else {
+            channel.push(value);
+          }
+          break;
+        }
+        case FUNC: {
+          channel.push(value);
+          func = value;
+          nest++;
+          if (REG_FN_MATH_START.test(value)) {
+            mathFunc.add(nest);
+          }
+          break;
+        }
+        case IDENT: {
+          // invalid channel key
+          if (!colorChannel.includes(value)) {
+            return new NullObject();
+          }
+          channel.push(value);
+          if (!func) {
+            i++;
+          }
+          break;
+        }
+        case NUM: {
+          channel.push(Number(detail?.value));
+          if (!func) {
+            i++;
+          }
+          break;
+        }
+        case PAREN_OPEN: {
+          channel.push(value);
+          nest++;
+          break;
+        }
+        case PAREN_CLOSE: {
+          if (func) {
+            const lastValue = channel[channel.length - 1];
+            if (lastValue === ' ') {
+              channel[channel.length - 1] = value;
+            } else {
+              channel.push(value);
+            }
+            if (mathFunc.has(nest)) {
+              mathFunc.delete(nest);
+            }
+            nest--;
+            if (nest === 0) {
+              func = '';
+              i++;
+            }
+          }
+          break;
+        }
+        case PCT: {
+          if (!func) {
+            return new NullObject();
+          } else if (!REG_FN_CALC_SUM.test(func)) {
+            let lastValue: string | number | undefined;
+            for (let j = channel.length - 1; j >= 0; j--) {
+              if (channel[j] !== ' ') {
+                lastValue = channel[j];
+                break;
+              }
+            }
+            if (lastValue === '+' || lastValue === '-') {
+              return new NullObject();
+            } else if (lastValue === '*' || lastValue === '/') {
+              precededPct = false;
+            } else {
+              precededPct = true;
+            }
+          }
+          channel.push(Number(detail?.value) / MAX_PCT);
+          break;
+        }
+        case W_SPACE: {
+          if (channel.length && func) {
+            const lastValue = channel[channel.length - 1];
+            if (typeof lastValue === 'number') {
+              channel.push(value);
+            } else if (
+              isString(lastValue) &&
+              !lastValue.endsWith('(') &&
+              lastValue !== ' '
+            ) {
+              channel.push(value);
+            }
+          }
+          break;
+        }
+        default: {
+          if (type !== COMMENT && type !== EOF && func) {
+            channel.push(value);
+          }
+        }
+      }
+    }
+  }
+  const channelValues = [];
+  for (const channel of channels) {
+    if (channel.length === 1) {
+      const [resolvedValue] = channel;
+      if (isStringOrNumber(resolvedValue)) {
+        channelValues.push(resolvedValue);
+      }
+    } else if (channel.length) {
+      const resolvedValue = serializeCalc(channel.join(''), {
+        format
+      });
+      channelValues.push(resolvedValue);
+    }
+  }
+  return channelValues as NumberOrStringColorChannels;
+}
+
+/**
+ * extract origin color
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns origin color value
+ */
+export function extractOriginColor(
+  value: string,
+  opt: Options = {}
+): string | NullObject {
+  const { colorScheme = 'normal', currentColor = '', format = '' } = opt;
+  if (isString(value)) {
+    value = value.toLowerCase().trim();
+    if (!value) {
+      return new NullObject();
+    }
+    if (!REG_FN_REL_START.test(value)) {
+      return value;
+    }
+  } else {
+    return new NullObject();
+  }
+  const cacheKey: string = createCacheKey(
+    {
+      namespace: NAMESPACE,
+      name: 'extractOriginColor',
+      value
+    },
+    opt
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    if (cachedResult.isNull) {
+      return cachedResult as NullObject;
+    }
+    return cachedResult.item as string;
+  }
+  if (/currentcolor/.test(value)) {
+    if (currentColor) {
+      value = value.replace(/currentcolor/g, currentColor);
+    } else {
+      setCache(cacheKey, null);
+      return new NullObject();
+    }
+  }
+  let colorSpace = '';
+  if (REG_FN_REL_CAPT.test(value)) {
+    [, colorSpace] = value.match(REG_FN_REL_CAPT) as MatchedRegExp;
+  }
+  opt.colorSpace = colorSpace;
+  if (value.includes(FN_LIGHT_DARK)) {
+    const colorParts = value
+      .replace(new RegExp(`^${colorSpace}\\(`), '')
+      .replace(/\)$/, '');
+    const [, originColor = ''] = splitValue(colorParts);
+    const specifiedOriginColor = resolveColor(originColor, {
+      colorScheme,
+      format: VAL_SPEC
+    }) as string;
+    if (specifiedOriginColor === '') {
+      setCache(cacheKey, null);
+      return new NullObject();
+    }
+    if (format === VAL_SPEC) {
+      value = value.replace(originColor, specifiedOriginColor);
+    } else {
+      const resolvedOriginColor = resolveColor(specifiedOriginColor, opt);
+      if (isString(resolvedOriginColor)) {
+        value = value.replace(originColor, resolvedOriginColor);
+      }
+    }
+  }
+  if (REG_COLOR_CAPT.test(value)) {
+    const [, originColor] = value.match(REG_COLOR_CAPT) as MatchedRegExp;
+    const [, restValue] = value.split(originColor) as MatchedRegExp;
+    if (/^[a-z]+$/.test(originColor)) {
+      if (
+        !/^transparent$/.test(originColor) &&
+        !Object.hasOwn(NAMED_COLORS, originColor)
+      ) {
+        setCache(cacheKey, null);
+        return new NullObject();
+      }
+    } else if (format === VAL_SPEC) {
+      const resolvedOriginColor = resolveColor(originColor, opt);
+      if (isString(resolvedOriginColor)) {
+        value = value.replace(originColor, resolvedOriginColor);
+      }
+    }
+    if (format === VAL_SPEC) {
+      const tokens = tokenize({ css: restValue });
+      const channelValues = resolveColorChannels(tokens, opt);
+      if (channelValues instanceof NullObject) {
+        setCache(cacheKey, null);
+        return channelValues;
+      }
+      const [v1, v2, v3, v4] = channelValues;
+      let channelValue = '';
+      if (isStringOrNumber(v4)) {
+        channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;
+      } else {
+        channelValue = ` ${channelValues.join(' ')})`;
+      }
+      if (restValue !== channelValue) {
+        value = value.replace(restValue, channelValue);
+      }
+    }
+  } else {
+    // nested relative color
+    const [, restValue] = value.split(REG_FN_REL_START) as MatchedRegExp;
+    const tokens = tokenize({ css: restValue });
+    const originColor: string[] = [];
+    let nest = 0;
+    let tokenIndex = 0;
+    for (const [type, tokenValue] of tokens) {
+      tokenIndex++;
+      switch (type) {
+        case FUNC:
+        case PAREN_OPEN: {
+          originColor.push(tokenValue);
+          nest++;
+          break;
+        }
+        case PAREN_CLOSE: {
+          const lastValue = originColor[originColor.length - 1];
+          if (lastValue === ' ') {
+            originColor[originColor.length - 1] = tokenValue;
+          } else if (isString(lastValue)) {
+            originColor.push(tokenValue);
+          }
+          nest--;
+          break;
+        }
+        case W_SPACE: {
+          const lastValue = originColor[originColor.length - 1];
+          if (
+            isString(lastValue) &&
+            !lastValue.endsWith('(') &&
+            lastValue !== ' '
+          ) {
+            originColor.push(tokenValue);
+          }
+          break;
+        }
+        default: {
+          if (type !== COMMENT && type !== EOF) {
+            originColor.push(tokenValue);
+          }
+        }
+      }
+      if (nest === 0) {
+        break;
+      }
+    }
+    const resolvedOriginColor = resolveRelativeColor(
+      originColor.join('').trim(),
+      opt
+    );
+    if (resolvedOriginColor instanceof NullObject) {
+      setCache(cacheKey, null);
+      return resolvedOriginColor;
+    }
+    const channelValues = resolveColorChannels(tokens.slice(tokenIndex), opt);
+    if (channelValues instanceof NullObject) {
+      setCache(cacheKey, null);
+      return channelValues;
+    }
+    const [v1, v2, v3, v4] = channelValues;
+    let channelValue = '';
+    if (isStringOrNumber(v4)) {
+      channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;
+    } else {
+      channelValue = ` ${channelValues.join(' ')})`;
+    }
+    value = value.replace(restValue, `${resolvedOriginColor}${channelValue}`);
+  }
+  setCache(cacheKey, value);
+  return value;
+}
+
+/**
+ * resolve relative color
+ * @param value - CSS relative color value
+ * @param [opt] - options
+ * @returns resolved value
+ */
+export function resolveRelativeColor(
+  value: string,
+  opt: Options = {}
+): string | NullObject {
+  const { format = '' } = opt;
+  if (isString(value)) {
+    if (REG_FN_VAR.test(value)) {
+      // var() must be resolved before resolveRelativeColor()
+      if (format !== VAL_SPEC) {
+        throw new SyntaxError(`Unexpected token ${FN_VAR} found.`);
+      }
+      return value;
+    } else if (!REG_FN_REL.test(value)) {
+      return value;
+    }
+    value = value.toLowerCase().trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const cacheKey: string = createCacheKey(
+    {
+      namespace: NAMESPACE,
+      name: 'resolveRelativeColor',
+      value
+    },
+    opt
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    if (cachedResult.isNull) {
+      return cachedResult as NullObject;
+    }
+    return cachedResult.item as string;
+  }
+  const originColor = extractOriginColor(value, opt);
+  if (originColor instanceof NullObject) {
+    setCache(cacheKey, null);
+    return originColor;
+  }
+  value = originColor;
+  if (format === VAL_SPEC) {
+    if (value.startsWith('rgba(')) {
+      value = value.replace('rgba(', 'rgb(');
+    } else if (value.startsWith('hsla(')) {
+      value = value.replace('hsla(', 'hsl(');
+    }
+    return value;
+  }
+  const tokens = tokenize({ css: value });
+  const components = parseComponentValue(tokens) as ComponentValue;
+  const parsedComponents = colorParser(components);
+  if (!parsedComponents) {
+    setCache(cacheKey, null);
+    return new NullObject();
+  }
+  const {
+    alpha: alphaComponent,
+    channels: channelsComponent,
+    colorNotation,
+    syntaxFlags
+  } = parsedComponents;
+  let alpha: number | string;
+  if (Number.isNaN(Number(alphaComponent))) {
+    if (syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE)) {
+      alpha = NONE;
+    } else {
+      alpha = 0;
+    }
+  } else {
+    alpha = roundToPrecision(Number(alphaComponent), OCT);
+  }
+  let v1: number | string;
+  let v2: number | string;
+  let v3: number | string;
+  [v1, v2, v3] = channelsComponent;
+  let resolvedValue;
+  if (REG_CS_CIE.test(colorNotation)) {
+    const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);
+    if (Number.isNaN(v1)) {
+      if (hasNone) {
+        v1 = NONE;
+      } else {
+        v1 = 0;
+      }
+    } else {
+      v1 = roundToPrecision(v1, HEX);
+    }
+    if (Number.isNaN(v2)) {
+      if (hasNone) {
+        v2 = NONE;
+      } else {
+        v2 = 0;
+      }
+    } else {
+      v2 = roundToPrecision(v2, HEX);
+    }
+    if (Number.isNaN(v3)) {
+      if (hasNone) {
+        v3 = NONE;
+      } else {
+        v3 = 0;
+      }
+    } else {
+      v3 = roundToPrecision(v3, HEX);
+    }
+    if (alpha === 1) {
+      resolvedValue = `${colorNotation}(${v1} ${v2} ${v3})`;
+    } else {
+      resolvedValue = `${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`;
+    }
+  } else if (REG_CS_HSL.test(colorNotation)) {
+    if (Number.isNaN(v1)) {
+      v1 = 0;
+    }
+    if (Number.isNaN(v2)) {
+      v2 = 0;
+    }
+    if (Number.isNaN(v3)) {
+      v3 = 0;
+    }
+    let [r, g, b] = convertColorToRgb(
+      `${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`
+    ) as ColorChannels;
+    r = roundToPrecision(r / MAX_RGB, DEC);
+    g = roundToPrecision(g / MAX_RGB, DEC);
+    b = roundToPrecision(b / MAX_RGB, DEC);
+    if (alpha === 1) {
+      resolvedValue = `color(srgb ${r} ${g} ${b})`;
+    } else {
+      resolvedValue = `color(srgb ${r} ${g} ${b} / ${alpha})`;
+    }
+  } else {
+    const cs = colorNotation === 'rgb' ? 'srgb' : colorNotation;
+    const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);
+    if (Number.isNaN(v1)) {
+      if (hasNone) {
+        v1 = NONE;
+      } else {
+        v1 = 0;
+      }
+    } else {
+      v1 = roundToPrecision(v1, DEC);
+    }
+    if (Number.isNaN(v2)) {
+      if (hasNone) {
+        v2 = NONE;
+      } else {
+        v2 = 0;
+      }
+    } else {
+      v2 = roundToPrecision(v2, DEC);
+    }
+    if (Number.isNaN(v3)) {
+      if (hasNone) {
+        v3 = NONE;
+      } else {
+        v3 = 0;
+      }
+    } else {
+      v3 = roundToPrecision(v3, DEC);
+    }
+    if (alpha === 1) {
+      resolvedValue = `color(${cs} ${v1} ${v2} ${v3})`;
+    } else {
+      resolvedValue = `color(${cs} ${v1} ${v2} ${v3} / ${alpha})`;
+    }
+  }
+  setCache(cacheKey, resolvedValue);
+  return resolvedValue;
+}
diff --git a/node_modules/@asamuzakjp/css-color/src/js/resolve.ts b/node_modules/@asamuzakjp/css-color/src/js/resolve.ts
new file mode 100644
index 0000000000000000000000000000000000000000..4768778afd1cb84318c7e46a921819f6c0c8c086
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/resolve.ts
@@ -0,0 +1,322 @@
+/**
+ * resolve
+ */
+
+import {
+  CacheItem,
+  NullObject,
+  createCacheKey,
+  getCache,
+  setCache
+} from './cache';
+import {
+  convertRgbToHex,
+  resolveColorFunc,
+  resolveColorMix,
+  resolveColorValue
+} from './color';
+import { isString } from './common';
+import { cssCalc } from './css-calc';
+import { resolveVar } from './css-var';
+import { resolveRelativeColor } from './relative-color';
+import { splitValue } from './util';
+import {
+  ComputedColorChannels,
+  Options,
+  SpecifiedColorChannels
+} from './typedef';
+
+/* constants */
+import {
+  FN_COLOR,
+  FN_MIX,
+  SYN_FN_CALC,
+  SYN_FN_LIGHT_DARK,
+  SYN_FN_REL,
+  SYN_FN_VAR,
+  VAL_COMP,
+  VAL_SPEC
+} from './constant';
+const NAMESPACE = 'resolve';
+const RGB_TRANSPARENT = 'rgba(0, 0, 0, 0)';
+
+/* regexp */
+const REG_FN_CALC = new RegExp(SYN_FN_CALC);
+const REG_FN_LIGHT_DARK = new RegExp(SYN_FN_LIGHT_DARK);
+const REG_FN_REL = new RegExp(SYN_FN_REL);
+const REG_FN_VAR = new RegExp(SYN_FN_VAR);
+
+/**
+ * resolve color
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns resolved color
+ */
+export const resolveColor = (
+  value: string,
+  opt: Options = {}
+): string | NullObject => {
+  if (!isString(value)) {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  value = value.trim();
+  const {
+    colorScheme = 'normal',
+    currentColor = '',
+    format = VAL_COMP,
+    nullable = false
+  } = opt;
+  const cacheKey: string = createCacheKey(
+    { namespace: NAMESPACE, name: 'resolve', value },
+    opt
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    if (cachedResult.isNull) {
+      return cachedResult as NullObject;
+    }
+    return cachedResult.item as string;
+  }
+  // 1. var() resolution
+  if (REG_FN_VAR.test(value)) {
+    if (format === VAL_SPEC) {
+      setCache(cacheKey, value);
+      return value;
+    }
+    const resolvedVar = resolveVar(value, opt);
+    if (resolvedVar instanceof NullObject) {
+      const res =
+        format === 'hex' || format === 'hexAlpha' || nullable
+          ? resolvedVar
+          : RGB_TRANSPARENT;
+      setCache(cacheKey, res);
+      return res;
+    }
+    value = resolvedVar;
+  }
+  if (opt.format !== format) {
+    opt.format = format;
+  }
+  value = value.toLowerCase();
+  // 2. light-dark() resolution
+  if (REG_FN_LIGHT_DARK.test(value) && value.endsWith(')')) {
+    const colorParts = value.replace(REG_FN_LIGHT_DARK, '').replace(/\)$/, '');
+    const [light = '', dark = ''] = splitValue(colorParts, { delimiter: ',' });
+    if (light && dark) {
+      if (format === VAL_SPEC) {
+        const lightColor = resolveColor(light, opt);
+        const darkColor = resolveColor(dark, opt);
+        const res =
+          lightColor && darkColor
+            ? `light-dark(${lightColor}, ${darkColor})`
+            : '';
+        setCache(cacheKey, res);
+        return res;
+      }
+      const chosen = colorScheme === 'dark' ? dark : light;
+      const resolved = resolveColor(chosen, opt);
+      const res =
+        resolved instanceof NullObject && !nullable
+          ? RGB_TRANSPARENT
+          : resolved;
+      setCache(cacheKey, res);
+      return res;
+    }
+    // fallback for invalid light-dark
+    const invalidRes =
+      format === VAL_SPEC
+        ? ''
+        : format === 'hex' || format === 'hexAlpha'
+          ? new NullObject()
+          : RGB_TRANSPARENT;
+    setCache(cacheKey, invalidRes);
+    return invalidRes;
+  }
+  // 3. Relative Color resolution
+  if (REG_FN_REL.test(value)) {
+    const resolvedRel = resolveRelativeColor(value, opt);
+    if (format === VAL_COMP) {
+      const res =
+        resolvedRel instanceof NullObject && !nullable
+          ? RGB_TRANSPARENT
+          : resolvedRel;
+      setCache(cacheKey, res);
+      return res;
+    }
+    if (format === VAL_SPEC) {
+      const res = resolvedRel instanceof NullObject ? '' : resolvedRel;
+      setCache(cacheKey, res);
+      return res;
+    }
+    value = resolvedRel instanceof NullObject ? '' : resolvedRel;
+  }
+  // 4. calc() resolution
+  if (REG_FN_CALC.test(value)) {
+    value = cssCalc(value, opt);
+  }
+  // 5. Keyword & Color-space resolution
+  let cs = '';
+  let r = NaN;
+  let g = NaN;
+  let b = NaN;
+  let alpha = NaN;
+  if (value === 'transparent') {
+    let res: string | NullObject;
+    switch (format) {
+      case VAL_SPEC: {
+        res = value;
+        break;
+      }
+      case 'hex': {
+        res = new NullObject();
+        break;
+      }
+      case 'hexAlpha': {
+        res = '#00000000';
+        break;
+      }
+      default: {
+        res = RGB_TRANSPARENT;
+      }
+    }
+    setCache(cacheKey, res);
+    return res;
+  }
+  if (value === 'currentcolor') {
+    if (format === VAL_SPEC) {
+      setCache(cacheKey, value);
+      return value;
+    }
+    if (currentColor) {
+      let resolvedCurrent;
+      if (currentColor.startsWith(FN_MIX)) {
+        resolvedCurrent = resolveColorMix(currentColor, opt);
+      } else if (currentColor.startsWith(FN_COLOR)) {
+        resolvedCurrent = resolveColorFunc(currentColor, opt);
+      } else {
+        resolvedCurrent = resolveColorValue(currentColor, opt);
+      }
+      if (resolvedCurrent instanceof NullObject) {
+        setCache(cacheKey, resolvedCurrent);
+        return resolvedCurrent;
+      }
+      [cs, r, g, b, alpha] = resolvedCurrent as ComputedColorChannels;
+    } else {
+      // value is handled below if not VAL_COMP
+      const res = format === VAL_COMP ? RGB_TRANSPARENT : value;
+      if (format === VAL_COMP) {
+        setCache(cacheKey, res);
+        return res;
+      }
+    }
+  } else if (format === VAL_SPEC) {
+    let res = '';
+    if (value.startsWith(FN_MIX)) {
+      res = resolveColorMix(value, opt) as string;
+    } else if (value.startsWith(FN_COLOR)) {
+      const [scs, rr, gg, bb, aa] = resolveColorFunc(
+        value,
+        opt
+      ) as SpecifiedColorChannels;
+      res =
+        aa === 1
+          ? `color(${scs} ${rr} ${gg} ${bb})`
+          : `color(${scs} ${rr} ${gg} ${bb} / ${aa})`;
+    } else {
+      const rgb = resolveColorValue(value, opt);
+      if (isString(rgb)) {
+        res = rgb;
+      } else {
+        const [scs, rr, gg, bb, aa] = rgb as SpecifiedColorChannels;
+        if (scs === 'rgb') {
+          res =
+            aa === 1
+              ? `${scs}(${rr}, ${gg}, ${bb})`
+              : `${scs}a(${rr}, ${gg}, ${bb}, ${aa})`;
+        } else {
+          res =
+            aa === 1
+              ? `${scs}(${rr} ${gg} ${bb})`
+              : `${scs}(${rr} ${gg} ${bb} / ${aa})`;
+        }
+      }
+    }
+    setCache(cacheKey, res);
+    return res;
+  } else if (value.startsWith(FN_MIX)) {
+    if (currentColor) {
+      value = value.replace(/currentcolor/g, currentColor);
+    }
+    value = value.replace(/transparent/g, RGB_TRANSPARENT);
+    const resolvedMix = resolveColorMix(value, opt);
+    if (resolvedMix instanceof NullObject) {
+      setCache(cacheKey, resolvedMix);
+      return resolvedMix;
+    }
+    [cs, r, g, b, alpha] = resolvedMix as ComputedColorChannels;
+  } else if (value.startsWith(FN_COLOR)) {
+    const resolvedFunc = resolveColorFunc(value, opt);
+    if (resolvedFunc instanceof NullObject) {
+      setCache(cacheKey, resolvedFunc);
+      return resolvedFunc;
+    }
+    [cs, r, g, b, alpha] = resolvedFunc as ComputedColorChannels;
+  } else if (value) {
+    const resolvedVal = resolveColorValue(value, opt);
+    if (resolvedVal instanceof NullObject) {
+      setCache(cacheKey, resolvedVal);
+      return resolvedVal;
+    }
+    [cs, r, g, b, alpha] = resolvedVal as ComputedColorChannels;
+  }
+  // 6. Format Finalization
+  let finalRes: string | NullObject = '';
+  switch (format) {
+    case 'hex':
+    case 'hexAlpha': {
+      if (
+        Number.isNaN(r) ||
+        Number.isNaN(g) ||
+        Number.isNaN(b) ||
+        Number.isNaN(alpha) ||
+        (format === 'hex' && alpha === 0)
+      ) {
+        finalRes = new NullObject();
+      } else {
+        finalRes = convertRgbToHex([r, g, b, format === 'hex' ? 1 : alpha]);
+      }
+      break;
+    }
+    default: {
+      if (cs === 'rgb') {
+        finalRes =
+          alpha === 1
+            ? `${cs}(${r}, ${g}, ${b})`
+            : `${cs}a(${r}, ${g}, ${b}, ${alpha})`;
+      } else if (['lab', 'lch', 'oklab', 'oklch'].includes(cs)) {
+        finalRes =
+          alpha === 1
+            ? `${cs}(${r} ${g} ${b})`
+            : `${cs}(${r} ${g} ${b} / ${alpha})`;
+      } else {
+        finalRes =
+          alpha === 1
+            ? `color(${cs} ${r} ${g} ${b})`
+            : `color(${cs} ${r} ${g} ${b} / ${alpha})`;
+      }
+    }
+  }
+  setCache(cacheKey, finalRes);
+  return finalRes;
+};
+
+/**
+ * resolve CSS color
+ * @param value - CSS color value. system colors are not supported
+ * @param [opt] - options
+ */
+export const resolve = (value: string, opt: Options = {}): string | null => {
+  opt.nullable = false;
+  const resolvedValue = resolveColor(value, opt);
+  return resolvedValue instanceof NullObject ? null : (resolvedValue as string);
+};
diff --git a/node_modules/@asamuzakjp/css-color/src/js/typedef.ts b/node_modules/@asamuzakjp/css-color/src/js/typedef.ts
new file mode 100644
index 0000000000000000000000000000000000000000..007363ebe3e02b4a959c76adfe88bbb5708e22ab
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/typedef.ts
@@ -0,0 +1,88 @@
+/**
+ * typedef
+ */
+
+/* type definitions */
+/**
+ * @typedef Options - options
+ * @property [alpha] - enable alpha
+ * @property [colorSpace] - color space
+ * @property [currentColor] - color for currentcolor
+ * @property [customProperty] - custom properties
+ * @property [d50] - white point in d50
+ * @property [dimension] - dimension
+ * @property [format] - output format
+ * @property [key] - key
+ */
+export interface Options {
+  alpha?: boolean;
+  colorScheme?: string;
+  colorSpace?: string;
+  currentColor?: string;
+  customProperty?: Record<string, string | ((K: string) => string)>;
+  d50?: boolean;
+  delimiter?: string | string[];
+  dimension?: Record<string, number | ((K: string) => number)>;
+  format?: string;
+  nullable?: boolean;
+  preserveComment?: boolean;
+}
+
+/**
+ * @type ColorChannels - color channels
+ */
+export type ColorChannels = [x: number, y: number, z: number, alpha: number];
+
+/**
+ * @type StringColorChannels - color channels
+ */
+export type StringColorChannels = [
+  x: string,
+  y: string,
+  z: string,
+  alpha: string | undefined
+];
+
+/**
+ * @type StringColorSpacedChannels - specified value
+ */
+export type StringColorSpacedChannels = [
+  cs: string,
+  x: string,
+  y: string,
+  z: string,
+  alpha: string | undefined
+];
+
+/**
+ * @type ComputedColorChannels - computed value
+ */
+export type ComputedColorChannels = [
+  cs: string,
+  x: number,
+  y: number,
+  z: number,
+  alpha: number
+];
+
+/**
+ * @type SpecifiedColorChannels - specified value
+ */
+export type SpecifiedColorChannels = [
+  cs: string,
+  x: number | string,
+  y: number | string,
+  z: number | string,
+  alpha: number | string
+];
+
+/**
+ * @type MatchedRegExp - matched regexp array
+ */
+export type MatchedRegExp = [
+  match: string,
+  gr1: string,
+  gr2: string,
+  gr3: string,
+  gr4: string
+];
diff --git a/node_modules/@asamuzakjp/css-color/src/js/util.ts b/node_modules/@asamuzakjp/css-color/src/js/util.ts
new file mode 100644
index 0000000000000000000000000000000000000000..e7a7c4d78d3060a93c42e7d862a0a2077ebe8ce4
--- /dev/null
+++ b/node_modules/@asamuzakjp/css-color/src/js/util.ts
@@ -0,0 +1,423 @@
+/**
+ * util
+ */
+
+import { TokenType, tokenize } from '@csstools/css-tokenizer';
+import { CacheItem, createCacheKey, getCache, setCache } from './cache';
+import { isString } from './common';
+import { resolveColor } from './resolve';
+import { Options } from './typedef';
+
+/* constants */
+import { NAMED_COLORS } from './color';
+import { SYN_COLOR_TYPE, SYN_MIX, VAL_SPEC } from './constant';
+const {
+  CloseParen: PAREN_CLOSE,
+  Comma: COMMA,
+  Comment: COMMENT,
+  Delim: DELIM,
+  EOF,
+  Function: FUNC,
+  OpenParen: PAREN_OPEN,
+  Whitespace: W_SPACE
+} = TokenType;
+const NAMESPACE = 'util';
+
+/* numeric constants */
+const DEC = 10;
+const HEX = 16;
+const DEG = 360;
+const DEG_HALF = 180;
+
+/* regexp */
+const REG_COLOR = new RegExp(`^(?:${SYN_COLOR_TYPE})$`);
+const REG_DIMENSION = /^([+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)([a-z]*)$/i;
+const REG_FN_COLOR =
+  /^(?:(?:ok)?l(?:ab|ch)|color(?:-mix)?|hsla?|hwb|rgba?|var)\(/;
+const REG_MIX = new RegExp(SYN_MIX);
+const REG_DASHED_IDENT = /--[\w-]+/g;
+const REG_COMMA = /^,$/;
+const REG_SLASH = /^\/$/;
+const REG_WHITESPACE = /^\s+$/;
+
+/**
+ * split value
+ * NOTE: comments are stripped, it can be preserved if, in the options param,
+ * `delimiter` is either ',' or '/' and with `preserveComment` set to `true`
+ * @param value - CSS value
+ * @param [opt] - options
+ * @returns array of values
+ */
+export const splitValue = (value: string, opt: Options = {}): string[] => {
+  if (!isString(value)) {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const strValue = value.trim();
+  const { delimiter = ' ', preserveComment = false } = opt;
+  const cacheKey: string = createCacheKey(
+    {
+      namespace: NAMESPACE,
+      name: 'splitValue',
+      value: strValue
+    },
+    { delimiter, preserveComment }
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    return cachedResult.item as string[];
+  }
+  let regDelimiter;
+  switch (delimiter) {
+    case ',': {
+      regDelimiter = REG_COMMA;
+      break;
+    }
+    case '/': {
+      regDelimiter = REG_SLASH;
+      break;
+    }
+    default: {
+      regDelimiter = REG_WHITESPACE;
+    }
+  }
+  const tokens = tokenize({ css: strValue });
+  let nest = 0;
+  let currentStr = '';
+  const res: string[] = [];
+  for (const [type, val] of tokens) {
+    switch (type) {
+      case COMMA:
+      case DELIM: {
+        if (nest === 0 && regDelimiter.test(val)) {
+          res.push(currentStr.trim());
+          currentStr = '';
+        } else {
+          currentStr += val;
+        }
+        break;
+      }
+      case COMMENT: {
+        if (preserveComment && (delimiter === ',' || delimiter === '/')) {
+          currentStr += val;
+        }
+        break;
+      }
+      case FUNC:
+      case PAREN_OPEN: {
+        currentStr += val;
+        nest++;
+        break;
+      }
+      case PAREN_CLOSE: {
+        currentStr += val;
+        nest--;
+        break;
+      }
+      case W_SPACE: {
+        if (regDelimiter.test(val)) {
+          if (nest === 0) {
+            if (currentStr) {
+              res.push(currentStr.trim());
+              currentStr = '';
+            }
+          } else {
+            currentStr += ' ';
+          }
+        } else if (!currentStr.endsWith(' ')) {
+          currentStr += ' ';
+        }
+        break;
+      }
+      default: {
+        if (type === EOF) {
+          res.push(currentStr.trim());
+          currentStr = '';
+        } else {
+          currentStr += val;
+        }
+      }
+    }
+  }
+  setCache(cacheKey, res);
+  return res;
+};
+
+/**
+ * extract dashed-ident tokens
+ * @param value - CSS value
+ * @returns array of dashed-ident tokens
+ */
+export const extractDashedIdent = (value: string): string[] => {
+  if (!isString(value)) {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const strValue = value.trim();
+  const cacheKey: string = createCacheKey({
+    namespace: NAMESPACE,
+    name: 'extractDashedIdent',
+    value: strValue
+  });
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    return cachedResult.item as string[];
+  }
+  const matches = strValue.match(REG_DASHED_IDENT);
+  const res = matches ? [...new Set(matches)] : [];
+  setCache(cacheKey, res);
+  return res;
+};
+
+/**
+ * is color
+ * @param value - CSS value
+ * @param [opt] - options
+ * @returns result
+ */
+export const isColor = (value: unknown, opt: Options = {}): boolean => {
+  if (!isString(value)) {
+    return false;
+  }
+  const str = value.toLowerCase().trim();
+  if (!str) {
+    return false;
+  }
+  if (/^[a-z]+$/.test(str)) {
+    return (
+      str === 'currentcolor' ||
+      str === 'transparent' ||
+      Object.hasOwn(NAMED_COLORS, str)
+    );
+  }
+  if (REG_COLOR.test(str) || REG_MIX.test(str)) {
+    return true;
+  }
+  if (REG_FN_COLOR.test(str)) {
+    const colorOpt = { ...opt, nullable: true };
+    if (!colorOpt.format) colorOpt.format = VAL_SPEC;
+    return !!resolveColor(str, colorOpt);
+  }
+  return false;
+};
+
+/**
+ * round to specified precision
+ * @param value - numeric value
+ * @param bit - minimum bits
+ * @returns rounded value
+ */
+export const roundToPrecision = (value: number, bit: number = 0): number => {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`${value} is not a finite number.`);
+  }
+  if (!Number.isFinite(bit)) {
+    throw new TypeError(`${bit} is not a finite number.`);
+  }
+  if (bit < 0 || bit > HEX) {
+    throw new RangeError(`${bit} is not between 0 and ${HEX}.`);
+  }
+  if (bit === 0) {
+    return Math.round(value);
+  }
+  const precision = bit === HEX ? 6 : bit < DEC ? 4 : 5;
+  return parseFloat(value.toPrecision(precision));
+};
+
+/**
+ * interpolate hue
+ * @param hueA - hue value
+ * @param hueB - hue value
+ * @param arc - shorter | longer | increasing | decreasing
+ * @returns result - [hueA, hueB]
+ */
+export const interpolateHue = (
+  hueA: number,
+  hueB: number,
+  arc: string = 'shorter'
+): [number, number] => {
+  if (!Number.isFinite(hueA)) {
+    throw new TypeError(`${hueA} is not a finite number.`);
+  }
+  if (!Number.isFinite(hueB)) {
+    throw new TypeError(`${hueB} is not a finite number.`);
+  }
+  let a = hueA;
+  let b = hueB;
+  switch (arc) {
+    case 'decreasing': {
+      if (b > a) {
+        a += DEG;
+      }
+      break;
+    }
+    case 'increasing': {
+      if (b < a) {
+        b += DEG;
+      }
+      break;
+    }
+    case 'longer': {
+      if (b > a && b < a + DEG_HALF) {
+        a += DEG;
+      } else if (b > a - DEG_HALF && b <= a) {
+        b += DEG;
+      }
+      break;
+    }
+    case 'shorter':
+    default: {
+      if (b > a + DEG_HALF) {
+        a += DEG;
+      } else if (b < a - DEG_HALF) {
+        b += DEG;
+      }
+    }
+  }
+  return [a, b];
+};
+
+/* absolute font size to pixel ratio */
+const absoluteFontSize = new Map([
+  ['xx-small', 9 / 16],
+  ['x-small', 5 / 8],
+  ['small', 13 / 16],
+  ['medium', 1],
+  ['large', 9 / 8],
+  ['x-large', 3 / 2],
+  ['xx-large', 2],
+  ['xxx-large', 3]
+]);
+
+/* relative font size to pixel ratio */
+const relativeFontSize = new Map([
+  ['smaller', 1 / 1.2],
+  ['larger', 1.2]
+]);
+
+/* absolute length to pixel ratio */
+const absoluteLength = new Map([
+  ['cm', 96 / 2.54],
+  ['mm', 96 / 25.4],
+  ['q', 96 / 101.6],
+  ['in', 96],
+  ['pc', 16],
+  ['pt', 96 / 72],
+  ['px', 1]
+]);
+
+/* relative length to pixel ratio */
+const relativeLength = new Map([
+  ['rcap', 1],
+  ['rch', 0.5],
+  ['rem', 1],
+  ['rex', 0.5],
+  ['ric', 1],
+  ['rlh', 1.2]
+]);
+
+/**
+ * resolve length in pixels
+ * @param value - value
+ * @param unit - unit
+ * @param [opt] - options
+ * @returns pixelated value
+ */
+export const resolveLengthInPixels = (
+  value: number | string,
+  unit: string | undefined,
+  opt: Options = {}
+): number => {
+  const { dimension = {} } = opt;
+  const { callback, em, rem, vh, vw } = dimension as {
+    callback: (K: string) => number;
+    em: number;
+    rem: number;
+    vh: number;
+    vw: number;
+  };
+  if (isString(value)) {
+    const str = value.toLowerCase().trim();
+    const ratio = absoluteFontSize.get(str);
+    if (ratio !== undefined) {
+      return ratio * rem;
+    }
+    const relRatio = relativeFontSize.get(str);
+    if (relRatio !== undefined) {
+      return relRatio * em;
+    }
+    return Number.NaN;
+  }
+  if (Number.isFinite(value) && unit) {
+    const u = unit.toLowerCase();
+    if (Object.hasOwn(dimension, u)) {
+      return value * Number(dimension[u]);
+    }
+    if (typeof callback === 'function') {
+      return value * (callback(u) ?? Number.NaN);
+    }
+    const absRatio = absoluteLength.get(u);
+    if (absRatio !== undefined) {
+      return value * absRatio;
+    }
+    const relRatio = relativeLength.get(u);
+    if (relRatio !== undefined) {
+      return value * relRatio * rem;
+    }
+    const rUnitRatio = relativeLength.get(`r${u}`);
+    if (rUnitRatio !== undefined) {
+      return value * rUnitRatio * em;
+    }
+    switch (u) {
+      case 'vb':
+      case 'vi': {
+        return value * vw;
+      }
+      case 'vmax': {
+        return value * Math.max(vh, vw);
+      }
+      case 'vmin': {
+        return value * Math.min(vh, vw);
+      }
+      default:
+    }
+  }
+  // unsupported or invalid value
+  return Number.NaN;
+};
+
+/**
+ * is absolute size or length
+ * @param value - value
+ * @param unit - unit
+ * @returns result
+ */
+export const isAbsoluteSizeOrLength = (
+  value: number | string,
+  unit: string | undefined
+): boolean => {
+  if (isString(value)) {
+    return absoluteFontSize.has(value.toLowerCase().trim());
+  }
+  if (isString(unit)) {
+    return absoluteLength.has(unit.toLowerCase().trim());
+  }
+  return value === 0;
+};
+
+/**
+ * is absolute font size
+ * @param css - css
+ * @returns result
+ */
+export const isAbsoluteFontSize = (css: unknown): boolean => {
+  if (!isString(css)) {
+    return false;
+  }
+  const str = css.trim();
+  if (isAbsoluteSizeOrLength(str, undefined)) {
+    return true;
+  }
+  const match = str.match(REG_DIMENSION);
+  return match
+    ? isAbsoluteSizeOrLength(Number(match[1]), match[2] || undefined)
+    : false;
+};
diff --git a/node_modules/@asamuzakjp/dom-selector/LICENSE b/node_modules/@asamuzakjp/dom-selector/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..f3f97a30fbb1922c30b508e8b1c1ab298e5e5293
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 asamuzaK (Kazz)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/@asamuzakjp/dom-selector/README.md b/node_modules/@asamuzakjp/dom-selector/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..50099f37e3bb9b0ee787be828701a171f1786837
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/README.md
@@ -0,0 +1,324 @@
+# DOM Selector
+
+[![build](https://github.com/asamuzaK/domSelector/actions/workflows/node.js.yml/badge.svg)](https://github.com/asamuzaK/domSelector/actions/workflows/node.js.yml)
+[![CodeQL](https://github.com/asamuzaK/domSelector/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/asamuzaK/domSelector/actions/workflows/github-code-scanning/codeql)
+[![npm (scoped)](https://img.shields.io/npm/v/@asamuzakjp/dom-selector)](https://www.npmjs.com/package/@asamuzakjp/dom-selector)
+
+A CSS selector engine.
+
+## Install
+
+```console
+npm i @asamuzakjp/dom-selector
+```
+
+## Usage
+
+```javascript
+import { DOMSelector } from '@asamuzakjp/dom-selector';
+import { JSDOM } from 'jsdom';
+
+const { window } = new JSDOM();
+const {
+  closest, matches, querySelector, querySelectorAll
+} = new DOMSelector(window);
+```
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+### matches(selector, node, opt)
+
+matches - equivalent to [Element.matches()][64]
+
+#### Parameters
+
+- `selector` **[string][59]** CSS selector
+- `node` **[object][60]** Element node
+- `opt` **[object][60]?** options
+  - `opt.noexcept` **[boolean][61]?** no exception
+  - `opt.warn` **[boolean][61]?** console warn e.g. unsupported pseudo-class
+
+Returns **[boolean][61]** `true` if matched, `false` otherwise
+
+
+### closest(selector, node, opt)
+
+closest - equivalent to [Element.closest()][65]
+
+#### Parameters
+
+- `selector` **[string][59]** CSS selector
+- `node` **[object][60]** Element node
+- `opt` **[object][60]?** options
+  - `opt.noexcept` **[boolean][61]?** no exception
+  - `opt.warn` **[boolean][61]?** console warn e.g. unsupported pseudo-class
+
+Returns **[object][60]?** matched node
+
+
+### querySelector(selector, node, opt)
+
+querySelector - equivalent to [Document.querySelector()][66], [DocumentFragment.querySelector()][67] and [Element.querySelector()][68]
+
+#### Parameters
+
+- `selector` **[string][59]** CSS selector
+- `node` **[object][60]** Document, DocumentFragment or Element node
+- `opt` **[object][60]?** options
+  - `opt.noexcept` **[boolean][61]?** no exception
+  - `opt.warn` **[boolean][61]?** console warn e.g. unsupported pseudo-class
+
+Returns **[object][60]?** matched node
+
+
+### querySelectorAll(selector, node, opt)
+
+querySelectorAll - equivalent to [Document.querySelectorAll()][69], [DocumentFragment.querySelectorAll()][70] and [Element.querySelectorAll()][71]  
+**NOTE**: returns Array, not NodeList
+
+#### Parameters
+
+- `selector` **[string][59]** CSS selector
+- `node` **[object][60]** Document, DocumentFragment or Element node
+- `opt` **[object][60]?** options
+  - `opt.noexcept` **[boolean][61]?** no exception
+  - `opt.warn` **[boolean][61]?** console warn e.g. unsupported pseudo-class
+
+Returns **[Array][62]&lt;([object][60] \| [undefined][63])>** array of matched nodes
+
+
+## Monkey patch jsdom
+
+``` javascript
+import { DOMSelector } from '@asamuzakjp/dom-selector';
+import { JSDOM } from 'jsdom';
+
+const dom = new JSDOM('', {
+  runScripts: 'dangerously',
+  url: 'http://localhost/',
+  beforeParse: window => {
+    const domSelector = new DOMSelector(window);
+
+    const matches = domSelector.matches.bind(domSelector);
+    window.Element.prototype.matches = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return matches(selector, this);
+    };
+
+    const closest = domSelector.closest.bind(domSelector);
+    window.Element.prototype.closest = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return closest(selector, this);
+    };
+
+    const querySelector = domSelector.querySelector.bind(domSelector);
+    window.Document.prototype.querySelector = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelector(selector, this);
+    };
+    window.DocumentFragment.prototype.querySelector = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelector(selector, this);
+    };
+    window.Element.prototype.querySelector = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelector(selector, this);
+    };
+
+    const querySelectorAll = domSelector.querySelectorAll.bind(domSelector);
+    window.Document.prototype.querySelectorAll = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelectorAll(selector, this);
+    };
+    window.DocumentFragment.prototype.querySelectorAll = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelectorAll(selector, this);
+    };
+    window.Element.prototype.querySelectorAll = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelectorAll(selector, this);
+    };
+  }
+});
+```
+
+
+## Supported CSS selectors
+
+|Pattern|Supported|Note|
+|:--------|:-------:|:--------|
+|\*|✓| |
+|E|✓| |
+|ns\|E|✓| |
+|\*\|E|✓| |
+|\|E|✓| |
+|E&nbsp;F|✓| |
+|E > F|✓| |
+|E + F|✓| |
+|E ~ F|✓| |
+|F \|\| E|Unsupported| |
+|E.warning|✓| |
+|E#myid|✓| |
+|E\[foo\]|✓| |
+|E\[foo="bar"\]|✓| |
+|E\[foo="bar"&nbsp;i\]|✓| |
+|E\[foo="bar"&nbsp;s\]|✓| |
+|E\[foo~="bar"\]|✓| |
+|E\[foo^="bar"\]|✓| |
+|E\[foo$="bar"\]|✓| |
+|E\[foo*="bar"\]|✓| |
+|E\[foo\|="en"\]|✓| |
+|E:is(s1, s2, …)|✓| |
+|E:not(s1, s2, …)|✓| |
+|E:where(s1, s2, …)|✓| |
+|E:has(rs1, rs2, …)|✓| |
+|E:defined|Partially supported|Matching with MathML is not yet supported.|
+|E:dir(ltr)|✓| |
+|E:lang(en)|✓| |
+|E:any&#8209;link|✓| |
+|E:link|✓| |
+|E:visited|✓|Returns `false` or `null` to prevent fingerprinting.|
+|E:local&#8209;link|✓| |
+|E:target|✓| |
+|E:target&#8209;within|✓| |
+|E:scope|✓| |
+|E:hover|✓| |
+|E:active|✓| |
+|E:focus|✓| |
+|E:focus&#8209;visible|✓| |
+|E:focus&#8209;within|✓| |
+|E:current|Unsupported| |
+|E:current(s)|Unsupported| |
+|E:past|Unsupported| |
+|E:future|Unsupported| |
+|E:open<br>E:closed|Partially supported|Matching with &lt;select&gt;, e.g. `select:open`, is not supported.|
+|E:popover-open|Unsupported| |
+|E:enabled<br>E:disabled|✓| |
+|E:read&#8209;write<br>E:read&#8209;only|✓| |
+|E:placeholder&#8209;shown|✓| |
+|E:default|✓| |
+|E:checked|✓| |
+|E:indeterminate|✓| |
+|E:blank|Unsupported| |
+|E:valid<br>E:invalid|✓| |
+|E:in-range<br>E:out-of-range|✓| |
+|E:required<br>E:optional|✓| |
+|E:user&#8209;valid<br>E:user&#8209;invalid|Unsupported| |
+|E:root|✓| |
+|E:empty|✓| |
+|E:nth&#8209;child(n&nbsp;[of&nbsp;S]?)|✓| |
+|E:nth&#8209;last&#8209;child(n&nbsp;[of&nbsp;S]?)|✓| |
+|E:first&#8209;child|✓| |
+|E:last&#8209;child|✓| |
+|E:only&#8209;child|✓| |
+|E:nth&#8209;of&#8209;type(n)|✓| |
+|E:nth&#8209;last&#8209;of&#8209;type(n)|✓| |
+|E:first&#8209;of&#8209;type|✓| |
+|E:last&#8209;of&#8209;type|✓| |
+|E:only&#8209;of&#8209;type|✓| |
+|E:nth&#8209;col(n)|Unsupported| |
+|E:nth&#8209;last&#8209;col(n)|Unsupported| |
+|CE:state(v)|✓|*1|
+|:host|✓| |
+|:host(s)|✓| |
+|:host(:state(v))|✓|*1|
+|:host:has(rs1, rs2, ...)|✓| |
+|:host(s):has(rs1, rs2, ...)|✓| |
+|:host&#8209;context(s)|✓| |
+|:host&#8209;context(s):has(rs1, rs2, ...)|✓| |
+|&amp;|✓|Only supports outermost `&`, i.e. equivalent to `:scope`|
+
+*1: `ElementInternals.states`, i.e. `CustomStateSet`, is not implemented in jsdom, so you need to apply a patch in the custom element constructor.
+
+``` javascript
+class LabeledCheckbox extends window.HTMLElement {
+  #internals;
+  constructor() {
+    super();
+    this.#internals = this.attachInternals();
+    // patch CustomStateSet
+    if (!this.#internals.states) {
+      this.#internals.states = new Set();
+    }
+    this.addEventListener('click', this._onClick.bind(this));
+  }
+  get checked() {
+    return this.#internals.states.has('checked');
+  }
+  set checked(flag) {
+    if (flag) {
+      this.#internals.states.add('checked');
+    } else {
+      this.#internals.states.delete('checked');
+    }
+  }
+  _onClick(event) {
+    this.checked = !this.checked;
+  }
+}
+```
+
+
+## Performance
+
+See [benchmark](https://github.com/asamuzaK/domSelector/actions/workflows/benchmark.yml) for the latest results.
+
+
+## Acknowledgments
+
+The following resources have been of great help in the development of the DOM Selector.
+
+- [CSSTree](https://github.com/csstree/csstree)
+- [selery](https://github.com/danburzo/selery)
+- [jsdom](https://github.com/jsdom/jsdom)
+- [nwsapi](https://github.com/dperini/nwsapi)
+
+---
+Copyright (c) 2023 [asamuzaK (Kazz)](https://github.com/asamuzaK/)
+
+
+[1]: #matches
+[2]: #parameters
+[3]: #closest
+[4]: #parameters-1
+[5]: #queryselector
+[6]: #parameters-2
+[7]: #queryselectorall
+[8]: #parameters-3
+[59]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[60]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+[61]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+[62]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+[63]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/undefined
+[64]: https://developer.mozilla.org/docs/Web/API/Element/matches
+[65]: https://developer.mozilla.org/docs/Web/API/Element/closest
+[66]: https://developer.mozilla.org/docs/Web/API/Document/querySelector
+[67]: https://developer.mozilla.org/docs/Web/API/DocumentFragment/querySelector
+[68]: https://developer.mozilla.org/docs/Web/API/Element/querySelector
+[69]: https://developer.mozilla.org/docs/Web/API/Document/querySelectorAll
+[70]: https://developer.mozilla.org/docs/Web/API/DocumentFragment/querySelectorAll
+[71]: https://developer.mozilla.org/docs/Web/API/Element/querySelectorAll
diff --git a/node_modules/@asamuzakjp/dom-selector/package.json b/node_modules/@asamuzakjp/dom-selector/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..f1f4999882618546e9810948e12e7510f4fca5e8
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/package.json
@@ -0,0 +1,79 @@
+{
+  "name": "@asamuzakjp/dom-selector",
+  "description": "A CSS selector engine.",
+  "author": "asamuzaK",
+  "license": "MIT",
+  "homepage": "https://github.com/asamuzaK/domSelector#readme",
+  "bugs": {
+    "url": "https://github.com/asamuzaK/domSelector/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/asamuzaK/domSelector.git"
+  },
+  "files": [
+    "src",
+    "types"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@asamuzakjp/generational-cache": "^1.0.1",
+    "@asamuzakjp/nwsapi": "^2.3.9",
+    "bidi-js": "^1.0.3",
+    "css-tree": "^3.2.1",
+    "is-potential-custom-element-name": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/css-tree": "^2.3.11",
+    "@types/node": "^25.6.0",
+    "benchmark": "^2.1.4",
+    "c8": "^11.0.0",
+    "chai": "^6.2.2",
+    "commander": "^14.0.3",
+    "eslint": "^9.39.4",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-jsdoc": "^62.9.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-regexp": "^3.1.0",
+    "eslint-plugin-unicorn": "^64.0.0",
+    "globals": "^17.5.0",
+    "jsdom": "^29.0.2",
+    "mitata": "^1.0.34",
+    "mocha": "^11.7.5",
+    "neostandard": "^0.13.0",
+    "prettier": "^3.8.3",
+    "sinon": "^21.1.2",
+    "typescript": "^6.0.3",
+    "wpt-runner": "^7.0.0"
+  },
+  "overrides": {
+    "c8": {
+      "yargs": "^18.0.0"
+    },
+    "jsdom": "$jsdom",
+    "serialize-javascript": "^7.0.4"
+  },
+  "scripts": {
+    "bench": "node benchmark/bench.js",
+    "bench:cache": "node benchmark/bench-cache.js",
+    "bench:cacheMonster": "node benchmark/bench-cache-monster.js",
+    "bench:sizzle": "node benchmark/bench-sizzle.js",
+    "build": "npm run tsc && npm run lint && npm test",
+    "lint": "eslint --fix .",
+    "test": "c8 --reporter=text mocha --exit test/**/*.test.js",
+    "test:wpt": "node test/wpt/wpt-runner.js",
+    "tsc": "node scripts/index clean --dir=types -i && npx tsc",
+    "update:wpt": "git submodule update --init --recursive --remote"
+  },
+  "engines": {
+    "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+  },
+  "version": "7.1.1"
+}
diff --git a/node_modules/@asamuzakjp/dom-selector/src/index.js b/node_modules/@asamuzakjp/dom-selector/src/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..6602fc5194d8102213b8fbdee19527a9bd0bd4d5
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/src/index.js
@@ -0,0 +1,393 @@
+/*!
+ * DOM Selector - A CSS selector engine.
+ * @license MIT
+ * @copyright asamuzaK (Kazz)
+ * @see {@link https://github.com/asamuzaK/domSelector/blob/main/LICENSE}
+ */
+
+/* import */
+import { GenerationalCache } from '@asamuzakjp/generational-cache';
+import { Finder } from './js/finder.js';
+import { unescapeSelector, parseAstName } from './js/parser.js';
+import { filterSelector, getType, initNwsapi } from './js/utility.js';
+
+/* constants */
+import {
+  DOCUMENT_NODE,
+  DOCUMENT_FRAGMENT_NODE,
+  ELEMENT_NODE,
+  TARGET_ALL,
+  TARGET_FIRST,
+  TARGET_LINEAL,
+  TARGET_SELF,
+  COMBINATOR,
+  ID_SELECTOR,
+  CLASS_SELECTOR,
+  TYPE_SELECTOR
+} from './js/constant.js';
+const CACHE_SIZE = 2048;
+
+/**
+ * @typedef {object} CheckResult
+ * @property {boolean} match - The match result.
+ * @property {string?} pseudoElement - The pseudo-element, if any.
+ * @property {object?} ast - The AST object.
+ */
+
+/* DOMSelector */
+export class DOMSelector {
+  /* private fields */
+  #window;
+  #document;
+  #finder;
+  #idlUtils;
+  #nwsapi;
+  #cache;
+
+  /**
+   * Creates an instance of DOMSelector.
+   * @param {Window} window - The window object.
+   * @param {Document} document - The document object.
+   * @param {object} [opt] - Options.
+   */
+  constructor(window, document, opt = {}) {
+    const { cacheSize, idlUtils } = opt;
+    this.#window = window;
+    this.#document = document ?? window.document;
+    this.#finder = new Finder(window);
+    this.#idlUtils = idlUtils;
+    this.#nwsapi = initNwsapi(window, document);
+    this.#cache = new GenerationalCache(cacheSize ?? CACHE_SIZE);
+  }
+
+  /**
+   * Clears the internal cache of finder results.
+   * @returns {void}
+   */
+  clear = () => {
+    this.#finder.clearResults(true);
+  };
+
+  /**
+   * Parses a selector and extracts the rightmost subject keys (Id, Class, Tag).
+   * @param {string} selector - The CSS selector to parse.
+   * @returns {Array<{id: string|null, className: string|null, tag: string|null}>} The list of extracted keys for each selector group.
+   */
+  extractSubjects = selector => {
+    if (!selector || typeof selector !== 'string') {
+      return [{ id: null, className: null, tag: null }];
+    }
+    const cacheKey = `extract_${selector}`;
+    let subjects = this.#cache.get(cacheKey);
+    if (subjects !== undefined) {
+      return subjects;
+    }
+    subjects = [];
+    try {
+      const ast = this.#finder.getAST(selector);
+      if (ast?.type === 'SelectorList') {
+        for (const selectorNode of ast.children) {
+          let idKey = null;
+          let classKey = null;
+          let tagKey = null;
+          let current = selectorNode.children.tail;
+          while (current) {
+            const node = current.data;
+            if (node.type === COMBINATOR) {
+              break;
+            }
+            if (node.type === ID_SELECTOR) {
+              idKey = idKey ?? unescapeSelector(node.name);
+            } else if (node.type === CLASS_SELECTOR) {
+              classKey = classKey ?? unescapeSelector(node.name);
+            } else if (node.type === TYPE_SELECTOR) {
+              const { localName } = parseAstName(unescapeSelector(node.name));
+              if (localName !== '*') {
+                tagKey = tagKey ?? localName.toLowerCase();
+              }
+            }
+            current = current.prev;
+          }
+          subjects.push({ id: idKey, className: classKey, tag: tagKey });
+        }
+      }
+    } catch (e) {
+      // fall through
+    }
+    if (!subjects.length) {
+      subjects.push({ id: null, className: null, tag: null });
+    }
+    this.#cache.set(cacheKey, subjects);
+    return subjects;
+  };
+
+  /**
+   * Checks if an element matches a CSS selector.
+   * @param {string} selector - The CSS selector to check against.
+   * @param {Element} node - The element node to check.
+   * @param {object} [opt] - Optional parameters.
+   * @returns {CheckResult} An object containing the check result.
+   */
+  check = (selector, node, opt = {}) => {
+    if (!node?.nodeType) {
+      const e = new this.#window.TypeError(`Unexpected type ${getType(node)}`);
+      return this.#finder.onError(e, opt);
+    } else if (node.nodeType !== ELEMENT_NODE) {
+      const e = new this.#window.TypeError(`Unexpected node ${node.nodeName}`);
+      return this.#finder.onError(e, opt);
+    }
+    const document = node.ownerDocument;
+    if (
+      document === this.#document &&
+      document.contentType === 'text/html' &&
+      document.documentElement &&
+      node.parentNode
+    ) {
+      const cacheKey = `check_${selector}`;
+      let filterMatches = this.#cache.get(cacheKey);
+      if (filterMatches === undefined) {
+        filterMatches = filterSelector(selector, TARGET_SELF);
+        this.#cache.set(cacheKey, filterMatches);
+      }
+      if (filterMatches) {
+        try {
+          const n = this.#idlUtils ? this.#idlUtils.wrapperForImpl(node) : node;
+          const match = this.#nwsapi.match(selector, n);
+          let ast = null;
+          if (match) {
+            const astCacheKey = `check_ast_${selector}`;
+            ast = this.#cache.get(astCacheKey);
+            if (ast === undefined) {
+              ast = this.#finder.getAST(selector);
+              this.#cache.set(astCacheKey, ast);
+            }
+          }
+          return {
+            match,
+            ast,
+            pseudoElement: null
+          };
+        } catch (e) {
+          // fall through
+        }
+      }
+    }
+    if (this.#idlUtils) {
+      node = this.#idlUtils.wrapperForImpl(node);
+    }
+    opt.check = true;
+    opt.noexcept = true;
+    opt.warn = false;
+    return this.#finder.setup(selector, node, opt).find(TARGET_SELF);
+  };
+
+  /**
+   * Returns true if the element matches the selector.
+   * @param {string} selector - The CSS selector to match against.
+   * @param {Element} node - The element node to test.
+   * @param {object} [opt] - Optional parameters.
+   * @returns {boolean} `true` if the element matches, or `false` otherwise.
+   */
+  matches = (selector, node, opt = {}) => {
+    if (!node?.nodeType) {
+      const e = new this.#window.TypeError(`Unexpected type ${getType(node)}`);
+      return this.#finder.onError(e, opt);
+    } else if (node.nodeType !== ELEMENT_NODE) {
+      const e = new this.#window.TypeError(`Unexpected node ${node.nodeName}`);
+      return this.#finder.onError(e, opt);
+    }
+    const document = node.ownerDocument;
+    if (
+      document === this.#document &&
+      document.contentType === 'text/html' &&
+      document.documentElement &&
+      node.parentNode
+    ) {
+      const cacheKey = `matches_${selector}`;
+      let filterMatches = this.#cache.get(cacheKey);
+      if (filterMatches === undefined) {
+        filterMatches = filterSelector(selector, TARGET_SELF);
+        this.#cache.set(cacheKey, filterMatches);
+      }
+      if (filterMatches) {
+        try {
+          const n = this.#idlUtils ? this.#idlUtils.wrapperForImpl(node) : node;
+          return this.#nwsapi.match(selector, n);
+        } catch (e) {
+          // fall through
+        }
+      }
+    }
+    let res;
+    try {
+      if (this.#idlUtils) {
+        node = this.#idlUtils.wrapperForImpl(node);
+      }
+      const nodes = this.#finder.setup(selector, node, opt).find(TARGET_SELF);
+      res = nodes.size;
+    } catch (e) {
+      this.#finder.onError(e, opt);
+    }
+    return !!res;
+  };
+
+  /**
+   * Traverses up the DOM tree to find the first node that matches the selector.
+   * @param {string} selector - The CSS selector to match against.
+   * @param {Element} node - The element from which to start traversing.
+   * @param {object} [opt] - Optional parameters.
+   * @returns {?Element} The first matching ancestor element, or `null`.
+   */
+  closest = (selector, node, opt = {}) => {
+    if (!node?.nodeType) {
+      const e = new this.#window.TypeError(`Unexpected type ${getType(node)}`);
+      return this.#finder.onError(e, opt);
+    } else if (node.nodeType !== ELEMENT_NODE) {
+      const e = new this.#window.TypeError(`Unexpected node ${node.nodeName}`);
+      return this.#finder.onError(e, opt);
+    }
+    const document = node.ownerDocument;
+    if (
+      document === this.#document &&
+      document.contentType === 'text/html' &&
+      document.documentElement &&
+      node.parentNode
+    ) {
+      const cacheKey = `closest_${selector}`;
+      let filterMatches = this.#cache.get(cacheKey);
+      if (filterMatches === undefined) {
+        filterMatches = filterSelector(selector, TARGET_LINEAL);
+        this.#cache.set(cacheKey, filterMatches);
+      }
+      if (filterMatches) {
+        try {
+          const n = this.#idlUtils ? this.#idlUtils.wrapperForImpl(node) : node;
+          return this.#nwsapi.closest(selector, n);
+        } catch (e) {
+          // fall through
+        }
+      }
+    }
+    let res;
+    try {
+      if (this.#idlUtils) {
+        node = this.#idlUtils.wrapperForImpl(node);
+      }
+      const nodes = this.#finder.setup(selector, node, opt).find(TARGET_LINEAL);
+      if (nodes.size) {
+        let refNode = node;
+        while (refNode) {
+          if (nodes.has(refNode)) {
+            res = refNode;
+            break;
+          }
+          refNode = refNode.parentNode;
+        }
+      }
+    } catch (e) {
+      this.#finder.onError(e, opt);
+    }
+    return res ?? null;
+  };
+
+  /**
+   * Returns the first element within the subtree that matches the selector.
+   * @param {string} selector - The CSS selector to match.
+   * @param {Document|DocumentFragment|Element} node - The node to find within.
+   * @param {object} [opt] - Optional parameters.
+   * @returns {?Element} The first matching element, or `null`.
+   */
+  querySelector = (selector, node, opt = {}) => {
+    if (!node?.nodeType) {
+      const e = new this.#window.TypeError(`Unexpected type ${getType(node)}`);
+      return this.#finder.onError(e, opt);
+    }
+    const document =
+      node.nodeType === DOCUMENT_NODE ? node : node.ownerDocument;
+    if (
+      document === this.#document &&
+      document.contentType === 'text/html' &&
+      document.documentElement &&
+      (node.nodeType !== DOCUMENT_FRAGMENT_NODE || !node.host)
+    ) {
+      const cacheKey = `querySelector_${selector}`;
+      let filterMatches = this.#cache.get(cacheKey);
+      if (filterMatches === undefined) {
+        filterMatches = filterSelector(selector, TARGET_FIRST);
+        this.#cache.set(cacheKey, filterMatches);
+      }
+      if (filterMatches) {
+        try {
+          const n = this.#idlUtils ? this.#idlUtils.wrapperForImpl(node) : node;
+          return this.#nwsapi.first(selector, n);
+        } catch (e) {
+          // fall through
+        }
+      }
+    }
+    let res;
+    try {
+      if (this.#idlUtils) {
+        node = this.#idlUtils.wrapperForImpl(node);
+      }
+      const nodes = this.#finder.setup(selector, node, opt).find(TARGET_FIRST);
+      if (nodes.size) {
+        [res] = [...nodes];
+      }
+    } catch (e) {
+      this.#finder.onError(e, opt);
+    }
+    return res ?? null;
+  };
+
+  /**
+   * Returns an array of elements within the subtree that match the selector.
+   * Note: This method returns an Array, not a NodeList.
+   * @param {string} selector - The CSS selector to match.
+   * @param {Document|DocumentFragment|Element} node - The node to find within.
+   * @param {object} [opt] - Optional parameters.
+   * @returns {Array<Element>} An array of elements, or an empty array.
+   */
+  querySelectorAll = (selector, node, opt = {}) => {
+    if (!node?.nodeType) {
+      const e = new this.#window.TypeError(`Unexpected type ${getType(node)}`);
+      return this.#finder.onError(e, opt);
+    }
+    const document =
+      node.nodeType === DOCUMENT_NODE ? node : node.ownerDocument;
+    if (
+      document === this.#document &&
+      document.contentType === 'text/html' &&
+      document.documentElement &&
+      (node.nodeType !== DOCUMENT_FRAGMENT_NODE || !node.host)
+    ) {
+      const cacheKey = `querySelectorAll_${selector}`;
+      let filterMatches = this.#cache.get(cacheKey);
+      if (filterMatches === undefined) {
+        filterMatches = filterSelector(selector, TARGET_ALL);
+        this.#cache.set(cacheKey, filterMatches);
+      }
+      if (filterMatches) {
+        try {
+          const n = this.#idlUtils ? this.#idlUtils.wrapperForImpl(node) : node;
+          return this.#nwsapi.select(selector, n);
+        } catch (e) {
+          // fall through
+        }
+      }
+    }
+    let res;
+    try {
+      if (this.#idlUtils) {
+        node = this.#idlUtils.wrapperForImpl(node);
+      }
+      const nodes = this.#finder.setup(selector, node, opt).find(TARGET_ALL);
+      if (nodes.size) {
+        res = [...nodes];
+      }
+    } catch (e) {
+      this.#finder.onError(e, opt);
+    }
+    return res ?? [];
+  };
+}
diff --git a/node_modules/@asamuzakjp/dom-selector/src/js/constant.js b/node_modules/@asamuzakjp/dom-selector/src/js/constant.js
new file mode 100644
index 0000000000000000000000000000000000000000..02986ecfec7cad12fdae6c077b197b53d154a27f
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/src/js/constant.js
@@ -0,0 +1,129 @@
+/**
+ * constant.js
+ */
+
+/* string */
+export const ATRULE = 'Atrule';
+export const ATTR_SELECTOR = 'AttributeSelector';
+export const CLASS_SELECTOR = 'ClassSelector';
+export const COMBINATOR = 'Combinator';
+export const IDENT = 'Identifier';
+export const ID_SELECTOR = 'IdSelector';
+export const NOT_SUPPORTED_ERR = 'NotSupportedError';
+export const NTH = 'Nth';
+export const OPERATOR = 'Operator';
+export const PS_CLASS_SELECTOR = 'PseudoClassSelector';
+export const PS_ELEMENT_SELECTOR = 'PseudoElementSelector';
+export const RULE = 'Rule';
+export const SCOPE = 'Scope';
+export const SELECTOR = 'Selector';
+export const SELECTOR_LIST = 'SelectorList';
+export const STRING = 'String';
+export const SYNTAX_ERR = 'SyntaxError';
+export const TARGET_ALL = 'all';
+export const TARGET_FIRST = 'first';
+export const TARGET_LINEAL = 'lineal';
+export const TARGET_SELF = 'self';
+export const TYPE_SELECTOR = 'TypeSelector';
+
+/* numeric */
+export const BIT_01 = 1;
+export const BIT_02 = 2;
+export const BIT_04 = 4;
+export const BIT_08 = 8;
+export const BIT_16 = 0x10;
+export const BIT_32 = 0x20;
+export const BIT_FFFF = 0xffff;
+export const DUO = 2;
+export const HEX = 16;
+export const TYPE_FROM = 8;
+export const TYPE_TO = -1;
+
+/* Node */
+export const ELEMENT_NODE = 1;
+export const TEXT_NODE = 3;
+export const DOCUMENT_NODE = 9;
+export const DOCUMENT_FRAGMENT_NODE = 11;
+export const DOCUMENT_POSITION_PRECEDING = 2;
+export const DOCUMENT_POSITION_CONTAINS = 8;
+export const DOCUMENT_POSITION_CONTAINED_BY = 0x10;
+
+/* NodeFilter */
+export const SHOW_ALL = 0xffffffff;
+export const SHOW_CONTAINER = 0x501;
+export const SHOW_DOCUMENT = 0x100;
+export const SHOW_DOCUMENT_FRAGMENT = 0x400;
+export const SHOW_ELEMENT = 1;
+
+/* selectors */
+export const ALPHA_NUM = '[A-Z\\d]+';
+export const CHILD_IDX = '(?:first|last|only)-(?:child|of-type)';
+export const DIGIT = '(?:0|[1-9]\\d*)';
+export const LANG_PART = `(?:-${ALPHA_NUM})*`;
+export const PSEUDO_CLASS = `(?:any-)?link|${CHILD_IDX}|checked|empty|indeterminate|read-(?:only|write)|target`;
+export const ANB = `[+-]?(?:${DIGIT}n?|n)|(?:[+-]?${DIGIT})?n\\s*[+-]\\s*${DIGIT}`;
+// combinators
+export const COMBO = '\\s?[\\s>~+]\\s?';
+export const DESCEND = '\\s?[\\s>]\\s?';
+export const SIBLING = '\\s?[+~]\\s?';
+// LOGIC_IS: :is()
+export const LOGIC_IS = `:is\\(\\s*[^)]+\\s*\\)`;
+// N_TH: excludes An+B with selector list, e.g. :nth-child(2n+1 of .foo)
+export const N_TH = `nth-(?:last-)?(?:child|of-type)\\(\\s*(?:even|odd|${ANB})\\s*\\)`;
+// SUB_TYPE: attr, id, class, pseudo-class, note that [foo|=bar] is excluded
+export const SUB_TYPE = '\\[[^|\\]]+\\]|[#.:][\\w-]+';
+export const SUB_TYPE_WO_PSEUDO = '\\[[^|\\]]+\\]|[#.][\\w-]+';
+// TAG_TYPE: *, tag
+export const TAG_TYPE = '\\*|[A-Za-z][\\w-]*';
+export const TAG_TYPE_I = '\\*|[A-Z][\\w-]*';
+export const COMPOUND = `(?:${TAG_TYPE}|(?:${TAG_TYPE})?(?:${SUB_TYPE})+)`;
+export const COMPOUND_L = `(?:${TAG_TYPE}|(?:${TAG_TYPE})?(?:${SUB_TYPE}|${LOGIC_IS})+)`;
+export const COMPOUND_I = `(?:${TAG_TYPE_I}|(?:${TAG_TYPE_I})?(?:${SUB_TYPE})+)`;
+export const COMPOUND_WO_PSEUDO = `(?:${TAG_TYPE}|(?:${TAG_TYPE})?(?:${SUB_TYPE_WO_PSEUDO})+)`;
+export const COMPLEX = `${COMPOUND}(?:${COMBO}${COMPOUND})*`;
+export const COMPLEX_L = `${COMPOUND_L}(?:${COMBO}${COMPOUND_L})*`;
+export const HAS_COMPOUND = `has\\([\\s>]?\\s*${COMPOUND_WO_PSEUDO}\\s*\\)`;
+export const LOGIC_COMPOUND = `(?:is|not)\\(\\s*${COMPOUND_L}(?:\\s*,\\s*${COMPOUND_L})*\\s*\\)`;
+export const LOGIC_COMPLEX = `(?:is|not)\\(\\s*${COMPLEX_L}(?:\\s*,\\s*${COMPLEX_L})*\\s*\\)`;
+
+/* forms and input types */
+export const FORM_PARTS = Object.freeze([
+  'button',
+  'input',
+  'select',
+  'textarea'
+]);
+export const INPUT_BUTTON = Object.freeze(['button', 'reset', 'submit']);
+export const INPUT_CHECK = Object.freeze(['checkbox', 'radio']);
+export const INPUT_DATE = Object.freeze([
+  'date',
+  'datetime-local',
+  'month',
+  'time',
+  'week'
+]);
+export const INPUT_TEXT = Object.freeze([
+  'email',
+  'password',
+  'search',
+  'tel',
+  'text',
+  'url'
+]);
+export const INPUT_EDIT = Object.freeze([
+  ...INPUT_DATE,
+  ...INPUT_TEXT,
+  'number'
+]);
+export const INPUT_LTR = Object.freeze([
+  ...INPUT_CHECK,
+  'color',
+  'date',
+  'image',
+  'number',
+  'range',
+  'time'
+]);
+
+/* logical combination pseudo-classes */
+export const KEYS_LOGICAL = new Set(['has', 'is', 'not', 'where']);
diff --git a/node_modules/@asamuzakjp/dom-selector/src/js/finder.js b/node_modules/@asamuzakjp/dom-selector/src/js/finder.js
new file mode 100644
index 0000000000000000000000000000000000000000..cd94b9d7f0b6a6c2fe93da6dff1eb21bf698c070
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/src/js/finder.js
@@ -0,0 +1,3150 @@
+/**
+ * finder.js
+ */
+
+/* import */
+import {
+  matchAttributeSelector,
+  matchDirectionPseudoClass,
+  matchDisabledPseudoClass,
+  matchLanguagePseudoClass,
+  matchPseudoElementSelector,
+  matchReadOnlyPseudoClass,
+  matchTypeSelector
+} from './matcher.js';
+import {
+  findAST,
+  generateCSS,
+  parseSelector,
+  sortAST,
+  unescapeSelector,
+  walkAST
+} from './parser.js';
+import {
+  filterNodesByAnB,
+  findLogicalWithNestedHas,
+  generateException,
+  isCustomElement,
+  isFocusVisible,
+  isFocusableArea,
+  isVisible,
+  resolveContent,
+  sortNodes,
+  traverseNode
+} from './utility.js';
+
+/* constants */
+import {
+  ATTR_SELECTOR,
+  CLASS_SELECTOR,
+  COMBINATOR,
+  DOCUMENT_FRAGMENT_NODE,
+  ELEMENT_NODE,
+  FORM_PARTS,
+  ID_SELECTOR,
+  INPUT_CHECK,
+  INPUT_DATE,
+  INPUT_EDIT,
+  INPUT_TEXT,
+  KEYS_LOGICAL,
+  NOT_SUPPORTED_ERR,
+  PS_CLASS_SELECTOR,
+  PS_ELEMENT_SELECTOR,
+  SHOW_ALL,
+  SHOW_CONTAINER,
+  SYNTAX_ERR,
+  TARGET_ALL,
+  TARGET_FIRST,
+  TARGET_LINEAL,
+  TARGET_SELF,
+  TEXT_NODE,
+  TYPE_SELECTOR
+} from './constant.js';
+const DIR_NEXT = 'next';
+const DIR_PREV = 'prev';
+const KEYS_FORM = new Set([...FORM_PARTS, 'fieldset', 'form']);
+const KEYS_FORM_PS_VALID = new Set([...FORM_PARTS, 'form']);
+const KEYS_INPUT_CHECK = new Set(INPUT_CHECK);
+const KEYS_INPUT_PLACEHOLDER = new Set([...INPUT_TEXT, 'number']);
+const KEYS_INPUT_RANGE = new Set([...INPUT_DATE, 'number', 'range']);
+const KEYS_INPUT_REQUIRED = new Set([...INPUT_CHECK, ...INPUT_EDIT, 'file']);
+const KEYS_INPUT_RESET = new Set(['button', 'reset']);
+const KEYS_INPUT_SUBMIT = new Set(['image', 'submit']);
+const KEYS_MODIFIER = new Set([
+  'Alt',
+  'AltGraph',
+  'CapsLock',
+  'Control',
+  'Fn',
+  'FnLock',
+  'Hyper',
+  'Meta',
+  'NumLock',
+  'ScrollLock',
+  'Shift',
+  'Super',
+  'Symbol',
+  'SymbolLock'
+]);
+const KEYS_PS_UNCACHE = new Set([
+  'any-link',
+  'defined',
+  'dir',
+  'link',
+  'scope'
+]);
+const KEYS_PS_NTH_OF_TYPE = new Set([
+  'first-of-type',
+  'last-of-type',
+  'only-of-type'
+]);
+
+/**
+ * Finder
+ * NOTE: #ast[i] corresponds to #nodes[i]
+ */
+export class Finder {
+  /* private fields */
+  #ast;
+  #astCache;
+  #check;
+  #descendant;
+  #document;
+  #documentCache;
+  #documentURL;
+  #event;
+  #eventHandlers;
+  #filterLeavesCache;
+  #focus;
+  #invalidate;
+  #invalidateResults;
+  #lastFocusVisible;
+  #node;
+  #nodeWalker;
+  #nodes;
+  #noexcept;
+  #pseudoElement;
+  #results;
+  #root;
+  #rootWalker;
+  #scoped;
+  #selector;
+  #selectorAST;
+  #shadow;
+  #verifyShadowHost;
+  #walkers;
+  #warn;
+  #window;
+
+  /**
+   * constructor
+   * @param {object} window - The window object.
+   */
+  constructor(window) {
+    this.#window = window;
+    this.#astCache = new WeakMap();
+    this.#documentCache = new WeakMap();
+    this.#event = null;
+    this.#focus = null;
+    this.#lastFocusVisible = null;
+    this.#eventHandlers = new Set([
+      {
+        keys: ['focus', 'focusin'],
+        handler: this._handleFocusEvent
+      },
+      {
+        keys: ['keydown', 'keyup'],
+        handler: this._handleKeyboardEvent
+      },
+      {
+        keys: ['mouseover', 'mousedown', 'mouseup', 'click', 'mouseout'],
+        handler: this._handleMouseEvent
+      }
+    ]);
+    this.#filterLeavesCache = new WeakMap();
+    this._registerEventListeners();
+    this.clearResults(true);
+  }
+
+  /**
+   * Handles errors.
+   * @param {Error} e - The error object.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.noexcept] - If true, exceptions are not thrown.
+   * @throws {Error} Throws an error.
+   * @returns {void}
+   */
+  onError = (e, opt = {}) => {
+    const noexcept = opt.noexcept ?? this.#noexcept;
+    if (noexcept) {
+      return;
+    }
+    const isDOMException =
+      e instanceof DOMException || e instanceof this.#window.DOMException;
+    if (isDOMException) {
+      if (e.name === NOT_SUPPORTED_ERR) {
+        if (this.#warn) {
+          console.warn(e.message);
+        }
+        return;
+      }
+      throw new this.#window.DOMException(e.message, e.name);
+    }
+    if (e.name in this.#window) {
+      throw new this.#window[e.name](e.message, { cause: e });
+    }
+    throw e;
+  };
+
+  /**
+   * Sets up the finder.
+   * @param {string} selector - The CSS selector.
+   * @param {object} node - Document, DocumentFragment, or Element.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.check] - Indicates if running in internal check().
+   * @param {boolean} [opt.noexcept] - If true, exceptions are not thrown.
+   * @param {boolean} [opt.warn] - If true, console warnings are enabled.
+   * @returns {object} The finder instance.
+   */
+  setup = (selector, node, opt = {}) => {
+    const { check, noexcept, warn } = opt;
+    this.#check = !!check;
+    this.#noexcept = !!noexcept;
+    this.#warn = !!warn;
+    [this.#document, this.#root, this.#shadow] = resolveContent(node);
+    this.#documentURL = null;
+    this.#node = node;
+    this.#scoped =
+      this.#node !== this.#root && this.#node.nodeType === ELEMENT_NODE;
+    this.#selector = selector;
+    this.#pseudoElement = [];
+    this.#walkers = new WeakMap();
+    this.#nodeWalker = null;
+    this.#rootWalker = null;
+    this.#verifyShadowHost = null;
+    this.clearResults();
+    return this;
+  };
+
+  /**
+   * Clear cached results.
+   * @param {boolean} all - clear all results
+   * @returns {void}
+   */
+  clearResults = (all = false) => {
+    this.#invalidateResults = new WeakMap();
+    if (all) {
+      this.#results = new WeakMap();
+      this.#filterLeavesCache = new WeakMap();
+    }
+  };
+
+  /**
+   * Handles focus events.
+   * @private
+   * @param {Event} evt - The event object.
+   * @returns {void}
+   */
+  _handleFocusEvent = evt => {
+    this.#focus = evt;
+  };
+
+  /**
+   * Handles keyboard events.
+   * @private
+   * @param {Event} evt - The event object.
+   * @returns {void}
+   */
+  _handleKeyboardEvent = evt => {
+    const { key } = evt;
+    if (!KEYS_MODIFIER.has(key)) {
+      this.#event = evt;
+    }
+  };
+
+  /**
+   * Handles mouse events.
+   * @private
+   * @param {Event} evt - The event object.
+   * @returns {void}
+   */
+  _handleMouseEvent = evt => {
+    this.#event = evt;
+  };
+
+  /**
+   * Registers event listeners.
+   * @private
+   * @returns {Array.<void>} An array of return values from addEventListener.
+   */
+  _registerEventListeners = () => {
+    const func = [];
+    for (const eventHandler of this.#eventHandlers) {
+      const { keys, handler } = eventHandler;
+      const l = keys.length;
+      for (let i = 0; i < l; i++) {
+        const key = keys[i];
+        func.push(
+          this.#window.addEventListener(key, handler, {
+            capture: true,
+            passive: true
+          })
+        );
+      }
+    }
+    return func;
+  };
+
+  /**
+   * Processes selector branches into the internal AST structure.
+   * @private
+   * @param {Array.<Array.<object>>} branches - The branches from walkAST.
+   * @param {string} selector - The original selector for error reporting.
+   * @returns {{ast: Array, descendant: boolean}}
+   * An object with the AST, descendant flag.
+   */
+  _processSelectorBranches = (branches, selector) => {
+    let descendant = false;
+    const ast = [];
+    const l = branches.length;
+    for (let i = 0; i < l; i++) {
+      const items = [...branches[i]];
+      const branch = [];
+      let item = items.shift();
+      if (item && item.type !== COMBINATOR) {
+        const leaves = new Set();
+        while (item) {
+          if (item.type === COMBINATOR) {
+            const [nextItem] = items;
+            if (!nextItem || nextItem.type === COMBINATOR) {
+              const msg = `Invalid selector ${selector}`;
+              this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+              // Stop processing on invalid selector.
+              return { ast: [], descendant: false, invalidate: false };
+            }
+            if (item.name === ' ' || item.name === '>') {
+              descendant = true;
+            }
+            branch.push({ combo: item, leaves: sortAST(leaves) });
+            leaves.clear();
+          } else {
+            if (item.name && typeof item.name === 'string') {
+              const unescapedName = unescapeSelector(item.name);
+              if (unescapedName !== item.name) {
+                item.name = unescapedName;
+              }
+              if (/[|:]/.test(unescapedName)) {
+                item.namespace = true;
+              }
+            }
+            leaves.add(item);
+          }
+          if (items.length) {
+            item = items.shift();
+          } else {
+            branch.push({ combo: null, leaves: sortAST(leaves) });
+            leaves.clear();
+            break;
+          }
+        }
+      }
+      ast.push({ branch, dir: null, filtered: false, find: false });
+    }
+    return { ast, descendant };
+  };
+
+  /**
+   * Corresponds AST and nodes.
+   * @private
+   * @param {string} selector - The CSS selector.
+   * @returns {Array.<Array.<object>>} An array with the AST and nodes.
+   */
+  _correspond = selector => {
+    const nodes = [];
+    this.#descendant = false;
+    this.#invalidate = false;
+    let ast;
+    if (this.#documentCache.has(this.#document)) {
+      const cachedItem = this.#documentCache.get(this.#document);
+      if (cachedItem && cachedItem.has(`${selector}`)) {
+        const item = cachedItem.get(`${selector}`);
+        ast = item.ast;
+        this.#descendant = item.descendant;
+        this.#invalidate = item.invalidate;
+        this.#selectorAST = item.selectorAST;
+      }
+    }
+    if (ast) {
+      const l = ast.length;
+      for (let i = 0; i < l; i++) {
+        ast[i].dir = null;
+        ast[i].filtered = false;
+        ast[i].find = false;
+        nodes[i] = [];
+      }
+    } else {
+      this.#selectorAST = parseSelector(selector);
+      const { branches, info } = walkAST(this.#selectorAST, true);
+      const {
+        hasHasPseudoFunc,
+        hasLogicalPseudoFunc,
+        hasNthChildOfSelector,
+        hasStatePseudoClass
+      } = info;
+      this.#invalidate =
+        hasHasPseudoFunc ||
+        hasStatePseudoClass ||
+        !!(hasLogicalPseudoFunc && hasNthChildOfSelector);
+      const processed = this._processSelectorBranches(branches, selector);
+      ast = processed.ast;
+      this.#descendant = processed.descendant;
+      let cachedItem;
+      if (this.#documentCache.has(this.#document)) {
+        cachedItem = this.#documentCache.get(this.#document);
+      } else {
+        cachedItem = new Map();
+      }
+      cachedItem.set(`${selector}`, {
+        ast,
+        descendant: this.#descendant,
+        invalidate: this.#invalidate,
+        selectorAST: this.#selectorAST
+      });
+      this.#documentCache.set(this.#document, cachedItem);
+      // Initialize nodes array for each branch.
+      for (let i = 0; i < ast.length; i++) {
+        nodes[i] = [];
+      }
+    }
+    return [ast, nodes];
+  };
+
+  /**
+   * Creates a TreeWalker.
+   * @private
+   * @param {object} node - The Document, DocumentFragment, or Element node.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.force] - Force creation of a new TreeWalker.
+   * @param {number} [opt.whatToShow] - The NodeFilter whatToShow value.
+   * @returns {object} The TreeWalker object.
+   */
+  _createTreeWalker = (node, opt = {}) => {
+    const { force = false, whatToShow = SHOW_CONTAINER } = opt;
+    if (force) {
+      return this.#document.createTreeWalker(node, whatToShow);
+    } else if (this.#walkers.has(node)) {
+      return this.#walkers.get(node);
+    }
+    const walker = this.#document.createTreeWalker(node, whatToShow);
+    this.#walkers.set(node, walker);
+    return walker;
+  };
+
+  /**
+   * Gets selector branches from cache or parses them.
+   * @private
+   * @param {object} selector - The AST.
+   * @returns {Array.<Array.<object>>} The selector branches.
+   */
+  _getSelectorBranches = selector => {
+    if (this.#astCache.has(selector)) {
+      return this.#astCache.get(selector);
+    }
+    const { branches } = walkAST(selector);
+    this.#astCache.set(selector, branches);
+    return branches;
+  };
+
+  /**
+   * Gets the children of a node, optionally filtered by a selector.
+   * @private
+   * @param {object} parentNode - The parent element.
+   * @param {Array.<Array.<object>>} selectorBranches - The selector branches.
+   * @param {object} opt - Options.
+   * @returns {Array.<object>} An array of child nodes.
+   */
+  _getFilteredChildren = (parentNode, selectorBranches, opt) => {
+    const children = [];
+    let childNode = parentNode.firstElementChild;
+    while (childNode) {
+      if (selectorBranches) {
+        let isMatch = false;
+        const l = selectorBranches.length;
+        for (let i = 0; i < l; i++) {
+          const leaves = selectorBranches[i];
+          if (this._matchLeaves(leaves, childNode, opt)) {
+            isMatch = true;
+            break;
+          }
+        }
+        if (isMatch) {
+          if (this.#node === childNode) {
+            children.push(childNode);
+          } else if (isVisible(childNode)) {
+            children.push(childNode);
+          }
+        }
+      } else {
+        children.push(childNode);
+      }
+      childNode = childNode.nextElementSibling;
+    }
+    return children;
+  };
+
+  /**
+   * Collects nth-child nodes.
+   * @private
+   * @param {object} anb - An+B options.
+   * @param {number} anb.a - The 'a' value.
+   * @param {number} anb.b - The 'b' value.
+   * @param {boolean} [anb.reverse] - If true, reverses the order.
+   * @param {object} [anb.selector] - The AST.
+   * @param {object} node - The Element node.
+   * @param {object} opt - Options.
+   * @returns {Set.<object>} A collection of matched nodes.
+   */
+  _collectNthChild = (anb, node, opt) => {
+    const { a, b, selector } = anb;
+    const { parentNode } = node;
+    if (!parentNode) {
+      const matchedNode = new Set();
+      if (node === this.#root && a * 1 + b * 1 === 1) {
+        if (selector) {
+          const selectorBranches = this._getSelectorBranches(selector);
+          const l = selectorBranches.length;
+          for (let i = 0; i < l; i++) {
+            const leaves = selectorBranches[i];
+            if (this._matchLeaves(leaves, node, opt)) {
+              matchedNode.add(node);
+              break;
+            }
+          }
+        } else {
+          matchedNode.add(node);
+        }
+      }
+      return matchedNode;
+    }
+    const selectorBranches = selector
+      ? this._getSelectorBranches(selector)
+      : null;
+    const children = this._getFilteredChildren(
+      parentNode,
+      selectorBranches,
+      opt
+    );
+    const matchedNodes = filterNodesByAnB(children, anb);
+    return new Set(matchedNodes);
+  };
+
+  /**
+   * Collects nth-of-type nodes.
+   * @private
+   * @param {object} anb - An+B options.
+   * @param {number} anb.a - The 'a' value.
+   * @param {number} anb.b - The 'b' value.
+   * @param {boolean} [anb.reverse] - If true, reverses the order.
+   * @param {object} node - The Element node.
+   * @returns {Set.<object>} A collection of matched nodes.
+   */
+  _collectNthOfType = (anb, node) => {
+    const { parentNode } = node;
+    if (!parentNode) {
+      if (node === this.#root && anb.a * 1 + anb.b * 1 === 1) {
+        return new Set([node]);
+      }
+      return new Set();
+    }
+    const typedSiblings = [];
+    let sibling = parentNode.firstElementChild;
+    while (sibling) {
+      if (
+        sibling.localName === node.localName &&
+        sibling.namespaceURI === node.namespaceURI &&
+        sibling.prefix === node.prefix
+      ) {
+        typedSiblings.push(sibling);
+      }
+      sibling = sibling.nextElementSibling;
+    }
+    const matchedNodes = filterNodesByAnB(typedSiblings, anb);
+    return new Set(matchedNodes);
+  };
+
+  /**
+   * Matches An+B.
+   * @private
+   * @param {object} ast - The AST.
+   * @param {object} node - The Element node.
+   * @param {string} nthName - The name of the nth pseudo-class.
+   * @param {object} opt - Options.
+   * @returns {Set.<object>} A collection of matched nodes.
+   */
+  _matchAnPlusB = (ast, node, nthName, opt) => {
+    const {
+      nth: { a, b, name: nthIdentName },
+      selector
+    } = ast;
+    const anbMap = new Map();
+    if (nthIdentName) {
+      if (nthIdentName === 'even') {
+        anbMap.set('a', 2);
+        anbMap.set('b', 0);
+      } else if (nthIdentName === 'odd') {
+        anbMap.set('a', 2);
+        anbMap.set('b', 1);
+      }
+      if (nthName.indexOf('last') > -1) {
+        anbMap.set('reverse', true);
+      }
+    } else {
+      if (typeof a === 'string' && /-?\d+/.test(a)) {
+        anbMap.set('a', a * 1);
+      } else {
+        anbMap.set('a', 0);
+      }
+      if (typeof b === 'string' && /-?\d+/.test(b)) {
+        anbMap.set('b', b * 1);
+      } else {
+        anbMap.set('b', 0);
+      }
+      if (nthName.indexOf('last') > -1) {
+        anbMap.set('reverse', true);
+      }
+    }
+    if (nthName === 'nth-child' || nthName === 'nth-last-child') {
+      if (selector) {
+        anbMap.set('selector', selector);
+      }
+      const anb = Object.fromEntries(anbMap);
+      const nodes = this._collectNthChild(anb, node, opt);
+      return nodes;
+    } else if (nthName === 'nth-of-type' || nthName === 'nth-last-of-type') {
+      const anb = Object.fromEntries(anbMap);
+      const nodes = this._collectNthOfType(anb, node);
+      return nodes;
+    }
+    return new Set();
+  };
+
+  /**
+   * Matches the :has() pseudo-class function.
+   * @private
+   * @param {Array.<object>} astLeaves - The AST leaves.
+   * @param {object} node - The Element node.
+   * @param {object} [opt] - Options.
+   * @returns {boolean} The result.
+   */
+  _matchHasPseudoFunc = (astLeaves, node, opt = {}) => {
+    if (Array.isArray(astLeaves) && astLeaves.length) {
+      // Prepare a copy to avoid astLeaves being consumed.
+      const leaves = [...astLeaves];
+      const [leaf] = leaves;
+      const { type: leafType } = leaf;
+      let combo;
+      if (leafType === COMBINATOR) {
+        combo = leaves.shift();
+      } else {
+        combo = {
+          name: ' ',
+          type: COMBINATOR
+        };
+      }
+      const twigLeaves = [];
+      while (leaves.length) {
+        const [item] = leaves;
+        const { type: itemType } = item;
+        if (itemType === COMBINATOR) {
+          break;
+        } else {
+          twigLeaves.push(leaves.shift());
+        }
+      }
+      const twig = {
+        combo,
+        leaves: twigLeaves
+      };
+      opt.dir = DIR_NEXT;
+      const nodes = this._collectCombinatorMatches(twig, node, opt, []);
+      if (nodes.length) {
+        if (leaves.length) {
+          let bool = false;
+          for (const nextNode of nodes) {
+            bool = this._matchHasPseudoFunc(leaves, nextNode, opt);
+            if (bool) {
+              break;
+            }
+          }
+          return bool;
+        }
+        return true;
+      }
+    }
+    return false;
+  };
+
+  /**
+   * Evaluates the :has() pseudo-class.
+   * @private
+   * @param {object} astData - The AST data.
+   * @param {object} node - The Element node.
+   * @param {object} [opt] - Options.
+   * @returns {?object} The matched node.
+   */
+  _evaluateHasPseudo = (astData, node, opt = {}) => {
+    const { branches } = astData;
+    let bool = false;
+    const l = branches.length;
+    for (let i = 0; i < l; i++) {
+      const leaves = branches[i];
+      bool = this._matchHasPseudoFunc(leaves, node, opt);
+      if (bool) {
+        break;
+      }
+    }
+    if (!bool) {
+      return null;
+    }
+    if (
+      (opt.isShadowRoot || this.#shadow) &&
+      node.nodeType === DOCUMENT_FRAGMENT_NODE
+    ) {
+      return this.#verifyShadowHost ? node : null;
+    }
+    return node;
+  };
+
+  /**
+   * Matches logical pseudo-class functions.
+   * @private
+   * @param {object} astData - The AST data.
+   * @param {object} node - The Element node.
+   * @param {object} [opt] - Options.
+   * @returns {?object} The matched node.
+   */
+  _matchLogicalPseudoFunc = (astData, node, opt = {}) => {
+    const { astName, branches, twigBranches } = astData;
+    // Handle :has().
+    if (astName === 'has') {
+      return this._evaluateHasPseudo(astData, node, opt);
+    }
+    // Handle :is(), :not(), :where().
+    const isShadowRoot =
+      (opt.isShadowRoot || this.#shadow) &&
+      node.nodeType === DOCUMENT_FRAGMENT_NODE;
+    // Check for invalid shadow root.
+    if (isShadowRoot) {
+      let invalid = false;
+      for (const branch of branches) {
+        if (branch.length > 1) {
+          invalid = true;
+          break;
+        } else if (astName === 'not') {
+          const [{ type: childAstType }] = branch;
+          if (childAstType !== PS_CLASS_SELECTOR) {
+            invalid = true;
+            break;
+          }
+        }
+      }
+      if (invalid) {
+        return null;
+      }
+    }
+    opt.forgive = astName === 'is' || astName === 'where';
+    const l = twigBranches.length;
+    let bool;
+    for (let i = 0; i < l; i++) {
+      const branch = twigBranches[i];
+      const lastIndex = branch.length - 1;
+      const { leaves } = branch[lastIndex];
+      bool = this._matchLeaves(leaves, node, opt);
+      if (bool && lastIndex > 0) {
+        let nextNodes = new Set([node]);
+        for (let j = lastIndex - 1; j >= 0; j--) {
+          const twig = branch[j];
+          const arr = [];
+          opt.dir = DIR_PREV;
+          for (const nextNode of nextNodes) {
+            this._collectCombinatorMatches(twig, nextNode, opt, arr);
+          }
+          if (arr.length) {
+            if (j === 0) {
+              bool = true;
+            } else {
+              nextNodes = new Set(arr);
+            }
+          } else {
+            bool = false;
+            break;
+          }
+        }
+      }
+      if (bool) {
+        break;
+      }
+    }
+    if (astName === 'not') {
+      if (bool) {
+        return null;
+      }
+      return node;
+    } else if (bool) {
+      return node;
+    }
+    return null;
+  };
+
+  /**
+   * Matches pseudo-class selector.
+   * @private
+   * @see https://html.spec.whatwg.org/#pseudo-classes
+   * @param {object} ast - The AST.
+   * @param {object} node - The Element node.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.forgive] - Ignores unknown or invalid selectors.
+   * @param {boolean} [opt.warn] - If true, console warnings are enabled.
+   * @returns {Set.<object>} A collection of matched nodes.
+   */
+  _matchPseudoClassSelector(ast, node, opt = {}) {
+    const { children: astChildren, name: astName } = ast;
+    const { localName, parentNode } = node;
+    const { forgive, warn = this.#warn } = opt;
+    const matched = new Set();
+    // :has(), :is(), :not(), :where()
+    if (Array.isArray(astChildren) && KEYS_LOGICAL.has(astName)) {
+      if (!astChildren.length && astName !== 'is' && astName !== 'where') {
+        const css = generateCSS(ast);
+        const msg = `Invalid selector ${css}`;
+        return this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+      }
+      let astData;
+      if (this.#astCache.has(ast)) {
+        astData = this.#astCache.get(ast);
+      } else {
+        const { branches } = walkAST(ast);
+        if (astName === 'has') {
+          // Check for nested :has().
+          let forgiven = false;
+          const l = astChildren.length;
+          for (let i = 0; i < l; i++) {
+            const child = astChildren[i];
+            const item = findAST(child, findLogicalWithNestedHas);
+            if (item) {
+              const itemName = item.name;
+              if (itemName === 'is' || itemName === 'where') {
+                forgiven = true;
+                break;
+              } else {
+                const css = generateCSS(ast);
+                const msg = `Invalid selector ${css}`;
+                return this.onError(
+                  generateException(msg, SYNTAX_ERR, this.#window)
+                );
+              }
+            }
+          }
+          if (forgiven) {
+            return matched;
+          }
+          astData = {
+            astName,
+            branches
+          };
+        } else {
+          const twigBranches = [];
+          const l = branches.length;
+          for (let i = 0; i < l; i++) {
+            const [...leaves] = branches[i];
+            const branch = [];
+            const leavesSet = new Set();
+            let item = leaves.shift();
+            while (item) {
+              if (item.type === COMBINATOR) {
+                branch.push({
+                  combo: item,
+                  leaves: [...leavesSet]
+                });
+                leavesSet.clear();
+              } else if (item) {
+                leavesSet.add(item);
+              }
+              if (leaves.length) {
+                item = leaves.shift();
+              } else {
+                branch.push({
+                  combo: null,
+                  leaves: [...leavesSet]
+                });
+                leavesSet.clear();
+                break;
+              }
+            }
+            twigBranches.push(branch);
+          }
+          astData = {
+            astName,
+            branches,
+            twigBranches
+          };
+          this.#astCache.set(ast, astData);
+        }
+      }
+      const res = this._matchLogicalPseudoFunc(astData, node, opt);
+      if (res) {
+        matched.add(res);
+      }
+    } else if (Array.isArray(astChildren)) {
+      // :nth-child(), :nth-last-child(), nth-of-type(), :nth-last-of-type()
+      if (/^nth-(?:last-)?(?:child|of-type)$/.test(astName)) {
+        if (astChildren.length !== 1) {
+          const css = generateCSS(ast);
+          return this.onError(
+            generateException(
+              `Invalid selector ${css}`,
+              SYNTAX_ERR,
+              this.#window
+            )
+          );
+        }
+        const [branch] = astChildren;
+        const nodes = this._matchAnPlusB(branch, node, astName, opt);
+        return nodes;
+      } else {
+        switch (astName) {
+          // :dir()
+          case 'dir': {
+            if (astChildren.length !== 1) {
+              const css = generateCSS(ast);
+              return this.onError(
+                generateException(
+                  `Invalid selector ${css}`,
+                  SYNTAX_ERR,
+                  this.#window
+                )
+              );
+            }
+            const [astChild] = astChildren;
+            const res = matchDirectionPseudoClass(astChild, node);
+            if (res) {
+              matched.add(node);
+            }
+            break;
+          }
+          // :lang()
+          case 'lang': {
+            if (!astChildren.length) {
+              const css = generateCSS(ast);
+              return this.onError(
+                generateException(
+                  `Invalid selector ${css}`,
+                  SYNTAX_ERR,
+                  this.#window
+                )
+              );
+            }
+            let bool;
+            for (const astChild of astChildren) {
+              bool = matchLanguagePseudoClass(astChild, node);
+              if (bool) {
+                break;
+              }
+            }
+            if (bool) {
+              matched.add(node);
+            }
+            break;
+          }
+          // :state()
+          case 'state': {
+            if (isCustomElement(node)) {
+              const [{ value: stateValue }] = astChildren;
+              if (stateValue) {
+                if (node[stateValue]) {
+                  matched.add(node);
+                } else {
+                  for (const i in node) {
+                    const prop = node[i];
+                    if (prop instanceof this.#window.ElementInternals) {
+                      if (prop?.states?.has(stateValue)) {
+                        matched.add(node);
+                      }
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+            break;
+          }
+          case 'current':
+          case 'heading':
+          case 'nth-col':
+          case 'nth-last-col': {
+            if (warn) {
+              this.onError(
+                generateException(
+                  `Unsupported pseudo-class :${astName}()`,
+                  NOT_SUPPORTED_ERR,
+                  this.#window
+                )
+              );
+            }
+            break;
+          }
+          // Ignore :host() and :host-context().
+          case 'host':
+          case 'host-context': {
+            break;
+          }
+          // Deprecated in CSS Selectors 3.
+          case 'contains': {
+            if (warn) {
+              this.onError(
+                generateException(
+                  `Unknown pseudo-class :${astName}()`,
+                  NOT_SUPPORTED_ERR,
+                  this.#window
+                )
+              );
+            }
+            break;
+          }
+          default: {
+            if (!forgive) {
+              this.onError(
+                generateException(
+                  `Unknown pseudo-class :${astName}()`,
+                  SYNTAX_ERR,
+                  this.#window
+                )
+              );
+            }
+          }
+        }
+      }
+    } else if (KEYS_PS_NTH_OF_TYPE.has(astName)) {
+      if (node === this.#root) {
+        matched.add(node);
+      } else if (parentNode) {
+        switch (astName) {
+          case 'first-of-type': {
+            const [node1] = this._collectNthOfType(
+              {
+                a: 0,
+                b: 1
+              },
+              node
+            );
+            if (node1) {
+              matched.add(node1);
+            }
+            break;
+          }
+          case 'last-of-type': {
+            const [node1] = this._collectNthOfType(
+              {
+                a: 0,
+                b: 1,
+                reverse: true
+              },
+              node
+            );
+            if (node1) {
+              matched.add(node1);
+            }
+            break;
+          }
+          // 'only-of-type' is handled by default.
+          default: {
+            const [node1] = this._collectNthOfType(
+              {
+                a: 0,
+                b: 1
+              },
+              node
+            );
+            if (node1 === node) {
+              const [node2] = this._collectNthOfType(
+                {
+                  a: 0,
+                  b: 1,
+                  reverse: true
+                },
+                node
+              );
+              if (node2 === node) {
+                matched.add(node);
+              }
+            }
+          }
+        }
+      }
+    } else {
+      switch (astName) {
+        case 'disabled':
+        case 'enabled': {
+          const isMatch = matchDisabledPseudoClass(astName, node);
+          if (isMatch) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'read-only':
+        case 'read-write': {
+          const isMatch = matchReadOnlyPseudoClass(astName, node);
+          if (isMatch) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'any-link':
+        case 'link': {
+          if (
+            (localName === 'a' || localName === 'area') &&
+            node.hasAttribute('href')
+          ) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'local-link': {
+          if (
+            (localName === 'a' || localName === 'area') &&
+            node.hasAttribute('href')
+          ) {
+            if (!this.#documentURL) {
+              this.#documentURL = new URL(this.#document.URL);
+            }
+            const { href, origin, pathname } = this.#documentURL;
+            const attrURL = new URL(node.getAttribute('href'), href);
+            if (attrURL.origin === origin && attrURL.pathname === pathname) {
+              matched.add(node);
+            }
+          }
+          break;
+        }
+        case 'visited': {
+          // prevent fingerprinting
+          break;
+        }
+        case 'hover': {
+          const { target, type } = this.#event ?? {};
+          if (
+            /^(?:click|mouse(?:down|over|up))$/.test(type) &&
+            target?.nodeType === ELEMENT_NODE &&
+            node.contains(target)
+          ) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'active': {
+          const { buttons, target, type } = this.#event ?? {};
+          if (
+            type === 'mousedown' &&
+            buttons & 1 &&
+            target?.nodeType === ELEMENT_NODE &&
+            node.contains(target)
+          ) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'target': {
+          if (!this.#documentURL) {
+            this.#documentURL = new URL(this.#document.URL);
+          }
+          const { hash } = this.#documentURL;
+          if (
+            node.id &&
+            hash === `#${node.id}` &&
+            this.#document.contains(node)
+          ) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'target-within': {
+          if (!this.#documentURL) {
+            this.#documentURL = new URL(this.#document.URL);
+          }
+          const { hash } = this.#documentURL;
+          if (hash) {
+            const id = hash.replace(/^#/, '');
+            let current = this.#document.getElementById(id);
+            while (current) {
+              if (current === node) {
+                matched.add(node);
+                break;
+              }
+              current = current.parentNode;
+            }
+          }
+          break;
+        }
+        case 'scope': {
+          if (this.#node.nodeType === ELEMENT_NODE) {
+            if (!this.#shadow && node === this.#node) {
+              matched.add(node);
+            }
+          } else if (node === this.#document.documentElement) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'focus': {
+          const activeElement = this.#document.activeElement;
+          if (node === activeElement && isFocusableArea(node)) {
+            matched.add(node);
+          } else if (activeElement.shadowRoot) {
+            const activeShadowElement = activeElement.shadowRoot.activeElement;
+            let current = activeShadowElement;
+            while (current) {
+              if (current.nodeType === DOCUMENT_FRAGMENT_NODE) {
+                const { host } = current;
+                if (host === activeElement) {
+                  if (isFocusableArea(node)) {
+                    matched.add(node);
+                  } else {
+                    matched.add(host);
+                  }
+                }
+                break;
+              } else {
+                current = current.parentNode;
+              }
+            }
+          }
+          break;
+        }
+        case 'focus-visible': {
+          if (node === this.#document.activeElement && isFocusableArea(node)) {
+            let bool;
+            if (isFocusVisible(node)) {
+              bool = true;
+            } else if (this.#focus) {
+              const { relatedTarget, target: focusTarget } = this.#focus;
+              if (focusTarget === node) {
+                if (isFocusVisible(relatedTarget)) {
+                  bool = true;
+                } else if (this.#event) {
+                  const {
+                    altKey: eventAltKey,
+                    ctrlKey: eventCtrlKey,
+                    key: eventKey,
+                    metaKey: eventMetaKey,
+                    target: eventTarget,
+                    type: eventType
+                  } = this.#event;
+                  // this.#event is irrelevant if eventTarget === relatedTarget
+                  if (eventTarget === relatedTarget) {
+                    if (this.#lastFocusVisible === null) {
+                      bool = true;
+                    } else if (focusTarget === this.#lastFocusVisible) {
+                      bool = true;
+                    }
+                  } else if (eventKey === 'Tab') {
+                    if (
+                      (eventType === 'keydown' && eventTarget !== node) ||
+                      (eventType === 'keyup' && eventTarget === node)
+                    ) {
+                      if (eventTarget === focusTarget) {
+                        if (this.#lastFocusVisible === null) {
+                          bool = true;
+                        } else if (
+                          eventTarget === this.#lastFocusVisible &&
+                          relatedTarget === null
+                        ) {
+                          bool = true;
+                        }
+                      } else {
+                        bool = true;
+                      }
+                    }
+                  } else if (eventKey) {
+                    if (
+                      (eventType === 'keydown' || eventType === 'keyup') &&
+                      !eventAltKey &&
+                      !eventCtrlKey &&
+                      !eventMetaKey &&
+                      eventTarget === node
+                    ) {
+                      bool = true;
+                    }
+                  }
+                } else if (
+                  relatedTarget === null ||
+                  relatedTarget === this.#lastFocusVisible
+                ) {
+                  bool = true;
+                }
+              }
+            }
+            if (bool) {
+              this.#lastFocusVisible = node;
+              matched.add(node);
+            } else if (this.#lastFocusVisible === node) {
+              this.#lastFocusVisible = null;
+            }
+          }
+          break;
+        }
+        case 'focus-within': {
+          const activeElement = this.#document.activeElement;
+          if (node.contains(activeElement) && isFocusableArea(activeElement)) {
+            matched.add(node);
+          } else if (activeElement.shadowRoot) {
+            const activeShadowElement = activeElement.shadowRoot.activeElement;
+            if (node.contains(activeShadowElement)) {
+              matched.add(node);
+            } else {
+              let current = activeShadowElement;
+              while (current) {
+                if (current.nodeType === DOCUMENT_FRAGMENT_NODE) {
+                  const { host } = current;
+                  if (host === activeElement && node.contains(host)) {
+                    matched.add(node);
+                  }
+                  break;
+                } else {
+                  current = current.parentNode;
+                }
+              }
+            }
+          }
+          break;
+        }
+        case 'open':
+        case 'closed': {
+          if (localName === 'details' || localName === 'dialog') {
+            if (node.hasAttribute('open')) {
+              if (astName === 'open') {
+                matched.add(node);
+              }
+            } else if (astName === 'closed') {
+              matched.add(node);
+            }
+          }
+          break;
+        }
+        case 'placeholder-shown': {
+          let placeholder;
+          if (node.placeholder) {
+            placeholder = node.placeholder;
+          } else if (node.hasAttribute('placeholder')) {
+            placeholder = node.getAttribute('placeholder');
+          }
+          if (typeof placeholder === 'string' && !/[\r\n]/.test(placeholder)) {
+            let targetNode;
+            if (localName === 'textarea') {
+              targetNode = node;
+            } else if (localName === 'input') {
+              if (node.hasAttribute('type')) {
+                if (KEYS_INPUT_PLACEHOLDER.has(node.getAttribute('type'))) {
+                  targetNode = node;
+                }
+              } else {
+                targetNode = node;
+              }
+            }
+            if (targetNode && node.value === '') {
+              matched.add(node);
+            }
+          }
+          break;
+        }
+        case 'checked': {
+          const attrType = node.getAttribute('type');
+          if (
+            (node.checked &&
+              localName === 'input' &&
+              (attrType === 'checkbox' || attrType === 'radio')) ||
+            (node.selected && localName === 'option')
+          ) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'indeterminate': {
+          if (
+            (node.indeterminate &&
+              localName === 'input' &&
+              node.type === 'checkbox') ||
+            (localName === 'progress' && !node.hasAttribute('value'))
+          ) {
+            matched.add(node);
+          } else if (
+            localName === 'input' &&
+            node.type === 'radio' &&
+            !node.hasAttribute('checked')
+          ) {
+            const nodeName = node.name;
+            let parent = node.parentNode;
+            while (parent) {
+              if (parent.localName === 'form') {
+                break;
+              }
+              parent = parent.parentNode;
+            }
+            if (!parent) {
+              parent = this.#document.documentElement;
+            }
+            const walker = this._createTreeWalker(parent);
+            let refNode = traverseNode(parent, walker);
+            refNode = walker.firstChild();
+            let checked;
+            while (refNode) {
+              if (
+                refNode.localName === 'input' &&
+                refNode.getAttribute('type') === 'radio'
+              ) {
+                if (refNode.hasAttribute('name')) {
+                  if (refNode.getAttribute('name') === nodeName) {
+                    checked = !!refNode.checked;
+                  }
+                } else {
+                  checked = !!refNode.checked;
+                }
+                if (checked) {
+                  break;
+                }
+              }
+              refNode = walker.nextNode();
+            }
+            if (!checked) {
+              matched.add(node);
+            }
+          }
+          break;
+        }
+        case 'default': {
+          // button[type="submit"], input[type="submit"], input[type="image"]
+          const attrType = node.getAttribute('type');
+          if (
+            (localName === 'button' &&
+              !(node.hasAttribute('type') && KEYS_INPUT_RESET.has(attrType))) ||
+            (localName === 'input' &&
+              node.hasAttribute('type') &&
+              KEYS_INPUT_SUBMIT.has(attrType))
+          ) {
+            let form = node.parentNode;
+            while (form) {
+              if (form.localName === 'form') {
+                break;
+              }
+              form = form.parentNode;
+            }
+            if (form) {
+              const walker = this._createTreeWalker(form);
+              let refNode = traverseNode(form, walker);
+              refNode = walker.firstChild();
+              while (refNode) {
+                const nodeName = refNode.localName;
+                const nodeAttrType = refNode.getAttribute('type');
+                let m;
+                if (nodeName === 'button') {
+                  m = !(
+                    refNode.hasAttribute('type') &&
+                    KEYS_INPUT_RESET.has(nodeAttrType)
+                  );
+                } else if (nodeName === 'input') {
+                  m =
+                    refNode.hasAttribute('type') &&
+                    KEYS_INPUT_SUBMIT.has(nodeAttrType);
+                }
+                if (m) {
+                  if (refNode === node) {
+                    matched.add(node);
+                  }
+                  break;
+                }
+                refNode = walker.nextNode();
+              }
+            }
+            // input[type="checkbox"], input[type="radio"]
+          } else if (
+            localName === 'input' &&
+            node.hasAttribute('type') &&
+            node.hasAttribute('checked') &&
+            KEYS_INPUT_CHECK.has(attrType)
+          ) {
+            matched.add(node);
+            // option
+          } else if (localName === 'option' && node.hasAttribute('selected')) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'valid':
+        case 'invalid': {
+          if (KEYS_FORM_PS_VALID.has(localName)) {
+            let valid;
+            if (node.checkValidity()) {
+              if (node.maxLength >= 0) {
+                if (node.maxLength >= node.value.length) {
+                  valid = true;
+                }
+              } else {
+                valid = true;
+              }
+            }
+            if (valid) {
+              if (astName === 'valid') {
+                matched.add(node);
+              }
+            } else if (astName === 'invalid') {
+              matched.add(node);
+            }
+          } else if (localName === 'fieldset') {
+            const walker = this._createTreeWalker(node);
+            let refNode = traverseNode(node, walker);
+            refNode = walker.firstChild();
+            let valid;
+            if (!refNode) {
+              valid = true;
+            } else {
+              while (refNode) {
+                if (KEYS_FORM_PS_VALID.has(refNode.localName)) {
+                  if (refNode.checkValidity()) {
+                    if (refNode.maxLength >= 0) {
+                      valid = refNode.maxLength >= refNode.value.length;
+                    } else {
+                      valid = true;
+                    }
+                  } else {
+                    valid = false;
+                  }
+                  if (!valid) {
+                    break;
+                  }
+                }
+                refNode = walker.nextNode();
+              }
+            }
+            if (valid) {
+              if (astName === 'valid') {
+                matched.add(node);
+              }
+            } else if (astName === 'invalid') {
+              matched.add(node);
+            }
+          }
+          break;
+        }
+        case 'in-range':
+        case 'out-of-range': {
+          const attrType = node.getAttribute('type');
+          if (
+            localName === 'input' &&
+            !(node.readOnly || node.hasAttribute('readonly')) &&
+            !(node.disabled || node.hasAttribute('disabled')) &&
+            KEYS_INPUT_RANGE.has(attrType)
+          ) {
+            const flowed =
+              node.validity.rangeUnderflow || node.validity.rangeOverflow;
+            if (astName === 'out-of-range' && flowed) {
+              matched.add(node);
+            } else if (
+              astName === 'in-range' &&
+              !flowed &&
+              (node.hasAttribute('min') ||
+                node.hasAttribute('max') ||
+                attrType === 'range')
+            ) {
+              matched.add(node);
+            }
+          }
+          break;
+        }
+        case 'required':
+        case 'optional': {
+          let required;
+          let optional;
+          if (localName === 'select' || localName === 'textarea') {
+            if (node.required || node.hasAttribute('required')) {
+              required = true;
+            } else {
+              optional = true;
+            }
+          } else if (localName === 'input') {
+            if (node.hasAttribute('type')) {
+              const attrType = node.getAttribute('type');
+              if (KEYS_INPUT_REQUIRED.has(attrType)) {
+                if (node.required || node.hasAttribute('required')) {
+                  required = true;
+                } else {
+                  optional = true;
+                }
+              } else {
+                optional = true;
+              }
+            } else if (node.required || node.hasAttribute('required')) {
+              required = true;
+            } else {
+              optional = true;
+            }
+          }
+          if (astName === 'required' && required) {
+            matched.add(node);
+          } else if (astName === 'optional' && optional) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'root': {
+          if (node === this.#document.documentElement) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'empty': {
+          if (node.hasChildNodes()) {
+            const walker = this._createTreeWalker(node, {
+              force: true,
+              whatToShow: SHOW_ALL
+            });
+            let refNode = walker.firstChild();
+            let bool;
+            while (refNode) {
+              bool =
+                refNode.nodeType !== ELEMENT_NODE &&
+                refNode.nodeType !== TEXT_NODE;
+              if (!bool) {
+                break;
+              }
+              refNode = walker.nextSibling();
+            }
+            if (bool) {
+              matched.add(node);
+            }
+          } else {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'first-child': {
+          if (
+            (parentNode && node === parentNode.firstElementChild) ||
+            node === this.#root
+          ) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'last-child': {
+          if (
+            (parentNode && node === parentNode.lastElementChild) ||
+            node === this.#root
+          ) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'only-child': {
+          if (
+            (parentNode &&
+              node === parentNode.firstElementChild &&
+              node === parentNode.lastElementChild) ||
+            node === this.#root
+          ) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'defined': {
+          if (node.hasAttribute('is') || localName.includes('-')) {
+            if (isCustomElement(node)) {
+              matched.add(node);
+            }
+            // NOTE: MathMLElement is not implemented in jsdom.
+          } else if (
+            node instanceof this.#window.HTMLElement ||
+            node instanceof this.#window.SVGElement
+          ) {
+            matched.add(node);
+          }
+          break;
+        }
+        case 'popover-open': {
+          // FIXME: not implemented in jsdom
+          // @see https://github.com/jsdom/jsdom/issues/3721
+          /*
+          if (node.popover && isVisible(node)) {
+            matched.add(node);
+          }
+          */
+          break;
+        }
+        // Ignore :host.
+        case 'host': {
+          break;
+        }
+        // Legacy pseudo-elements.
+        case 'after':
+        case 'before':
+        case 'first-letter':
+        case 'first-line': {
+          if (warn) {
+            this.onError(
+              generateException(
+                `Unsupported pseudo-element ::${astName}`,
+                NOT_SUPPORTED_ERR,
+                this.#window
+              )
+            );
+          }
+          break;
+        }
+        // Not supported.
+        case 'autofill':
+        case 'blank':
+        case 'buffering':
+        case 'current':
+        case 'fullscreen':
+        case 'future':
+        case 'has-slotted':
+        case 'heading':
+        case 'modal':
+        case 'muted':
+        case 'past':
+        case 'paused':
+        case 'picture-in-picture':
+        case 'playing':
+        case 'seeking':
+        case 'stalled':
+        case 'user-invalid':
+        case 'user-valid':
+        case 'volume-locked':
+        case '-webkit-autofill': {
+          if (warn) {
+            this.onError(
+              generateException(
+                `Unsupported pseudo-class :${astName}`,
+                NOT_SUPPORTED_ERR,
+                this.#window
+              )
+            );
+          }
+          break;
+        }
+        default: {
+          if (astName.startsWith('-webkit-')) {
+            if (warn) {
+              this.onError(
+                generateException(
+                  `Unsupported pseudo-class :${astName}`,
+                  NOT_SUPPORTED_ERR,
+                  this.#window
+                )
+              );
+            }
+          } else if (!forgive) {
+            this.onError(
+              generateException(
+                `Unknown pseudo-class :${astName}`,
+                SYNTAX_ERR,
+                this.#window
+              )
+            );
+          }
+        }
+      }
+    }
+    return matched;
+  }
+
+  /**
+   * Evaluates the :host() pseudo-class.
+   * @private
+   * @param {Array.<object>} leaves - The AST leaves.
+   * @param {object} host - The host element.
+   * @param {object} ast - The original AST for error reporting.
+   * @returns {boolean} True if matched.
+   */
+  _evaluateHostPseudo = (leaves, host, ast) => {
+    const l = leaves.length;
+    for (let i = 0; i < l; i++) {
+      const leaf = leaves[i];
+      if (leaf.type === COMBINATOR) {
+        const css = generateCSS(ast);
+        const msg = `Invalid selector ${css}`;
+        this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+        return false;
+      }
+      if (!this._matchSelector(leaf, host).has(host)) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  /**
+   * Evaluates the :host-context() pseudo-class.
+   * @private
+   * @param {Array.<object>} leaves - The AST leaves.
+   * @param {object} host - The host element.
+   * @param {object} ast - The original AST for error reporting.
+   * @returns {boolean} True if matched.
+   */
+  _evaluateHostContextPseudo = (leaves, host, ast) => {
+    let parent = host;
+    while (parent) {
+      let bool;
+      const l = leaves.length;
+      for (let i = 0; i < l; i++) {
+        const leaf = leaves[i];
+        if (leaf.type === COMBINATOR) {
+          const css = generateCSS(ast);
+          const msg = `Invalid selector ${css}`;
+          this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+          return false;
+        }
+        bool = this._matchSelector(leaf, parent).has(parent);
+        if (!bool) {
+          break;
+        }
+      }
+      if (bool) {
+        return true;
+      }
+      parent = parent.parentNode;
+    }
+    return false;
+  };
+
+  /**
+   * Matches shadow host pseudo-classes.
+   * @private
+   * @param {object} ast - The AST.
+   * @param {object} node - The DocumentFragment node.
+   * @returns {?object} The matched node.
+   */
+  _matchShadowHostPseudoClass = (ast, node) => {
+    const { children: astChildren, name: astName } = ast;
+    // Handle simple pseudo-class (no arguments).
+    if (!Array.isArray(astChildren)) {
+      if (astName === 'host') {
+        return node;
+      }
+      const msg = `Invalid selector :${astName}`;
+      return this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+    }
+    // Handle functional pseudo-class like :host(...).
+    if (astName !== 'host' && astName !== 'host-context') {
+      const msg = `Invalid selector :${astName}()`;
+      return this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+    }
+    if (astChildren.length !== 1) {
+      const css = generateCSS(ast);
+      const msg = `Invalid selector ${css}`;
+      return this.onError(generateException(msg, SYNTAX_ERR, this.#window));
+    }
+    const { host } = node;
+    const { branches } = walkAST(astChildren[0]);
+    const [branch] = branches;
+    const [...leaves] = branch;
+    let isMatch = false;
+    if (astName === 'host') {
+      isMatch = this._evaluateHostPseudo(leaves, host, ast);
+      // astName === 'host-context'.
+    } else {
+      isMatch = this._evaluateHostContextPseudo(leaves, host, ast);
+    }
+    return isMatch ? node : null;
+  };
+
+  /**
+   * Matches a selector for element nodes.
+   * @private
+   * @param {object} ast - The AST.
+   * @param {object} node - The Element node.
+   * @param {object} opt - Options.
+   * @returns {Set.<object>} A collection of matched nodes.
+   */
+  _matchSelectorForElement = (ast, node, opt) => {
+    const { type: astType } = ast;
+    const astName = unescapeSelector(ast.name);
+    const matched = new Set();
+    switch (astType) {
+      case ATTR_SELECTOR: {
+        if (matchAttributeSelector(ast, node, opt)) {
+          matched.add(node);
+        }
+        break;
+      }
+      case ID_SELECTOR: {
+        if (node.id === astName) {
+          matched.add(node);
+        }
+        break;
+      }
+      case CLASS_SELECTOR: {
+        if (node.classList.contains(astName)) {
+          matched.add(node);
+        }
+        break;
+      }
+      case PS_CLASS_SELECTOR: {
+        return this._matchPseudoClassSelector(ast, node, opt);
+      }
+      case TYPE_SELECTOR: {
+        if (matchTypeSelector(ast, node, opt)) {
+          matched.add(node);
+        }
+        break;
+      }
+      // PS_ELEMENT_SELECTOR is handled by default.
+      default: {
+        try {
+          if (this.#check) {
+            const css = generateCSS(ast);
+            this.#pseudoElement.push(css);
+            matched.add(node);
+          } else {
+            matchPseudoElementSelector(astName, astType, opt);
+          }
+        } catch (e) {
+          this.onError(e);
+        }
+      }
+    }
+    return matched;
+  };
+
+  /**
+   * Matches a selector for a shadow root.
+   * @private
+   * @param {object} ast - The AST.
+   * @param {object} node - The DocumentFragment node.
+   * @param {object} [opt] - Options.
+   * @returns {Set.<object>} A collection of matched nodes.
+   */
+  _matchSelectorForShadowRoot = (ast, node, opt = {}) => {
+    const { name: astName } = ast;
+    if (KEYS_LOGICAL.has(astName)) {
+      opt.isShadowRoot = true;
+      return this._matchPseudoClassSelector(ast, node, opt);
+    }
+    const matched = new Set();
+    if (astName === 'host' || astName === 'host-context') {
+      const res = this._matchShadowHostPseudoClass(ast, node, opt);
+      if (res) {
+        this.#verifyShadowHost = true;
+        matched.add(res);
+      }
+    }
+    return matched;
+  };
+
+  /**
+   * Matches a selector.
+   * @private
+   * @param {object} ast - The AST.
+   * @param {object} node - The Document, DocumentFragment, or Element node.
+   * @param {object} opt - Options.
+   * @returns {Set.<object>} A collection of matched nodes.
+   */
+  _matchSelector = (ast, node, opt) => {
+    if (node.nodeType === ELEMENT_NODE) {
+      return this._matchSelectorForElement(ast, node, opt);
+    }
+    if (
+      this.#shadow &&
+      node.nodeType === DOCUMENT_FRAGMENT_NODE &&
+      ast.type === PS_CLASS_SELECTOR
+    ) {
+      return this._matchSelectorForShadowRoot(ast, node, opt);
+    }
+    return new Set();
+  };
+
+  /**
+   * Matches leaves.
+   * @private
+   * @param {Array.<object>} leaves - The AST leaves.
+   * @param {object} node - The node.
+   * @param {object} opt - Options.
+   * @returns {boolean} The result.
+   */
+  _matchLeaves = (leaves, node, opt) => {
+    const results = this.#invalidate ? this.#invalidateResults : this.#results;
+    let result = results.get(leaves);
+    if (result && result.has(node)) {
+      const { matched } = result.get(node);
+      return matched;
+    }
+    let cacheable = true;
+    if (node.nodeType === ELEMENT_NODE && KEYS_FORM.has(node.localName)) {
+      cacheable = false;
+    }
+    let bool;
+    const l = leaves.length;
+    for (let i = 0; i < l; i++) {
+      const leaf = leaves[i];
+      switch (leaf.type) {
+        case ATTR_SELECTOR:
+        case ID_SELECTOR: {
+          cacheable = false;
+          break;
+        }
+        case PS_CLASS_SELECTOR: {
+          if (KEYS_PS_UNCACHE.has(leaf.name)) {
+            cacheable = false;
+          }
+          break;
+        }
+        default: {
+          // No action needed for other types.
+        }
+      }
+      bool = this._matchSelector(leaf, node, opt).has(node);
+      if (!bool) {
+        break;
+      }
+    }
+    if (cacheable) {
+      if (!result) {
+        result = new WeakMap();
+      }
+      result.set(node, {
+        matched: bool
+      });
+      results.set(leaves, result);
+    }
+    return bool;
+  };
+
+  /**
+   * Returns a cached slice of the leaves array (excluding the first item).
+   * @private
+   * @param {Array.<object>} leaves - The original AST leaves array.
+   * @returns {Array.<object>} The filtered leaves.
+   */
+  _getFilterLeaves = leaves => {
+    if (this.#filterLeavesCache.has(leaves)) {
+      return this.#filterLeavesCache.get(leaves);
+    }
+    const filterLeaves = leaves.slice(1);
+    this.#filterLeavesCache.set(leaves, filterLeaves);
+    return filterLeaves;
+  };
+
+  /**
+   * Traverses all descendant nodes and collects matches.
+   * @private
+   * @param {object} baseNode - The base Element node or Element.shadowRoot.
+   * @param {Array.<object>} leaves - The AST leaves.
+   * @param {object} opt - Options.
+   * @returns {Set.<object>} A collection of matched nodes.
+   */
+  _traverseAllDescendants = (baseNode, leaves, opt) => {
+    const walker = this._createTreeWalker(baseNode);
+    traverseNode(baseNode, walker);
+    let currentNode = walker.firstChild();
+    const nodes = new Set();
+    while (currentNode) {
+      if (this._matchLeaves(leaves, currentNode, opt)) {
+        nodes.add(currentNode);
+      }
+      currentNode = walker.nextNode();
+    }
+    return nodes;
+  };
+
+  /**
+   * Finds descendant nodes.
+   * @private
+   * @param {Array.<object>} leaves - The AST leaves.
+   * @param {object} baseNode - The base Element node or Element.shadowRoot.
+   * @param {object} opt - Options.
+   * @returns {Set.<object>} A collection of matched nodes.
+   */
+  _findDescendantNodes = (leaves, baseNode, opt) => {
+    const [leaf] = leaves;
+    const filterLeaves = this._getFilterLeaves(leaves);
+    const { type: leafType } = leaf;
+    switch (leafType) {
+      case ID_SELECTOR: {
+        const canUseGetElementById =
+          !this.#shadow &&
+          baseNode.nodeType === ELEMENT_NODE &&
+          this.#root.nodeType !== ELEMENT_NODE;
+        if (canUseGetElementById) {
+          const leafName = unescapeSelector(leaf.name);
+          const nodes = new Set();
+          const foundNode = this.#root.getElementById(leafName);
+          if (
+            foundNode &&
+            foundNode !== baseNode &&
+            baseNode.contains(foundNode)
+          ) {
+            const isCompoundSelector = filterLeaves.length > 0;
+            if (
+              !isCompoundSelector ||
+              this._matchLeaves(filterLeaves, foundNode, opt)
+            ) {
+              nodes.add(foundNode);
+            }
+          }
+          return nodes;
+        }
+        // Fallback to default traversal if fast path is not applicable.
+        return this._traverseAllDescendants(baseNode, leaves, opt);
+      }
+      case PS_ELEMENT_SELECTOR: {
+        const leafName = unescapeSelector(leaf.name);
+        matchPseudoElementSelector(leafName, leafType, opt);
+        return new Set();
+      }
+      default: {
+        return this._traverseAllDescendants(baseNode, leaves, opt);
+      }
+    }
+  };
+
+  /**
+   * Collects combinator matches into an array without creating intermediate sets.
+   * @private
+   * @param {object} twig - The twig object.
+   * @param {object} node - The Element node.
+   * @param {object} [opt] - Options.
+   * @param {string} [opt.dir] - The find direction.
+   * @param {Array.<object>} matched - The collector array.
+   * @returns {Array.<object>} The collector array.
+   */
+  _collectCombinatorMatches = (twig, node, opt = {}, matched = []) => {
+    const {
+      combo: { name: comboName },
+      leaves
+    } = twig;
+    const { dir } = opt;
+    switch (comboName) {
+      case '+': {
+        const refNode =
+          dir === DIR_NEXT
+            ? node.nextElementSibling
+            : node.previousElementSibling;
+        if (refNode && this._matchLeaves(leaves, refNode, opt)) {
+          matched.push(refNode);
+        }
+        break;
+      }
+      case '~': {
+        let refNode =
+          dir === DIR_NEXT
+            ? node.nextElementSibling
+            : node.previousElementSibling;
+        while (refNode) {
+          if (this._matchLeaves(leaves, refNode, opt)) {
+            matched.push(refNode);
+          }
+          refNode =
+            dir === DIR_NEXT
+              ? refNode.nextElementSibling
+              : refNode.previousElementSibling;
+        }
+        break;
+      }
+      case '>': {
+        if (dir === DIR_NEXT) {
+          let refNode = node.firstElementChild;
+          while (refNode) {
+            if (this._matchLeaves(leaves, refNode, opt)) {
+              matched.push(refNode);
+            }
+            refNode = refNode.nextElementSibling;
+          }
+        } else {
+          const { parentNode } = node;
+          if (parentNode && this._matchLeaves(leaves, parentNode, opt)) {
+            matched.push(parentNode);
+          }
+        }
+        break;
+      }
+      case ' ':
+      default: {
+        if (dir === DIR_NEXT) {
+          for (const refNode of this._findDescendantNodes(leaves, node, opt)) {
+            matched.push(refNode);
+          }
+        } else {
+          const ancestors = [];
+          let refNode = node.parentNode;
+          while (refNode) {
+            if (this._matchLeaves(leaves, refNode, opt)) {
+              ancestors.push(refNode);
+            }
+            refNode = refNode.parentNode;
+          }
+          if (ancestors.length) {
+            matched.push(...ancestors.reverse());
+          }
+        }
+      }
+    }
+    return matched;
+  };
+
+  /**
+   * Matches a combinator.
+   * @private
+   * @param {object} twig - The twig object.
+   * @param {object} node - The Element node.
+   * @param {object} opt - Options.
+   * @returns {Set.<object>} A collection of matched nodes.
+   */
+  _matchCombinator = (twig, node, opt) =>
+    new Set(this._collectCombinatorMatches(twig, node, opt));
+
+  /**
+   * Traverses with a TreeWalker and collects nodes matching the leaves.
+   * @private
+   * @param {TreeWalker} walker - The TreeWalker instance to use.
+   * @param {Array} leaves - The AST leaves to match against.
+   * @param {object} [opt] - Traversal options.
+   * @param {Node} [opt.boundaryNode] - The node to stop traversal at.
+   * @param {boolean} [opt.force] - Force traversal to the next node.
+   * @param {Node} [opt.startNode] - The node to start traversal from.
+   * @param {string} [opt.targetType] - The type of target ('all' or 'first').
+   * @returns {Array.<Node>} An array of matched nodes.
+   */
+  _traverseAndCollectNodes = (walker, leaves, opt = {}) => {
+    const { boundaryNode, force, startNode, targetType } = opt;
+    const collectedNodes = [];
+    let currentNode = traverseNode(startNode, walker, !!force);
+    if (!currentNode) {
+      return [];
+    }
+    // Adjust starting node.
+    if (currentNode.nodeType !== ELEMENT_NODE) {
+      currentNode = walker.nextNode();
+    } else if (currentNode === startNode && currentNode !== this.#root) {
+      currentNode = walker.nextNode();
+    }
+    const matchOpt = {
+      warn: this.#warn
+    };
+    while (currentNode) {
+      // Stop when we reach the boundary.
+      if (boundaryNode) {
+        if (currentNode === boundaryNode) {
+          break;
+        } else if (
+          targetType === TARGET_ALL &&
+          !boundaryNode.contains(currentNode)
+        ) {
+          break;
+        }
+      }
+      if (
+        this._matchLeaves(leaves, currentNode, matchOpt) &&
+        currentNode !== this.#node
+      ) {
+        collectedNodes.push(currentNode);
+        // Stop after the first match if not collecting all.
+        if (targetType !== TARGET_ALL) {
+          break;
+        }
+      }
+      currentNode = walker.nextNode();
+    }
+    return collectedNodes;
+  };
+
+  /**
+   * Finds matched node(s) preceding this.#node.
+   * @private
+   * @param {Array.<object>} leaves - The AST leaves.
+   * @param {object} node - The node to start from.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.force] - If true, traverses only to the next node.
+   * @param {string} [opt.targetType] - The target type.
+   * @returns {Array.<object>} A collection of matched nodes.
+   */
+  _findPrecede = (leaves, node, opt = {}) => {
+    const { force, targetType } = opt;
+    if (!this.#rootWalker) {
+      this.#rootWalker = this._createTreeWalker(this.#root);
+    }
+    return this._traverseAndCollectNodes(this.#rootWalker, leaves, {
+      force,
+      targetType,
+      boundaryNode: this.#node,
+      startNode: node
+    });
+  };
+
+  /**
+   * Finds matched node(s) in #nodeWalker.
+   * @private
+   * @param {Array.<object>} leaves - The AST leaves.
+   * @param {object} node - The node to start from.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.precede] - If true, finds preceding nodes.
+   * @returns {Array.<object>} A collection of matched nodes.
+   */
+  _findNodeWalker = (leaves, node, opt = {}) => {
+    const { precede, ...traversalOpts } = opt;
+    if (precede) {
+      const precedeNodes = this._findPrecede(leaves, this.#root, opt);
+      if (precedeNodes.length) {
+        return precedeNodes;
+      }
+    }
+    if (!this.#nodeWalker) {
+      this.#nodeWalker = this._createTreeWalker(this.#node);
+    }
+    return this._traverseAndCollectNodes(this.#nodeWalker, leaves, {
+      startNode: node,
+      ...traversalOpts
+    });
+  };
+
+  /**
+   * Matches the node itself.
+   * @private
+   * @param {Array} leaves - The AST leaves.
+   * @returns {Array} An array containing [nodes, filtered, pseudoElement].
+   */
+  _matchSelf = leaves => {
+    const matched = this._matchLeaves(leaves, this.#node, {
+      check: this.#check,
+      warn: this.#warn
+    });
+    const nodes = matched ? [this.#node] : [];
+    return [nodes, matched, this.#pseudoElement];
+  };
+
+  /**
+   * Finds lineal nodes (self and ancestors).
+   * @private
+   * @param {Array} leaves - The AST leaves.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.complex] - If true, the selector is complex.
+   * @returns {Array} An array containing [nodes, filtered].
+   */
+  _findLineal = (leaves, opt = {}) => {
+    const { complex } = opt;
+    const nodes = [];
+    const matchOpts = { warn: this.#warn };
+    const selfMatched = this._matchLeaves(leaves, this.#node, matchOpts);
+    if (selfMatched) {
+      nodes.push(this.#node);
+    }
+    if (!selfMatched || complex) {
+      let currentNode = this.#node.parentNode;
+      while (currentNode) {
+        if (this._matchLeaves(leaves, currentNode, matchOpts)) {
+          nodes.push(currentNode);
+        }
+        currentNode = currentNode.parentNode;
+      }
+    }
+    const filtered = nodes.length > 0;
+    return [nodes, filtered];
+  };
+
+  /**
+   * Finds entry nodes for pseudo-element selectors.
+   * @private
+   * @param {object} leaf - The pseudo-element leaf from the AST.
+   * @param {Array.<object>} filterLeaves - Leaves for compound selectors.
+   * @param {string} targetType - The type of target to find.
+   * @returns {object} The result { nodes, filtered, pending }.
+   */
+  _findEntryNodesForPseudoElement = (leaf, filterLeaves, targetType) => {
+    let nodes = [];
+    let filtered = false;
+    if (targetType === TARGET_SELF && this.#check) {
+      const css = generateCSS(leaf);
+      this.#pseudoElement.push(css);
+      if (filterLeaves.length) {
+        [nodes, filtered] = this._matchSelf(filterLeaves);
+      } else {
+        nodes.push(this.#node);
+        filtered = true;
+      }
+    } else {
+      matchPseudoElementSelector(leaf.name, leaf.type, { warn: this.#warn });
+    }
+    return { nodes, filtered, pending: false };
+  };
+
+  /**
+   * Finds entry nodes for ID selectors.
+   * @private
+   * @param {object} twig - The current twig from the AST branch.
+   * @param {string} targetType - The type of target to find.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.complex] - If true, the selector is complex.
+   * @param {boolean} [opt.precede] - If true, finds preceding nodes.
+   * @returns {object} The result { nodes, filtered, pending }.
+   */
+  _findEntryNodesForId = (twig, targetType, opt = {}) => {
+    const { leaves } = twig;
+    const [leaf] = leaves;
+    const filterLeaves = this._getFilterLeaves(leaves);
+    const { complex, precede } = opt;
+    let nodes = [];
+    let filtered = false;
+    if (targetType === TARGET_SELF) {
+      [nodes, filtered] = this._matchSelf(leaves);
+    } else if (targetType === TARGET_LINEAL) {
+      [nodes, filtered] = this._findLineal(leaves, { complex });
+    } else if (
+      targetType === TARGET_FIRST &&
+      this.#root.nodeType !== ELEMENT_NODE
+    ) {
+      const node = this.#root.getElementById(leaf.name);
+      if (node) {
+        if (filterLeaves.length) {
+          if (this._matchLeaves(filterLeaves, node, { warn: this.#warn })) {
+            nodes.push(node);
+            filtered = true;
+          }
+        } else {
+          nodes.push(node);
+          filtered = true;
+        }
+      }
+    } else {
+      nodes = this._findNodeWalker(leaves, this.#node, { precede, targetType });
+      filtered = nodes.length > 0;
+    }
+    return { nodes, filtered, pending: false };
+  };
+
+  /**
+   * Finds entry nodes for class selectors.
+   * @private
+   * @param {Array.<object>} leaves - The AST leaves for the selector.
+   * @param {string} targetType - The type of target to find.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.complex] - If true, the selector is complex.
+   * @param {boolean} [opt.precede] - If true, finds preceding nodes.
+   * @returns {object} The result { nodes, filtered, pending }.
+   */
+  _findEntryNodesForClass = (leaves, targetType, opt = {}) => {
+    const { complex, precede } = opt;
+    let nodes = [];
+    let filtered = false;
+    if (targetType === TARGET_SELF) {
+      [nodes, filtered] = this._matchSelf(leaves);
+    } else if (targetType === TARGET_LINEAL) {
+      [nodes, filtered] = this._findLineal(leaves, { complex });
+    } else {
+      nodes = this._findNodeWalker(leaves, this.#node, { precede, targetType });
+      filtered = nodes.length > 0;
+    }
+    return { nodes, filtered, pending: false };
+  };
+
+  /**
+   * Finds entry nodes for type selectors.
+   * @private
+   * @param {Array.<object>} leaves - The AST leaves for the selector.
+   * @param {string} targetType - The type of target to find.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.complex] - If true, the selector is complex.
+   * @param {boolean} [opt.precede] - If true, finds preceding nodes.
+   * @returns {object} The result { nodes, filtered, pending }.
+   */
+  _findEntryNodesForType = (leaves, targetType, opt = {}) => {
+    const { complex, precede } = opt;
+    let nodes = [];
+    let filtered = false;
+    if (targetType === TARGET_SELF) {
+      [nodes, filtered] = this._matchSelf(leaves);
+    } else if (targetType === TARGET_LINEAL) {
+      [nodes, filtered] = this._findLineal(leaves, { complex });
+    } else {
+      nodes = this._findNodeWalker(leaves, this.#node, { precede, targetType });
+      filtered = nodes.length > 0;
+    }
+    return { nodes, filtered, pending: false };
+  };
+
+  /**
+   * Finds entry nodes for other selector types (default case).
+   * @private
+   * @param {object} twig - The current twig from the AST branch.
+   * @param {string} targetType - The type of target to find.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.complex] - If true, the selector is complex.
+   * @param {boolean} [opt.precede] - If true, finds preceding nodes.
+   * @returns {object} The result { nodes, filtered, pending }.
+   */
+  _findEntryNodesForOther = (twig, targetType, opt = {}) => {
+    const { leaves } = twig;
+    const [leaf] = leaves;
+    const filterLeaves = this._getFilterLeaves(leaves);
+    const { complex, precede } = opt;
+    let nodes = [];
+    let filtered = false;
+    let pending = false;
+    if (targetType !== TARGET_LINEAL && /host(?:-context)?/.test(leaf.name)) {
+      let shadowRoot = null;
+      if (this.#shadow && this.#node.nodeType === DOCUMENT_FRAGMENT_NODE) {
+        shadowRoot = this._matchShadowHostPseudoClass(leaf, this.#node);
+      } else if (filterLeaves.length && this.#node.nodeType === ELEMENT_NODE) {
+        shadowRoot = this._matchShadowHostPseudoClass(
+          leaf,
+          this.#node.shadowRoot
+        );
+      }
+      if (shadowRoot) {
+        let bool = true;
+        const l = filterLeaves.length;
+        for (let i = 0; i < l; i++) {
+          const filterLeaf = filterLeaves[i];
+          switch (filterLeaf.name) {
+            case 'host':
+            case 'host-context': {
+              const matchedNode = this._matchShadowHostPseudoClass(
+                filterLeaf,
+                shadowRoot
+              );
+              bool = matchedNode === shadowRoot;
+              break;
+            }
+            case 'has': {
+              bool = this._matchPseudoClassSelector(
+                filterLeaf,
+                shadowRoot,
+                {}
+              ).has(shadowRoot);
+              break;
+            }
+            default: {
+              bool = false;
+            }
+          }
+          if (!bool) {
+            break;
+          }
+        }
+        if (bool) {
+          nodes.push(shadowRoot);
+          filtered = true;
+        }
+      }
+    } else if (targetType === TARGET_SELF) {
+      [nodes, filtered] = this._matchSelf(leaves);
+    } else if (targetType === TARGET_LINEAL) {
+      [nodes, filtered] = this._findLineal(leaves, { complex });
+    } else if (targetType === TARGET_FIRST) {
+      nodes = this._findNodeWalker(leaves, this.#node, { precede, targetType });
+      filtered = nodes.length > 0;
+    } else {
+      pending = true;
+    }
+    return { nodes, filtered, pending };
+  };
+
+  /**
+   * Finds entry nodes.
+   * @private
+   * @param {object} twig - The twig object.
+   * @param {string} targetType - The target type.
+   * @param {object} [opt] - Options.
+   * @param {boolean} [opt.complex] - If true, the selector is complex.
+   * @param {string} [opt.dir] - The find direction.
+   * @returns {object} An object with nodes and their state.
+   */
+  _findEntryNodes = (twig, targetType, opt = {}) => {
+    const { leaves } = twig;
+    const [leaf] = leaves;
+    const filterLeaves = this._getFilterLeaves(leaves);
+    const { complex = false, dir = DIR_PREV } = opt;
+    const precede =
+      dir === DIR_NEXT &&
+      this.#node.nodeType === ELEMENT_NODE &&
+      this.#node !== this.#root;
+    let result;
+    switch (leaf.type) {
+      case PS_ELEMENT_SELECTOR: {
+        result = this._findEntryNodesForPseudoElement(
+          leaf,
+          filterLeaves,
+          targetType
+        );
+        break;
+      }
+      case ID_SELECTOR: {
+        result = this._findEntryNodesForId(twig, targetType, {
+          complex,
+          precede
+        });
+        break;
+      }
+      case CLASS_SELECTOR: {
+        result = this._findEntryNodesForClass(leaves, targetType, {
+          complex,
+          precede
+        });
+        break;
+      }
+      case TYPE_SELECTOR: {
+        result = this._findEntryNodesForType(leaves, targetType, {
+          complex,
+          precede
+        });
+        break;
+      }
+      default: {
+        result = this._findEntryNodesForOther(twig, targetType, {
+          complex,
+          precede
+        });
+      }
+    }
+    return {
+      compound: filterLeaves.length > 0,
+      filtered: result.filtered,
+      nodes: result.nodes,
+      pending: result.pending
+    };
+  };
+
+  /**
+   * Determines the direction and starting twig for a selector branch.
+   * @private
+   * @param {Array.<object>} branch - The AST branch.
+   * @param {string} targetType - The type of target to find.
+   * @returns {object} An object with the direction and starting twig.
+   */
+  _determineTraversalStrategy = (branch, targetType) => {
+    const branchLen = branch.length;
+    const firstTwig = branch[0];
+    const lastTwig = branch[branchLen - 1];
+    if (branchLen === 1) {
+      return { dir: DIR_PREV, twig: firstTwig };
+    }
+    // Complex selector (branchLen > 1).
+    const {
+      leaves: [{ name: firstName, type: firstType }]
+    } = firstTwig;
+    const {
+      leaves: [{ name: lastName, type: lastType }]
+    } = lastTwig;
+    const { combo: firstCombo } = firstTwig;
+    if (
+      this.#selector.includes(':scope') ||
+      lastType === PS_ELEMENT_SELECTOR ||
+      lastType === ID_SELECTOR
+    ) {
+      return { dir: DIR_PREV, twig: lastTwig };
+    }
+    if (firstType === ID_SELECTOR) {
+      return { dir: DIR_NEXT, twig: firstTwig };
+    }
+    if (firstName === '*' && firstType === TYPE_SELECTOR) {
+      return { dir: DIR_PREV, twig: lastTwig };
+    }
+    if (lastName === '*' && lastType === TYPE_SELECTOR) {
+      return { dir: DIR_NEXT, twig: firstTwig };
+    }
+    if (branchLen === 2) {
+      if (targetType === TARGET_FIRST) {
+        return { dir: DIR_PREV, twig: lastTwig };
+      }
+      const { name: comboName } = firstCombo;
+      if (comboName === '+' || comboName === '~') {
+        return { dir: DIR_PREV, twig: lastTwig };
+      }
+    } else if (branchLen > 2 && this.#scoped && targetType === TARGET_FIRST) {
+      if (lastType === TYPE_SELECTOR) {
+        return { dir: DIR_PREV, twig: lastTwig };
+      }
+      let isChildOrDescendant = false;
+      for (const { combo } of branch) {
+        if (combo) {
+          const { name: comboName } = combo;
+          isChildOrDescendant = comboName === '>' || comboName === ' ';
+          if (!isChildOrDescendant) {
+            break;
+          }
+        }
+      }
+      if (isChildOrDescendant) {
+        return { dir: DIR_PREV, twig: lastTwig };
+      }
+    }
+    // Default strategy for complex selectors.
+    return { dir: DIR_NEXT, twig: firstTwig };
+  };
+
+  /**
+   * Processes pending items not resolved with a direct strategy.
+   * @private
+   * @param {Set.<Map>} pendingItems - The set of pending items.
+   */
+  _processPendingItems = pendingItems => {
+    if (!pendingItems.size) {
+      return;
+    }
+    if (!this.#rootWalker) {
+      this.#rootWalker = this._createTreeWalker(this.#root);
+    }
+    const walker = this.#rootWalker;
+    let node = this.#root;
+    if (this.#scoped) {
+      node = this.#node;
+    }
+    let nextNode = traverseNode(node, walker);
+    while (nextNode) {
+      const isWithinScope =
+        this.#node.nodeType !== ELEMENT_NODE ||
+        nextNode === this.#node ||
+        this.#node.contains(nextNode);
+      if (isWithinScope) {
+        for (const pendingItem of pendingItems) {
+          const { leaves } = pendingItem.get('twig');
+          if (this._matchLeaves(leaves, nextNode, { warn: this.#warn })) {
+            const index = pendingItem.get('index');
+            this.#ast[index].filtered = true;
+            this.#ast[index].find = true;
+            this.#nodes[index].push(nextNode);
+          }
+        }
+      } else if (this.#scoped) {
+        break;
+      }
+      nextNode = walker.nextNode();
+    }
+  };
+
+  /**
+   * Collects nodes.
+   * @private
+   * @param {string} targetType - The target type.
+   * @returns {Array.<Array.<object>>} An array containing the AST and nodes.
+   */
+  _collectNodes = targetType => {
+    [this.#ast, this.#nodes] = this._correspond(this.#selector);
+    const ast = this.#ast.values();
+    if (targetType === TARGET_ALL || targetType === TARGET_FIRST) {
+      const pendingItems = new Set();
+      let i = 0;
+      for (const { branch } of ast) {
+        const complex = branch.length > 1;
+        const { dir, twig } = this._determineTraversalStrategy(
+          branch,
+          targetType
+        );
+        const { compound, filtered, nodes, pending } = this._findEntryNodes(
+          twig,
+          targetType,
+          { complex, dir }
+        );
+        if (nodes.length) {
+          this.#ast[i].find = true;
+          this.#nodes[i] = nodes;
+        } else if (pending) {
+          pendingItems.add(
+            new Map([
+              ['index', i],
+              ['twig', twig]
+            ])
+          );
+        }
+        this.#ast[i].dir = dir;
+        this.#ast[i].filtered = filtered || !compound;
+        i++;
+      }
+      this._processPendingItems(pendingItems);
+    } else {
+      let i = 0;
+      for (const { branch } of ast) {
+        const twig = branch[branch.length - 1];
+        const complex = branch.length > 1;
+        const dir = DIR_PREV;
+        const { compound, filtered, nodes } = this._findEntryNodes(
+          twig,
+          targetType,
+          { complex, dir }
+        );
+        if (nodes.length) {
+          this.#ast[i].find = true;
+          this.#nodes[i] = nodes;
+        }
+        this.#ast[i].dir = dir;
+        this.#ast[i].filtered = filtered || !compound;
+        i++;
+      }
+    }
+    return [this.#ast, this.#nodes];
+  };
+
+  /**
+   * Gets combined nodes.
+   * @private
+   * @param {object} twig - The twig object.
+   * @param {object} nodes - A collection of nodes.
+   * @param {string} dir - The direction.
+   * @returns {Array.<object>} A collection of matched nodes.
+   */
+  _getCombinedNodes = (twig, nodes, dir) => {
+    const arr = [];
+    for (const node of nodes) {
+      this._collectCombinatorMatches(
+        twig,
+        node,
+        { dir, warn: this.#warn },
+        arr
+      );
+    }
+    return arr;
+  };
+
+  /**
+   * Matches a node in the 'next' direction.
+   * @private
+   * @param {Array} branch - The branch.
+   * @param {Set.<object>} nodes - A collection of Element nodes.
+   * @param {object} [opt] - Options.
+   * @param {object} [opt.combo] - The combo object.
+   * @param {number} [opt.index] - The index.
+   * @returns {?object} The matched node.
+   */
+  _matchNodeNext = (branch, nodes, opt = {}) => {
+    const { combo, index } = opt;
+    const { combo: nextCombo, leaves } = branch[index];
+    const twig = {
+      combo,
+      leaves
+    };
+    const nextNodes = this._getCombinedNodes(twig, nodes, DIR_NEXT);
+    if (nextNodes.length) {
+      if (index === branch.length - 1) {
+        if (nextNodes.length === 1) {
+          return nextNodes[0];
+        }
+        const [nextNode] = sortNodes(nextNodes);
+        return nextNode;
+      }
+      return this._matchNodeNext(branch, nextNodes, {
+        combo: nextCombo,
+        index: index + 1
+      });
+    }
+    return null;
+  };
+
+  /**
+   * Matches a node in the 'previous' direction.
+   * @private
+   * @param {Array} branch - The branch.
+   * @param {object} node - The Element node.
+   * @param {object} [opt] - Options.
+   * @param {number} [opt.index] - The index.
+   * @returns {?object} The node.
+   */
+  _matchNodePrev = (branch, node, opt = {}) => {
+    const { index } = opt;
+    const twig = branch[index];
+    const nextNodes = this._getCombinedNodes(twig, [node], DIR_PREV);
+    if (nextNodes.length) {
+      if (index === 0) {
+        return node;
+      }
+      let matched;
+      for (const nextNode of nextNodes) {
+        matched = this._matchNodePrev(branch, nextNode, {
+          index: index - 1
+        });
+        if (matched) {
+          break;
+        }
+      }
+      if (matched) {
+        return node;
+      }
+    }
+    return null;
+  };
+
+  /**
+   * Processes a complex selector branch to find all matching nodes.
+   * @private
+   * @param {Array} branch - The selector branch from the AST.
+   * @param {Array} entryNodes - The initial set of nodes to start from.
+   * @param {string} dir - The direction of traversal ('next' or 'prev').
+   * @returns {Set.<object>} A set of all matched nodes.
+   */
+  _processComplexBranchAll = (branch, entryNodes, dir) => {
+    const matchedNodes = new Set();
+    const branchLen = branch.length;
+    const lastIndex = branchLen - 1;
+
+    if (dir === DIR_NEXT) {
+      const { combo: firstCombo } = branch[0];
+      for (const node of entryNodes) {
+        let combo = firstCombo;
+        let nextNodes = [node];
+        for (let j = 1; j < branchLen; j++) {
+          const { combo: nextCombo, leaves } = branch[j];
+          const twig = { combo, leaves };
+          const nodesArr = this._getCombinedNodes(twig, nextNodes, dir);
+          if (nodesArr.length) {
+            if (j === lastIndex) {
+              for (const nextNode of nodesArr) {
+                matchedNodes.add(nextNode);
+              }
+            }
+            combo = nextCombo;
+            nextNodes = nodesArr;
+          } else {
+            break;
+          }
+        }
+      }
+      // DIR_PREV
+    } else {
+      for (const node of entryNodes) {
+        let nextNodes = [node];
+        for (let j = lastIndex - 1; j >= 0; j--) {
+          const twig = branch[j];
+          const nodesArr = this._getCombinedNodes(twig, nextNodes, dir);
+          if (nodesArr.length) {
+            // The entry node is the final match
+            if (j === 0) {
+              matchedNodes.add(node);
+            }
+            nextNodes = nodesArr;
+          } else {
+            break;
+          }
+        }
+      }
+    }
+    return matchedNodes;
+  };
+
+  /**
+   * Processes a complex selector branch to find the first matching node.
+   * @private
+   * @param {Array} branch - The selector branch from the AST.
+   * @param {Array} entryNodes - The initial set of nodes to start from.
+   * @param {string} dir - The direction of traversal ('next' or 'prev').
+   * @param {string} targetType - The type of search (e.g., 'first').
+   * @returns {?object} The first matched node, or null.
+   */
+  _processComplexBranchFirst = (branch, entryNodes, dir, targetType) => {
+    const branchLen = branch.length;
+    const lastIndex = branchLen - 1;
+    // DIR_NEXT logic for finding the first match.
+    if (dir === DIR_NEXT) {
+      const { combo: entryCombo } = branch[0];
+      for (const node of entryNodes) {
+        const matchedNode = this._matchNodeNext(branch, new Set([node]), {
+          combo: entryCombo,
+          index: 1
+        });
+        if (matchedNode) {
+          if (this.#node.nodeType === ELEMENT_NODE) {
+            if (
+              matchedNode !== this.#node &&
+              this.#node.contains(matchedNode)
+            ) {
+              return matchedNode;
+            }
+          } else {
+            return matchedNode;
+          }
+        }
+      }
+      // Fallback logic if no direct match found.
+      const { leaves: entryLeaves } = branch[0];
+      const [entryNode] = entryNodes;
+      if (this.#node.contains(entryNode)) {
+        let [refNode] = this._findNodeWalker(entryLeaves, entryNode, {
+          targetType
+        });
+        while (refNode) {
+          const matchedNode = this._matchNodeNext(branch, new Set([refNode]), {
+            combo: entryCombo,
+            index: 1
+          });
+          if (matchedNode) {
+            if (this.#node.nodeType === ELEMENT_NODE) {
+              if (
+                matchedNode !== this.#node &&
+                this.#node.contains(matchedNode)
+              ) {
+                return matchedNode;
+              }
+            } else {
+              return matchedNode;
+            }
+          }
+          [refNode] = this._findNodeWalker(entryLeaves, refNode, {
+            targetType,
+            force: true
+          });
+        }
+      }
+      // DIR_PREV logic for finding the first match.
+    } else {
+      for (const node of entryNodes) {
+        const matchedNode = this._matchNodePrev(branch, node, {
+          index: lastIndex - 1
+        });
+        if (matchedNode) {
+          return matchedNode;
+        }
+      }
+      // Fallback for TARGET_FIRST.
+      if (targetType === TARGET_FIRST) {
+        const { leaves: entryLeaves } = branch[lastIndex];
+        const [entryNode] = entryNodes;
+        let [refNode] = this._findNodeWalker(entryLeaves, entryNode, {
+          targetType
+        });
+        while (refNode) {
+          const matchedNode = this._matchNodePrev(branch, refNode, {
+            index: lastIndex - 1
+          });
+          if (matchedNode) {
+            return refNode;
+          }
+          [refNode] = this._findNodeWalker(entryLeaves, refNode, {
+            targetType,
+            force: true
+          });
+        }
+      }
+    }
+    return null;
+  };
+
+  /**
+   * Finds matched nodes.
+   * @param {string} targetType - The target type.
+   * @returns {Set.<object>} A collection of matched nodes.
+   */
+  find = targetType => {
+    let collection;
+    try {
+      collection = this._collectNodes(targetType);
+    } catch (e) {
+      if (this.#check) {
+        let pseudoElement;
+        if (this.#pseudoElement.length) {
+          pseudoElement = this.#pseudoElement.join('');
+        } else {
+          pseudoElement = null;
+        }
+        return {
+          pseudoElement,
+          match: false,
+          ast: this.#selectorAST ?? null
+        };
+      } else {
+        throw e;
+      }
+    }
+    const [[...branches], collectedNodes] = collection;
+    const l = branches.length;
+    let sort =
+      l > 1 && targetType === TARGET_ALL && this.#selector.includes(':scope');
+    let nodes = new Set();
+    for (let i = 0; i < l; i++) {
+      const { branch, dir, find } = branches[i];
+      if (!branch.length || !find) {
+        continue;
+      }
+      const entryNodes = collectedNodes[i];
+      const lastIndex = branch.length - 1;
+      // Handle simple selectors (no combinators).
+      if (lastIndex === 0) {
+        if (
+          (targetType === TARGET_ALL || targetType === TARGET_FIRST) &&
+          this.#node.nodeType === ELEMENT_NODE
+        ) {
+          for (const node of entryNodes) {
+            if (node !== this.#node && this.#node.contains(node)) {
+              nodes.add(node);
+              if (targetType === TARGET_FIRST) {
+                break;
+              }
+            }
+          }
+        } else if (targetType === TARGET_ALL) {
+          if (nodes.size) {
+            for (const node of entryNodes) {
+              nodes.add(node);
+            }
+            sort = true;
+          } else {
+            nodes = new Set(entryNodes);
+          }
+        } else {
+          if (entryNodes.length) {
+            nodes.add(entryNodes[0]);
+          }
+        }
+        // Handle complex selectors.
+      } else {
+        if (targetType === TARGET_ALL) {
+          const newNodes = this._processComplexBranchAll(
+            branch,
+            entryNodes,
+            dir
+          );
+          if (nodes.size) {
+            for (const newNode of newNodes) {
+              nodes.add(newNode);
+            }
+            sort = true;
+          } else {
+            nodes = newNodes;
+          }
+        } else {
+          const matchedNode = this._processComplexBranchFirst(
+            branch,
+            entryNodes,
+            dir,
+            targetType
+          );
+          if (matchedNode) {
+            nodes.add(matchedNode);
+          }
+        }
+      }
+    }
+    if (this.#check) {
+      const match = !!nodes.size;
+      let pseudoElement;
+      if (this.#pseudoElement.length) {
+        pseudoElement = this.#pseudoElement.join('');
+      } else {
+        pseudoElement = null;
+      }
+      return {
+        match,
+        pseudoElement,
+        ast: this.#selectorAST
+      };
+    }
+    if (targetType === TARGET_FIRST || targetType === TARGET_ALL) {
+      nodes.delete(this.#node);
+    }
+    if ((sort || targetType === TARGET_FIRST) && nodes.size > 1) {
+      return new Set(sortNodes(nodes));
+    }
+    return nodes;
+  };
+
+  /**
+   * Gets AST for selector.
+   * @param {string} selector - The selector text.
+   * @returns {object} The AST for the selector.
+   */
+  getAST = selector => {
+    return parseSelector(selector);
+  };
+}
diff --git a/node_modules/@asamuzakjp/dom-selector/src/js/matcher.js b/node_modules/@asamuzakjp/dom-selector/src/js/matcher.js
new file mode 100644
index 0000000000000000000000000000000000000000..9dd1885a47fcfac8726a25ca2772eb2d455a1359
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/src/js/matcher.js
@@ -0,0 +1,612 @@
+/**
+ * matcher.js
+ */
+
+/* import */
+import { generateCSS, parseAstName, unescapeSelector } from './parser.js';
+import {
+  generateException,
+  getDirectionality,
+  getLanguageAttribute,
+  getType,
+  isContentEditable,
+  isCustomElement,
+  isNamespaceDeclared
+} from './utility.js';
+
+/* constants */
+import {
+  ALPHA_NUM,
+  FORM_PARTS,
+  IDENT,
+  INPUT_EDIT,
+  LANG_PART,
+  NOT_SUPPORTED_ERR,
+  PS_ELEMENT_SELECTOR,
+  STRING,
+  SYNTAX_ERR
+} from './constant.js';
+const KEYS_FORM_PS_DISABLED = new Set([
+  ...FORM_PARTS,
+  'fieldset',
+  'optgroup',
+  'option'
+]);
+const KEYS_INPUT_EDIT = new Set(INPUT_EDIT);
+const REG_LANG_VALID = new RegExp(`^(?:\\*-)?${ALPHA_NUM}${LANG_PART}$`, 'i');
+
+/**
+ * Validates a pseudo-element selector.
+ * @param {string} astName - The name of the pseudo-element from the AST.
+ * @param {string} astType - The type of the selector from the AST.
+ * @param {object} [opt] - Optional parameters.
+ * @param {boolean} [opt.forgive] - If true, ignores unknown pseudo-elements.
+ * @param {boolean} [opt.warn] - If true, throws an error for unsupported ones.
+ * @throws {DOMException} If the selector is invalid or unsupported.
+ * @returns {void}
+ */
+export const matchPseudoElementSelector = (astName, astType, opt = {}) => {
+  const { forgive, globalObject, warn } = opt;
+  if (astType !== PS_ELEMENT_SELECTOR) {
+    // Ensure the AST node is a pseudo-element selector.
+    throw new TypeError(`Unexpected ast type ${getType(astType)}`);
+  }
+  switch (astName) {
+    case 'after':
+    case 'backdrop':
+    case 'before':
+    case 'cue':
+    case 'cue-region':
+    case 'first-letter':
+    case 'first-line':
+    case 'file-selector-button':
+    case 'marker':
+    case 'placeholder':
+    case 'selection':
+    case 'target-text': {
+      // Warn if the pseudo-element is known but unsupported.
+      if (warn) {
+        throw generateException(
+          `Unsupported pseudo-element ::${astName}`,
+          NOT_SUPPORTED_ERR,
+          globalObject
+        );
+      }
+      break;
+    }
+    case 'part':
+    case 'slotted': {
+      // Warn if the functional pseudo-element is known but unsupported.
+      if (warn) {
+        throw generateException(
+          `Unsupported pseudo-element ::${astName}()`,
+          NOT_SUPPORTED_ERR,
+          globalObject
+        );
+      }
+      break;
+    }
+    default: {
+      // Handle vendor-prefixed or unknown pseudo-elements.
+      if (astName.startsWith('-webkit-')) {
+        if (warn) {
+          throw generateException(
+            `Unsupported pseudo-element ::${astName}`,
+            NOT_SUPPORTED_ERR,
+            globalObject
+          );
+        }
+        // Throw an error for unknown pseudo-elements if not forgiven.
+      } else if (!forgive) {
+        throw generateException(
+          `Unknown pseudo-element ::${astName}`,
+          SYNTAX_ERR,
+          globalObject
+        );
+      }
+    }
+  }
+};
+
+/**
+ * Matches the :dir() pseudo-class against an element's directionality.
+ * @param {object} ast - The AST object for the pseudo-class.
+ * @param {object} node - The element node to match against.
+ * @throws {TypeError} If the AST does not contain a valid direction value.
+ * @returns {boolean} - True if the directionality matches, otherwise false.
+ */
+export const matchDirectionPseudoClass = (ast, node) => {
+  const { name } = ast;
+  // The :dir() pseudo-class requires a direction argument (e.g., "ltr").
+  if (!name) {
+    const type = name === '' ? '(empty String)' : getType(name);
+    throw new TypeError(`Unexpected ast type ${type}`);
+  }
+  // Get the computed directionality of the element.
+  const dir = getDirectionality(node);
+  // Compare the expected direction with the element's actual direction.
+  return name === dir;
+};
+
+/**
+ * Matches the :lang() pseudo-class against an element's language.
+ * @see https://datatracker.ietf.org/doc/html/rfc4647#section-3.3.1
+ * @param {object} ast - The AST object for the pseudo-class.
+ * @param {object} node - The element node to match against.
+ * @returns {boolean} - True if the language matches, otherwise false.
+ */
+export const matchLanguagePseudoClass = (ast, node) => {
+  // Get the effective language attribute for the current node.
+  const elementLang = getLanguageAttribute(node);
+  // If the element has no language, it cannot match a specific pattern.
+  if (elementLang === null) {
+    return false;
+  }
+  // Use cached regex.
+  if (ast._langRegex !== undefined) {
+    if (ast._langPattern === '*') {
+      return elementLang !== '';
+    }
+    if (ast._langRegex === null) {
+      return false;
+    }
+    return ast._langRegex.test(elementLang);
+  }
+  const { name, type, value } = ast;
+  let langPattern;
+  // Determine the language pattern from the AST.
+  if (type === STRING && value) {
+    langPattern = value;
+  } else if (type === IDENT && name) {
+    langPattern = unescapeSelector(name);
+  }
+  // Cache lang pattern.
+  ast._langPattern = langPattern;
+  // If no valid language pattern is provided, it cannot match.
+  if (typeof langPattern !== 'string') {
+    ast._langRegex = null;
+    return false;
+  }
+  // Handle the universal selector '*' for :lang.
+  if (langPattern === '*') {
+    ast._langRegex = null;
+    return elementLang !== '';
+  }
+  // Validate the provided language pattern structure.
+  if (!REG_LANG_VALID.test(langPattern)) {
+    ast._langRegex = null;
+    return false;
+  }
+  // Build a regex for extended language range matching.
+  let matcherRegex;
+  if (langPattern.indexOf('-') > -1) {
+    const [langMain, langSub, ...langRest] = langPattern.split('-');
+    const extendedMain =
+      langMain === '*' ? `${ALPHA_NUM}${LANG_PART}` : `${langMain}${LANG_PART}`;
+    const extendedSub = `-${langSub}${LANG_PART}`;
+    let extendedRest = '';
+    for (let i = 0; i < langRest.length; i++) {
+      extendedRest += `-${langRest[i]}${LANG_PART}`;
+    }
+    matcherRegex = new RegExp(
+      `^${extendedMain}${extendedSub}${extendedRest}$`,
+      'i'
+    );
+  } else {
+    matcherRegex = new RegExp(`^${langPattern}${LANG_PART}$`, 'i');
+  }
+  ast._langRegex = matcherRegex;
+  // Test the element's language against the constructed regex.
+  return matcherRegex.test(elementLang);
+};
+
+/**
+ * Matches the :disabled and :enabled pseudo-classes.
+ * @param {string} astName - pseudo-class name
+ * @param {object} node - Element node
+ * @returns {boolean} - True if matched
+ */
+export const matchDisabledPseudoClass = (astName, node) => {
+  const { localName, parentNode } = node;
+  if (
+    !KEYS_FORM_PS_DISABLED.has(localName) &&
+    !isCustomElement(node, { formAssociated: true })
+  ) {
+    return false;
+  }
+  let isDisabled = false;
+  if (node.disabled || node.hasAttribute('disabled')) {
+    isDisabled = true;
+  } else if (localName === 'option') {
+    if (
+      parentNode &&
+      parentNode.localName === 'optgroup' &&
+      (parentNode.disabled || parentNode.hasAttribute('disabled'))
+    ) {
+      isDisabled = true;
+    }
+  } else if (localName !== 'optgroup') {
+    let current = parentNode;
+    while (current) {
+      if (
+        current.localName === 'fieldset' &&
+        (current.disabled || current.hasAttribute('disabled'))
+      ) {
+        // The first <legend> in a disabled <fieldset> is not disabled.
+        let legend;
+        let element = current.firstElementChild;
+        while (element) {
+          if (element.localName === 'legend') {
+            legend = element;
+            break;
+          }
+          element = element.nextElementSibling;
+        }
+        if (!legend || !legend.contains(node)) {
+          isDisabled = true;
+        }
+        // Found the containing fieldset, stop searching up.
+        break;
+      }
+      current = current.parentNode;
+    }
+  }
+  if (astName === 'disabled') {
+    return isDisabled;
+  }
+  return !isDisabled;
+};
+
+/**
+ * Match the :read-only and :read-write pseudo-classes
+ * @param {string} astName - pseudo-class name
+ * @param {object} node - Element node
+ * @returns {boolean} - True if matched
+ */
+export const matchReadOnlyPseudoClass = (astName, node) => {
+  const { localName } = node;
+  let isReadOnly = false;
+  switch (localName) {
+    case 'textarea':
+    case 'input': {
+      const isEditableInput = !node.type || KEYS_INPUT_EDIT.has(node.type);
+      if (localName === 'textarea' || isEditableInput) {
+        isReadOnly =
+          node.readOnly ||
+          node.hasAttribute('readonly') ||
+          node.disabled ||
+          node.hasAttribute('disabled');
+      } else {
+        // Non-editable input types are always read-only
+        isReadOnly = true;
+      }
+      break;
+    }
+    default: {
+      isReadOnly = !isContentEditable(node);
+    }
+  }
+  if (astName === 'read-only') {
+    return isReadOnly;
+  }
+  return !isReadOnly;
+};
+
+/**
+ * Matches an attribute selector against an element.
+ * This function handles various attribute matchers like '=', '~=', '^=', etc.,
+ * and considers namespaces and case sensitivity based on document type.
+ * @param {object} ast - The AST for the attribute selector.
+ * @param {object} node - The element node to match against.
+ * @param {object} [opt] - Optional parameters.
+ * @param {boolean} [opt.check] - True if running in an internal check.
+ * @param {boolean} [opt.forgive] - True to forgive certain syntax errors.
+ * @returns {boolean} - True if the attribute selector matches, otherwise false.
+ */
+export const matchAttributeSelector = (ast, node, opt = {}) => {
+  const {
+    flags: astFlags,
+    matcher: astMatcher,
+    name: astName,
+    value: astValue
+  } = ast;
+  const { check, forgive, globalObject } = opt;
+  // Validate selector flags ('i' or 's').
+  if (typeof astFlags === 'string' && !/^[is]$/i.test(astFlags) && !forgive) {
+    const css = generateCSS(ast);
+    throw generateException(
+      `Invalid selector ${css}`,
+      SYNTAX_ERR,
+      globalObject
+    );
+  }
+  const { attributes } = node;
+  // An element with no attributes cannot match.
+  if (!attributes || !attributes.length) {
+    return false;
+  }
+  // Determine case sensitivity based on document type and flags.
+  let caseInsensitive;
+  if (node.ownerDocument.contentType === 'text/html') {
+    if (typeof astFlags === 'string' && /^s$/i.test(astFlags)) {
+      caseInsensitive = false;
+    } else {
+      caseInsensitive = true;
+    }
+  } else if (typeof astFlags === 'string' && /^i$/i.test(astFlags)) {
+    caseInsensitive = true;
+  } else {
+    caseInsensitive = false;
+  }
+  // Prepare the attribute name from the selector for matching.
+  let astAttrName = unescapeSelector(astName.name);
+  if (caseInsensitive) {
+    astAttrName = astAttrName.toLowerCase();
+  }
+  // A set to store the values of attributes whose names match.
+  const attrValues = new Set();
+  // Handle namespaced attribute names (e.g., [*|attr], [ns|attr]).
+  if (astAttrName.indexOf('|') > -1) {
+    const { prefix: astPrefix, localName: astLocalName } =
+      parseAstName(astAttrName);
+    for (const item of attributes) {
+      let { name: itemName, value: itemValue } = item;
+      if (caseInsensitive) {
+        itemName = itemName.toLowerCase();
+        itemValue = itemValue.toLowerCase();
+      }
+      const colonIdx = itemName.indexOf(':');
+      switch (astPrefix) {
+        case '': {
+          if (astLocalName === itemName) {
+            attrValues.add(itemValue);
+          }
+          break;
+        }
+        case '*': {
+          if (colonIdx > -1) {
+            const itemLocalName = itemName
+              .substring(colonIdx + 1)
+              .replace(/^:/, '');
+            if (itemLocalName === astLocalName) {
+              attrValues.add(itemValue);
+            }
+          } else if (astLocalName === itemName) {
+            attrValues.add(itemValue);
+          }
+          break;
+        }
+        default: {
+          if (!check) {
+            if (forgive) {
+              return false;
+            }
+            const css = generateCSS(ast);
+            throw generateException(
+              `Invalid selector ${css}`,
+              SYNTAX_ERR,
+              globalObject
+            );
+          }
+          if (colonIdx > -1) {
+            const itemPrefix = itemName.substring(0, colonIdx);
+            const itemLocalName = itemName
+              .substring(colonIdx + 1)
+              .replace(/^:/, '');
+            // Ignore the 'xml:lang' attribute.
+            if (itemPrefix === 'xml' && itemLocalName === 'lang') {
+              continue;
+            } else if (
+              astPrefix === itemPrefix &&
+              astLocalName === itemLocalName
+            ) {
+              const namespaceDeclared = isNamespaceDeclared(astPrefix, node);
+              if (namespaceDeclared) {
+                attrValues.add(itemValue);
+              }
+            }
+          }
+        }
+      }
+    }
+    // Handle non-namespaced attribute names.
+  } else {
+    for (let { name: itemName, value: itemValue } of attributes) {
+      if (caseInsensitive) {
+        itemName = itemName.toLowerCase();
+        itemValue = itemValue.toLowerCase();
+      }
+      const colonIdx = itemName.indexOf(':');
+      if (colonIdx > -1) {
+        const itemPrefix = itemName.substring(0, colonIdx);
+        const itemLocalName = itemName
+          .substring(colonIdx + 1)
+          .replace(/^:/, '');
+        // The attribute is starting with ':'.
+        if (!itemPrefix && astAttrName === `:${itemLocalName}`) {
+          attrValues.add(itemValue);
+          // Ignore the 'xml:lang' attribute.
+        } else if (itemPrefix === 'xml' && itemLocalName === 'lang') {
+          continue;
+        } else if (astAttrName === itemLocalName) {
+          attrValues.add(itemValue);
+        }
+      } else if (astAttrName === itemName) {
+        attrValues.add(itemValue);
+      }
+    }
+  }
+  if (!attrValues.size) {
+    return false;
+  }
+  // Prepare the value from the selector's RHS for comparison.
+  const { name: astIdentValue, value: astStringValue } = astValue ?? {};
+  let attrValue;
+  if (astIdentValue) {
+    // Ident values are not unescaped by css-tree, so we must unescape them
+    // (e.g. `\5c` hex escapes, `\n` character escapes).
+    if (caseInsensitive) {
+      attrValue = unescapeSelector(astIdentValue).toLowerCase();
+    } else {
+      attrValue = unescapeSelector(astIdentValue);
+    }
+  } else if (astStringValue) {
+    // String values (quoted) are already unescaped by css-tree, so use as-is.
+    if (caseInsensitive) {
+      attrValue = astStringValue.toLowerCase();
+    } else {
+      attrValue = astStringValue;
+    }
+  } else if (astStringValue === '') {
+    attrValue = astStringValue;
+  }
+  // Perform the final match based on the specified matcher.
+  switch (astMatcher) {
+    case '=': {
+      return typeof attrValue === 'string' && attrValues.has(attrValue);
+    }
+    case '~=': {
+      if (attrValue && typeof attrValue === 'string') {
+        if (/\s/.test(attrValue)) {
+          return false;
+        }
+        if (ast._tildeTarget === undefined) {
+          ast._tildeTarget = ` ${attrValue} `;
+        }
+        const target = ast._tildeTarget;
+        for (const value of attrValues) {
+          if (` ${value.replace(/[\t\r\n\f]/g, ' ')} `.includes(target)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    case '|=': {
+      if (attrValue && typeof attrValue === 'string') {
+        for (const value of attrValues) {
+          if (value === attrValue || value.startsWith(`${attrValue}-`)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    case '^=': {
+      if (attrValue && typeof attrValue === 'string') {
+        for (const value of attrValues) {
+          if (value.startsWith(`${attrValue}`)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    case '$=': {
+      if (attrValue && typeof attrValue === 'string') {
+        for (const value of attrValues) {
+          if (value.endsWith(`${attrValue}`)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    case '*=': {
+      if (attrValue && typeof attrValue === 'string') {
+        for (const value of attrValues) {
+          if (value.includes(`${attrValue}`)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    case null:
+    default: {
+      // This case handles attribute existence checks (e.g., '[disabled]').
+      return true;
+    }
+  }
+};
+
+/**
+ * match type selector
+ * @param {object} ast - AST
+ * @param {object} node - Element node
+ * @param {object} [opt] - options
+ * @param {boolean} [opt.check] - running in internal check()
+ * @param {boolean} [opt.forgive] - forgive undeclared namespace
+ * @returns {boolean} - result
+ */
+export const matchTypeSelector = (ast, node, opt = {}) => {
+  const astName = unescapeSelector(ast.name);
+  const { localName, namespaceURI, prefix } = node;
+  const { check, forgive, globalObject } = opt;
+  let { prefix: astPrefix, localName: astLocalName } = parseAstName(
+    astName,
+    node
+  );
+  const isHTML =
+    node.ownerDocument.contentType === 'text/html' &&
+    (!namespaceURI || namespaceURI === 'http://www.w3.org/1999/xhtml');
+  if (isHTML && localName === astLocalName && !astName.includes('|')) {
+    return true;
+  }
+  const firstChar = localName.charCodeAt(0);
+  const isAlphabet =
+    (firstChar >= 65 && firstChar <= 90) ||
+    (firstChar >= 97 && firstChar <= 122);
+  if (isHTML && isAlphabet) {
+    astPrefix = astPrefix.toLowerCase();
+    astLocalName = astLocalName.toLowerCase();
+  }
+  let nodePrefix;
+  let nodeLocalName;
+  const colonIdx = localName.indexOf(':');
+  if (colonIdx > -1) {
+    nodePrefix = localName.substring(0, colonIdx);
+    nodeLocalName = localName.substring(colonIdx + 1);
+  } else {
+    nodePrefix = prefix || '';
+    nodeLocalName = localName;
+  }
+  const isUniversal = astLocalName === '*';
+  switch (astPrefix) {
+    case '': {
+      return (
+        !nodePrefix &&
+        !namespaceURI &&
+        (isUniversal || astLocalName === nodeLocalName)
+      );
+    }
+    case '*': {
+      return isUniversal || astLocalName === nodeLocalName;
+    }
+    default: {
+      if (!check) {
+        if (forgive) {
+          return false;
+        }
+        const css = generateCSS(ast);
+        throw generateException(
+          `Invalid selector ${css}`,
+          SYNTAX_ERR,
+          globalObject
+        );
+      }
+      const astNS = node.lookupNamespaceURI(astPrefix);
+      const nodeNS = node.lookupNamespaceURI(nodePrefix);
+      if (astNS === nodeNS && astPrefix === nodePrefix) {
+        return isUniversal || astLocalName === nodeLocalName;
+      } else if (!forgive && !astNS) {
+        throw generateException(
+          `Undeclared namespace ${astPrefix}`,
+          SYNTAX_ERR,
+          globalObject
+        );
+      }
+      return false;
+    }
+  }
+};
diff --git a/node_modules/@asamuzakjp/dom-selector/src/js/parser.js b/node_modules/@asamuzakjp/dom-selector/src/js/parser.js
new file mode 100644
index 0000000000000000000000000000000000000000..410f2b65ae6e0b0dfbae27334fad068230b53970
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/src/js/parser.js
@@ -0,0 +1,441 @@
+/**
+ * parser.js
+ */
+
+/* import */
+import * as cssTree from 'css-tree';
+import { getType } from './utility.js';
+
+/* constants */
+import {
+  ATTR_SELECTOR,
+  BIT_01,
+  BIT_02,
+  BIT_04,
+  BIT_08,
+  BIT_16,
+  BIT_32,
+  BIT_FFFF,
+  CLASS_SELECTOR,
+  DUO,
+  HEX,
+  ID_SELECTOR,
+  KEYS_LOGICAL,
+  NTH,
+  PS_CLASS_SELECTOR,
+  PS_ELEMENT_SELECTOR,
+  SELECTOR,
+  SYNTAX_ERR,
+  TYPE_SELECTOR
+} from './constant.js';
+const AST_SORT_ORDER = new Map([
+  [PS_ELEMENT_SELECTOR, BIT_01],
+  [ID_SELECTOR, BIT_02],
+  [CLASS_SELECTOR, BIT_04],
+  [TYPE_SELECTOR, BIT_08],
+  [ATTR_SELECTOR, BIT_16],
+  [PS_CLASS_SELECTOR, BIT_32]
+]);
+const KEYS_PS_CLASS_STATE = new Set([
+  'checked',
+  'closed',
+  'disabled',
+  'empty',
+  'enabled',
+  'in-range',
+  'indeterminate',
+  'invalid',
+  'open',
+  'out-of-range',
+  'placeholder-shown',
+  'read-only',
+  'read-write',
+  'valid'
+]);
+const KEYS_SHADOW_HOST = new Set(['host', 'host-context']);
+const REG_EMPTY_PS_FUNC =
+  /(?<=:(?:dir|has|host(?:-context)?|is|lang|not|nth-(?:last-)?(?:child|of-type)|where))\(\s+\)/g;
+const REG_SHADOW_PS_ELEMENT = /^part|slotted$/;
+const U_FFFD = '\uFFFD';
+
+/**
+ * Unescapes a CSS selector string.
+ * @param {string} selector - The CSS selector to unescape.
+ * @returns {string} The unescaped selector string.
+ */
+export const unescapeSelector = (selector = '') => {
+  if (typeof selector === 'string' && selector.indexOf('\\', 0) >= 0) {
+    const arr = selector.split('\\');
+    const selectorItems = [arr[0]];
+    const l = arr.length;
+    for (let i = 1; i < l; i++) {
+      const item = arr[i];
+      if (item === '' && i === l - 1) {
+        selectorItems.push(U_FFFD);
+      } else if (item === '') {
+        // Empty segment at non-last position means \\ (escaped backslash)
+        selectorItems.push('\\');
+        i++; // skip the next segment which is the remainder after \\
+        if (i < l) {
+          selectorItems.push(arr[i]);
+        }
+      } else {
+        const hexExists = /^([\da-f]{1,6}\s?)/i.exec(item);
+        if (hexExists) {
+          const [, hex] = hexExists;
+          let str;
+          try {
+            const low = parseInt('D800', HEX);
+            const high = parseInt('DFFF', HEX);
+            const deci = parseInt(hex, HEX);
+            if (deci === 0 || (deci >= low && deci <= high)) {
+              str = U_FFFD;
+            } else {
+              str = String.fromCodePoint(deci);
+            }
+          } catch (e) {
+            str = U_FFFD;
+          }
+          let postStr = '';
+          if (item.length > hex.length) {
+            postStr = item.substring(hex.length);
+          }
+          selectorItems.push(`${str}${postStr}`);
+          // whitespace
+        } else if (/^[\n\r\f]/.test(item)) {
+          selectorItems.push(`\\${item}`);
+        } else {
+          selectorItems.push(item);
+        }
+      }
+    }
+    return selectorItems.join('');
+  }
+  return selector;
+};
+
+/**
+ * Preprocesses a selector string according to the specification.
+ * @see https://drafts.csswg.org/css-syntax-3/#input-preprocessing
+ * @param {string} value - The value to preprocess.
+ * @returns {string} The preprocessed selector string.
+ */
+export const preprocess = value => {
+  // Non-string values will be converted to string.
+  if (typeof value !== 'string') {
+    if (value === undefined || value === null) {
+      return getType(value).toLowerCase();
+    } else if (Array.isArray(value)) {
+      return value.join(',');
+    } else if (Object.hasOwn(value, 'toString')) {
+      return value.toString();
+    } else {
+      throw new DOMException(`Invalid selector ${value}`, SYNTAX_ERR);
+    }
+  }
+  let selector = value;
+  let index = 0;
+  while (index >= 0) {
+    // @see https://drafts.csswg.org/selectors/#id-selectors
+    index = selector.indexOf('#', index);
+    if (index < 0) {
+      break;
+    }
+    const preHash = selector.substring(0, index + 1);
+    let postHash = selector.substring(index + 1);
+    const codePoint = postHash.codePointAt(0);
+    if (codePoint > BIT_FFFF) {
+      const str = `\\${codePoint.toString(HEX)} `;
+      if (postHash.length === DUO) {
+        postHash = str;
+      } else {
+        postHash = `${str}${postHash.substring(DUO)}`;
+      }
+    }
+    selector = `${preHash}${postHash}`;
+    index++;
+  }
+  selector = selector
+    .replace(/\f|\r\n?/g, '\n')
+    .replace(/[\0\uD800-\uDFFF]|\\$/g, U_FFFD);
+  if (selector === '&') {
+    return '';
+  }
+  return selector.replace(/\x26/g, ':scope');
+};
+
+/**
+ * Creates an Abstract Syntax Tree (AST) from a CSS selector string.
+ * @param {string} sel - The CSS selector string.
+ * @returns {object} The parsed AST object.
+ */
+export const parseSelector = sel => {
+  const selector = preprocess(sel);
+  // invalid selectors
+  if (/^$|^\s*>|,\s*$/.test(selector)) {
+    throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
+  }
+  try {
+    return cssTree.parse(selector, {
+      context: 'selectorList'
+    });
+  } catch (e) {
+    const { message } = e;
+    if (
+      /^(?:"\]"|Attribute selector [()\s,=~^$*|]+) is expected$/.test(
+        message
+      ) &&
+      !selector.endsWith(']')
+    ) {
+      const index = selector.lastIndexOf('[');
+      const selPart = selector.substring(index);
+      if (selPart.includes('"')) {
+        const quotes = selPart.match(/"/g).length;
+        if (quotes % 2) {
+          return parseSelector(`${selector}"]`);
+        }
+        return parseSelector(`${selector}]`);
+      }
+      return parseSelector(`${selector}]`);
+    } else if (message === '")" is expected') {
+      // workaround for https://github.com/csstree/csstree/issues/283
+      if (REG_EMPTY_PS_FUNC.test(selector)) {
+        return parseSelector(`${selector.replaceAll(REG_EMPTY_PS_FUNC, '()')}`);
+      } else if (!selector.endsWith(')')) {
+        return parseSelector(`${selector})`);
+      } else {
+        throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
+      }
+    } else {
+      throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
+    }
+  }
+};
+
+/**
+ * Walks the provided AST to collect selector branches and gather information
+ * about its contents.
+ * @param {object} ast - The AST to traverse.
+ * @param {boolean} toObject - True if converts ast to object, false otherwise.
+ * @returns {{branches: Array<object>, info: object}} An object containing the selector branches and info.
+ */
+export const walkAST = (ast = {}, toObject = false) => {
+  const branches = new Set();
+  const info = {
+    hasForgivenPseudoFunc: false,
+    hasHasPseudoFunc: false,
+    hasLogicalPseudoFunc: false,
+    hasNotPseudoFunc: false,
+    hasNthChildOfSelector: false,
+    hasNestedSelector: false,
+    hasStatePseudoClass: false
+  };
+  const opt = {
+    enter(node) {
+      switch (node.type) {
+        case CLASS_SELECTOR: {
+          if (/^-?\d/.test(node.name)) {
+            throw new DOMException(
+              `Invalid selector .${node.name}`,
+              SYNTAX_ERR
+            );
+          }
+          break;
+        }
+        case ID_SELECTOR: {
+          if (/^-?\d/.test(node.name)) {
+            throw new DOMException(
+              `Invalid selector #${node.name}`,
+              SYNTAX_ERR
+            );
+          }
+          break;
+        }
+        case PS_CLASS_SELECTOR: {
+          if (KEYS_LOGICAL.has(node.name)) {
+            info.hasNestedSelector = true;
+            info.hasLogicalPseudoFunc = true;
+            if (node.name === 'has') {
+              info.hasHasPseudoFunc = true;
+            } else if (node.name === 'not') {
+              info.hasNotPseudoFunc = true;
+            } else {
+              info.hasForgivenPseudoFunc = true;
+            }
+          } else if (KEYS_PS_CLASS_STATE.has(node.name)) {
+            info.hasStatePseudoClass = true;
+          } else if (
+            KEYS_SHADOW_HOST.has(node.name) &&
+            Array.isArray(node.children) &&
+            node.children.length
+          ) {
+            info.hasNestedSelector = true;
+          }
+          break;
+        }
+        case PS_ELEMENT_SELECTOR: {
+          if (REG_SHADOW_PS_ELEMENT.test(node.name)) {
+            info.hasNestedSelector = true;
+          }
+          break;
+        }
+        case NTH: {
+          if (node.selector) {
+            info.hasNestedSelector = true;
+            info.hasNthChildOfSelector = true;
+          }
+          break;
+        }
+        case SELECTOR: {
+          branches.add(node.children);
+          break;
+        }
+        default:
+      }
+    }
+  };
+  const clonedAst = cssTree.clone(ast);
+  cssTree.walk(toObject ? cssTree.toPlainObject(clonedAst) : clonedAst, opt);
+  if (info.hasNestedSelector === true) {
+    cssTree.findAll(clonedAst, (node, item, list) => {
+      if (list) {
+        if (node.type === PS_CLASS_SELECTOR && KEYS_LOGICAL.has(node.name)) {
+          const itemList = list.filter(i => {
+            const { name, type } = i;
+            return type === PS_CLASS_SELECTOR && KEYS_LOGICAL.has(name);
+          });
+          for (const { children } of itemList) {
+            // SelectorList
+            for (const { children: grandChildren } of children) {
+              // Selector
+              for (const { children: greatGrandChildren } of grandChildren) {
+                if (branches.has(greatGrandChildren)) {
+                  branches.delete(greatGrandChildren);
+                }
+              }
+            }
+          }
+        } else if (
+          node.type === PS_CLASS_SELECTOR &&
+          KEYS_SHADOW_HOST.has(node.name) &&
+          Array.isArray(node.children) &&
+          node.children.length
+        ) {
+          const itemList = list.filter(i => {
+            const { children, name, type } = i;
+            const res =
+              type === PS_CLASS_SELECTOR &&
+              KEYS_SHADOW_HOST.has(name) &&
+              Array.isArray(children) &&
+              children.length;
+            return res;
+          });
+          for (const { children } of itemList) {
+            // Selector
+            for (const { children: grandChildren } of children) {
+              if (branches.has(grandChildren)) {
+                branches.delete(grandChildren);
+              }
+            }
+          }
+        } else if (
+          node.type === PS_ELEMENT_SELECTOR &&
+          REG_SHADOW_PS_ELEMENT.test(node.name)
+        ) {
+          const itemList = list.filter(i => {
+            const { name, type } = i;
+            const res =
+              type === PS_ELEMENT_SELECTOR && REG_SHADOW_PS_ELEMENT.test(name);
+            return res;
+          });
+          for (const { children } of itemList) {
+            // Selector
+            for (const { children: grandChildren } of children) {
+              if (branches.has(grandChildren)) {
+                branches.delete(grandChildren);
+              }
+            }
+          }
+        } else if (node.type === NTH && node.selector) {
+          const itemList = list.filter(i => {
+            const { selector, type } = i;
+            const res = type === NTH && selector;
+            return res;
+          });
+          for (const { selector } of itemList) {
+            const { children } = selector;
+            // Selector
+            for (const { children: grandChildren } of children) {
+              if (branches.has(grandChildren)) {
+                branches.delete(grandChildren);
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+  return {
+    info,
+    branches: [...branches]
+  };
+};
+
+/**
+ * Comparison function for sorting AST nodes based on specificity.
+ * @param {object} a - The first AST node.
+ * @param {object} b - The second AST node.
+ * @returns {number} -1, 0 or 1, depending on the sort order.
+ */
+export const compareASTNodes = (a, b) => {
+  const bitA = AST_SORT_ORDER.get(a.type);
+  const bitB = AST_SORT_ORDER.get(b.type);
+  if (bitA === bitB) {
+    return 0;
+  } else if (bitA > bitB) {
+    return 1;
+  } else {
+    return -1;
+  }
+};
+
+/**
+ * Sorts a collection of AST nodes based on CSS specificity rules.
+ * @param {Array<object>} asts - A collection of AST nodes to sort.
+ * @returns {Array<object>} A new array containing the sorted AST nodes.
+ */
+export const sortAST = asts => {
+  const arr = [...asts];
+  if (arr.length > 1) {
+    arr.sort(compareASTNodes);
+  }
+  return arr;
+};
+
+/**
+ * Parses a type selector's name, which may include a namespace prefix.
+ * @param {string} selector - The type selector name (e.g., 'ns|E' or 'E').
+ * @returns {{prefix: string, localName: string}} An object with `prefix` and
+ * `localName` properties.
+ */
+export const parseAstName = selector => {
+  let prefix;
+  let localName;
+  if (selector && typeof selector === 'string') {
+    if (selector.indexOf('|') > -1) {
+      [prefix, localName] = selector.split('|');
+    } else {
+      prefix = '*';
+      localName = selector;
+    }
+  } else {
+    throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
+  }
+  return {
+    prefix,
+    localName
+  };
+};
+
+/* Re-exported from css-tree. */
+export { find as findAST, generate as generateCSS } from 'css-tree';
diff --git a/node_modules/@asamuzakjp/dom-selector/src/js/utility.js b/node_modules/@asamuzakjp/dom-selector/src/js/utility.js
new file mode 100644
index 0000000000000000000000000000000000000000..b4b72846cc06586baadf073737d9d376f5be90c0
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/src/js/utility.js
@@ -0,0 +1,1109 @@
+/**
+ * utility.js
+ */
+
+/* import */
+import nwsapi from '@asamuzakjp/nwsapi';
+import bidiFactory from 'bidi-js';
+import * as cssTree from 'css-tree';
+import isCustomElementName from 'is-potential-custom-element-name';
+
+/* constants */
+import {
+  ATRULE,
+  COMBO,
+  COMPOUND_I,
+  DESCEND,
+  DOCUMENT_FRAGMENT_NODE,
+  DOCUMENT_NODE,
+  DOCUMENT_POSITION_CONTAINS,
+  DOCUMENT_POSITION_PRECEDING,
+  ELEMENT_NODE,
+  HAS_COMPOUND,
+  INPUT_BUTTON,
+  INPUT_EDIT,
+  INPUT_LTR,
+  INPUT_TEXT,
+  KEYS_LOGICAL,
+  LOGIC_COMPLEX,
+  LOGIC_COMPOUND,
+  N_TH,
+  PSEUDO_CLASS,
+  RULE,
+  SCOPE,
+  SELECTOR_LIST,
+  TAG_TYPE,
+  TARGET_ALL,
+  TARGET_FIRST,
+  TEXT_NODE,
+  TYPE_FROM,
+  TYPE_TO
+} from './constant.js';
+const KEYS_DIR_AUTO = new Set([...INPUT_BUTTON, ...INPUT_TEXT, 'hidden']);
+const KEYS_DIR_LTR = new Set(INPUT_LTR);
+const KEYS_INPUT_EDIT = new Set(INPUT_EDIT);
+const KEYS_NODE_DIR_EXCLUDE = new Set(['bdi', 'script', 'style', 'textarea']);
+const KEYS_NODE_FOCUSABLE = new Set(['button', 'select', 'textarea']);
+const KEYS_NODE_FOCUSABLE_SVG = new Set([
+  'clipPath',
+  'defs',
+  'desc',
+  'linearGradient',
+  'marker',
+  'mask',
+  'metadata',
+  'pattern',
+  'radialGradient',
+  'script',
+  'style',
+  'symbol',
+  'title'
+]);
+const REG_ATTR_SIMPLE = /^\[[A-Z\d-]{1,255}(?:="?[A-Z\d\s-]{1,255}"?)?\]$/i;
+const REG_TAG_SIMPLE = new RegExp(`^(?:${TAG_TYPE})$`);
+const REG_EXCLUDE_BASIC =
+  /[|\\]|::|[^\u0021-\u007F\s]|\[\s*[\w$*=^|~-]+(?:(?:"[\w$*=^|~\s'-]+"|'[\w$*=^|~\s"-]+')?(?:\s+[\w$*=^|~-]+)+|"[^"\]]{1,255}|'[^'\]]{1,255})\s*\]|:(?:is|where)\(\s*\)/;
+const REG_COMPLEX = new RegExp(`${COMPOUND_I}${COMBO}${COMPOUND_I}`, 'i');
+const REG_DESCEND = new RegExp(`${COMPOUND_I}${DESCEND}${COMPOUND_I}`, 'i');
+const REG_LOGIC_COMPLEX = new RegExp(
+  `:(?!${PSEUDO_CLASS}|${N_TH}|${LOGIC_COMPLEX})`
+);
+const REG_LOGIC_COMPOUND = new RegExp(
+  `:(?!${PSEUDO_CLASS}|${N_TH}|${LOGIC_COMPOUND})`
+);
+const REG_LOGIC_HAS_COMPOUND = new RegExp(
+  `:(?!${PSEUDO_CLASS}|${N_TH}|${LOGIC_COMPOUND}|${HAS_COMPOUND})`
+);
+const REG_END_WITH_HAS = new RegExp(`:${HAS_COMPOUND}$`);
+const REG_WO_LOGICAL = new RegExp(`:(?!${PSEUDO_CLASS}|${N_TH})`);
+const REG_IS_HTML = /^(?:application\/xhtml\+x|text\/ht)ml$/;
+const REG_IS_XML =
+  /^(?:application\/(?:[\w\-.]+\+)?|image\/[\w\-.]+\+|text\/)xml$/;
+
+/**
+ * Manages state for extracting nested selectors from a CSS AST.
+ */
+class SelectorExtractor {
+  constructor() {
+    this.selectors = [];
+    this.isScoped = false;
+  }
+
+  /**
+   * Walker enter function.
+   * @param {object} node - The AST node.
+   */
+  enter(node) {
+    switch (node.type) {
+      case ATRULE: {
+        if (node.name === 'scope') {
+          this.isScoped = true;
+        }
+        break;
+      }
+      case SCOPE: {
+        const { children, type } = node.root;
+        const arr = [];
+        if (type === SELECTOR_LIST) {
+          for (const child of children) {
+            const selector = cssTree.generate(child);
+            arr.push(selector);
+          }
+          this.selectors.push(arr);
+        }
+        break;
+      }
+      case RULE: {
+        const { children, type } = node.prelude;
+        const arr = [];
+        if (type === SELECTOR_LIST) {
+          let hasAmp = false;
+          for (const child of children) {
+            const selector = cssTree.generate(child);
+            if (this.isScoped && !hasAmp) {
+              hasAmp = /\x26/.test(selector);
+            }
+            arr.push(selector);
+          }
+          if (this.isScoped) {
+            if (hasAmp) {
+              this.selectors.push(arr);
+              /* FIXME:
+              } else {
+                this.selectors = arr;
+                this.isScoped = false;
+              */
+            }
+          } else {
+            this.selectors.push(arr);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Walker leave function.
+   * @param {object} node - The AST node.
+   */
+  leave(node) {
+    if (node.type === ATRULE) {
+      if (node.name === 'scope') {
+        this.isScoped = false;
+      }
+    }
+  }
+}
+
+/**
+ * Get type of an object.
+ * @param {object} o - Object to check.
+ * @returns {string} - Type of the object.
+ */
+export const getType = o =>
+  Object.prototype.toString.call(o).slice(TYPE_FROM, TYPE_TO);
+
+/**
+ * Verify array contents.
+ * @param {Array} arr - The array.
+ * @param {string} type - Expected type, e.g. 'String'.
+ * @throws {TypeError} - Throws if array or its items are of unexpected type.
+ * @returns {Array} - The verified array.
+ */
+export const verifyArray = (arr, type) => {
+  if (!Array.isArray(arr)) {
+    throw new TypeError(`Unexpected type ${getType(arr)}`);
+  }
+  if (typeof type !== 'string') {
+    throw new TypeError(`Unexpected type ${getType(type)}`);
+  }
+  for (const item of arr) {
+    if (getType(item) !== type) {
+      throw new TypeError(`Unexpected type ${getType(item)}`);
+    }
+  }
+  return arr;
+};
+
+/**
+ * Generate a DOMException.
+ * @param {string} msg - The error message.
+ * @param {string} name - The error name.
+ * @param {object} globalObject - The global object (e.g., window).
+ * @returns {DOMException} The generated DOMException object.
+ */
+export const generateException = (msg, name, globalObject = globalThis) => {
+  return new globalObject.DOMException(msg, name);
+};
+
+/**
+ * Find a nested :has() pseudo-class.
+ * @param {object} leaf - The AST leaf to check.
+ * @returns {?object} The leaf if it's :has, otherwise null.
+ */
+export const findNestedHas = leaf => {
+  return leaf.name === 'has';
+};
+
+/**
+ * Find a logical pseudo-class that contains a nested :has().
+ * @param {object} leaf - The AST leaf to check.
+ * @returns {?object} The leaf if it matches, otherwise null.
+ */
+export const findLogicalWithNestedHas = leaf => {
+  if (KEYS_LOGICAL.has(leaf.name) && cssTree.find(leaf, findNestedHas)) {
+    return leaf;
+  }
+  return null;
+};
+
+/**
+ * Filter a list of nodes based on An+B logic
+ * @param {Array.<object>} nodes - array of nodes to filter
+ * @param {object} anb - An+B options
+ * @param {number} anb.a - a
+ * @param {number} anb.b - b
+ * @param {boolean} [anb.reverse] - reverse order
+ * @returns {Array.<object>} - array of matched nodes
+ */
+export const filterNodesByAnB = (nodes, anb) => {
+  const { a, b, reverse } = anb;
+  const processedNodes = reverse ? [...nodes].reverse() : nodes;
+  const l = nodes.length;
+  const matched = [];
+  if (a === 0) {
+    if (b > 0 && b <= l) {
+      matched.push(processedNodes[b - 1]);
+    }
+    return matched;
+  }
+  let startIndex = b - 1;
+  if (a > 0) {
+    while (startIndex < 0) {
+      startIndex += a;
+    }
+    for (let i = startIndex; i < l; i += a) {
+      matched.push(processedNodes[i]);
+    }
+  } else if (startIndex >= 0) {
+    for (let i = startIndex; i >= 0; i += a) {
+      matched.push(processedNodes[i]);
+    }
+    return matched.reverse();
+  }
+  return matched;
+};
+
+/**
+ * Resolve content document, root node, and check if it's in a shadow DOM.
+ * @param {object} node - Document, DocumentFragment, or Element node.
+ * @returns {Array.<object|boolean>} - [document, root, isInShadow].
+ */
+export const resolveContent = node => {
+  if (!node?.nodeType) {
+    throw new TypeError(`Unexpected type ${getType(node)}`);
+  }
+  let document;
+  let root;
+  let shadow;
+  switch (node.nodeType) {
+    case DOCUMENT_NODE: {
+      document = node;
+      root = node;
+      break;
+    }
+    case DOCUMENT_FRAGMENT_NODE: {
+      const { host, mode, ownerDocument } = node;
+      document = ownerDocument;
+      root = node;
+      shadow = host && (mode === 'close' || mode === 'open');
+      break;
+    }
+    case ELEMENT_NODE: {
+      document = node.ownerDocument;
+      let refNode = node;
+      while (refNode) {
+        const { host, mode, nodeType, parentNode } = refNode;
+        if (nodeType === DOCUMENT_FRAGMENT_NODE) {
+          shadow = host && (mode === 'close' || mode === 'open');
+          break;
+        } else if (parentNode) {
+          refNode = parentNode;
+        } else {
+          break;
+        }
+      }
+      root = refNode;
+      break;
+    }
+    default: {
+      throw new TypeError(`Unexpected node ${node.nodeName}`);
+    }
+  }
+  return [document, root, !!shadow];
+};
+
+/**
+ * Traverse node tree with a TreeWalker.
+ * @param {object} node - The target node.
+ * @param {object} walker - The TreeWalker instance.
+ * @param {boolean} [force] - Traverse only to the next node.
+ * @returns {?object} - The current node if found, otherwise null.
+ */
+export const traverseNode = (node, walker, force = false) => {
+  if (!node?.nodeType) {
+    throw new TypeError(`Unexpected type ${getType(node)}`);
+  }
+  if (!walker) {
+    return null;
+  }
+  let refNode = walker.currentNode;
+  if (refNode === node) {
+    return refNode;
+  } else if (force || refNode.contains(node)) {
+    refNode = walker.nextNode();
+    while (refNode) {
+      if (refNode === node) {
+        break;
+      }
+      refNode = walker.nextNode();
+    }
+    return refNode;
+  } else {
+    if (refNode !== walker.root) {
+      let bool;
+      while (refNode) {
+        if (refNode === node) {
+          bool = true;
+          break;
+        } else if (refNode === walker.root || refNode.contains(node)) {
+          break;
+        }
+        refNode = walker.parentNode();
+      }
+      if (bool) {
+        return refNode;
+      }
+    }
+    if (node.nodeType === ELEMENT_NODE) {
+      let bool;
+      while (refNode) {
+        if (refNode === node) {
+          bool = true;
+          break;
+        }
+        refNode = walker.nextNode();
+      }
+      if (bool) {
+        return refNode;
+      }
+    }
+  }
+  return null;
+};
+
+/**
+ * Check if a node is a custom element.
+ * @param {object} node - The Element node.
+ * @param {object} [opt] - Options.
+ * @returns {boolean} - True if it's a custom element.
+ */
+export const isCustomElement = (node, opt = {}) => {
+  if (!node?.nodeType) {
+    throw new TypeError(`Unexpected type ${getType(node)}`);
+  }
+  if (node.nodeType !== ELEMENT_NODE) {
+    return false;
+  }
+  const { localName, ownerDocument } = node;
+  const { formAssociated } = opt;
+  const window = ownerDocument.defaultView;
+  let elmConstructor;
+  const attr = node.getAttribute('is');
+  if (attr) {
+    elmConstructor =
+      isCustomElementName(attr) && window.customElements.get(attr);
+  } else {
+    elmConstructor =
+      isCustomElementName(localName) && window.customElements.get(localName);
+  }
+  if (elmConstructor) {
+    if (formAssociated) {
+      return !!elmConstructor.formAssociated;
+    }
+    return true;
+  }
+  return false;
+};
+
+/**
+ * Get slotted text content.
+ * @param {object} node - The Element node (likely a <slot>).
+ * @returns {?string} - The text content.
+ */
+export const getSlottedTextContent = node => {
+  if (!node?.nodeType) {
+    throw new TypeError(`Unexpected type ${getType(node)}`);
+  }
+  if (typeof node.assignedNodes !== 'function') {
+    return null;
+  }
+  const nodes = node.assignedNodes();
+  if (nodes.length) {
+    let text = '';
+    const l = nodes.length;
+    for (let i = 0; i < l; i++) {
+      const item = nodes[i];
+      text = item.textContent.trim();
+      if (text) {
+        break;
+      }
+    }
+    return text;
+  }
+  return node.textContent.trim();
+};
+
+/**
+ * Get directionality of a node.
+ * @see https://html.spec.whatwg.org/multipage/dom.html#the-dir-attribute
+ * @param {object} node - The Element node.
+ * @returns {?string} - 'ltr' or 'rtl'.
+ */
+export const getDirectionality = node => {
+  if (!node?.nodeType) {
+    throw new TypeError(`Unexpected type ${getType(node)}`);
+  }
+  if (node.nodeType !== ELEMENT_NODE) {
+    return null;
+  }
+  const { dir: dirAttr, localName, parentNode } = node;
+  const { getEmbeddingLevels } = bidiFactory();
+  if (dirAttr === 'ltr' || dirAttr === 'rtl') {
+    return dirAttr;
+  } else if (dirAttr === 'auto') {
+    let text = '';
+    switch (localName) {
+      case 'input': {
+        if (!node.type || KEYS_DIR_AUTO.has(node.type)) {
+          text = node.value;
+        } else if (KEYS_DIR_LTR.has(node.type)) {
+          return 'ltr';
+        }
+        break;
+      }
+      case 'slot': {
+        text = getSlottedTextContent(node);
+        break;
+      }
+      case 'textarea': {
+        text = node.value;
+        break;
+      }
+      default: {
+        const items = [].slice.call(node.childNodes);
+        for (const item of items) {
+          const {
+            dir: itemDir,
+            localName: itemLocalName,
+            nodeType: itemNodeType,
+            textContent: itemTextContent
+          } = item;
+          if (itemNodeType === TEXT_NODE) {
+            text = itemTextContent.trim();
+          } else if (
+            itemNodeType === ELEMENT_NODE &&
+            !KEYS_NODE_DIR_EXCLUDE.has(itemLocalName) &&
+            (!itemDir || (itemDir !== 'ltr' && itemDir !== 'rtl'))
+          ) {
+            if (itemLocalName === 'slot') {
+              text = getSlottedTextContent(item);
+            } else {
+              text = itemTextContent.trim();
+            }
+          }
+          if (text) {
+            break;
+          }
+        }
+      }
+    }
+    if (text) {
+      const {
+        paragraphs: [{ level }]
+      } = getEmbeddingLevels(text);
+      if (level % 2 === 1) {
+        return 'rtl';
+      }
+    } else if (parentNode) {
+      const { nodeType: parentNodeType } = parentNode;
+      if (parentNodeType === ELEMENT_NODE) {
+        return getDirectionality(parentNode);
+      }
+    }
+  } else if (localName === 'input' && node.type === 'tel') {
+    return 'ltr';
+  } else if (localName === 'bdi') {
+    const text = node.textContent.trim();
+    if (text) {
+      const {
+        paragraphs: [{ level }]
+      } = getEmbeddingLevels(text);
+      if (level % 2 === 1) {
+        return 'rtl';
+      }
+    }
+  } else if (parentNode) {
+    if (localName === 'slot') {
+      const text = getSlottedTextContent(node);
+      if (text) {
+        const {
+          paragraphs: [{ level }]
+        } = getEmbeddingLevels(text);
+        if (level % 2 === 1) {
+          return 'rtl';
+        }
+        return 'ltr';
+      }
+    }
+    const { nodeType: parentNodeType } = parentNode;
+    if (parentNodeType === ELEMENT_NODE) {
+      return getDirectionality(parentNode);
+    }
+  }
+  return 'ltr';
+};
+
+/**
+ * Traverses up the DOM tree to find the language attribute for a node.
+ * It checks for 'lang' in HTML and 'xml:lang' in XML contexts.
+ * @param {object} node - The starting element node.
+ * @returns {string|null} The language attribute value, or null if not found.
+ */
+export const getLanguageAttribute = node => {
+  if (!node?.nodeType) {
+    throw new TypeError(`Unexpected type ${getType(node)}`);
+  }
+  if (node.nodeType !== ELEMENT_NODE) {
+    return null;
+  }
+  const { contentType } = node.ownerDocument;
+  const isHtml = REG_IS_HTML.test(contentType);
+  const isXml = REG_IS_XML.test(contentType);
+  let isShadow = false;
+  // Traverse up from the current node to the root.
+  let current = node;
+  while (current) {
+    // Check if the current node is an element.
+    switch (current.nodeType) {
+      case ELEMENT_NODE: {
+        // Check for and return the language attribute if present.
+        if (isHtml && current.hasAttribute('lang')) {
+          return current.getAttribute('lang');
+        } else if (isXml && current.hasAttribute('xml:lang')) {
+          return current.getAttribute('xml:lang');
+        }
+        break;
+      }
+      case DOCUMENT_FRAGMENT_NODE: {
+        // Continue traversal if the current node is a shadow root.
+        if (current.host) {
+          isShadow = true;
+        }
+        break;
+      }
+      case DOCUMENT_NODE:
+      default: {
+        // Stop if we reach the root document node.
+        return null;
+      }
+    }
+    if (isShadow) {
+      current = current.host;
+      isShadow = false;
+    } else if (current.parentNode) {
+      current = current.parentNode;
+    } else {
+      break;
+    }
+  }
+  // No language attribute was found in the hierarchy.
+  return null;
+};
+
+/**
+ * Check if content is editable.
+ * NOTE: Not implemented in jsdom https://github.com/jsdom/jsdom/issues/1670
+ * @param {object} node - The Element node.
+ * @returns {boolean} - True if content is editable.
+ */
+export const isContentEditable = node => {
+  if (!node?.nodeType) {
+    throw new TypeError(`Unexpected type ${getType(node)}`);
+  }
+  if (node.nodeType !== ELEMENT_NODE) {
+    return false;
+  }
+  if (typeof node.isContentEditable === 'boolean') {
+    return node.isContentEditable;
+  } else if (node.ownerDocument.designMode === 'on') {
+    return true;
+  } else {
+    let attr;
+    if (node.hasAttribute('contenteditable')) {
+      attr = node.getAttribute('contenteditable');
+    } else {
+      attr = 'inherit';
+    }
+    switch (attr) {
+      case '':
+      case 'true': {
+        return true;
+      }
+      case 'plaintext-only': {
+        // FIXME:
+        // @see https://github.com/w3c/editing/issues/470
+        // @see https://github.com/whatwg/html/issues/10651
+        return true;
+      }
+      case 'false': {
+        return false;
+      }
+      default: {
+        if (node?.parentNode?.nodeType === ELEMENT_NODE) {
+          return isContentEditable(node.parentNode);
+        }
+        return false;
+      }
+    }
+  }
+};
+
+/**
+ * Check if a node is visible.
+ * @param {object} node - The Element node.
+ * @returns {boolean} - True if the node is visible.
+ */
+export const isVisible = node => {
+  if (node?.nodeType !== ELEMENT_NODE) {
+    return false;
+  }
+  // TODO: switch to node.checkVisibility()
+  const window = node.ownerDocument.defaultView;
+  const { display, visibility } = window.getComputedStyle(node);
+  return display !== 'none' && visibility === 'visible';
+};
+
+/**
+ * Check if focus is visible on the node.
+ * @param {object} node - The Element node.
+ * @returns {boolean} - True if focus is visible.
+ */
+export const isFocusVisible = node => {
+  if (node?.nodeType !== ELEMENT_NODE) {
+    return false;
+  }
+  const { localName, type } = node;
+  switch (localName) {
+    case 'input': {
+      if (!type || KEYS_INPUT_EDIT.has(type)) {
+        return true;
+      }
+      return false;
+    }
+    case 'textarea': {
+      return true;
+    }
+    default: {
+      return isContentEditable(node);
+    }
+  }
+};
+
+/**
+ * Check if an area is focusable.
+ * @param {object} node - The Element node.
+ * @returns {boolean} - True if the area is focusable.
+ */
+export const isFocusableArea = node => {
+  if (node?.nodeType !== ELEMENT_NODE) {
+    return false;
+  }
+  if (!node.isConnected) {
+    return false;
+  }
+  const window = node.ownerDocument.defaultView;
+  if (node instanceof window.HTMLElement) {
+    if (Number.isInteger(parseInt(node.getAttribute('tabindex')))) {
+      return true;
+    }
+    if (isContentEditable(node)) {
+      return true;
+    }
+    const { localName, parentNode } = node;
+    switch (localName) {
+      case 'a': {
+        if (node.href || node.hasAttribute('href')) {
+          return true;
+        }
+        return false;
+      }
+      case 'iframe': {
+        return true;
+      }
+      case 'input': {
+        if (
+          node.disabled ||
+          node.hasAttribute('disabled') ||
+          node.hidden ||
+          node.hasAttribute('hidden')
+        ) {
+          return false;
+        }
+        return true;
+      }
+      case 'summary': {
+        if (parentNode.localName === 'details') {
+          let child = parentNode.firstElementChild;
+          let bool = false;
+          while (child) {
+            if (child.localName === 'summary') {
+              bool = child === node;
+              break;
+            }
+            child = child.nextElementSibling;
+          }
+          return bool;
+        }
+        return false;
+      }
+      default: {
+        if (
+          KEYS_NODE_FOCUSABLE.has(localName) &&
+          !(node.disabled || node.hasAttribute('disabled'))
+        ) {
+          return true;
+        }
+      }
+    }
+  } else if (node instanceof window.SVGElement) {
+    if (Number.isInteger(parseInt(node.getAttributeNS(null, 'tabindex')))) {
+      const ns = 'http://www.w3.org/2000/svg';
+      let bool;
+      let refNode = node;
+      while (refNode.namespaceURI === ns) {
+        bool = KEYS_NODE_FOCUSABLE_SVG.has(refNode.localName);
+        if (bool) {
+          break;
+        }
+        if (refNode?.parentNode?.namespaceURI === ns) {
+          refNode = refNode.parentNode;
+        } else {
+          break;
+        }
+      }
+      if (bool) {
+        return false;
+      }
+      return true;
+    }
+    if (
+      node.localName === 'a' &&
+      (node.href || node.hasAttributeNS(null, 'href'))
+    ) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Check if a node is focusable.
+ * NOTE: Not applied, needs fix in jsdom itself.
+ * @see https://github.com/whatwg/html/pull/8392
+ * @see https://phabricator.services.mozilla.com/D156219
+ * @see https://github.com/jsdom/jsdom/issues/3029
+ * @see https://github.com/jsdom/jsdom/issues/3464
+ * @param {object} node - The Element node.
+ * @returns {boolean} - True if the node is focusable.
+ */
+export const isFocusable = node => {
+  if (node?.nodeType !== ELEMENT_NODE) {
+    return false;
+  }
+  const window = node.ownerDocument.defaultView;
+  let refNode = node;
+  let res = true;
+  while (refNode) {
+    if (refNode.disabled || refNode.hasAttribute('disabled')) {
+      res = false;
+      break;
+    }
+    if (refNode.hidden || refNode.hasAttribute('hidden')) {
+      res = false;
+    }
+    const { contentVisibility, display, visibility } =
+      window.getComputedStyle(refNode);
+    if (
+      display === 'none' ||
+      visibility !== 'visible' ||
+      (contentVisibility === 'hidden' && refNode !== node)
+    ) {
+      res = false;
+    } else {
+      res = true;
+    }
+    if (res && refNode?.parentNode?.nodeType === ELEMENT_NODE) {
+      refNode = refNode.parentNode;
+    } else {
+      break;
+    }
+  }
+  return res;
+};
+
+/**
+ * Get namespace URI.
+ * @param {string} ns - The namespace prefix.
+ * @param {object} node - The Element node.
+ * @returns {?string} - The namespace URI.
+ */
+export const getNamespaceURI = (ns, node) => {
+  if (typeof ns !== 'string') {
+    throw new TypeError(`Unexpected type ${getType(ns)}`);
+  } else if (!node?.nodeType) {
+    throw new TypeError(`Unexpected type ${getType(node)}`);
+  }
+  if (!ns || node.nodeType !== ELEMENT_NODE) {
+    return null;
+  }
+  const { attributes } = node;
+  let res;
+  for (const attr of attributes) {
+    const { name, namespaceURI, prefix, value } = attr;
+    if (name === `xmlns:${ns}`) {
+      res = value;
+    } else if (prefix === ns) {
+      res = namespaceURI;
+    }
+    if (res) {
+      break;
+    }
+  }
+  return res ?? null;
+};
+
+/**
+ * Check if a namespace is declared.
+ * @param {string} ns - The namespace.
+ * @param {object} node - The Element node.
+ * @returns {boolean} - True if the namespace is declared.
+ */
+export const isNamespaceDeclared = (ns = '', node = {}) => {
+  if (!ns || typeof ns !== 'string' || node?.nodeType !== ELEMENT_NODE) {
+    return false;
+  }
+  if (node.lookupNamespaceURI(ns)) {
+    return true;
+  }
+  const root = node.ownerDocument.documentElement;
+  let parent = node;
+  let res;
+  while (parent) {
+    res = getNamespaceURI(ns, parent);
+    if (res || parent === root) {
+      break;
+    }
+    parent = parent.parentNode;
+  }
+  return !!res;
+};
+
+/**
+ * Check if nodeA precedes and/or contains nodeB.
+ * @param {object} nodeA - The first Element node.
+ * @param {object} nodeB - The second Element node.
+ * @returns {boolean} - True if nodeA precedes nodeB.
+ */
+export const isPreceding = (nodeA, nodeB) => {
+  if (!nodeA?.nodeType) {
+    throw new TypeError(`Unexpected type ${getType(nodeA)}`);
+  } else if (!nodeB?.nodeType) {
+    throw new TypeError(`Unexpected type ${getType(nodeB)}`);
+  }
+  if (nodeA.nodeType !== ELEMENT_NODE || nodeB.nodeType !== ELEMENT_NODE) {
+    return false;
+  }
+  const posBit = nodeB.compareDocumentPosition(nodeA);
+  const res =
+    posBit & DOCUMENT_POSITION_PRECEDING || posBit & DOCUMENT_POSITION_CONTAINS;
+  return !!res;
+};
+
+/**
+ * Comparison function for sorting nodes based on document position.
+ * @param {object} a - The first node.
+ * @param {object} b - The second node.
+ * @returns {number} - Sort order.
+ */
+export const compareNodes = (a, b) => {
+  if (isPreceding(b, a)) {
+    return 1;
+  }
+  return -1;
+};
+
+/**
+ * Sort a collection of nodes.
+ * @param {Array.<object>|Set.<object>} nodes - Collection of nodes.
+ * @returns {Array.<object>} - Collection of sorted nodes.
+ */
+export const sortNodes = (nodes = []) => {
+  const arr = [...nodes];
+  if (arr.length > 1) {
+    arr.sort(compareNodes);
+  }
+  return arr;
+};
+
+/**
+ * Concat an array of nested selectors into an equivalent single selector.
+ * @param {Array.<Array.<string>>} selectors - [parents, children, ...].
+ * @returns {string} - The concatenated selector.
+ */
+export const concatNestedSelectors = selectors => {
+  if (!Array.isArray(selectors)) {
+    throw new TypeError(`Unexpected type ${getType(selectors)}`);
+  }
+  let selector = '';
+  if (selectors.length) {
+    const revSelectors = selectors.toReversed();
+    let child = verifyArray(revSelectors.shift(), 'String');
+    if (child.length === 1) {
+      [child] = child;
+    }
+    while (revSelectors.length) {
+      const parentArr = verifyArray(revSelectors.shift(), 'String');
+      if (!parentArr.length) {
+        continue;
+      }
+      let parent;
+      if (parentArr.length === 1) {
+        [parent] = parentArr;
+        if (!/^[>~+]/.test(parent) && /[\s>~+]/.test(parent)) {
+          parent = `:is(${parent})`;
+        }
+      } else {
+        parent = `:is(${parentArr.join(', ')})`;
+      }
+      if (selector.includes('\x26')) {
+        selector = selector.replace(/\x26/g, parent);
+      }
+      if (Array.isArray(child)) {
+        const items = [];
+        for (let item of child) {
+          if (item.includes('\x26')) {
+            if (/^[>~+]/.test(item)) {
+              item = `${parent} ${item.replace(/\x26/g, parent)} ${selector}`;
+            } else {
+              item = `${item.replace(/\x26/g, parent)} ${selector}`;
+            }
+          } else {
+            item = `${parent} ${item} ${selector}`;
+          }
+          items.push(item.trim());
+        }
+        selector = items.join(', ');
+      } else if (revSelectors.length) {
+        selector = `${child} ${selector}`;
+      } else {
+        if (child.includes('\x26')) {
+          if (/^[>~+]/.test(child)) {
+            selector = `${parent} ${child.replace(/\x26/g, parent)} ${selector}`;
+          } else {
+            selector = `${child.replace(/\x26/g, parent)} ${selector}`;
+          }
+        } else {
+          selector = `${parent} ${child} ${selector}`;
+        }
+      }
+      selector = selector.trim();
+      if (revSelectors.length) {
+        child = parentArr.length > 1 ? parentArr : parent;
+      } else {
+        break;
+      }
+    }
+    selector = selector.replace(/\x26/g, ':scope').trim();
+  }
+  return selector;
+};
+
+/**
+ * Extract nested selectors from CSSRule.cssText.
+ * @param {string} css - CSSRule.cssText.
+ * @returns {Array.<Array.<string>>} - Array of nested selectors.
+ */
+export const extractNestedSelectors = css => {
+  const ast = cssTree.parse(css, {
+    context: 'rule'
+  });
+  const extractor = new SelectorExtractor();
+  cssTree.walk(ast, {
+    enter: extractor.enter.bind(extractor),
+    leave: extractor.leave.bind(extractor)
+  });
+  return extractor.selectors;
+};
+
+/**
+ * Initialize nwsapi.
+ * @param {object} window - The Window object.
+ * @param {object} document - The Document object.
+ * @returns {object} - The nwsapi instance.
+ */
+export const initNwsapi = (window, document) => {
+  if (!window?.DOMException) {
+    throw new TypeError(`Unexpected global object ${getType(window)}`);
+  }
+  if (document?.nodeType !== DOCUMENT_NODE) {
+    document = window.document;
+  }
+  const nw = nwsapi({
+    document,
+    DOMException: window.DOMException
+  });
+  nw.configure({
+    LOGERRORS: false
+  });
+  return nw;
+};
+
+/**
+ * Filter a selector for use with nwsapi.
+ * @param {string} selector - The selector string.
+ * @param {string} target - The target type.
+ * @returns {boolean} - True if the selector is valid for nwsapi.
+ */
+export const filterSelector = (selector, target) => {
+  const isQuerySelectorAll = target === TARGET_ALL;
+  // Basic validation and fast-fail for null/undefined/non-string values
+  if (
+    !selector ||
+    typeof selector !== 'string' ||
+    /null|undefined/.test(selector)
+  ) {
+    return false;
+  }
+  // Exclude various complex or unsupported selectors early
+  // i.e. non-ASCII, escaped selectors, namespaced selectors and pseudo-elements
+  if (selector.includes('/') || REG_EXCLUDE_BASIC.test(selector)) {
+    return false;
+  }
+  // Validate attribute selector integrity
+  if (selector.includes('[')) {
+    const index = selector.lastIndexOf('[');
+    if (selector.indexOf(']', index) === -1) {
+      return false;
+    }
+  }
+  // Target-specific early exits
+  if (target === TARGET_FIRST) {
+    return REG_ATTR_SIMPLE.test(selector);
+  }
+  if (target === TARGET_ALL && REG_TAG_SIMPLE.test(selector)) {
+    return false;
+  }
+  // Logic for pseudo-classes
+  if (selector.includes(':')) {
+    // Exclude descendant combinators in logical selectors for querySelectorAll
+    if (isQuerySelectorAll && REG_DESCEND.test(selector)) {
+      return false;
+    }
+    // Determine if the selector has complex logical structures
+    const isComplex = isQuerySelectorAll ? false : REG_COMPLEX.test(selector);
+    // Handle :has() specifically
+    if (selector.includes(':has(')) {
+      if (isQuerySelectorAll) {
+        return false;
+      }
+      if (!isComplex || REG_LOGIC_HAS_COMPOUND.test(selector)) {
+        return false;
+      }
+      return REG_END_WITH_HAS.test(selector);
+    }
+    // Handle :is() and :not()
+    if (/(?:is|not)\(/.test(selector)) {
+      if (isComplex) {
+        return !REG_LOGIC_COMPLEX.test(selector);
+      } else {
+        return !REG_LOGIC_COMPOUND.test(selector);
+      }
+    }
+    // Default check for other pseudo-classes against known list
+    if (REG_WO_LOGICAL.test(selector)) {
+      return false;
+    }
+  }
+  return true;
+};
diff --git a/node_modules/@asamuzakjp/dom-selector/types/index.d.ts b/node_modules/@asamuzakjp/dom-selector/types/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9cfeaf0fd73ccd3de803457e56d2caad5c4b08b3
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/types/index.d.ts
@@ -0,0 +1,20 @@
+export class DOMSelector {
+    constructor(window: Window, document: Document, opt?: object);
+    clear: () => void;
+    extractSubjects: (selector: string) => Array<{
+        id: string | null;
+        className: string | null;
+        tag: string | null;
+    }>;
+    check: (selector: string, node: Element, opt?: object) => CheckResult;
+    matches: (selector: string, node: Element, opt?: object) => boolean;
+    closest: (selector: string, node: Element, opt?: object) => Element | null;
+    querySelector: (selector: string, node: Document | DocumentFragment | Element, opt?: object) => Element | null;
+    querySelectorAll: (selector: string, node: Document | DocumentFragment | Element, opt?: object) => Array<Element>;
+    #private;
+}
+export type CheckResult = {
+    match: boolean;
+    pseudoElement: string | null;
+    ast: object | null;
+};
diff --git a/node_modules/@asamuzakjp/dom-selector/types/js/constant.d.ts b/node_modules/@asamuzakjp/dom-selector/types/js/constant.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f999a789819c41aa7c3fd3fefdfb96078730eea0
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/types/js/constant.d.ts
@@ -0,0 +1,77 @@
+export const ATRULE: "Atrule";
+export const ATTR_SELECTOR: "AttributeSelector";
+export const CLASS_SELECTOR: "ClassSelector";
+export const COMBINATOR: "Combinator";
+export const IDENT: "Identifier";
+export const ID_SELECTOR: "IdSelector";
+export const NOT_SUPPORTED_ERR: "NotSupportedError";
+export const NTH: "Nth";
+export const OPERATOR: "Operator";
+export const PS_CLASS_SELECTOR: "PseudoClassSelector";
+export const PS_ELEMENT_SELECTOR: "PseudoElementSelector";
+export const RULE: "Rule";
+export const SCOPE: "Scope";
+export const SELECTOR: "Selector";
+export const SELECTOR_LIST: "SelectorList";
+export const STRING: "String";
+export const SYNTAX_ERR: "SyntaxError";
+export const TARGET_ALL: "all";
+export const TARGET_FIRST: "first";
+export const TARGET_LINEAL: "lineal";
+export const TARGET_SELF: "self";
+export const TYPE_SELECTOR: "TypeSelector";
+export const BIT_01: 1;
+export const BIT_02: 2;
+export const BIT_04: 4;
+export const BIT_08: 8;
+export const BIT_16: 16;
+export const BIT_32: 32;
+export const BIT_FFFF: 65535;
+export const DUO: 2;
+export const HEX: 16;
+export const TYPE_FROM: 8;
+export const TYPE_TO: -1;
+export const ELEMENT_NODE: 1;
+export const TEXT_NODE: 3;
+export const DOCUMENT_NODE: 9;
+export const DOCUMENT_FRAGMENT_NODE: 11;
+export const DOCUMENT_POSITION_PRECEDING: 2;
+export const DOCUMENT_POSITION_CONTAINS: 8;
+export const DOCUMENT_POSITION_CONTAINED_BY: 16;
+export const SHOW_ALL: 4294967295;
+export const SHOW_CONTAINER: 1281;
+export const SHOW_DOCUMENT: 256;
+export const SHOW_DOCUMENT_FRAGMENT: 1024;
+export const SHOW_ELEMENT: 1;
+export const ALPHA_NUM: "[A-Z\\d]+";
+export const CHILD_IDX: "(?:first|last|only)-(?:child|of-type)";
+export const DIGIT: "(?:0|[1-9]\\d*)";
+export const LANG_PART: "(?:-[A-Z\\d]+)*";
+export const PSEUDO_CLASS: "(?:any-)?link|(?:first|last|only)-(?:child|of-type)|checked|empty|indeterminate|read-(?:only|write)|target";
+export const ANB: "[+-]?(?:(?:0|[1-9]\\d*)n?|n)|(?:[+-]?(?:0|[1-9]\\d*))?n\\s*[+-]\\s*(?:0|[1-9]\\d*)";
+export const COMBO: "\\s?[\\s>~+]\\s?";
+export const DESCEND: "\\s?[\\s>]\\s?";
+export const SIBLING: "\\s?[+~]\\s?";
+export const LOGIC_IS: ":is\\(\\s*[^)]+\\s*\\)";
+export const N_TH: "nth-(?:last-)?(?:child|of-type)\\(\\s*(?:even|odd|[+-]?(?:(?:0|[1-9]\\d*)n?|n)|(?:[+-]?(?:0|[1-9]\\d*))?n\\s*[+-]\\s*(?:0|[1-9]\\d*))\\s*\\)";
+export const SUB_TYPE: "\\[[^|\\]]+\\]|[#.:][\\w-]+";
+export const SUB_TYPE_WO_PSEUDO: "\\[[^|\\]]+\\]|[#.][\\w-]+";
+export const TAG_TYPE: "\\*|[A-Za-z][\\w-]*";
+export const TAG_TYPE_I: "\\*|[A-Z][\\w-]*";
+export const COMPOUND: "(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+)+)";
+export const COMPOUND_L: "(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+)";
+export const COMPOUND_I: "(?:\\*|[A-Z][\\w-]*|(?:\\*|[A-Z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+)+)";
+export const COMPOUND_WO_PSEUDO: "(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.][\\w-]+)+)";
+export const COMPLEX: "(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+)+)(?:\\s?[\\s>~+]\\s?(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+)+))*";
+export const COMPLEX_L: "(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+)(?:\\s?[\\s>~+]\\s?(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+))*";
+export const HAS_COMPOUND: "has\\([\\s>]?\\s*(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.][\\w-]+)+)\\s*\\)";
+export const LOGIC_COMPOUND: "(?:is|not)\\(\\s*(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+)(?:\\s*,\\s*(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+))*\\s*\\)";
+export const LOGIC_COMPLEX: "(?:is|not)\\(\\s*(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+)(?:\\s?[\\s>~+]\\s?(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+))*(?:\\s*,\\s*(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+)(?:\\s?[\\s>~+]\\s?(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+))*)*\\s*\\)";
+export const FORM_PARTS: readonly string[];
+export const INPUT_BUTTON: readonly string[];
+export const INPUT_CHECK: readonly string[];
+export const INPUT_DATE: readonly string[];
+export const INPUT_TEXT: readonly string[];
+export const INPUT_EDIT: readonly string[];
+export const INPUT_LTR: readonly string[];
+export const KEYS_LOGICAL: Set<string>;
diff --git a/node_modules/@asamuzakjp/dom-selector/types/js/finder.d.ts b/node_modules/@asamuzakjp/dom-selector/types/js/finder.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..a01fc66b78707efc8447a3e8bc3fc083fcf11061
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/types/js/finder.d.ts
@@ -0,0 +1,62 @@
+export class Finder {
+    constructor(window: object);
+    onError: (e: Error, opt?: {
+        noexcept?: boolean | undefined;
+    }) => void;
+    setup: (selector: string, node: object, opt?: {
+        check?: boolean | undefined;
+        noexcept?: boolean | undefined;
+        warn?: boolean | undefined;
+    }) => object;
+    clearResults: (all?: boolean) => void;
+    private _handleFocusEvent;
+    private _handleKeyboardEvent;
+    private _handleMouseEvent;
+    private _registerEventListeners;
+    private _processSelectorBranches;
+    private _correspond;
+    private _createTreeWalker;
+    private _getSelectorBranches;
+    private _getFilteredChildren;
+    private _collectNthChild;
+    private _collectNthOfType;
+    private _matchAnPlusB;
+    private _matchHasPseudoFunc;
+    private _evaluateHasPseudo;
+    private _matchLogicalPseudoFunc;
+    private _matchPseudoClassSelector;
+    private _evaluateHostPseudo;
+    private _evaluateHostContextPseudo;
+    private _matchShadowHostPseudoClass;
+    private _matchSelectorForElement;
+    private _matchSelectorForShadowRoot;
+    private _matchSelector;
+    private _matchLeaves;
+    private _getFilterLeaves;
+    private _traverseAllDescendants;
+    private _findDescendantNodes;
+    private _collectCombinatorMatches;
+    private _matchCombinator;
+    private _traverseAndCollectNodes;
+    private _findPrecede;
+    private _findNodeWalker;
+    private _matchSelf;
+    private _findLineal;
+    private _findEntryNodesForPseudoElement;
+    private _findEntryNodesForId;
+    private _findEntryNodesForClass;
+    private _findEntryNodesForType;
+    private _findEntryNodesForOther;
+    private _findEntryNodes;
+    private _determineTraversalStrategy;
+    private _processPendingItems;
+    private _collectNodes;
+    private _getCombinedNodes;
+    private _matchNodeNext;
+    private _matchNodePrev;
+    private _processComplexBranchAll;
+    private _processComplexBranchFirst;
+    find: (targetType: string) => Set<object>;
+    getAST: (selector: string) => object;
+    #private;
+}
diff --git a/node_modules/@asamuzakjp/dom-selector/types/js/matcher.d.ts b/node_modules/@asamuzakjp/dom-selector/types/js/matcher.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d4105d861f6244b2302f26f2ac007bc26d217bfc
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/types/js/matcher.d.ts
@@ -0,0 +1,16 @@
+export function matchPseudoElementSelector(astName: string, astType: string, opt?: {
+    forgive?: boolean | undefined;
+    warn?: boolean | undefined;
+}): void;
+export function matchDirectionPseudoClass(ast: object, node: object): boolean;
+export function matchLanguagePseudoClass(ast: object, node: object): boolean;
+export function matchDisabledPseudoClass(astName: string, node: object): boolean;
+export function matchReadOnlyPseudoClass(astName: string, node: object): boolean;
+export function matchAttributeSelector(ast: object, node: object, opt?: {
+    check?: boolean | undefined;
+    forgive?: boolean | undefined;
+}): boolean;
+export function matchTypeSelector(ast: object, node: object, opt?: {
+    check?: boolean | undefined;
+    forgive?: boolean | undefined;
+}): boolean;
diff --git a/node_modules/@asamuzakjp/dom-selector/types/js/parser.d.ts b/node_modules/@asamuzakjp/dom-selector/types/js/parser.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..20b07824c51792b4d70e8d98d4e93e7e090412d2
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/types/js/parser.d.ts
@@ -0,0 +1,14 @@
+export function unescapeSelector(selector?: string): string;
+export function preprocess(value: string): string;
+export function parseSelector(sel: string): object;
+export function walkAST(ast?: object, toObject?: boolean): {
+    branches: Array<object>;
+    info: object;
+};
+export function compareASTNodes(a: object, b: object): number;
+export function sortAST(asts: Array<object>): Array<object>;
+export function parseAstName(selector: string): {
+    prefix: string;
+    localName: string;
+};
+export { find as findAST, generate as generateCSS } from "css-tree";
diff --git a/node_modules/@asamuzakjp/dom-selector/types/js/utility.d.ts b/node_modules/@asamuzakjp/dom-selector/types/js/utility.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..6120af05970d07470c728971072cdf6525f039c1
--- /dev/null
+++ b/node_modules/@asamuzakjp/dom-selector/types/js/utility.d.ts
@@ -0,0 +1,30 @@
+export function getType(o: object): string;
+export function verifyArray(arr: any[], type: string): any[];
+export function generateException(msg: string, name: string, globalObject?: object): DOMException;
+export function findNestedHas(leaf: object): object | null;
+export function findLogicalWithNestedHas(leaf: object): object | null;
+export function filterNodesByAnB(nodes: Array<object>, anb: {
+    a: number;
+    b: number;
+    reverse?: boolean | undefined;
+}): Array<object>;
+export function resolveContent(node: object): Array<object | boolean>;
+export function traverseNode(node: object, walker: object, force?: boolean): object | null;
+export function isCustomElement(node: object, opt?: object): boolean;
+export function getSlottedTextContent(node: object): string | null;
+export function getDirectionality(node: object): string | null;
+export function getLanguageAttribute(node: object): string | null;
+export function isContentEditable(node: object): boolean;
+export function isVisible(node: object): boolean;
+export function isFocusVisible(node: object): boolean;
+export function isFocusableArea(node: object): boolean;
+export function isFocusable(node: object): boolean;
+export function getNamespaceURI(ns: string, node: object): string | null;
+export function isNamespaceDeclared(ns?: string, node?: object): boolean;
+export function isPreceding(nodeA: object, nodeB: object): boolean;
+export function compareNodes(a: object, b: object): number;
+export function sortNodes(nodes?: Array<object> | Set<object>): Array<object>;
+export function concatNestedSelectors(selectors: Array<Array<string>>): string;
+export function extractNestedSelectors(css: string): Array<Array<string>>;
+export function initNwsapi(window: object, document: object): object;
+export function filterSelector(selector: string, target: string): boolean;
diff --git a/node_modules/@asamuzakjp/generational-cache/LICENSE b/node_modules/@asamuzakjp/generational-cache/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..6c37c44a827d3259302bbdabafdd905f426535e8
--- /dev/null
+++ b/node_modules/@asamuzakjp/generational-cache/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 asamuzaK (Kazz)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/@asamuzakjp/generational-cache/README.md b/node_modules/@asamuzakjp/generational-cache/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..26d4473aa57da2c53614b15efa8655d3c7ade386
--- /dev/null
+++ b/node_modules/@asamuzakjp/generational-cache/README.md
@@ -0,0 +1,125 @@
+# generational-cache
+
+[![CI](https://github.com/asamuzaK/generationalCache/actions/workflows/ci.yaml/badge.svg)](https://github.com/asamuzaK/generationalCache/actions/workflows/ci.yaml)
+[![CodeQL](https://github.com/asamuzaK/generationalCache/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/asamuzaK/generationalCache/actions/workflows/github-code-scanning/codeql)
+[![npm (scoped)](https://img.shields.io/npm/v/@asamuzakjp/generational-cache)](https://www.npmjs.com/package/@asamuzakjp/generational-cache)
+
+A lightweight, **generational pseudo-LRU (Least Recently Used) cache** with strict maximum size limits.
+
+## How it Works
+
+`GenerationalCache` maintains two internal `Map` objects: `current` and `old`.
+
+1.  **Insertion**: New items are always added to the `current` generation.
+2.  **Promotion**: If you `get` an item that exists in the `old` generation, it is promoted to the `current` generation to ensure it stays in the cache longer.
+3.  **Generation Swapping**: Once the `current` generation reaches the boundary size ($max / 2$), the `old` generation is discarded, the `current` generation becomes the `old` generation, and a new empty `current` generation is created.
+
+This "pseudo-LRU" approach avoids the overhead of updating timestamps or complex linked list pointers on every single access.
+
+## Installation
+```bash
+npm i @asamuzakjp/generational-cache
+```
+
+## Usage
+```javascript
+import { GenerationalCache } from '@asamuzakjp/generational-cache';
+
+// Initialize with a max capacity of 1024 items
+const cache = new GenerationalCache(1024);
+```
+
+## API
+
+### `new GenerationalCache(max)`
+
+Creates a new cache instance.
+
+* **`max`** *(number)*: The maximum number of items the cache can hold.
+  If the specified value is less than 4, or if an invalid value is specified, the default value of 4 will be used.
+
+### Properties
+
+* **`cache.size`** *(number, read-only)*: Returns the total number of *entries* currently in the cache.
+  **Note:** To optimize for write speed, this library allows temporary key duplication between generations.
+  Therefore, this value may not always reflect the exact count of unique *keys*.
+* **`cache.max`** *(number)*: Gets or sets the maximum capacity.
+  **Note:** Updating this property dynamically will invoke `cache.clear()` to safely recalculate boundaries.
+
+### Methods
+
+* **`cache.get(key)`**
+  Retrieves an item.
+  If the item is found in the older generation, it is automatically promoted to the current generation to prevent it from being evicted during the next swap.
+    * **Returns:** The value associated with the key, or `undefined`.
+* **`cache.set(key, value)`**
+  Adds or updates an item. If adding this item pushes the current generation's size to the boundary threshold (`max / 2`), a generation swap is triggered, and the old generation is discarded.
+    * **Returns:** The cache instance itself (allows chaining).
+* **`cache.has(key)`**
+  Checks if a key exists in the cache (in either generation).
+    * **Returns:** `true` if the key exists, otherwise `false`.
+* **`cache.delete(key)`**
+  Removes an item from the cache.
+    * **Returns:** `true` if the item existed and was removed, otherwise `false`.
+* **`cache.clear()`**
+  Empties all items from the cache by dropping references to the internal Maps.
+
+## Performance
+
+Benchmarks are divided into two states to simulate real-world conditions:
+- **Cold State**: Measured with aggressive internal Garbage Collection to observe performance before full V8 TurboFan optimizations.
+- **Warm State**: Measured after sufficient warmup, representing sustained throughput under optimal JIT compilation.
+
+*The results below reflect the sustained operations per second (ops/sec), calculated from the average latency (`ns/iter`). Higher values indicate better performance.*
+
+### Benchmark Environment
+- **Engine:** Node.js v24.x (V8)
+- **Measurement:** [mitata](https://github.com/evanwashere/mitata).
+- **Comparison:** [LRUCache](https://www.npmjs.com/package/lru-cache) (v11.x), [QuickLRU](https://www.npmjs.com/package/quick-lru) (v7.x), [Mnemonist](https://www.npmjs.com/package/mnemonist) (v0.40.x)
+
+### 1. Small Cache (Max Size = 512)
+| Scenario | State | **GenerationalCache** | LRUCache | QuickLRU | Mnemonist |
+| :--- | :--- | :--- | :--- | :--- | :--- |
+| **Set** | Cold | **17,733,640 ops/sec** | 4,933,885 ops/sec | 13,506,212 ops/sec | **17,229,496 ops/sec** |
+| | Warm | **23,030,861 ops/sec** | 15,216,068 ops/sec | 18,175,209 ops/sec | 19,409,937 ops/sec |
+| **Get** | Cold | 17,717,930 ops/sec | 7,633,587 ops/sec | 13,734,377 ops/sec | **30,731,407 ops/sec** |
+| | Warm | 21,724,961 ops/sec | 24,148,756 ops/sec | 16,385,384 ops/sec | **35,688,793 ops/sec** |
+| **Eviction** | Cold | **16,700,066 ops/sec** | 6,953,619 ops/sec | 13,285,505 ops/sec | 4,925,865 ops/sec |
+| | Warm | **23,148,148 ops/sec** | 9,040,773 ops/sec | 16,903,313 ops/sec | 8,037,293 ops/sec |
+
+### 2. Medium Cache (Max Size = 2,048)
+| Scenario | State | **GenerationalCache** | LRUCache | QuickLRU | Mnemonist |
+| :--- | :--- | :--- | :--- | :--- | :--- |
+| **Set** | Cold | **15,987,210 ops/sec** | 4,874,957 ops/sec | 11,849,745 ops/sec | **15,309,246 ops/sec** |
+| | Warm | **19,716,088 ops/sec** | 13,345,789 ops/sec | 14,755,791 ops/sec | 17,325,017 ops/sec |
+| **Get** | Cold | 14,994,751 ops/sec | 7,950,389 ops/sec | 11,503,508 ops/sec | **23,651,844 ops/sec** |
+| | Warm | 17,825,311 ops/sec | 18,789,928 ops/sec | 13,838,915 ops/sec | **31,289,111 ops/sec** |
+| **Eviction** | Cold | **16,355,904 ops/sec** | 6,757,669 ops/sec | 12,074,378 ops/sec | 5,175,983 ops/sec |
+| | Warm | **21,982,853 ops/sec** | 8,089,305 ops/sec | 15,309,246 ops/sec | 7,132,158 ops/sec |
+
+### 3. Large Cache (Max Size = 8,192)
+| Scenario | State | **GenerationalCache** | LRUCache | QuickLRU | Mnemonist |
+| :--- | :--- | :--- | :--- | :--- | :--- |
+| **Set** | Cold | **13,679,890 ops/sec** | 3,954,288 ops/sec | 8,126,777 ops/sec | 10,972,130 ops/sec |
+| | Warm | **20,593,080 ops/sec** | 12,054,001 ops/sec | 12,995,451 ops/sec | 15,600,624 ops/sec |
+| **Get** | Cold | 11,918,951 ops/sec | 5,785,363 ops/sec | 9,067,827 ops/sec | **16,784,155 ops/sec** |
+| | Warm | 16,781,339 ops/sec | 17,247,326 ops/sec | 12,733,987 ops/sec | **31,436,655 ops/sec** |
+| **Eviction** | Cold | **13,561,160 ops/sec** | 5,510,249 ops/sec | 9,642,271 ops/sec | 4,040,404 ops/sec |
+| | Warm | **21,128,248 ops/sec** | 7,082,152 ops/sec | 13,208,294 ops/sec | 6,023,007 ops/sec |
+
+### 4. Cyclic Access (Max Size = 8,192 / Working Set = 5,000)
+| Metric | **GenerationalCache** | LRUCache | QuickLRU | Mnemonist |
+| :--- | :--- | :--- | :--- | :--- |
+| **Hit Rate** | 78.30% | **100.00%** | **100.00%** | **100.00%** |
+| **Throughput** | 10,365,916 ops/sec | 40,832,993 ops/sec | 40,950,040 ops/sec | **48,426,150 ops/sec** |
+
+## Key Characteristics
+
+* **High Eviction Efficiency**: `GenerationalCache` demonstrates strong throughput during high-turnover workloads, maintaining a performance margin compared to standard LRU designs in large-scale eviction scenarios.
+* **Predictable Scalability**: While other libraries may experience performance degradation as cache size increases, `GenerationalCache` maintains consistent throughput due to its generational swap mechanism.
+* **Balanced Read/Write**: It provides stable and competitive performance across all basic operations (`get`, `set`), making it suitable for both read-heavy and write-heavy environments.
+* **Trade-offs**: In cyclic access patterns where the working set is greater than `max / 2` but smaller than `max`, `GenerationalCache` will experience frequent generation swaps and cache misses. To maximize the performance benefits of `GenerationalCache`, it is often better to keep the `max` size small enough to allow some evictions, rather than trying to fit the entire working set.
+
+## License
+
+MIT
diff --git a/node_modules/@asamuzakjp/generational-cache/package.json b/node_modules/@asamuzakjp/generational-cache/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..14721033cba7660586718163c487d0a07ace0482
--- /dev/null
+++ b/node_modules/@asamuzakjp/generational-cache/package.json
@@ -0,0 +1,65 @@
+{
+  "name": "@asamuzakjp/generational-cache",
+  "description": "A generational pseudo-LRU cache with strict maximum size limits.",
+  "author": "asamuzaK",
+  "license": "MIT",
+  "homepage": "https://github.com/asamuzaK/generationalCache",
+  "bugs": "https://github.com/asamuzaK/generationalCache/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/asamuzaK/generationalCache.git"
+  },
+  "files": [
+    "src",
+    "types"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "c8": "^11.0.0",
+    "commander": "^14.0.3",
+    "eslint": "^9.39.4",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-jsdoc": "^62.9.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-regexp": "^3.1.0",
+    "eslint-plugin-unicorn": "^64.0.0",
+    "globals": "^17.5.0",
+    "lru-cache": "^11.3.5",
+    "mitata": "^1.0.34",
+    "mnemonist": "^0.40.3",
+    "mocha": "^11.7.5",
+    "neostandard": "^0.13.0",
+    "prettier": "^3.8.2",
+    "quick-lru": "^7.3.0",
+    "typescript": "^6.0.2"
+  },
+  "overrides": {
+    "c8": {
+      "yargs": "^18.0.0"
+    },
+    "eslint": {
+      "brace-expansion": "^1.1.13"
+    },
+    "serialize-javascript": "^7.0.4"
+  },
+  "scripts": {
+    "bench": "node --expose-gc ./benchmark/benchmark.js",
+    "bench:worst": "node --expose-gc ./benchmark/worst-case-benchmark.js",
+    "build": "npm run tsc && npm run lint && npm test",
+    "lint": "eslint --fix .",
+    "test": "c8 --reporter=text mocha --exit test/*.test.js",
+    "tsc": "node scripts/index clean --dir=types -i && npx tsc"
+  },
+  "engines": {
+    "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
+  },
+  "version": "1.0.1"
+}
diff --git a/node_modules/@asamuzakjp/generational-cache/src/index.js b/node_modules/@asamuzakjp/generational-cache/src/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..dd19bd4742ea17d54421a2f02d0b43be65b2f20e
--- /dev/null
+++ b/node_modules/@asamuzakjp/generational-cache/src/index.js
@@ -0,0 +1,125 @@
+/**
+ * @file generational-cache.js
+ * A generational pseudo-LRU cache with strict maximum size limits.
+ */
+
+/**
+ * @template K, V
+ */
+export class GenerationalCache {
+  #max;
+  #boundary;
+  #current = new Map();
+  #old = new Map();
+
+  /**
+   * Initializes a new instance of the GenerationalCache class.
+   * @param {number} max - The maximum number of items the cache can hold.
+   */
+  constructor(max) {
+    this.max = max;
+  }
+
+  /**
+   * Returns the total number of `entries` currently in the cache.
+   * @note To optimize for write speed, this library allows temporary key
+   * duplication between generations. Therefore, this value may not always
+   * reflect the exact count of unique `keys`.
+   * @returns {number} The total entry count.
+   */
+  get size() {
+    return this.#current.size + this.#old.size;
+  }
+
+  /**
+   * Returns the maximum capacity of the cache.
+   * @returns {number} The maximum size limit.
+   */
+  get max() {
+    return this.#max;
+  }
+
+  /**
+   * Sets the maximum capacity of the cache and recalculates the boundary.
+   * Clears the cache when updated.
+   * @param {number} value - The new maximum capacity to set.
+   */
+  set max(value) {
+    if (Number.isFinite(value) && value > 4) {
+      this.#max = value;
+      this.#boundary = Math.ceil(value / 2);
+    } else {
+      this.#max = 4;
+      this.#boundary = 2;
+    }
+    this.clear();
+  }
+
+  /**
+   * Retrieves an item from the cache.
+   * If the item is in the older generation, it gets promoted to the current
+   * generation.
+   * @param {K} key - The key of the element to return.
+   * @returns {V | undefined} The element associated with the specified key, or
+   * undefined if the key cannot be found.
+   */
+  get(key) {
+    let value = this.#current.get(key);
+    if (value !== undefined) {
+      return value;
+    }
+    value = this.#old.get(key);
+    if (value !== undefined) {
+      this.set(key, value);
+      return value;
+    }
+    return undefined;
+  }
+
+  /**
+   * Adds or updates an element with a specified key and a value to the cache.
+   * @param {K} key - The key of the element to add.
+   * @param {V} value - The value of the element to add.
+   * @returns {GenerationalCache} The cache object itself.
+   */
+  set(key, value) {
+    this.#current.set(key, value);
+    // Swap generations if the current map reaches the boundary
+    if (this.#current.size >= this.#boundary) {
+      this.#old = this.#current;
+      this.#current = new Map();
+    }
+    return this;
+  }
+
+  /**
+   * Returns a boolean indicating whether an element with the specified key
+   * exists or not.
+   * @param {K} key - The key of the element to test for presence.
+   * @returns {boolean} true if an element with the specified key exists in the
+   * cache; otherwise false.
+   */
+  has(key) {
+    return this.#current.has(key) || this.#old.has(key);
+  }
+
+  /**
+   * Removes the specified element from the cache.
+   * @param {K} key - The key of the element to remove.
+   * @returns {boolean} true if an element in the cache existed and has been
+   * removed, or false if the element does not exist.
+   */
+  delete(key) {
+    const deletedFromCurrent = this.#current.delete(key);
+    const deletedFromOld = this.#old.delete(key);
+    return deletedFromCurrent || deletedFromOld;
+  }
+
+  /**
+   * Removes all elements from the cache.
+   */
+  clear() {
+    this.#current.clear();
+    this.#old.clear();
+  }
+}
diff --git a/node_modules/@asamuzakjp/generational-cache/types/index.d.ts b/node_modules/@asamuzakjp/generational-cache/types/index.d.ts
new file mode 100644
index 0000000000000000000000000000000000000000..cc8b494abf9c65f5ba696669b565aad3cc80f7bf
--- /dev/null
+++ b/node_modules/@asamuzakjp/generational-cache/types/index.d.ts
@@ -0,0 +1,12 @@
+export class GenerationalCache<K, V> {
+    constructor(max: number);
+    set max(value: number);
+    get max(): number;
+    get size(): number;
+    get(key: K): V | undefined;
+    set(key: K, value: V): GenerationalCache<any, any>;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    #private;
+}
diff --git a/node_modules/@asamuzakjp/nwsapi/LICENSE b/node_modules/@asamuzakjp/nwsapi/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..cc3621a8ae416c848d931d02181a95e905625e67
--- /dev/null
+++ b/node_modules/@asamuzakjp/nwsapi/LICENSE
@@ -0,0 +1,22 @@
+Copyright (c) 2007-2019 Diego Perini (http://www.iport.it/)
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@asamuzakjp/nwsapi/README.md b/node_modules/@asamuzakjp/nwsapi/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..f74b87d885cd9e07eec50c68b4376c351ea40fdd
--- /dev/null
+++ b/node_modules/@asamuzakjp/nwsapi/README.md
@@ -0,0 +1,132 @@
+# [NWSAPI](http://dperini.github.io/nwsapi/)
+
+Fast CSS Selectors API Engine
+
+![](https://img.shields.io/npm/v/nwsapi.svg?colorB=orange&style=flat) ![](https://img.shields.io/github/tag/dperini/nwsapi.svg?style=flat) ![](https://img.shields.io/npm/dw/nwsapi.svg?style=flat) ![](https://img.shields.io/github/issues/dperini/nwsapi.svg?style=flat)
+
+NWSAPI is the development progress of [NWMATCHER](https://github.com/dperini/nwmatcher) aiming at [Selectors Level 4](https://www.w3.org/TR/selectors-4/) conformance. It has been completely reworked to be easily extended and maintained. It is a right-to-left selector parser and compiler written in pure Javascript with no external dependencies. It was initially thought as a cross browser library to improve event delegation and web page scraping in various frameworks but it has become a popular replacement of the native CSS selection and matching functionality in newer browsers and headless environments.
+
+It uses [regular expressions](https://en.wikipedia.org/wiki/Regular_expression) to parse CSS selector strings and [metaprogramming](https://en.wikipedia.org/wiki/Metaprogramming) to transforms these selector strings into Javascript function resolvers. This process is executed only once for each selector string allowing memoization of the function resolvers and achieving unmatched performances.
+
+## Installation
+
+To include NWSAPI in a standard web page:
+
+```html
+<script type="text/javascript" src="nwsapi.js"></script>
+```
+
+To include NWSAPI in a standard web page and automatically replace the native QSA:
+
+```html
+<script type="text/javascript" src="nwsapi.js" onload="NW.Dom.install()"></script>
+```
+
+To use NWSAPI with Node.js:
+
+```
+$ npm install nwsapi
+```
+
+NWSAPI currently supports browsers (as a global, `NW.Dom`) and headless environments (as a CommonJS module).
+
+
+## Supported Selectors
+
+Here is a list of all the CSS2/CSS3/CSS4 [Supported selectors](https://github.com/dperini/nwsapi/wiki/CSS-supported-selectors).
+
+
+## Features and Compliance
+
+You can read more about NWSAPI [features and compliance](https://github.com/dperini/nwsapi/wiki/Features-and-compliance) on the wiki.
+
+
+## API
+
+### DOM Selection
+
+#### `ancestor( selector, context, callback )`
+
+Returns a reference to the nearest ancestor element matching `selector`, starting at `context`. Returns `null` if no element is found. If `callback` is provided, it is invoked for the matched element.
+
+#### `first( selector, context, callback )`
+
+Returns a reference to the first element matching `selector`, starting at `context`. Returns `null` if no element matches. If `callback` is provided, it is invoked for the matched element.
+
+#### `match( selector, element, callback )`
+
+Returns `true` if `element` matches `selector`, starting at `context`; returns `false` otherwise. If `callback` is provided, it is invoked for the matched element.
+
+#### `select( selector, context, callback )`
+
+Returns an array of all the elements matching `selector`, starting at `context`; returns empty `Array` otherwise. If `callback` is provided, it is invoked for each matching element.
+
+
+### DOM Helpers
+
+#### `byId( id, from )`
+
+Returns a reference to the first element with ID `id`, optionally filtered to descendants of the element `from`.
+
+#### `byTag( tag, from )`
+
+Returns an array of elements having the specified tag name `tag`, optionally filtered to descendants of the element `from`.
+
+#### `byClass( class, from )`
+
+Returns an array of elements having the specified class name `class`, optionally filtered to descendants of the element `from`.
+
+
+### Engine Configuration
+
+#### `configure( options )`
+
+The following is the list of currently available configuration options, their default values and descriptions, they are boolean flags that can be set to `true` or `false`:
+
+* `IDS_DUPES`: true  - true to allow using multiple elements having the same id, false to disallow
+* `LIVECACHE`: true  - true for caching both results and resolvers, false for caching only resolvers
+* `MIXEDCASE`: true  - true to match tag names case insensitive, false to match using case sensitive
+* `LOGERRORS`: true  - true to print errors and warnings to the console, false to mute both of them
+
+
+### Examples on extending the basic functionalities
+
+#### `configure( { <configuration-flag>: [ true | false ] } )`
+
+Disable logging errors/warnings to console, disallow duplicate ids. Example:
+
+```js
+NW.Dom.configure( { LOGERRORS: false, IDS_DUPES: false } );
+```
+NOTE: NW.Dom.configure() without parameters return the current configuration.
+
+#### `registerCombinator( symbol, resolver )`
+
+Registers a new symbol and its matching resolver in the combinators table. Example:
+
+```js
+NW.Dom.registerCombinator( '^', 'e.parentElement' );
+```
+
+#### `registerOperator( symbol, resolver )`
+
+Registers a new symbol and its matching resolver in the attribute operators table. Example:
+
+```js
+NW.Dom.registerOperator( '!=', { p1: '^', p2: '$', p3: 'false' } );
+```
+
+#### `registerSelector( name, rexp, func )`
+
+Registers a new selector, the matching RE and the resolver function, in the selectors table. Example:
+
+```js
+NW.Dom.registerSelector('Controls', /^\:(control)(.*)/i,
+  (function(global) {
+    return function(match, source, mode, callback) {
+      var status = true;
+      source = 'if(/^(button|input|select|textarea)/i.test(e.nodeName)){' + source + '}';
+      return { 'source': source, 'status': status };
+    };
+  })(this));
+```
diff --git a/node_modules/@asamuzakjp/nwsapi/package.json b/node_modules/@asamuzakjp/nwsapi/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..6a44b9c71265e8ea0e7eed53c9d7dde8042daf51
--- /dev/null
+++ b/node_modules/@asamuzakjp/nwsapi/package.json
@@ -0,0 +1,43 @@
+{
+  "name": "@asamuzakjp/nwsapi",
+  "version": "2.3.9",
+  "description": "Fast CSS Selectors API Engine",
+  "homepage": "http://javascript.nwbox.com/nwsapi/",
+  "main": "./src/nwsapi",
+  "keywords": [
+    "css",
+    "css3",
+    "css4",
+    "matcher",
+    "selector"
+  ],
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://javascript.nwbox.com/nwsapi/MIT-LICENSE"
+    }
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Diego Perini",
+    "email": "diego.perini@gmail.com",
+    "web": "http://www.iport.it/"
+  },
+  "maintainers": [
+    {
+      "name": "Diego Perini",
+      "email": "diego.perini@gmail.com",
+      "web": "http://www.iport.it/"
+    }
+  ],
+  "bugs": {
+    "url": "http://github.com/dperini/nwsapi/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/dperini/nwsapi.git"
+  },
+  "scripts": {
+    "lint": "eslint ./src/nwsapi.js"
+  }
+}
diff --git a/node_modules/@asamuzakjp/nwsapi/src/nwsapi.js b/node_modules/@asamuzakjp/nwsapi/src/nwsapi.js
new file mode 100644
index 0000000000000000000000000000000000000000..e118fd5e5320224396a78ce6e64f7795836d24a0
--- /dev/null
+++ b/node_modules/@asamuzakjp/nwsapi/src/nwsapi.js
@@ -0,0 +1,1855 @@
+/**
+ * Forked and modified from nwsapi@2.2.2
+ * - Export to cjs only
+ * - Remove ./modules directory
+ * - Remove unused exported properties
+ * - Remove unused pseudo-classes
+ * - Remove Snapshot.root and resolve document.documentElement on runtime
+ * - Use `let` and `const` as much as possible
+ * - Use `===` and `!==`
+ * - Fix `:nth-of-type()`
+ * - Fix function source for :root, :target and :indeterminate pseudo-classes
+ * - Fix <ident-token>
+ * - Support complex selectors within `:is()` and `:not()`
+ * - Add ::slotted() and ::part() to pseudo-elements list
+ * - Add isContentEditable() function
+ * - Add createMatchingParensRegex() function from upstream
+ * - Invalidate cache for :has() pseudo class
+ * - Optimize some regular expressions
+ */
+/*
+ * Copyright (C) 2007-2019 Diego Perini
+ * All rights reserved.
+ *
+ * nwsapi.js - Fast CSS Selectors API Engine
+ *
+ * Author: Diego Perini <diego.perini at gmail com>
+ * Version: 2.2.0
+ * Created: 20070722
+ * Release: 20220901
+ *
+ * License:
+ *  http://javascript.nwbox.com/nwsapi/MIT-LICENSE
+ * Download:
+ *  http://javascript.nwbox.com/nwsapi/nwsapi.js
+ */
+
+(function Export(global, factory) {
+  'use strict';
+  module.exports = factory;
+})(this, function Factory(global, Export) {
+  const version = 'nwsapi-2.2.2';
+
+  let doc = global.document;
+
+  /**
+   * Generate a regex that matches a balanced set of parentheses.
+   * Outermost parentheses are excluded so any amount of children can be handled.
+   * See https://stackoverflow.com/a/35271017 for reference
+   *
+   * @param {number} depth
+   * @return {string}
+   */
+  function createMatchingParensRegex(depth = 1) {
+    const out = '\\([^)(]*?(?:'.repeat(depth) + '\\([^)(]*?\\)' + '[^)(]*?)*?\\)'.repeat(depth);
+    // remove outermost escaped parens
+    return out.slice(2, out.length - 2);
+  }
+
+  const CFG = {
+    // extensions
+    operators: '[~*^$|]=|=',
+    combinators: '[\\s>+~](?=[^>+~])'
+  };
+
+  const NOT = {
+    // not enclosed in double/single/parens/square
+    doubleEnc: '(?=(?:[^"]*"[^"]*")*[^"]*$)',
+    singleEnc: "(?=(?:[^']*'[^']*')*[^']*$)",
+    parensEnc: '(?![^\\x28]*\\x29)',
+    squareEnc: '(?![^\\x5b]*\\x5d)'
+  };
+
+  const REX = {
+    // regular expressions
+    hasEscapes: /\\/,
+    hexNumbers: /^[0-9a-f]/i,
+    escOrQuote: /^\\|[\x22\x27]/,
+    regExpChar: /(?:(?!\\)[\\^$.*+?()[\]{}|/])/g,
+    trimSpaces: /[\r\n\f]|^\s+|\s+$/g,
+    commaGroup: RegExp('(\\s{0,255},\\s{0,255})' + NOT.squareEnc + NOT.parensEnc, 'g'),
+    splitGroup: /((?:\x28[^\x29]{0,255}\x29|\[[^\]]{0,255}\]|\\.|[^,])+)/g,
+    fixEscapes: /\\([0-9a-f]{1,6}\s?|.)|([\x22\x27])/gi,
+    combineWSP: RegExp('\\s{1,255}' + NOT.singleEnc + NOT.doubleEnc, 'g'),
+    tabCharWSP: RegExp('(\\s?\\t{1,255}\\s?)' + NOT.singleEnc + NOT.doubleEnc, 'g'),
+    pseudosWSP: RegExp('\\s{1,255}([-+])\\s{1,255}' + NOT.squareEnc, 'g')
+  };
+
+  const STD = {
+    combinator: /\s?([>+~])\s?/g,
+    apimethods: /^(?:[a-z]+|\*)\|/i,
+    namespaces: /(\*|[a-z]+)\|[-a-z]+/i
+  };
+
+  const GROUPS = {
+    // pseudo-classes requiring parameters
+    logicalsel: '(is|where|matches|not|has)(?:\\x28\\s?(' + createMatchingParensRegex(3) + ')\\s?\\x29)',
+    treestruct: '(nth(?:-last)?(?:-child|-of-type))(?:\\x28\\s?(even|odd|(?:[-+]?\\d*)(?:n\\s?[-+]?\\s?\\d*)?)\\s?(?:\\x29|$))',
+    // pseudo-classes not requiring parameters
+    locationpc: '(any-link|link|visited|target)\\b',
+    structural: '(root|empty|(?:(?:first|last|only)(?:-child|-of-type)))\\b',
+    inputstate: '(enabled|disabled|read-(?:only|write)|placeholder-shown|default)\\b',
+    inputvalue: '(checked|indeterminate)\\b',
+    // pseudo-classes for parsing only selectors
+    pseudoNop: '(autofill|-webkit-autofill)\\b',
+    // pseudo-elements starting with single colon (:)
+    pseudoSng: '(after|before|first-letter|first-line)\\b',
+    // pseudo-elements starting with double colon (::)
+    pseudoDbl: ':(after|before|first-letter|first-line|selection|part|placeholder|slotted|-webkit-[-a-z0-9]{2,})\\b'
+  };
+
+  const Patterns = {
+    // pseudo-classes
+    treestruct: RegExp('^:(?:' + GROUPS.treestruct + ')(.*)', 'i'),
+    structural: RegExp('^:(?:' + GROUPS.structural + ')(.*)', 'i'),
+    inputstate: RegExp('^:(?:' + GROUPS.inputstate + ')(.*)', 'i'),
+    inputvalue: RegExp('^:(?:' + GROUPS.inputvalue + ')(.*)', 'i'),
+    locationpc: RegExp('^:(?:' + GROUPS.locationpc + ')(.*)', 'i'),
+    logicalsel: RegExp('^:(?:' + GROUPS.logicalsel + ')(.*)', 'i'),
+    pseudoNop: RegExp('^:(?:' + GROUPS.pseudoNop + ')(.*)', 'i'),
+    pseudoSng: RegExp('^:(?:' + GROUPS.pseudoSng + ')(.*)', 'i'),
+    pseudoDbl: RegExp('^:(?:' + GROUPS.pseudoDbl + ')(.*)', 'i'),
+    // combinator symbols
+    children: /^\s?>\s?(.*)/,
+    adjacent: /^\s?\+\s?(.*)/,
+    relative: /^\s?~\s?(.*)/,
+    ancestor: /^\s+(.*)/,
+    // universal & namespace
+    universal: /^\*(.*)/,
+    namespace: /^(\w+|\*)?\|(.*)/
+  };
+
+  // emulate firefox error strings
+  const qsNotArgs = 'Not enough arguments';
+  const qsInvalid = ' is not a valid selector';
+
+  // detect structural pseudo-classes in selectors
+  const reNthElem = /(:nth(?:-last)?-child)/i;
+  const reNthType = /(:nth(?:-last)?-of-type)/i;
+
+  // placeholder for global regexp
+  let reOptimizer;
+  let reValidator;
+
+  // special handling configuration flags
+  const Config = {
+    IDS_DUPES: true,
+    MIXEDCASE: true,
+    LOGERRORS: true,
+    VERBOSITY: true
+  };
+
+  let NAMESPACE;
+  let QUIRKS_MODE;
+  let HTML_DOCUMENT;
+
+  const ATTR_STD_OPS = {
+    '=': 1,
+    '^=': 1,
+    '$=': 1,
+    '|=': 1,
+    '*=': 1,
+    '~=': 1
+  };
+
+  const HTML_TABLE = {
+    accept: 1,
+    'accept-charset': 1,
+    align: 1,
+    alink: 1,
+    axis: 1,
+    bgcolor: 1,
+    charset: 1,
+    checked: 1,
+    clear: 1,
+    codetype: 1,
+    color: 1,
+    compact: 1,
+    declare: 1,
+    defer: 1,
+    dir: 1,
+    direction: 1,
+    disabled: 1,
+    enctype: 1,
+    face: 1,
+    frame: 1,
+    hreflang: 1,
+    'http-equiv': 1,
+    lang: 1,
+    language: 1,
+    link: 1,
+    media: 1,
+    method: 1,
+    multiple: 1,
+    nohref: 1,
+    noresize: 1,
+    noshade: 1,
+    nowrap: 1,
+    readonly: 1,
+    rel: 1,
+    rev: 1,
+    rules: 1,
+    scope: 1,
+    scrolling: 1,
+    selected: 1,
+    shape: 1,
+    target: 1,
+    text: 1,
+    type: 1,
+    valign: 1,
+    valuetype: 1,
+    vlink: 1
+  };
+
+  const Combinators = {};
+
+  const Selectors = {};
+
+  const Operators = {
+    '=': {
+      p1: '^',
+      p2: '$',
+      p3: 'true'
+    },
+    '^=': {
+      p1: '^',
+      p2: '',
+      p3: 'true'
+    },
+    '$=': {
+      p1: '',
+      p2: '$',
+      p3: 'true'
+    },
+    '*=': {
+      p1: '',
+      p2: '',
+      p3: 'true'
+    },
+    '|=': {
+      p1: '^',
+      p2: '(-|$)',
+      p3: 'true'
+    },
+    '~=': {
+      p1: '(^|\\s)',
+      p2: '(\\s|$)',
+      p3: 'true'
+    }
+  };
+
+  const concatCall = function (nodes, callback) {
+    let i = 0;
+    const l = nodes.length;
+    const list = Array(l);
+    while (l > i) {
+      if (callback(list[i] = nodes[i]) === false) {
+        break;
+      }
+      ++i;
+    }
+    return list;
+  };
+
+  const concatList = function (list, nodes) {
+    let i = -1;
+    let l = nodes.length;
+    while (l--) {
+      list[list.length] = nodes[++i];
+    }
+    return list;
+  };
+
+  let hasDupes = false;
+
+  const documentOrder = function (a, b) {
+    if (!hasDupes && a === b) {
+      hasDupes = true;
+      return 0;
+    }
+    return a.compareDocumentPosition(b) & 4 ? -1 : 1;
+  };
+
+  const unique = function (nodes) {
+    let i = 0;
+    let j = -1;
+    let l = nodes.length + 1;
+    const list = [];
+    while (--l) {
+      if (nodes[i++] === nodes[i]) {
+        continue;
+      }
+      list[++j] = nodes[i - 1];
+    }
+    hasDupes = false;
+    return list;
+  };
+
+  // check context for mixed content
+  const hasMixedCaseTagNames = function (context) {
+    const api = 'getElementsByTagNameNS';
+
+    // current host context (ownerDocument)
+    context = context.ownerDocument || context;
+
+    // documentElement (root) element namespace or default html/xhtml namespace
+    const ns = context.documentElement && context.documentElement.namespaceURI
+       ? context.documentElement.namespaceURI
+       : 'http://www.w3.org/1999/xhtml';
+
+    // checking the number of non HTML nodes in the document
+    return (context[api]('*', '*').length - context[api](ns, '*').length) > 0;
+  };
+
+  // check if the document type is HTML
+  const isHTML = function (node) {
+    const doc = node.ownerDocument || node;
+    return doc.nodeType === 9 && doc.contentType === 'text/html';
+  };
+
+  // convert single codepoint to UTF-16 encoding
+  const codePointToUTF16 = function (codePoint) {
+    // out of range, use replacement character
+    if (codePoint < 1 || codePoint > 0x10ffff ||
+        (codePoint > 0xd7ff && codePoint < 0xe000)) {
+      return '\\ufffd';
+    }
+    // javascript strings are UTF-16 encoded
+    if (codePoint < 0x10000) {
+      const lowHex = '000' + codePoint.toString(16);
+      return '\\u' + lowHex.substr(lowHex.length - 4);
+    }
+    // supplementary high + low surrogates
+    return '\\u' + (((codePoint - 0x10000) >> 0x0a) + 0xd800).toString(16) +
+           '\\u' + (((codePoint - 0x10000) % 0x400) + 0xdc00).toString(16);
+  };
+
+  // convert single codepoint to string
+  const stringFromCodePoint = function (codePoint) {
+    // out of range, use replacement character
+    if (codePoint < 1 || codePoint > 0x10ffff ||
+        (codePoint > 0xd7ff && codePoint < 0xe000)) {
+      return '\ufffd';
+    }
+    if (codePoint < 0x10000) {
+      return String.fromCharCode(codePoint);
+    }
+    return String.fromCodePoint(codePoint);
+  };
+
+  // convert escape sequence in a CSS string or identifier
+  // to javascript string with javascript escape sequences
+  const convertEscapes = function (str) {
+    return REX.hasEscapes.test(str)
+      ? str.replace(REX.fixEscapes, function (substring, p1, p2) {
+        // unescaped " or '
+        return p2
+          ? '\\' + p2
+          // javascript strings are UTF-16 encoded
+          : REX.hexNumbers.test(p1)
+            ? codePointToUTF16(parseInt(p1, 16))
+            // \' \"
+            : REX.escOrQuote.test(p1)
+              ? substring
+              // \g \h \. \# etc
+              : p1;
+      })
+      : str;
+  };
+
+  // convert escape sequence in a CSS string or identifier
+  // to javascript string with characters representations
+  const unescapeIdentifier = function (str) {
+    return REX.hasEscapes.test(str)
+      ? str.replace(REX.fixEscapes, function (substring, p1, p2) {
+        // unescaped " or '
+        return p2 || (REX.hexNumbers.test(p1)
+          ? stringFromCodePoint(parseInt(p1, 16))
+          // \' \"
+          : REX.escOrQuote.test(p1)
+            ? substring
+            // \g \h \. \# etc
+            : p1);
+      })
+      : str;
+  };
+
+  // empty set
+  const none = [];
+
+  // cached lambdas
+  const matchLambdas = {};
+  const selectLambdas = {};
+
+  // cached resolvers
+  let matchResolvers = {};
+  let selectResolvers = {};
+
+  const method = {
+    '#': 'getElementById',
+    '*': 'getElementsByTagName',
+    '|': 'getElementsByTagNameNS',
+    '.': 'getElementsByClassName'
+  };
+
+  // find duplicate ids using iterative walk
+  const byIdRaw = function (id, context) {
+    let node = context;
+    const nodes = [];
+    let next = node.firstElementChild;
+    while ((node = next)) {
+      node.id === id && nodes.push(node);
+      if ((next = node.firstElementChild || node.nextElementSibling)) {
+        continue;
+      }
+      while (!next && (node = node.parentElement) && node !== context) {
+        next = node.nextElementSibling;
+      }
+    }
+    return nodes;
+  };
+
+  // context agnostic getElementById
+  const byId = function (id, context) {
+    let e;
+    const api = method['#'];
+
+    // duplicates id allowed
+    if (Config.IDS_DUPES === false) {
+      if (api in context) {
+        e = context[api](id);
+        return e ? [e] : none;
+      }
+    } else if ('all' in context) {
+      if ((e = context.all[id])) {
+        if (e.nodeType === 1) {
+          return e.getAttribute('id') !== id ? [] : [e];
+        } else if (id === 'length') {
+          e = context[api](id);
+          return e ? [e] : none;
+        }
+        const nodes = [];
+        for (let i = 0, l = e.length; l > i; ++i) {
+          if (e[i].id === id) {
+            nodes.push(e[i]);
+          }
+        }
+        return nodes.length ? nodes : none;
+      } else {
+        return none;
+      }
+    }
+
+    return byIdRaw(id, context);
+  };
+
+  // context agnostic getElementsByTagName
+  const byTag = function (tag, context) {
+    let e;
+    let nodes;
+    const api = method['*'];
+
+    // DOCUMENT_NODE (9) & ELEMENT_NODE (1)
+    if (api in context) {
+      return Array.prototype.slice.call(context[api](tag));
+    } else {
+      tag = tag.toLowerCase();
+      // DOCUMENT_FRAGMENT_NODE (11)
+      if ((e = context.firstElementChild)) {
+        if (!(e.nextElementSibling || tag === '*' || e.localName === tag)) {
+          return Array.prototype.slice.call(e[api](tag));
+        } else {
+          nodes = [];
+          do {
+            if (tag === '*' || e.localName === tag) {
+              nodes.push(e);
+            }
+            concatList(nodes, e[api](tag));
+          } while ((e = e.nextElementSibling));
+        }
+      } else {
+        nodes = none;
+      }
+    }
+    return nodes;
+  };
+
+  // context agnostic getElementsByClassName
+  const byClass = function (cls, context) {
+    let e;
+    let nodes;
+    const api = method['.'];
+    let reCls;
+    // DOCUMENT_NODE (9) & ELEMENT_NODE (1)
+    if (api in context) {
+      return Array.prototype.slice.call(context[api](cls));
+    } else {
+      // DOCUMENT_FRAGMENT_NODE (11)
+      if ((e = context.firstElementChild)) {
+        reCls = RegExp('(^|\\s)' + cls + '(\\s|$)', QUIRKS_MODE ? 'i' : '');
+        if (!(e.nextElementSibling || reCls.test(e.className))) {
+          return Array.prototype.slice.call(e[api](cls));
+        } else {
+          nodes = [];
+          do {
+            if (reCls.test(e.className)) {
+              nodes.push(e);
+            }
+            concatList(nodes, e[api](cls));
+          } while ((e = e.nextElementSibling));
+        }
+      } else nodes = none;
+    }
+    return nodes;
+  };
+
+  const compat = {
+    '#': function (c, n) {
+      REX.hasEscapes.test(n) && (n = unescapeIdentifier(n));
+      return function (e, f) {
+        return byId(n, c);
+      };
+    },
+    '*': function (c, n) {
+      REX.hasEscapes.test(n) && (n = unescapeIdentifier(n));
+      return function (e, f) {
+        return byTag(n, c);
+      };
+    },
+    '|': function (c, n) {
+      REX.hasEscapes.test(n) && (n = unescapeIdentifier(n));
+      return function (e, f) {
+        return byTag(n, c);
+      };
+    },
+    '.': function (c, n) {
+      REX.hasEscapes.test(n) && (n = unescapeIdentifier(n));
+      return function (e, f) {
+        return byClass(n, c);
+      };
+    }
+  };
+
+  // namespace aware hasAttribute
+  // helper for XML/XHTML documents
+  const hasAttributeNS = function (e, name) {
+    let i;
+    let l;
+    const attr = e.getAttributeNames();
+    name = RegExp(':?' + name + '$', HTML_DOCUMENT ? 'i' : '');
+    for (i = 0, l = attr.length; l > i; ++i) {
+      if (name.test(attr[i])) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  // fast resolver for the :nth-child() and :nth-last-child() pseudo-classes
+  const nthElement = (function () {
+    let idx = 0;
+    let len = 0;
+    let set = 0;
+    let parent;
+    let parents = [];
+    let nodes = [];
+    return function (element, dir) {
+      // ensure caches are emptied after each run, invoking with dir = 2
+      if (dir === 2) {
+        idx = 0; len = 0; set = 0; nodes = []; parents = []; parent = undefined;
+        return -1;
+      }
+      let e, i, j, k, l;
+      if (parent === element.parentElement) {
+        i = set; j = idx; l = len;
+      } else {
+        l = parents.length;
+        parent = element.parentElement;
+        for (i = -1, j = 0, k = l - 1; l > j; ++j, --k) {
+          if (parents[j] === parent) {
+            i = j;
+            break;
+          }
+          if (parents[k] === parent) {
+            i = k;
+            break;
+          }
+        }
+        if (i < 0) {
+          parents[i = l] = parent;
+          l = 0; nodes[i] = [];
+          e = (parent && parent.firstElementChild) || element;
+          while (e) {
+            nodes[i][l] = e;
+            if (e === element) {
+              j = l;
+            }
+            e = e.nextElementSibling;
+            ++l;
+          }
+          set = i; idx = 0; len = l;
+          if (l < 2) {
+            return l;
+          }
+        } else {
+          l = nodes[i].length;
+          set = i;
+        }
+      }
+      if (element !== nodes[i][j] && element !== nodes[i][j = 0]) {
+        for (j = 0, e = nodes[i], k = l - 1; l > j; ++j, --k) {
+          if (e[j] === element) {
+            break;
+          }
+          if (e[k] === element) {
+            j = k;
+            break;
+          }
+        }
+      }
+      idx = j + 1; len = l;
+      return dir ? l - j : idx;
+    };
+  })();
+
+  // fast resolver for the :nth-of-type() and :nth-last-of-type() pseudo-classes
+  const nthOfType = (function () {
+    let idx = 0;
+    let len = 0;
+    let set = 0;
+    let parent;
+    let parents = [];
+    let nodes = [];
+    return function (element, dir) {
+      // ensure caches are emptied after each run, invoking with dir = 2
+      if (dir === 2) {
+        idx = 0; len = 0; set = 0; nodes = []; parents = []; parent = undefined;
+        return -1;
+      }
+      const name = element.localName;
+      const nsURI = element.namespaceURI;
+      if (nsURI !== 'http://www.w3.org/1999/xhtml') {
+        idx = 0; len = 0; set = 0; nodes = []; parents = []; parent = undefined;
+      }
+      let e;
+      let i;
+      let j;
+      let k;
+      let l;
+      if (nodes[set] && nodes[set][name] && parent === element.parentElement) {
+        i = set;
+        j = idx;
+        l = len;
+      } else {
+        l = parents.length;
+        parent = element.parentElement;
+        for (i = -1, j = 0, k = l - 1; l > j; ++j, --k) {
+          if (parents[j] === parent) {
+            i = j;
+            break;
+          }
+          if (parents[k] === parent) {
+            i = k;
+            break;
+          }
+        }
+        if (i < 0 || !nodes[i][name]) {
+          parents[i = l] = parent;
+          nodes[i] || (nodes[i] = Object());
+          l = 0; nodes[i][name] = [];
+          e = (parent && parent.firstElementChild) || element;
+          while (e) {
+            if (e === element) {
+              j = l;
+            }
+            if (e.localName === name && e.namespaceURI === nsURI) {
+              nodes[i][name][l] = e;
+              ++l;
+            }
+            e = e.nextElementSibling;
+          }
+          set = i; idx = j; len = l;
+          if (l < 2) {
+            return l;
+          }
+        } else {
+          l = nodes[i][name].length;
+          set = i;
+        }
+      }
+      if (element !== nodes[i][name][j] && element !== nodes[i][name][j = 0]) {
+        for (j = 0, e = nodes[i][name], k = l - 1; l > j; ++j, --k) {
+          if (e[j] === element) {
+            break;
+          }
+          if (e[k] === element) {
+            j = k;
+            break;
+          }
+        }
+      }
+      idx = j + 1; len = l;
+      return dir ? l - j : idx;
+    };
+  })();
+
+  // check if the node is the target
+  const isTarget = function (node) {
+    const doc = node.ownerDocument || node;
+    const { hash } = new URL(doc.URL);
+    if (node.id && hash === `#${node.id}` && doc.contains(node)) {
+      return true;
+    }
+    return false;
+  };
+
+  // check if node is indeterminate
+  const isIndeterminate = function (node) {
+    if ((node.indeterminate && node.localName === 'input' &&
+         node.type === 'checkbox') ||
+        (node.localName === 'progress' && !node.hasAttribute('value'))) {
+      return true;
+    }
+    if (node.localName === 'input' && node.type === 'radio' &&
+        !node.hasAttribute('checked')) {
+      const nodeName = node.name;
+      let parent = node.parentNode;
+      while (parent) {
+        if (parent.localName === 'form') {
+          break;
+        }
+        parent = parent.parentNode;
+      }
+      if (!parent) {
+        const doc = node.ownerDocument;
+        parent = doc.documentElement;
+      }
+      const items = parent.getElementsByTagName('input');
+      const l = items.length;
+      let checked;
+      for (let i = 0; i < l; i++) {
+        const item = items[i];
+        if (item.getAttribute('type') === 'radio') {
+          if (nodeName) {
+            if (item.getAttribute('name') === nodeName) {
+              checked = !!item.checked;
+            }
+          } else if (!item.hasAttribute('name')) {
+            checked = !!item.checked;
+          }
+          if (checked) {
+            break;
+          }
+        }
+      }
+      if (!checked) {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  // check if node content is editable
+  const isContentEditable = function (node) {
+    let attrValue = 'inherit';
+    if (node.hasAttribute('contenteditable')) {
+      attrValue = node.getAttribute('contenteditable');
+    }
+    switch (attrValue) {
+      case '':
+      case 'plaintext-only':
+      case 'true':
+        return true;
+      case 'false':
+        return false;
+      default:
+        if (node.parentNode && node.parentNode.nodeType === 1) {
+          return isContentEditable(node.parentNode);
+        }
+        return false;
+    }
+  };
+
+  // build validation regexps used by the engine
+  const setIdentifierSyntax = function () {
+    //
+    // NOTE: SPECIAL CASES IN CSS SYNTAX PARSING RULES
+    //
+    // The <EOF-token> https://drafts.csswg.org/css-syntax/#typedef-eof-token
+    // allow mangled|unclosed selector syntax at the end of selectors strings
+    //
+    // Literal equivalent hex representations of the characters: " ' ` ] )
+    //
+    //     \\x22 = " - double quotes    \\x5b = [ - open square bracket
+    //     \\x27 = ' - single quote     \\x5d = ] - closed square bracket
+    //     \\x60 = ` - back tick        \\x28 = ( - open round parens
+    //     \\x5c = \ - back slash       \\x29 = ) - closed round parens
+    //
+    // using hex format prevents false matches of opened/closed instances
+    // pairs, coloring breakage and other editors highlightning problems.
+    //
+
+    // @see https://drafts.csswg.org/css-syntax-3/#ident-token-diagram
+    const nonascii = '[^\\x00-\\x9f]';
+    const esctoken = '\\\\(?:[^\\r\\n\\f\\da-f]|[\\da-f]{1,6}\\s{0,255})';
+    const identifier =
+      '(?:--|-?(?:[a-z_]|' + nonascii + '|' + esctoken + '))' +
+      '(?:[\\w-]|' + nonascii + '|' + esctoken + ')*';
+
+    const pseudonames = '[-\\w]+';
+    const pseudoparms = '(?:[-+]?\\d*)(?:n\\s?[-+]?\\s?\\d*)';
+    const doublequote = '"[^"\\\\]*(?:\\\\.[^"\\\\]*)*(?:"|$)';
+    const singlequote = "'[^'\\\\]*(?:\\\\.[^'\\\\]*)*(?:'|$)";
+
+    const attrparser = identifier + '|' + doublequote + '|' + singlequote;
+
+    const attrvalues = '([\\x22\\x27]?)((?!\\3)*|(?:\\\\?.)*?)(?:\\3|$)';
+
+    const attributes =
+      '\\[' +
+        // attribute presence
+        '(?:\\*\\|)?\\s?(' + identifier + '(?::' + identifier + ')?)\\s?' +
+        '(?:(' + CFG.operators + ')\\s?(?:' + attrparser + '))?' +
+        // attribute case sensitivity
+        '(?:\\s?\\b(i))?\\s?' +
+      '(?:\\]|$)';
+
+    const attrmatcher = attributes.replace(attrparser, attrvalues);
+
+    const pseudoclass =
+      '(?:\\x28\\s*' +
+        '(?:' + pseudoparms + '?)?|' +
+        // universal * &
+        // namespace *|*
+        '[*|]|' +
+        '(?:' +
+          '(?::' + pseudonames + '(?:\\x28' + pseudoparms + '?(?:\\x29|$))?)|' +
+          '(?:[.#]?' + identifier + ')|' +
+          '(?:' + attributes + ')' +
+        ')+|' +
+        '\\s?[>+~]\\s?|' +
+        '\\s?,\\s?|' +
+        '\\s|' +
+        '\\x29|$' +
+      ')*';
+
+    const standardValidator =
+      '(?=\\s?[^>+~(){}<])' +
+      '(?:' +
+        // universal * &
+        // namespace *|*
+        '\\*|\\||' +
+        '(?:[.#]?' + identifier + ')+|' +
+        '(?:' + attributes + ')+|' +
+        '(?:::?' + pseudonames + pseudoclass + ')|' +
+        '(?:\\s?' + CFG.combinators + '\\s?)|' +
+        '\\s?,\\s?|' +
+        '\\s?' +
+      ')+';
+
+    // the following global RE is used to return the
+    // deepest localName in selector strings and then
+    // use it to retrieve all possible matching nodes
+    // that will be filtered by compiled resolvers
+    reOptimizer = RegExp(
+      '(?:([.:#*]?)(' + identifier + ')' +
+        '(?::[-\\w]+|\\[[^\\]]+(?:\\]|$)|\\x28[^\\x29]+(?:\\x29|$))*' +
+      ')$', 'i');
+
+    // global
+    reValidator = RegExp(standardValidator, 'gi');
+
+    Patterns.id = RegExp('^#(' + identifier + ')(.*)', 'i');
+    Patterns.tagName = RegExp('^(' + identifier + ')(.*)', 'i');
+    Patterns.className = RegExp('^\\.(' + identifier + ')(.*)', 'i');
+    Patterns.attribute = RegExp('^(?:' + attrmatcher + ')(.*)');
+  };
+
+  // configure the engine to use special handling
+  const configure = function (option, clear) {
+    if (typeof option === 'string') {
+      return !!Config[option];
+    }
+    if (typeof option !== 'object') {
+      return Config;
+    }
+    for (const i in option) {
+      Config[i] = !!option[i];
+    }
+    // clear lambda cache
+    if (clear) {
+      matchResolvers = {};
+      selectResolvers = {};
+    }
+    setIdentifierSyntax();
+    return true;
+  };
+
+  // centralized error and exceptions handling
+  const emit = function (message, proto) {
+    let err;
+    if (Config.VERBOSITY) {
+      if (global[proto]) {
+        err = new global[proto](message);
+      } else {
+        err = new global.DOMException(message, 'SyntaxError');
+      }
+      throw err;
+    }
+    if (Config.LOGERRORS && console && console.log) {
+      console.log(message);
+    }
+  };
+
+  // passed to resolvers
+  const Snapshot = {
+    doc: null,
+    from: null,
+    byTag: null,
+    first: null,
+    match: null,
+    ancestor: null,
+    nthOfType: null,
+    nthElement: null,
+    hasAttributeNS: null,
+    isTarget: null,
+    isIndeterminate: null,
+    isContentEditable: null
+  };
+
+  // context
+  let lastContext;
+
+  const switchContext = function (context, force) {
+    const oldDoc = doc;
+    doc = context.ownerDocument || context;
+    if (force || oldDoc !== doc) {
+      // force a new check for each document change
+      // performed before the next select operation
+      HTML_DOCUMENT = isHTML(doc);
+      QUIRKS_MODE = HTML_DOCUMENT && doc.compatMode.indexOf('CSS') < 0;
+      NAMESPACE = doc.documentElement && doc.documentElement.namespaceURI;
+      Snapshot.doc = doc;
+    }
+    Snapshot.from = context;
+    return context;
+  };
+
+  // selector
+  let lastMatched;
+  let lastSelected;
+
+  const F_INIT = '"use strict";return function Resolver(c,f,x,r)';
+
+  const S_HEAD = 'var e,n,o,j=r.length-1,k=-1';
+  const M_HEAD = 'var e,n,o';
+
+  const S_LOOP = 'main:while((e=c[++k]))';
+  const N_LOOP = 'main:while((e=c.item(++k)))';
+  const M_LOOP = 'e=c;';
+
+  const S_BODY = 'r[++j]=c[k];';
+  const N_BODY = 'r[++j]=c.item(k);';
+  const M_BODY = '';
+
+  const S_TAIL = 'continue main;';
+  const M_TAIL = 'r=true;';
+
+  const S_TEST = 'if(f(c[k])){break main;}';
+  const N_TEST = 'if(f(c.item(k))){break main;}';
+  const M_TEST = 'f(c);';
+
+  let S_VARS = [];
+  let M_VARS = [];
+
+  // build conditional code to check components of selector strings
+  const compileSelector = function (expression, source, mode, callback) {
+    // N is the negation pseudo-class flag
+    // D is the default inverted negation flag
+    let a;
+    let b;
+    let n;
+    let f;
+    let name;
+    let NS;
+    const N = '';
+    const D = '!';
+    let compat;
+    let expr;
+    let match;
+    let result;
+    let status;
+    let symbol;
+    let test;
+    let type;
+    let selector = expression;
+    let vars;
+
+    // original 'select' or 'match' selector string before normalization
+    const selectorString = mode ? lastSelected : lastMatched;
+
+    // isolate selector combinators/components and normalize whitespace
+    selector = selector.replace(STD.combinator, '$1'); // .replace(STD.whitespace, ' ');
+
+    let selectorRecursion = true;
+    while (selector) {
+      // get namespace prefix if present or get first char of selector
+      symbol = STD.apimethods.test(selector) ? '|' : selector[0];
+
+      switch (symbol) {
+        // universal resolver
+        case '*':
+          match = selector.match(Patterns.universal);
+          if (N === '!') {
+            source = 'if(' + N + 'true' + '){' + source + '}';
+          }
+          break;
+        // id resolver
+        case '#':
+          match = selector.match(Patterns.id);
+          source = 'if(' + N + '(/^' + match[1] + '$/.test(e.getAttribute("id"))' +
+            ')){' + source + '}';
+          break;
+        // class name resolver
+        case '.':
+          match = selector.match(Patterns.className);
+          compat = (QUIRKS_MODE ? 'i' : '') + '.test(e.getAttribute("class"))';
+          source = 'if(' + N + '(/(^|\\s)' + match[1] + '(\\s|$)/' + compat +
+            ')){' + source + '}';
+          break;
+        // tag name resolver
+        case (/[_a-z]/i.test(symbol) ? symbol : undefined):
+          match = selector.match(Patterns.tagName);
+          source = 'if(' + N + '(e.localName' +
+            (Config.MIXEDCASE || hasMixedCaseTagNames(doc)
+              ? '=="' + match[1].toLowerCase() + '"'
+              : '=="' + match[1].toUpperCase() + '"') +
+            ')){' + source + '}';
+          break;
+        // namespace resolver
+        case '|':
+          match = selector.match(Patterns.namespace);
+          if (match[1] === '*') {
+            source = 'if(' + N + 'true){' + source + '}';
+          } else if (!match[1]) {
+            source = 'if(' + N + '(!e.namespaceURI)){' + source + '}';
+          } else if (typeof match[1] === 'string' && doc.documentElement &&
+                     doc.documentElement.prefix === match[1]) {
+            source = 'if(' + N + '(e.namespaceURI=="' + NAMESPACE + '")){' + source + '}';
+          } else {
+            emit('\'' + selectorString + '\'' + qsInvalid);
+          }
+          break;
+        // attributes resolver
+        case '[':
+          match = selector.match(Patterns.attribute);
+          NS = match[0].match(STD.namespaces);
+          name = match[1];
+          expr = name.split(':');
+          expr = expr.length === 2 ? expr[1] : expr[0];
+          if (match[2] && !(test = Operators[match[2]])) {
+            emit('\'' + selectorString + '\'' + qsInvalid);
+            return '';
+          }
+          if (match[4] === '') {
+            test = match[2] === '~='
+              ? { p1: '^\\s', p2: '+$', p3: 'true' }
+              : match[2] in ATTR_STD_OPS && match[2] !== '~='
+                ? { p1: '^', p2: '$', p3: 'true' }
+                : test;
+          } else if (match[2] === '~=' && match[4].includes(' ')) {
+            // whitespace separated list but value contains space
+            source = 'if(' + N + 'false){' + source + '}';
+            break;
+          } else if (match[4]) {
+            match[4] = convertEscapes(match[4]).replace(REX.regExpChar, '\\$&');
+          }
+          type = match[5] === 'i' || (HTML_DOCUMENT && HTML_TABLE[expr.toLowerCase()])
+            ? 'i'
+            : '';
+          source =
+            'if(' + N + '(' +
+              (!match[2]
+                ? (NS ? 's.hasAttributeNS(e,"' + name + '")' : 'e.hasAttribute&&e.hasAttribute("' + name + '")')
+                : !match[4] && ATTR_STD_OPS[match[2]] && match[2] !== '~='
+                  ? 'e.getAttribute&&e.getAttribute("' + name + '")==""'
+                  : '(/' + test.p1 + match[4] + test.p2 + '/' + type + ').test(e.getAttribute&&e.getAttribute("' + name + '"))==' + test.p3) +
+            ')){' + source + '}';
+          break;
+        // *** General sibling combinator
+        // E ~ F (F relative sibling of E)
+        case '~':
+          match = selector.match(Patterns.relative);
+          source = 'n=e;while((e=e.previousElementSibling)){' + source + '}e=n;';
+          break;
+        // *** Adjacent sibling combinator
+        // E + F (F adiacent sibling of E)
+        case '+':
+          match = selector.match(Patterns.adjacent);
+          source = 'n=e;if((e=e.previousElementSibling)){' + source + '}e=n;';
+          break;
+        // *** Descendant combinator
+        // E F (E ancestor of F)
+        case '\x09':
+        case '\x20':
+          match = selector.match(Patterns.ancestor);
+          source = 'n=e;while((e=e.parentElement)){' + source + '}e=n;';
+          break;
+        // *** Child combinator
+        // E > F (F children of E)
+        case '>':
+          match = selector.match(Patterns.children);
+          source = 'n=e;if((e=e.parentElement)){' + source + '}e=n;';
+          break;
+        // *** user supplied combinators extensions
+        case (symbol in Combinators ? symbol : undefined):
+          // for other registered combinators extensions
+          match[match.length - 1] = '*';
+          source = Combinators[symbol](match) + source;
+          break;
+        // *** tree-structural pseudo-classes
+        // :root, :empty, :first-child, :last-child, :only-child, :first-of-type, :last-of-type, :only-of-type
+        case ':':
+          if ((match = selector.match(Patterns.structural))) {
+            match[1] = match[1].toLowerCase();
+            switch (match[1]) {
+              case 'root':
+                // there can only be one :root element, so exit the loop once found
+                source = 'if(' + N + '(e===s.doc.documentElement)){' + source + (mode ? 'break main;' : '') + '}';
+                break;
+              case 'empty':
+                // matches elements that don't contain elements or text nodes
+                source = 'n=e.firstChild;while(n&&!(/1|3/).test(n.nodeType)){n=n.nextSibling}if(' + D + 'n){' + source + '}';
+                break;
+              // *** child-indexed pseudo-classes
+              // :first-child, :last-child, :only-child
+              case 'only-child':
+                source = 'if(' + N + '(!e.nextElementSibling&&!e.previousElementSibling)){' + source + '}';
+                break;
+              case 'last-child':
+                source = 'if(' + N + '(!e.nextElementSibling)){' + source + '}';
+                break;
+              case 'first-child':
+                source = 'if(' + N + '(!e.previousElementSibling)){' + source + '}';
+                break;
+              // *** typed child-indexed pseudo-classes
+              // :only-of-type, :last-of-type, :first-of-type
+              case 'only-of-type':
+                source = 'o=e.localName;' +
+                  'n=e;while((n=n.nextElementSibling)&&n.localName!=o);if(!n){' +
+                  'n=e;while((n=n.previousElementSibling)&&n.localName!=o);}if(' + D + 'n){' + source + '}';
+                break;
+              case 'last-of-type':
+                source = 'n=e;o=e.localName;while((n=n.nextElementSibling)&&n.localName!=o);if(' + D + 'n){' + source + '}';
+                break;
+              case 'first-of-type':
+                source = 'n=e;o=e.localName;while((n=n.previousElementSibling)&&n.localName!=o);if(' + D + 'n){' + source + '}';
+                break;
+              default:
+                emit('\'' + selectorString + '\'' + qsInvalid);
+            }
+          // *** child-indexed & typed child-indexed pseudo-classes
+          // :nth-child, :nth-of-type, :nth-last-child, :nth-last-of-type
+          } else if ((match = selector.match(Patterns.treestruct))) {
+            match[1] = match[1].toLowerCase();
+            switch (match[1]) {
+              case 'nth-child':
+              case 'nth-of-type':
+              case 'nth-last-child':
+              case 'nth-last-of-type':
+                expr = /-of-type/i.test(match[1]);
+                if (match[1] && match[2]) {
+                  type = /last/i.test(match[1]);
+                  if (match[2] === 'n') {
+                    source = 'if(' + N + 'true){' + source + '}';
+                    break;
+                  } else if (match[2] === '1') {
+                    test = type ? 'next' : 'previous';
+                    source = expr
+                      ? 'n=e;o=e.localName;' +
+                          'while((n=n.' + test + 'ElementSibling)&&n.localName!=o);if(' + D + 'n){' + source + '}'
+                      : 'if(' + N + '!e.' + test + 'ElementSibling){' + source + '}';
+                    break;
+                  } else if (match[2] === 'even' || match[2] === '2n0' || match[2] === '2n+0' || match[2] === '2n') {
+                    test = 'n%2==0';
+                  } else if (match[2] === 'odd' || match[2] === '2n1' || match[2] === '2n+1') {
+                    test = 'n%2==1';
+                  } else {
+                    f = /n/i.test(match[2]);
+                    n = match[2].split('n');
+                    a = parseInt(n[0], 10) || 0;
+                    b = parseInt(n[1], 10) || 0;
+                    if (n[0] === '-') {
+                      a = -1;
+                    }
+                    if (n[0] === '+') {
+                      a = +1;
+                    }
+                    test = (b ? '(n' + (b > 0 ? '-' : '+') + Math.abs(b) + ')' : 'n') + '%' + a + '==0';
+                    test = a >= +1
+                      ? (f
+                          ? 'n>' + (b - 1) + (Math.abs(a) !== 1
+                            ? '&&' + test
+                            : '')
+                          : 'n==' + a)
+                      : a <= -1
+                        ? (f
+                            ? 'n<' + (b + 1) + (Math.abs(a) !== 1
+                              ? '&&' + test
+                              : '')
+                            : 'n==' + a)
+                        : a === 0
+                          ? (n[0]
+                              ? 'n==' + b
+                              : 'n>' + (b - 1))
+                          : 'false';
+                  }
+                  expr = expr ? 'OfType' : 'Element';
+                  type = type ? 'true' : 'false';
+                  source = 'n=s.nth' + expr + '(e,' + type + ');if(' + N + '(' + test + ')){' + source + '}';
+                } else {
+                  emit('\'' + selectorString + '\'' + qsInvalid);
+                }
+                break;
+              default:
+                emit('\'' + selectorString + '\'' + qsInvalid);
+            }
+          // *** logical combination pseudo-classes
+          // :is( s1, [ s2, ... ]), :not( s1, [ s2, ... ])
+          } else if ((match = selector.match(Patterns.logicalsel))) {
+            match[1] = match[1].toLowerCase();
+            expr = match[2].replace(REX.CommaGroup, ',').replace(REX.TrimSpaces, '');
+            switch (match[1]) {
+              // FIXME:
+              case 'is':
+              case 'where':
+              case 'matches':
+                source = 'if(s.match("' + expr.replace(/\x22/g, '\\"') + '",e)){' + source + '}';
+                break;
+              // FIXME:
+              case 'not':
+                source = 'if(!s.match("' + expr.replace(/\x22/g, '\\"') + '",e)){' + source + '}';
+                break;
+              // FIXME:
+              case 'has':
+                // clear cache
+                matchResolvers = {};
+                source = 'if(e.querySelector(":scope ' + expr.replace(/\x22/g, '\\"') + '")){' + source + '}';
+                break;
+              default:
+                emit('\'' + selectorString + '\'' + qsInvalid);
+            }
+          // *** location pseudo-classes
+          // :any-link, :link, :visited, :target
+          } else if ((match = selector.match(Patterns.locationpc))) {
+            match[1] = match[1].toLowerCase();
+            switch (match[1]) {
+              case 'any-link':
+                source = 'if(' + N + '(/^a|area$/i.test(e.localName)&&e.hasAttribute("href")||e.visited)){' + source + '}';
+                break;
+              case 'link':
+                source = 'if(' + N + '(/^a|area$/i.test(e.localName)&&e.hasAttribute("href"))){' + source + '}';
+                break;
+              // FIXME:
+              case 'visited':
+                source = 'if(' + N + '(/^a|area$/i.test(e.localName)&&e.hasAttribute("href")&&e.visited)){' + source + '}';
+                break;
+              case 'target':
+                source = 'if(s.isTarget(e)){' + source + '}';
+                break;
+              default:
+                emit('\'' + selectorString + '\'' + qsInvalid);
+            }
+          // *** user interface and form pseudo-classes
+          // :enabled, :disabled, :read-only, :read-write, :placeholder-shown, :default
+          } else if ((match = selector.match(Patterns.inputstate))) {
+            match[1] = match[1].toLowerCase();
+            switch (match[1]) {
+              // FIXME: lacks custom element support
+              case 'enabled':
+                source = 'if((("form" in e||/^optgroup$/i.test(e.localName))&&"disabled" in e &&e.disabled===false' +
+                  ')){' + source + '}';
+                break;
+              // FIXME: lacks custom element support
+              case 'disabled':
+                // https://html.spec.whatwg.org/#enabling-and-disabling-form-controls:-the-disabled-attribute
+                source = 'if((("form" in e||/^optgroup$/i.test(e.localName))&&"disabled" in e)){' +
+                  // F is true if any of the fieldset elements in the ancestry chain has the disabled attribute specified
+                  // L is true if the first legend element of the fieldset contains the element
+                  'var x=0,N=[],F=false,L=false;' +
+                  'if(!(/^(optgroup|option)$/i.test(e.localName))){' +
+                    'n=e.parentElement;' +
+                    'while(n){' +
+                      'if(n.localName==="fieldset"){' +
+                        'N[x++]=n;' +
+                        'if(n.disabled===true){' +
+                          'F=true;' +
+                          'break;' +
+                        '}' +
+                      '}' +
+                      'n=n.parentElement;' +
+                    '}' +
+                    'for(var x=0;x<N.length;x++){' +
+                      'if((n=s.first("legend",N[x]))&&n.contains(e)){' +
+                        'L=true;' +
+                        'break;' +
+                      '}' +
+                    '}' +
+                  '}' +
+                  'if(e.disabled===true||(F&&!L)){' + source + '}}';
+                break;
+              case 'read-only':
+                source =
+                  'if(' +
+                    '(/^textarea$/i.test(e.localName)&&(e.readOnly||e.disabled))||' +
+                    '(/^input$/i.test(e.localName)&&("|date|datetime-local|email|month|number|password|search|tel|text|time|url|week|".includes("|"+e.type+"|")?(e.readOnly||e.disabled):true))||' +
+                    '(!/^(?:input|textarea)$/i.test(e.localName) && !s.isContentEditable(e))' +
+                  '){' + source + '}';
+                break;
+              case 'read-write':
+                source =
+                  'if(' +
+                    '(/^textarea$/i.test(e.localName)&&!e.readOnly&&!e.disabled)||' +
+                    '(/^input$/i.test(e.localName)&&"|date|datetime-local|email|month|number|password|search|tel|text|time|url|week|".includes("|"+e.type+"|")&&!e.readOnly&&!e.disabled)||' +
+                    '(!/^(?:input|textarea)$/i.test(e.localName) && s.isContentEditable(e))' +
+                  '){' + source + '}';
+                break;
+              // FIXME:
+              case 'placeholder-shown':
+                source =
+                  'if((' +
+                    '(/^input|textarea$/i.test(e.localName))&&e.hasAttribute("placeholder")&&' +
+                    '("|textarea|password|number|search|email|text|tel|url|".includes("|"+e.type+"|"))&&' +
+                    '(!s.match(":focus",e))' +
+                  ')){' + source + '}';
+                break;
+              // FIXME:
+              case 'default':
+                source =
+                  'if(("form" in e && e.form)){' +
+                    'var x=0;n=[];' +
+                    'if(e.type=="image")n=e.form.getElementsByTagName("input");' +
+                    'if(e.type=="submit")n=e.form.elements;' +
+                    'while(n[x]&&e!==n[x]){' +
+                      'if(n[x].type=="image")break;' +
+                      'if(n[x].type=="submit")break;' +
+                      'x++;' +
+                    '}' +
+                  '}' +
+                  'if((e.form&&(e===n[x]&&"|image|submit|".includes("|"+e.type+"|"))||' +
+                    '((/^option$/i.test(e.localName))&&e.defaultSelected)||' +
+                    '(("|radio|checkbox|".includes("|"+e.type+"|"))&&e.defaultChecked)' +
+                  ')){' + source + '}';
+                break;
+              default:
+                emit('\'' + selector_string + '\'' + qsInvalid);
+                break;
+            }
+          // *** input pseudo-classes (for form validation)
+          // :checked, :indeterminate, :valid, :invalid, :in-range, :out-of-range, :required, :optional
+          } else if ((match = selector.match(Patterns.inputvalue))) {
+            match[1] = match[1].toLowerCase();
+            switch (match[1]) {
+              case 'checked':
+                source = 'if(' + N + '(/^input$/i.test(e.localName)&&' +
+                  '("|radio|checkbox|".includes("|"+e.type+"|")&&e.checked)||' +
+                  '(/^option$/i.test(e.localName)&&(e.selected||e.checked))' +
+                  ')){' + source + '}';
+                break;
+              case 'indeterminate':
+                source = 'if(s.isIndeterminate(e)){' + source + '}';
+                break;
+              // FIXME:
+              case 'required':
+                source =
+                  'if(' + N +
+                    '(/^input|select|textarea$/i.test(e.localName)&&e.required)' +
+                  '){' + source + '}';
+                break;
+              // FIXME:
+              case 'optional':
+                source =
+                  'if(' + N +
+                    '(/^input|select|textarea$/i.test(e.localName)&&!e.required)' +
+                  '){' + source + '}';
+                break;
+              // FIXME:
+              case 'invalid':
+                source =
+                  'if(' + N + '((' +
+                    '(/^form$/i.test(e.localName)&&!e.noValidate)||' +
+                    '(e.willValidate&&!e.formNoValidate))&&!e.checkValidity())||' +
+                    '(/^fieldset$/i.test(e.localName)&&s.first(":invalid",e))' +
+                  '){' + source + '}';
+                break;
+              // FIXME:
+              case 'valid':
+                source =
+                  'if(' + N + '((' +
+                    '(/^form$/i.test(e.localName)&&!e.noValidate)||' +
+                    '(e.willValidate&&!e.formNoValidate))&&e.checkValidity())||' +
+                    '(/^fieldset$/i.test(e.localName)&&s.first(":valid",e))' +
+                  '){' + source + '}';
+                break;
+              // FIXME:
+              case 'in-range':
+                source =
+                  'if(' + N +
+                    '(/^input$/i.test(e.localName))&&' +
+                    '(e.willValidate&&!e.formNoValidate)&&' +
+                    '(!e.validity.rangeUnderflow&&!e.validity.rangeOverflow)&&' +
+                    '("|date|datetime-local|month|number|range|time|week|".includes("|"+e.type+"|"))&&' +
+                    '("range"==e.type||e.getAttribute("min")||e.getAttribute("max"))' +
+                  '){' + source + '}';
+                break;
+              // FIXME:
+              case 'out-of-range':
+                source =
+                  'if(' + N +
+                    '(/^input$/i.test(e.localName))&&' +
+                    '(e.willValidate&&!e.formNoValidate)&&' +
+                    '(e.validity.rangeUnderflow||e.validity.rangeOverflow)&&' +
+                    '("|date|datetime-local|month|number|range|time|week|".includes("|"+e.type+"|"))&&' +
+                    '("range"==e.type||e.getAttribute("min")||e.getAttribute("max"))' +
+                  '){' + source + '}';
+                break;
+              default:
+                emit('\'' + selectorString + '\'' + qsInvalid);
+            }
+          // allow pseudo-elements starting with single colon (:)
+          // :after, :before, :first-letter, :first-line
+          // assert: e.type is in double-colon format, like ::after
+          } else if ((match = selector.match(Patterns.pseudoSng))) {
+            source = 'if(e.element&&e.type.toLowerCase()=="' +
+              ':' + match[0].toLowerCase() + '"){e=e.element;' + source + '}';
+          // allow pseudo-elements starting with double colon (::)
+          // ::after, ::before, ::marker, ::placeholder, ::inactive-selection, ::selection, ::-webkit-<foo-bar>
+          // assert: e.type is in double-colon format, like ::after
+          } else if ((match = selector.match(Patterns.pseudoDbl))) {
+            source = 'if(e.element&&e.type.toLowerCase()=="' +
+              match[0].toLowerCase() + '"){e=e.element;' + source + '}';
+          // placeholder for parsed only no-op selectors
+          } else if ((match = selector.match(Patterns.pseudoNop))) {
+            source = 'if(' + N + 'false' + '){' + source + '}';
+          } else {
+            // reset
+            expr = false;
+            status = false;
+            // process registered selector extensions
+            for (expr in Selectors) {
+              if ((match = selector.match(Selectors[expr].Expression))) {
+                result = Selectors[expr].Callback(match, source, mode, callback);
+                if ('match' in result) {
+                  match = result.match;
+                }
+                vars = result.modvar;
+                if (mode) {
+                  // add extra select() vars
+                  vars && !S_VARS.includes(vars) && S_VARS.push(vars);
+                } else {
+                  // add extra match() vars
+                  vars && M_VARS.includes(vars) && M_VARS.push(vars);
+                }
+                // extension source code
+                source = result.source;
+                // extension status code
+                status = result.status;
+                // break on status error
+                if (status) { break; }
+              }
+            }
+            if (!status) {
+              emit('unknown pseudo-class selector \'' + selector + '\'');
+              return '';
+            }
+            if (!expr) {
+              emit('unknown token in selector \'' + selector + '\'');
+              return '';
+            }
+          }
+          break;
+        default:
+          selectorRecursion = false;
+          emit('\'' + selectorString + '\'' + qsInvalid);
+      }
+      // end of switch symbol
+      if (!selectorRecursion) {
+        break;
+      }
+      if (!match) {
+        emit('\'' + selectorString + '\'' + qsInvalid);
+        return '';
+      }
+
+      // pop last component
+      selector = match.pop();
+    }
+    // end of while selector
+
+    return source;
+  };
+
+  // compile groups or single selector strings into
+  // executable functions for matching or selecting
+  const compile = function (selector, mode, callback) {
+    let head = ''; let loop = ''; let macro = ''; let source = ''; let vars = '';
+
+    // 'mode' can be boolean or null
+    // true = select / false = match
+    // null to use collection.item()
+    switch (mode) {
+      case true:
+        if (selectLambdas[selector]) {
+          return selectLambdas[selector];
+        }
+        macro = S_BODY + (callback ? S_TEST : '') + S_TAIL;
+        head = S_HEAD;
+        loop = S_LOOP;
+        break;
+      case false:
+        if (matchLambdas[selector]) {
+          return matchLambdas[selector];
+        }
+        macro = M_BODY + (callback ? M_TEST : '') + M_TAIL;
+        head = M_HEAD;
+        loop = M_LOOP;
+        break;
+      case null:
+        if (selectLambdas[selector]) {
+          return selectLambdas[selector];
+        }
+        macro = N_BODY + (callback ? N_TEST : '') + S_TAIL;
+        head = S_HEAD;
+        loop = N_LOOP;
+        break;
+      default:
+    }
+
+    source = compileSelector(selector, macro, mode, callback);
+
+    loop += (mode || mode === null) ? '{' + source + '}' : source;
+
+    if ((mode || mode === null) && selector.includes(':nth')) {
+      loop += reNthElem.test(selector) ? 's.nthElement(null, 2);' : '';
+      loop += reNthType.test(selector) ? 's.nthOfType(null, 2);' : '';
+    }
+
+    if (S_VARS[0] || M_VARS[0]) {
+      vars = ',' + (S_VARS.join(',') || M_VARS.join(','));
+      S_VARS = [];
+      M_VARS = [];
+    }
+
+    const factory = Function('s', F_INIT + '{' + head + vars + ';' + loop + 'return r;}')(Snapshot);
+
+    return mode || mode === null ? (selectLambdas[selector] = factory) : (matchLambdas[selector] = factory);
+  };
+
+  // optimize selectors avoiding duplicated checks
+  const optimize = function (selector, token) {
+    const index = token.index;
+    const length = token[1].length + token[2].length;
+    return selector.slice(0, index) +
+      (' >+~'.indexOf(selector.charAt(index - 1)) > -1
+        ? (':['.indexOf(selector.charAt(index + length + 1)) > -1
+            ? '*'
+            : '')
+        : '') + selector.slice(index + length - (token[1] === '*' ? 1 : 0));
+  };
+
+  // prepare factory resolvers and closure collections
+  const collect = function (selectors, context, callback) {
+    let i;
+    let l;
+    const seen = { };
+    let token = ['', '*', '*'];
+    const optimized = selectors;
+    const factory = [];
+    const htmlset = [];
+    const nodeset = [];
+    let results = [];
+    let type;
+
+    for (i = 0, l = selectors.length; l > i; ++i) {
+      if (!seen[selectors[i]] && (seen[selectors[i]] = true)) {
+        type = selectors[i].match(reOptimizer);
+        if (type && type[1] !== ':' && (token = type)) {
+          token[1] || (token[1] = '*');
+          optimized[i] = optimize(optimized[i], token);
+        } else {
+          token = ['', '*', '*'];
+        }
+      }
+
+      nodeset[i] = token[1] + token[2];
+      htmlset[i] = compat[token[1]](context, token[2]);
+      factory[i] = compile(optimized[i], true, null);
+
+      factory[i]
+        ? factory[i](htmlset[i](), callback, context, results)
+        : results.concat(htmlset[i]());
+    }
+
+    if (l > 1) {
+      results.sort(documentOrder);
+      hasDupes && (results = unique(results));
+    }
+
+    return {
+      callback,
+      context,
+      factory,
+      htmlset,
+      nodeset,
+      results
+    };
+  };
+
+  // replace ':scope' pseudo-class with element references
+  const makeref = function (selectors, element) {
+    // DOCUMENT_NODE (9)
+    if (element.nodeType === 9) {
+      element = element.documentElement;
+    }
+
+    return selectors.replace(/:scope/gi,
+      element.localName +
+        (element.id ? '#' + element.id : '') +
+        (element.className ? '.' + element.classList[0] : ''));
+  };
+
+  const matchAssert = function (f, element, callback) {
+    let r = false;
+    for (let i = 0, l = f.length; l > i; ++i) {
+      f[i](element, callback, null, false) && (r = true);
+    }
+    return r;
+  };
+
+  const matchCollect = function (selectors, callback) {
+    const f = [];
+    for (let i = 0, l = selectors.length; l > i; ++i) {
+      f[i] = compile(selectors[i], false, callback);
+    }
+    return { factory: f };
+  };
+
+  // equivalent of w3c 'matches' method
+  const match = function _matches(selectors, element, callback) {
+    let expressions;
+
+    if (element && !/:has\(/.test(selectors) && matchResolvers[selectors]) {
+      return matchAssert(matchResolvers[selectors].factory, element, callback);
+    }
+
+    lastMatched = selectors;
+
+    // arguments validation
+    if (arguments.length === 0) {
+      emit(qsNotArgs, 'TypeError');
+      return Config.VERBOSITY ? undefined : false;
+    } else if (arguments[0] === '') {
+      emit('\'\'' + qsInvalid);
+      return Config.VERBOSITY ? undefined : false;
+    }
+
+    // input NULL or UNDEFINED
+    if (typeof selectors !== 'string') {
+      selectors = '' + selectors;
+    }
+
+    if ((/:scope/i).test(selectors)) {
+      selectors = makeref(selectors, element);
+    }
+
+    // normalize input string
+    const parsed = selectors
+      .replace(/\0|\\$/g, '\ufffd')
+      .replace(REX.combineWSP, '\x20')
+      .replace(REX.pseudosWSP, '$1')
+      .replace(REX.tabCharWSP, '\t')
+      .replace(REX.commaGroup, ',')
+      .replace(REX.trimSpaces, '');
+
+    // parse, validate and split possible compound selectors
+    if ((expressions = parsed.match(reValidator)) && expressions.join('') === parsed) {
+      expressions = parsed.match(REX.splitGroup);
+      if (parsed[parsed.length - 1] === ',') {
+        emit(qsInvalid);
+        return Config.VERBOSITY ? undefined : false;
+      }
+    } else {
+      emit('\'' + selectors + '\'' + qsInvalid);
+      return Config.VERBOSITY ? undefined : false;
+    }
+
+    matchResolvers[selectors] = matchCollect(expressions, callback);
+
+    return matchAssert(matchResolvers[selectors].factory, element, callback);
+  };
+
+  // equivalent of w3c 'closest' method
+  const ancestor = function _closest(selectors, element, callback) {
+    if ((/:scope/i).test(selectors)) {
+      selectors = makeref(selectors, element);
+    }
+
+    while (element) {
+      if (match(selectors, element, callback)) break;
+      element = element.parentElement;
+    }
+    return element;
+  };
+
+  // equivalent of w3c 'querySelectorAll' method
+  const select = function _querySelectorAll(selectors, context, callback) {
+    let expressions; let nodes = []; let resolver;
+
+    context || (context = doc);
+
+    if (selectors) {
+      if ((resolver = selectResolvers[selectors])) {
+        if (resolver.context === context && resolver.callback === callback) {
+          const f = resolver.factory;
+          const h = resolver.htmlset;
+          const n = resolver.nodeset;
+          if (n.length > 1) {
+            const l = n.length;
+            for (let i = 0, l = n.length, list; l > i; ++i) {
+              list = compat[n[i][0]](context, n[i].slice(1))();
+              if (f[i] !== null) {
+                f[i](list, callback, context, nodes);
+              } else {
+                nodes = nodes.concat(list);
+              }
+            }
+            if (l > 1 && nodes.length > 1) {
+              nodes.sort(documentOrder);
+              hasDupes && (nodes = unique(nodes));
+            }
+          } else {
+            if (f[0]) {
+              nodes = f[0](h[0](), callback, context, nodes);
+            } else {
+              nodes = h[0]();
+            }
+          }
+          return typeof callback === 'function'
+            ? concatCall(nodes, callback)
+            : nodes;
+        }
+      }
+    }
+
+    lastSelected = selectors;
+
+    // arguments validation
+    if (arguments.length === 0) {
+      emit(qsNotArgs, 'TypeError');
+      return Config.VERBOSITY ? undefined : none;
+    } else if (arguments[0] === '') {
+      emit('\'\'' + qsInvalid);
+      return Config.VERBOSITY ? undefined : none;
+    } else if (lastContext !== context) {
+      lastContext = switchContext(context);
+    }
+
+    // input NULL or UNDEFINED
+    if (typeof selectors !== 'string') {
+      selectors = '' + selectors;
+    }
+
+    if ((/:scope/i).test(selectors)) {
+      selectors = makeref(selectors, context);
+    }
+
+    // normalize input string
+    const parsed = selectors
+      .replace(/\0|\\$/g, '\ufffd')
+      .replace(REX.combineWSP, '\x20')
+      .replace(REX.pseudosWSP, '$1')
+      .replace(REX.tabCharWSP, '\t')
+      .replace(REX.commaGroup, ',')
+      .replace(REX.trimSpaces, '');
+
+    // parse, validate and split possible compound selectors
+    if ((expressions = parsed.match(reValidator)) && expressions.join('') === parsed) {
+      expressions = parsed.match(REX.splitGroup);
+      if (parsed[parsed.length - 1] === ',') {
+        emit(qsInvalid);
+        return Config.VERBOSITY ? undefined : false;
+      }
+    } else {
+      emit('\'' + selectors + '\'' + qsInvalid);
+      return Config.VERBOSITY ? undefined : false;
+    }
+
+    // save/reuse factory and closure collection
+    selectResolvers[selectors] = collect(expressions, context, callback);
+
+    nodes = selectResolvers[selectors].results;
+
+    return typeof callback === 'function'
+      ? concatCall(nodes, callback)
+      : nodes;
+  };
+
+  // equivalent of w3c 'querySelector' method
+  const first = function _querySelector(selectors, context, callback) {
+    if (arguments.length === 0) {
+      emit(qsNotArgs, 'TypeError');
+    }
+    return select(selectors, context, typeof callback === 'function'
+      ? function firstMatch(element) {
+        callback(element);
+        return false;
+      }
+      : function firstMatch() {
+        return false;
+      }
+    )[0] || null;
+  };
+
+  // execute the engine initialization code
+  const initialize = function (d) {
+    setIdentifierSyntax();
+    lastContext = switchContext(d, true);
+    Snapshot.doc = doc;
+    Snapshot.from = doc;
+    Snapshot.byTag = byTag;
+    Snapshot.first = first;
+    Snapshot.match = match;
+    Snapshot.ancestor = ancestor;
+    Snapshot.nthOfType = nthOfType;
+    Snapshot.nthElement = nthElement;
+    Snapshot.hasAttributeNS = hasAttributeNS;
+    Snapshot.isTarget = isTarget;
+    Snapshot.isIndeterminate = isIndeterminate;
+    Snapshot.isContentEditable = isContentEditable;
+  };
+
+  initialize(doc);
+
+  // public exported methods/objects
+  const Dom = {
+    // exported engine methods
+    Version: version,
+    configure,
+    match,
+    closest: ancestor,
+    first,
+    select
+  };
+
+  return Dom;
+});
diff --git a/node_modules/@babel/code-frame/LICENSE b/node_modules/@babel/code-frame/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1
--- /dev/null
+++ b/node_modules/@babel/code-frame/LICENSE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@babel/code-frame/README.md b/node_modules/@babel/code-frame/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7160755113aaa771161a0626a7a9c7b6a99ac8d8
--- /dev/null
+++ b/node_modules/@babel/code-frame/README.md
@@ -0,0 +1,19 @@
+# @babel/code-frame
+
+> Generate errors that contain a code frame that point to source locations.
+
+See our website [@babel/code-frame](https://babeljs.io/docs/babel-code-frame) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/code-frame
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/code-frame --dev
+```
diff --git a/node_modules/@babel/code-frame/lib/index.js b/node_modules/@babel/code-frame/lib/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..9c5db40650ce1a02ad39ad125e1b32f01e4eea64
--- /dev/null
+++ b/node_modules/@babel/code-frame/lib/index.js
@@ -0,0 +1,217 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var picocolors = require('picocolors');
+var jsTokens = require('js-tokens');
+var helperValidatorIdentifier = require('@babel/helper-validator-identifier');
+
+function isColorSupported() {
+  return (typeof process === "object" && (process.env.FORCE_COLOR === "0" || process.env.FORCE_COLOR === "false") ? false : picocolors.isColorSupported
+  );
+}
+const compose = (f, g) => v => f(g(v));
+function buildDefs(colors) {
+  return {
+    keyword: colors.cyan,
+    capitalized: colors.yellow,
+    jsxIdentifier: colors.yellow,
+    punctuator: colors.yellow,
+    number: colors.magenta,
+    string: colors.green,
+    regex: colors.magenta,
+    comment: colors.gray,
+    invalid: compose(compose(colors.white, colors.bgRed), colors.bold),
+    gutter: colors.gray,
+    marker: compose(colors.red, colors.bold),
+    message: compose(colors.red, colors.bold),
+    reset: colors.reset
+  };
+}
+const defsOn = buildDefs(picocolors.createColors(true));
+const defsOff = buildDefs(picocolors.createColors(false));
+function getDefs(enabled) {
+  return enabled ? defsOn : defsOff;
+}
+
+const sometimesKeywords = new Set(["as", "async", "from", "get", "of", "set"]);
+const NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
+const BRACKET = /^[()[\]{}]$/;
+let tokenize;
+const JSX_TAG = /^[a-z][\w-]*$/i;
+const getTokenType = function (token, offset, text) {
+  if (token.type === "name") {
+    const tokenValue = token.value;
+    if (helperValidatorIdentifier.isKeyword(tokenValue) || helperValidatorIdentifier.isStrictReservedWord(tokenValue, true) || sometimesKeywords.has(tokenValue)) {
+      return "keyword";
+    }
+    if (JSX_TAG.test(tokenValue) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
+      return "jsxIdentifier";
+    }
+    const firstChar = String.fromCodePoint(tokenValue.codePointAt(0));
+    if (firstChar !== firstChar.toLowerCase()) {
+      return "capitalized";
+    }
+  }
+  if (token.type === "punctuator" && BRACKET.test(token.value)) {
+    return "bracket";
+  }
+  if (token.type === "invalid" && (token.value === "@" || token.value === "#")) {
+    return "punctuator";
+  }
+  return token.type;
+};
+tokenize = function* (text) {
+  let match;
+  while (match = jsTokens.default.exec(text)) {
+    const token = jsTokens.matchToToken(match);
+    yield {
+      type: getTokenType(token, match.index, text),
+      value: token.value
+    };
+  }
+};
+function highlight(text) {
+  if (text === "") return "";
+  const defs = getDefs(true);
+  let highlighted = "";
+  for (const {
+    type,
+    value
+  } of tokenize(text)) {
+    if (type in defs) {
+      highlighted += value.split(NEWLINE$1).map(str => defs[type](str)).join("\n");
+    } else {
+      highlighted += value;
+    }
+  }
+  return highlighted;
+}
+
+let deprecationWarningShown = false;
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+function getMarkerLines(loc, source, opts, startLineBaseZero) {
+  const startLoc = Object.assign({
+    column: 0,
+    line: -1
+  }, loc.start);
+  const endLoc = Object.assign({}, startLoc, loc.end);
+  const {
+    linesAbove = 2,
+    linesBelow = 3
+  } = opts || {};
+  const startLine = startLoc.line - startLineBaseZero;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line - startLineBaseZero;
+  const endColumn = endLoc.column;
+  let start = Math.max(startLine - (linesAbove + 1), 0);
+  let end = Math.min(source.length, endLine + linesBelow);
+  if (startLine === -1) {
+    start = 0;
+  }
+  if (endLine === -1) {
+    end = source.length;
+  }
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+  if (lineDiff) {
+    for (let i = 0; i <= lineDiff; i++) {
+      const lineNumber = i + startLine;
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (i === 0) {
+        const sourceLength = source[lineNumber - 1].length;
+        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - i].length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else {
+    if (startColumn === endColumn) {
+      if (startColumn) {
+        markerLines[startLine] = [startColumn, 0];
+      } else {
+        markerLines[startLine] = true;
+      }
+    } else {
+      markerLines[startLine] = [startColumn, endColumn - startColumn];
+    }
+  }
+  return {
+    start,
+    end,
+    markerLines
+  };
+}
+function codeFrameColumns(rawLines, loc, opts = {}) {
+  const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
+  const startLineBaseZero = (opts.startLine || 1) - 1;
+  const defs = getDefs(shouldHighlight);
+  const lines = rawLines.split(NEWLINE);
+  const {
+    start,
+    end,
+    markerLines
+  } = getMarkerLines(loc, lines, opts, startLineBaseZero);
+  const hasColumns = loc.start && typeof loc.start.column === "number";
+  const numberMaxWidth = String(end + startLineBaseZero).length;
+  const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;
+  let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const paddedNumber = ` ${number + startLineBaseZero}`.slice(-numberMaxWidth);
+    const gutter = ` ${paddedNumber} |`;
+    const hasMarker = markerLines[number];
+    const lastMarkerLine = !markerLines[number + 1];
+    if (hasMarker) {
+      let markerLine = "";
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = ["\n ", defs.gutter(gutter.replace(/\d/g, " ")), " ", markerSpacing, defs.marker("^").repeat(numberOfMarkers)].join("");
+        if (lastMarkerLine && opts.message) {
+          markerLine += " " + defs.message(opts.message);
+        }
+      }
+      return [defs.marker(">"), defs.gutter(gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    } else {
+      return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+    }
+  }).join("\n");
+  if (opts.message && !hasColumns) {
+    frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
+  }
+  if (shouldHighlight) {
+    return defs.reset(frame);
+  } else {
+    return frame;
+  }
+}
+function index (rawLines, lineNumber, colNumber, opts = {}) {
+  if (!deprecationWarningShown) {
+    deprecationWarningShown = true;
+    const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
+    if (process.emitWarning) {
+      process.emitWarning(message, "DeprecationWarning");
+    } else {
+      const deprecationError = new Error(message);
+      deprecationError.name = "DeprecationWarning";
+      console.warn(new Error(message));
+    }
+  }
+  colNumber = Math.max(colNumber, 0);
+  const location = {
+    start: {
+      column: colNumber,
+      line: lineNumber
+    }
+  };
+  return codeFrameColumns(rawLines, location, opts);
+}
+
+exports.codeFrameColumns = codeFrameColumns;
+exports.default = index;
+exports.highlight = highlight;
+//# sourceMappingURL=index.js.map
diff --git a/node_modules/@babel/code-frame/lib/index.js.map b/node_modules/@babel/code-frame/lib/index.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..6b85ae4957d58fb4115f8713e9c66639dffb50d9
--- /dev/null
+++ b/node_modules/@babel/code-frame/lib/index.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/defs.ts","../src/highlight.ts","../src/index.ts"],"sourcesContent":["import picocolors, { createColors } from \"picocolors\";\nimport type { Colors, Formatter } from \"picocolors/types\";\n\nexport function isColorSupported() {\n  return (\n    // See https://github.com/alexeyraspopov/picocolors/issues/62\n    typeof process === \"object\" &&\n      (process.env.FORCE_COLOR === \"0\" || process.env.FORCE_COLOR === \"false\")\n      ? false\n      : picocolors.isColorSupported\n  );\n}\n\nexport type InternalTokenType =\n  | \"keyword\"\n  | \"capitalized\"\n  | \"jsxIdentifier\"\n  | \"punctuator\"\n  | \"number\"\n  | \"string\"\n  | \"regex\"\n  | \"comment\"\n  | \"invalid\";\n\ntype UITokens = \"gutter\" | \"marker\" | \"message\";\n\nexport type Defs = Record<InternalTokenType | UITokens | \"reset\", Formatter>;\n\nconst compose: <T, U, V>(f: (gv: U) => V, g: (v: T) => U) => (v: T) => V =\n  (f, g) => v =>\n    f(g(v));\n\n/**\n * Styles for token types.\n */\nfunction buildDefs(colors: Colors): Defs {\n  return {\n    keyword: colors.cyan,\n    capitalized: colors.yellow,\n    jsxIdentifier: colors.yellow,\n    punctuator: colors.yellow,\n    number: colors.magenta,\n    string: colors.green,\n    regex: colors.magenta,\n    comment: colors.gray,\n    invalid: compose(compose(colors.white, colors.bgRed), colors.bold),\n\n    gutter: colors.gray,\n    marker: compose(colors.red, colors.bold),\n    message: compose(colors.red, colors.bold),\n\n    reset: colors.reset,\n  };\n}\n\nconst defsOn = buildDefs(createColors(true));\nconst defsOff = buildDefs(createColors(false));\n\nexport function getDefs(enabled: boolean): Defs {\n  return enabled ? defsOn : defsOff;\n}\n","import type { Token as JSToken, JSXToken } from \"js-tokens\";\nimport jsTokens from \"js-tokens\";\n// We inline this package\n// eslint-disable-next-line import/no-extraneous-dependencies\nimport * as charCodes from \"charcodes\";\n\nimport {\n  isStrictReservedWord,\n  isKeyword,\n} from \"@babel/helper-validator-identifier\";\n\nimport { getDefs, type InternalTokenType } from \"./defs.ts\";\n\n/**\n * Names that are always allowed as identifiers, but also appear as keywords\n * within certain syntactic productions.\n *\n * https://tc39.es/ecma262/#sec-keywords-and-reserved-words\n *\n * `target` has been omitted since it is very likely going to be a false\n * positive.\n */\nconst sometimesKeywords = new Set([\"as\", \"async\", \"from\", \"get\", \"of\", \"set\"]);\n\ntype Token = {\n  type: InternalTokenType | \"uncolored\";\n  value: string;\n};\n\n/**\n * RegExp to test for newlines in terminal.\n */\nconst NEWLINE = /\\r\\n|[\\n\\r\\u2028\\u2029]/;\n\n/**\n * RegExp to test for the three types of brackets.\n */\nconst BRACKET = /^[()[\\]{}]$/;\n\nlet tokenize: (\n  text: string,\n) => Generator<{ type: InternalTokenType | \"uncolored\"; value: string }>;\n\nif (process.env.BABEL_8_BREAKING) {\n  /**\n   * Get the type of token, specifying punctuator type.\n   */\n  const getTokenType = function (\n    token: JSToken | JSXToken,\n  ): InternalTokenType | \"uncolored\" {\n    if (token.type === \"IdentifierName\") {\n      const tokenValue = token.value;\n      if (\n        isKeyword(tokenValue) ||\n        isStrictReservedWord(tokenValue, true) ||\n        sometimesKeywords.has(tokenValue)\n      ) {\n        return \"keyword\";\n      }\n\n      const firstChar = tokenValue.charCodeAt(0);\n      if (firstChar < 128) {\n        // ASCII characters\n        if (\n          firstChar >= charCodes.uppercaseA &&\n          firstChar <= charCodes.uppercaseZ\n        ) {\n          return \"capitalized\";\n        }\n      } else {\n        const firstChar = String.fromCodePoint(tokenValue.codePointAt(0));\n        if (firstChar !== firstChar.toLowerCase()) {\n          return \"capitalized\";\n        }\n      }\n    }\n\n    if (token.type === \"Punctuator\" && BRACKET.test(token.value)) {\n      return \"uncolored\";\n    }\n\n    if (token.type === \"Invalid\" && token.value === \"@\") {\n      return \"punctuator\";\n    }\n\n    switch (token.type) {\n      case \"NumericLiteral\":\n        return \"number\";\n\n      case \"StringLiteral\":\n      case \"JSXString\":\n      case \"NoSubstitutionTemplate\":\n        return \"string\";\n\n      case \"RegularExpressionLiteral\":\n        return \"regex\";\n\n      case \"Punctuator\":\n      case \"JSXPunctuator\":\n        return \"punctuator\";\n\n      case \"MultiLineComment\":\n      case \"SingleLineComment\":\n        return \"comment\";\n\n      case \"Invalid\":\n      case \"JSXInvalid\":\n        return \"invalid\";\n\n      case \"JSXIdentifier\":\n        return \"jsxIdentifier\";\n\n      default:\n        return \"uncolored\";\n    }\n  };\n\n  /**\n   * Turn a string of JS into an array of objects.\n   */\n  tokenize = function* (text: string): Generator<Token> {\n    for (const token of jsTokens(text, { jsx: true })) {\n      switch (token.type) {\n        case \"TemplateHead\":\n          yield { type: \"string\", value: token.value.slice(0, -2) };\n          yield { type: \"punctuator\", value: \"${\" };\n          break;\n\n        case \"TemplateMiddle\":\n          yield { type: \"punctuator\", value: \"}\" };\n          yield { type: \"string\", value: token.value.slice(1, -2) };\n          yield { type: \"punctuator\", value: \"${\" };\n          break;\n\n        case \"TemplateTail\":\n          yield { type: \"punctuator\", value: \"}\" };\n          yield { type: \"string\", value: token.value.slice(1) };\n          break;\n\n        default:\n          yield {\n            type: getTokenType(token),\n            value: token.value,\n          };\n      }\n    }\n  };\n} else {\n  /**\n   * RegExp to test for what seems to be a JSX tag name.\n   */\n  const JSX_TAG = /^[a-z][\\w-]*$/i;\n\n  // The token here is defined in js-tokens@4. However we don't bother\n  // typing it since the whole block will be removed in Babel 8\n  const getTokenType = function (token: any, offset: number, text: string) {\n    if (token.type === \"name\") {\n      const tokenValue = token.value;\n      if (\n        isKeyword(tokenValue) ||\n        isStrictReservedWord(tokenValue, true) ||\n        sometimesKeywords.has(tokenValue)\n      ) {\n        return \"keyword\";\n      }\n\n      if (\n        JSX_TAG.test(tokenValue) &&\n        (text[offset - 1] === \"<\" || text.slice(offset - 2, offset) === \"</\")\n      ) {\n        return \"jsxIdentifier\";\n      }\n\n      const firstChar = String.fromCodePoint(tokenValue.codePointAt(0));\n      if (firstChar !== firstChar.toLowerCase()) {\n        return \"capitalized\";\n      }\n    }\n\n    if (token.type === \"punctuator\" && BRACKET.test(token.value)) {\n      return \"bracket\";\n    }\n\n    if (\n      token.type === \"invalid\" &&\n      (token.value === \"@\" || token.value === \"#\")\n    ) {\n      return \"punctuator\";\n    }\n\n    return token.type;\n  };\n\n  tokenize = function* (text: string) {\n    let match;\n    while ((match = (jsTokens as any).default.exec(text))) {\n      const token = (jsTokens as any).matchToToken(match);\n\n      yield {\n        type: getTokenType(token, match.index, text),\n        value: token.value,\n      };\n    }\n  };\n}\n\nexport function highlight(text: string) {\n  if (text === \"\") return \"\";\n\n  const defs = getDefs(true);\n\n  let highlighted = \"\";\n\n  for (const { type, value } of tokenize(text)) {\n    if (type in defs) {\n      highlighted += value\n        .split(NEWLINE)\n        .map(str => defs[type as InternalTokenType](str))\n        .join(\"\\n\");\n    } else {\n      highlighted += value;\n    }\n  }\n\n  return highlighted;\n}\n","import { getDefs, isColorSupported } from \"./defs.ts\";\nimport { highlight } from \"./highlight.ts\";\n\nexport { highlight };\n\nlet deprecationWarningShown = false;\n\ntype Location = {\n  column: number;\n  line: number;\n};\n\ntype NodeLocation = {\n  end?: Location;\n  start: Location;\n};\n\nexport interface Options {\n  /** Syntax highlight the code as JavaScript for terminals. default: false */\n  highlightCode?: boolean;\n  /**  The number of lines to show above the error. default: 2 */\n  linesAbove?: number;\n  /**  The number of lines to show below the error. default: 3 */\n  linesBelow?: number;\n  /** The line number corresponding to the first line in `rawLines`. default: 1 */\n  startLine?: number;\n  /**\n   * Forcibly syntax highlight the code as JavaScript (for non-terminals);\n   * overrides highlightCode.\n   * default: false\n   */\n  forceColor?: boolean;\n  /**\n   * Pass in a string to be displayed inline (if possible) next to the\n   * highlighted location in the code. If it can't be positioned inline,\n   * it will be placed above the code frame.\n   * default: nothing\n   */\n  message?: string;\n}\n\n/**\n * RegExp to test for newlines in terminal.\n */\n\nconst NEWLINE = /\\r\\n|[\\n\\r\\u2028\\u2029]/;\n\n/**\n * Extract what lines should be marked and highlighted.\n */\n\ntype MarkerLines = Record<number, true | [number, number]>;\n\nfunction getMarkerLines(\n  loc: NodeLocation,\n  source: string[],\n  opts: Options,\n  startLineBaseZero: number,\n): {\n  start: number;\n  end: number;\n  markerLines: MarkerLines;\n} {\n  const startLoc: Location = {\n    column: 0,\n    line: -1,\n    ...loc.start,\n  };\n  const endLoc: Location = {\n    ...startLoc,\n    ...loc.end,\n  };\n  const { linesAbove = 2, linesBelow = 3 } = opts || {};\n  const startLine = startLoc.line - startLineBaseZero;\n  const startColumn = startLoc.column;\n  const endLine = endLoc.line - startLineBaseZero;\n  const endColumn = endLoc.column;\n\n  let start = Math.max(startLine - (linesAbove + 1), 0);\n  let end = Math.min(source.length, endLine + linesBelow);\n\n  if (startLine === -1) {\n    start = 0;\n  }\n\n  if (endLine === -1) {\n    end = source.length;\n  }\n\n  const lineDiff = endLine - startLine;\n  const markerLines: MarkerLines = {};\n\n  if (lineDiff) {\n    for (let i = 0; i <= lineDiff; i++) {\n      const lineNumber = i + startLine;\n\n      if (!startColumn) {\n        markerLines[lineNumber] = true;\n      } else if (i === 0) {\n        const sourceLength = source[lineNumber - 1].length;\n\n        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];\n      } else if (i === lineDiff) {\n        markerLines[lineNumber] = [0, endColumn];\n      } else {\n        const sourceLength = source[lineNumber - i].length;\n\n        markerLines[lineNumber] = [0, sourceLength];\n      }\n    }\n  } else {\n    if (startColumn === endColumn) {\n      if (startColumn) {\n        markerLines[startLine] = [startColumn, 0];\n      } else {\n        markerLines[startLine] = true;\n      }\n    } else {\n      markerLines[startLine] = [startColumn, endColumn - startColumn];\n    }\n  }\n\n  return { start, end, markerLines };\n}\n\nexport function codeFrameColumns(\n  rawLines: string,\n  loc: NodeLocation,\n  opts: Options = {},\n): string {\n  const shouldHighlight =\n    opts.forceColor || (isColorSupported() && opts.highlightCode);\n  const startLineBaseZero = (opts.startLine || 1) - 1;\n  const defs = getDefs(shouldHighlight);\n\n  const lines = rawLines.split(NEWLINE);\n  const { start, end, markerLines } = getMarkerLines(\n    loc,\n    lines,\n    opts,\n    startLineBaseZero,\n  );\n  const hasColumns = loc.start && typeof loc.start.column === \"number\";\n\n  const numberMaxWidth = String(end + startLineBaseZero).length;\n\n  const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;\n\n  let frame = highlightedLines\n    .split(NEWLINE, end)\n    .slice(start, end)\n    .map((line, index) => {\n      const number = start + 1 + index;\n      const paddedNumber = ` ${number + startLineBaseZero}`.slice(\n        -numberMaxWidth,\n      );\n      const gutter = ` ${paddedNumber} |`;\n      const hasMarker = markerLines[number];\n      const lastMarkerLine = !markerLines[number + 1];\n      if (hasMarker) {\n        let markerLine = \"\";\n        if (Array.isArray(hasMarker)) {\n          const markerSpacing = line\n            .slice(0, Math.max(hasMarker[0] - 1, 0))\n            .replace(/[^\\t]/g, \" \");\n          const numberOfMarkers = hasMarker[1] || 1;\n\n          markerLine = [\n            \"\\n \",\n            defs.gutter(gutter.replace(/\\d/g, \" \")),\n            \" \",\n            markerSpacing,\n            defs.marker(\"^\").repeat(numberOfMarkers),\n          ].join(\"\");\n\n          if (lastMarkerLine && opts.message) {\n            markerLine += \" \" + defs.message(opts.message);\n          }\n        }\n        return [\n          defs.marker(\">\"),\n          defs.gutter(gutter),\n          line.length > 0 ? ` ${line}` : \"\",\n          markerLine,\n        ].join(\"\");\n      } else {\n        return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : \"\"}`;\n      }\n    })\n    .join(\"\\n\");\n\n  if (opts.message && !hasColumns) {\n    frame = `${\" \".repeat(numberMaxWidth + 1)}${opts.message}\\n${frame}`;\n  }\n\n  if (shouldHighlight) {\n    return defs.reset(frame);\n  } else {\n    return frame;\n  }\n}\n\n/**\n * Create a code frame, adding line numbers, code highlighting, and pointing to a given position.\n */\n\nexport default function (\n  rawLines: string,\n  lineNumber: number,\n  colNumber?: number | null,\n  opts: Options = {},\n): string {\n  if (!deprecationWarningShown) {\n    deprecationWarningShown = true;\n\n    const message =\n      \"Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.\";\n\n    if (process.emitWarning) {\n      // A string is directly supplied to emitWarning, because when supplying an\n      // Error object node throws in the tests because of different contexts\n      process.emitWarning(message, \"DeprecationWarning\");\n    } else {\n      const deprecationError = new Error(message);\n      deprecationError.name = \"DeprecationWarning\";\n      console.warn(new Error(message));\n    }\n  }\n\n  colNumber = Math.max(colNumber, 0);\n\n  const location: NodeLocation = {\n    start: { column: colNumber, line: lineNumber },\n  };\n\n  return codeFrameColumns(rawLines, location, opts);\n}\n"],"names":["isColorSupported","process","env","FORCE_COLOR","picocolors","compose","f","g","v","buildDefs","colors","keyword","cyan","capitalized","yellow","jsxIdentifier","punctuator","number","magenta","string","green","regex","comment","gray","invalid","white","bgRed","bold","gutter","marker","red","message","reset","defsOn","createColors","defsOff","getDefs","enabled","sometimesKeywords","Set","NEWLINE","BRACKET","tokenize","JSX_TAG","getTokenType","token","offset","text","type","tokenValue","value","isKeyword","isStrictReservedWord","has","test","slice","firstChar","String","fromCodePoint","codePointAt","toLowerCase","match","jsTokens","default","exec","matchToToken","index","highlight","defs","highlighted","split","map","str","join","deprecationWarningShown","getMarkerLines","loc","source","opts","startLineBaseZero","startLoc","Object","assign","column","line","start","endLoc","end","linesAbove","linesBelow","startLine","startColumn","endLine","endColumn","Math","max","min","length","lineDiff","markerLines","i","lineNumber","sourceLength","codeFrameColumns","rawLines","shouldHighlight","forceColor","highlightCode","lines","hasColumns","numberMaxWidth","highlightedLines","frame","paddedNumber","hasMarker","lastMarkerLine","markerLine","Array","isArray","markerSpacing","replace","numberOfMarkers","repeat","colNumber","emitWarning","deprecationError","Error","name","console","warn","location"],"mappings":"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"}
\ No newline at end of file
diff --git a/node_modules/@babel/code-frame/package.json b/node_modules/@babel/code-frame/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..1f21a379df39479bc38dedc221ef6d18927cf0df
--- /dev/null
+++ b/node_modules/@babel/code-frame/package.json
@@ -0,0 +1,32 @@
+{
+  "name": "@babel/code-frame",
+  "version": "7.29.7",
+  "description": "Generate errors that contain a code frame that point to source locations.",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-code-frame",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-code-frame"
+  },
+  "main": "./lib/index.js",
+  "dependencies": {
+    "@babel/helper-validator-identifier": "^7.29.7",
+    "js-tokens": "^4.0.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "charcodes": "^0.2.0",
+    "import-meta-resolve": "^4.1.0",
+    "strip-ansi": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}
\ No newline at end of file
diff --git a/node_modules/@babel/compat-data/LICENSE b/node_modules/@babel/compat-data/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1
--- /dev/null
+++ b/node_modules/@babel/compat-data/LICENSE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@babel/compat-data/README.md b/node_modules/@babel/compat-data/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c19189872ec7139957f70c5f933ca0572db8d6a1
--- /dev/null
+++ b/node_modules/@babel/compat-data/README.md
@@ -0,0 +1,19 @@
+# @babel/compat-data
+
+> The compat-data to determine required Babel plugins
+
+See our website [@babel/compat-data](https://babeljs.io/docs/babel-compat-data) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/compat-data
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/compat-data
+```
diff --git a/node_modules/@babel/compat-data/corejs2-built-ins.js b/node_modules/@babel/compat-data/corejs2-built-ins.js
new file mode 100644
index 0000000000000000000000000000000000000000..ed19e0b8a4ffd6bf191602c04d7c9308038f5562
--- /dev/null
+++ b/node_modules/@babel/compat-data/corejs2-built-ins.js
@@ -0,0 +1,2 @@
+// Todo (Babel 8): remove this file as Babel 8 drop support of core-js 2
+module.exports = require("./data/corejs2-built-ins.json");
diff --git a/node_modules/@babel/compat-data/corejs3-shipped-proposals.js b/node_modules/@babel/compat-data/corejs3-shipped-proposals.js
new file mode 100644
index 0000000000000000000000000000000000000000..7909b8c46d3717def2168c9a1e8cc6a068b29541
--- /dev/null
+++ b/node_modules/@babel/compat-data/corejs3-shipped-proposals.js
@@ -0,0 +1,2 @@
+// Todo (Babel 8): remove this file now that it is included in babel-plugin-polyfill-corejs3
+module.exports = require("./data/corejs3-shipped-proposals.json");
diff --git a/node_modules/@babel/compat-data/data/corejs2-built-ins.json b/node_modules/@babel/compat-data/data/corejs2-built-ins.json
new file mode 100644
index 0000000000000000000000000000000000000000..c7fd1889bddc30127e94be2bc035794866cd3871
--- /dev/null
+++ b/node_modules/@babel/compat-data/data/corejs2-built-ins.json
@@ -0,0 +1,2120 @@
+{
+  "es6.array.copy-within": {
+    "chrome": "45",
+    "opera": "32",
+    "edge": "12",
+    "firefox": "32",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.31"
+  },
+  "es6.array.every": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.array.fill": {
+    "chrome": "45",
+    "opera": "32",
+    "edge": "12",
+    "firefox": "31",
+    "safari": "7.1",
+    "node": "4",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.31"
+  },
+  "es6.array.filter": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.array.find": {
+    "chrome": "45",
+    "opera": "32",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "4",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.31"
+  },
+  "es6.array.find-index": {
+    "chrome": "45",
+    "opera": "32",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "4",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.31"
+  },
+  "es7.array.flat-map": {
+    "chrome": "69",
+    "opera": "56",
+    "edge": "79",
+    "firefox": "62",
+    "safari": "12",
+    "node": "11",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "10",
+    "rhino": "1.7.15",
+    "opera_mobile": "48",
+    "electron": "4.0"
+  },
+  "es6.array.for-each": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.array.from": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "15",
+    "firefox": "36",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.7.15",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es7.array.includes": {
+    "chrome": "47",
+    "opera": "34",
+    "edge": "14",
+    "firefox": "102",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "34",
+    "electron": "0.36"
+  },
+  "es6.array.index-of": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.array.is-array": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "4",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.array.iterator": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "12",
+    "firefox": "60",
+    "safari": "9",
+    "node": "10",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "9",
+    "rhino": "1.7.13",
+    "opera_mobile": "47",
+    "electron": "3.0"
+  },
+  "es6.array.last-index-of": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.array.map": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.array.of": {
+    "chrome": "45",
+    "opera": "32",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.31"
+  },
+  "es6.array.reduce": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "3",
+    "safari": "4",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.array.reduce-right": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "3",
+    "safari": "4",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.array.slice": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.array.some": {
+    "chrome": "5",
+    "opera": "10.10",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.array.sort": {
+    "chrome": "63",
+    "opera": "50",
+    "edge": "12",
+    "firefox": "5",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ie": "9",
+    "ios": "12",
+    "samsung": "8",
+    "rhino": "1.7.13",
+    "opera_mobile": "46",
+    "electron": "3.0"
+  },
+  "es6.array.species": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.7.15",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.date.now": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "4",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.date.to-iso-string": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "3.5",
+    "safari": "4",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.date.to-json": {
+    "chrome": "5",
+    "opera": "12.10",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "10",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "10",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "12.1",
+    "electron": "0.20"
+  },
+  "es6.date.to-primitive": {
+    "chrome": "47",
+    "opera": "34",
+    "edge": "15",
+    "firefox": "44",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "34",
+    "electron": "0.36"
+  },
+  "es6.date.to-string": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "10",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.function.bind": {
+    "chrome": "7",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "5.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "12",
+    "electron": "0.20"
+  },
+  "es6.function.has-instance": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "15",
+    "firefox": "50",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.function.name": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "14",
+    "firefox": "2",
+    "safari": "4",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es6.map": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.math.acosh": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.asinh": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.atanh": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.cbrt": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.clz32": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "31",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.cosh": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.expm1": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.fround": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "26",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.hypot": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "27",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.imul": {
+    "chrome": "30",
+    "opera": "17",
+    "edge": "12",
+    "firefox": "23",
+    "safari": "7",
+    "node": "0.12",
+    "deno": "1",
+    "android": "4.4",
+    "ios": "7",
+    "samsung": "2",
+    "rhino": "1.7.13",
+    "opera_mobile": "18",
+    "electron": "0.20"
+  },
+  "es6.math.log1p": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.log10": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.log2": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.sign": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.sinh": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.tanh": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.math.trunc": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "7.1",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.number.constructor": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "36",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "rhino": "1.7.13",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "es6.number.epsilon": {
+    "chrome": "34",
+    "opera": "21",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "2",
+    "rhino": "1.7.14",
+    "opera_mobile": "21",
+    "electron": "0.20"
+  },
+  "es6.number.is-finite": {
+    "chrome": "19",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "16",
+    "safari": "9",
+    "node": "0.8",
+    "deno": "1",
+    "android": "4.1",
+    "ios": "9",
+    "samsung": "1.5",
+    "rhino": "1.7.13",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.number.is-integer": {
+    "chrome": "34",
+    "opera": "21",
+    "edge": "12",
+    "firefox": "16",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "2",
+    "rhino": "1.7.13",
+    "opera_mobile": "21",
+    "electron": "0.20"
+  },
+  "es6.number.is-nan": {
+    "chrome": "19",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "15",
+    "safari": "9",
+    "node": "0.8",
+    "deno": "1",
+    "android": "4.1",
+    "ios": "9",
+    "samsung": "1.5",
+    "rhino": "1.7.13",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.number.is-safe-integer": {
+    "chrome": "34",
+    "opera": "21",
+    "edge": "12",
+    "firefox": "32",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "2",
+    "rhino": "1.7.13",
+    "opera_mobile": "21",
+    "electron": "0.20"
+  },
+  "es6.number.max-safe-integer": {
+    "chrome": "34",
+    "opera": "21",
+    "edge": "12",
+    "firefox": "31",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "2",
+    "rhino": "1.7.13",
+    "opera_mobile": "21",
+    "electron": "0.20"
+  },
+  "es6.number.min-safe-integer": {
+    "chrome": "34",
+    "opera": "21",
+    "edge": "12",
+    "firefox": "31",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "2",
+    "rhino": "1.7.13",
+    "opera_mobile": "21",
+    "electron": "0.20"
+  },
+  "es6.number.parse-float": {
+    "chrome": "34",
+    "opera": "21",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "2",
+    "rhino": "1.7.14",
+    "opera_mobile": "21",
+    "electron": "0.20"
+  },
+  "es6.number.parse-int": {
+    "chrome": "34",
+    "opera": "21",
+    "edge": "12",
+    "firefox": "25",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "2",
+    "rhino": "1.7.14",
+    "opera_mobile": "21",
+    "electron": "0.20"
+  },
+  "es6.object.assign": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "13",
+    "firefox": "36",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.object.create": {
+    "chrome": "5",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "4",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "12",
+    "electron": "0.20"
+  },
+  "es7.object.define-getter": {
+    "chrome": "62",
+    "opera": "49",
+    "edge": "16",
+    "firefox": "48",
+    "safari": "9",
+    "node": "8.10",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "8",
+    "opera_mobile": "46",
+    "electron": "3.0"
+  },
+  "es7.object.define-setter": {
+    "chrome": "62",
+    "opera": "49",
+    "edge": "16",
+    "firefox": "48",
+    "safari": "9",
+    "node": "8.10",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "8",
+    "opera_mobile": "46",
+    "electron": "3.0"
+  },
+  "es6.object.define-property": {
+    "chrome": "5",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "5.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "12",
+    "electron": "0.20"
+  },
+  "es6.object.define-properties": {
+    "chrome": "5",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "4",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "12",
+    "electron": "0.20"
+  },
+  "es7.object.entries": {
+    "chrome": "54",
+    "opera": "41",
+    "edge": "14",
+    "firefox": "47",
+    "safari": "10.1",
+    "node": "7",
+    "deno": "1",
+    "ios": "10.3",
+    "samsung": "6",
+    "rhino": "1.7.14",
+    "opera_mobile": "41",
+    "electron": "1.4"
+  },
+  "es6.object.freeze": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.30"
+  },
+  "es6.object.get-own-property-descriptor": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.30"
+  },
+  "es7.object.get-own-property-descriptors": {
+    "chrome": "54",
+    "opera": "41",
+    "edge": "15",
+    "firefox": "50",
+    "safari": "10.1",
+    "node": "7",
+    "deno": "1",
+    "ios": "10.3",
+    "samsung": "6",
+    "rhino": "1.8",
+    "opera_mobile": "41",
+    "electron": "1.4"
+  },
+  "es6.object.get-own-property-names": {
+    "chrome": "40",
+    "opera": "27",
+    "edge": "12",
+    "firefox": "33",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "rhino": "1.7.13",
+    "opera_mobile": "27",
+    "electron": "0.21"
+  },
+  "es6.object.get-prototype-of": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.30"
+  },
+  "es7.object.lookup-getter": {
+    "chrome": "62",
+    "opera": "49",
+    "edge": "79",
+    "firefox": "36",
+    "safari": "9",
+    "node": "8.10",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "8",
+    "opera_mobile": "46",
+    "electron": "3.0"
+  },
+  "es7.object.lookup-setter": {
+    "chrome": "62",
+    "opera": "49",
+    "edge": "79",
+    "firefox": "36",
+    "safari": "9",
+    "node": "8.10",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "8",
+    "opera_mobile": "46",
+    "electron": "3.0"
+  },
+  "es6.object.prevent-extensions": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.30"
+  },
+  "es6.object.to-string": {
+    "chrome": "57",
+    "opera": "44",
+    "edge": "15",
+    "firefox": "51",
+    "safari": "10",
+    "node": "8",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "7",
+    "rhino": "1.9",
+    "opera_mobile": "43",
+    "electron": "1.7"
+  },
+  "es6.object.is": {
+    "chrome": "19",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "22",
+    "safari": "9",
+    "node": "0.8",
+    "deno": "1",
+    "android": "4.1",
+    "ios": "9",
+    "samsung": "1.5",
+    "rhino": "1.7.13",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.object.is-frozen": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.30"
+  },
+  "es6.object.is-sealed": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.30"
+  },
+  "es6.object.is-extensible": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.30"
+  },
+  "es6.object.keys": {
+    "chrome": "40",
+    "opera": "27",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "rhino": "1.7.13",
+    "opera_mobile": "27",
+    "electron": "0.21"
+  },
+  "es6.object.seal": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "35",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.13",
+    "opera_mobile": "32",
+    "electron": "0.30"
+  },
+  "es6.object.set-prototype-of": {
+    "chrome": "34",
+    "opera": "21",
+    "edge": "12",
+    "firefox": "31",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ie": "11",
+    "ios": "9",
+    "samsung": "2",
+    "rhino": "1.7.13",
+    "opera_mobile": "21",
+    "electron": "0.20"
+  },
+  "es7.object.values": {
+    "chrome": "54",
+    "opera": "41",
+    "edge": "14",
+    "firefox": "47",
+    "safari": "10.1",
+    "node": "7",
+    "deno": "1",
+    "ios": "10.3",
+    "samsung": "6",
+    "rhino": "1.7.14",
+    "opera_mobile": "41",
+    "electron": "1.4"
+  },
+  "es6.promise": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "14",
+    "firefox": "45",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.7.15",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es7.promise.finally": {
+    "chrome": "63",
+    "opera": "50",
+    "edge": "18",
+    "firefox": "58",
+    "safari": "11.1",
+    "node": "10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "8",
+    "opera_mobile": "46",
+    "electron": "3.0"
+  },
+  "es6.reflect.apply": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.construct": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "13",
+    "firefox": "49",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.define-property": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "13",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.delete-property": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.get": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.get-own-property-descriptor": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.get-prototype-of": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.has": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.is-extensible": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.own-keys": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.prevent-extensions": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.set": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.reflect.set-prototype-of": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "42",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.regexp.constructor": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "79",
+    "firefox": "40",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "37",
+    "electron": "1.1"
+  },
+  "es6.regexp.flags": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "79",
+    "firefox": "37",
+    "safari": "9",
+    "node": "6",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "5",
+    "rhino": "1.7.15",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "es6.regexp.match": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "79",
+    "firefox": "49",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "opera_mobile": "37",
+    "electron": "1.1"
+  },
+  "es6.regexp.replace": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "79",
+    "firefox": "49",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "37",
+    "electron": "1.1"
+  },
+  "es6.regexp.split": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "79",
+    "firefox": "49",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "37",
+    "electron": "1.1"
+  },
+  "es6.regexp.search": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "79",
+    "firefox": "49",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "opera_mobile": "37",
+    "electron": "1.1"
+  },
+  "es6.regexp.to-string": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "79",
+    "firefox": "39",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.7.15",
+    "opera_mobile": "37",
+    "electron": "1.1"
+  },
+  "es6.set": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.symbol": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "79",
+    "firefox": "51",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es7.symbol.async-iterator": {
+    "chrome": "63",
+    "opera": "50",
+    "edge": "79",
+    "firefox": "57",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "8",
+    "opera_mobile": "46",
+    "electron": "3.0"
+  },
+  "es6.string.anchor": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.big": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.blink": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.bold": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.code-point-at": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "29",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "rhino": "1.7.13",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "es6.string.ends-with": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "29",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "rhino": "1.7.13",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "es6.string.fixed": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.fontcolor": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.fontsize": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.from-code-point": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "29",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "rhino": "1.7.13",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "es6.string.includes": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "40",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "rhino": "1.7.13",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "es6.string.italics": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.iterator": {
+    "chrome": "38",
+    "opera": "25",
+    "edge": "12",
+    "firefox": "36",
+    "safari": "9",
+    "node": "0.12",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3",
+    "rhino": "1.7.13",
+    "opera_mobile": "25",
+    "electron": "0.20"
+  },
+  "es6.string.link": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es7.string.pad-start": {
+    "chrome": "57",
+    "opera": "44",
+    "edge": "15",
+    "firefox": "48",
+    "safari": "10",
+    "node": "8",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "7",
+    "rhino": "1.7.13",
+    "opera_mobile": "43",
+    "electron": "1.7"
+  },
+  "es7.string.pad-end": {
+    "chrome": "57",
+    "opera": "44",
+    "edge": "15",
+    "firefox": "48",
+    "safari": "10",
+    "node": "8",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "7",
+    "rhino": "1.7.13",
+    "opera_mobile": "43",
+    "electron": "1.7"
+  },
+  "es6.string.raw": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "34",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "rhino": "1.7.14",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "es6.string.repeat": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "24",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "rhino": "1.7.13",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "es6.string.small": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.starts-with": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "29",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "rhino": "1.7.13",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "es6.string.strike": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.sub": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.sup": {
+    "chrome": "5",
+    "opera": "15",
+    "edge": "12",
+    "firefox": "17",
+    "safari": "6",
+    "node": "0.4",
+    "deno": "1",
+    "android": "4",
+    "ios": "7",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.14",
+    "opera_mobile": "14",
+    "electron": "0.20"
+  },
+  "es6.string.trim": {
+    "chrome": "5",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "3.5",
+    "safari": "4",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "es7.string.trim-left": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "79",
+    "firefox": "61",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "9",
+    "rhino": "1.7.13",
+    "opera_mobile": "47",
+    "electron": "3.0"
+  },
+  "es7.string.trim-right": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "79",
+    "firefox": "61",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "9",
+    "rhino": "1.7.13",
+    "opera_mobile": "47",
+    "electron": "3.0"
+  },
+  "es6.typed.array-buffer": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.typed.data-view": {
+    "chrome": "5",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "15",
+    "safari": "5.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "10",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "12",
+    "electron": "0.20"
+  },
+  "es6.typed.int8-array": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.typed.uint8-array": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.typed.uint8-clamped-array": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.typed.int16-array": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.typed.uint16-array": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.typed.int32-array": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.typed.uint32-array": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.typed.float32-array": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.typed.float64-array": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "13",
+    "firefox": "48",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.weak-map": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "9",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "5",
+    "rhino": "1.7.15",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "es6.weak-set": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "9",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "5",
+    "rhino": "1.7.15",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  }
+}
diff --git a/node_modules/@babel/compat-data/data/corejs3-shipped-proposals.json b/node_modules/@babel/compat-data/data/corejs3-shipped-proposals.json
new file mode 100644
index 0000000000000000000000000000000000000000..d03b698ff0c18a2e55ff3df2414e4bc366962515
--- /dev/null
+++ b/node_modules/@babel/compat-data/data/corejs3-shipped-proposals.json
@@ -0,0 +1,5 @@
+[
+  "esnext.promise.all-settled",
+  "esnext.string.match-all",
+  "esnext.global-this"
+]
diff --git a/node_modules/@babel/compat-data/data/native-modules.json b/node_modules/@babel/compat-data/data/native-modules.json
new file mode 100644
index 0000000000000000000000000000000000000000..2328d2138bd513cde3d1fe009ef41f969226f023
--- /dev/null
+++ b/node_modules/@babel/compat-data/data/native-modules.json
@@ -0,0 +1,18 @@
+{
+  "es6.module": {
+    "chrome": "61",
+    "and_chr": "61",
+    "edge": "16",
+    "firefox": "60",
+    "and_ff": "60",
+    "node": "13.2.0",
+    "opera": "48",
+    "op_mob": "45",
+    "safari": "10.1",
+    "ios": "10.3",
+    "samsung": "8.2",
+    "android": "61",
+    "electron": "2.0",
+    "ios_saf": "10.3"
+  }
+}
diff --git a/node_modules/@babel/compat-data/data/overlapping-plugins.json b/node_modules/@babel/compat-data/data/overlapping-plugins.json
new file mode 100644
index 0000000000000000000000000000000000000000..c0df4bd445ed52b2138b0b7c228cda5ebe713609
--- /dev/null
+++ b/node_modules/@babel/compat-data/data/overlapping-plugins.json
@@ -0,0 +1,38 @@
+{
+  "transform-async-to-generator": [
+    "bugfix/transform-async-arrows-in-class"
+  ],
+  "transform-parameters": [
+    "bugfix/transform-edge-default-parameters",
+    "bugfix/transform-safari-id-destructuring-collision-in-function-expression"
+  ],
+  "transform-function-name": [
+    "bugfix/transform-edge-function-name"
+  ],
+  "transform-block-scoping": [
+    "bugfix/transform-safari-block-shadowing",
+    "bugfix/transform-safari-for-shadowing"
+  ],
+  "transform-destructuring": [
+    "bugfix/transform-safari-rest-destructuring-rhs-array"
+  ],
+  "transform-template-literals": [
+    "bugfix/transform-tagged-template-caching"
+  ],
+  "transform-optional-chaining": [
+    "bugfix/transform-v8-spread-parameters-in-optional-chaining"
+  ],
+  "proposal-optional-chaining": [
+    "bugfix/transform-v8-spread-parameters-in-optional-chaining"
+  ],
+  "transform-class-properties": [
+    "bugfix/transform-v8-static-class-fields-redefine-readonly",
+    "bugfix/transform-firefox-class-in-computed-class-key",
+    "bugfix/transform-safari-class-field-initializer-scope"
+  ],
+  "proposal-class-properties": [
+    "bugfix/transform-v8-static-class-fields-redefine-readonly",
+    "bugfix/transform-firefox-class-in-computed-class-key",
+    "bugfix/transform-safari-class-field-initializer-scope"
+  ]
+}
diff --git a/node_modules/@babel/compat-data/data/plugin-bugfixes.json b/node_modules/@babel/compat-data/data/plugin-bugfixes.json
new file mode 100644
index 0000000000000000000000000000000000000000..7b6589ae7f8936a45c1b6efbd370cf4d502253d8
--- /dev/null
+++ b/node_modules/@babel/compat-data/data/plugin-bugfixes.json
@@ -0,0 +1,231 @@
+{
+  "bugfix/transform-async-arrows-in-class": {
+    "chrome": "55",
+    "opera": "42",
+    "edge": "15",
+    "firefox": "52",
+    "safari": "11",
+    "node": "7.6",
+    "deno": "1",
+    "ios": "11",
+    "samsung": "6",
+    "opera_mobile": "42",
+    "electron": "1.6"
+  },
+  "bugfix/transform-edge-default-parameters": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "18",
+    "firefox": "52",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "bugfix/transform-edge-function-name": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "79",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.9",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "bugfix/transform-safari-block-shadowing": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "44",
+    "safari": "11",
+    "node": "6",
+    "deno": "1",
+    "ie": "11",
+    "ios": "11",
+    "samsung": "5",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "bugfix/transform-safari-for-shadowing": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "12",
+    "firefox": "4",
+    "safari": "11",
+    "node": "6",
+    "deno": "1",
+    "ie": "11",
+    "ios": "11",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "bugfix/transform-safari-id-destructuring-collision-in-function-expression": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "14",
+    "firefox": "2",
+    "safari": "16.3",
+    "node": "6",
+    "deno": "1",
+    "ios": "16.3",
+    "samsung": "5",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "bugfix/transform-safari-rest-destructuring-rhs-array": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "14",
+    "firefox": "34",
+    "safari": "14.1",
+    "node": "6",
+    "deno": "1",
+    "ios": "14.5",
+    "samsung": "5",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "bugfix/transform-tagged-template-caching": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "34",
+    "safari": "13",
+    "node": "4",
+    "deno": "1",
+    "ios": "13",
+    "samsung": "3.4",
+    "rhino": "1.7.14",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "bugfix/transform-v8-spread-parameters-in-optional-chaining": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "16.9",
+    "deno": "1.9",
+    "ios": "13.4",
+    "samsung": "16",
+    "opera_mobile": "64",
+    "electron": "13.0"
+  },
+  "transform-optional-chaining": {
+    "chrome": "80",
+    "opera": "67",
+    "edge": "80",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "14",
+    "deno": "1",
+    "ios": "13.4",
+    "samsung": "13",
+    "rhino": "1.8",
+    "opera_mobile": "57",
+    "electron": "8.0"
+  },
+  "proposal-optional-chaining": {
+    "chrome": "80",
+    "opera": "67",
+    "edge": "80",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "14",
+    "deno": "1",
+    "ios": "13.4",
+    "samsung": "13",
+    "rhino": "1.8",
+    "opera_mobile": "57",
+    "electron": "8.0"
+  },
+  "transform-parameters": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "15",
+    "firefox": "52",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "transform-async-to-generator": {
+    "chrome": "55",
+    "opera": "42",
+    "edge": "15",
+    "firefox": "52",
+    "safari": "10.1",
+    "node": "7.6",
+    "deno": "1",
+    "ios": "10.3",
+    "samsung": "6",
+    "opera_mobile": "42",
+    "electron": "1.6"
+  },
+  "transform-template-literals": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "13",
+    "firefox": "34",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "rhino": "1.9",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "transform-function-name": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "14",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "transform-destructuring": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "transform-block-scoping": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "14",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "37",
+    "electron": "1.1"
+  }
+}
diff --git a/node_modules/@babel/compat-data/data/plugins.json b/node_modules/@babel/compat-data/data/plugins.json
new file mode 100644
index 0000000000000000000000000000000000000000..81e6de4ef58a38bccac0bc6628392f8d41a08edb
--- /dev/null
+++ b/node_modules/@babel/compat-data/data/plugins.json
@@ -0,0 +1,843 @@
+{
+  "transform-explicit-resource-management": {
+    "chrome": "141",
+    "edge": "141",
+    "firefox": "141",
+    "node": "25",
+    "electron": "39.0"
+  },
+  "transform-duplicate-named-capturing-groups-regex": {
+    "chrome": "126",
+    "opera": "112",
+    "edge": "126",
+    "firefox": "129",
+    "safari": "17.4",
+    "node": "23",
+    "ios": "17.4",
+    "rhino": "1.9",
+    "electron": "31.0"
+  },
+  "transform-regexp-modifiers": {
+    "chrome": "125",
+    "opera": "111",
+    "edge": "125",
+    "firefox": "132",
+    "node": "23",
+    "samsung": "27",
+    "electron": "31.0"
+  },
+  "transform-unicode-sets-regex": {
+    "chrome": "112",
+    "opera": "98",
+    "edge": "112",
+    "firefox": "116",
+    "safari": "17",
+    "node": "20",
+    "deno": "1.32",
+    "ios": "17",
+    "samsung": "23",
+    "opera_mobile": "75",
+    "electron": "24.0"
+  },
+  "bugfix/transform-v8-static-class-fields-redefine-readonly": {
+    "chrome": "98",
+    "opera": "84",
+    "edge": "98",
+    "firefox": "75",
+    "safari": "15",
+    "node": "12",
+    "deno": "1.18",
+    "ios": "15",
+    "samsung": "11",
+    "opera_mobile": "52",
+    "electron": "17.0"
+  },
+  "bugfix/transform-firefox-class-in-computed-class-key": {
+    "chrome": "74",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "126",
+    "safari": "16",
+    "node": "12",
+    "deno": "1",
+    "ios": "16",
+    "samsung": "11",
+    "opera_mobile": "53",
+    "electron": "6.0"
+  },
+  "bugfix/transform-safari-class-field-initializer-scope": {
+    "chrome": "74",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "69",
+    "safari": "16",
+    "node": "12",
+    "deno": "1",
+    "ios": "16",
+    "samsung": "11",
+    "opera_mobile": "53",
+    "electron": "6.0"
+  },
+  "transform-class-static-block": {
+    "chrome": "94",
+    "opera": "80",
+    "edge": "94",
+    "firefox": "93",
+    "safari": "16.4",
+    "node": "16.11",
+    "deno": "1.14",
+    "ios": "16.4",
+    "samsung": "17",
+    "opera_mobile": "66",
+    "electron": "15.0"
+  },
+  "proposal-class-static-block": {
+    "chrome": "94",
+    "opera": "80",
+    "edge": "94",
+    "firefox": "93",
+    "safari": "16.4",
+    "node": "16.11",
+    "deno": "1.14",
+    "ios": "16.4",
+    "samsung": "17",
+    "opera_mobile": "66",
+    "electron": "15.0"
+  },
+  "transform-private-property-in-object": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "90",
+    "safari": "15",
+    "node": "16.9",
+    "deno": "1.9",
+    "ios": "15",
+    "samsung": "16",
+    "opera_mobile": "64",
+    "electron": "13.0"
+  },
+  "proposal-private-property-in-object": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "90",
+    "safari": "15",
+    "node": "16.9",
+    "deno": "1.9",
+    "ios": "15",
+    "samsung": "16",
+    "opera_mobile": "64",
+    "electron": "13.0"
+  },
+  "transform-class-properties": {
+    "chrome": "74",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "90",
+    "safari": "14.1",
+    "node": "12",
+    "deno": "1",
+    "ios": "14.5",
+    "samsung": "11",
+    "opera_mobile": "53",
+    "electron": "6.0"
+  },
+  "proposal-class-properties": {
+    "chrome": "74",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "90",
+    "safari": "14.1",
+    "node": "12",
+    "deno": "1",
+    "ios": "14.5",
+    "samsung": "11",
+    "opera_mobile": "53",
+    "electron": "6.0"
+  },
+  "transform-private-methods": {
+    "chrome": "84",
+    "opera": "70",
+    "edge": "84",
+    "firefox": "90",
+    "safari": "15",
+    "node": "14.6",
+    "deno": "1",
+    "ios": "15",
+    "samsung": "14",
+    "opera_mobile": "60",
+    "electron": "10.0"
+  },
+  "proposal-private-methods": {
+    "chrome": "84",
+    "opera": "70",
+    "edge": "84",
+    "firefox": "90",
+    "safari": "15",
+    "node": "14.6",
+    "deno": "1",
+    "ios": "15",
+    "samsung": "14",
+    "opera_mobile": "60",
+    "electron": "10.0"
+  },
+  "transform-numeric-separator": {
+    "chrome": "75",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "70",
+    "safari": "13",
+    "node": "12.5",
+    "deno": "1",
+    "ios": "13",
+    "samsung": "11",
+    "rhino": "1.7.14",
+    "opera_mobile": "54",
+    "electron": "6.0"
+  },
+  "proposal-numeric-separator": {
+    "chrome": "75",
+    "opera": "62",
+    "edge": "79",
+    "firefox": "70",
+    "safari": "13",
+    "node": "12.5",
+    "deno": "1",
+    "ios": "13",
+    "samsung": "11",
+    "rhino": "1.7.14",
+    "opera_mobile": "54",
+    "electron": "6.0"
+  },
+  "transform-logical-assignment-operators": {
+    "chrome": "85",
+    "opera": "71",
+    "edge": "85",
+    "firefox": "79",
+    "safari": "14",
+    "node": "15",
+    "deno": "1.2",
+    "ios": "14",
+    "samsung": "14",
+    "opera_mobile": "60",
+    "electron": "10.0"
+  },
+  "proposal-logical-assignment-operators": {
+    "chrome": "85",
+    "opera": "71",
+    "edge": "85",
+    "firefox": "79",
+    "safari": "14",
+    "node": "15",
+    "deno": "1.2",
+    "ios": "14",
+    "samsung": "14",
+    "opera_mobile": "60",
+    "electron": "10.0"
+  },
+  "transform-nullish-coalescing-operator": {
+    "chrome": "80",
+    "opera": "67",
+    "edge": "80",
+    "firefox": "72",
+    "safari": "13.1",
+    "node": "14",
+    "deno": "1",
+    "ios": "13.4",
+    "samsung": "13",
+    "rhino": "1.8",
+    "opera_mobile": "57",
+    "electron": "8.0"
+  },
+  "proposal-nullish-coalescing-operator": {
+    "chrome": "80",
+    "opera": "67",
+    "edge": "80",
+    "firefox": "72",
+    "safari": "13.1",
+    "node": "14",
+    "deno": "1",
+    "ios": "13.4",
+    "samsung": "13",
+    "rhino": "1.8",
+    "opera_mobile": "57",
+    "electron": "8.0"
+  },
+  "transform-optional-chaining": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "16.9",
+    "deno": "1.9",
+    "ios": "13.4",
+    "samsung": "16",
+    "opera_mobile": "64",
+    "electron": "13.0"
+  },
+  "proposal-optional-chaining": {
+    "chrome": "91",
+    "opera": "77",
+    "edge": "91",
+    "firefox": "74",
+    "safari": "13.1",
+    "node": "16.9",
+    "deno": "1.9",
+    "ios": "13.4",
+    "samsung": "16",
+    "opera_mobile": "64",
+    "electron": "13.0"
+  },
+  "transform-json-strings": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "79",
+    "firefox": "62",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "9",
+    "rhino": "1.7.14",
+    "opera_mobile": "47",
+    "electron": "3.0"
+  },
+  "proposal-json-strings": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "79",
+    "firefox": "62",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "9",
+    "rhino": "1.7.14",
+    "opera_mobile": "47",
+    "electron": "3.0"
+  },
+  "transform-optional-catch-binding": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "79",
+    "firefox": "58",
+    "safari": "11.1",
+    "node": "10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "9",
+    "opera_mobile": "47",
+    "electron": "3.0"
+  },
+  "proposal-optional-catch-binding": {
+    "chrome": "66",
+    "opera": "53",
+    "edge": "79",
+    "firefox": "58",
+    "safari": "11.1",
+    "node": "10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "9",
+    "opera_mobile": "47",
+    "electron": "3.0"
+  },
+  "transform-parameters": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "18",
+    "firefox": "52",
+    "safari": "16.3",
+    "node": "6",
+    "deno": "1",
+    "ios": "16.3",
+    "samsung": "5",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "transform-async-generator-functions": {
+    "chrome": "63",
+    "opera": "50",
+    "edge": "79",
+    "firefox": "57",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "8",
+    "opera_mobile": "46",
+    "electron": "3.0"
+  },
+  "proposal-async-generator-functions": {
+    "chrome": "63",
+    "opera": "50",
+    "edge": "79",
+    "firefox": "57",
+    "safari": "12",
+    "node": "10",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "8",
+    "opera_mobile": "46",
+    "electron": "3.0"
+  },
+  "transform-object-rest-spread": {
+    "chrome": "60",
+    "opera": "47",
+    "edge": "79",
+    "firefox": "55",
+    "safari": "11.1",
+    "node": "8.3",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "8",
+    "opera_mobile": "44",
+    "electron": "2.0"
+  },
+  "proposal-object-rest-spread": {
+    "chrome": "60",
+    "opera": "47",
+    "edge": "79",
+    "firefox": "55",
+    "safari": "11.1",
+    "node": "8.3",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "8",
+    "opera_mobile": "44",
+    "electron": "2.0"
+  },
+  "transform-dotall-regex": {
+    "chrome": "62",
+    "opera": "49",
+    "edge": "79",
+    "firefox": "78",
+    "safari": "11.1",
+    "node": "8.10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "8",
+    "rhino": "1.7.15",
+    "opera_mobile": "46",
+    "electron": "3.0"
+  },
+  "transform-unicode-property-regex": {
+    "chrome": "64",
+    "opera": "51",
+    "edge": "79",
+    "firefox": "78",
+    "safari": "11.1",
+    "node": "10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "9",
+    "rhino": "1.9",
+    "opera_mobile": "47",
+    "electron": "3.0"
+  },
+  "proposal-unicode-property-regex": {
+    "chrome": "64",
+    "opera": "51",
+    "edge": "79",
+    "firefox": "78",
+    "safari": "11.1",
+    "node": "10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "9",
+    "rhino": "1.9",
+    "opera_mobile": "47",
+    "electron": "3.0"
+  },
+  "transform-named-capturing-groups-regex": {
+    "chrome": "64",
+    "opera": "51",
+    "edge": "79",
+    "firefox": "78",
+    "safari": "11.1",
+    "node": "10",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "9",
+    "rhino": "1.9",
+    "opera_mobile": "47",
+    "electron": "3.0"
+  },
+  "transform-async-to-generator": {
+    "chrome": "55",
+    "opera": "42",
+    "edge": "15",
+    "firefox": "52",
+    "safari": "11",
+    "node": "7.6",
+    "deno": "1",
+    "ios": "11",
+    "samsung": "6",
+    "opera_mobile": "42",
+    "electron": "1.6"
+  },
+  "transform-exponentiation-operator": {
+    "chrome": "52",
+    "opera": "39",
+    "edge": "14",
+    "firefox": "52",
+    "safari": "10.1",
+    "node": "7",
+    "deno": "1",
+    "ios": "10.3",
+    "samsung": "6",
+    "rhino": "1.7.14",
+    "opera_mobile": "41",
+    "electron": "1.3"
+  },
+  "transform-template-literals": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "13",
+    "firefox": "34",
+    "safari": "13",
+    "node": "4",
+    "deno": "1",
+    "ios": "13",
+    "samsung": "3.4",
+    "rhino": "1.9",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "transform-literals": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "53",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.15",
+    "opera_mobile": "32",
+    "electron": "0.30"
+  },
+  "transform-function-name": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "79",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "transform-arrow-functions": {
+    "chrome": "47",
+    "opera": "34",
+    "edge": "13",
+    "firefox": "43",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.7.13",
+    "opera_mobile": "34",
+    "electron": "0.36"
+  },
+  "transform-block-scoped-functions": {
+    "chrome": "41",
+    "opera": "28",
+    "edge": "12",
+    "firefox": "46",
+    "safari": "10",
+    "node": "4",
+    "deno": "1",
+    "ie": "11",
+    "ios": "10",
+    "samsung": "3.4",
+    "opera_mobile": "28",
+    "electron": "0.21"
+  },
+  "transform-classes": {
+    "chrome": "46",
+    "opera": "33",
+    "edge": "13",
+    "firefox": "45",
+    "safari": "10",
+    "node": "5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "33",
+    "electron": "0.36"
+  },
+  "transform-object-super": {
+    "chrome": "46",
+    "opera": "33",
+    "edge": "13",
+    "firefox": "45",
+    "safari": "10",
+    "node": "5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "33",
+    "electron": "0.36"
+  },
+  "transform-shorthand-properties": {
+    "chrome": "43",
+    "opera": "30",
+    "edge": "12",
+    "firefox": "33",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.14",
+    "opera_mobile": "30",
+    "electron": "0.27"
+  },
+  "transform-duplicate-keys": {
+    "chrome": "42",
+    "opera": "29",
+    "edge": "12",
+    "firefox": "34",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "3.4",
+    "opera_mobile": "29",
+    "electron": "0.25"
+  },
+  "transform-computed-properties": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "34",
+    "safari": "7.1",
+    "node": "4",
+    "deno": "1",
+    "ios": "8",
+    "samsung": "4",
+    "rhino": "1.8",
+    "opera_mobile": "32",
+    "electron": "0.30"
+  },
+  "transform-for-of": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "transform-sticky-regex": {
+    "chrome": "49",
+    "opera": "36",
+    "edge": "13",
+    "firefox": "3",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "rhino": "1.7.15",
+    "opera_mobile": "36",
+    "electron": "0.37"
+  },
+  "transform-unicode-escapes": {
+    "chrome": "44",
+    "opera": "31",
+    "edge": "12",
+    "firefox": "53",
+    "safari": "9",
+    "node": "4",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "4",
+    "rhino": "1.7.15",
+    "opera_mobile": "32",
+    "electron": "0.30"
+  },
+  "transform-unicode-regex": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "13",
+    "firefox": "46",
+    "safari": "12",
+    "node": "6",
+    "deno": "1",
+    "ios": "12",
+    "samsung": "5",
+    "opera_mobile": "37",
+    "electron": "1.1"
+  },
+  "transform-spread": {
+    "chrome": "46",
+    "opera": "33",
+    "edge": "13",
+    "firefox": "45",
+    "safari": "10",
+    "node": "5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "33",
+    "electron": "0.36"
+  },
+  "transform-destructuring": {
+    "chrome": "51",
+    "opera": "38",
+    "edge": "15",
+    "firefox": "53",
+    "safari": "14.1",
+    "node": "6.5",
+    "deno": "1",
+    "ios": "14.5",
+    "samsung": "5",
+    "opera_mobile": "41",
+    "electron": "1.2"
+  },
+  "transform-block-scoping": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "14",
+    "firefox": "53",
+    "safari": "11",
+    "node": "6",
+    "deno": "1",
+    "ios": "11",
+    "samsung": "5",
+    "opera_mobile": "37",
+    "electron": "1.1"
+  },
+  "transform-typeof-symbol": {
+    "chrome": "48",
+    "opera": "35",
+    "edge": "12",
+    "firefox": "36",
+    "safari": "9",
+    "node": "6",
+    "deno": "1",
+    "ios": "9",
+    "samsung": "5",
+    "rhino": "1.8",
+    "opera_mobile": "35",
+    "electron": "0.37"
+  },
+  "transform-new-target": {
+    "chrome": "46",
+    "opera": "33",
+    "edge": "14",
+    "firefox": "41",
+    "safari": "10",
+    "node": "5",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "33",
+    "electron": "0.36"
+  },
+  "transform-regenerator": {
+    "chrome": "50",
+    "opera": "37",
+    "edge": "13",
+    "firefox": "53",
+    "safari": "10",
+    "node": "6",
+    "deno": "1",
+    "ios": "10",
+    "samsung": "5",
+    "opera_mobile": "37",
+    "electron": "1.1"
+  },
+  "transform-member-expression-literals": {
+    "chrome": "7",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "5.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "12",
+    "electron": "0.20"
+  },
+  "transform-property-literals": {
+    "chrome": "7",
+    "opera": "12",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "5.1",
+    "node": "0.4",
+    "deno": "1",
+    "ie": "9",
+    "android": "4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "12",
+    "electron": "0.20"
+  },
+  "transform-reserved-words": {
+    "chrome": "13",
+    "opera": "10.50",
+    "edge": "12",
+    "firefox": "2",
+    "safari": "3.1",
+    "node": "0.6",
+    "deno": "1",
+    "ie": "9",
+    "android": "4.4",
+    "ios": "6",
+    "phantom": "1.9",
+    "samsung": "1",
+    "rhino": "1.7.13",
+    "opera_mobile": "10.1",
+    "electron": "0.20"
+  },
+  "transform-export-namespace-from": {
+    "chrome": "72",
+    "deno": "1.0",
+    "edge": "79",
+    "firefox": "80",
+    "node": "13.2.0",
+    "opera": "60",
+    "opera_mobile": "51",
+    "safari": "14.1",
+    "ios": "14.5",
+    "samsung": "11.0",
+    "android": "72",
+    "electron": "5.0"
+  },
+  "proposal-export-namespace-from": {
+    "chrome": "72",
+    "deno": "1.0",
+    "edge": "79",
+    "firefox": "80",
+    "node": "13.2.0",
+    "opera": "60",
+    "opera_mobile": "51",
+    "safari": "14.1",
+    "ios": "14.5",
+    "samsung": "11.0",
+    "android": "72",
+    "electron": "5.0"
+  }
+}
diff --git a/node_modules/@babel/compat-data/native-modules.js b/node_modules/@babel/compat-data/native-modules.js
new file mode 100644
index 0000000000000000000000000000000000000000..f8c25fa37c725bf198ca05821ec0515e377fe137
--- /dev/null
+++ b/node_modules/@babel/compat-data/native-modules.js
@@ -0,0 +1,2 @@
+// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly
+module.exports = require("./data/native-modules.json");
diff --git a/node_modules/@babel/compat-data/overlapping-plugins.js b/node_modules/@babel/compat-data/overlapping-plugins.js
new file mode 100644
index 0000000000000000000000000000000000000000..0dd35f1573f98ceb7d2c947e658b8bd0fcf639bb
--- /dev/null
+++ b/node_modules/@babel/compat-data/overlapping-plugins.js
@@ -0,0 +1,2 @@
+// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly
+module.exports = require("./data/overlapping-plugins.json");
diff --git a/node_modules/@babel/compat-data/package.json b/node_modules/@babel/compat-data/package.json
new file mode 100644
index 0000000000000000000000000000000000000000..9a59bd07b6c4f9557ad3d9bd74fd9398e87a096e
--- /dev/null
+++ b/node_modules/@babel/compat-data/package.json
@@ -0,0 +1,40 @@
+{
+  "name": "@babel/compat-data",
+  "version": "7.29.7",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "license": "MIT",
+  "description": "The compat-data to determine required Babel plugins",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-compat-data"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./plugins": "./plugins.js",
+    "./native-modules": "./native-modules.js",
+    "./corejs2-built-ins": "./corejs2-built-ins.js",
+    "./corejs3-shipped-proposals": "./corejs3-shipped-proposals.js",
+    "./overlapping-plugins": "./overlapping-plugins.js",
+    "./plugin-bugfixes": "./plugin-bugfixes.js"
+  },
+  "scripts": {
+    "build-data": "./scripts/download-compat-table.sh && node ./scripts/build-data.mjs && node ./scripts/build-modules-support.mjs && node ./scripts/build-bugfixes-targets.mjs"
+  },
+  "keywords": [
+    "babel",
+    "compat-table",
+    "compat-data"
+  ],
+  "devDependencies": {
+    "@mdn/browser-compat-data": "^6.0.8",
+    "core-js-compat": "^3.48.0",
+    "electron-to-chromium": "^1.5.278"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "type": "commonjs"
+}
\ No newline at end of file
diff --git a/node_modules/@babel/compat-data/plugin-bugfixes.js b/node_modules/@babel/compat-data/plugin-bugfixes.js
new file mode 100644
index 0000000000000000000000000000000000000000..9aaf3641701370ff57b1a2866a0e5c811cf7ac04
--- /dev/null
+++ b/node_modules/@babel/compat-data/plugin-bugfixes.js
@@ -0,0 +1,2 @@
+// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly
+module.exports = require("./data/plugin-bugfixes.json");
diff --git a/node_modules/@babel/compat-data/plugins.js b/node_modules/@babel/compat-data/plugins.js
new file mode 100644
index 0000000000000000000000000000000000000000..b191017be6a865bb2760ca351d9f1e610693468c
--- /dev/null
+++ b/node_modules/@babel/compat-data/plugins.js
@@ -0,0 +1,2 @@
+// Todo (Babel 8): remove this file, in Babel 8 users import the .json directly
+module.exports = require("./data/plugins.json");
diff --git a/node_modules/@babel/core/LICENSE b/node_modules/@babel/core/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..f31575ec773bb199aeb7c0d0f1612cfe1c7038f1
--- /dev/null
+++ b/node_modules/@babel/core/LICENSE
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/node_modules/@babel/core/README.md b/node_modules/@babel/core/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2903543469699795279ec0c977ee56114bd21e01
--- /dev/null
+++ b/node_modules/@babel/core/README.md
@@ -0,0 +1,19 @@
+# @babel/core
+
+> Babel compiler core.
+
+See our website [@babel/core](https://babeljs.io/docs/babel-core) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20core%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/core
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/core --dev
+```
diff --git a/node_modules/@babel/core/lib/config/cache-contexts.js b/node_modules/@babel/core/lib/config/cache-contexts.js
new file mode 100644
index 0000000000000000000000000000000000000000..f2ececdae59d09ca55a8961edd77db7baf7b8bd5
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/cache-contexts.js
@@ -0,0 +1,5 @@
+"use strict";
+
+0 && 0;
+
+//# sourceMappingURL=cache-contexts.js.map
diff --git a/node_modules/@babel/core/lib/config/cache-contexts.js.map b/node_modules/@babel/core/lib/config/cache-contexts.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..39b1898d30e8184fd5d489488be517e50f0a75bf
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/cache-contexts.js.map
@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["../../src/config/cache-contexts.ts"],"sourcesContent":["import type { ConfigContext } from \"./config-chain.ts\";\nimport type {\n  CallerMetadata,\n  TargetsListOrObject,\n} from \"./validation/options.ts\";\n\nexport type { ConfigContext as FullConfig };\n\nexport type FullPreset = {\n  targets: TargetsListOrObject;\n} & ConfigContext;\nexport type FullPlugin = {\n  assumptions: Record<string, boolean>;\n} & FullPreset;\n\n// Context not including filename since it is used in places that cannot\n// process 'ignore'/'only' and other filename-based logic.\nexport type SimpleConfig = {\n  envName: string;\n  caller: CallerMetadata | undefined;\n};\nexport type SimplePreset = {\n  targets: TargetsListOrObject;\n} & SimpleConfig;\nexport type SimplePlugin = {\n  assumptions: Record<string, boolean>;\n} & SimplePreset;\n"],"mappings":"","ignoreList":[]}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/caching.js b/node_modules/@babel/core/lib/config/caching.js
new file mode 100644
index 0000000000000000000000000000000000000000..344c8390e3d054513e7c797fef4cfa98f0ba30f7
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/caching.js
@@ -0,0 +1,261 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertSimpleType = assertSimpleType;
+exports.makeStrongCache = makeStrongCache;
+exports.makeStrongCacheSync = makeStrongCacheSync;
+exports.makeWeakCache = makeWeakCache;
+exports.makeWeakCacheSync = makeWeakCacheSync;
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+var _async = require("../gensync-utils/async.js");
+var _util = require("./util.js");
+const synchronize = gen => {
+  return _gensync()(gen).sync;
+};
+function* genTrue() {
+  return true;
+}
+function makeWeakCache(handler) {
+  return makeCachedFunction(WeakMap, handler);
+}
+function makeWeakCacheSync(handler) {
+  return synchronize(makeWeakCache(handler));
+}
+function makeStrongCache(handler) {
+  return makeCachedFunction(Map, handler);
+}
+function makeStrongCacheSync(handler) {
+  return synchronize(makeStrongCache(handler));
+}
+function makeCachedFunction(CallCache, handler) {
+  const callCacheSync = new CallCache();
+  const callCacheAsync = new CallCache();
+  const futureCache = new CallCache();
+  return function* cachedFunction(arg, data) {
+    const asyncContext = yield* (0, _async.isAsync)();
+    const callCache = asyncContext ? callCacheAsync : callCacheSync;
+    const cached = yield* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data);
+    if (cached.valid) return cached.value;
+    const cache = new CacheConfigurator(data);
+    const handlerResult = handler(arg, cache);
+    let finishLock;
+    let value;
+    if ((0, _util.isIterableIterator)(handlerResult)) {
+      value = yield* (0, _async.onFirstPause)(handlerResult, () => {
+        finishLock = setupAsyncLocks(cache, futureCache, arg);
+      });
+    } else {
+      value = handlerResult;
+    }
+    updateFunctionCache(callCache, cache, arg, value);
+    if (finishLock) {
+      futureCache.delete(arg);
+      finishLock.release(value);
+    }
+    return value;
+  };
+}
+function* getCachedValue(cache, arg, data) {
+  const cachedValue = cache.get(arg);
+  if (cachedValue) {
+    for (const {
+      value,
+      valid
+    } of cachedValue) {
+      if (yield* valid(data)) return {
+        valid: true,
+        value
+      };
+    }
+  }
+  return {
+    valid: false,
+    value: null
+  };
+}
+function* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data) {
+  const cached = yield* getCachedValue(callCache, arg, data);
+  if (cached.valid) {
+    return cached;
+  }
+  if (asyncContext) {
+    const cached = yield* getCachedValue(futureCache, arg, data);
+    if (cached.valid) {
+      const value = yield* (0, _async.waitFor)(cached.value.promise);
+      return {
+        valid: true,
+        value
+      };
+    }
+  }
+  return {
+    valid: false,
+    value: null
+  };
+}
+function setupAsyncLocks(config, futureCache, arg) {
+  const finishLock = new Lock();
+  updateFunctionCache(futureCache, config, arg, finishLock);
+  return finishLock;
+}
+function updateFunctionCache(cache, config, arg, value) {
+  if (!config.configured()) config.forever();
+  let cachedValue = cache.get(arg);
+  config.deactivate();
+  switch (config.mode()) {
+    case "forever":
+      cachedValue = [{
+        value,
+        valid: genTrue
+      }];
+      cache.set(arg, cachedValue);
+      break;
+    case "invalidate":
+      cachedValue = [{
+        value,
+        valid: config.validator()
+      }];
+      cache.set(arg, cachedValue);
+      break;
+    case "valid":
+      if (cachedValue) {
+        cachedValue.push({
+          value,
+          valid: config.validator()
+        });
+      } else {
+        cachedValue = [{
+          value,
+          valid: config.validator()
+        }];
+        cache.set(arg, cachedValue);
+      }
+  }
+}
+class CacheConfigurator {
+  constructor(data) {
+    this._active = true;
+    this._never = false;
+    this._forever = false;
+    this._invalidate = false;
+    this._configured = false;
+    this._pairs = [];
+    this._data = void 0;
+    this._data = data;
+  }
+  simple() {
+    return makeSimpleConfigurator(this);
+  }
+  mode() {
+    if (this._never) return "never";
+    if (this._forever) return "forever";
+    if (this._invalidate) return "invalidate";
+    return "valid";
+  }
+  forever() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._never) {
+      throw new Error("Caching has already been configured with .never()");
+    }
+    this._forever = true;
+    this._configured = true;
+  }
+  never() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._forever) {
+      throw new Error("Caching has already been configured with .forever()");
+    }
+    this._never = true;
+    this._configured = true;
+  }
+  using(handler) {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._never || this._forever) {
+      throw new Error("Caching has already been configured with .never or .forever()");
+    }
+    this._configured = true;
+    const key = handler(this._data);
+    const fn = (0, _async.maybeAsync)(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`);
+    if ((0, _async.isThenable)(key)) {
+      return key.then(key => {
+        this._pairs.push([key, fn]);
+        return key;
+      });
+    }
+    this._pairs.push([key, fn]);
+    return key;
+  }
+  invalidate(handler) {
+    this._invalidate = true;
+    return this.using(handler);
+  }
+  validator() {
+    const pairs = this._pairs;
+    return function* (data) {
+      for (const [key, fn] of pairs) {
+        if (key !== (yield* fn(data))) return false;
+      }
+      return true;
+    };
+  }
+  deactivate() {
+    this._active = false;
+  }
+  configured() {
+    return this._configured;
+  }
+}
+function makeSimpleConfigurator(cache) {
+  function cacheFn(val) {
+    if (typeof val === "boolean") {
+      if (val) cache.forever();else cache.never();
+      return;
+    }
+    return cache.using(() => assertSimpleType(val()));
+  }
+  cacheFn.forever = () => cache.forever();
+  cacheFn.never = () => cache.never();
+  cacheFn.using = cb => cache.using(() => assertSimpleType(cb()));
+  cacheFn.invalidate = cb => cache.invalidate(() => assertSimpleType(cb()));
+  return cacheFn;
+}
+function assertSimpleType(value) {
+  if ((0, _async.isThenable)(value)) {
+    throw new Error(`You appear to be using an async cache handler, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously handle your caching logic.`);
+  }
+  if (value != null && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number") {
+    throw new Error("Cache keys must be either string, boolean, number, null, or undefined.");
+  }
+  return value;
+}
+class Lock {
+  constructor() {
+    this.released = false;
+    this.promise = void 0;
+    this._resolve = void 0;
+    this.promise = new Promise(resolve => {
+      this._resolve = resolve;
+    });
+  }
+  release(value) {
+    this.released = true;
+    this._resolve(value);
+  }
+}
+0 && 0;
+
+//# sourceMappingURL=caching.js.map
diff --git a/node_modules/@babel/core/lib/config/caching.js.map b/node_modules/@babel/core/lib/config/caching.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..c9a69fd65d4727620da46808e2112a1e76eb7a38
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/caching.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_gensync","data","require","_async","_util","synchronize","gen","gensync","sync","genTrue","makeWeakCache","handler","makeCachedFunction","WeakMap","makeWeakCacheSync","makeStrongCache","Map","makeStrongCacheSync","CallCache","callCacheSync","callCacheAsync","futureCache","cachedFunction","arg","asyncContext","isAsync","callCache","cached","getCachedValueOrWait","valid","value","cache","CacheConfigurator","handlerResult","finishLock","isIterableIterator","onFirstPause","setupAsyncLocks","updateFunctionCache","delete","release","getCachedValue","cachedValue","get","waitFor","promise","config","Lock","configured","forever","deactivate","mode","set","validator","push","constructor","_active","_never","_forever","_invalidate","_configured","_pairs","_data","simple","makeSimpleConfigurator","Error","never","using","key","fn","maybeAsync","isThenable","then","invalidate","pairs","cacheFn","val","assertSimpleType","cb","released","_resolve","Promise","resolve"],"sources":["../../src/config/caching.ts"],"sourcesContent":["import gensync from \"gensync\";\nimport type { Handler } from \"gensync\";\nimport {\n  maybeAsync,\n  isAsync,\n  onFirstPause,\n  waitFor,\n  isThenable,\n} from \"../gensync-utils/async.ts\";\nimport { isIterableIterator } from \"./util.ts\";\n\nexport type { CacheConfigurator };\n\nexport type SimpleCacheConfigurator = {\n  (forever: boolean): void;\n  <T extends SimpleType>(handler: () => T): T;\n\n  forever: () => void;\n  never: () => void;\n  using: <T extends SimpleType>(handler: () => T) => T;\n  invalidate: <T extends SimpleType>(handler: () => T) => T;\n};\n\nexport type CacheEntry<ResultT, SideChannel> = {\n  value: ResultT;\n  valid: (channel: SideChannel) => Handler<boolean>;\n}[];\n\nconst synchronize = <ArgsT extends unknown[], ResultT>(\n  gen: (...args: ArgsT) => Handler<ResultT>,\n): ((...args: ArgsT) => ResultT) => {\n  return gensync(gen).sync;\n};\n\n// eslint-disable-next-line require-yield\nfunction* genTrue() {\n  return true;\n}\n\nexport function makeWeakCache<ArgT extends object, ResultT, SideChannel>(\n  handler: (\n    arg: ArgT,\n    cache: CacheConfigurator<SideChannel>,\n  ) => Handler<ResultT> | ResultT,\n): (arg: ArgT, data: SideChannel) => Handler<ResultT> {\n  return makeCachedFunction<ArgT, ResultT, SideChannel>(WeakMap, handler);\n}\n\nexport function makeWeakCacheSync<ArgT extends object, ResultT, SideChannel>(\n  handler: (arg: ArgT, cache?: CacheConfigurator<SideChannel>) => ResultT,\n): (arg: ArgT, data?: SideChannel) => ResultT {\n  return synchronize<[ArgT, SideChannel], ResultT>(\n    makeWeakCache<ArgT, ResultT, SideChannel>(handler),\n  );\n}\n\nexport function makeStrongCache<ArgT, ResultT, SideChannel>(\n  handler: (\n    arg: ArgT,\n    cache: CacheConfigurator<SideChannel>,\n  ) => Handler<ResultT> | ResultT,\n): (arg: ArgT, data: SideChannel) => Handler<ResultT> {\n  return makeCachedFunction<ArgT, ResultT, SideChannel>(Map, handler);\n}\n\nexport function makeStrongCacheSync<ArgT, ResultT, SideChannel>(\n  handler: (arg: ArgT, cache?: CacheConfigurator<SideChannel>) => ResultT,\n): (arg: ArgT, data?: SideChannel) => ResultT {\n  return synchronize<[ArgT, SideChannel], ResultT>(\n    makeStrongCache<ArgT, ResultT, SideChannel>(handler),\n  );\n}\n\n/* NOTE: Part of the logic explained in this comment is explained in the\n *       getCachedValueOrWait and setupAsyncLocks functions.\n *\n * > There are only two hard things in Computer Science: cache invalidation and naming things.\n * > -- Phil Karlton\n *\n * I don't know if Phil was also thinking about handling a cache whose invalidation function is\n * defined asynchronously is considered, but it is REALLY hard to do correctly.\n *\n * The implemented logic (only when gensync is run asynchronously) is the following:\n *   1. If there is a valid cache associated to the current \"arg\" parameter,\n *       a. RETURN the cached value\n *   3. If there is a FinishLock associated to the current \"arg\" parameter representing a valid cache,\n *       a. Wait for that lock to be released\n *       b. RETURN the value associated with that lock\n *   5. Start executing the function to be cached\n *       a. If it pauses on a promise, then\n *           i. Let FinishLock be a new lock\n *          ii. Store FinishLock as associated to the current \"arg\" parameter\n *         iii. Wait for the function to finish executing\n *          iv. Release FinishLock\n *           v. Send the function result to anyone waiting on FinishLock\n *   6. Store the result in the cache\n *   7. RETURN the result\n */\nfunction makeCachedFunction<ArgT, ResultT, SideChannel>(\n  CallCache: new <Cached>() => CacheMap<ArgT, Cached, SideChannel>,\n  handler: (\n    arg: ArgT,\n    cache: CacheConfigurator<SideChannel>,\n  ) => Handler<ResultT> | ResultT,\n): (arg: ArgT, data: SideChannel) => Handler<ResultT> {\n  const callCacheSync = new CallCache<ResultT>();\n  const callCacheAsync = new CallCache<ResultT>();\n  const futureCache = new CallCache<Lock<ResultT>>();\n\n  return function* cachedFunction(arg: ArgT, data: SideChannel) {\n    const asyncContext = yield* isAsync();\n    const callCache = asyncContext ? callCacheAsync : callCacheSync;\n\n    const cached = yield* getCachedValueOrWait<ArgT, ResultT, SideChannel>(\n      asyncContext,\n      callCache,\n      futureCache,\n      arg,\n      data,\n    );\n    if (cached.valid) return cached.value;\n\n    const cache = new CacheConfigurator(data);\n\n    const handlerResult: Handler<ResultT> | ResultT = handler(arg, cache);\n\n    let finishLock: Lock<ResultT>;\n    let value: ResultT;\n\n    if (isIterableIterator(handlerResult)) {\n      value = yield* onFirstPause(handlerResult, () => {\n        finishLock = setupAsyncLocks(cache, futureCache, arg);\n      });\n    } else {\n      value = handlerResult;\n    }\n\n    updateFunctionCache(callCache, cache, arg, value);\n\n    if (finishLock) {\n      futureCache.delete(arg);\n      finishLock.release(value);\n    }\n\n    return value;\n  };\n}\n\ntype CacheMap<ArgT, ResultT, SideChannel> =\n  | Map<ArgT, CacheEntry<ResultT, SideChannel>>\n  // @ts-expect-error todo(flow->ts): add `extends object` constraint to ArgT\n  | WeakMap<ArgT, CacheEntry<ResultT, SideChannel>>;\n\nfunction* getCachedValue<ArgT, ResultT, SideChannel>(\n  cache: CacheMap<ArgT, ResultT, SideChannel>,\n  arg: ArgT,\n  data: SideChannel,\n): Handler<{ valid: true; value: ResultT } | { valid: false; value: null }> {\n  const cachedValue: CacheEntry<ResultT, SideChannel> | void = cache.get(arg);\n\n  if (cachedValue) {\n    for (const { value, valid } of cachedValue) {\n      if (yield* valid(data)) return { valid: true, value };\n    }\n  }\n\n  return { valid: false, value: null };\n}\n\nfunction* getCachedValueOrWait<ArgT, ResultT, SideChannel>(\n  asyncContext: boolean,\n  callCache: CacheMap<ArgT, ResultT, SideChannel>,\n  futureCache: CacheMap<ArgT, Lock<ResultT>, SideChannel>,\n  arg: ArgT,\n  data: SideChannel,\n): Handler<{ valid: true; value: ResultT } | { valid: false; value: null }> {\n  const cached = yield* getCachedValue(callCache, arg, data);\n  if (cached.valid) {\n    return cached;\n  }\n\n  if (asyncContext) {\n    const cached = yield* getCachedValue(futureCache, arg, data);\n    if (cached.valid) {\n      const value = yield* waitFor<ResultT>(cached.value.promise);\n      return { valid: true, value };\n    }\n  }\n\n  return { valid: false, value: null };\n}\n\nfunction setupAsyncLocks<ArgT, ResultT, SideChannel>(\n  config: CacheConfigurator<SideChannel>,\n  futureCache: CacheMap<ArgT, Lock<ResultT>, SideChannel>,\n  arg: ArgT,\n): Lock<ResultT> {\n  const finishLock = new Lock<ResultT>();\n\n  updateFunctionCache(futureCache, config, arg, finishLock);\n\n  return finishLock;\n}\n\nfunction updateFunctionCache<\n  ArgT,\n  ResultT,\n  SideChannel,\n  Cache extends CacheMap<ArgT, ResultT, SideChannel>,\n>(\n  cache: Cache,\n  config: CacheConfigurator<SideChannel>,\n  arg: ArgT,\n  value: ResultT,\n) {\n  if (!config.configured()) config.forever();\n\n  let cachedValue: CacheEntry<ResultT, SideChannel> | void = cache.get(arg);\n\n  config.deactivate();\n\n  switch (config.mode()) {\n    case \"forever\":\n      cachedValue = [{ value, valid: genTrue }];\n      cache.set(arg, cachedValue);\n      break;\n    case \"invalidate\":\n      cachedValue = [{ value, valid: config.validator() }];\n      cache.set(arg, cachedValue);\n      break;\n    case \"valid\":\n      if (cachedValue) {\n        cachedValue.push({ value, valid: config.validator() });\n      } else {\n        cachedValue = [{ value, valid: config.validator() }];\n        cache.set(arg, cachedValue);\n      }\n  }\n}\n\nclass CacheConfigurator<SideChannel = void> {\n  _active: boolean = true;\n  _never: boolean = false;\n  _forever: boolean = false;\n  _invalidate: boolean = false;\n\n  _configured: boolean = false;\n\n  _pairs: [\n    cachedValue: unknown,\n    handler: (data: SideChannel) => Handler<unknown>,\n  ][] = [];\n\n  _data: SideChannel;\n\n  constructor(data: SideChannel) {\n    this._data = data;\n  }\n\n  simple() {\n    return makeSimpleConfigurator(this);\n  }\n\n  mode() {\n    if (this._never) return \"never\";\n    if (this._forever) return \"forever\";\n    if (this._invalidate) return \"invalidate\";\n    return \"valid\";\n  }\n\n  forever() {\n    if (!this._active) {\n      throw new Error(\"Cannot change caching after evaluation has completed.\");\n    }\n    if (this._never) {\n      throw new Error(\"Caching has already been configured with .never()\");\n    }\n    this._forever = true;\n    this._configured = true;\n  }\n\n  never() {\n    if (!this._active) {\n      throw new Error(\"Cannot change caching after evaluation has completed.\");\n    }\n    if (this._forever) {\n      throw new Error(\"Caching has already been configured with .forever()\");\n    }\n    this._never = true;\n    this._configured = true;\n  }\n\n  using<T>(handler: (data: SideChannel) => T): T {\n    if (!this._active) {\n      throw new Error(\"Cannot change caching after evaluation has completed.\");\n    }\n    if (this._never || this._forever) {\n      throw new Error(\n        \"Caching has already been configured with .never or .forever()\",\n      );\n    }\n    this._configured = true;\n\n    const key = handler(this._data);\n\n    const fn = maybeAsync(\n      handler,\n      `You appear to be using an async cache handler, but Babel has been called synchronously`,\n    );\n\n    if (isThenable(key)) {\n      // @ts-expect-error todo(flow->ts): improve function return type annotation\n      return key.then((key: unknown) => {\n        this._pairs.push([key, fn]);\n        return key;\n      });\n    }\n\n    this._pairs.push([key, fn]);\n    return key;\n  }\n\n  invalidate<T>(handler: (data: SideChannel) => T): T {\n    this._invalidate = true;\n    return this.using(handler);\n  }\n\n  validator(): (data: SideChannel) => Handler<boolean> {\n    const pairs = this._pairs;\n    return function* (data: SideChannel) {\n      for (const [key, fn] of pairs) {\n        if (key !== (yield* fn(data))) return false;\n      }\n      return true;\n    };\n  }\n\n  deactivate() {\n    this._active = false;\n  }\n\n  configured() {\n    return this._configured;\n  }\n}\n\nfunction makeSimpleConfigurator(\n  cache: CacheConfigurator<any>,\n): SimpleCacheConfigurator {\n  function cacheFn(val: any) {\n    if (typeof val === \"boolean\") {\n      if (val) cache.forever();\n      else cache.never();\n      return;\n    }\n\n    return cache.using(() => assertSimpleType(val()));\n  }\n  cacheFn.forever = () => cache.forever();\n  cacheFn.never = () => cache.never();\n  cacheFn.using = (cb: () => SimpleType) =>\n    cache.using(() => assertSimpleType(cb()));\n  cacheFn.invalidate = (cb: () => SimpleType) =>\n    cache.invalidate(() => assertSimpleType(cb()));\n\n  return cacheFn as any;\n}\n\n// Types are limited here so that in the future these values can be used\n// as part of Babel's caching logic.\nexport type SimpleType =\n  | string\n  | boolean\n  | number\n  | null\n  | void\n  | Promise<SimpleType>;\nexport function assertSimpleType(value: unknown): SimpleType {\n  if (isThenable(value)) {\n    throw new Error(\n      `You appear to be using an async cache handler, ` +\n        `which your current version of Babel does not support. ` +\n        `We may add support for this in the future, ` +\n        `but if you're on the most recent version of @babel/core and still ` +\n        `seeing this error, then you'll need to synchronously handle your caching logic.`,\n    );\n  }\n\n  if (\n    value != null &&\n    typeof value !== \"string\" &&\n    typeof value !== \"boolean\" &&\n    typeof value !== \"number\"\n  ) {\n    throw new Error(\n      \"Cache keys must be either string, boolean, number, null, or undefined.\",\n    );\n  }\n  // @ts-expect-error Type 'unknown' is not assignable to type 'SimpleType'. This can be removed\n  // when strictNullCheck is enabled\n  return value;\n}\n\nclass Lock<T> {\n  released: boolean = false;\n  promise: Promise<T>;\n  _resolve: (value: T) => void;\n\n  constructor() {\n    this.promise = new Promise(resolve => {\n      this._resolve = resolve;\n    });\n  }\n\n  release(value: T) {\n    this.released = true;\n    this._resolve(value);\n  }\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/config-chain.js b/node_modules/@babel/core/lib/config/config-chain.js
new file mode 100644
index 0000000000000000000000000000000000000000..5fded8e6b84cbc073667b8788e880f7b07025c6e
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/config-chain.js
@@ -0,0 +1,469 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildPresetChain = buildPresetChain;
+exports.buildPresetChainWalker = void 0;
+exports.buildRootChain = buildRootChain;
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _debug() {
+  const data = require("debug");
+  _debug = function () {
+    return data;
+  };
+  return data;
+}
+var _options = require("./validation/options.js");
+var _patternToRegex = require("./pattern-to-regex.js");
+var _printer = require("./printer.js");
+var _rewriteStackTrace = require("../errors/rewrite-stack-trace.js");
+var _configError = require("../errors/config-error.js");
+var _index = require("./files/index.js");
+var _caching = require("./caching.js");
+var _configDescriptors = require("./config-descriptors.js");
+const debug = _debug()("babel:config:config-chain");
+function* buildPresetChain(arg, context) {
+  const chain = yield* buildPresetChainWalker(arg, context);
+  if (!chain) return null;
+  return {
+    plugins: dedupDescriptors(chain.plugins),
+    presets: dedupDescriptors(chain.presets),
+    options: chain.options.map(o => createConfigChainOptions(o)),
+    files: new Set()
+  };
+}
+const buildPresetChainWalker = exports.buildPresetChainWalker = makeChainWalker({
+  root: preset => loadPresetDescriptors(preset),
+  env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName),
+  overrides: (preset, index) => loadPresetOverridesDescriptors(preset)(index),
+  overridesEnv: (preset, index, envName) => loadPresetOverridesEnvDescriptors(preset)(index)(envName),
+  createLogger: () => () => {}
+});
+const loadPresetDescriptors = (0, _caching.makeWeakCacheSync)(preset => buildRootDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors));
+const loadPresetEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, envName)));
+const loadPresetOverridesDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index)));
+const loadPresetOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(preset => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(preset, preset.alias, _configDescriptors.createUncachedDescriptors, index, envName))));
+function* buildRootChain(opts, context) {
+  let configReport, babelRcReport;
+  const programmaticLogger = new _printer.ConfigPrinter();
+  const programmaticChain = yield* loadProgrammaticChain({
+    options: opts,
+    dirname: context.cwd
+  }, context, undefined, programmaticLogger);
+  if (!programmaticChain) return null;
+  const programmaticReport = yield* programmaticLogger.output();
+  let configFile;
+  if (typeof opts.configFile === "string") {
+    configFile = yield* (0, _index.loadConfig)(opts.configFile, context.cwd, context.envName, context.caller);
+  } else if (opts.configFile !== false) {
+    configFile = yield* (0, _index.findRootConfig)(context.root, context.envName, context.caller);
+  }
+  let {
+    babelrc,
+    babelrcRoots
+  } = opts;
+  let babelrcRootsDirectory = context.cwd;
+  const configFileChain = emptyChain();
+  const configFileLogger = new _printer.ConfigPrinter();
+  if (configFile) {
+    const validatedFile = validateConfigFile(configFile);
+    const result = yield* loadFileChain(validatedFile, context, undefined, configFileLogger);
+    if (!result) return null;
+    configReport = yield* configFileLogger.output();
+    if (babelrc === undefined) {
+      babelrc = validatedFile.options.babelrc;
+    }
+    if (babelrcRoots === undefined) {
+      babelrcRootsDirectory = validatedFile.dirname;
+      babelrcRoots = validatedFile.options.babelrcRoots;
+    }
+    mergeChain(configFileChain, result);
+  }
+  let ignoreFile, babelrcFile;
+  let isIgnored = false;
+  const fileChain = emptyChain();
+  if ((babelrc === true || babelrc === undefined) && typeof context.filename === "string") {
+    const pkgData = yield* (0, _index.findPackageData)(context.filename);
+    if (pkgData && babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory)) {
+      ({
+        ignore: ignoreFile,
+        config: babelrcFile
+      } = yield* (0, _index.findRelativeConfig)(pkgData, context.envName, context.caller));
+      if (ignoreFile) {
+        fileChain.files.add(ignoreFile.filepath);
+      }
+      if (ignoreFile && shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)) {
+        isIgnored = true;
+      }
+      if (babelrcFile && !isIgnored) {
+        const validatedFile = validateBabelrcFile(babelrcFile);
+        const babelrcLogger = new _printer.ConfigPrinter();
+        const result = yield* loadFileChain(validatedFile, context, undefined, babelrcLogger);
+        if (!result) {
+          isIgnored = true;
+        } else {
+          babelRcReport = yield* babelrcLogger.output();
+          mergeChain(fileChain, result);
+        }
+      }
+      if (babelrcFile && isIgnored) {
+        fileChain.files.add(babelrcFile.filepath);
+      }
+    }
+  }
+  if (context.showConfig) {
+    console.log(`Babel configs on "${context.filename}" (ascending priority):\n` + [configReport, babelRcReport, programmaticReport].filter(x => !!x).join("\n\n") + "\n-----End Babel configs-----");
+  }
+  const chain = mergeChain(mergeChain(mergeChain(emptyChain(), configFileChain), fileChain), programmaticChain);
+  return {
+    plugins: isIgnored ? [] : dedupDescriptors(chain.plugins),
+    presets: isIgnored ? [] : dedupDescriptors(chain.presets),
+    options: isIgnored ? [] : chain.options.map(o => createConfigChainOptions(o)),
+    fileHandling: isIgnored ? "ignored" : "transpile",
+    ignore: ignoreFile || undefined,
+    babelrc: babelrcFile || undefined,
+    config: configFile || undefined,
+    files: chain.files
+  };
+}
+function babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory) {
+  if (typeof babelrcRoots === "boolean") return babelrcRoots;
+  const absoluteRoot = context.root;
+  if (babelrcRoots === undefined) {
+    return pkgData.directories.includes(absoluteRoot);
+  }
+  let babelrcPatterns = babelrcRoots;
+  if (!Array.isArray(babelrcPatterns)) {
+    babelrcPatterns = [babelrcPatterns];
+  }
+  babelrcPatterns = babelrcPatterns.map(pat => {
+    return typeof pat === "string" ? _path().resolve(babelrcRootsDirectory, pat) : pat;
+  });
+  if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) {
+    return pkgData.directories.includes(absoluteRoot);
+  }
+  return babelrcPatterns.some(pat => {
+    if (typeof pat === "string") {
+      pat = (0, _patternToRegex.default)(pat, babelrcRootsDirectory);
+    }
+    return pkgData.directories.some(directory => {
+      return matchPattern(pat, babelrcRootsDirectory, directory, context);
+    });
+  });
+}
+const validateConfigFile = (0, _caching.makeWeakCacheSync)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("configfile", file.options, file.filepath)
+}));
+const validateBabelrcFile = (0, _caching.makeWeakCacheSync)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("babelrcfile", file.options, file.filepath)
+}));
+const validateExtendFile = (0, _caching.makeWeakCacheSync)(file => ({
+  filepath: file.filepath,
+  dirname: file.dirname,
+  options: (0, _options.validate)("extendsfile", file.options, file.filepath)
+}));
+const loadProgrammaticChain = makeChainWalker({
+  root: input => buildRootDescriptors(input, "base", _configDescriptors.createCachedDescriptors),
+  env: (input, envName) => buildEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, envName),
+  overrides: (input, index) => buildOverrideDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index),
+  overridesEnv: (input, index, envName) => buildOverrideEnvDescriptors(input, "base", _configDescriptors.createCachedDescriptors, index, envName),
+  createLogger: (input, context, baseLogger) => buildProgrammaticLogger(input, context, baseLogger)
+});
+const loadFileChainWalker = makeChainWalker({
+  root: file => loadFileDescriptors(file),
+  env: (file, envName) => loadFileEnvDescriptors(file)(envName),
+  overrides: (file, index) => loadFileOverridesDescriptors(file)(index),
+  overridesEnv: (file, index, envName) => loadFileOverridesEnvDescriptors(file)(index)(envName),
+  createLogger: (file, context, baseLogger) => buildFileLogger(file.filepath, context, baseLogger)
+});
+function* loadFileChain(input, context, files, baseLogger) {
+  const chain = yield* loadFileChainWalker(input, context, files, baseLogger);
+  chain == null || chain.files.add(input.filepath);
+  return chain;
+}
+const loadFileDescriptors = (0, _caching.makeWeakCacheSync)(file => buildRootDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors));
+const loadFileEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(envName => buildEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, envName)));
+const loadFileOverridesDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => buildOverrideDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index)));
+const loadFileOverridesEnvDescriptors = (0, _caching.makeWeakCacheSync)(file => (0, _caching.makeStrongCacheSync)(index => (0, _caching.makeStrongCacheSync)(envName => buildOverrideEnvDescriptors(file, file.filepath, _configDescriptors.createUncachedDescriptors, index, envName))));
+function buildFileLogger(filepath, context, baseLogger) {
+  if (!baseLogger) {
+    return () => {};
+  }
+  return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Config, {
+    filepath
+  });
+}
+function buildRootDescriptors({
+  dirname,
+  options
+}, alias, descriptors) {
+  return descriptors(dirname, options, alias);
+}
+function buildProgrammaticLogger(_, context, baseLogger) {
+  var _context$caller;
+  if (!baseLogger) {
+    return () => {};
+  }
+  return baseLogger.configure(context.showConfig, _printer.ChainFormatter.Programmatic, {
+    callerName: (_context$caller = context.caller) == null ? void 0 : _context$caller.name
+  });
+}
+function buildEnvDescriptors({
+  dirname,
+  options
+}, alias, descriptors, envName) {
+  var _options$env;
+  const opts = (_options$env = options.env) == null ? void 0 : _options$env[envName];
+  return opts ? descriptors(dirname, opts, `${alias}.env["${envName}"]`) : null;
+}
+function buildOverrideDescriptors({
+  dirname,
+  options
+}, alias, descriptors, index) {
+  var _options$overrides;
+  const opts = (_options$overrides = options.overrides) == null ? void 0 : _options$overrides[index];
+  if (!opts) throw new Error("Assertion failure - missing override");
+  return descriptors(dirname, opts, `${alias}.overrides[${index}]`);
+}
+function buildOverrideEnvDescriptors({
+  dirname,
+  options
+}, alias, descriptors, index, envName) {
+  var _options$overrides2, _override$env;
+  const override = (_options$overrides2 = options.overrides) == null ? void 0 : _options$overrides2[index];
+  if (!override) throw new Error("Assertion failure - missing override");
+  const opts = (_override$env = override.env) == null ? void 0 : _override$env[envName];
+  return opts ? descriptors(dirname, opts, `${alias}.overrides[${index}].env["${envName}"]`) : null;
+}
+function makeChainWalker({
+  root,
+  env,
+  overrides,
+  overridesEnv,
+  createLogger
+}) {
+  return function* chainWalker(input, context, files = new Set(), baseLogger) {
+    const {
+      dirname
+    } = input;
+    const flattenedConfigs = [];
+    const rootOpts = root(input);
+    if (configIsApplicable(rootOpts, dirname, context, input.filepath)) {
+      flattenedConfigs.push({
+        config: rootOpts,
+        envName: undefined,
+        index: undefined
+      });
+      const envOpts = env(input, context.envName);
+      if (envOpts && configIsApplicable(envOpts, dirname, context, input.filepath)) {
+        flattenedConfigs.push({
+          config: envOpts,
+          envName: context.envName,
+          index: undefined
+        });
+      }
+      (rootOpts.options.overrides || []).forEach((_, index) => {
+        const overrideOps = overrides(input, index);
+        if (configIsApplicable(overrideOps, dirname, context, input.filepath)) {
+          flattenedConfigs.push({
+            config: overrideOps,
+            index,
+            envName: undefined
+          });
+          const overrideEnvOpts = overridesEnv(input, index, context.envName);
+          if (overrideEnvOpts && configIsApplicable(overrideEnvOpts, dirname, context, input.filepath)) {
+            flattenedConfigs.push({
+              config: overrideEnvOpts,
+              index,
+              envName: context.envName
+            });
+          }
+        }
+      });
+    }
+    if (flattenedConfigs.some(({
+      config: {
+        options: {
+          ignore,
+          only
+        }
+      }
+    }) => shouldIgnore(context, ignore, only, dirname))) {
+      return null;
+    }
+    const chain = emptyChain();
+    const logger = createLogger(input, context, baseLogger);
+    for (const {
+      config,
+      index,
+      envName
+    } of flattenedConfigs) {
+      if (!(yield* mergeExtendsChain(chain, config.options, dirname, context, files, baseLogger))) {
+        return null;
+      }
+      logger(config, index, envName);
+      yield* mergeChainOpts(chain, config);
+    }
+    return chain;
+  };
+}
+function* mergeExtendsChain(chain, opts, dirname, context, files, baseLogger) {
+  if (opts.extends === undefined) return true;
+  const file = yield* (0, _index.loadConfig)(opts.extends, dirname, context.envName, context.caller);
+  if (files.has(file)) {
+    throw new Error(`Configuration cycle detected loading ${file.filepath}.\n` + `File already loaded following the config chain:\n` + Array.from(files, file => ` - ${file.filepath}`).join("\n"));
+  }
+  files.add(file);
+  const fileChain = yield* loadFileChain(validateExtendFile(file), context, files, baseLogger);
+  files.delete(file);
+  if (!fileChain) return false;
+  mergeChain(chain, fileChain);
+  return true;
+}
+function mergeChain(target, source) {
+  target.options.push(...source.options);
+  target.plugins.push(...source.plugins);
+  target.presets.push(...source.presets);
+  for (const file of source.files) {
+    target.files.add(file);
+  }
+  return target;
+}
+function* mergeChainOpts(target, {
+  options,
+  plugins,
+  presets
+}) {
+  target.options.push(options);
+  target.plugins.push(...(yield* plugins()));
+  target.presets.push(...(yield* presets()));
+  return target;
+}
+function emptyChain() {
+  return {
+    options: [],
+    presets: [],
+    plugins: [],
+    files: new Set()
+  };
+}
+function createConfigChainOptions(opts) {
+  const options = Object.assign({}, opts);
+  delete options.extends;
+  delete options.env;
+  delete options.overrides;
+  delete options.plugins;
+  delete options.presets;
+  delete options.passPerPreset;
+  delete options.ignore;
+  delete options.only;
+  delete options.test;
+  delete options.include;
+  delete options.exclude;
+  if (hasOwnProperty.call(options, "sourceMap")) {
+    options.sourceMaps = options.sourceMap;
+    delete options.sourceMap;
+  }
+  return options;
+}
+function dedupDescriptors(items) {
+  const map = new Map();
+  const descriptors = [];
+  for (const item of items) {
+    if (typeof item.value === "function") {
+      const fnKey = item.value;
+      let nameMap = map.get(fnKey);
+      if (!nameMap) {
+        nameMap = new Map();
+        map.set(fnKey, nameMap);
+      }
+      let desc = nameMap.get(item.name);
+      if (!desc) {
+        desc = {
+          value: item
+        };
+        descriptors.push(desc);
+        if (!item.ownPass) nameMap.set(item.name, desc);
+      } else {
+        desc.value = item;
+      }
+    } else {
+      descriptors.push({
+        value: item
+      });
+    }
+  }
+  return descriptors.reduce((acc, desc) => {
+    acc.push(desc.value);
+    return acc;
+  }, []);
+}
+function configIsApplicable({
+  options
+}, dirname, context, configName) {
+  return (options.test === undefined || configFieldIsApplicable(context, options.test, dirname, configName)) && (options.include === undefined || configFieldIsApplicable(context, options.include, dirname, configName)) && (options.exclude === undefined || !configFieldIsApplicable(context, options.exclude, dirname, configName));
+}
+function configFieldIsApplicable(context, test, dirname, configName) {
+  const patterns = Array.isArray(test) ? test : [test];
+  return matchesPatterns(context, patterns, dirname, configName);
+}
+function ignoreListReplacer(_key, value) {
+  if (value instanceof RegExp) {
+    return String(value);
+  }
+  return value;
+}
+function shouldIgnore(context, ignore, only, dirname) {
+  if (ignore && matchesPatterns(context, ignore, dirname)) {
+    var _context$filename;
+    const message = `No config is applied to "${(_context$filename = context.filename) != null ? _context$filename : "(unknown)"}" because it matches one of \`ignore: ${JSON.stringify(ignore, ignoreListReplacer)}\` from "${dirname}"`;
+    debug(message);
+    if (context.showConfig) {
+      console.log(message);
+    }
+    return true;
+  }
+  if (only && !matchesPatterns(context, only, dirname)) {
+    var _context$filename2;
+    const message = `No config is applied to "${(_context$filename2 = context.filename) != null ? _context$filename2 : "(unknown)"}" because it fails to match one of \`only: ${JSON.stringify(only, ignoreListReplacer)}\` from "${dirname}"`;
+    debug(message);
+    if (context.showConfig) {
+      console.log(message);
+    }
+    return true;
+  }
+  return false;
+}
+function matchesPatterns(context, patterns, dirname, configName) {
+  return patterns.some(pattern => matchPattern(pattern, dirname, context.filename, context, configName));
+}
+function matchPattern(pattern, dirname, pathToTest, context, configName) {
+  if (typeof pattern === "function") {
+    return !!(0, _rewriteStackTrace.endHiddenCallStack)(pattern)(pathToTest, {
+      dirname,
+      envName: context.envName,
+      caller: context.caller
+    });
+  }
+  if (typeof pathToTest !== "string") {
+    throw new _configError.default(`Configuration contains string/RegExp pattern, but no filename was passed to Babel`, configName);
+  }
+  if (typeof pattern === "string") {
+    pattern = (0, _patternToRegex.default)(pattern, dirname);
+  }
+  return pattern.test(pathToTest);
+}
+0 && 0;
+
+//# sourceMappingURL=config-chain.js.map
diff --git a/node_modules/@babel/core/lib/config/config-chain.js.map b/node_modules/@babel/core/lib/config/config-chain.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..92414e53a24b3b0cf89092347a6dbf16a1a8ee48
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/config-chain.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_path","data","require","_debug","_options","_patternToRegex","_printer","_rewriteStackTrace","_configError","_index","_caching","_configDescriptors","debug","buildDebug","buildPresetChain","arg","context","chain","buildPresetChainWalker","plugins","dedupDescriptors","presets","options","map","o","createConfigChainOptions","files","Set","exports","makeChainWalker","root","preset","loadPresetDescriptors","env","envName","loadPresetEnvDescriptors","overrides","index","loadPresetOverridesDescriptors","overridesEnv","loadPresetOverridesEnvDescriptors","createLogger","makeWeakCacheSync","buildRootDescriptors","alias","createUncachedDescriptors","makeStrongCacheSync","buildEnvDescriptors","buildOverrideDescriptors","buildOverrideEnvDescriptors","buildRootChain","opts","configReport","babelRcReport","programmaticLogger","ConfigPrinter","programmaticChain","loadProgrammaticChain","dirname","cwd","undefined","programmaticReport","output","configFile","loadConfig","caller","findRootConfig","babelrc","babelrcRoots","babelrcRootsDirectory","configFileChain","emptyChain","configFileLogger","validatedFile","validateConfigFile","result","loadFileChain","mergeChain","ignoreFile","babelrcFile","isIgnored","fileChain","filename","pkgData","findPackageData","babelrcLoadEnabled","ignore","config","findRelativeConfig","add","filepath","shouldIgnore","validateBabelrcFile","babelrcLogger","showConfig","console","log","filter","x","join","fileHandling","absoluteRoot","directories","includes","babelrcPatterns","Array","isArray","pat","path","resolve","length","some","pathPatternToRegex","directory","matchPattern","file","validate","validateExtendFile","input","createCachedDescriptors","baseLogger","buildProgrammaticLogger","loadFileChainWalker","loadFileDescriptors","loadFileEnvDescriptors","loadFileOverridesDescriptors","loadFileOverridesEnvDescriptors","buildFileLogger","configure","ChainFormatter","Config","descriptors","_","_context$caller","Programmatic","callerName","name","_options$env","_options$overrides","Error","_options$overrides2","_override$env","override","chainWalker","flattenedConfigs","rootOpts","configIsApplicable","push","envOpts","forEach","overrideOps","overrideEnvOpts","only","logger","mergeExtendsChain","mergeChainOpts","extends","has","from","delete","target","source","Object","assign","passPerPreset","test","include","exclude","hasOwnProperty","call","sourceMaps","sourceMap","items","Map","item","value","fnKey","nameMap","get","set","desc","ownPass","reduce","acc","configName","configFieldIsApplicable","patterns","matchesPatterns","ignoreListReplacer","_key","RegExp","String","_context$filename","message","JSON","stringify","_context$filename2","pattern","pathToTest","endHiddenCallStack","ConfigError"],"sources":["../../src/config/config-chain.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-use-before-define */\n\nimport path from \"node:path\";\nimport buildDebug from \"debug\";\nimport type { Handler } from \"gensync\";\nimport { validate } from \"./validation/options.ts\";\nimport type {\n  ConfigApplicableTest,\n  BabelrcSearch,\n  CallerMetadata,\n  MatchItem,\n  InputOptions,\n  ConfigChainOptions,\n} from \"./validation/options.ts\";\nimport pathPatternToRegex from \"./pattern-to-regex.ts\";\nimport { ConfigPrinter, ChainFormatter } from \"./printer.ts\";\nimport type { ReadonlyDeepArray } from \"./helpers/deep-array.ts\";\n\nimport { endHiddenCallStack } from \"../errors/rewrite-stack-trace.ts\";\nimport ConfigError from \"../errors/config-error.ts\";\nimport type { PluginAPI, PresetAPI } from \"./helpers/config-api.ts\";\n\nconst debug = buildDebug(\"babel:config:config-chain\");\n\nimport {\n  findPackageData,\n  findRelativeConfig,\n  findRootConfig,\n  loadConfig,\n} from \"./files/index.ts\";\nimport type { ConfigFile, IgnoreFile, FilePackageData } from \"./files/index.ts\";\n\nimport { makeWeakCacheSync, makeStrongCacheSync } from \"./caching.ts\";\n\nimport {\n  createCachedDescriptors,\n  createUncachedDescriptors,\n} from \"./config-descriptors.ts\";\nimport type {\n  UnloadedDescriptor,\n  OptionsAndDescriptors,\n  ValidatedFile,\n} from \"./config-descriptors.ts\";\n\nexport type ConfigChain = {\n  plugins: UnloadedDescriptor<PluginAPI>[];\n  presets: UnloadedDescriptor<PresetAPI>[];\n  options: ConfigChainOptions[];\n  files: Set<string>;\n};\n\nexport type PresetInstance = {\n  options: InputOptions;\n  alias: string;\n  dirname: string;\n  externalDependencies: ReadonlyDeepArray<string>;\n};\n\nexport type ConfigContext = {\n  filename: string | undefined;\n  cwd: string;\n  root: string;\n  envName: string;\n  caller: CallerMetadata | undefined;\n  showConfig: boolean;\n};\n\n/**\n * Build a config chain for a given preset.\n */\nexport function* buildPresetChain(\n  arg: PresetInstance,\n  context: any,\n): Handler<ConfigChain | null> {\n  const chain = yield* buildPresetChainWalker(arg, context);\n  if (!chain) return null;\n\n  return {\n    plugins: dedupDescriptors(chain.plugins),\n    presets: dedupDescriptors(chain.presets),\n    options: chain.options.map(o => createConfigChainOptions(o)),\n    files: new Set(),\n  };\n}\n\nexport const buildPresetChainWalker = makeChainWalker<PresetInstance>({\n  root: preset => loadPresetDescriptors(preset),\n  env: (preset, envName) => loadPresetEnvDescriptors(preset)(envName),\n  overrides: (preset, index) => loadPresetOverridesDescriptors(preset)(index),\n  overridesEnv: (preset, index, envName) =>\n    loadPresetOverridesEnvDescriptors(preset)(index)(envName),\n  createLogger: () => () => {}, // Currently we don't support logging how preset is expanded\n});\nconst loadPresetDescriptors = makeWeakCacheSync((preset: PresetInstance) =>\n  buildRootDescriptors(preset, preset.alias, createUncachedDescriptors),\n);\nconst loadPresetEnvDescriptors = makeWeakCacheSync((preset: PresetInstance) =>\n  makeStrongCacheSync((envName: string) =>\n    buildEnvDescriptors(\n      preset,\n      preset.alias,\n      createUncachedDescriptors,\n      envName,\n    ),\n  ),\n);\nconst loadPresetOverridesDescriptors = makeWeakCacheSync(\n  (preset: PresetInstance) =>\n    makeStrongCacheSync((index: number) =>\n      buildOverrideDescriptors(\n        preset,\n        preset.alias,\n        createUncachedDescriptors,\n        index,\n      ),\n    ),\n);\nconst loadPresetOverridesEnvDescriptors = makeWeakCacheSync(\n  (preset: PresetInstance) =>\n    makeStrongCacheSync((index: number) =>\n      makeStrongCacheSync((envName: string) =>\n        buildOverrideEnvDescriptors(\n          preset,\n          preset.alias,\n          createUncachedDescriptors,\n          index,\n          envName,\n        ),\n      ),\n    ),\n);\n\nexport type FileHandling = \"transpile\" | \"ignored\" | \"unsupported\";\nexport type RootConfigChain = ConfigChain & {\n  babelrc: ConfigFile | undefined;\n  config: ConfigFile | undefined;\n  ignore: IgnoreFile | undefined;\n  fileHandling: FileHandling;\n  files: Set<string>;\n};\n\n/**\n * Build a config chain for Babel's full root configuration.\n */\nexport function* buildRootChain(\n  opts: InputOptions,\n  context: ConfigContext,\n): Handler<RootConfigChain | null> {\n  let configReport, babelRcReport;\n  const programmaticLogger = new ConfigPrinter();\n  const programmaticChain = yield* loadProgrammaticChain(\n    {\n      options: opts,\n      dirname: context.cwd,\n    },\n    context,\n    undefined,\n    programmaticLogger,\n  );\n  if (!programmaticChain) return null;\n  const programmaticReport = yield* programmaticLogger.output();\n\n  let configFile;\n  if (typeof opts.configFile === \"string\") {\n    configFile = yield* loadConfig(\n      opts.configFile,\n      context.cwd,\n      context.envName,\n      context.caller,\n    );\n  } else if (opts.configFile !== false) {\n    configFile = yield* findRootConfig(\n      context.root,\n      context.envName,\n      context.caller,\n    );\n  }\n\n  let { babelrc, babelrcRoots } = opts;\n  let babelrcRootsDirectory = context.cwd;\n\n  const configFileChain = emptyChain();\n  const configFileLogger = new ConfigPrinter();\n  if (configFile) {\n    const validatedFile = validateConfigFile(configFile);\n    const result = yield* loadFileChain(\n      validatedFile,\n      context,\n      undefined,\n      configFileLogger,\n    );\n    if (!result) return null;\n    configReport = yield* configFileLogger.output();\n\n    // Allow config files to toggle `.babelrc` resolution on and off and\n    // specify where the roots are.\n    if (babelrc === undefined) {\n      babelrc = validatedFile.options.babelrc;\n    }\n    if (babelrcRoots === undefined) {\n      babelrcRootsDirectory = validatedFile.dirname;\n      babelrcRoots = validatedFile.options.babelrcRoots;\n    }\n\n    mergeChain(configFileChain, result);\n  }\n\n  let ignoreFile, babelrcFile;\n  let isIgnored = false;\n  const fileChain = emptyChain();\n  // resolve all .babelrc files\n  if (\n    (babelrc === true || babelrc === undefined) &&\n    typeof context.filename === \"string\"\n  ) {\n    const pkgData = yield* findPackageData(context.filename);\n\n    if (\n      pkgData &&\n      babelrcLoadEnabled(context, pkgData, babelrcRoots, babelrcRootsDirectory)\n    ) {\n      ({ ignore: ignoreFile, config: babelrcFile } = yield* findRelativeConfig(\n        pkgData,\n        context.envName,\n        context.caller,\n      ));\n\n      if (ignoreFile) {\n        fileChain.files.add(ignoreFile.filepath);\n      }\n\n      if (\n        ignoreFile &&\n        shouldIgnore(context, ignoreFile.ignore, null, ignoreFile.dirname)\n      ) {\n        isIgnored = true;\n      }\n\n      if (babelrcFile && !isIgnored) {\n        const validatedFile = validateBabelrcFile(babelrcFile);\n        const babelrcLogger = new ConfigPrinter();\n        const result = yield* loadFileChain(\n          validatedFile,\n          context,\n          undefined,\n          babelrcLogger,\n        );\n        if (!result) {\n          isIgnored = true;\n        } else {\n          babelRcReport = yield* babelrcLogger.output();\n          mergeChain(fileChain, result);\n        }\n      }\n\n      if (babelrcFile && isIgnored) {\n        fileChain.files.add(babelrcFile.filepath);\n      }\n    }\n  }\n\n  if (context.showConfig) {\n    console.log(\n      `Babel configs on \"${context.filename}\" (ascending priority):\\n` +\n        // print config by the order of ascending priority\n        [configReport, babelRcReport, programmaticReport]\n          .filter(x => !!x)\n          .join(\"\\n\\n\") +\n        \"\\n-----End Babel configs-----\",\n    );\n  }\n  // Insert file chain in front so programmatic options have priority\n  // over configuration file chain items.\n  const chain = mergeChain(\n    mergeChain(mergeChain(emptyChain(), configFileChain), fileChain),\n    programmaticChain,\n  );\n\n  return {\n    plugins: isIgnored ? [] : dedupDescriptors(chain.plugins),\n    presets: isIgnored ? [] : dedupDescriptors(chain.presets),\n    options: isIgnored\n      ? []\n      : chain.options.map(o => createConfigChainOptions(o)),\n    fileHandling: isIgnored ? \"ignored\" : \"transpile\",\n    ignore: ignoreFile || undefined,\n    babelrc: babelrcFile || undefined,\n    config: configFile || undefined,\n    files: chain.files,\n  };\n}\n\nfunction babelrcLoadEnabled(\n  context: ConfigContext,\n  pkgData: FilePackageData,\n  babelrcRoots: BabelrcSearch | undefined,\n  babelrcRootsDirectory: string,\n): boolean {\n  if (typeof babelrcRoots === \"boolean\") return babelrcRoots;\n\n  const absoluteRoot = context.root;\n\n  // Fast path to avoid having to match patterns if the babelrc is just\n  // loading in the standard root directory.\n  if (babelrcRoots === undefined) {\n    return pkgData.directories.includes(absoluteRoot);\n  }\n\n  let babelrcPatterns = babelrcRoots;\n  if (!Array.isArray(babelrcPatterns)) {\n    babelrcPatterns = [babelrcPatterns];\n  }\n  babelrcPatterns = babelrcPatterns.map(pat => {\n    return typeof pat === \"string\"\n      ? path.resolve(babelrcRootsDirectory, pat)\n      : pat;\n  });\n\n  // Fast path to avoid having to match patterns if the babelrc is just\n  // loading in the standard root directory.\n  if (babelrcPatterns.length === 1 && babelrcPatterns[0] === absoluteRoot) {\n    return pkgData.directories.includes(absoluteRoot);\n  }\n\n  return babelrcPatterns.some(pat => {\n    if (typeof pat === \"string\") {\n      pat = pathPatternToRegex(pat, babelrcRootsDirectory);\n    }\n\n    return pkgData.directories.some(directory => {\n      return matchPattern(pat, babelrcRootsDirectory, directory, context);\n    });\n  });\n}\n\nconst validateConfigFile = makeWeakCacheSync(\n  (file: ConfigFile): ValidatedFile => ({\n    filepath: file.filepath,\n    dirname: file.dirname,\n    options: validate(\"configfile\", file.options, file.filepath),\n  }),\n);\n\nconst validateBabelrcFile = makeWeakCacheSync(\n  (file: ConfigFile): ValidatedFile => ({\n    filepath: file.filepath,\n    dirname: file.dirname,\n    options: validate(\"babelrcfile\", file.options, file.filepath),\n  }),\n);\n\nconst validateExtendFile = makeWeakCacheSync(\n  (file: ConfigFile): ValidatedFile => ({\n    filepath: file.filepath,\n    dirname: file.dirname,\n    options: validate(\"extendsfile\", file.options, file.filepath),\n  }),\n);\n\n/**\n * Build a config chain for just the programmatic options passed into Babel.\n */\nconst loadProgrammaticChain = makeChainWalker({\n  root: input => buildRootDescriptors(input, \"base\", createCachedDescriptors),\n  env: (input, envName) =>\n    buildEnvDescriptors(input, \"base\", createCachedDescriptors, envName),\n  overrides: (input, index) =>\n    buildOverrideDescriptors(input, \"base\", createCachedDescriptors, index),\n  overridesEnv: (input, index, envName) =>\n    buildOverrideEnvDescriptors(\n      input,\n      \"base\",\n      createCachedDescriptors,\n      index,\n      envName,\n    ),\n  createLogger: (input, context, baseLogger) =>\n    buildProgrammaticLogger(input, context, baseLogger),\n});\n\n/**\n * Build a config chain for a given file.\n */\nconst loadFileChainWalker = makeChainWalker<ValidatedFile>({\n  root: file => loadFileDescriptors(file),\n  env: (file, envName) => loadFileEnvDescriptors(file)(envName),\n  overrides: (file, index) => loadFileOverridesDescriptors(file)(index),\n  overridesEnv: (file, index, envName) =>\n    loadFileOverridesEnvDescriptors(file)(index)(envName),\n  createLogger: (file, context, baseLogger) =>\n    buildFileLogger(file.filepath, context, baseLogger),\n});\n\nfunction* loadFileChain(\n  input: ValidatedFile,\n  context: ConfigContext,\n  files: Set<ConfigFile>,\n  baseLogger: ConfigPrinter,\n) {\n  const chain = yield* loadFileChainWalker(input, context, files, baseLogger);\n  chain?.files.add(input.filepath);\n\n  return chain;\n}\n\nconst loadFileDescriptors = makeWeakCacheSync((file: ValidatedFile) =>\n  buildRootDescriptors(file, file.filepath, createUncachedDescriptors),\n);\nconst loadFileEnvDescriptors = makeWeakCacheSync((file: ValidatedFile) =>\n  makeStrongCacheSync((envName: string) =>\n    buildEnvDescriptors(\n      file,\n      file.filepath,\n      createUncachedDescriptors,\n      envName,\n    ),\n  ),\n);\nconst loadFileOverridesDescriptors = makeWeakCacheSync((file: ValidatedFile) =>\n  makeStrongCacheSync((index: number) =>\n    buildOverrideDescriptors(\n      file,\n      file.filepath,\n      createUncachedDescriptors,\n      index,\n    ),\n  ),\n);\nconst loadFileOverridesEnvDescriptors = makeWeakCacheSync(\n  (file: ValidatedFile) =>\n    makeStrongCacheSync((index: number) =>\n      makeStrongCacheSync((envName: string) =>\n        buildOverrideEnvDescriptors(\n          file,\n          file.filepath,\n          createUncachedDescriptors,\n          index,\n          envName,\n        ),\n      ),\n    ),\n);\n\nfunction buildFileLogger(\n  filepath: string,\n  context: ConfigContext,\n  baseLogger: ConfigPrinter | void,\n) {\n  if (!baseLogger) {\n    return () => {};\n  }\n  return baseLogger.configure(context.showConfig, ChainFormatter.Config, {\n    filepath,\n  });\n}\n\nfunction buildRootDescriptors(\n  { dirname, options }: Partial<ValidatedFile>,\n  alias: string,\n  descriptors: (\n    dirname: string,\n    options: InputOptions,\n    alias: string,\n  ) => OptionsAndDescriptors,\n) {\n  return descriptors(dirname, options, alias);\n}\n\nfunction buildProgrammaticLogger(\n  _: unknown,\n  context: ConfigContext,\n  baseLogger: ConfigPrinter | void,\n) {\n  if (!baseLogger) {\n    return () => {};\n  }\n  return baseLogger.configure(context.showConfig, ChainFormatter.Programmatic, {\n    callerName: context.caller?.name,\n  });\n}\n\nfunction buildEnvDescriptors(\n  { dirname, options }: Partial<ValidatedFile>,\n  alias: string,\n  descriptors: (\n    dirname: string,\n    options: InputOptions,\n    alias: string,\n  ) => OptionsAndDescriptors,\n  envName: string,\n) {\n  const opts = options.env?.[envName];\n  return opts ? descriptors(dirname, opts, `${alias}.env[\"${envName}\"]`) : null;\n}\n\nfunction buildOverrideDescriptors(\n  { dirname, options }: Partial<ValidatedFile>,\n  alias: string,\n  descriptors: (\n    dirname: string,\n    options: InputOptions,\n    alias: string,\n  ) => OptionsAndDescriptors,\n  index: number,\n) {\n  const opts = options.overrides?.[index];\n  if (!opts) throw new Error(\"Assertion failure - missing override\");\n\n  return descriptors(dirname, opts, `${alias}.overrides[${index}]`);\n}\n\nfunction buildOverrideEnvDescriptors(\n  { dirname, options }: Partial<ValidatedFile>,\n  alias: string,\n  descriptors: (\n    dirname: string,\n    options: InputOptions,\n    alias: string,\n  ) => OptionsAndDescriptors,\n  index: number,\n  envName: string,\n) {\n  const override = options.overrides?.[index];\n  if (!override) throw new Error(\"Assertion failure - missing override\");\n\n  const opts = override.env?.[envName];\n  return opts\n    ? descriptors(\n        dirname,\n        opts,\n        `${alias}.overrides[${index}].env[\"${envName}\"]`,\n      )\n    : null;\n}\n\nfunction makeChainWalker<\n  ArgT extends {\n    options: InputOptions;\n    dirname: string;\n    filepath?: string;\n  },\n>({\n  root,\n  env,\n  overrides,\n  overridesEnv,\n  createLogger,\n}: {\n  root: (configEntry: ArgT) => OptionsAndDescriptors;\n  env: (configEntry: ArgT, env: string) => OptionsAndDescriptors | null;\n  overrides: (configEntry: ArgT, index: number) => OptionsAndDescriptors;\n  overridesEnv: (\n    configEntry: ArgT,\n    index: number,\n    env: string,\n  ) => OptionsAndDescriptors | null;\n  createLogger: (\n    configEntry: ArgT,\n    context: ConfigContext,\n    printer: ConfigPrinter | void,\n  ) => (\n    opts: OptionsAndDescriptors,\n    index?: number | null,\n    env?: string | null,\n  ) => void;\n}): (\n  configEntry: ArgT,\n  context: ConfigContext,\n  files?: Set<ConfigFile>,\n  baseLogger?: ConfigPrinter,\n) => Handler<ConfigChain | null> {\n  return function* chainWalker(input, context, files = new Set(), baseLogger) {\n    const { dirname } = input;\n\n    const flattenedConfigs: {\n      config: OptionsAndDescriptors;\n      index: number | undefined | null;\n      envName: string | undefined | null;\n    }[] = [];\n\n    const rootOpts = root(input);\n    if (configIsApplicable(rootOpts, dirname, context, input.filepath)) {\n      flattenedConfigs.push({\n        config: rootOpts,\n        envName: undefined,\n        index: undefined,\n      });\n\n      const envOpts = env(input, context.envName);\n      if (\n        envOpts &&\n        configIsApplicable(envOpts, dirname, context, input.filepath)\n      ) {\n        flattenedConfigs.push({\n          config: envOpts,\n          envName: context.envName,\n          index: undefined,\n        });\n      }\n\n      (rootOpts.options.overrides || []).forEach((_, index) => {\n        const overrideOps = overrides(input, index);\n        if (configIsApplicable(overrideOps, dirname, context, input.filepath)) {\n          flattenedConfigs.push({\n            config: overrideOps,\n            index,\n            envName: undefined,\n          });\n\n          const overrideEnvOpts = overridesEnv(input, index, context.envName);\n          if (\n            overrideEnvOpts &&\n            configIsApplicable(\n              overrideEnvOpts,\n              dirname,\n              context,\n              input.filepath,\n            )\n          ) {\n            flattenedConfigs.push({\n              config: overrideEnvOpts,\n              index,\n              envName: context.envName,\n            });\n          }\n        }\n      });\n    }\n\n    // Process 'ignore' and 'only' before 'extends' items are processed so\n    // that we don't do extra work loading extended configs if a file is\n    // ignored.\n    if (\n      flattenedConfigs.some(\n        ({\n          config: {\n            options: { ignore, only },\n          },\n        }) => shouldIgnore(context, ignore, only, dirname),\n      )\n    ) {\n      return null;\n    }\n\n    const chain = emptyChain();\n    const logger = createLogger(input, context, baseLogger);\n\n    for (const { config, index, envName } of flattenedConfigs) {\n      if (\n        !(yield* mergeExtendsChain(\n          chain,\n          config.options,\n          dirname,\n          context,\n          files,\n          baseLogger,\n        ))\n      ) {\n        return null;\n      }\n\n      logger(config, index, envName);\n      yield* mergeChainOpts(chain, config);\n    }\n    return chain;\n  };\n}\n\nfunction* mergeExtendsChain(\n  chain: ConfigChain,\n  opts: InputOptions,\n  dirname: string,\n  context: ConfigContext,\n  files: Set<ConfigFile>,\n  baseLogger?: ConfigPrinter,\n): Handler<boolean> {\n  if (opts.extends === undefined) return true;\n\n  const file = yield* loadConfig(\n    opts.extends,\n    dirname,\n    context.envName,\n    context.caller,\n  );\n\n  if (files.has(file)) {\n    throw new Error(\n      `Configuration cycle detected loading ${file.filepath}.\\n` +\n        `File already loaded following the config chain:\\n` +\n        Array.from(files, file => ` - ${file.filepath}`).join(\"\\n\"),\n    );\n  }\n\n  files.add(file);\n  const fileChain = yield* loadFileChain(\n    validateExtendFile(file),\n    context,\n    files,\n    baseLogger,\n  );\n  files.delete(file);\n\n  if (!fileChain) return false;\n\n  mergeChain(chain, fileChain);\n\n  return true;\n}\n\nfunction mergeChain(target: ConfigChain, source: ConfigChain): ConfigChain {\n  target.options.push(...source.options);\n  target.plugins.push(...source.plugins);\n  target.presets.push(...source.presets);\n  for (const file of source.files) {\n    target.files.add(file);\n  }\n\n  return target;\n}\n\nfunction* mergeChainOpts(\n  target: ConfigChain,\n  { options, plugins, presets }: OptionsAndDescriptors,\n): Handler<ConfigChain> {\n  target.options.push(options);\n  target.plugins.push(...(yield* plugins()));\n  target.presets.push(...(yield* presets()));\n\n  return target;\n}\n\nfunction emptyChain(): ConfigChain {\n  return {\n    options: [],\n    presets: [],\n    plugins: [],\n    files: new Set(),\n  };\n}\n\nfunction createConfigChainOptions(opts: InputOptions): ConfigChainOptions {\n  const options = {\n    ...opts,\n  };\n  delete options.extends;\n  delete options.env;\n  delete options.overrides;\n  delete options.plugins;\n  delete options.presets;\n  delete options.passPerPreset;\n  delete options.ignore;\n  delete options.only;\n  delete options.test;\n  delete options.include;\n  delete options.exclude;\n\n  // \"sourceMap\" is just aliased to sourceMap, so copy it over as\n  // we merge the options together.\n  if (Object.hasOwn(options, \"sourceMap\")) {\n    options.sourceMaps = options.sourceMap;\n    delete options.sourceMap;\n  }\n  return options;\n}\n\nfunction dedupDescriptors<API>(\n  items: UnloadedDescriptor<API>[],\n): UnloadedDescriptor<API>[] {\n  const map = new Map<\n    Function,\n    Map<string | void, { value: UnloadedDescriptor<API> }>\n  >();\n\n  const descriptors = [];\n\n  for (const item of items) {\n    if (typeof item.value === \"function\") {\n      const fnKey = item.value;\n      let nameMap = map.get(fnKey);\n      if (!nameMap) {\n        nameMap = new Map();\n        map.set(fnKey, nameMap);\n      }\n      let desc = nameMap.get(item.name);\n      if (!desc) {\n        desc = { value: item };\n        descriptors.push(desc);\n\n        // Treat passPerPreset presets as unique, skipping them\n        // in the merge processing steps.\n        if (!item.ownPass) nameMap.set(item.name, desc);\n      } else {\n        desc.value = item;\n      }\n    } else {\n      descriptors.push({ value: item });\n    }\n  }\n\n  return descriptors.reduce((acc, desc) => {\n    acc.push(desc.value);\n    return acc;\n  }, []);\n}\n\nfunction configIsApplicable(\n  { options }: OptionsAndDescriptors,\n  dirname: string,\n  context: ConfigContext,\n  configName: string,\n): boolean {\n  return (\n    (options.test === undefined ||\n      configFieldIsApplicable(context, options.test, dirname, configName)) &&\n    (options.include === undefined ||\n      configFieldIsApplicable(context, options.include, dirname, configName)) &&\n    (options.exclude === undefined ||\n      !configFieldIsApplicable(context, options.exclude, dirname, configName))\n  );\n}\n\nfunction configFieldIsApplicable(\n  context: ConfigContext,\n  test: ConfigApplicableTest,\n  dirname: string,\n  configName: string,\n): boolean {\n  const patterns = Array.isArray(test) ? test : [test];\n\n  return matchesPatterns(context, patterns, dirname, configName);\n}\n\n/**\n * Print the ignoreList-values in a more helpful way than the default.\n */\nfunction ignoreListReplacer(\n  _key: string,\n  value: MatchItem[] | MatchItem,\n): MatchItem[] | MatchItem | string {\n  if (value instanceof RegExp) {\n    return String(value);\n  }\n\n  return value;\n}\n\n/**\n * Tests if a filename should be ignored based on \"ignore\" and \"only\" options.\n */\nfunction shouldIgnore(\n  context: ConfigContext,\n  ignore: MatchItem[] | undefined | null,\n  only: MatchItem[] | undefined | null,\n  dirname: string,\n): boolean {\n  if (ignore && matchesPatterns(context, ignore, dirname)) {\n    const message = `No config is applied to \"${\n      context.filename ?? \"(unknown)\"\n    }\" because it matches one of \\`ignore: ${JSON.stringify(\n      ignore,\n      ignoreListReplacer,\n    )}\\` from \"${dirname}\"`;\n    debug(message);\n    if (context.showConfig) {\n      console.log(message);\n    }\n    return true;\n  }\n\n  if (only && !matchesPatterns(context, only, dirname)) {\n    const message = `No config is applied to \"${\n      context.filename ?? \"(unknown)\"\n    }\" because it fails to match one of \\`only: ${JSON.stringify(\n      only,\n      ignoreListReplacer,\n    )}\\` from \"${dirname}\"`;\n    debug(message);\n    if (context.showConfig) {\n      console.log(message);\n    }\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Returns result of calling function with filename if pattern is a function.\n * Otherwise returns result of matching pattern Regex with filename.\n */\nfunction matchesPatterns(\n  context: ConfigContext,\n  patterns: MatchItem[],\n  dirname: string,\n  configName?: string,\n): boolean {\n  return patterns.some(pattern =>\n    matchPattern(pattern, dirname, context.filename, context, configName),\n  );\n}\n\nfunction matchPattern(\n  pattern: MatchItem,\n  dirname: string,\n  pathToTest: string | undefined,\n  context: ConfigContext,\n  configName?: string,\n): boolean {\n  if (typeof pattern === \"function\") {\n    return !!endHiddenCallStack(pattern)(pathToTest, {\n      dirname,\n      envName: context.envName,\n      caller: context.caller,\n    });\n  }\n\n  if (typeof pathToTest !== \"string\") {\n    throw new ConfigError(\n      `Configuration contains string/RegExp pattern, but no filename was passed to Babel`,\n      configName,\n    );\n  }\n\n  if (typeof pattern === \"string\") {\n    pattern = pathPatternToRegex(pattern, dirname);\n  }\n  return pattern.test(pathToTest);\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/config-descriptors.js b/node_modules/@babel/core/lib/config/config-descriptors.js
new file mode 100644
index 0000000000000000000000000000000000000000..21fb4146b7f3dcb802756eaf3141d6e424e8a399
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/config-descriptors.js
@@ -0,0 +1,190 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCachedDescriptors = createCachedDescriptors;
+exports.createDescriptor = createDescriptor;
+exports.createUncachedDescriptors = createUncachedDescriptors;
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+var _functional = require("../gensync-utils/functional.js");
+var _index = require("./files/index.js");
+var _item = require("./item.js");
+var _caching = require("./caching.js");
+var _resolveTargets = require("./resolve-targets.js");
+function isEqualDescriptor(a, b) {
+  var _a$file, _b$file, _a$file2, _b$file2;
+  return a.name === b.name && a.value === b.value && a.options === b.options && a.dirname === b.dirname && a.alias === b.alias && a.ownPass === b.ownPass && ((_a$file = a.file) == null ? void 0 : _a$file.request) === ((_b$file = b.file) == null ? void 0 : _b$file.request) && ((_a$file2 = a.file) == null ? void 0 : _a$file2.resolved) === ((_b$file2 = b.file) == null ? void 0 : _b$file2.resolved);
+}
+function* handlerOf(value) {
+  return value;
+}
+function optionsWithResolvedBrowserslistConfigFile(options, dirname) {
+  if (typeof options.browserslistConfigFile === "string") {
+    options.browserslistConfigFile = (0, _resolveTargets.resolveBrowserslistConfigFile)(options.browserslistConfigFile, dirname);
+  }
+  return options;
+}
+function createCachedDescriptors(dirname, options, alias) {
+  const {
+    plugins,
+    presets,
+    passPerPreset
+  } = options;
+  return {
+    options: optionsWithResolvedBrowserslistConfigFile(options, dirname),
+    plugins: plugins ? () => createCachedPluginDescriptors(plugins, dirname)(alias) : () => handlerOf([]),
+    presets: presets ? () => createCachedPresetDescriptors(presets, dirname)(alias)(!!passPerPreset) : () => handlerOf([])
+  };
+}
+function createUncachedDescriptors(dirname, options, alias) {
+  return {
+    options: optionsWithResolvedBrowserslistConfigFile(options, dirname),
+    plugins: (0, _functional.once)(() => createPluginDescriptors(options.plugins || [], dirname, alias)),
+    presets: (0, _functional.once)(() => createPresetDescriptors(options.presets || [], dirname, alias, !!options.passPerPreset))
+  };
+}
+const PRESET_DESCRIPTOR_CACHE = new WeakMap();
+const createCachedPresetDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
+  const dirname = cache.using(dir => dir);
+  return (0, _caching.makeStrongCacheSync)(alias => (0, _caching.makeStrongCache)(function* (passPerPreset) {
+    const descriptors = yield* createPresetDescriptors(items, dirname, alias, passPerPreset);
+    return descriptors.map(desc => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc));
+  }));
+});
+const PLUGIN_DESCRIPTOR_CACHE = new WeakMap();
+const createCachedPluginDescriptors = (0, _caching.makeWeakCacheSync)((items, cache) => {
+  const dirname = cache.using(dir => dir);
+  return (0, _caching.makeStrongCache)(function* (alias) {
+    const descriptors = yield* createPluginDescriptors(items, dirname, alias);
+    return descriptors.map(desc => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc));
+  });
+});
+const DEFAULT_OPTIONS = {};
+function loadCachedDescriptor(cache, desc) {
+  const {
+    value,
+    options = DEFAULT_OPTIONS
+  } = desc;
+  if (options === false) return desc;
+  let cacheByOptions = cache.get(value);
+  if (!cacheByOptions) {
+    cacheByOptions = new WeakMap();
+    cache.set(value, cacheByOptions);
+  }
+  let possibilities = cacheByOptions.get(options);
+  if (!possibilities) {
+    possibilities = [];
+    cacheByOptions.set(options, possibilities);
+  }
+  if (!possibilities.includes(desc)) {
+    const matches = possibilities.filter(possibility => isEqualDescriptor(possibility, desc));
+    if (matches.length > 0) {
+      return matches[0];
+    }
+    possibilities.push(desc);
+  }
+  return desc;
+}
+function* createPresetDescriptors(items, dirname, alias, passPerPreset) {
+  return yield* createDescriptors("preset", items, dirname, alias, passPerPreset);
+}
+function* createPluginDescriptors(items, dirname, alias) {
+  return yield* createDescriptors("plugin", items, dirname, alias);
+}
+function* createDescriptors(type, items, dirname, alias, ownPass) {
+  const descriptors = yield* _gensync().all(items.map((item, index) => createDescriptor(item, dirname, {
+    type,
+    alias: `${alias}$${index}`,
+    ownPass: !!ownPass
+  })));
+  assertNoDuplicates(descriptors);
+  return descriptors;
+}
+function* createDescriptor(pair, dirname, {
+  type,
+  alias,
+  ownPass
+}) {
+  const desc = (0, _item.getItemDescriptor)(pair);
+  if (desc) {
+    return desc;
+  }
+  let name;
+  let options;
+  let value = pair;
+  if (Array.isArray(value)) {
+    if (value.length === 3) {
+      [value, options, name] = value;
+    } else {
+      [value, options] = value;
+    }
+  }
+  let file = undefined;
+  let filepath = null;
+  if (typeof value === "string") {
+    if (typeof type !== "string") {
+      throw new Error("To resolve a string-based item, the type of item must be given");
+    }
+    const resolver = type === "plugin" ? _index.loadPlugin : _index.loadPreset;
+    const request = value;
+    ({
+      filepath,
+      value
+    } = yield* resolver(value, dirname));
+    file = {
+      request,
+      resolved: filepath
+    };
+  }
+  if (!value) {
+    throw new Error(`Unexpected falsy value: ${String(value)}`);
+  }
+  if (typeof value === "object" && value.__esModule) {
+    if (value.default) {
+      value = value.default;
+    } else {
+      throw new Error("Must export a default export when using ES6 modules.");
+    }
+  }
+  if (typeof value !== "object" && typeof value !== "function") {
+    throw new Error(`Unsupported format: ${typeof value}. Expected an object or a function.`);
+  }
+  if (filepath !== null && typeof value === "object" && value) {
+    throw new Error(`Plugin/Preset files are not allowed to export objects, only functions. In ${filepath}`);
+  }
+  return {
+    name,
+    alias: filepath || alias,
+    value,
+    options,
+    dirname,
+    ownPass,
+    file
+  };
+}
+function assertNoDuplicates(items) {
+  const map = new Map();
+  for (const item of items) {
+    if (typeof item.value !== "function") continue;
+    let nameMap = map.get(item.value);
+    if (!nameMap) {
+      nameMap = new Set();
+      map.set(item.value, nameMap);
+    }
+    if (nameMap.has(item.name)) {
+      const conflicts = items.filter(i => i.value === item.value);
+      throw new Error([`Duplicate plugin/preset detected.`, `If you'd like to use two separate instances of a plugin,`, `they need separate names, e.g.`, ``, `  plugins: [`, `    ['some-plugin', {}],`, `    ['some-plugin', {}, 'some unique name'],`, `  ]`, ``, `Duplicates detected are:`, `${JSON.stringify(conflicts, null, 2)}`].join("\n"));
+    }
+    nameMap.add(item.name);
+  }
+}
+0 && 0;
+
+//# sourceMappingURL=config-descriptors.js.map
diff --git a/node_modules/@babel/core/lib/config/config-descriptors.js.map b/node_modules/@babel/core/lib/config/config-descriptors.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..b51b2cbd362407cf3f2ce7e210977eaf4e16ecab
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/config-descriptors.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_gensync","data","require","_functional","_index","_item","_caching","_resolveTargets","isEqualDescriptor","a","b","_a$file","_b$file","_a$file2","_b$file2","name","value","options","dirname","alias","ownPass","file","request","resolved","handlerOf","optionsWithResolvedBrowserslistConfigFile","browserslistConfigFile","resolveBrowserslistConfigFile","createCachedDescriptors","plugins","presets","passPerPreset","createCachedPluginDescriptors","createCachedPresetDescriptors","createUncachedDescriptors","once","createPluginDescriptors","createPresetDescriptors","PRESET_DESCRIPTOR_CACHE","WeakMap","makeWeakCacheSync","items","cache","using","dir","makeStrongCacheSync","makeStrongCache","descriptors","map","desc","loadCachedDescriptor","PLUGIN_DESCRIPTOR_CACHE","DEFAULT_OPTIONS","cacheByOptions","get","set","possibilities","includes","matches","filter","possibility","length","push","createDescriptors","type","gensync","all","item","index","createDescriptor","assertNoDuplicates","pair","getItemDescriptor","Array","isArray","undefined","filepath","Error","resolver","loadPlugin","loadPreset","String","__esModule","default","Map","nameMap","Set","has","conflicts","i","JSON","stringify","join","add"],"sources":["../../src/config/config-descriptors.ts"],"sourcesContent":["import gensync, { type Handler } from \"gensync\";\nimport { once } from \"../gensync-utils/functional.ts\";\n\nimport { loadPlugin, loadPreset } from \"./files/index.ts\";\n\nimport { getItemDescriptor } from \"./item.ts\";\n\nimport {\n  makeWeakCacheSync,\n  makeStrongCacheSync,\n  makeStrongCache,\n} from \"./caching.ts\";\nimport type { CacheConfigurator } from \"./caching.ts\";\n\nimport type {\n  PluginItem,\n  InputOptions,\n  PresetItem,\n} from \"./validation/options.ts\";\n\nimport { resolveBrowserslistConfigFile } from \"./resolve-targets.ts\";\nimport type { PluginAPI, PresetAPI } from \"./helpers/config-api.ts\";\n\n// Represents a config object and functions to lazily load the descriptors\n// for the plugins and presets so we don't load the plugins/presets unless\n// the options object actually ends up being applicable.\nexport type OptionsAndDescriptors = {\n  options: InputOptions;\n  plugins: () => Handler<UnloadedDescriptor<PluginAPI>[]>;\n  presets: () => Handler<UnloadedDescriptor<PresetAPI>[]>;\n};\n\n// Represents a plugin or presets at a given location in a config object.\n// At this point these have been resolved to a specific object or function,\n// but have not yet been executed to call functions with options.\nexport interface UnloadedDescriptor<API, Options = object | undefined> {\n  name: string | undefined;\n  value: object | ((api: API, options: Options, dirname: string) => unknown);\n  options: Options;\n  dirname: string;\n  alias: string;\n  ownPass?: boolean;\n  file?: {\n    request: string;\n    resolved: string;\n  };\n}\n\nfunction isEqualDescriptor<API>(\n  a: UnloadedDescriptor<API>,\n  b: UnloadedDescriptor<API>,\n): boolean {\n  return (\n    a.name === b.name &&\n    a.value === b.value &&\n    a.options === b.options &&\n    a.dirname === b.dirname &&\n    a.alias === b.alias &&\n    a.ownPass === b.ownPass &&\n    a.file?.request === b.file?.request &&\n    a.file?.resolved === b.file?.resolved\n  );\n}\n\nexport type ValidatedFile = {\n  filepath: string;\n  dirname: string;\n  options: InputOptions;\n};\n\n// eslint-disable-next-line require-yield\nfunction* handlerOf<T>(value: T): Handler<T> {\n  return value;\n}\n\nfunction optionsWithResolvedBrowserslistConfigFile(\n  options: InputOptions,\n  dirname: string,\n): InputOptions {\n  if (typeof options.browserslistConfigFile === \"string\") {\n    options.browserslistConfigFile = resolveBrowserslistConfigFile(\n      options.browserslistConfigFile,\n      dirname,\n    );\n  }\n  return options;\n}\n\n/**\n * Create a set of descriptors from a given options object, preserving\n * descriptor identity based on the identity of the plugin/preset arrays\n * themselves, and potentially on the identity of the plugins/presets + options.\n */\nexport function createCachedDescriptors(\n  dirname: string,\n  options: InputOptions,\n  alias: string,\n): OptionsAndDescriptors {\n  const { plugins, presets, passPerPreset } = options;\n  return {\n    options: optionsWithResolvedBrowserslistConfigFile(options, dirname),\n    plugins: plugins\n      ? () =>\n          // @ts-expect-error todo(flow->ts) ts complains about incorrect arguments\n          // eslint-disable-next-line @typescript-eslint/no-use-before-define\n          createCachedPluginDescriptors(plugins, dirname)(alias)\n      : () => handlerOf([]),\n    presets: presets\n      ? () =>\n          // @ts-expect-error todo(flow->ts) ts complains about incorrect arguments\n          // eslint-disable-next-line @typescript-eslint/no-use-before-define\n          createCachedPresetDescriptors(presets, dirname)(alias)(\n            !!passPerPreset,\n          )\n      : () => handlerOf([]),\n  };\n}\n\n/**\n * Create a set of descriptors from a given options object, with consistent\n * identity for the descriptors, but not caching based on any specific identity.\n */\nexport function createUncachedDescriptors(\n  dirname: string,\n  options: InputOptions,\n  alias: string,\n): OptionsAndDescriptors {\n  return {\n    options: optionsWithResolvedBrowserslistConfigFile(options, dirname),\n    // The returned result here is cached to represent a config object in\n    // memory, so we build and memoize the descriptors to ensure the same\n    // values are returned consistently.\n    plugins: once(() =>\n      createPluginDescriptors(options.plugins || [], dirname, alias),\n    ),\n    presets: once(() =>\n      createPresetDescriptors(\n        options.presets || [],\n        dirname,\n        alias,\n        !!options.passPerPreset,\n      ),\n    ),\n  };\n}\n\nconst PRESET_DESCRIPTOR_CACHE = new WeakMap();\nconst createCachedPresetDescriptors = makeWeakCacheSync(\n  (items: PresetItem[], cache: CacheConfigurator<string>) => {\n    const dirname = cache.using(dir => dir);\n    return makeStrongCacheSync((alias: string) =>\n      makeStrongCache(function* (\n        passPerPreset: boolean,\n      ): Handler<UnloadedDescriptor<PresetAPI>[]> {\n        const descriptors = yield* createPresetDescriptors(\n          items,\n          dirname,\n          alias,\n          passPerPreset,\n        );\n        return descriptors.map(\n          // Items are cached using the overall preset array identity when\n          // possibly, but individual descriptors are also cached if a match\n          // can be found in the previously-used descriptor lists.\n          desc => loadCachedDescriptor(PRESET_DESCRIPTOR_CACHE, desc),\n        );\n      }),\n    );\n  },\n);\n\nconst PLUGIN_DESCRIPTOR_CACHE = new WeakMap();\nconst createCachedPluginDescriptors = makeWeakCacheSync(\n  (items: PluginItem[], cache: CacheConfigurator<string>) => {\n    const dirname = cache.using(dir => dir);\n    return makeStrongCache(function* (\n      alias: string,\n    ): Handler<UnloadedDescriptor<PluginAPI>[]> {\n      const descriptors = yield* createPluginDescriptors(items, dirname, alias);\n      return descriptors.map(\n        // Items are cached using the overall plugin array identity when\n        // possibly, but individual descriptors are also cached if a match\n        // can be found in the previously-used descriptor lists.\n        desc => loadCachedDescriptor(PLUGIN_DESCRIPTOR_CACHE, desc),\n      );\n    });\n  },\n);\n\n/**\n * When no options object is given in a descriptor, this object is used\n * as a WeakMap key in order to have consistent identity.\n */\nconst DEFAULT_OPTIONS = {};\n\n/**\n * Given the cache and a descriptor, returns a matching descriptor from the\n * cache, or else returns the input descriptor and adds it to the cache for\n * next time.\n */\nfunction loadCachedDescriptor<API>(\n  cache: WeakMap<object | Function, WeakMap<object, UnloadedDescriptor<API>[]>>,\n  desc: UnloadedDescriptor<API>,\n) {\n  const { value, options = DEFAULT_OPTIONS } = desc;\n  if (options === false) return desc;\n\n  let cacheByOptions = cache.get(value);\n  if (!cacheByOptions) {\n    cacheByOptions = new WeakMap();\n    cache.set(value, cacheByOptions);\n  }\n\n  let possibilities = cacheByOptions.get(options);\n  if (!possibilities) {\n    possibilities = [];\n    cacheByOptions.set(options, possibilities);\n  }\n\n  if (!possibilities.includes(desc)) {\n    const matches = possibilities.filter(possibility =>\n      isEqualDescriptor(possibility, desc),\n    );\n    if (matches.length > 0) {\n      return matches[0];\n    }\n\n    possibilities.push(desc);\n  }\n\n  return desc;\n}\n\nfunction* createPresetDescriptors(\n  items: PresetItem[],\n  dirname: string,\n  alias: string,\n  passPerPreset: boolean,\n): Handler<UnloadedDescriptor<PresetAPI>[]> {\n  return yield* createDescriptors(\n    \"preset\",\n    items,\n    dirname,\n    alias,\n    passPerPreset,\n  );\n}\n\nfunction* createPluginDescriptors(\n  items: PluginItem[],\n  dirname: string,\n  alias: string,\n): Handler<UnloadedDescriptor<PluginAPI>[]> {\n  return yield* createDescriptors(\"plugin\", items, dirname, alias);\n}\n\nfunction* createDescriptors<const Type extends \"plugin\" | \"preset\">(\n  type: Type,\n  items: Type extends \"plugin\" ? PluginItem[] : PresetItem[],\n  dirname: string,\n  alias: string,\n  ownPass?: boolean,\n): Handler<\n  UnloadedDescriptor<Type extends \"plugin\" ? PluginAPI : PresetAPI>[]\n> {\n  const descriptors = yield* gensync.all(\n    items.map((item, index) =>\n      createDescriptor(item, dirname, {\n        type,\n        alias: `${alias}$${index}`,\n        ownPass: !!ownPass,\n      }),\n    ),\n  );\n\n  assertNoDuplicates(descriptors);\n\n  return descriptors;\n}\n\n/**\n * Given a plugin/preset item, resolve it into a standard format.\n */\nexport function* createDescriptor<API>(\n  pair: PluginItem | PresetItem,\n  dirname: string,\n  {\n    type,\n    alias,\n    ownPass,\n  }: {\n    type?: \"plugin\" | \"preset\";\n    alias: string;\n    ownPass?: boolean;\n  },\n): Handler<UnloadedDescriptor<API>> {\n  const desc = getItemDescriptor(pair);\n  if (desc) {\n    return desc;\n  }\n\n  let name;\n  let options;\n  let value = pair;\n  if (Array.isArray(value)) {\n    if (value.length === 3) {\n      [value, options, name] = value;\n    } else {\n      [value, options] = value;\n    }\n  }\n\n  let file = undefined;\n  let filepath = null;\n  if (typeof value === \"string\") {\n    if (typeof type !== \"string\") {\n      throw new Error(\n        \"To resolve a string-based item, the type of item must be given\",\n      );\n    }\n    const resolver = type === \"plugin\" ? loadPlugin : loadPreset;\n    const request = value;\n\n    // @ts-expect-error value must be a PluginItem\n    ({ filepath, value } = yield* resolver(value, dirname));\n\n    file = {\n      request,\n      resolved: filepath,\n    };\n  }\n\n  if (!value) {\n    // eslint-disable-next-line @typescript-eslint/no-base-to-string\n    throw new Error(`Unexpected falsy value: ${String(value)}`);\n  }\n\n  // @ts-expect-error Handle transpiled ES6 modules.\n  if (typeof value === \"object\" && value.__esModule) {\n    // @ts-expect-error Handle transpiled ES6 modules.\n    if (value.default) {\n      // @ts-expect-error Handle transpiled ES6 modules.\n      value = value.default;\n    } else {\n      throw new Error(\"Must export a default export when using ES6 modules.\");\n    }\n  }\n\n  if (typeof value !== \"object\" && typeof value !== \"function\") {\n    throw new Error(\n      `Unsupported format: ${typeof value}. Expected an object or a function.`,\n    );\n  }\n\n  if (filepath !== null && typeof value === \"object\" && value) {\n    // We allow object values for plugins/presets nested directly within a\n    // config object, because it can be useful to define them in nested\n    // configuration contexts.\n    throw new Error(\n      `Plugin/Preset files are not allowed to export objects, only functions. In ${filepath}`,\n    );\n  }\n\n  return {\n    name,\n    alias: filepath || alias,\n    value,\n    options,\n    dirname,\n    ownPass,\n    file,\n  };\n}\n\nfunction assertNoDuplicates<API>(items: UnloadedDescriptor<API>[]): void {\n  const map = new Map();\n\n  for (const item of items) {\n    if (typeof item.value !== \"function\") continue;\n\n    let nameMap = map.get(item.value);\n    if (!nameMap) {\n      nameMap = new Set();\n      map.set(item.value, nameMap);\n    }\n\n    if (nameMap.has(item.name)) {\n      const conflicts = items.filter(i => i.value === item.value);\n      throw new Error(\n        [\n          `Duplicate plugin/preset detected.`,\n          `If you'd like to use two separate instances of a plugin,`,\n          `they need separate names, e.g.`,\n          ``,\n          `  plugins: [`,\n          `    ['some-plugin', {}],`,\n          `    ['some-plugin', {}, 'some unique name'],`,\n          `  ]`,\n          ``,\n          `Duplicates detected are:`,\n          `${JSON.stringify(conflicts, null, 2)}`,\n        ].join(\"\\n\"),\n      );\n    }\n\n    nameMap.add(item.name);\n  }\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/files/configuration.js b/node_modules/@babel/core/lib/config/files/configuration.js
new file mode 100644
index 0000000000000000000000000000000000000000..582fc327e173fefad09fa07c9c1866eb41067282
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/configuration.js
@@ -0,0 +1,290 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ROOT_CONFIG_FILENAMES = void 0;
+exports.findConfigUpwards = findConfigUpwards;
+exports.findRelativeConfig = findRelativeConfig;
+exports.findRootConfig = findRootConfig;
+exports.loadConfig = loadConfig;
+exports.resolveShowConfigPath = resolveShowConfigPath;
+function _debug() {
+  const data = require("debug");
+  _debug = function () {
+    return data;
+  };
+  return data;
+}
+function _fs() {
+  const data = require("fs");
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _json() {
+  const data = require("json5");
+  _json = function () {
+    return data;
+  };
+  return data;
+}
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+var _caching = require("../caching.js");
+var _configApi = require("../helpers/config-api.js");
+var _utils = require("./utils.js");
+var _moduleTypes = require("./module-types.js");
+var _patternToRegex = require("../pattern-to-regex.js");
+var _configError = require("../../errors/config-error.js");
+var fs = require("../../gensync-utils/fs.js");
+require("module");
+var _rewriteStackTrace = require("../../errors/rewrite-stack-trace.js");
+var _async = require("../../gensync-utils/async.js");
+const debug = _debug()("babel:config:loading:files:configuration");
+const ROOT_CONFIG_FILENAMES = exports.ROOT_CONFIG_FILENAMES = ["babel.config.js", "babel.config.cjs", "babel.config.mjs", "babel.config.json", "babel.config.cts", "babel.config.ts", "babel.config.mts"];
+const RELATIVE_CONFIG_FILENAMES = [".babelrc", ".babelrc.js", ".babelrc.cjs", ".babelrc.mjs", ".babelrc.json", ".babelrc.cts"];
+const BABELIGNORE_FILENAME = ".babelignore";
+const runConfig = (0, _caching.makeWeakCache)(function* runConfig(options, cache) {
+  yield* [];
+  return {
+    options: (0, _rewriteStackTrace.endHiddenCallStack)(options)((0, _configApi.makeConfigAPI)(cache)),
+    cacheNeedsConfiguration: !cache.configured()
+  };
+});
+function* readConfigCode(filepath, data) {
+  if (!_fs().existsSync(filepath)) return null;
+  let options = yield* (0, _moduleTypes.default)(filepath, (yield* (0, _async.isAsync)()) ? "auto" : "require", "You appear to be using a native ECMAScript module configuration " + "file, which is only supported when running Babel asynchronously " + "or when using the Node.js `--experimental-require-module` flag.", "You appear to be using a configuration file that contains top-level " + "await, which is only supported when running Babel asynchronously.");
+  let cacheNeedsConfiguration = false;
+  if (typeof options === "function") {
+    ({
+      options,
+      cacheNeedsConfiguration
+    } = yield* runConfig(options, data));
+  }
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new _configError.default(`Configuration should be an exported JavaScript object.`, filepath);
+  }
+  if (typeof options.then === "function") {
+    options.catch == null || options.catch(() => {});
+    throw new _configError.default(`You appear to be using an async configuration, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously return your config.`, filepath);
+  }
+  if (cacheNeedsConfiguration) throwConfigError(filepath);
+  return buildConfigFileObject(options, filepath);
+}
+const cfboaf = new WeakMap();
+function buildConfigFileObject(options, filepath) {
+  let configFilesByFilepath = cfboaf.get(options);
+  if (!configFilesByFilepath) {
+    cfboaf.set(options, configFilesByFilepath = new Map());
+  }
+  let configFile = configFilesByFilepath.get(filepath);
+  if (!configFile) {
+    configFile = {
+      filepath,
+      dirname: _path().dirname(filepath),
+      options
+    };
+    configFilesByFilepath.set(filepath, configFile);
+  }
+  return configFile;
+}
+const packageToBabelConfig = (0, _caching.makeWeakCacheSync)(file => {
+  const babel = file.options.babel;
+  if (babel === undefined) return null;
+  if (typeof babel !== "object" || Array.isArray(babel) || babel === null) {
+    throw new _configError.default(`.babel property must be an object`, file.filepath);
+  }
+  return {
+    filepath: file.filepath,
+    dirname: file.dirname,
+    options: babel
+  };
+});
+const readConfigJSON5 = (0, _utils.makeStaticFileCache)((filepath, content) => {
+  let options;
+  try {
+    options = _json().parse(content);
+  } catch (err) {
+    throw new _configError.default(`Error while parsing config - ${err.message}`, filepath);
+  }
+  if (!options) throw new _configError.default(`No config detected`, filepath);
+  if (typeof options !== "object") {
+    throw new _configError.default(`Config returned typeof ${typeof options}`, filepath);
+  }
+  if (Array.isArray(options)) {
+    throw new _configError.default(`Expected config object but found array`, filepath);
+  }
+  delete options.$schema;
+  return {
+    filepath,
+    dirname: _path().dirname(filepath),
+    options
+  };
+});
+const readIgnoreConfig = (0, _utils.makeStaticFileCache)((filepath, content) => {
+  const ignoreDir = _path().dirname(filepath);
+  const ignorePatterns = content.split("\n").map(line => line.replace(/#.*$/, "").trim()).filter(Boolean);
+  for (const pattern of ignorePatterns) {
+    if (pattern.startsWith("!")) {
+      throw new _configError.default(`Negation of file paths is not supported.`, filepath);
+    }
+  }
+  return {
+    filepath,
+    dirname: _path().dirname(filepath),
+    ignore: ignorePatterns.map(pattern => (0, _patternToRegex.default)(pattern, ignoreDir))
+  };
+});
+function findConfigUpwards(rootDir) {
+  let dirname = rootDir;
+  for (;;) {
+    for (const filename of ROOT_CONFIG_FILENAMES) {
+      if (_fs().existsSync(_path().join(dirname, filename))) {
+        return dirname;
+      }
+    }
+    const nextDir = _path().dirname(dirname);
+    if (dirname === nextDir) break;
+    dirname = nextDir;
+  }
+  return null;
+}
+function* findRelativeConfig(packageData, envName, caller) {
+  let config = null;
+  let ignore = null;
+  const dirname = _path().dirname(packageData.filepath);
+  for (const loc of packageData.directories) {
+    if (!config) {
+      var _packageData$pkg;
+      config = yield* loadOneConfig(RELATIVE_CONFIG_FILENAMES, loc, envName, caller, ((_packageData$pkg = packageData.pkg) == null ? void 0 : _packageData$pkg.dirname) === loc ? packageToBabelConfig(packageData.pkg) : null);
+    }
+    if (!ignore) {
+      const ignoreLoc = _path().join(loc, BABELIGNORE_FILENAME);
+      ignore = yield* readIgnoreConfig(ignoreLoc);
+      if (ignore) {
+        debug("Found ignore %o from %o.", ignore.filepath, dirname);
+      }
+    }
+  }
+  return {
+    config,
+    ignore
+  };
+}
+function findRootConfig(dirname, envName, caller) {
+  return loadOneConfig(ROOT_CONFIG_FILENAMES, dirname, envName, caller);
+}
+function* loadOneConfig(names, dirname, envName, caller, previousConfig = null) {
+  const configs = yield* _gensync().all(names.map(filename => readConfig(_path().join(dirname, filename), envName, caller)));
+  const config = configs.reduce((previousConfig, config) => {
+    if (config && previousConfig) {
+      throw new _configError.default(`Multiple configuration files found. Please remove one:\n` + ` - ${_path().basename(previousConfig.filepath)}\n` + ` - ${config.filepath}\n` + `from ${dirname}`);
+    }
+    return config || previousConfig;
+  }, previousConfig);
+  if (config) {
+    debug("Found configuration %o from %o.", config.filepath, dirname);
+  }
+  return config;
+}
+function* loadConfig(name, dirname, envName, caller) {
+  const filepath = (((v, w) => (v = v.split("."), w = w.split("."), +v[0] > +w[0] || v[0] == w[0] && +v[1] >= +w[1]))(process.versions.node, "8.9") ? require.resolve : (r, {
+    paths: [b]
+  }, M = require("module")) => {
+    let f = M._findPath(r, M._nodeModulePaths(b).concat(b));
+    if (f) return f;
+    f = new Error(`Cannot resolve module '${r}'`);
+    f.code = "MODULE_NOT_FOUND";
+    throw f;
+  })(name, {
+    paths: [dirname]
+  });
+  const conf = yield* readConfig(filepath, envName, caller);
+  if (!conf) {
+    throw new _configError.default(`Config file contains no configuration data`, filepath);
+  }
+  debug("Loaded config %o from %o.", name, dirname);
+  return conf;
+}
+function readConfig(filepath, envName, caller) {
+  const ext = _path().extname(filepath);
+  switch (ext) {
+    case ".js":
+    case ".cjs":
+    case ".mjs":
+    case ".ts":
+    case ".cts":
+    case ".mts":
+      return readConfigCode(filepath, {
+        envName,
+        caller
+      });
+    default:
+      return readConfigJSON5(filepath);
+  }
+}
+function* resolveShowConfigPath(dirname) {
+  const targetPath = process.env.BABEL_SHOW_CONFIG_FOR;
+  if (targetPath != null) {
+    const absolutePath = _path().resolve(dirname, targetPath);
+    const stats = yield* fs.stat(absolutePath);
+    if (!stats.isFile()) {
+      throw new Error(`${absolutePath}: BABEL_SHOW_CONFIG_FOR must refer to a regular file, directories are not supported.`);
+    }
+    return absolutePath;
+  }
+  return null;
+}
+function throwConfigError(filepath) {
+  throw new _configError.default(`\
+Caching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured
+for various types of caching, using the first param of their handler functions:
+
+module.exports = function(api) {
+  // The API exposes the following:
+
+  // Cache the returned value forever and don't call this function again.
+  api.cache(true);
+
+  // Don't cache at all. Not recommended because it will be very slow.
+  api.cache(false);
+
+  // Cached based on the value of some function. If this function returns a value different from
+  // a previously-encountered value, the plugins will re-evaluate.
+  var env = api.cache(() => process.env.NODE_ENV);
+
+  // If testing for a specific env, we recommend specifics to avoid instantiating a plugin for
+  // any possible NODE_ENV value that might come up during plugin execution.
+  var isProd = api.cache(() => process.env.NODE_ENV === "production");
+
+  // .cache(fn) will perform a linear search though instances to find the matching plugin based
+  // based on previous instantiated plugins. If you want to recreate the plugin and discard the
+  // previous instance whenever something changes, you may use:
+  var isProd = api.cache.invalidate(() => process.env.NODE_ENV === "production");
+
+  // Note, we also expose the following more-verbose versions of the above examples:
+  api.cache.forever(); // api.cache(true)
+  api.cache.never();   // api.cache(false)
+  api.cache.using(fn); // api.cache(fn)
+
+  // Return the value that will be cached.
+  return { };
+};`, filepath);
+}
+0 && 0;
+
+//# sourceMappingURL=configuration.js.map
diff --git a/node_modules/@babel/core/lib/config/files/configuration.js.map b/node_modules/@babel/core/lib/config/files/configuration.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..07c99ef74203c2857c1b9aeeab02b86c3a8b5691
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/configuration.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["_debug","data","require","_fs","_path","_json","_gensync","_caching","_configApi","_utils","_moduleTypes","_patternToRegex","_configError","fs","_rewriteStackTrace","_async","debug","buildDebug","ROOT_CONFIG_FILENAMES","exports","RELATIVE_CONFIG_FILENAMES","BABELIGNORE_FILENAME","runConfig","makeWeakCache","options","cache","endHiddenCallStack","makeConfigAPI","cacheNeedsConfiguration","configured","readConfigCode","filepath","nodeFs","existsSync","loadCodeDefault","isAsync","Array","isArray","ConfigError","then","catch","throwConfigError","buildConfigFileObject","cfboaf","WeakMap","configFilesByFilepath","get","set","Map","configFile","dirname","path","packageToBabelConfig","makeWeakCacheSync","file","babel","undefined","readConfigJSON5","makeStaticFileCache","content","json5","parse","err","message","$schema","readIgnoreConfig","ignoreDir","ignorePatterns","split","map","line","replace","trim","filter","Boolean","pattern","startsWith","ignore","pathPatternToRegex","findConfigUpwards","rootDir","filename","join","nextDir","findRelativeConfig","packageData","envName","caller","config","loc","directories","_packageData$pkg","loadOneConfig","pkg","ignoreLoc","findRootConfig","names","previousConfig","configs","gensync","all","readConfig","reduce","basename","loadConfig","name","v","w","process","versions","node","resolve","r","paths","b","M","f","_findPath","_nodeModulePaths","concat","Error","code","conf","ext","extname","resolveShowConfigPath","targetPath","env","BABEL_SHOW_CONFIG_FOR","absolutePath","stats","stat","isFile"],"sources":["../../../src/config/files/configuration.ts"],"sourcesContent":["import buildDebug from \"debug\";\nimport nodeFs from \"node:fs\";\nimport path from \"node:path\";\nimport json5 from \"json5\";\nimport gensync from \"gensync\";\nimport type { Handler } from \"gensync\";\nimport { makeWeakCache, makeWeakCacheSync } from \"../caching.ts\";\nimport type { CacheConfigurator } from \"../caching.ts\";\nimport { makeConfigAPI } from \"../helpers/config-api.ts\";\nimport type { ConfigAPI } from \"../helpers/config-api.ts\";\nimport { makeStaticFileCache } from \"./utils.ts\";\nimport loadCodeDefault from \"./module-types.ts\";\nimport pathPatternToRegex from \"../pattern-to-regex.ts\";\nimport type { FilePackageData, RelativeConfig, ConfigFile } from \"./types.ts\";\nimport type { CallerMetadata, InputOptions } from \"../validation/options.ts\";\nimport ConfigError from \"../../errors/config-error.ts\";\n\nimport * as fs from \"../../gensync-utils/fs.ts\";\n\nimport { createRequire } from \"node:module\";\nimport { endHiddenCallStack } from \"../../errors/rewrite-stack-trace.ts\";\nimport { isAsync } from \"../../gensync-utils/async.ts\";\nconst require = createRequire(import.meta.url);\n\nconst debug = buildDebug(\"babel:config:loading:files:configuration\");\n\nexport const ROOT_CONFIG_FILENAMES = [\n  \"babel.config.js\",\n  \"babel.config.cjs\",\n  \"babel.config.mjs\",\n  \"babel.config.json\",\n  \"babel.config.cts\",\n  \"babel.config.ts\",\n  \"babel.config.mts\",\n];\nconst RELATIVE_CONFIG_FILENAMES = [\n  \".babelrc\",\n  \".babelrc.js\",\n  \".babelrc.cjs\",\n  \".babelrc.mjs\",\n  \".babelrc.json\",\n  \".babelrc.cts\",\n];\n\nconst BABELIGNORE_FILENAME = \".babelignore\";\n\ntype ConfigCacheData = {\n  envName: string;\n  caller: CallerMetadata | undefined;\n};\n\nconst runConfig = makeWeakCache(function* runConfig(\n  options: Function,\n  cache: CacheConfigurator<ConfigCacheData>,\n): Handler<{\n  options: InputOptions | null;\n  cacheNeedsConfiguration: boolean;\n}> {\n  // if we want to make it possible to use async configs\n  yield* [];\n\n  return {\n    options: endHiddenCallStack(options as any as (api: ConfigAPI) => unknown)(\n      makeConfigAPI(cache),\n    ),\n    cacheNeedsConfiguration: !cache.configured(),\n  };\n});\n\nfunction* readConfigCode(\n  filepath: string,\n  data: ConfigCacheData,\n): Handler<ConfigFile | null> {\n  if (!nodeFs.existsSync(filepath)) return null;\n\n  let options = yield* loadCodeDefault(\n    filepath,\n    (yield* isAsync()) ? \"auto\" : \"require\",\n    \"You appear to be using a native ECMAScript module configuration \" +\n      \"file, which is only supported when running Babel asynchronously \" +\n      \"or when using the Node.js `--experimental-require-module` flag.\",\n    \"You appear to be using a configuration file that contains top-level \" +\n      \"await, which is only supported when running Babel asynchronously.\",\n  );\n\n  let cacheNeedsConfiguration = false;\n  if (typeof options === \"function\") {\n    ({ options, cacheNeedsConfiguration } = yield* runConfig(options, data));\n  }\n\n  if (!options || typeof options !== \"object\" || Array.isArray(options)) {\n    throw new ConfigError(\n      `Configuration should be an exported JavaScript object.`,\n      filepath,\n    );\n  }\n\n  // @ts-expect-error todo(flow->ts)\n  if (typeof options.then === \"function\") {\n    // @ts-expect-error We use ?. in case options is a thenable but not a promise\n    options.catch?.(() => {});\n    throw new ConfigError(\n      `You appear to be using an async configuration, ` +\n        `which your current version of Babel does not support. ` +\n        `We may add support for this in the future, ` +\n        `but if you're on the most recent version of @babel/core and still ` +\n        `seeing this error, then you'll need to synchronously return your config.`,\n      filepath,\n    );\n  }\n\n  if (cacheNeedsConfiguration) throwConfigError(filepath);\n\n  return buildConfigFileObject(options, filepath);\n}\n\n// We cache the generated ConfigFile object rather than creating a new one\n// every time, so that it can be used as a cache key in other functions.\nconst cfboaf /* configFilesByOptionsAndFilepath */ = new WeakMap<\n  InputOptions,\n  Map<string, ConfigFile>\n>();\nfunction buildConfigFileObject(\n  options: InputOptions,\n  filepath: string,\n): ConfigFile {\n  let configFilesByFilepath = cfboaf.get(options);\n  if (!configFilesByFilepath) {\n    cfboaf.set(options, (configFilesByFilepath = new Map()));\n  }\n\n  let configFile = configFilesByFilepath.get(filepath);\n  if (!configFile) {\n    configFile = {\n      filepath,\n      dirname: path.dirname(filepath),\n      options,\n    };\n    configFilesByFilepath.set(filepath, configFile);\n  }\n\n  return configFile;\n}\n\nconst packageToBabelConfig = makeWeakCacheSync(\n  (file: ConfigFile): ConfigFile | null => {\n    const babel: unknown = file.options.babel;\n\n    if (babel === undefined) return null;\n\n    if (typeof babel !== \"object\" || Array.isArray(babel) || babel === null) {\n      throw new ConfigError(`.babel property must be an object`, file.filepath);\n    }\n\n    return {\n      filepath: file.filepath,\n      dirname: file.dirname,\n      options: babel,\n    };\n  },\n);\n\nconst readConfigJSON5 = makeStaticFileCache((filepath, content): ConfigFile => {\n  let options;\n  try {\n    options = json5.parse(content);\n  } catch (err) {\n    throw new ConfigError(\n      `Error while parsing config - ${err.message}`,\n      filepath,\n    );\n  }\n\n  if (!options) throw new ConfigError(`No config detected`, filepath);\n\n  if (typeof options !== \"object\") {\n    throw new ConfigError(`Config returned typeof ${typeof options}`, filepath);\n  }\n  if (Array.isArray(options)) {\n    throw new ConfigError(`Expected config object but found array`, filepath);\n  }\n\n  delete options.$schema;\n\n  return {\n    filepath,\n    dirname: path.dirname(filepath),\n    options,\n  };\n});\n\nconst readIgnoreConfig = makeStaticFileCache((filepath, content) => {\n  const ignoreDir = path.dirname(filepath);\n  const ignorePatterns = content\n    .split(\"\\n\")\n    .map(line =>\n      line.replace(process.env.BABEL_8_BREAKING ? /^#.*$/ : /#.*$/, \"\").trim(),\n    )\n    .filter(Boolean);\n\n  for (const pattern of ignorePatterns) {\n    if (pattern.startsWith(\"!\")) {\n      throw new ConfigError(\n        `Negation of file paths is not supported.`,\n        filepath,\n      );\n    }\n  }\n\n  return {\n    filepath,\n    dirname: path.dirname(filepath),\n    ignore: ignorePatterns.map(pattern =>\n      pathPatternToRegex(pattern, ignoreDir),\n    ),\n  };\n});\n\nexport function findConfigUpwards(rootDir: string): string | null {\n  let dirname = rootDir;\n  for (;;) {\n    for (const filename of ROOT_CONFIG_FILENAMES) {\n      if (nodeFs.existsSync(path.join(dirname, filename))) {\n        return dirname;\n      }\n    }\n\n    const nextDir = path.dirname(dirname);\n    if (dirname === nextDir) break;\n    dirname = nextDir;\n  }\n\n  return null;\n}\n\nexport function* findRelativeConfig(\n  packageData: FilePackageData,\n  envName: string,\n  caller: CallerMetadata | undefined,\n): Handler<RelativeConfig> {\n  let config = null;\n  let ignore = null;\n\n  const dirname = path.dirname(packageData.filepath);\n\n  for (const loc of packageData.directories) {\n    if (!config) {\n      config = yield* loadOneConfig(\n        RELATIVE_CONFIG_FILENAMES,\n        loc,\n        envName,\n        caller,\n        packageData.pkg?.dirname === loc\n          ? packageToBabelConfig(packageData.pkg)\n          : null,\n      );\n    }\n\n    if (!ignore) {\n      const ignoreLoc = path.join(loc, BABELIGNORE_FILENAME);\n      ignore = yield* readIgnoreConfig(ignoreLoc);\n\n      if (ignore) {\n        debug(\"Found ignore %o from %o.\", ignore.filepath, dirname);\n      }\n    }\n  }\n\n  return { config, ignore };\n}\n\nexport function findRootConfig(\n  dirname: string,\n  envName: string,\n  caller: CallerMetadata | undefined,\n): Handler<ConfigFile | null> {\n  return loadOneConfig(ROOT_CONFIG_FILENAMES, dirname, envName, caller);\n}\n\nfunction* loadOneConfig(\n  names: string[],\n  dirname: string,\n  envName: string,\n  caller: CallerMetadata | undefined,\n  previousConfig: ConfigFile | null = null,\n): Handler<ConfigFile | null> {\n  const configs = yield* gensync.all(\n    names.map(filename =>\n      readConfig(path.join(dirname, filename), envName, caller),\n    ),\n  );\n  const config = configs.reduce((previousConfig: ConfigFile | null, config) => {\n    if (config && previousConfig) {\n      throw new ConfigError(\n        `Multiple configuration files found. Please remove one:\\n` +\n          ` - ${path.basename(previousConfig.filepath)}\\n` +\n          ` - ${config.filepath}\\n` +\n          `from ${dirname}`,\n      );\n    }\n\n    return config || previousConfig;\n  }, previousConfig);\n\n  if (config) {\n    debug(\"Found configuration %o from %o.\", config.filepath, dirname);\n  }\n  return config;\n}\n\nexport function* loadConfig(\n  name: string,\n  dirname: string,\n  envName: string,\n  caller: CallerMetadata | undefined,\n): Handler<ConfigFile> {\n  const filepath = require.resolve(name, { paths: [dirname] });\n\n  const conf = yield* readConfig(filepath, envName, caller);\n  if (!conf) {\n    throw new ConfigError(\n      `Config file contains no configuration data`,\n      filepath,\n    );\n  }\n\n  debug(\"Loaded config %o from %o.\", name, dirname);\n  return conf;\n}\n\n/**\n * Read the given config file, returning the result. Returns null if no config was found, but will\n * throw if there are parsing errors while loading a config.\n */\nfunction readConfig(\n  filepath: string,\n  envName: string,\n  caller: CallerMetadata | undefined,\n): Handler<ConfigFile | null> {\n  const ext = path.extname(filepath);\n  switch (ext) {\n    case \".js\":\n    case \".cjs\":\n    case \".mjs\":\n    case \".ts\":\n    case \".cts\":\n    case \".mts\":\n      return readConfigCode(filepath, { envName, caller });\n    default:\n      return readConfigJSON5(filepath);\n  }\n}\n\nexport function* resolveShowConfigPath(\n  dirname: string,\n): Handler<string | null> {\n  const targetPath = process.env.BABEL_SHOW_CONFIG_FOR;\n  if (targetPath != null) {\n    const absolutePath = path.resolve(dirname, targetPath);\n    const stats = yield* fs.stat(absolutePath);\n    if (!stats.isFile()) {\n      throw new Error(\n        `${absolutePath}: BABEL_SHOW_CONFIG_FOR must refer to a regular file, directories are not supported.`,\n      );\n    }\n    return absolutePath;\n  }\n  return null;\n}\n\nfunction throwConfigError(filepath: string): never {\n  throw new ConfigError(\n    `\\\nCaching was left unconfigured. Babel's plugins, presets, and .babelrc.js files can be configured\nfor various types of caching, using the first param of their handler functions:\n\nmodule.exports = function(api) {\n  // The API exposes the following:\n\n  // Cache the returned value forever and don't call this function again.\n  api.cache(true);\n\n  // Don't cache at all. Not recommended because it will be very slow.\n  api.cache(false);\n\n  // Cached based on the value of some function. If this function returns a value different from\n  // a previously-encountered value, the plugins will re-evaluate.\n  var env = api.cache(() => process.env.NODE_ENV);\n\n  // If testing for a specific env, we recommend specifics to avoid instantiating a plugin for\n  // any possible NODE_ENV value that might come up during plugin execution.\n  var isProd = api.cache(() => process.env.NODE_ENV === \"production\");\n\n  // .cache(fn) will perform a linear search though instances to find the matching plugin based\n  // based on previous instantiated plugins. If you want to recreate the plugin and discard the\n  // previous instance whenever something changes, you may use:\n  var isProd = api.cache.invalidate(() => process.env.NODE_ENV === \"production\");\n\n  // Note, we also expose the following more-verbose versions of the above examples:\n  api.cache.forever(); // api.cache(true)\n  api.cache.never();   // api.cache(false)\n  api.cache.using(fn); // api.cache(fn)\n\n  // Return the value that will be cached.\n  return { };\n};`,\n    filepath,\n  );\n}\n"],"mappings":"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","ignoreList":[]}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/files/import.cjs b/node_modules/@babel/core/lib/config/files/import.cjs
new file mode 100644
index 0000000000000000000000000000000000000000..46fa5d5cfc41c42efc8b8be53aa993e8a9e3c651
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/import.cjs
@@ -0,0 +1,6 @@
+module.exports = function import_(filepath) {
+  return import(filepath);
+};
+0 && 0;
+
+//# sourceMappingURL=import.cjs.map
diff --git a/node_modules/@babel/core/lib/config/files/import.cjs.map b/node_modules/@babel/core/lib/config/files/import.cjs.map
new file mode 100644
index 0000000000000000000000000000000000000000..2200da80f43f57e23145c3ce719b16743188fd66
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/import.cjs.map
@@ -0,0 +1 @@
+{"version":3,"names":["module","exports","import_","filepath"],"sources":["../../../src/config/files/import.cjs"],"sourcesContent":["// We keep this in a separate file so that in older node versions, where\n// import() isn't supported, we can try/catch around the require() call\n// when loading this file.\n\nmodule.exports = function import_(filepath) {\n  return import(filepath);\n};\n"],"mappings":"AAIAA,MAAM,CAACC,OAAO,GAAG,SAASC,OAAOA,CAACC,QAAQ,EAAE;EAC1C,OAAO,OAAOA,QAAQ,CAAC;AACzB,CAAC;AAAC","ignoreList":[]}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/files/index-browser.js b/node_modules/@babel/core/lib/config/files/index-browser.js
new file mode 100644
index 0000000000000000000000000000000000000000..d8ba7dbc8d7e96837481886ae35931428acca238
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/index-browser.js
@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ROOT_CONFIG_FILENAMES = void 0;
+exports.findConfigUpwards = findConfigUpwards;
+exports.findPackageData = findPackageData;
+exports.findRelativeConfig = findRelativeConfig;
+exports.findRootConfig = findRootConfig;
+exports.loadConfig = loadConfig;
+exports.loadPlugin = loadPlugin;
+exports.loadPreset = loadPreset;
+exports.resolvePlugin = resolvePlugin;
+exports.resolvePreset = resolvePreset;
+exports.resolveShowConfigPath = resolveShowConfigPath;
+function findConfigUpwards(rootDir) {
+  return null;
+}
+function* findPackageData(filepath) {
+  return {
+    filepath,
+    directories: [],
+    pkg: null,
+    isPackage: false
+  };
+}
+function* findRelativeConfig(pkgData, envName, caller) {
+  return {
+    config: null,
+    ignore: null
+  };
+}
+function* findRootConfig(dirname, envName, caller) {
+  return null;
+}
+function* loadConfig(name, dirname, envName, caller) {
+  throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);
+}
+function* resolveShowConfigPath(dirname) {
+  return null;
+}
+const ROOT_CONFIG_FILENAMES = exports.ROOT_CONFIG_FILENAMES = [];
+function resolvePlugin(name, dirname) {
+  return null;
+}
+function resolvePreset(name, dirname) {
+  return null;
+}
+function loadPlugin(name, dirname) {
+  throw new Error(`Cannot load plugin ${name} relative to ${dirname} in a browser`);
+}
+function loadPreset(name, dirname) {
+  throw new Error(`Cannot load preset ${name} relative to ${dirname} in a browser`);
+}
+0 && 0;
+
+//# sourceMappingURL=index-browser.js.map
diff --git a/node_modules/@babel/core/lib/config/files/index-browser.js.map b/node_modules/@babel/core/lib/config/files/index-browser.js.map
new file mode 100644
index 0000000000000000000000000000000000000000..e10ddeeef8bece1675f04692609e1f8fcb4aadb1
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/index-browser.js.map
@@ -0,0 +1 @@
+{"version":3,"names":["findConfigUpwards","rootDir","findPackageData","filepath","directories","pkg","isPackage","findRelativeConfig","pkgData","envName","caller","config","ignore","findRootConfig","dirname","loadConfig","name","Error","resolveShowConfigPath","ROOT_CONFIG_FILENAMES","exports","resolvePlugin","resolvePreset","loadPlugin","loadPreset"],"sources":["../../../src/config/files/index-browser.ts"],"sourcesContent":["/* c8 ignore start */\n\nimport type { Handler } from \"gensync\";\n\nimport type {\n  ConfigFile,\n  IgnoreFile,\n  RelativeConfig,\n  FilePackageData,\n} from \"./types.ts\";\n\nimport type { CallerMetadata } from \"../validation/options.ts\";\n\nexport type { ConfigFile, IgnoreFile, RelativeConfig, FilePackageData };\n\nexport function findConfigUpwards(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  rootDir: string,\n): string | null {\n  return null;\n}\n\n// eslint-disable-next-line require-yield\nexport function* findPackageData(filepath: string): Handler<FilePackageData> {\n  return {\n    filepath,\n    directories: [],\n    pkg: null,\n    isPackage: false,\n  };\n}\n\n// eslint-disable-next-line require-yield\nexport function* findRelativeConfig(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  pkgData: FilePackageData,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  envName: string,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  caller: CallerMetadata | undefined,\n): Handler<RelativeConfig> {\n  return { config: null, ignore: null };\n}\n\n// eslint-disable-next-line require-yield\nexport function* findRootConfig(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  dirname: string,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  envName: string,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  caller: CallerMetadata | undefined,\n): Handler<ConfigFile | null> {\n  return null;\n}\n\n// eslint-disable-next-line require-yield\nexport function* loadConfig(\n  name: string,\n  dirname: string,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  envName: string,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  caller: CallerMetadata | undefined,\n): Handler<ConfigFile> {\n  throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);\n}\n\n// eslint-disable-next-line require-yield\nexport function* resolveShowConfigPath(\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  dirname: string,\n): Handler<string | null> {\n  return null;\n}\n\nexport const ROOT_CONFIG_FILENAMES: string[] = [];\n\ntype Resolved =\n  | { loader: \"require\"; filepath: string }\n  | { loader: \"import\"; filepath: string };\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function resolvePlugin(name: string, dirname: string): Resolved | null {\n  return null;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nexport function resolvePreset(name: string, dirname: string): Resolved | null {\n  return null;\n}\n\nexport function loadPlugin(\n  name: string,\n  dirname: string,\n): Handler<{\n  filepath: string;\n  value: unknown;\n}> {\n  throw new Error(\n    `Cannot load plugin ${name} relative to ${dirname} in a browser`,\n  );\n}\n\nexport function loadPreset(\n  name: string,\n  dirname: string,\n): Handler<{\n  filepath: string;\n  value: unknown;\n}> {\n  throw new Error(\n    `Cannot load preset ${name} relative to ${dirname} in a browser`,\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeO,SAASA,iBAAiBA,CAE/BC,OAAe,EACA;EACf,OAAO,IAAI;AACb;AAGO,UAAUC,eAAeA,CAACC,QAAgB,EAA4B;EAC3E,OAAO;IACLA,QAAQ;IACRC,WAAW,EAAE,EAAE;IACfC,GAAG,EAAE,IAAI;IACTC,SAAS,EAAE;EACb,CAAC;AACH;AAGO,UAAUC,kBAAkBA,CAEjCC,OAAwB,EAExBC,OAAe,EAEfC,MAAkC,EACT;EACzB,OAAO;IAAEC,MAAM,EAAE,IAAI;IAAEC,MAAM,EAAE;EAAK,CAAC;AACvC;AAGO,UAAUC,cAAcA,CAE7BC,OAAe,EAEfL,OAAe,EAEfC,MAAkC,EACN;EAC5B,OAAO,IAAI;AACb;AAGO,UAAUK,UAAUA,CACzBC,IAAY,EACZF,OAAe,EAEfL,OAAe,EAEfC,MAAkC,EACb;EACrB,MAAM,IAAIO,KAAK,CAAC,eAAeD,IAAI,gBAAgBF,OAAO,eAAe,CAAC;AAC5E;AAGO,UAAUI,qBAAqBA,CAEpCJ,OAAe,EACS;EACxB,OAAO,IAAI;AACb;AAEO,MAAMK,qBAA+B,GAAAC,OAAA,CAAAD,qBAAA,GAAG,EAAE;AAO1C,SAASE,aAAaA,CAACL,IAAY,EAAEF,OAAe,EAAmB;EAC5E,OAAO,IAAI;AACb;AAGO,SAASQ,aAAaA,CAACN,IAAY,EAAEF,OAAe,EAAmB;EAC5E,OAAO,IAAI;AACb;AAEO,SAASS,UAAUA,CACxBP,IAAY,EACZF,OAAe,EAId;EACD,MAAM,IAAIG,KAAK,CACb,sBAAsBD,IAAI,gBAAgBF,OAAO,eACnD,CAAC;AACH;AAEO,SAASU,UAAUA,CACxBR,IAAY,EACZF,OAAe,EAId;EACD,MAAM,IAAIG,KAAK,CACb,sBAAsBD,IAAI,gBAAgBF,OAAO,eACnD,CAAC;AACH;AAAC","ignoreList":[]}
\ No newline at end of file
diff --git a/node_modules/@babel/core/lib/config/files/index.js b/node_modules/@babel/core/lib/config/files/index.js
new file mode 100644
index 0000000000000000000000000000000000000000..8750f40a9c80b2ef6cb5d980f4125092b9b2c031
--- /dev/null
+++ b/node_modules/@babel/core/lib/config/files/index.js
@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ROOT_CONFIG_FILENAMES", {
+  enumerable: true,
+  get: function () {
+    return _configuration.ROOT_CONFIG_FILENAMES;
+  }
+});
+Object.defineProperty(exports, "findConfigUpwards", {
+  enumerable: true,
+  get: function () {
+    return _configuration.findConfigUpwards;
+  }
+});
+Object.defineProperty(exports, "findPackageData", {
+  enumerable: true,
+  get: function () {
+    return _package.findPackageData;
+  }
+});
+Object.defineProperty(exports, "findRelativeConfig", {
+  enumerable: true,
+  get: function () {
+    return _configuration.findRelativeConfig;
+  }
+});
+Object.defineProperty(exports, "findRootConfig", {
+  enumerable: true,
+  get: function () {
+    return _configuration.findRootConfig;
+  }
+});
+Object.defineProperty(exports, "loadConfig", {
+  enumerable: true,
+  get: function () {
+    return _configuration.loadConfig;
+  }
+});
+Object.defineProperty(exports, "loadPlugin", {
+  enumerable: true,
+  get: function () {
+    return _plugins.loadPlugin;
+  }
+});
+Object.defineProperty(exports, "loadPreset", {
+  enumerable: true,
+  get: function () {
+    return _plugins.loadPreset;
+  }
+});
+Object.defineProperty(exports, "resolvePlugin", {
+  enumerable: true,
+  get: function () {
+    return _plugins.resolvePlugin;
+  }
+});
+Object.defineProperty(exports, "resolvePreset", {
+  enumerable: true,
+  get: function () {
+    return _plugins.resolvePreset;
+  }
+});
+Object.defineProperty(exports, "resolveShowConfigPath", {
+  enumerable: true,
+  get: function () {
+    return _configuration.resolveShowConfigPath;
+  }
+});
+var _package = require("./package.js");
+var _configuration = require("./configuration.js");
+var _plugins = require("./plugins.js");
+({});
+0 && 0;
+
+//# sourceMappingURL=index.js.map