From c8f8bbc5ac81825fa435eeff4e57ffe779ca5ee9 Mon Sep 17 00:00:00 2001 From: Rawman Grey Date: Sun, 25 Oct 2026 11:19:54 +0300 Subject: [PATCH] feat: pre-generate Directus image previews Bundle extension (upload hook + API endpoint + admin module) that warms Directus image transform cache in-process with an explicit acceptFormat, so the generated file matches the browser's cache key byte-for-byte. - resumable, window-aware backfill with progress + cancel - system + custom presets, effective-format reporting, shadow warnings - storage breakdown (previews vs originals), human-readable API fields - diagnostics: resolve-plan prediction, per-file generate, ops ring buffer - isolated dev/staging compose stack + deploy/rollback scripts Verified on Directus 11.17.4: 40/40 tests, hash-match gate passed, idempotent backfill, custom fixed-format presets, error surfacing. --- .gitignore | 5 + .opencode/.gitignore | 1 + .opencode/feature_list.json | 206 ++ .opencode/goal.md | 249 ++ .opencode/progress.txt | 136 + AGENTS.md | 129 + README.md | 102 + dev/README.md | 48 + dev/compose.dev.yml | 51 + dev/compose.staging.yml | 58 + dev/deploy-staging.sh | 21 + dev/rollback-staging.sh | 13 + dev/seed/test-large.jpg | Bin 0 -> 510156 bytes dev/seed/test.jpg | Bin 0 -> 23726 bytes dev/sync-extension.sh | 13 + package-lock.json | 6346 +++++++++++++++++++++++++++++++++++ package.json | 63 + src/endpoint/index.ts | 312 ++ src/hook/index.ts | 56 + src/lib/backfill.ts | 206 ++ src/lib/diagnostics.test.ts | 77 + src/lib/diagnostics.ts | 97 + src/lib/format.test.ts | 31 + src/lib/format.ts | 34 + src/lib/presets.test.ts | 63 + src/lib/presets.ts | 58 + src/lib/settings.test.ts | 69 + src/lib/settings.ts | 156 + src/lib/state.test.ts | 95 + src/lib/state.ts | 107 + src/lib/storage.test.ts | 42 + src/lib/storage.ts | 162 + src/lib/system-presets.ts | 36 + src/lib/types.ts | 50 + src/lib/warmer.test.ts | 92 + src/lib/warmer.ts | 110 + src/lib/window.test.ts | 47 + src/lib/window.ts | 32 + src/module/index.ts | 14 + src/module/module.vue | 579 ++++ src/shims.d.ts | 11 + tsconfig.json | 28 + 42 files changed, 10005 insertions(+) create mode 100644 .gitignore create mode 100644 .opencode/.gitignore create mode 100644 .opencode/feature_list.json create mode 100644 .opencode/goal.md create mode 100644 .opencode/progress.txt create mode 100644 AGENTS.md create mode 100644 README.md create mode 100644 dev/README.md create mode 100644 dev/compose.dev.yml create mode 100644 dev/compose.staging.yml create mode 100755 dev/deploy-staging.sh create mode 100755 dev/rollback-staging.sh create mode 100644 dev/seed/test-large.jpg create mode 100644 dev/seed/test.jpg create mode 100755 dev/sync-extension.sh create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 src/endpoint/index.ts create mode 100644 src/hook/index.ts create mode 100644 src/lib/backfill.ts create mode 100644 src/lib/diagnostics.test.ts create mode 100644 src/lib/diagnostics.ts create mode 100644 src/lib/format.test.ts create mode 100644 src/lib/format.ts create mode 100644 src/lib/presets.test.ts create mode 100644 src/lib/presets.ts create mode 100644 src/lib/settings.test.ts create mode 100644 src/lib/settings.ts create mode 100644 src/lib/state.test.ts create mode 100644 src/lib/state.ts create mode 100644 src/lib/storage.test.ts create mode 100644 src/lib/storage.ts create mode 100644 src/lib/system-presets.ts create mode 100644 src/lib/types.ts create mode 100644 src/lib/warmer.test.ts create mode 100644 src/lib/warmer.ts create mode 100644 src/lib/window.test.ts create mode 100644 src/lib/window.ts create mode 100644 src/module/index.ts create mode 100644 src/module/module.vue create mode 100644 src/shims.d.ts create mode 100644 tsconfig.json diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..21df11a --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.DS_Store +node_modules +dist +dev/extension +dev/.smoke.env diff --git a/.opencode/.gitignore b/.opencode/.gitignore new file mode 100644 index 0000000..3c3629e --- /dev/null +++ b/.opencode/.gitignore @@ -0,0 +1 @@ +node_modules diff --git a/.opencode/feature_list.json b/.opencode/feature_list.json new file mode 100644 index 0000000..9186709 --- /dev/null +++ b/.opencode/feature_list.json @@ -0,0 +1,206 @@ +{ + "$schema": [ + "/home/rawman/.config/opencode/schemas/feature_list.schema.json" + ], + "features": [ + { + "feature_id": "F01", + "title": "Bundle scaffold (module + hook + endpoint), build pipeline, and local load", + "acceptance_steps": [ + "Run `npm install` → resolves the pinned devDependencies including vue.", + "Run `npm run build` → emits `dist/app.js` and `dist/api.js`; `npm run typecheck` reports 0 errors.", + "`directus-extension link` (or the dev compose stack) loads the bundle into a local Directus 11.17.4 with no error.", + "The `image-previews` module appears in the admin sidebar, `GET /image-previews/status` answers, and a test upload emits the hook debug line.", + "`npm run publish` copies `dist/` + `package.json` to the configured deploy target (staging only at this stage)." + ], + "passes": false, + "notes": [ + "Manifest is a bundle: `path:{app,api}`, `entries[{type:module|hook|endpoint,name,source}]`, `host:^10.10.0 || ^11.0.0`.", + "Module sidebar fields (id/name/icon/routes) live in the entrypoint object, not package.json." + ] + }, + { + "feature_id": "F02", + "title": "Staging environment harness + deploy/rollback scripts (safe testing)", + "acceptance_steps": [ + "`dev/compose.dev.yml` brings up Directus 11.17.4 with its own postgres + redis on a dedicated port, with the extension mounted.", + "The stack seeds from a **restored anonymized DB dump** and a **copy of uploads** (`dev/seed/`), so previews can be tested against realistic data.", + "A documented script builds and deploys to the staging instance, and a rollback script restores the previous `dist/` and disables the extension.", + "Confirmed the local/staging stack shares NOTHING with prod (separate DB, separate storage, separate ports).", + "README documents how to start/stop/seed the stack and the exact anonymization rules used for the dump." + ], + "passes": false, + "blocked_by": [ + "F01" + ], + "notes": [ + "This must land before any feature is tested on real-ish data; never test on the prod instance.", + "Decide staging placement (second compose project on land-nest vs a separate dev box) — goal.md open item #5.", + "Dev harness (dev/compose.dev.yml + sync-extension.sh) verified; staging compose/deploy/rollback templates added but not executed remotely." + ] + }, + { + "feature_id": "F03", + "title": "Persisted settings + progress-state store and the config/status API endpoints", + "acceptance_steps": [ + "`src/lib/settings.ts` reads/writes a JSON settings file under `IMAGE_PREVIEWS_STATE_DIR` (default `/directus/extensions/.image-previews`), merged over env defaults; keys: `enabled` (default false), `windowStart`, `windowEnd`, `concurrency`, `presets`, `formats` (`avif,webp`), `onUpload`, `debug`.", + "`GET /image-previews/config` returns effective settings; `PUT /image-previews/config` validates and persists them; invalid payloads return 400 without corrupting the file.", + "`src/lib/state.ts` appends completed `{file_id,preset_key,format}` records to `state.jsonl` and loads them back; a resume helper returns completed pairs + totals.", + "`GET /image-previews/status` returns `{ running, total, done, remaining, generated, hits, failed, rate, eta, lastRun, nextWindow }`.", + "Unit tests cover settings merge/defaults/validation, config round-trip, state append/resume, status aggregation.", + "`npm test` green and `npm run typecheck` 0 errors." + ], + "passes": true, + "blocked_by": [ + "F02" + ], + "notes": [ + "No native Directus extension-settings store exists; a JSON file under a persisted writable dir is the pragmatic choice.", + "All state is file-backed (PM2 cluster, 8 workers — never in-memory)." + ] + }, + { + "feature_id": "F04", + "title": "Preset registry (system + settings, dynamic) and the in-process warmer core", + "acceptance_steps": [ + "`src/lib/presets.ts` returns the merged preset list in controller order (`[...SYSTEM_ASSET_ALLOW_LIST, ...storage_asset_presets]`) with first-match-wins on duplicate keys.", + "System preset objects come from an `@directus/api` constant import if available, else the version-pinned copy in `src/lib/system-presets.ts`; the mechanism used is recorded in progress.txt.", + "`src/lib/warmer.ts` calls `new services.AssetsService({ schema }).getAsset(fileId, { transformationParams: , acceptFormat })` then destroys/unpipes the returned stream.", + "For a `format:'auto'` preset the warmer emits BOTH `avif` and `webp`; a fixed-`format` preset emits one; a resize-only preset emits none.", + "Concurrency honours the configured limit; a per-preset/format failure (concurrency error, `IllegalAssetTransformation`, missing dims) is caught, logged, and doesn't abort the rest; the result summarises `{ requested, ok, failed }`.", + "Unit tests assert: merged preset order + first-match-wins; variant selection per format; exact `getAsset` args; concurrency cap; error isolation.", + "`npm test` green and `npm run typecheck` 0 errors." + ], + "passes": true, + "blocked_by": [ + "F03" + ], + "notes": [ + "Passing `{ key }` alone is a no-op — always pass the full preset object.", + "`acceptFormat:'avif'` in a direct call equals a browser `Accept: image/avif` (verified) — reproduces the admin cache file without HTTP." + ] + }, + { + "feature_id": "F05", + "title": "Upload hook + new-preset trigger", + "acceptance_steps": [ + "On `files.upload` where `payload.type` starts with `image/` and `onUpload` is enabled, the hook runs the warmer for configured presets off the response path (fire-and-forget; never blocks or fails the upload).", + "A non-image upload performs no warming; a warmer failure never fails or slows the upload.", + "After uploading a test JPEG through the admin, the expected `__.avif` (and `.webp`) files for each configured `format:'auto'` preset appear in the storage root.", + "When a storage asset preset is added/changed, existing images are warmed for it (`settings.update` hook and/or a manual \"sync presets\" action); re-running is idempotent.", + "Under PM2 cluster the hook fires once per upload (logged once, not per worker)." + ], + "passes": true, + "blocked_by": [ + "F04" + ], + "notes": [ + "`files.upload` is the correct/only post-write event in v11.17.4.", + "New-preset trigger mechanics are goal.md open item #3.", + "Decision: manual sync chosen — POST /run is idempotent and warms existing images for all presets; no settings.update auto-trigger." + ] + }, + { + "feature_id": "F06", + "title": "Diagnostics & manual generation API + observability", + "acceptance_steps": [ + "`POST /image-previews/generate` `{ fileId, keys?, formats?, dryRun? }` generates (or dry-runs) previews for ONE file and returns per `(key,format)` `{ ok, cached, filename, bytes, ms, error }`.", + "`GET /image-previews/resolve-plan?fileId=&key=` returns the resolved transforms array, the **predicted cache filename**, and whether it already exists — WITHOUT generating.", + "`GET /image-previews/ops?limit=` returns a recent-operations ring buffer (timestamp, fileId, key, format, ok, ms, error), capped in size.", + "A `debug` setting toggles verbose structured logs; logs carry ids/metadata only, never file contents.", + "All diagnostics endpoints except `/generate` are read-only and safe to call on a live instance.", + "Unit tests cover resolve-plan prediction (given a preset, the predicted filename equals the warmer's produced filename) and ops-ring-buffer behaviour.", + "`npm test` green and `npm run typecheck` 0 errors." + ], + "passes": true, + "blocked_by": [ + "F04" + ], + "notes": [ + "resolve-plan is the debugging tool that proves hash-match before anything is written.", + "Also the autonomous loop's primary feedback channel — keep responses machine-readable." + ] + }, + { + "feature_id": "F07", + "title": "Admin module UI: progress bar, disk usage, config form, diagnostics panel", + "acceptance_steps": [ + "The \"Image Previews\" module renders and shows a progress bar with `done / total`, remaining, throughput, ETA, plus last-run and next-window times.", + "During a run the page live-updates (polls `/status`); \"Run now\" / \"Cancel\" controls start/stop a run.", + "A disk-usage panel shows total bytes + count of preview files (list the storage root, sum `stat()` sizes of `__` files); a refresh control recomputes it.", + "A config form edits `enabled`, maintenance window, concurrency, preset selection, formats, `onUpload`, `debug`, persisting via `PUT /config`; changes take effect without rebuilding.", + "A diagnostics panel lists recent operations (`/ops`) and lets an operator run generate/dry-run/resolve-plan for a pasted file id.", + "Invalid input is rejected client-side with a clear message; a saved change is reflected after reload.", + "Smoke-verified on the staging stack (notes/screenshots in progress.txt)." + ], + "passes": false, + "blocked_by": [ + "F06" + ], + "notes": [ + "Use Directus UI components / the private-view shell; keep it minimal.", + "Concurrency is the throttle knob here because in-process generation bypasses the HTTP rate limiter." + ] + }, + { + "feature_id": "F08", + "title": "Resumable backfill engine (window-aware, throttled, progress-reporting)", + "acceptance_steps": [ + "The job enumerates `directus_files` with `type` starting `image/` (paginated) and runs the warmer for each file × configured preset × format.", + "It only runs inside the configured maintenance window, or on an explicit manual run; starting outside the window when scheduled is a logged no-op.", + "It honours the configured concurrency cap and appends completed pairs to `state.jsonl`; restarting after a kill resumes from the last completed pair.", + "Progress is observable during a run via `GET /status` and periodic log lines.", + "A second full run over an already-warmed library reports zero new generations (idempotent).", + "A >6000px original or a concurrency error is recorded as `failed` for that pair; the job continues.", + "`POST /run` starts a run, `POST /run/cancel` stops it; a second concurrent run returns 409 (cluster-wide lock file)." + ], + "passes": true, + "blocked_by": [ + "F07" + ], + "notes": [ + "Run state is file-backed; only one run at a time across the cluster.", + "Scheduling: external cron hitting `/run` (default) vs in-process timer — goal.md open item #4." + ] + }, + { + "feature_id": "F09", + "title": "Verification harness: hash-match gate + cold/warm timing + disk counts", + "acceptance_steps": [ + "For one real file, the on-disk filename produced by an admin browser request for `?key=system-medium-cover` is byte-identical to the warmer's non-dry-run output for the same key+format (the avif variant matches the browser's avif request).", + "The same is demonstrated for `system-large-cover` (image field) and `system-small-cover` (image display).", + "A timing check prints cold vs warm `GET /assets/?key=system-medium-cover`; warm is materially faster.", + "Preview-file count and total bytes are reported before/after a backfill chunk and increase by the expected number of (file × preset × format) entries.", + "Findings (observed admin query string, resulting filenames, uuids, timings) are recorded in progress.txt." + ], + "passes": true, + "blocked_by": [ + "F08" + ], + "notes": [ + "Make-or-break gate: if the warmer's filename does not match the admin's, the approach is wrong — revisit before rollout.", + "Also validates the system-preset copy from F04." + ] + }, + { + "feature_id": "F10", + "title": "Ops: fail-open/disabled-by-default, prod rollout + rollback, scheduling, docs, remote-feedback runbook", + "acceptance_steps": [ + "Every entrypoint body is wrapped so a thrown error is logged and swallowed (never propagates into Directus core), and ALL behavior is gated by `enabled` (default false) — a loaded-but-disabled extension is inert, proven by loading it on staging with `enabled=false`.", + "A documented prod rollout procedure exists: backup previous `dist/` → deploy → healthcheck → enable via config; and a rollback that restores `dist/` and disables.", + "A documented scheduling setup runs the backfill inside the maintenance window (cron hitting `POST /image-previews/run`, by default).", + "`README.md` documents purpose, install/build/publish, every setting, presets/formats warmed, run/resume/cancel, disk reporting, and the maintenance window; `AGENTS.md` captures the transform invariants and safety rules.", + "A **remote-feedback runbook** documents the scoped token and/or restricted SSH access for the autonomous loop (staging only, no prod Docker socket, no prod admin token, private network), and the machine-readable endpoints used as the feedback channel.", + "Final end-to-end pass on staging: upload a fresh image → previews appear with no admin-visible delay; a small backfill chunk completes with the progress bar advancing and disk usage updating; then a controlled prod enable with rollback verified." + ], + "passes": false, + "blocked_by": [ + "F09" + ], + "notes": [ + "Promotion to prod is a human action; the loop proposes, a human deploys.", + "Record the exact cron entry, the scoped grants, and the rollback commands verbatim." + ] + } + ] +} diff --git a/.opencode/goal.md b/.opencode/goal.md new file mode 100644 index 0000000..eaaf91b --- /dev/null +++ b/.opencode/goal.md @@ -0,0 +1,249 @@ +# Goal: Directus image preview pre-generation + +Status: SCAFFOLDED — opened 2026-10-25. Standalone extension project (not part of the +landshaft.life app repo). +Location: `/home/rawman/Projects/DirectusExtensions/directus-extension-generate-image-previews` +Target server: `land-nest`, Directus **11.17.4** (self-hosted, PM2 cluster, local disk storage). +Project type: Directus **bundle** extension (app module + api hook + api endpoint). + +## Summary + +Pre-generate Directus image transform ("preview") cache files so the admin UI never pays the +first-request sharp cost. One warmer, several triggers: + +- **upload hook** — after an image upload, warm its previews. +- **new-preset trigger** — when a storage asset preset is added/changed, warm it for existing images. +- **backfill job** — a resumable, scheduled sweep over the existing `directus_files` library, inside a + configurable maintenance window. +- **manual / diagnostics** — generate (or dry-run) previews for a single file on demand, to debug. + +Plus an **admin module** ("Image Previews") with a **progress bar**, **disk usage**, a **config form** +(persisted, no rebuild), and a **diagnostics panel**. + +## Verified mechanism (source-checked against tag v11.17.4) + +The on-disk transform cache file is: + +``` +__. +``` + +written **beside the original** in the storage root (`STORAGE_LOCAL_ROOT=./uploads`). + +- `hash` = `object-hash@3` defaults: sha1/hex, `unorderedArrays:false` (**array order matters**), + `unorderedObjects:true`. Hashed over the **RESOLVED** transform array from `resolvePreset`. +- `resolvePreset` order is fixed: `(1) copy transformationParams.transforms[]`, `(2) push toFormat` + (if `format`/`quality`), `(3) push resize` (+`extract` on focal cover). +- `maybeExtractFormat` picks the last `toFormat` arg as the file extension. +- `AssetsService.getAsset` checks `exists(assetFilename)` first (cache hit → no sharp); on miss runs + sharp and **awaits** `storage.write(...)` before returning. Not draining the returned stream only + leaks an FD (never truncates). +- Called as sudo (`new AssetsService({ schema })`) it needs **no** HTTP request context. + +## Why the naive / community approach FAILS (must not repeat) + +1. **`{ key }` alone is a no-op.** `resolvePreset` never reads `key`. Pass the **full preset object**. +2. **`format:'auto'` mismatch.** Every `system-*` preset is `format:'auto'`. `getFormat` with no + `acceptFormat` → JPEG→`jpg`/PNG→`png`; a browser `Accept: image/avif` → `avif`. Different + `toFormat` arg → different hash → **guaranteed miss**. +3. Disproved myths: the write is awaited; the admin does NOT use `width`/`height`. +4. Raw params resolve to `[toFormat, resize]`; a preset resolves to `[resize, toFormat]` → different hash. + +## Chosen strategy — IN-PROCESS generation (no token, no HTTP, no rate limiter) + +Because this is an internal extension, generate by calling Directus's own service in-process: + +```ts +const assets = new services.AssetsService({ schema }); // sudo +const { stream } = await assets.getAsset(fileId, { + transformationParams: presetObject, // FULL object, not { key } + acceptFormat: 'avif', // or 'webp' +}); +(stream as Readable).destroy?.(); +``` + +`acceptFormat` reproduces exactly what a browser's `Accept` header does, so the cache filename is +byte-identical to the admin/browser read — **without any HTTP request, token, proxy, or rate limiter**. +Generate **two variants** for `format:'auto'` presets (`avif`, `webp`); fixed-`format` presets yield +one; resize-only presets (no `format`/`quality`) yield none. + +HTTP-replay (`GET /assets/{id}?key=…` with a browser `Accept` + auth) is the documented **fallback** +only — it needs a token and rate-limiter pacing, which is why it is not the default. + +## Preset registry (system + settings, dynamic) + +The controller builds its preset list inline as: + +``` +res.locals['shortcuts'] = [...SYSTEM_ASSET_ALLOW_LIST, ...(directus_settings.storage_asset_presets ?? [])] +``` + +and resolves `?key=` with `.find(t => t.key === key)` → **first match wins** (a system key shadows a +custom preset of the same key). There is **no** reusable helper and `GET /settings` exposes **only** +custom presets. + +Our registry (`src/lib/presets.ts`) mirrors this exact list: + +- **System presets**: 6 objects in `SYSTEM_ASSET_ALLOW_LIST` (`system-small|medium|large` × + `cover|contain`), each `format:'auto'`, resize inside `transforms[]`; sourced at runtime from + `@directus/api` **if** importable, else the version-pinned copy `src/lib/system-presets.ts` (v11.17.4). +- **Custom presets**: read `directus_settings.storage_asset_presets` each run; pass the verbatim object. +- **Dynamic**: newly created presets are picked up per run; the new-preset trigger warms them for + existing images. + +## Admin UI (module "Image Previews") + +- **Progress**: bar + `done / total / remaining`, throughput, ETA, last-run, next-window; live during a run. +- **Storage breakdown**: bytes + file counts separately for **preview assets** (`__`), **original + assets**, and the total — raw and human-readable. Computed by listing the storage root and `stat()`-ing + each file (listing yields paths only, no sizes); the state dir is excluded. +- **Config form** (persisted, no rebuild; defaults `enabled:true`, window `01:00–04:00`): `enabled`, + maintenance window, concurrency, preset selection, formats, `onUpload`, `debug`; each field carries a + plain-language explanation. **Run now** ignores the window; **Cancel** is shown only while a run is active. +- **Diagnostics panel**: recent operations, per-file generate/dry-run, resolve-plan viewer. + +## Diagnostics & manual generation (observability) + +- `POST /image-previews/generate` `{ fileId, keys?, formats?, dryRun? }` → generate (or dry-run) for ONE + file; returns per `(key,format)` `{ ok, failed, cached, filename, bytes, ms, error }`. Primary dev tool. +- `GET /image-previews/resolve-plan?fileId=&key=` → resolved transforms + **predicted cache filename** + + whether it already exists, WITHOUT generating. The hash-match debugging tool. +- `GET /image-previews/ops?limit=` → recent-operations ring buffer (timestamp, fileId, key, format, ok, ms, error). +- `debug` setting enables verbose structured logs; logs carry ids/metadata only, never file contents. +- Everything except `/generate` is read-only. + +## Safe deployment & staging (must not crash prod) + +- **Fail-open, inert by default**: every entrypoint is tiny, bodies wrapped in try/catch, hooks never + throw into Directus core, and ALL behavior is gated by `enabled` (default `false`). A loaded-but-disabled + extension does nothing. +- **Local dev**: `directus-extension link` (or the dev compose stack) loads `src/` live for iteration. +- **Staging stack**: a second compose project (`dev/compose.dev.yml`) running the SAME Directus 11.17.4 + image with its own pg+redis, a **restored anonymized dump**, and a **copy of uploads**, on a separate + port — realistic data, zero prod risk. +- **Rollout discipline**: build → verify on staging → back up the previous `dist/` → copy in → healthcheck + → enable via config → rollback = restore previous `dist/` + disable. +- `EXTENSIONS_AUTO_RELOAD` in prod reloads on file change; deploy with it controlled and accept the brief + reload, or restart deliberately. + +## Remote feedback & autonomous operation (security) + +- Feedback channel = the extension's own **machine-readable endpoints** (`/status`, `/ops`, + `/disk-usage`, `/resolve-plan`). Automation reads those, not CMS content. +- **Least privilege**: + - A Directus **admin token = full CMS control**. Do NOT give it to an autonomous loop. Use a scoped + token reaching only `/image-previews/*` (+ `directus_files` metadata read). + - A **Docker socket = root-equivalent**. Never expose the prod socket to automation; keep the loop on staging. + - Deployment access = a dedicated **non-sudo** SSH user with a restricted key (`restrict`, `from=`, + `command=`), or run opencode on the staging host via `handoff`. +- **Network**: staging reachable only over a private network / VPN / tunnel — never public. +- **Prompt-injection**: treat logs, filenames, and image metadata as untrusted input; keep tooling scoped. +- **Promotion to prod is a human action**: the loop proposes, a human merges/deploys. +- Guard long autonomous runs with a cost/time budget. + +## Design + +``` +src/ + hook/index.ts (api) files.upload -> warmer; settings/presets change -> warm existing + endpoint/index.ts (api) routes: /config (GET/PUT), /status, /run, /run/cancel, + /disk-usage, /generate, /resolve-plan, /ops + module/ + index.ts (app) defineModule({ id:'image-previews', name, icon, routes }) + module.vue progress + disk usage + config form + diagnostics panel + lib/ + presets.ts merged registry (system + settings), mirrors controller semantics + system-presets.ts version-pinned SYSTEM_ASSET_ALLOW_LIST copy (v11.17.4) + warmer.ts in-process getAsset(x, { transformationParams, acceptFormat }) + concurrency + backfill.ts enumerate directus_files (image/*), window-aware, resumable + state.ts state.jsonl read/append/resume + settings.ts config file read/write + env defaults + disk.ts sum sizes of __ files (driver.list + stat) + window.ts maintenance-window logic (is-now-in-window, next-window) + diagnostics.ts resolve-plan/dry-run (resolved transforms + predicted filename), ops ring buffer +dev/ + compose.dev.yml local Directus 11.17.4 + postgres + redis, extension linked + seed/ anonymized DB dump + sample images for local/staging runs +``` + +## Non-goals + +- No Directus upgrade (server stays on 11.17.4; license constraint). +- No change to admin preset configuration or to how the admin builds URLs. +- Never hand-write `__.` filenames. +- No CDN/nginx caching work (separate ops concern). No image `quality` policy change. +- Automation never gets prod Docker socket or a full prod admin token. + +## Constraints / risks + +- `ASSETS_TRANSFORM_MAX_CONCURRENT=45` per worker; over it errors. Catch per file/preset and continue + (never fail the upload). +- `ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION` default 6000 is a **pixel dimension** guard in Directus, not a + file-size limit. The extension imposes no limit of its own; raise the Directus env var to process larger + images (watch memory). Upload-size limits (`FILES_MAX_UPLOAD_SIZE`, `MAX_PAYLOAD_SIZE`) are unrelated. +- Local storage write is **non-atomic** → warm only AFTER an upload is committed; serialize so the + upload hook and the backfill never generate the same file concurrently. +- PM2 cluster (8 workers): the upload hook fires on the handling worker; the backfill runs in the worker + that served the run request. Shared state MUST be file/DB-backed (never in-memory). +- In-process backfill competes with live API serving → the maintenance window + concurrency cap govern + that. (HTTP rate limiter is irrelevant in-process.) +- Observed server bottleneck (2026-10-23): `storage:local:responseTime 1206ms`, `pg:responseTime` + 150–738ms; no 503s, no sharp errors. + +## Verification policy + +- `npm run typecheck` → 0 errors; `npm test` (node:test via tsx) green. +- **The hash-match gate (F09)**: for a real file, the on-disk filename produced by a browser/admin + request for `?key=system-medium-cover` is byte-identical to the warmer's output for the same key+format + (+ the resolved extension matches, e.g. `.avif`). +- Cold-vs-warm timing; preview-file count + total bytes before/after a run. +- All feature testing happens on the **staging** stack; prod deploy only at goal completion, via the + documented backup/rollback procedure. + +## Expected files + +- `package.json`, `tsconfig.json`, `.gitignore` +- `src/hook/`, `src/endpoint/`, `src/module/`, `src/lib/`, plus `src/**/*.test.ts` +- `dev/compose.dev.yml`, `dev/seed/` +- `.opencode/goal.md`, `.opencode/feature_list.json`, `.opencode/progress.txt` +- `README.md`, `AGENTS.md` + +## Resolved decisions (2026-10-25) + +1. State/config: JSON files under `/.image-previews` (default + `/directus/uploads/.image-previews`), override with `IMAGE_PREVIEWS_STATE_DIR`. The former + `/directus/extensions/.image-previews` default was rejected — root-owned volume → `EACCES`. +2. System presets: version-pinned copy (`src/lib/system-presets.ts`, verbatim v11.17.4); no + `@directus/api` import needed for presets. +3. New-preset trigger: manual `POST /run` (idempotent) + the module's Run button; no + `settings.update` auto-trigger. +4. Backfill scheduling: external cron → `POST /image-previews/run`. +5. Dev/staging: isolated local compose stack (`dev/compose.dev.yml`). A land-nest staging project is + still to be created for realistic-data runs. +6. Autonomous-loop grants: still to be defined (scoped token / restricted SSH, staging only). + +## Implementation status (2026-10-25) + +Implemented and verified against an isolated Directus 11.17.4: settings/state, presets + warmer, +upload hook, diagnostics, backfill, endpoints. `npm test` 32/32, typecheck clean, build emits both +bundles. **Hash-match gate passed** (a real browser-style asset request produced exactly the +predicted filename). Features F03–F06, F08, F09 pass. + +Outstanding: admin-module browser verification (F07), staging deploy/rollback + prod rollout (F02/F10), +and the F01 publish-to-staging step. + +## Reference: source anchors (v11.17.4) + +- `api/src/services/assets.ts` — `getAsset`, `getAssetSuffix`, filename build, awaited `write`. +- `api/src/utils/transformations.ts` — `resolvePreset`, `getFormat`. +- `api/src/controllers/assets.ts` — inline `shortcuts = [...SYSTEM_ASSET_ALLOW_LIST, ...settings]`, + `acceptFormat` selection from `req.headers.accept`. +- `api/src/constants.ts` — `SYSTEM_ASSET_ALLOW_LIST` (6 presets, `format:'auto'`); + `ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION` default 6000. +- `app/src/utils/get-asset-url.ts`, `app/src/layouts/cards/components/card.vue`, + `app/src/interfaces/file-image/file-image.vue`, `app/src/displays/image/image.vue` — admin URLs: + Files grid `?key=system-medium-cover&v=`; image field `system-large-cover|contain`; + image display `system-small-cover`. +- `packages/storage-driver-local/src/index.ts` — non-atomic `write`; `list()` returns paths only. +- Prior art that does NOT work as-is: `directus-extension-auto-generate-file-transformations` + (utomic-media) — still falls foul of the `auto`→format mismatch unless it forces the format. diff --git a/.opencode/progress.txt b/.opencode/progress.txt new file mode 100644 index 0000000..066354a --- /dev/null +++ b/.opencode/progress.txt @@ -0,0 +1,136 @@ +# progress.txt — directus-extension-generate-image-previews + +Append-only log of decisions, evidence, and learnings. Newest at the bottom. + +## 2026-10-25 — project scaffolded + +- Opened this standalone extension project to pre-generate Directus image previews. +- Source-verified the strategy against Directus **v11.17.4** (see `.opencode/goal.md`). +- Root causes why existing/community extensions do not work: + 1. `resolvePreset` never reads `key` → `{transformationParams:{key}}` yields `transforms=[]` → no-op. + 2. `system-*` presets are `format:'auto'` → `jpg`/`png` server-side vs `avif` in-browser → different hash. + 3. "undrained stream truncates file" — false (write is awaited). + 4. admin uses `?key=system-*`, not raw width/height. +- Admin URLs (v11.17.4 app source): files grid `?key=system-medium-cover&v=`; + image field `system-large-cover|contain`; image display `system-small-cover`. +- Server bottleneck evidence (2026-10-23 log triage): `storage:local:responseTime 1206ms`, + `pg:responseTime` 150–738ms; no 503s, no sharp errors. + +## 2026-10-25 — scope expanded after user direction (v2) + +- **No token needed.** Dropped HTTP-replay as primary. Strategy: **in-process** + `AssetsService.getAsset(id, { transformationParams: , acceptFormat: 'avif'|'webp' })`. + No HTTP → no token, no proxy, no rate limiter. (HTTP-replay kept as documented fallback.) +- **Bundle extension**: api `hook` + api `endpoint` + app `module`. +- **Presets: all, dynamically** — system `SYSTEM_ASSET_ALLOW_LIST` (6) + `directus_settings.storage_asset_presets`, + controller order `[...SYSTEM, ...custom]`, first-match-wins; new presets picked up per run. +- **Admin module**: progress bar, disk usage (`list`+`stat`), config form, diagnostics panel. +- **Config**: maintenance window + concurrency (throttle knob; in-process bypasses HTTP rate limiter), + persisted in JSON. +- Confirmed `acceptFormat:'avif'` in a direct call equals browser `Accept: image/avif`. + +## 2026-10-25 — diagnostics + safety + autonomy (v3) + +- **Diagnostics / manual generation** (F06): `POST /generate` (one file, dry-run supported), + `GET /resolve-plan` (resolved transforms + predicted filename, no write), `GET /ops` (ring buffer). +- **Safe testing** (F02): staging compose stack + deploy/rollback scripts; fail-open, `enabled` default false. +- **Autonomous remote feedback**: staging-only, least privilege (scoped token, no prod Docker socket, + restricted SSH, private network, human-only prod promotion). + +## 2026-10-25 — implementation + local verification (autonomous session) + +Built the full extension locally and smoke-tested against an **isolated** Directus 11.17.4 stack +(`dev/compose.dev.yml`, port 8057, own pg + volumes). No contact with the prod instance. + +### Implemented +- `src/lib/`: settings (env + JSON), state (`state.jsonl`, run state, lock, cancel flag), + presets (pinned system copy + custom merge, controller parity), warmer (in-process `getAsset` with + `acceptFormat` variants, concurrency, per-task error isolation, stream release), window, storage + (dynamic `getStorage` + local-FS fallback), diagnostics (resolve-plan prediction + ops ring buffer), + backfill (paginated, resumable, window-aware, idempotent). +- `src/endpoint/index.ts`: `/status`, `/config` (GET/PUT), `/presets`, `/run`, `/run/cancel`, + `/disk-usage`, `/generate`, `/resolve-plan`, `/ops`; admin-only guard. +- `src/hook/index.ts`: `files.upload` → fire-and-forget warm. +- `src/module/`: admin module (progress bar, disk usage, config form, diagnostics panel, ops table). +- `dev/`: compose stack, `sync-extension.sh`, seed images. + +### Bugs found & fixed during smoke test +1. **Directus coerces env values** (`"true"` → boolean `true`, `"1"` → number). My string-only parsers + threw `e.toLowerCase is not a function`, which silently broke the upload hook. Fixed `settings.ts` + to accept `unknown` and stringify. Regression test added. +2. **State dir EACCES.** `/directus/extensions/.image-previews` (named volume on a non-existent path) + is root-owned; the API runs as `node`. This broke config writes and the backfill lock. Fixed: default + state dir is now `/.image-previews` (i.e. `/directus/uploads/.image-previews`), + which is writable; `IMAGE_PREVIEWS_STATE_DIR` still overrides. +3. **Bind-mount reload gotcha.** `rm -rf` of the bind-mounted extension dir breaks the Docker mount + (Directus removes the extension and never re-adds it). `sync-extension.sh` now updates in place; + restart the dev container after a sync. + +### Verified evidence (local stack) +- `npm run typecheck` → 0 errors. `npm test` → **32/32 pass**. `npm run build` → `dist/app.js` + `dist/api.js`. +- Directus logs: `Loaded extensions: directus-extension-generate-image-previews` (no errors). +- `/status` → `{enabled:true, inWindow:true, locked:false}`; `/presets` → 6 system presets. +- Upload a JPEG → hook warmed **12 files** (6 presets × avif/webp) in `/directus/uploads`. +- **HASH-MATCH GATE PASSED:** after deleting the cached files, a real + `GET /assets/?key=system-medium-cover` with `Accept: image/avif` produced exactly + `__f15aa4b815722867859d2a3fa46ab50834dfc8dc.avif` — byte-identical to `resolve-plan`'s prediction. +- `/generate` dry-run reports `exists:true/false` correctly; `/ops` shows per-task timing. +- Backfill: `total=36` (3 images × 6 presets × 2 formats), `generated=36`, state `state.jsonl` = 36 lines. + Second run: `generated=0, hits=36`, state unchanged, file count unchanged → **idempotent/resumable**. +- Window gating: `/run` outside `03:00–05:00` → `409 outside-window` with `nextWindow`. +- `/disk-usage` → `157633 bytes / 36 files (source: storage)`. +- Cold vs warm (`system-medium-cover`): 114 ms → 16–30 ms. (`system-large-cover`): 304 ms → 36 ms. + +### Decisions recorded +- System presets: version-pinned copy in `src/lib/system-presets.ts` (verbatim from `api/src/constants.ts` + v11.17.4). No `@directus/api` import needed for presets. +- Storage/disk usage: `@directus/api/storage/index` loaded via dynamic import (hidden from the bundler), + with a local-FS fallback; shares the host `getStorage()` singleton. +- New-preset trigger: **manual** via `POST /run` (idempotent) + the module's Run button; no + `settings.update` auto-trigger (avoids heavy background runs on unrelated settings changes). +- Scheduling: external cron → `POST /image-previews/run` (default). +- State/config dir: `/.image-previews` (writable), override with `IMAGE_PREVIEWS_STATE_DIR`. + +### Additional verification (same session) +- `GET /extensions` → bundle registered with entries `module`, `hook`, `endpoint`, all enabled. +- Inert test: with `enabled:false`, uploading an image produced **zero** new preview files (25 → 25). +- Added `dev/compose.staging.yml`, `dev/deploy-staging.sh`, `dev/rollback-staging.sh` (templates; + NOT executed against any remote host). +- Added `storage.test.ts`; total tests now **34/34**. +- Restarted the dev stack after the final build; `/status`, `/disk-usage`, and bundle entries all good. + +### Still open +- Admin module UI not yet verified in a real browser (bundle + entries registered; rendering/polling untested). +- Cancel + concurrent-run 409 not exercised end-to-end (unit-tested only; local runs finish too fast). +- Staging deploy not executed (scripts/templates provided); prod rollout not done. +- F01/F02/F07/F10 remain `passes:false` (F01 publish step, F02 staging run, F07 browser, F10 rollout). + +## 2026-10-25 — feedback round (UI, defaults, custom formats, docs) + +- **Defaults changed**: `enabled` now `true`; maintenance window defaults to `01:00–04:00`. +- **Custom fixed-format presets verified**: `custom-png` (format `png`) generated `.png` and + `resolve-plan` predicted the exact filename (`exists:true`). `custom-auto` generated avif+webp. + An unsupported preset (`format: bmp`) failed with Directus's clear error + ("Expected one of: heic, heif, avif, jpeg, … received bmp") and is surfaced in Recent operations / `/ops`. +- **Effective format fix**: ops/presets now report the preset's real output format (`png`) instead of + `null`; backfill resume keys use the effective format (fixed a re-warm mismatch). +- **Progress accounting fix**: already-cached tasks now count toward `done`/`hits`. Runs report + `128/128` (120 hits + 8 expected failures) instead of `8/128`. After removing the unsupported preset: + `120/120 hits, 0 failed, 0 generated`. +- **Storage reporting**: `/disk-usage` + panel now split **previews** vs **originals** vs **total** + (raw + human): e.g. previews 774.7 KB / 115 files, originals 24.9 MB / 9 files, total 25.6 MB / 124. +- **Human-readable fields** added to `/status` (ISO + human dates, `etaHuman`, `rateHuman`), + `/disk-usage` (`bytesHuman`), `/ops` (`tsHuman`, `msHuman`), `/generate` (`msHuman`). +- **Admin module rewritten with Directus UI kit** (`v-button`, `v-input`, `v-checkbox`, `v-select`, + `v-notice`, `v-progress-linear`), field explanations, preset table with effective formats + shadow + warnings, storage table, error column in Recent operations, and a full collapsible **API reference**. +- **Run now** now ignores the maintenance window; **Cancel** only renders while a run is active. +- **Dimension vs file size clarified** in README/goal/AGENTS: the 6000 limit is a pixel-dimension guard in + Directus, not a file-size limit; the extension imposes none. +- Tests: **40/40** pass; typecheck clean; build OK. + +### Still open +- Admin module UI not yet verified in a real browser (bundle + entries registered; rendering/polling untested). +- Cancel + concurrent-run 409 not exercised end-to-end. +- Staging deploy not executed (scripts/templates provided); prod rollout not done. +- F01/F02/F07/F10 remain `passes:false`. diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..5e535b7 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,129 @@ +# Agent notes — directus-extension-generate-image-previews + +Common confusion points for agents working here. Read before touching the warmer. + +## What this is + +A Directus **bundle** extension that pre-generates image transform ("preview") cache files so the +admin UI never pays the first-request sharp cost. Target server: **Directus 11.17.4** on `land-nest` +(self-hosted, PM2 cluster, `STORAGE_LOCAL_ROOT=./uploads`). + +Bundle entries: an api **hook** (`files.upload`), an api **endpoint** (`/image-previews/*`), and an +app **module** (`image-previews` admin page: progress, disk usage, config). + +## Directus transform invariants (source-verified, tag v11.17.4) — DO NOT REGRESS + +1. **Cached transform filename** = `__.`, + written **beside the original** in the storage root (`./uploads`, no `.cache` subdir). + +2. **Hash = `object-hash@3` defaults**: sha1/hex, `unorderedArrays:false` (**array order matters**), + `unorderedObjects:true`. Hashes the **RESOLVED** transform array from `resolvePreset`, NOT the raw + query/preset object. + +3. **`resolvePreset` order is fixed**: copy `transformationParams.transforms[]` → push `toFormat` + (if `format`/`quality`) → push `resize` (+`extract` on focal cover). Raw params `?width=&height=&fit=&format=` + resolve to `[toFormat, resize]`; a preset resolves to `[resize, toFormat]` → **different hash for a + visually identical result**. + +4. **`{ key }` alone is a NO-OP.** `resolvePreset` never reads `key`. Always pass the **full preset object**. + +5. **`format:'auto'` is the killer trap.** All six `system-*` presets are `format:'auto'`. `getFormat` + with no `acceptFormat` → JPEG→`jpg`, PNG→`png`; a browser `Accept: image/avif` → `avif`. Different + `toFormat` arg → **different hash → guaranteed miss**. + +6. **The write IS awaited.** Not draining the returned stream leaks an FD but never truncates. + Still: destroy/unpipe the returned stream to avoid FD leaks. + +7. `AssetsService.getAsset` runs fine as sudo (`new AssetsService({ schema })`) with **no HTTP request + context** — this is the basis of our in-process strategy. + +## Preset registry semantics (controller parity) + +The controller builds, inline in `api/src/controllers/assets.ts`: + +``` +res.locals['shortcuts'] = [...SYSTEM_ASSET_ALLOW_LIST, ...(directus_settings.storage_asset_presets ?? [])] +``` + +and resolves `?key=` with `.find(t => t.key === key)` → **first match wins** (a system key shadows a +custom preset of the same key). There is **no** reusable helper, and `GET /settings` exposes **only** +custom presets. Our registry (`src/lib/presets.ts`) must mirror this order exactly. + +## What the admin actually requests (verbatim from app source) + +| Surface | URL | +| ------------- | -------------------------------------------------------- | +| Files grid | `?key=system-medium-cover&v=` (cards, crop) | +| Image field | `?key=system-large-cover` / `system-large-contain` | +| Image display | `?key=system-small-cover` | + +No explicit `width`/`height`/`format`. `format:auto` is implicit. `v=` is ignored for hashing. + +## Chosen strategy — IN-PROCESS (no token, no HTTP, no rate limiter) + +```ts +const assets = new services.AssetsService({ schema }); // sudo +const { stream } = await assets.getAsset(fileId, { + transformationParams: presetObject, // FULL object, not { key } + acceptFormat: 'avif', // or 'webp' +}); +(stream as Readable).destroy?.(); +``` + +`acceptFormat` reproduces what a browser's `Accept` header does → byte-identical cache filename with +no HTTP/token. Warm **both** `avif` and `webp` for `format:'auto'` presets. + +HTTP-replay (`GET /assets/{id}?key=…`) is the documented **fallback** only (needs a token + rate-limit +pacing). + +## Config + state + +- Persisted settings + progress state are small JSON files under `/.image-previews` + (default `/directus/uploads/.image-previews`; override `IMAGE_PREVIEWS_STATE_DIR`). Do NOT default to + `/directus/extensions/...` — that path is a root-owned volume and the API runs as `node` → EACCES. +- `state.jsonl` = append-only completed `{file_id,preset_key,format}` → resume. +- All state is **file-backed** (PM2 cluster, 8 workers — never in-memory). + +## Gotchas learned the hard way + +- **Directus coerces env values**: `"true"` arrives as boolean `true`, `"1"` as number. Env parsing must + accept `unknown` and stringify (see `asString` in `settings.ts`). A string-only `.toLowerCase()` call + silently killed the upload hook. +- **Docker bind mounts**: never `rm -rf` the bind-mounted extension directory — it breaks the mount and + Directus removes the extension without re-adding it. Sync contents in place; restart the dev container. +- The dev stack (`dev/compose.dev.yml`) is the only place to test; never load this into prod while + iterating (prod has `EXTENSIONS_AUTO_RELOAD=true`). + + +## Server facts (land-nest) + +- Directus image `directus/directus:11.17.4`; `PUBLIC_URL=https://data.landshaft.life`; + `PM2_INSTANCES=8`; `STORAGE_LOCAL_ROOT=./uploads`; logs at `~/apps/directus/logs`. +- `ASSETS_TRANSFORM_MAX_CONCURRENT=45` per worker → over it errors; catch per file/preset. +- `ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION` default 6000 is a **pixel dimension** guard, not a file-size + limit. The extension imposes no limit; raise the Directus env var to process larger images. +- Local storage writes are **non-atomic** — warm only after an upload is committed. +- `RATE_LIMITER_*` applies to HTTP only → irrelevant to in-process generation (this is why the admin + knob is *concurrency*, not a rate limit). +- Observed bottleneck (2026-10-23 log triage): `storage:local:responseTime 1206ms`, + `pg:responseTime` 150–738ms; **no** 503s, **no** sharp errors. Pre-generation removes the + cold-transform cost; uploads-volume I/O latency is a separate ops concern. + +## Safety (do not crash prod) + +- Every entrypoint body is wrapped so thrown errors are logged and swallowed — never propagate into + Directus core. ALL behaviour is gated by `enabled` (default **false**): a loaded-but-disabled bundle + does nothing. +- Test only on the **staging** stack (`dev/compose.dev.yml`), never the prod instance. +- Rollout = backup previous `dist/` → deploy → healthcheck → enable; rollback = restore `dist/` + disable. +- Automation (autonomous loops) gets **staging only**: a scoped token limited to `/image-previews/*` + (+ `directus_files` metadata read), never a prod admin token; never the prod Docker socket; restricted + non-sudo SSH or opencode-on-host. Promotion to prod is a human action. + +## Conventions + +- Build via `@directus/extensions-sdk` (`npm run build` / `dev` / `link`); bundle emits `dist/app.js` + `dist/api.js`. +- Deploy with `npm run publish` (scp `dist` + `package.json` to land-nest extensions dir). +- Tests: `node:test` via `tsx` (`npm test`). Typecheck: `npm run typecheck`. +- Do not add comments unless asked. Follow the sibling extensions' style. +- Never commit without explicit request. diff --git a/README.md b/README.md new file mode 100644 index 0000000..dbd8691 --- /dev/null +++ b/README.md @@ -0,0 +1,102 @@ +# directus-extension-generate-image-previews + +Pre-generate Directus image transform ("preview") cache files so the admin UI and API never pay the +first-request sharp cost. + +A Directus **bundle**: + +- **upload hook** — warm previews right after an image upload. +- **new-preset trigger** — `Run now` warms every preset (system + custom) for existing images. +- **backfill job** — resumable, window-aware sweep over the existing library. +- **admin module** — progress, storage breakdown, configuration, diagnostics, and API reference. + +Target: self-hosted Directus **11.17.4** (PM2 cluster, local disk storage). + +## Why this approach (read AGENTS.md too) + +The cache file is `__.`. The hash depends on the +RESOLVED transforms, and every `system-*` preset is `format:'auto'` — which resolves differently +server-side (jpg/png) than in a browser (avif). We therefore generate **in-process** with an explicit +`acceptFormat` (`avif` + `webp`), reproducing the browser's cache file byte-for-byte without any HTTP +request. Naive warming (or the popular community extension) silently misses. + +## Install / build / publish + +```bash +npm install +npm run build # emits dist/app.js + dist/api.js +npm run typecheck # 0 errors +npm test # unit tests +npm run dev # watch build +npm run publish # scp dist + package.json to the (staging) deploy target +``` + +## Settings + +Defaults are applied automatically; everything is editable at runtime from the admin module — no rebuild. + +| setting | default | meaning | +| -------------------------- | -------------------------------------- | ---------------------------------------------------------------- | +| `enabled` | `true` | master switch (off = hooks/backfill inert) | +| `onUpload` | `true` | generate previews immediately after an upload | +| `windowStart` / `windowEnd` | `01:00` / `04:00` | scheduled runs only start inside this window (local time) | +| `concurrency` | `1` | parallel generations | +| `formats` | `avif,webp` | output variants **for `format:'auto'` presets only** (all system presets) | +| `presetKeys` | `null` (all) | restrict to specific preset keys | +| `debug` | `false` | verbose generation logs in the Directus server log | +| `IMAGE_PREVIEWS_STATE_DIR` | `/.image-previews` | where settings + progress state live | + +### Presets and formats + +- **System presets** (`system-small|medium|large` × `cover|contain`) always use `format:'auto'`, so they + generate one file per entry in `formats` (default avif + webp), at their built-in sizes (64 / 300 / 800 px). +- **Custom presets** from Settings → File Storage are added automatically. A custom preset with a fixed + `format` (e.g. `png`) ignores `formats` and generates exactly that format. A custom preset with + `format:'auto'` follows `formats`. +- A custom preset whose `key` equals a system key is **shadowed** (system wins, same as Directus) and is + flagged in the admin module. + +## Storage reporting + +`GET /image-previews/disk-usage` (and the admin panel) reports bytes + file counts separately for +**preview assets** and **original assets**, plus the total — in both raw bytes and human-readable form. + +## API endpoints + +All require an admin session or admin token. Human-readable fields accompany machine-readable ones. + +- `GET /image-previews/status` — run progress, rate, ETA, window state, ISO + human dates +- `GET /image-previews/config`, `PUT /image-previews/config` +- `GET /image-previews/presets` — system + custom presets, effective formats, shadowed keys +- `POST /image-previews/run` — start backfill (`{"ignoreWindow":true}` for an immediate run) +- `POST /image-previews/run/cancel` +- `GET /image-previews/disk-usage` — previews vs originals vs total +- `POST /image-previews/generate` — one file (`{fileId, keys?, formats?, dryRun?}`) +- `GET /image-previews/resolve-plan?fileId=&key=` — predicted cache filename, no write +- `GET /image-previews/ops?limit=` — recent operations with timing + error messages + +The admin module includes a full API reference with curl examples. + +## Safe testing & deployment + +Never test against the prod instance. + +- **Local / staging** (`dev/compose.dev.yml`): Directus 11.17.4 + its own postgres + volumes, on separate + ports. Shares nothing with prod. See `dev/README.md`. +- **Fail-open**: entrypoints never throw into Directus core. +- **Rollout**: build → verify on staging → back up previous `dist/` → deploy → healthcheck → enable. + **Rollback**: restore previous `dist/`. +- Scripts: `dev/deploy-staging.sh`, `dev/rollback-staging.sh`, template `dev/compose.staging.yml`. + +## Caveats + +- **Transform dimension guard, not a file-size limit.** Directus rejects transformations of images whose + width or height exceeds `ASSETS_TRANSFORM_IMAGE_MAX_DIMENSION` (default **6000 px**). This is a Directus + env var, not something this extension imposes. To process larger images, raise it on the Directus + instance (and watch memory). Upload size limits (`FILES_MAX_UPLOAD_SIZE`, `MAX_PAYLOAD_SIZE`) are separate. +- Warm only after uploads are committed (local writes are non-atomic). +- In-process generation bypasses the HTTP rate limiter; bound it with `concurrency` + the window. +- Unsupported custom preset formats (e.g. `bmp`) fail at generation time; the error appears in + Recent operations / `/ops`. + +See `.opencode/goal.md` for the full contract and `.opencode/feature_list.json` for the task list. diff --git a/dev/README.md b/dev/README.md new file mode 100644 index 0000000..251d5aa --- /dev/null +++ b/dev/README.md @@ -0,0 +1,48 @@ +# Local dev / staging stack + +Isolated Directus **11.17.4** with its own Postgres and volumes. Nothing is shared with the prod +instance (separate containers, volumes, and port **8057**). + +## Run + +```bash +# from the project root +./dev/sync-extension.sh # build + copy dist/package.json into dev/extension +docker compose -f dev/compose.dev.yml up -d +``` + +Admin: `http://localhost:8057` — `admin@example.com` / `admin12345`. +The extension is loaded from `dev/extension` (bind mount). Check: + +```bash +docker logs image-previews-dev-directus-1 | grep -i "loaded extensions" +``` + +## After changing source + +```bash +./dev/sync-extension.sh +docker compose -f dev/compose.dev.yml restart directus +``` + +(`EXTENSIONS_AUTO_RELOAD` is on, but a restart is the reliable path. Never `rm -rf dev/extension` — +it breaks the bind mount.) + +## Smoke test + +```bash +BASE=http://localhost:8057 +TOKEN=$(curl -s -X POST "$BASE/auth/login" -H 'Content-Type: application/json' \ + -d '{"email":"admin@example.com","password":"admin12345"}' | jq -r '.data.access_token') + +curl -s "$BASE/image-previews/status" -H "Authorization: Bearer $TOKEN" | jq . +curl -s -X POST "$BASE/files" -H "Authorization: Bearer $TOKEN" -F "file=@dev/seed/test.jpg" | jq '.data | {id,filename_disk}' +docker exec image-previews-dev-directus-1 sh -c "ls -1 /directus/uploads | grep '__' | sort" +``` + +## Stop / reset + +```bash +docker compose -f dev/compose.dev.yml down # stop, keep data +docker compose -f dev/compose.dev.yml down -v # stop and wipe DB + uploads +``` diff --git a/dev/compose.dev.yml b/dev/compose.dev.yml new file mode 100644 index 0000000..88332d4 --- /dev/null +++ b/dev/compose.dev.yml @@ -0,0 +1,51 @@ +name: image-previews-dev + +services: + db: + image: postgres:16-alpine + environment: + POSTGRES_USER: directus + POSTGRES_PASSWORD: directus + POSTGRES_DB: directus + volumes: + - db-data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U directus"] + interval: 5s + timeout: 5s + retries: 20 + + directus: + image: directus/directus:11.17.4 + ports: + - "8057:8055" + depends_on: + db: + condition: service_healthy + environment: + KEY: dev-key + SECRET: dev-secret + ADMIN_EMAIL: admin@example.com + ADMIN_PASSWORD: admin12345 + DB_CLIENT: pg + DB_HOST: db + DB_PORT: "5432" + DB_DATABASE: directus + DB_USER: directus + DB_PASSWORD: directus + STORAGE_LOCATIONS: local + STORAGE_LOCAL_ROOT: /directus/uploads + EXTENSIONS_AUTO_RELOAD: "true" + CACHE_ENABLED: "false" + RATE_LIMITER_ENABLED: "false" + ASSETS_TRANSFORM_MAX_CONCURRENT: "2" + IMAGE_PREVIEWS_ENABLED: "true" + IMAGE_PREVIEWS_CONCURRENCY: "1" + LOG_LEVEL: info + volumes: + - uploads:/directus/uploads + - ./extension:/directus/extensions/directus-extension-generate-image-previews + +volumes: + db-data: + uploads: diff --git a/dev/compose.staging.yml b/dev/compose.staging.yml new file mode 100644 index 0000000..070bddc --- /dev/null +++ b/dev/compose.staging.yml @@ -0,0 +1,58 @@ +# Staging stack template (run on the staging host only — never on prod). +# +# 1. Restore an anonymized DB dump into the `db` service. +# 2. Copy (or rsync) a subset of prod uploads into the `uploads` volume. +# 3. Deploy the extension with dev/deploy-staging.sh, then start this stack. +# +# Keep ports/volumes/network distinct from the prod stack. + +name: land-nest-staging + +services: + db: + image: postgres:16-alpine + environment: + POSTGRES_USER: directus + POSTGRES_PASSWORD: change-me + POSTGRES_DB: directus + volumes: + - db-data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U directus"] + interval: 5s + timeout: 5s + retries: 20 + + directus: + image: directus/directus:11.17.4 + ports: + - "8056:8055" + depends_on: + db: + condition: service_healthy + environment: + KEY: change-me + SECRET: change-me-to-at-least-32-bytes-long + ADMIN_EMAIL: staging@example.com + ADMIN_PASSWORD: change-me + DB_CLIENT: pg + DB_HOST: db + DB_PORT: "5432" + DB_DATABASE: directus + DB_USER: directus + DB_PASSWORD: change-me + STORAGE_LOCATIONS: local + STORAGE_LOCAL_ROOT: /directus/uploads + EXTENSIONS_AUTO_RELOAD: "true" + CACHE_ENABLED: "false" + RATE_LIMITER_ENABLED: "false" + IMAGE_PREVIEWS_ENABLED: "true" + IMAGE_PREVIEWS_CONCURRENCY: "1" + LOG_LEVEL: info + volumes: + - uploads:/directus/uploads + - ./extensions:/directus/extensions + +volumes: + db-data: + uploads: diff --git a/dev/deploy-staging.sh b/dev/deploy-staging.sh new file mode 100755 index 0000000..1e03ad1 --- /dev/null +++ b/dev/deploy-staging.sh @@ -0,0 +1,21 @@ +#!/usr/bin/env bash +# Deploy the built extension to a STAGING Directus extensions dir. Never target prod. +# Usage: ./dev/deploy-staging.sh +set -euo pipefail + +HOST="${1:?usage: deploy-staging.sh }" +EXT_ROOT="${2:?usage: deploy-staging.sh }" +NAME="directus-extension-generate-image-previews" +STAMP="$(date +%Y%m%d-%H%M%S)" + +cd "$(dirname "$0")/.." + +npm run build + +ssh "$HOST" "mkdir -p '$EXT_ROOT/$NAME' && if [ -d '$EXT_ROOT/$NAME/dist' ]; then cp -a '$EXT_ROOT/$NAME/dist' '$EXT_ROOT/$NAME/dist.bak-$STAMP'; fi" + +rsync -az --delete dist/ "$HOST:$EXT_ROOT/$NAME/dist/" +scp package.json "$HOST:$EXT_ROOT/$NAME/package.json" + +echo "deployed to $HOST:$EXT_ROOT/$NAME (backup stamp: $STAMP)" +echo "restart staging Directus, then check: docker logs | grep -i 'loaded extensions'" diff --git a/dev/rollback-staging.sh b/dev/rollback-staging.sh new file mode 100755 index 0000000..8b5426e --- /dev/null +++ b/dev/rollback-staging.sh @@ -0,0 +1,13 @@ +#!/usr/bin/env bash +# Roll back a staging deploy to a previous dist backup. +# Usage: ./dev/rollback-staging.sh +set -euo pipefail + +HOST="${1:?usage: rollback-staging.sh }" +EXT_ROOT="${2:?usage: rollback-staging.sh }" +STAMP="${3:?usage: rollback-staging.sh }" +NAME="directus-extension-generate-image-previews" + +ssh "$HOST" "test -d '$EXT_ROOT/$NAME/dist.bak-$STAMP' && rm -rf '$EXT_ROOT/$NAME/dist' && cp -a '$EXT_ROOT/$NAME/dist.bak-$STAMP' '$EXT_ROOT/$NAME/dist'" + +echo "rolled back $HOST:$EXT_ROOT/$NAME to dist.bak-$STAMP" diff --git a/dev/seed/test-large.jpg b/dev/seed/test-large.jpg new file mode 100644 index 0000000000000000000000000000000000000000..fa71ca7a340ebfa98a8c72eadcaeed71f030b71f GIT binary patch literal 510156 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
~jTUwKpC>#F+5bEXAQ=ITEcKqFbibzzY~VBE5-_ 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�ORp+%F=%(>p7a5xx(4PAzPL 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

*Z|j%yj!nBa6^Owr=T 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 literal 0 HcmV?d00001 diff --git a/dev/sync-extension.sh b/dev/sync-extension.sh new file mode 100755 index 0000000..4ee1a19 --- /dev/null +++ b/dev/sync-extension.sh @@ -0,0 +1,13 @@ +#!/usr/bin/env bash +set -euo pipefail + +cd "$(dirname "$0")/.." + +npm run build + +mkdir -p dev/extension +rm -rf dev/extension/dist +cp -r dist dev/extension/dist +cp package.json dev/extension/package.json + +echo "synced dev/extension (in place)" diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..72ba10a --- /dev/null +++ b/package-lock.json @@ -0,0 +1,6346 @@ +{ + "name": "directus-extension-generate-image-previews", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "directus-extension-generate-image-previews", + "version": "0.1.0", + "dependencies": { + "object-hash": "^3.0.0" + }, + "devDependencies": { + "@directus/extensions-sdk": "13.0.1", + "@types/node": "^22.13.5", + "tsx": "^4.19.2", + "typescript": "^5.7.3", + "vue": "^3.5.13" + } + }, + "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/helper-string-parser": { + "version": "7.29.11", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.11.tgz", + "integrity": "sha512-snZbO7MEDOof+hvNa97EjEY7qD7h2kwvQr5AJC3ZhQudKW5dnej6k3kP9NQV88hJwaS8vDqRLFo9rivLEhle2g==", + "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/parser": { + "version": "7.29.11", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.11.tgz", + "integrity": "sha512-OZ6+oaK7GMyg3IfCpj8JOmn8n+w2rJbDT0LLfVDTLb1ZFeKDh3AiNELgCMUw175IJHSkLl74hG0M0VLsvx+gag==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.11" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.11", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.11.tgz", + "integrity": "sha512-WCsemW40Cpc6gouC1SrY6PBaZ+oLRlEVY9XBvZBI7il/HyUrb2nJ505wE1MHEFyDZNnrWDEuy4jL50WVHfTTSQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.29.11", + "@babel/helper-validator-identifier": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@directus/composables": { + "version": "11.1.6", + "resolved": "https://registry.npmjs.org/@directus/composables/-/composables-11.1.6.tgz", + "integrity": "sha512-zm6GCT9KiTZpqRJzA9IqXTWlFVYB4eYiRha0isr1yMTv1vJEv33H8OzBn8nB3ux6GQC0BVUIyPwwAwKdXSvCRg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@directus/constants": "13.0.0", + "@directus/utils": "13.0.0", + "axios": "1.7.9", + "lodash-es": "4.17.21", + "nanoid": "5.0.9" + }, + "funding": { + "url": "https://github.com/directus/directus?sponsor=1" + }, + "peerDependencies": { + "vue": "^3.4" + } + }, + "node_modules/@directus/constants": { + "version": "13.0.0", + "resolved": "https://registry.npmjs.org/@directus/constants/-/constants-13.0.0.tgz", + "integrity": "sha512-R2uuMEJarlq29IPH9Pqe11U74mDqQWBHWhVy77R7ZrnJeZiiayLFoQTlZS4FN8M+ROVrCkIcsg39meNpxEyvpA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/directus/directus?sponsor=1" + } + }, + "node_modules/@directus/extensions": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@directus/extensions/-/extensions-3.0.1.tgz", + "integrity": "sha512-31fJOIYhZpg0a5yrvMvc8K8G+/o4lpQeOumYdraDylw8oaIm8jzw2vznrooQS5vO3A1c9+QawsENDSZdt72Aow==", + "dev": true, + "license": "MIT", + "dependencies": { + "@directus/constants": "13.0.0", + "@directus/themes": "1.0.7", + "@directus/types": "13.0.0", + "@directus/utils": "13.0.0", + "@types/express": "4.17.21", + "fs-extra": "11.2.0", + "lodash-es": "4.17.21", + "zod": "3.24.1" + }, + "funding": { + "url": "https://github.com/directus/directus?sponsor=1" + }, + "peerDependencies": { + "knex": "3", + "pino": "9", + "vue": "^3.4", + "vue-router": "4" + }, + "peerDependenciesMeta": { + "knex": { + "optional": true + }, + "pino": { + "optional": true + }, + "vue": { + "optional": true + }, + "vue-router": { + "optional": true + } + } + }, + "node_modules/@directus/extensions-sdk": { + "version": "13.0.1", + "resolved": "https://registry.npmjs.org/@directus/extensions-sdk/-/extensions-sdk-13.0.1.tgz", + "integrity": "sha512-knEBNGhpogIrElnqwkvuw4K384URR9yeJhbWe9aPJk68z1eDfjpNggzJqQKhDwkHYeMWR+GcDs32Itkq/zimEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@directus/composables": "11.1.6", + "@directus/constants": "13.0.0", + "@directus/extensions": "3.0.1", + "@directus/themes": "1.0.7", + "@directus/types": "13.0.0", + "@directus/utils": "13.0.0", + "@rollup/plugin-commonjs": "25.0.8", + "@rollup/plugin-json": "6.1.0", + "@rollup/plugin-node-resolve": "15.3.1", + "@rollup/plugin-replace": "5.0.7", + "@rollup/plugin-terser": "0.4.4", + "@rollup/plugin-virtual": "3.0.2", + "@vitejs/plugin-vue": "4.6.2", + "chalk": "5.4.1", + "commander": "10.0.1", + "esbuild": "0.17.19", + "execa": "7.2.0", + "fs-extra": "11.2.0", + "inquirer": "12.3.0", + "ora": "6.3.1", + "rollup": "3.29.5", + "rollup-plugin-esbuild": "5.0.0", + "rollup-plugin-styles": "4.0.0", + "semver": "7.6.3", + "vite": "4.5.5", + "vue": "3.5.13" + }, + "bin": { + "directus-extension": "cli.js" + }, + "engines": { + "node": ">=12.20.0" + }, + "funding": { + "url": "https://github.com/directus/directus?sponsor=1" + } + }, + "node_modules/@directus/extensions-sdk/node_modules/@vue/compiler-core": { + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.13.tgz", + "integrity": "sha512-oOdAkwqUfW1WqpwSYJce06wvt6HljgY3fGeM9NcVA1HaYOij3mZG9Rkysn0OHuyUAGMbEbARIpsG+LPVlBJ5/Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.25.3", + "@vue/shared": "3.5.13", + "entities": "^4.5.0", + "estree-walker": "^2.0.2", + "source-map-js": "^1.2.0" + } + }, + "node_modules/@directus/extensions-sdk/node_modules/@vue/compiler-dom": { + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.13.tgz", + "integrity": "sha512-ZOJ46sMOKUjO3e94wPdCzQ6P1Lx/vhp2RSvfaab88Ajexs0AHeV0uasYhi99WPaogmBlRHNRuly8xV75cNTMDA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-core": "3.5.13", + "@vue/shared": "3.5.13" + } + }, + "node_modules/@directus/extensions-sdk/node_modules/@vue/compiler-sfc": { + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.13.tgz", + "integrity": "sha512-6VdaljMpD82w6c2749Zhf5T9u5uLBWKnVue6XWxprDobftnletJ8+oel7sexFfM3qIxNmVE7LSFGTpv6obNyaQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.25.3", + "@vue/compiler-core": "3.5.13", + "@vue/compiler-dom": "3.5.13", + "@vue/compiler-ssr": "3.5.13", + "@vue/shared": "3.5.13", + "estree-walker": "^2.0.2", + "magic-string": "^0.30.11", + "postcss": "^8.4.48", + "source-map-js": "^1.2.0" + } + }, + "node_modules/@directus/extensions-sdk/node_modules/@vue/compiler-ssr": { + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.13.tgz", + "integrity": "sha512-wMH6vrYHxQl/IybKJagqbquvxpWCuVYpoUJfCqFZwa/JY1GdATAQ+TgVtgrwwMZ0D07QhA99rs/EAAWfvG6KpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-dom": "3.5.13", + "@vue/shared": "3.5.13" + } + }, + "node_modules/@directus/extensions-sdk/node_modules/@vue/reactivity": { + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.13.tgz", + "integrity": "sha512-NaCwtw8o48B9I6L1zl2p41OHo/2Z4wqYGGIK1Khu5T7yxrn+ATOixn/Udn2m+6kZKB/J7cuT9DbWWhRxqixACg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/shared": "3.5.13" + } + }, + "node_modules/@directus/extensions-sdk/node_modules/@vue/runtime-core": { + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.13.tgz", + "integrity": "sha512-Fj4YRQ3Az0WTZw1sFe+QDb0aXCerigEpw418pw1HBUKFtnQHWzwojaukAs2X/c9DQz4MQ4bsXTGlcpGxU/RCIw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/reactivity": "3.5.13", + "@vue/shared": "3.5.13" + } + }, + "node_modules/@directus/extensions-sdk/node_modules/@vue/runtime-dom": { + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.13.tgz", + "integrity": "sha512-dLaj94s93NYLqjLiyFzVs9X6dWhTdAlEAciC3Moq7gzAc13VJUdCnjjRurNM6uTLFATRHexHCTu/Xp3eW6yoog==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/reactivity": "3.5.13", + "@vue/runtime-core": "3.5.13", + "@vue/shared": "3.5.13", + "csstype": "^3.1.3" + } + }, + "node_modules/@directus/extensions-sdk/node_modules/@vue/server-renderer": { + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.13.tgz", + "integrity": "sha512-wAi4IRJV/2SAW3htkTlB+dHeRmpTiVIK1OGLWV1yeStVSebSQQOwGwIq0D3ZIoBj2C2qpgz5+vX9iEBkTdk5YA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-ssr": "3.5.13", + "@vue/shared": "3.5.13" + }, + "peerDependencies": { + "vue": "3.5.13" + } + }, + "node_modules/@directus/extensions-sdk/node_modules/@vue/shared": { + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.13.tgz", + "integrity": "sha512-/hnE/qP5ZoGpol0a5mDi45bOd7t3tjYJBjsgCsivow7D48cJeV5l05RD82lPqi7gRiphZM37rnhW1l6ZoCNNnQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/@directus/extensions-sdk/node_modules/entities": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", + "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/@directus/extensions-sdk/node_modules/rollup": { + "version": "3.29.5", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-3.29.5.tgz", + "integrity": "sha512-GVsDdsbJzzy4S/v3dqWPJ7EfvZJfCHiDqe80IyrF59LYuP+e6U1LJoUqeuqRbwAWoMNoXivMNeNAOf5E22VA1w==", + "dev": true, + "license": "MIT", + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=14.18.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/@directus/extensions-sdk/node_modules/vue": { + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.13.tgz", + "integrity": "sha512-wmeiSMxkZCSc+PM2w2VRsOYAZC8GdipNFRTsLSfodVqI9mbejKeXEGr8SckuLnrQPGe3oJN5c3K0vpoU9q/wCQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-dom": "3.5.13", + "@vue/compiler-sfc": "3.5.13", + "@vue/runtime-dom": "3.5.13", + "@vue/server-renderer": "3.5.13", + "@vue/shared": "3.5.13" + }, + "peerDependencies": { + "typescript": "*" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@directus/schema": { + "version": "13.0.0", + "resolved": "https://registry.npmjs.org/@directus/schema/-/schema-13.0.0.tgz", + "integrity": "sha512-QrL+HQ6BWyoyQSXNoPNhaFE7OrK/9jcT10TP86qKxWwLt1BQ+yxgWqar53Hh3i4r/dA25qCIXhm9I/SLWqe9SA==", + "dev": true, + "license": "BUSL-1.1", + "dependencies": { + "knex": "3.1.0" + }, + "funding": { + "url": "https://github.com/directus/directus?sponsor=1" + } + }, + "node_modules/@directus/system-data": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@directus/system-data/-/system-data-3.0.0.tgz", + "integrity": "sha512-CwhZ/eRWqgmikxNgJONsYzdxGSr1us/35o+fTcTjh9YsLYBzV3d/jNzeU7JjAR1+i9AfFOwrnwQyraPmmS2nrw==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/directus/directus?sponsor=1" + } + }, + "node_modules/@directus/themes": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/@directus/themes/-/themes-1.0.7.tgz", + "integrity": "sha512-RBsl+vCKvbuvc0eJVXN8hDsXJwPGPl4yLOnnQiV7L0wW/h27W4jTB0Zf5mdyg+OBVSAxLhGStH5hUDmqWZJLIw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@directus/utils": "13.0.0", + "@sinclair/typebox": "0.34.13", + "decamelize": "6.0.0", + "flat": "6.0.1", + "lodash-es": "4.17.21" + }, + "funding": { + "url": "https://github.com/directus/directus?sponsor=1" + }, + "peerDependencies": { + "@unhead/vue": "1", + "pinia": "2", + "vue": "^3.4" + } + }, + "node_modules/@directus/types": { + "version": "13.0.0", + "resolved": "https://registry.npmjs.org/@directus/types/-/types-13.0.0.tgz", + "integrity": "sha512-e1zcdk/vCYVTqo3uXVPPU5zJoCWcPHLihRz3ihn8cq/HVrTwAYAKpSjYCsvL9/cmjggubozocgGqfte/+HQ23w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@directus/constants": "13.0.0", + "@directus/schema": "13.0.0", + "@types/geojson": "7946.0.15" + }, + "funding": { + "url": "https://github.com/directus/directus?sponsor=1" + }, + "peerDependencies": { + "knex": "3", + "vue": "^3.4" + }, + "peerDependenciesMeta": { + "knex": { + "optional": true + }, + "vue": { + "optional": true + } + } + }, + "node_modules/@directus/utils": { + "version": "13.0.0", + "resolved": "https://registry.npmjs.org/@directus/utils/-/utils-13.0.0.tgz", + "integrity": "sha512-2ZP2PUEQhW0fm4CNt8AoMEoS9DBMd/1NWTdA85OGIfjZiu3RUAaVgk9r3KPtt4Xr5UNLkxp/hIZXH0aUzfdMyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@directus/constants": "13.0.0", + "@directus/system-data": "3.0.0", + "date-fns": "4.1.0", + "fs-extra": "11.2.0", + "joi": "17.13.3", + "js-yaml": "4.1.0", + "lodash-es": "4.17.21", + "micromustache": "8.0.3" + }, + "funding": { + "url": "https://github.com/directus/directus?sponsor=1" + }, + "peerDependencies": { + "vue": "^3.4" + }, + "peerDependenciesMeta": { + "vue": { + "optional": true + } + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.2.tgz", + "integrity": "sha512-XExcO+dvLKvVtNTibSTBej1NCAbaGhWn9Ww1ZPx80qsahhPFe/8jgWP0IchNe0F3HwkU7n8ejhH8bjonqht8mQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.17.19.tgz", + "integrity": "sha512-rIKddzqhmav7MSmoFCmDIb6e2W57geRsM94gV2l38fzhXMwq7hZoClug9USI2pFRGL06f4IOPHHpFNOkWieR8A==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.17.19.tgz", + "integrity": "sha512-KBMWvEZooR7+kzY0BtbTQn0OAYY7CsiydT63pVEaPtVYF0hXbUaOyZog37DKxK7NF3XacBJOpYT4adIJh+avxA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.17.19.tgz", + "integrity": "sha512-uUTTc4xGNDT7YSArp/zbtmbhO0uEEK9/ETW29Wk1thYUJBz3IVnvgEiEwEa9IeLyvnpKrWK64Utw2bgUmDveww==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.17.19.tgz", + "integrity": "sha512-80wEoCfF/hFKM6WE1FyBHc9SfUblloAWx6FJkFWTWiCoht9Mc0ARGEM47e67W9rI09YoUxJL68WHfDRYEAvOhg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.17.19.tgz", + "integrity": "sha512-IJM4JJsLhRYr9xdtLytPLSH9k/oxR3boaUIYiHkAawtwNOXKE8KoU8tMvryogdcT8AU+Bflmh81Xn6Q0vTZbQw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.17.19.tgz", + "integrity": "sha512-pBwbc7DufluUeGdjSU5Si+P3SoMF5DQ/F/UmTSb8HXO80ZEAJmrykPyzo1IfNbAoaqw48YRpv8shwd1NoI0jcQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.17.19.tgz", + "integrity": "sha512-4lu+n8Wk0XlajEhbEffdy2xy53dpR06SlzvhGByyg36qJw6Kpfk7cp45DR/62aPH9mtJRmIyrXAS5UWBrJT6TQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.17.19.tgz", + "integrity": "sha512-cdmT3KxjlOQ/gZ2cjfrQOtmhG4HJs6hhvm3mWSRDPtZ/lP5oe8FWceS10JaSJC13GBd4eH/haHnqf7hhGNLerA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.17.19.tgz", + "integrity": "sha512-ct1Tg3WGwd3P+oZYqic+YZF4snNl2bsnMKRkb3ozHmnM0dGWuxcPTTntAF6bOP0Sp4x0PjSF+4uHQ1xvxfRKqg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.17.19.tgz", + "integrity": "sha512-w4IRhSy1VbsNxHRQpeGCHEmibqdTUx61Vc38APcsRbuVgK0OPEnQ0YD39Brymn96mOx48Y2laBQGqgZ0j9w6SQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.17.19.tgz", + "integrity": "sha512-2iAngUbBPMq439a+z//gE+9WBldoMp1s5GWsUSgqHLzLJ9WoZLZhpwWuym0u0u/4XmZ3gpHmzV84PonE+9IIdQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.17.19.tgz", + "integrity": "sha512-LKJltc4LVdMKHsrFe4MGNPp0hqDFA1Wpt3jE1gEyM3nKUvOiO//9PheZZHfYRfYl6AwdTH4aTcXSqBerX0ml4A==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.17.19.tgz", + "integrity": "sha512-/c/DGybs95WXNS8y3Ti/ytqETiW7EU44MEKuCAcpPto3YjQbyK3IQVKfF6nbghD7EcLUGl0NbiL5Rt5DMhn5tg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.17.19.tgz", + "integrity": "sha512-FC3nUAWhvFoutlhAkgHf8f5HwFWUL6bYdvLc/TTuxKlvLi3+pPzdZiFKSWz/PF30TB1K19SuCxDTI5KcqASJqA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.17.19.tgz", + "integrity": "sha512-IbFsFbxMWLuKEbH+7sTkKzL6NJmG2vRyy6K7JJo55w+8xDk7RElYn6xvXtDW8HCfoKBFK69f3pgBJSUSQPr+4Q==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.17.19.tgz", + "integrity": "sha512-68ngA9lg2H6zkZcyp22tsVt38mlhWde8l3eJLWkyLrp4HwMUr3c1s/M2t7+kHIhvMjglIBrFpncX1SzMckomGw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.2.tgz", + "integrity": "sha512-sSATRjPeDBg3pdgHoQfoYBob11Kk1FGa9lui5RIHZCoCkJa9QKlvl3/vKz2usCmYYjs7ymJR/2Nnsqe+Hjt5nw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.17.19.tgz", + "integrity": "sha512-CwFq42rXCR8TYIjIfpXCbRX0rp1jo6cPIUPSaWwzbVI4aOfX96OXY8M6KNmtPcg7QjYeDmN+DD0Wp3LaBOLf4Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.2.tgz", + "integrity": "sha512-AL2qJILH7lNjrDmCQDvdxMfAUIv8KMNZOvrwAQ8i8//ntL9FflhOyMJ8OZSMBb8/AWXe3/5v5S20y3zCoZWKoQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.17.19.tgz", + "integrity": "sha512-cnq5brJYrSZ2CF6c35eCmviIN3k3RczmHz8eYaVlNasVqsNY+JKohZU5MKmaOI+KkllCdzOKKdPs762VCPC20g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.2.tgz", + "integrity": "sha512-WkhYDmpTjLvGlScA1rwjRUmhl4k8oXR3cIbtqWmELgU/dFeHHlEllxDvdWcNJV9rbzCexB5vz8gtNewWLgCT7Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.17.19.tgz", + "integrity": "sha512-vCRT7yP3zX+bKWFeP/zdS6SqdWB8OIpaRq/mbXQxTGHnIxspRtigpkUcDMlSCOejlHowLqII7K2JKevwyRP2rg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.17.19.tgz", + "integrity": "sha512-yYx+8jwowUstVdorcMdNlzklLYhPxjniHWFKgRqH7IFlUEa0Umu3KuYplf1HUZZ422e3NU9F4LGb+4O0Kdcaag==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.17.19.tgz", + "integrity": "sha512-eggDKanJszUtCdlVs0RB+h35wNlb5v4TWEkq4vZcmVt5u/HiDZrTXe2bWFQUez3RgNHwx/x4sk5++4NSSicKkw==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.17.19.tgz", + "integrity": "sha512-lAhycmKnVOuRYNtRtatQR1LPQf2oYCkRGkSFnseDAKPl8lu5SOsK/e1sXe5a0Pc5kHIHe6P2I/ilntNv2xf3cA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@hapi/hoek": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/@hapi/hoek/-/hoek-9.3.0.tgz", + "integrity": "sha512-/c6rf4UJlmHlC9b5BaNvzAcFv7HZ2QHaV0D4/HNlBdvFnvQq8RI4kYdhyPCl7Xj+oWvTWQ8ujhqS53LIgAe6KQ==", + "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/@hapi/topo": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@hapi/topo/-/topo-5.1.0.tgz", + "integrity": "sha512-foQZKJig7Ob0BMAYBfcJk8d77QtOe7Wo4ox7ff1lQYoNNAb6jwcY1ncdoy2e9wQZzvNy7ODZCYJkK8kzmcAnAg==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "@hapi/hoek": "^9.0.0" + } + }, + "node_modules/@inquirer/ansi": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@inquirer/ansi/-/ansi-1.0.2.tgz", + "integrity": "sha512-S8qNSZiYzFd0wAcyG5AXCvUHC5Sr7xpZ9wZ2py9XR88jUz8wooStVx5M6dRzczbBWjic9NP7+rY0Xi7qqK/aMQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/@inquirer/checkbox": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/@inquirer/checkbox/-/checkbox-4.3.2.tgz", + "integrity": "sha512-VXukHf0RR1doGe6Sm4F0Em7SWYLTHSsbGfJdS9Ja2bX5/D5uwVOEjr07cncLROdBvmnvCATYEWlHqYmXv2IlQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/ansi": "^1.0.2", + "@inquirer/core": "^10.3.2", + "@inquirer/figures": "^1.0.15", + "@inquirer/type": "^3.0.10", + "yoctocolors-cjs": "^2.1.3" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/confirm": { + "version": "5.1.21", + "resolved": "https://registry.npmjs.org/@inquirer/confirm/-/confirm-5.1.21.tgz", + "integrity": "sha512-KR8edRkIsUayMXV+o3Gv+q4jlhENF9nMYUZs9PA2HzrXeHI8M5uDag70U7RJn9yyiMZSbtF5/UexBtAVtZGSbQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/core": "^10.3.2", + "@inquirer/type": "^3.0.10" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/core": { + "version": "10.3.2", + "resolved": "https://registry.npmjs.org/@inquirer/core/-/core-10.3.2.tgz", + "integrity": "sha512-43RTuEbfP8MbKzedNqBrlhhNKVwoK//vUFNW3Q3vZ88BLcrs4kYpGg+B2mm5p2K/HfygoCxuKwJJiv8PbGmE0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/ansi": "^1.0.2", + "@inquirer/figures": "^1.0.15", + "@inquirer/type": "^3.0.10", + "cli-width": "^4.1.0", + "mute-stream": "^2.0.0", + "signal-exit": "^4.1.0", + "wrap-ansi": "^6.2.0", + "yoctocolors-cjs": "^2.1.3" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/core/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/@inquirer/editor": { + "version": "4.2.23", + "resolved": "https://registry.npmjs.org/@inquirer/editor/-/editor-4.2.23.tgz", + "integrity": "sha512-aLSROkEwirotxZ1pBaP8tugXRFCxW94gwrQLxXfrZsKkfjOYC1aRvAZuhpJOb5cu4IBTJdsCigUlf2iCOu4ZDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/core": "^10.3.2", + "@inquirer/external-editor": "^1.0.3", + "@inquirer/type": "^3.0.10" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/expand": { + "version": "4.0.23", + "resolved": "https://registry.npmjs.org/@inquirer/expand/-/expand-4.0.23.tgz", + "integrity": "sha512-nRzdOyFYnpeYTTR2qFwEVmIWypzdAx/sIkCMeTNTcflFOovfqUk+HcFhQQVBftAh9gmGrpFj6QcGEqrDMDOiew==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/core": "^10.3.2", + "@inquirer/type": "^3.0.10", + "yoctocolors-cjs": "^2.1.3" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/external-editor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@inquirer/external-editor/-/external-editor-1.0.3.tgz", + "integrity": "sha512-RWbSrDiYmO4LbejWY7ttpxczuwQyZLBUyygsA9Nsv95hpzUWwnNTVQmAq3xuh7vNwCp07UTmE5i11XAEExx4RA==", + "dev": true, + "license": "MIT", + "dependencies": { + "chardet": "^2.1.1", + "iconv-lite": "^0.7.0" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/figures": { + "version": "1.0.15", + "resolved": "https://registry.npmjs.org/@inquirer/figures/-/figures-1.0.15.tgz", + "integrity": "sha512-t2IEY+unGHOzAaVM5Xx6DEWKeXlDDcNPeDyUpsRc6CUhBfU3VQOEl+Vssh7VNp1dR8MdUJBWhuObjXCsVpjN5g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/@inquirer/input": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/@inquirer/input/-/input-4.3.1.tgz", + "integrity": "sha512-kN0pAM4yPrLjJ1XJBjDxyfDduXOuQHrBB8aLDMueuwUGn+vNpF7Gq7TvyVxx8u4SHlFFj4trmj+a2cbpG4Jn1g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/core": "^10.3.2", + "@inquirer/type": "^3.0.10" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/number": { + "version": "3.0.23", + "resolved": "https://registry.npmjs.org/@inquirer/number/-/number-3.0.23.tgz", + "integrity": "sha512-5Smv0OK7K0KUzUfYUXDXQc9jrf8OHo4ktlEayFlelCjwMXz0299Y8OrI+lj7i4gCBY15UObk76q0QtxjzFcFcg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/core": "^10.3.2", + "@inquirer/type": "^3.0.10" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/password": { + "version": "4.0.23", + "resolved": "https://registry.npmjs.org/@inquirer/password/-/password-4.0.23.tgz", + "integrity": "sha512-zREJHjhT5vJBMZX/IUbyI9zVtVfOLiTO66MrF/3GFZYZ7T4YILW5MSkEYHceSii/KtRk+4i3RE7E1CUXA2jHcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/ansi": "^1.0.2", + "@inquirer/core": "^10.3.2", + "@inquirer/type": "^3.0.10" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/prompts": { + "version": "7.10.1", + "resolved": "https://registry.npmjs.org/@inquirer/prompts/-/prompts-7.10.1.tgz", + "integrity": "sha512-Dx/y9bCQcXLI5ooQ5KyvA4FTgeo2jYj/7plWfV5Ak5wDPKQZgudKez2ixyfz7tKXzcJciTxqLeK7R9HItwiByg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/checkbox": "^4.3.2", + "@inquirer/confirm": "^5.1.21", + "@inquirer/editor": "^4.2.23", + "@inquirer/expand": "^4.0.23", + "@inquirer/input": "^4.3.1", + "@inquirer/number": "^3.0.23", + "@inquirer/password": "^4.0.23", + "@inquirer/rawlist": "^4.1.11", + "@inquirer/search": "^3.2.2", + "@inquirer/select": "^4.4.2" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/rawlist": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/@inquirer/rawlist/-/rawlist-4.1.11.tgz", + "integrity": "sha512-+LLQB8XGr3I5LZN/GuAHo+GpDJegQwuPARLChlMICNdwW7OwV2izlCSCxN6cqpL0sMXmbKbFcItJgdQq5EBXTw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/core": "^10.3.2", + "@inquirer/type": "^3.0.10", + "yoctocolors-cjs": "^2.1.3" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/search": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/@inquirer/search/-/search-3.2.2.tgz", + "integrity": "sha512-p2bvRfENXCZdWF/U2BXvnSI9h+tuA8iNqtUKb9UWbmLYCRQxd8WkvwWvYn+3NgYaNwdUkHytJMGG4MMLucI1kA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/core": "^10.3.2", + "@inquirer/figures": "^1.0.15", + "@inquirer/type": "^3.0.10", + "yoctocolors-cjs": "^2.1.3" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/select": { + "version": "4.4.2", + "resolved": "https://registry.npmjs.org/@inquirer/select/-/select-4.4.2.tgz", + "integrity": "sha512-l4xMuJo55MAe+N7Qr4rX90vypFwCajSakx59qe/tMaC1aEHWLyw68wF4o0A4SLAY4E0nd+Vt+EyskeDIqu1M6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/ansi": "^1.0.2", + "@inquirer/core": "^10.3.2", + "@inquirer/figures": "^1.0.15", + "@inquirer/type": "^3.0.10", + "yoctocolors-cjs": "^2.1.3" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "node_modules/@inquirer/type": { + "version": "3.0.10", + "resolved": "https://registry.npmjs.org/@inquirer/type/-/type-3.0.10.tgz", + "integrity": "sha512-BvziSRxfz5Ov8ch0z/n3oijRSEcEsHnhggm4xFZe93DHcUCTlutlq9Ox4SVENAfcRD22UQq7T/atg9Wr3k09eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + } + } + }, + "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/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.6.0", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz", + "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==", + "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/@rollup/plugin-commonjs": { + "version": "25.0.8", + "resolved": "https://registry.npmjs.org/@rollup/plugin-commonjs/-/plugin-commonjs-25.0.8.tgz", + "integrity": "sha512-ZEZWTK5n6Qde0to4vS9Mr5x/0UZoqCxPVR9KRUjU4kA2sO7GEUn1fop0DAwpO6z0Nw/kJON9bDmSxdWxO/TT1A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "commondir": "^1.0.1", + "estree-walker": "^2.0.2", + "glob": "^8.0.3", + "is-reference": "1.2.1", + "magic-string": "^0.30.3" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^2.68.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-json": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/@rollup/plugin-json/-/plugin-json-6.1.0.tgz", + "integrity": "sha512-EGI2te5ENk1coGeADSIwZ7G2Q8CJS2sF120T7jLw4xFw9n7wIOXHo+kIYRAoVpJAN+kmqZSoO3Fp4JtoNF4ReA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.1.0" + }, + "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/plugin-node-resolve": { + "version": "15.3.1", + "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-15.3.1.tgz", + "integrity": "sha512-tgg6b91pAybXHJQMAAwW9VuWBO6Thi+q7BCNARLwSqlmsHz0XYURtGvh/AuwSADXSI4h/2uHbs7s4FzlZDGSGA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "@types/resolve": "1.20.2", + "deepmerge": "^4.2.2", + "is-module": "^1.0.0", + "resolve": "^1.22.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^2.78.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-replace": { + "version": "5.0.7", + "resolved": "https://registry.npmjs.org/@rollup/plugin-replace/-/plugin-replace-5.0.7.tgz", + "integrity": "sha512-PqxSfuorkHz/SPpyngLyg5GCEkOcee9M1bkxiVDr41Pd61mqP1PLOoDPbpl44SB2mQGKwV/In74gqQmGITOhEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "magic-string": "^0.30.3" + }, + "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/plugin-terser": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/@rollup/plugin-terser/-/plugin-terser-0.4.4.tgz", + "integrity": "sha512-XHeJC5Bgvs8LfukDwWZp7yeqin6ns8RTl2B9avbejt6tZqsqvVoWI7ZTQrcNsfKEDWBTnTxM8nMDkO2IFFbd0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "serialize-javascript": "^6.0.1", + "smob": "^1.0.0", + "terser": "^5.17.4" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-virtual": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@rollup/plugin-virtual/-/plugin-virtual-3.0.2.tgz", + "integrity": "sha512-10monEYsBp3scM4/ND4LNH5Rxvh3e/cVeL3jWTgZ2SrQ+BmUoQcopVQvnaMcOnykb1VkxUFuDAN+0FnpTFRy2A==", + "dev": true, + "license": "MIT", + "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": { + "version": "5.5.1", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.5.1.tgz", + "integrity": "sha512-P9ZvnfouRu4MSC+ilERaw6FmZs8zqKhpHxEs4aGDGWQAMzQGXnhvCSvoNwokfNvdt7t3Y5Y4p6gStQgezeIqug==", + "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/@sideway/address": { + "version": "4.1.5", + "resolved": "https://registry.npmjs.org/@sideway/address/-/address-4.1.5.tgz", + "integrity": "sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "@hapi/hoek": "^9.0.0" + } + }, + "node_modules/@sideway/formula": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@sideway/formula/-/formula-3.0.1.tgz", + "integrity": "sha512-/poHZJJVjx3L+zVD6g9KgHfYnb443oi7wLu/XKojDviHy6HOEOA6z1Trk5aR1dGcmPenJEgb2sK2I80LeS3MIg==", + "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/@sideway/pinpoint": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@sideway/pinpoint/-/pinpoint-2.0.0.tgz", + "integrity": "sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ==", + "dev": true, + "license": "BSD-3-Clause" + }, + "node_modules/@sinclair/typebox": { + "version": "0.34.13", + "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.34.13.tgz", + "integrity": "sha512-ceVKqyCEgC355Kw0s/0tyfY9MzMQINSykJ/pG2w6YnaZyrcjV48svZpr8lVZrYgWjzOmrIPBhQRAtr/7eJpA5g==", + "dev": true, + "license": "MIT" + }, + "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/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/cssnano": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/@types/cssnano/-/cssnano-5.0.0.tgz", + "integrity": "sha512-z98V7ICNAojxj9YV9+Q8qV+F7fW0poLWJRjed9tu7KNdYzHwAvLOAsTMI8xWjkOY9yzO+HmMxRRixlIvRsZwXg==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss": "^8" + } + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/express": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.21.tgz", + "integrity": "sha512-ejlPM315qwLpaQlQDTjPdsUFSc6ZsP4AN6AlWnogPjQ7CVi7PYF3YVz+CY3jE2pwYf7E/7HlDAN0rV2GxTG0HQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/body-parser": "*", + "@types/express-serve-static-core": "^4.17.33", + "@types/qs": "*", + "@types/serve-static": "*" + } + }, + "node_modules/@types/express-serve-static-core": { + "version": "4.19.9", + "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.9.tgz", + "integrity": "sha512-QP2ESEe/ImWY0HDwNAnK9PvEffUyhLTnWkk7KXzHfyeWAnlrDe1fN77bXl6ia8KT3wPlmA7t9/VPRpnf4Ex9sg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*", + "@types/qs": "*", + "@types/range-parser": "*", + "@types/send": "*" + } + }, + "node_modules/@types/geojson": { + "version": "7946.0.15", + "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.15.tgz", + "integrity": "sha512-9oSxFzDCT2Rj6DfcHF8G++jxBKS7mBqXl5xrRW+Kbvjry6Uduya2iiwqHPhVXpasAVMBYKkEPGgKhd3+/HZ6xA==", + "dev": true, + "license": "MIT" + }, + "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/node": { + "version": "22.20.5", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.20.5.tgz", + "integrity": "sha512-U2+DNr+wSjpsTS/wZGYHq7GcwfuSmKiKvoPvK22zwTlRhU91yOniN4qRR5KhIjvif7ysw/dz/hKmfDH0Ris4aA==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "node_modules/@types/parse-json": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.2.tgz", + "integrity": "sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==", + "dev": true, + "license": "MIT" + }, + "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/resolve": { + "version": "1.20.2", + "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.20.2.tgz", + "integrity": "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==", + "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": "2.2.0", + "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-2.2.0.tgz", + "integrity": "sha512-8mam4H1NHLtu7nmtalF7eyBH14QyOASmcxHhSfEoRyr0nP/YdoesEtU+uSRvMe96TW/HPTtkoKqQLl53N7UXMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/http-errors": "*", + "@types/node": "*" + } + }, + "node_modules/@unhead/dom": { + "version": "1.11.20", + "resolved": "https://registry.npmjs.org/@unhead/dom/-/dom-1.11.20.tgz", + "integrity": "sha512-jgfGYdOH+xHJF/j8gudjsYu3oIjFyXhCWcgKaw3vQnT616gSqyqnGQGOItL+BQtQZACKNISwIfx5PuOtztMKLA==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@unhead/schema": "1.11.20", + "@unhead/shared": "1.11.20" + }, + "funding": { + "url": "https://github.com/sponsors/harlan-zw" + } + }, + "node_modules/@unhead/schema": { + "version": "1.11.20", + "resolved": "https://registry.npmjs.org/@unhead/schema/-/schema-1.11.20.tgz", + "integrity": "sha512-0zWykKAaJdm+/Y7yi/Yds20PrUK7XabLe9c3IRcjnwYmSWY6z0Cr19VIs3ozCj8P+GhR+/TI2mwtGlueCEYouA==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "hookable": "^5.5.3", + "zhead": "^2.2.4" + }, + "funding": { + "url": "https://github.com/sponsors/harlan-zw" + } + }, + "node_modules/@unhead/shared": { + "version": "1.11.20", + "resolved": "https://registry.npmjs.org/@unhead/shared/-/shared-1.11.20.tgz", + "integrity": "sha512-1MOrBkGgkUXS+sOKz/DBh4U20DNoITlJwpmvSInxEUNhghSNb56S0RnaHRq0iHkhrO/cDgz2zvfdlRpoPLGI3w==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@unhead/schema": "1.11.20", + "packrup": "^0.1.2" + }, + "funding": { + "url": "https://github.com/sponsors/harlan-zw" + } + }, + "node_modules/@unhead/vue": { + "version": "1.11.20", + "resolved": "https://registry.npmjs.org/@unhead/vue/-/vue-1.11.20.tgz", + "integrity": "sha512-sqQaLbwqY9TvLEGeq8Fd7+F2TIuV3nZ5ihVISHjWpAM3y7DwNWRU7NmT9+yYT+2/jw1Vjwdkv5/HvDnvCLrgmg==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@unhead/schema": "1.11.20", + "@unhead/shared": "1.11.20", + "hookable": "^5.5.3", + "unhead": "1.11.20" + }, + "funding": { + "url": "https://github.com/sponsors/harlan-zw" + }, + "peerDependencies": { + "vue": ">=2.7 || >=3" + } + }, + "node_modules/@vitejs/plugin-vue": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-4.6.2.tgz", + "integrity": "sha512-kqf7SGFoG+80aZG6Pf+gsZIVvGSCKE98JbiWqcCV9cThtg91Jav0yvYFC9Zb+jKetNGF6ZKeoaxgZfND21fWKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "peerDependencies": { + "vite": "^4.0.0 || ^5.0.0", + "vue": "^3.2.25" + } + }, + "node_modules/@vue/compiler-core": { + "version": "3.5.44", + "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.44.tgz", + "integrity": "sha512-k34nCytbK8PQ1gR2mGROYOw6Pnv/mumqIdrZ3x2tbyXZDWm7ViKGLTfdB+DRrWqEQsLgGJvn0WN9jBif5zCTLQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.9", + "@vue/shared": "3.5.44", + "entities": "^7.0.1", + "estree-walker": "^2.0.2", + "source-map-js": "^1.2.2" + } + }, + "node_modules/@vue/compiler-core/node_modules/entities": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz", + "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/@vue/compiler-dom": { + "version": "3.5.44", + "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.44.tgz", + "integrity": "sha512-W5AoBFWdw1lQAKiHowkfgFKFab82oSRT6sGsPfw/q1GRjsy/ZJFLHGhJyBRIFN9APLTUduDH9U2JAiPOIyKuYg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-core": "3.5.44", + "@vue/shared": "3.5.44" + } + }, + "node_modules/@vue/compiler-sfc": { + "version": "3.5.44", + "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.44.tgz", + "integrity": "sha512-dzHmQ4jXTpdr5FjIQUeykVakN/uzqFbUo9/C5ikBFg3a3PeM6uRxeczx1ZbXBML0/zJstEh3ygYipzR5Z7b2Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.9", + "@vue/compiler-core": "3.5.44", + "@vue/compiler-dom": "3.5.44", + "@vue/compiler-ssr": "3.5.44", + "@vue/shared": "3.5.44", + "estree-walker": "^2.0.2", + "magic-string": "^0.30.21", + "postcss": "^8.5.29", + "source-map-js": "^1.2.2" + } + }, + "node_modules/@vue/compiler-ssr": { + "version": "3.5.44", + "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.44.tgz", + "integrity": "sha512-xr5gb1JVHlfXJwSlRz1FeP6uxoazdzHuMTVLE7up+4Vrqxk219CvxLPxD9NXBt47yvZW7+p4DXfyp4O1fkByIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-dom": "3.5.44", + "@vue/shared": "3.5.44" + } + }, + "node_modules/@vue/devtools-api": { + "version": "6.6.4", + "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-6.6.4.tgz", + "integrity": "sha512-sGhTPMuXqZ1rVOk32RylztWkfXTRhuS7vgAKv0zjqk8gbsHkJ7xfFf+jbySxt7tWObEJwyKaHMikV/WGDiQm8g==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/@vue/reactivity": { + "version": "3.5.44", + "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.44.tgz", + "integrity": "sha512-u+QJdKeBBEADkPdevsL+6E12QlYVfBD8Zcw5qjDQKtamI6l14KyqazJMobhCKelhWN5zpyKUiEDoTyHE93cqWw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/shared": "3.5.44" + } + }, + "node_modules/@vue/runtime-core": { + "version": "3.5.44", + "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.44.tgz", + "integrity": "sha512-uEa/ndwjhrrhnOfb2p+sZy6zeoamJOISqaLSJGk/8R6nABT1ZldpzcJoPzKj+zHVomVBPcmQYyC2r4LtvDV6CQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/reactivity": "3.5.44", + "@vue/shared": "3.5.44" + } + }, + "node_modules/@vue/runtime-dom": { + "version": "3.5.44", + "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.44.tgz", + "integrity": "sha512-3fc4ARcXVhVBaJ3ujWiNZJARD6pkyRcwG+ZYhMzjKtKUp7MAY0HLwr7r3Smep3Li6ZaWT6ewdmx8XqdaD5oNZg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/reactivity": "3.5.44", + "@vue/runtime-core": "3.5.44", + "@vue/shared": "3.5.44", + "csstype": "^3.2.3" + } + }, + "node_modules/@vue/server-renderer": { + "version": "3.5.44", + "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.44.tgz", + "integrity": "sha512-R4S1UoH4h5Frrauv8Z5XE5TxV9oBiUSgWIC4TyVK1FK+RocRnOLwFA5Xcmo2011RlgJp+AbZCnw6afrhlgRuUQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-ssr": "3.5.44", + "@vue/runtime-dom": "3.5.44", + "@vue/shared": "3.5.44" + } + }, + "node_modules/@vue/shared": { + "version": "3.5.44", + "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.44.tgz", + "integrity": "sha512-H82XLH0DjmSOdbEwO15x3QTo1f5PWEtv237eLpYKc0mqLu+B8hnq16lFWmuBmNurkeiG3wr+oM1FhOll/YVFRg==", + "dev": true, + "license": "MIT" + }, + "node_modules/acorn": { + "version": "8.19.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.19.0.tgz", + "integrity": "sha512-oJlA3XiRm7Cyk6qFD2Jn8ak9B7jSy0qy00ADO3+8dpT0LSjFihQYv4C02LFCSYJV3Q37xYwwRy5m+IpIiUzqWw==", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "type-fest": "^0.21.3" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ansi-regex": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.4.0.tgz", + "integrity": "sha512-KzTVk2tCWAHtYrvvvaP8bJKJq2pVinhLcGEQdtLIYPbmNGNyYe8QwNaTUYQp2J7/vIsUKt5QCqAfUkYyG9DkOw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "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/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "license": "Python-2.0" + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/axios": { + "version": "1.7.9", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.9.tgz", + "integrity": "sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==", + "dev": true, + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.15.6", + "form-data": "^4.0.0", + "proxy-from-env": "^1.1.0" + } + }, + "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==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/baseline-browser-mapping": { + "version": "2.11.32", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.32.tgz", + "integrity": "sha512-UvuxFU9P3hM29LrQdwu0cD6w6/+SFr+UlB9s/knI7+O2rK9xFxKUwSDWxGdbbqQ9/V7BJ5s0NI5nQAE4uJp3gQ==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/bl": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/bl/-/bl-5.1.0.tgz", + "integrity": "sha512-tv1ZJHLfTDnXE6tMHv73YgSJaWR2AFuPwMntBe7XL/GBFHnT0CLnsHMogfk5+GzCDC5ZWarSCYaIGATZt9dNsQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "buffer": "^6.0.3", + "inherits": "^2.0.4", + "readable-stream": "^3.4.0" + } + }, + "node_modules/boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==", + "dev": true, + "license": "ISC" + }, + "node_modules/brace-expansion": { + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.7.tgz", + "integrity": "sha512-uZbew1NqdmPDTMJ8ah1y+b+9QEJrfkXFk3RcTQw3X0jW/xRUvFKsg1CfQdSYGdTbXZWExtU3J3ccxtnfw1Fi0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/browserslist": { + "version": "4.29.4", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.4.tgz", + "integrity": "sha512-2TcbbiwXEq+N0kD36tykpCfyyQigUXmuwNQbnPp4Xk4PX9JOqVIKjJlIDjpH7uY6tmRGoAd+apeT1p60T8wsdA==", + "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.11.29", + "caniuse-lite": "^1.0.30001816", + "electron-to-chromium": "^1.5.459", + "node-releases": "^2.0.59", + "update-browserslist-db": "^1.3.4" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "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==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "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/caniuse-api": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/caniuse-api/-/caniuse-api-3.0.0.tgz", + "integrity": "sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.0.0", + "caniuse-lite": "^1.0.0", + "lodash.memoize": "^4.1.2", + "lodash.uniq": "^4.5.0" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001819", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001819.tgz", + "integrity": "sha512-LFUqIIAwpzsIuevnKnsR9qnStBcgzPShTX61lBwN9uFkkf8o8zLiebEjbW8AYtZiF+1YKDWfdt/pWDtMuG8Xwg==", + "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/chalk": { + "version": "5.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz", + "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/chardet": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/chardet/-/chardet-2.2.0.tgz", + "integrity": "sha512-rddelWYNPRrXq6PtNEN2S3f6t9ILzvqaN5pVgi4kqt9jHQaXIial9PznB5iSPVlQSLNaaH22ItWz3EJtQ10+OA==", + "dev": true, + "license": "MIT" + }, + "node_modules/cli-cursor": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-4.0.0.tgz", + "integrity": "sha512-VGtlMu3x/4DOtIUwEkRezxUZ2lBacNJCHash0N0WeZDBS+7Ux1dm3XWAgWYxLJFMMdOeXMHXorshEFhbMSGelg==", + "dev": true, + "license": "MIT", + "dependencies": { + "restore-cursor": "^4.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cli-spinners": { + "version": "2.9.2", + "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.9.2.tgz", + "integrity": "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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/clone": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz", + "integrity": "sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/colord": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/colord/-/colord-2.10.0.tgz", + "integrity": "sha512-AidJptpBJmjTclAp9BkLwJi0T93fo5epJnbaZslpg6QVzpHjAiveF55mE9AcUJiGMqRHgMDY8soMsQtuNYMHfw==", + "dev": true, + "license": "MIT" + }, + "node_modules/colorette": { + "version": "2.0.19", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.19.tgz", + "integrity": "sha512-3tlv/dIP7FWvj3BsbHrGLJ6l/oKh1O3TcgBqMn+yyCagOxc23fyzDS6HypQbgxWbkpDnf52p1LuR4eWDQ/K9WQ==", + "dev": true, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/commander": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz", + "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14" + } + }, + "node_modules/commondir": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz", + "integrity": "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==", + "dev": true, + "license": "MIT" + }, + "node_modules/cosmiconfig": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.1.0.tgz", + "integrity": "sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/parse-json": "^4.0.0", + "import-fresh": "^3.2.1", + "parse-json": "^5.0.0", + "path-type": "^4.0.0", + "yaml": "^1.10.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/css-declaration-sorter": { + "version": "6.4.1", + "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-6.4.1.tgz", + "integrity": "sha512-rtdthzxKuyq6IzqX6jEcIzQF/YqccluefyCYheovBOLhFT/drQA9zj/UbRAa9J7C0o6EG6u3E6g+vKkay7/k3g==", + "dev": true, + "license": "ISC", + "engines": { + "node": "^10 || ^12 || >=14" + }, + "peerDependencies": { + "postcss": "^8.0.9" + } + }, + "node_modules/css-select": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz", + "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^6.0.1", + "domhandler": "^4.3.1", + "domutils": "^2.8.0", + "nth-check": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css-tree": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-1.1.3.tgz", + "integrity": "sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.14", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/css-what": { + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.2.2.tgz", + "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/cssesc": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", + "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "dev": true, + "license": "MIT", + "bin": { + "cssesc": "bin/cssesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/cssnano": { + "version": "5.1.15", + "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-5.1.15.tgz", + "integrity": "sha512-j+BKgDcLDQA+eDifLx0EO4XSA56b7uut3BQFH+wbSaSTuGLuiyTa/wbRYthUXX8LC9mLg+WWKe8h+qJuwTAbHw==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssnano-preset-default": "^5.2.14", + "lilconfig": "^2.0.3", + "yaml": "^1.10.2" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/cssnano" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/cssnano-preset-default": { + "version": "5.2.14", + "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-5.2.14.tgz", + "integrity": "sha512-t0SFesj/ZV2OTylqQVOrFgEh5uanxbO6ZAdeCrNsUQ6fVuXwYTxJPNAGvGTxHbD68ldIJNec7PyYZDBrfDQ+6A==", + "dev": true, + "license": "MIT", + "dependencies": { + "css-declaration-sorter": "^6.3.1", + "cssnano-utils": "^3.1.0", + "postcss-calc": "^8.2.3", + "postcss-colormin": "^5.3.1", + "postcss-convert-values": "^5.1.3", + "postcss-discard-comments": "^5.1.2", + "postcss-discard-duplicates": "^5.1.0", + "postcss-discard-empty": "^5.1.1", + "postcss-discard-overridden": "^5.1.0", + "postcss-merge-longhand": "^5.1.7", + "postcss-merge-rules": "^5.1.4", + "postcss-minify-font-values": "^5.1.0", + "postcss-minify-gradients": "^5.1.1", + "postcss-minify-params": "^5.1.4", + "postcss-minify-selectors": "^5.2.1", + "postcss-normalize-charset": "^5.1.0", + "postcss-normalize-display-values": "^5.1.0", + "postcss-normalize-positions": "^5.1.1", + "postcss-normalize-repeat-style": "^5.1.1", + "postcss-normalize-string": "^5.1.0", + "postcss-normalize-timing-functions": "^5.1.0", + "postcss-normalize-unicode": "^5.1.1", + "postcss-normalize-url": "^5.1.0", + "postcss-normalize-whitespace": "^5.1.1", + "postcss-ordered-values": "^5.1.3", + "postcss-reduce-initial": "^5.1.2", + "postcss-reduce-transforms": "^5.1.0", + "postcss-svgo": "^5.1.0", + "postcss-unique-selectors": "^5.1.1" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/cssnano-utils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/cssnano-utils/-/cssnano-utils-3.1.0.tgz", + "integrity": "sha512-JQNR19/YZhz4psLX/rQ9M83e3z2Wf/HdJbryzte4a3NSuafyp9w/I4U+hx5C2S9g41qlstH7DEWnZaaj83OuEA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/csso": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/csso/-/csso-4.2.0.tgz", + "integrity": "sha512-wvlcdIbf6pwKEk7vHj8/Bkc0B4ylXZruLvOgs9doS5eOsOpuodOV2zJChSpkp+pRpYQLQMeF04nr3Z68Sta9jA==", + "dev": true, + "license": "MIT", + "dependencies": { + "css-tree": "^1.1.2" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/date-fns": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.1.0.tgz", + "integrity": "sha512-Ukq0owbQXxa/U3EGtsdVBkR1w7KOQ5gIBqdH2hkvknzZPYvBxb/aa6E8L7tmjFtkwZBu3UXBbjIgPo/Ez4xaNg==", + "dev": true, + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/kossnocorp" + } + }, + "node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decamelize": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-6.0.0.tgz", + "integrity": "sha512-Fv96DCsdOgB6mdGl67MT5JaTNKRzrzill5OH5s8bjYJXVlcXyPYGyPsUkWyGV5p1TXI5esYIYMMeDJL0hEIwaA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/decode-uri-component": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.2.tgz", + "integrity": "sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10" + } + }, + "node_modules/deepmerge": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz", + "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/defaults": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/defaults/-/defaults-1.0.4.tgz", + "integrity": "sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==", + "dev": true, + "license": "MIT", + "dependencies": { + "clone": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/dom-serializer": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz", + "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==", + "dev": true, + "license": "MIT", + "dependencies": { + "domelementtype": "^2.0.1", + "domhandler": "^4.2.0", + "entities": "^2.0.0" + }, + "funding": { + "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" + } + }, + "node_modules/domelementtype": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz", + "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "license": "BSD-2-Clause" + }, + "node_modules/domhandler": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz", + "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "domelementtype": "^2.2.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "node_modules/domutils": { + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz", + "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "dom-serializer": "^1.0.1", + "domelementtype": "^2.2.0", + "domhandler": "^4.2.0" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, + "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==", + "dev": true, + "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/electron-to-chromium": { + "version": "1.5.464", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.464.tgz", + "integrity": "sha512-nRa65aFge40viPAKxMKULIY8tcXKwKboJWNn4RoKwyWXJ6SP7BnrDGKUTzc64818jIciH0PK7LSF8QzZes19GA==", + "dev": true, + "license": "ISC" + }, + "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/entities": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", + "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==", + "dev": true, + "license": "BSD-2-Clause", + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/error-ex": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz", + "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-arrayish": "^0.2.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==", + "dev": true, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-module-lexer": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz", + "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==", + "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==", + "dev": true, + "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==", + "dev": true, + "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/esbuild": { + "version": "0.17.19", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.17.19.tgz", + "integrity": "sha512-XQ0jAPFkK/u3LcVRcvVHQcTIqD6E2H1fvZMA5dQPSOWb3suUbWbfbRf94pjc0bNzRYLfIrDRQXr7X+LHIm5oHw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/android-arm": "0.17.19", + "@esbuild/android-arm64": "0.17.19", + "@esbuild/android-x64": "0.17.19", + "@esbuild/darwin-arm64": "0.17.19", + "@esbuild/darwin-x64": "0.17.19", + "@esbuild/freebsd-arm64": "0.17.19", + "@esbuild/freebsd-x64": "0.17.19", + "@esbuild/linux-arm": "0.17.19", + "@esbuild/linux-arm64": "0.17.19", + "@esbuild/linux-ia32": "0.17.19", + "@esbuild/linux-loong64": "0.17.19", + "@esbuild/linux-mips64el": "0.17.19", + "@esbuild/linux-ppc64": "0.17.19", + "@esbuild/linux-riscv64": "0.17.19", + "@esbuild/linux-s390x": "0.17.19", + "@esbuild/linux-x64": "0.17.19", + "@esbuild/netbsd-x64": "0.17.19", + "@esbuild/openbsd-x64": "0.17.19", + "@esbuild/sunos-x64": "0.17.19", + "@esbuild/win32-arm64": "0.17.19", + "@esbuild/win32-ia32": "0.17.19", + "@esbuild/win32-x64": "0.17.19" + } + }, + "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/esm": { + "version": "3.2.25", + "resolved": "https://registry.npmjs.org/esm/-/esm-3.2.25.tgz", + "integrity": "sha512-U1suiZ2oDVWv4zPO56S0NcR5QriEahGtdN2OR6FiOG4WJvcjBVFB0qI4+eKoWFH483PKGuLuu6V8Z4T5g63UVA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "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/eventemitter3": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", + "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==", + "dev": true, + "license": "MIT" + }, + "node_modules/execa": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-7.2.0.tgz", + "integrity": "sha512-UduyVP7TLB5IcAQl+OzLyLcS/l32W/GLg+AhHJ+ow40FOk2U3SAllPwR44v4vmdFwIWqpdwxxpQbF1n5ta9seA==", + "dev": true, + "license": "MIT", + "dependencies": { + "cross-spawn": "^7.0.3", + "get-stream": "^6.0.1", + "human-signals": "^4.3.0", + "is-stream": "^3.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^5.1.0", + "onetime": "^6.0.0", + "signal-exit": "^3.0.7", + "strip-final-newline": "^3.0.0" + }, + "engines": { + "node": "^14.18.0 || ^16.14.0 || >=18.0.0" + }, + "funding": { + "url": "https://github.com/sindresorhus/execa?sponsor=1" + } + }, + "node_modules/filter-obj": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/filter-obj/-/filter-obj-1.1.0.tgz", + "integrity": "sha512-8rXg1ZnX7xzy2NGDVkBVaAy+lSlPNwad13BtgSlLuxfIslyt5Vg64U7tFcCt4WS1R0hvtnQybT/IyCkGZ3DpXQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/flat": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/flat/-/flat-6.0.1.tgz", + "integrity": "sha512-/3FfIa8mbrg3xE7+wAhWeV+bd7L2Mof+xtZb5dRDKZ+wDvYJK4WDYeIOuOhre5Yv5aQObZrlbRmk3RTSiuQBtw==", + "dev": true, + "license": "BSD-3-Clause", + "bin": { + "flat": "cli.js" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/follow-redirects": { + "version": "1.16.1", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.16.1.tgz", + "integrity": "sha512-FNvFGzoMLWmE6Yj9spb/zjd7yiNCHiAW9/Tg9CXrQ8wuu32HtlJOwWO11OJafl5FfY3DxTdQ0vj42zU1kvv5jg==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "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==", + "dev": true, + "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/fs-extra": { + "version": "11.2.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.2.0.tgz", + "integrity": "sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw==", + "dev": true, + "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==", + "dev": true, + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "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==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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==", + "dev": true, + "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-package-type": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz", + "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.0.0" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/getopts": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/getopts/-/getopts-2.3.0.tgz", + "integrity": "sha512-5eDf9fuSXwxBL6q5HX+dhDj+dslFGWzU5thZ9kNKUkcPtaPdatmUFKwHFrLb/uf/WpA4BHET+AX3Scl56cAjpA==", + "dev": true, + "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", + "dev": true, + "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/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "dev": true, + "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==", + "dev": true, + "license": "ISC" + }, + "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==", + "dev": true, + "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==", + "dev": true, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hookable": { + "version": "5.5.3", + "resolved": "https://registry.npmjs.org/hookable/-/hookable-5.5.3.tgz", + "integrity": "sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==", + "dev": true, + "license": "MIT", + "peer": true + }, + "node_modules/human-signals": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-4.3.1.tgz", + "integrity": "sha512-nZXjEF2nbo7lIw3mgYjItAfgQXog3OjJogSbKa2CQIIvSGWcKgeJnQlNXip6NglNzYH45nSRiEVimMvYL8DDqQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=14.18.0" + } + }, + "node_modules/iconv-lite": { + "version": "0.7.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.3.tgz", + "integrity": "sha512-IKXpvIzjnC9XTAUbVBcMfGS0EPaIXtW6v+zr+RRp+hqULEpo0owZax6wyRwPOJbWbzjYspQwusTsfVr0ifh4uQ==", + "dev": true, + "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/icss-utils": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/icss-utils/-/icss-utils-5.1.0.tgz", + "integrity": "sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==", + "dev": true, + "license": "ISC", + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.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==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "BSD-3-Clause" + }, + "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/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", + "dev": true, + "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==", + "dev": true, + "license": "ISC" + }, + "node_modules/inquirer": { + "version": "12.3.0", + "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-12.3.0.tgz", + "integrity": "sha512-3NixUXq+hM8ezj2wc7wC37b32/rHq1MwNZDYdvx+d6jokOD+r+i8Q4Pkylh9tISYP114A128LCX8RKhopC5RfQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@inquirer/core": "^10.1.2", + "@inquirer/prompts": "^7.2.1", + "@inquirer/type": "^3.0.2", + "ansi-escapes": "^4.3.2", + "mute-stream": "^2.0.0", + "run-async": "^3.0.0", + "rxjs": "^7.8.1" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "@types/node": ">=18" + } + }, + "node_modules/interpret": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-2.2.0.tgz", + "integrity": "sha512-Ju0Bz/cEia55xDwUWEa8+olFpCiQoypjnQySseKtmjNrnps3P+xfpUmGr90T7yjlVJmOtybRvPXhKMbHr+fWnw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-core-module": { + "version": "2.17.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.17.0.tgz", + "integrity": "sha512-J/vG0zBCbIKOQFfufSwyXdMrsohyJIUNkrnmo6WZGzoM7tr/lsbfW5b2BvisL6zsyMzK9UxV9L6c7AoFbyXHOA==", + "dev": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-interactive": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-2.0.0.tgz", + "integrity": "sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz", + "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==", + "dev": true, + "license": "MIT" + }, + "node_modules/is-reference": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz", + "integrity": "sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "*" + } + }, + "node_modules/is-stream": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz", + "integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-unicode-supported": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-1.3.0.tgz", + "integrity": "sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "node_modules/joi": { + "version": "17.13.3", + "resolved": "https://registry.npmjs.org/joi/-/joi-17.13.3.tgz", + "integrity": "sha512-otDA4ldcIx+ZXsKHWmp0YizCweVRZG96J10b0FevjfuncLO1oX59THoAmHkNubYJ+9gWsYsp5k8v4ib6oDv1fA==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "@hapi/hoek": "^9.3.0", + "@hapi/topo": "^5.1.0", + "@sideway/address": "^4.1.5", + "@sideway/formula": "^3.0.1", + "@sideway/pinpoint": "^2.0.0" + } + }, + "node_modules/joycon": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/joycon/-/joycon-3.1.1.tgz", + "integrity": "sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "dev": true, + "license": "MIT" + }, + "node_modules/jsonc-parser": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.3.1.tgz", + "integrity": "sha512-HUgH65KyejrUFPvHFPbqOY0rsFip3Bo5wb4ngvdi1EpCYWUQDC5V+Y7mZws+DLkr4M//zQJoanu1SP+87Dv1oQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/jsonfile": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz", + "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/knex": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/knex/-/knex-3.1.0.tgz", + "integrity": "sha512-GLoII6hR0c4ti243gMs5/1Rb3B+AjwMOfjYm97pu0FOQa7JH56hgBxYf5WK2525ceSbBY1cjeZ9yk99GPMB6Kw==", + "dev": true, + "license": "MIT", + "dependencies": { + "colorette": "2.0.19", + "commander": "^10.0.0", + "debug": "4.3.4", + "escalade": "^3.1.1", + "esm": "^3.2.25", + "get-package-type": "^0.1.0", + "getopts": "2.3.0", + "interpret": "^2.2.0", + "lodash": "^4.17.21", + "pg-connection-string": "2.6.2", + "rechoir": "^0.8.0", + "resolve-from": "^5.0.0", + "tarn": "^3.0.2", + "tildify": "2.0.0" + }, + "bin": { + "knex": "bin/cli.js" + }, + "engines": { + "node": ">=16" + }, + "peerDependenciesMeta": { + "better-sqlite3": { + "optional": true + }, + "mysql": { + "optional": true + }, + "mysql2": { + "optional": true + }, + "pg": { + "optional": true + }, + "pg-native": { + "optional": true + }, + "sqlite3": { + "optional": true + }, + "tedious": { + "optional": true + } + } + }, + "node_modules/lilconfig": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz", + "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/lines-and-columns": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/lodash-es": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.17.21.tgz", + "integrity": "sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==", + "dev": true, + "license": "MIT" + }, + "node_modules/lodash.memoize": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz", + "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==", + "dev": true, + "license": "MIT" + }, + "node_modules/lodash.uniq": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz", + "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/log-symbols": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-5.1.0.tgz", + "integrity": "sha512-l0x2DvrW294C9uDCoQe1VSU4gf529FkSZ6leBl4TiqZH/e+0R7hSfHQBNut2mNygDgHwvYHfFLn6Oxb3VWj2rA==", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^5.0.0", + "is-unicode-supported": "^1.1.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/mdn-data": { + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.14.tgz", + "integrity": "sha512-dn6wd0uw5GsdswPFfsgMp5NSB0/aDe6fK94YJV/AJDYXL6HVLWBsxeq7js7Ad+mU2K9LAlwpk6kN2D5mwCPVow==", + "dev": true, + "license": "CC0-1.0" + }, + "node_modules/merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "dev": true, + "license": "MIT" + }, + "node_modules/micromustache": { + "version": "8.0.3", + "resolved": "https://registry.npmjs.org/micromustache/-/micromustache-8.0.3.tgz", + "integrity": "sha512-SXjrEPuYNtWq0reR9LR2nHdzdQx/3re9HPcDGjm00L7hi2RsH5KMRBhYEBvPdyQC51RW/2TznjwX/sQLPPyHNw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/userpixel/micromustache/blob/master/.github/FUNDING.yml" + } + }, + "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==", + "dev": true, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mimic-fn": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz", + "integrity": "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/minimatch": { + "version": "5.1.9", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz", + "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "dev": true, + "license": "MIT" + }, + "node_modules/mute-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-2.0.0.tgz", + "integrity": "sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==", + "dev": true, + "license": "ISC", + "engines": { + "node": "^18.17.0 || >=20.5.0" + } + }, + "node_modules/nanoid": { + "version": "5.0.9", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-5.0.9.tgz", + "integrity": "sha512-Aooyr6MXU6HpvvWXKoVoXwKMs/KyVakWwg7xQfv5/S/RIgJMy0Ifa45H9qqYy7pTCszrHzP21Uk4PZq2HpEM8Q==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.js" + }, + "engines": { + "node": "^18 || >=20" + } + }, + "node_modules/node-releases": { + "version": "2.0.60", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.60.tgz", + "integrity": "sha512-OmO8+GM1JUZqXET720VrJCwkjUCXmCMQm0Z3UDDRbfNLHS4NEAvY60j5jiFv0tkKw2PNNlqOLhahVmwJIOLDIQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/normalize-url": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz", + "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-run-path": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.3.0.tgz", + "integrity": "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^4.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-run-path/node_modules/path-key": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz", + "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/nth-check": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz", + "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0" + }, + "funding": { + "url": "https://github.com/fb55/nth-check?sponsor=1" + } + }, + "node_modules/object-hash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz", + "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==", + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "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==", + "dev": true, + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/onetime": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz", + "integrity": "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "mimic-fn": "^4.0.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ora": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/ora/-/ora-6.3.1.tgz", + "integrity": "sha512-ERAyNnZOfqM+Ao3RAvIXkYh5joP220yf59gVe2X/cI6SiCxIdi4c9HZKZD8R6q/RDXEje1THBju6iExiSsgJaQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^5.0.0", + "cli-cursor": "^4.0.0", + "cli-spinners": "^2.6.1", + "is-interactive": "^2.0.0", + "is-unicode-supported": "^1.1.0", + "log-symbols": "^5.1.0", + "stdin-discarder": "^0.1.0", + "strip-ansi": "^7.0.1", + "wcwidth": "^1.0.1" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-finally": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", + "integrity": "sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/p-queue": { + "version": "6.6.2", + "resolved": "https://registry.npmjs.org/p-queue/-/p-queue-6.6.2.tgz", + "integrity": "sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "eventemitter3": "^4.0.4", + "p-timeout": "^3.2.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-timeout": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-3.2.0.tgz", + "integrity": "sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-finally": "^1.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/packrup": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/packrup/-/packrup-0.1.2.tgz", + "integrity": "sha512-ZcKU7zrr5GlonoS9cxxrb5HVswGnyj6jQvwFBa6p5VFw7G71VAHcUKL5wyZSU/ECtPM/9gacWxy2KFQKt1gMNA==", + "dev": true, + "license": "MIT", + "peer": true, + "funding": { + "url": "https://github.com/sponsors/harlan-zw" + } + }, + "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-json": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", + "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.0.0", + "error-ex": "^1.3.1", + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true, + "license": "MIT" + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/pg-connection-string": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.6.2.tgz", + "integrity": "sha512-ch6OwaeaPYcova4kKZ15sbJ2hKb/VP48ZD2gE7i1J+L4MspCtBMAx8nMgz7bksc7IojCIIWuEhHibSMFH8m8oA==", + "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": "4.0.7", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz", + "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pinia": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/pinia/-/pinia-2.3.1.tgz", + "integrity": "sha512-khUlZSwt9xXCaTbbxFYBKDc/bWAGWJjOgvxETwkTN7KRm66EeT1ZdZj6i2ceh9sP2Pzqsbc704r2yngBrxBVug==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@vue/devtools-api": "^6.6.3", + "vue-demi": "^0.14.10" + }, + "funding": { + "url": "https://github.com/sponsors/posva" + }, + "peerDependencies": { + "typescript": ">=4.4.4", + "vue": "^2.7.0 || ^3.5.11" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/postcss": { + "version": "8.5.31", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.31.tgz", + "integrity": "sha512-YUbWYCgErwnMAVkjUnYa+KlMBzGpHwiIt/DE7f0G33AuX2LH9UcTk6KgWxd3zRU+pN3u/C+Xl3EnMLM4Hea7Sg==", + "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.20", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.2" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/postcss-calc": { + "version": "8.2.4", + "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-8.2.4.tgz", + "integrity": "sha512-SmWMSJmB8MRnnULldx0lQIyhSNvuDl9HfrZkaqqE/WHAhToYsAvDq+yAsA/kIyINDszOp3Rh0GFoNuH5Ypsm3Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.9", + "postcss-value-parser": "^4.2.0" + }, + "peerDependencies": { + "postcss": "^8.2.2" + } + }, + "node_modules/postcss-colormin": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-5.3.1.tgz", + "integrity": "sha512-UsWQG0AqTFQmpBegeLLc1+c3jIqBNB0zlDGRWR+dQ3pRKJL1oeMzyqmH3o2PIfn9MBdNrVPWhDbT769LxCTLJQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "caniuse-api": "^3.0.0", + "colord": "^2.9.1", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-convert-values": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-5.1.3.tgz", + "integrity": "sha512-82pC1xkJZtcJEfiLw6UXnXVXScgtBrjlO5CBmuDQc+dlb88ZYheFsjTn40+zBVi3DkfF7iezO0nJUPLcJK3pvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-discard-comments": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-5.1.2.tgz", + "integrity": "sha512-+L8208OVbHVF2UQf1iDmRcbdjJkuBF6IS29yBDSiWUIzpYaAhtNl6JYnYm12FnkeCwQqF5LeklOu6rAqgfBZqQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-discard-duplicates": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-5.1.0.tgz", + "integrity": "sha512-zmX3IoSI2aoenxHV6C7plngHWWhUOV3sP1T8y2ifzxzbtnuhk1EdPwm0S1bIUNaJ2eNbWeGLEwzw8huPD67aQw==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-discard-empty": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-5.1.1.tgz", + "integrity": "sha512-zPz4WljiSuLWsI0ir4Mcnr4qQQ5e1Ukc3i7UfE2XcrwKK2LIPIqE5jxMRxO6GbI3cv//ztXDsXwEWT3BHOGh3A==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-discard-overridden": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-5.1.0.tgz", + "integrity": "sha512-21nOL7RqWR1kasIVdKs8HNqQJhFxLsyRfAnUDm4Fe4t4mCWL9OJiHvlHPjcd8zc5Myu89b/7wZDnOSjFgeWRtw==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-merge-longhand": { + "version": "5.1.7", + "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-5.1.7.tgz", + "integrity": "sha512-YCI9gZB+PLNskrK0BB3/2OzPnGhPkBEwmwhfYk1ilBHYVAZB7/tkTHFBAnCrvBBOmeYyMYw3DMjT55SyxMBzjQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0", + "stylehacks": "^5.1.1" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-merge-rules": { + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-5.1.4.tgz", + "integrity": "sha512-0R2IuYpgU93y9lhVbO/OylTtKMVcHb67zjWIfCiKR9rWL3GUk1677LAqD/BcHizukdZEjT8Ru3oHRoAYoJy44g==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "caniuse-api": "^3.0.0", + "cssnano-utils": "^3.1.0", + "postcss-selector-parser": "^6.0.5" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-font-values": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-5.1.0.tgz", + "integrity": "sha512-el3mYTgx13ZAPPirSVsHqFzl+BBBDrXvbySvPGFnQcTI4iNslrPaFq4muTkLZmKlGk4gyFAYUBMH30+HurREyA==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-gradients": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-5.1.1.tgz", + "integrity": "sha512-VGvXMTpCEo4qHTNSa9A0a3D+dxGFZCYwR6Jokk+/3oB6flu2/PnPXAh2x7x52EkY5xlIHLm+Le8tJxe/7TNhzw==", + "dev": true, + "license": "MIT", + "dependencies": { + "colord": "^2.9.1", + "cssnano-utils": "^3.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-params": { + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-5.1.4.tgz", + "integrity": "sha512-+mePA3MgdmVmv6g+30rn57USjOGSAyuxUmkfiWpzalZ8aiBkdPYjXWtHuwJGm1v5Ojy0Z0LaSYhHaLJQB0P8Jw==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "cssnano-utils": "^3.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-selectors": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-5.2.1.tgz", + "integrity": "sha512-nPJu7OjZJTsVUmPdm2TcaiohIwxP+v8ha9NehQ2ye9szv4orirRU3SDdtUmKH+10nzn0bAyOXZ0UEr7OpvLehg==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.5" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-modules-extract-imports": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.1.0.tgz", + "integrity": "sha512-k3kNe0aNFQDAZGbin48pL2VNidTF0w4/eASDsxlyspobzU3wZQLOGj7L9gfRe0Jo9/4uud09DsjFNH7winGv8Q==", + "dev": true, + "license": "ISC", + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-local-by-default": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.2.0.tgz", + "integrity": "sha512-5kcJm/zk+GJDSfw+V/42fJ5fhjL5YbFDl8nVdXkJPLLW+Vf9mTD5Xe0wqIaDnLuL2U6cDNpTr+UQ+v2HWIBhzw==", + "dev": true, + "license": "MIT", + "dependencies": { + "icss-utils": "^5.0.0", + "postcss-selector-parser": "^7.0.0", + "postcss-value-parser": "^4.1.0" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-local-by-default/node_modules/postcss-selector-parser": { + "version": "7.1.7", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.7.tgz", + "integrity": "sha512-wWBro/7hJ40ye6TPiXkUQoXKCw23xSsjriUvqd7Uls9Sso3oLiON1flc18cCdnjgCRXw4fBVqUJJeOdDTh3P3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-modules-scope": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-3.2.1.tgz", + "integrity": "sha512-m9jZstCVaqGjTAuny8MdgE88scJnCiQSlSrOWcTQgM2t32UBe+MUmFSO5t7VMSfAf/FJKImAxBav8ooCHJXCJA==", + "dev": true, + "license": "ISC", + "dependencies": { + "postcss-selector-parser": "^7.0.0" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-scope/node_modules/postcss-selector-parser": { + "version": "7.1.7", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.7.tgz", + "integrity": "sha512-wWBro/7hJ40ye6TPiXkUQoXKCw23xSsjriUvqd7Uls9Sso3oLiON1flc18cCdnjgCRXw4fBVqUJJeOdDTh3P3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-modules-values": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz", + "integrity": "sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "icss-utils": "^5.0.0" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-normalize-charset": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-5.1.0.tgz", + "integrity": "sha512-mSgUJ+pd/ldRGVx26p2wz9dNZ7ji6Pn8VWBajMXFf8jk7vUoSrZ2lt/wZR7DtlZYKesmZI680qjr2CeFF2fbUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-display-values": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-display-values/-/postcss-normalize-display-values-5.1.0.tgz", + "integrity": "sha512-WP4KIM4o2dazQXWmFaqMmcvsKmhdINFblgSeRgn8BJ6vxaMyaJkwAzpPpuvSIoG/rmX3M+IrRZEz2H0glrQNEA==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-positions": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-positions/-/postcss-normalize-positions-5.1.1.tgz", + "integrity": "sha512-6UpCb0G4eofTCQLFVuI3EVNZzBNPiIKcA1AKVka+31fTVySphr3VUgAIULBhxZkKgwLImhzMR2Bw1ORK+37INg==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-repeat-style": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-5.1.1.tgz", + "integrity": "sha512-mFpLspGWkQtBcWIRFLmewo8aC3ImN2i/J3v8YCFUwDnPu3Xz4rLohDO26lGjwNsQxB3YF0KKRwspGzE2JEuS0g==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-string": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-string/-/postcss-normalize-string-5.1.0.tgz", + "integrity": "sha512-oYiIJOf4T9T1N4i+abeIc7Vgm/xPCGih4bZz5Nm0/ARVJ7K6xrDlLwvwqOydvyL3RHNf8qZk6vo3aatiw/go3w==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-timing-functions": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-5.1.0.tgz", + "integrity": "sha512-DOEkzJ4SAXv5xkHl0Wa9cZLF3WCBhF3o1SKVxKQAa+0pYKlueTpCgvkFAHfk+Y64ezX9+nITGrDZeVGgITJXjg==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-unicode": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-5.1.1.tgz", + "integrity": "sha512-qnCL5jzkNUmKVhZoENp1mJiGNPcsJCs1aaRmURmeJGES23Z/ajaln+EPTD+rBeNkSryI+2WTdW+lwcVdOikrpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-url": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-5.1.0.tgz", + "integrity": "sha512-5upGeDO+PVthOxSmds43ZeMeZfKH+/DKgGRD7TElkkyS46JXAUhMzIKiCa7BabPeIy3AQcTkXwVVN7DbqsiCew==", + "dev": true, + "license": "MIT", + "dependencies": { + "normalize-url": "^6.0.1", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-whitespace": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-whitespace/-/postcss-normalize-whitespace-5.1.1.tgz", + "integrity": "sha512-83ZJ4t3NUDETIHTa3uEg6asWjSBYL5EdkVB0sDncx9ERzOKBVJIUeDO9RyA9Zwtig8El1d79HBp0JEi8wvGQnA==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-ordered-values": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-5.1.3.tgz", + "integrity": "sha512-9UO79VUhPwEkzbb3RNpqqghc6lcYej1aveQteWY+4POIwlqkYE21HKWaLDF6lWNuqCobEAyTovVhtI32Rbv2RQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssnano-utils": "^3.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-reduce-initial": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-5.1.2.tgz", + "integrity": "sha512-dE/y2XRaqAi6OvjzD22pjTUQ8eOfc6m/natGHgKFBK9DxFmIm69YmaRVQrGgFlEfc1HePIurY0TmDeROK05rIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "caniuse-api": "^3.0.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-reduce-transforms": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-5.1.0.tgz", + "integrity": "sha512-2fbdbmgir5AvpW9RLtdONx1QoYG2/EtqpNQbFASDlixBbAYuTcJ0dECwlqNqH7VbaUnEnh8SrxOe2sRIn24XyQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-selector-parser": { + "version": "6.1.5", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.5.tgz", + "integrity": "sha512-TEHFzb5KRDKaOgJ4TYE+0jyJtFbjLvkdVOu0fZ2b6MTWzoqZd4Le+61aEppWkvTlYePgOX4ATL1wsAIPMLTw6Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-svgo": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-5.1.0.tgz", + "integrity": "sha512-D75KsH1zm5ZrHyxPakAxJWtkyXew5qwS70v56exwvw542d9CRtTo78K0WeFxZB4G7JXKKMbEZtZayTGdIky/eA==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0", + "svgo": "^2.7.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-unique-selectors": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-5.1.1.tgz", + "integrity": "sha512-5JiODlELrz8L2HwxfPnhOWZYWDxVHWL83ufOv84NrcgipI7TaeRsatAhK4Tr2/ZiYldpK/wBvw5BD3qfaK96GA==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.5" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-value-parser": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz", + "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/postcss/node_modules/nanoid": { + "version": "3.3.20", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.20.tgz", + "integrity": "sha512-uKdg2G3GNCKQn9byYOpxbGqrT2fGO5KRt5J/8b3pok8rT6qxGWF6hxMyJiEYtAf+FVyYuD9hRaDqX5uPFYJ4ZQ==", + "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/proxy-from-env": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", + "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==", + "dev": true, + "license": "MIT" + }, + "node_modules/query-string": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/query-string/-/query-string-7.1.3.tgz", + "integrity": "sha512-hh2WYhq4fi8+b+/2Kg9CEge4fDPvHS534aOOvOZeQ3+Vf2mCFsaFBYj0i+iXcAq6I9Vzp5fjMFBlONvayDC1qg==", + "dev": true, + "license": "MIT", + "dependencies": { + "decode-uri-component": "^0.2.2", + "filter-obj": "^1.1.0", + "split-on-first": "^1.0.0", + "strict-uri-encode": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/rechoir": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.8.0.tgz", + "integrity": "sha512-/vxpCXddiX8NGfGO/mTafwjq4aFa/71pvamip0++IQk3zG8cbCj0fifNPrjjF1XMXUne91jL9OoxmdykoEtifQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "resolve": "^1.20.0" + }, + "engines": { + "node": ">= 10.13.0" + } + }, + "node_modules/resolve": { + "version": "1.22.13", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.13.tgz", + "integrity": "sha512-Dj/cW9zBV2aRj6XzCxuGIs3ESZKv02jixne3q6jFZYZ3/Tg09gHHviSMDL4kObh9pqSahdRHEnDoaP2gn8YLhA==", + "dev": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "is-core-module": "^2.17.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/restore-cursor": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-4.0.0.tgz", + "integrity": "sha512-I9fPXU9geO9bHOt9pHHOhOkYerIMsmVaWB0rA2AI9ERh/+x/i7MV5HKBNrg+ljO5eoPVgCcnFuRjJ9uH6I/3eg==", + "dev": true, + "license": "MIT", + "dependencies": { + "onetime": "^5.1.0", + "signal-exit": "^3.0.2" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/restore-cursor/node_modules/mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/restore-cursor/node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/rollup": { + "version": "2.80.0", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.80.0.tgz", + "integrity": "sha512-cIFJOD1DESzpjOBl763Kp1AH7UE/0fcdHe6rZXUdQ9c50uvgigvW97u3IcSeBwOkgqL/PXPBktBCh0KEu5L8XQ==", + "dev": true, + "license": "MIT", + "peer": true, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=10.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/rollup-plugin-esbuild": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/rollup-plugin-esbuild/-/rollup-plugin-esbuild-5.0.0.tgz", + "integrity": "sha512-1cRIOHAPh8WQgdQQyyvFdeOdxuiyk+zB5zJ5+YOwrZP4cJ0MT3Fs48pQxrZeyZHcn+klFherytILVfE4aYrneg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "debug": "^4.3.4", + "es-module-lexer": "^1.0.5", + "joycon": "^3.1.1", + "jsonc-parser": "^3.2.0" + }, + "engines": { + "node": ">=14.18.0", + "npm": ">=8.0.0" + }, + "peerDependencies": { + "esbuild": ">=0.10.1", + "rollup": "^1.20.0 || ^2.0.0 || ^3.0.0" + } + }, + "node_modules/rollup-plugin-styles": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/rollup-plugin-styles/-/rollup-plugin-styles-4.0.0.tgz", + "integrity": "sha512-A2K2sao84OsTmDxXG83JTCdXWrmgvQkkI38XDat46rdtpGMRm9tSYqeCdlwwGDJF4kKIafhV1mUidqu8MxUGig==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^4.1.2", + "@types/cssnano": "^5.0.0", + "cosmiconfig": "^7.0.1", + "cssnano": "^5.0.15", + "fs-extra": "^10.0.0", + "icss-utils": "^5.1.0", + "mime-types": "^2.1.34", + "p-queue": "^6.6.2", + "postcss": "^8.4.5", + "postcss-modules-extract-imports": "^3.0.0", + "postcss-modules-local-by-default": "^4.0.0", + "postcss-modules-scope": "^3.0.0", + "postcss-modules-values": "^4.0.0", + "postcss-value-parser": "^4.2.0", + "query-string": "^7.1.0", + "resolve": "^1.21.0", + "source-map-js": "^1.0.1", + "tslib": "^2.3.1" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "peerDependencies": { + "rollup": "^2.63.0" + } + }, + "node_modules/rollup-plugin-styles/node_modules/@rollup/pluginutils": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-4.2.1.tgz", + "integrity": "sha512-iKnFXr7NkdZAIHiIWE+BX5ULi/ucVFYWD6TbAV+rZctiRTY2PL6tsIKhoIOaoskiWAkgu+VsbXgUVDNLHf+InQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "estree-walker": "^2.0.1", + "picomatch": "^2.2.2" + }, + "engines": { + "node": ">= 8.0.0" + } + }, + "node_modules/rollup-plugin-styles/node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/rollup-plugin-styles/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/run-async": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/run-async/-/run-async-3.0.0.tgz", + "integrity": "sha512-540WwVDOMxA6dN6We19EcT9sc3hkXPw5mzRNGM3FkdN/vtE9NFvj5lFAPNwUDmJjXidm3v7TC1cTE7t17Ulm1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/rxjs": { + "version": "7.8.2", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz", + "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==", + "dev": true, + "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==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/sax": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.1.tgz", + "integrity": "sha512-42tBVwLWnaQvW5zc4HbZrTuWccECCZfBi92FDuwtqxasH+JbPB3/FOKb1m222K42R4WxuxzzMsTswfzgtSu64Q==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=11.0.0" + } + }, + "node_modules/semver": { + "version": "7.6.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz", + "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/serialize-javascript": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz", + "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "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==", + "dev": true, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/smob": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/smob/-/smob-1.6.2.tgz", + "integrity": "sha512-RQsvleCbF8cVHEv+xuDGaA4pOizFqJ0GgjtMSRo6oP8pnN7WsigHgVGey6aILRBKv4W2YOMHLqbKdnB6hpB9fw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=20.0.0" + } + }, + "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/source-map-js": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.2.tgz", + "integrity": "sha512-KGj/8Y43x35aZVDtt+J4mK1hoLGHULMYfSkODJNQjNDC3oW1PqPoxMwo0pLUsWM/UEGzON/NxeHywEfNXNP3Vw==", + "dev": true, + "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/split-on-first": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/split-on-first/-/split-on-first-1.1.0.tgz", + "integrity": "sha512-43ZssAJaMusuKWL8sKUBQXHWOpq8d6CfN/u1p4gUzfJkM05C8rxTmYrkIPTXapZpORA6LkkzcUulJ8FqA7Uudw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/stable": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/stable/-/stable-0.1.8.tgz", + "integrity": "sha512-ji9qxRnOVfcuLDySj9qzhGSEFVobyt1kIOSkj1qZzYLzq7Tos/oUUWvotUPQLlrsidqsK6tBH89Bc9kL5zHA6w==", + "deprecated": "Modern JS already guarantees Array#sort() is a stable sort, so this library is deprecated. See the compatibility table on MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#browser_compatibility", + "dev": true, + "license": "MIT" + }, + "node_modules/stdin-discarder": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/stdin-discarder/-/stdin-discarder-0.1.0.tgz", + "integrity": "sha512-xhV7w8S+bUwlPTb4bAOUQhv8/cSS5offJuX8GQGq32ONF0ZtDWKfkdomM3HMRA+LhX6um/FZ0COqlwsjD53LeQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "bl": "^5.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/strict-uri-encode": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strict-uri-encode/-/strict-uri-encode-2.0.0.tgz", + "integrity": "sha512-QwiXZgpRcKkhTj2Scnn++4PKtWsH0kpzZ62L2R6c/LUVYv7hVnZqcg2+sMuT6R7Jusu1vviK/MFsu6kNJfWlEQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "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/string-width/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/string-width/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/strip-ansi": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz", + "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.2.2" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/strip-final-newline": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz", + "integrity": "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/stylehacks": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-5.1.1.tgz", + "integrity": "sha512-sBpcd5Hx7G6seo7b1LkpttvTz7ikD0LlH5RmdcBNb6fFR0Fl7LQwHDFr300q4cwUqi+IYrFGmsIHieMBfnN/Bw==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "postcss-selector-parser": "^6.0.4" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/svgo": { + "version": "2.8.4", + "resolved": "https://registry.npmjs.org/svgo/-/svgo-2.8.4.tgz", + "integrity": "sha512-2GJ4h3rl13qYTdwllaK6QlL8tG+UrM8626V2Ylcd/yBUv2Y/EwLsYisVV6UDCRmlk+C74G8nMpxJCk0RWPdDCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "commander": "^7.2.0", + "css-select": "^4.1.3", + "css-tree": "^1.1.3", + "csso": "^4.2.0", + "picocolors": "^1.0.0", + "sax": "^1.5.0", + "stable": "^0.1.8" + }, + "bin": { + "svgo": "bin/svgo" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/svgo/node_modules/commander": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz", + "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10" + } + }, + "node_modules/tarn": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/tarn/-/tarn-3.1.2.tgz", + "integrity": "sha512-3RTvqKZcK/17jnJ8rMKFXbyNogywTs1z0gVPPwFsJGX46rkmUHOdIaSQ/aVO1rS7nH+soiXiWk7rvUXxndm8Dg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/terser": { + "version": "5.51.2", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.51.2.tgz", + "integrity": "sha512-bWnjSNscmuI+GJze6ZupnHP8G/cTcsJF+bXCeQknk2SHQsgbNJnLrqiH9jZ2W4STPVXH2mDKKRX3iwPhc9Cn/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/tildify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/tildify/-/tildify-2.0.0.tgz", + "integrity": "sha512-Cc+OraorugtXNfs50hU9KS369rFXCfgGLpfCfvlc+Ud5u6VWmUQsOAa9HbTvheQdYnrdJqqv1e5oIqXppMYnSw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "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==", + "dev": true, + "license": "0BSD" + }, + "node_modules/tsx": { + "version": "4.23.15", + "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.23.15.tgz", + "integrity": "sha512-Yiex1Ovn8z2xPpOWckIiysV1SSyRMY9BkLF++q0yKiDxCqRhosKfMg3janKkiLBwZ5c/YryloKwGZcrEmtwxKw==", + "dev": true, + "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/android-arm": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.2.tgz", + "integrity": "sha512-kXXoiPVVGQcnIYGOeaovwOURpniDBpSq4A03qkQ+BMQqtGG6HYap3xne9C1O1yo4TR3qxlCX5IqqmX6fFo2Lqg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/android-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.2.tgz", + "integrity": "sha512-5YfKeeI8qWfBZIX+u2xZC3Zlb3Os/gLS2sbEKM+I4ZOcsWmHS2WLysCcQZDAFRslDUU5Oiq44gf6PYN1vGwG5A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/android-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.2.tgz", + "integrity": "sha512-O387ite7SzUyCcy3JQX4P4bLtEA7bLLkx+esve5JHnyYfNTxcVpXZo9jhdB0lTKN44gztELTdU7nS8Nr16Fs1Q==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/darwin-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.2.tgz", + "integrity": "sha512-n4KqkOQrraxHJcgjM1RvwbigfQKIKJVpM7xp+KsxiyUSrRdIXnt73VhrPAx0fV44hgfmIVKjxMN9J1t5jySVkw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/darwin-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.2.tgz", + "integrity": "sha512-uq6suIWYP37qzGddBKPw5QEQPi6HiLGsO7UmkpfyaYNQ3D+rN6w6WfwH+nuqcGXWvawGwxOEroO4YGnFh95azw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/freebsd-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.2.tgz", + "integrity": "sha512-n+I0BTSRIoy+d6RPKnEVwql5UwBJolytvY4mAOIEJorKlqgPII8ix6slVVrfZ5Tnj7glIZvloylbB/EJPMWEXw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/freebsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.2.tgz", + "integrity": "sha512-78XJTJkvPs0kz2w61301PJjXl4g7q3JqiYMZ/M/yVI73EHBrCRTgkhu9oqG7vPqq+a/yadEW8aD+agKlk5xrmg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-arm": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.2.tgz", + "integrity": "sha512-XlDnu2q5yoqems+xay6wSAcg9DDD7K9RLKZEBOMZm3ckNpJBvOX20tSfby8KfrrhINDyv9V2YVZKY/SpoGJI8w==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.2.tgz", + "integrity": "sha512-pW4AC0P3it8c7do9MVM4p51FzHzdM/TZrerurgRcHJ2WTa1VQ1CIq18xncfpBJw4ojkiZZrKW2yIBWBP92j6Ug==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-ia32": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.2.tgz", + "integrity": "sha512-CYbnj78HsIeA+DhgUKgFCfvNsTHFhMMrinUrMZpDXJXKN8T3XViTZ/+wtHeVxEWY8ewSzTFN+nRmSwO2tZaLUQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-loong64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.2.tgz", + "integrity": "sha512-buwkd8nsph4R+ajRvw0qM5Hja/TXQow3ptzWO2EbG/cqcIkHloRrdlBtQlshyYGTNFvfkfJ5tpPLVkY4DtsPfQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-mips64el": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.2.tgz", + "integrity": "sha512-ZVykbDyk7519VwiNb9Lcj9m8XM6v5V9uKPvrEMkkEedVewf+0itkhahp4HDpgERXhwLRpWFypsGbG/J8s0QjJA==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-ppc64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.2.tgz", + "integrity": "sha512-CAXl+Dtd9UUuJd8pKKdwh6MLm3MUMiqMPmhZ3tTSXPqfyQ3vDl6R5hZdZ/kYojK4ofXtdfSv1tFq8XzWx3heNQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-riscv64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.2.tgz", + "integrity": "sha512-GeXCej4IQtU1B+QlDV8W/RRvbzI3O/Stss+/bCXv4lZls5WGRtu2a+3JkA3i4qIUlMXpcHebWpF8AkJhATowuA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-s390x": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.2.tgz", + "integrity": "sha512-3H1weTYZPxt/WOhByszQZybS9w5lKzUn1FDMsgEChbHWQwHYQQRfBxgCcZvPhjHfKyJjIievvMmEUawJrdY9Dg==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/linux-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.2.tgz", + "integrity": "sha512-4xTZr1FUmSoQW4XIWmit3tzQrUTZM+N3P0XV8xROKYF50XfI7xeO90+1bZvNwxIufQ9hDQVRJH5YhgPVF8A/HQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/netbsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.2.tgz", + "integrity": "sha512-lqnzCV+mM0gIADaKihiCg6ifgfU2L3h5E33rNQBN1Y4MaVGnzryzmvvf7UHxprpQdE8hpqLolJ9Rl+SkIRDpyw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/openbsd-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.2.tgz", + "integrity": "sha512-QtiuPytchRyC4rwUKhexJdQKvDuZ6hWloi3igqPQNUJCS1/v9EiO3UTOXR6A3FoMo4fnAKbWJdqaIwhOzh8qEw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/sunos-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.2.tgz", + "integrity": "sha512-GPMSkTOtMnv2U2F8gxe4Io6qmVs+YKyp832Etqqxr0hFngmXQ3rzwytelm3GIn7T4VviRUlf3sOgBOiTdvaf7g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/win32-arm64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.2.tgz", + "integrity": "sha512-PIhhEkE9uPBleRBrQEJpUn7MBnibZzbGzYWPmY3x+YoVg/95zbjB4CxPPOQ8l5tYYM4mMaCthF8/1DIfBQQyWQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/win32-ia32": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.2.tgz", + "integrity": "sha512-YmJbfTlvU7Sdn9BB+4PRES4oB6pxgS37MAONj+hBr/cpXS1aBPKXxNnDbu+QCWPj0o9dgyxeq79g6c5P8KeuYA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/@esbuild/win32-x64": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.2.tgz", + "integrity": "sha512-5ebpxr3nWMzrL/rnUI755Jkuee0bHL/Gq0WTF9lvcpv73wAp5eu8MfBUgWK9bhWvZjj7yX8etf/8tI8Ney695g==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/tsx/node_modules/esbuild": { + "version": "0.28.2", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.2.tgz", + "integrity": "sha512-HKVLS8dvII+xoKW9kmqxbRKrnWEXfJJr/FZhhJmiqIB0e053QNYFqOBouTMO/k5sID4MvCiUCvv8b9M4h32wIA==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.28.2", + "@esbuild/android-arm": "0.28.2", + "@esbuild/android-arm64": "0.28.2", + "@esbuild/android-x64": "0.28.2", + "@esbuild/darwin-arm64": "0.28.2", + "@esbuild/darwin-x64": "0.28.2", + "@esbuild/freebsd-arm64": "0.28.2", + "@esbuild/freebsd-x64": "0.28.2", + "@esbuild/linux-arm": "0.28.2", + "@esbuild/linux-arm64": "0.28.2", + "@esbuild/linux-ia32": "0.28.2", + "@esbuild/linux-loong64": "0.28.2", + "@esbuild/linux-mips64el": "0.28.2", + "@esbuild/linux-ppc64": "0.28.2", + "@esbuild/linux-riscv64": "0.28.2", + "@esbuild/linux-s390x": "0.28.2", + "@esbuild/linux-x64": "0.28.2", + "@esbuild/netbsd-arm64": "0.28.2", + "@esbuild/netbsd-x64": "0.28.2", + "@esbuild/openbsd-arm64": "0.28.2", + "@esbuild/openbsd-x64": "0.28.2", + "@esbuild/openharmony-arm64": "0.28.2", + "@esbuild/sunos-x64": "0.28.2", + "@esbuild/win32-arm64": "0.28.2", + "@esbuild/win32-ia32": "0.28.2", + "@esbuild/win32-x64": "0.28.2" + } + }, + "node_modules/type-fest": { + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", + "dev": true, + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "dev": true, + "license": "MIT" + }, + "node_modules/unhead": { + "version": "1.11.20", + "resolved": "https://registry.npmjs.org/unhead/-/unhead-1.11.20.tgz", + "integrity": "sha512-3AsNQC0pjwlLqEYHLjtichGWankK8yqmocReITecmpB1H0aOabeESueyy+8X1gyJx4ftZVwo9hqQ4O3fPWffCA==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@unhead/dom": "1.11.20", + "@unhead/schema": "1.11.20", + "@unhead/shared": "1.11.20", + "hookable": "^5.5.3" + }, + "funding": { + "url": "https://github.com/sponsors/harlan-zw" + } + }, + "node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.4.tgz", + "integrity": "sha512-t8wonIOdQyOjtPd2VktlBu6QjTVTks6v8bSi7kd0r2Vll8TK1JYDZtRRdbmCHOAMphkZgrzK+L+vXK4pyZ8t4A==", + "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/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "dev": true, + "license": "MIT" + }, + "node_modules/vite": { + "version": "4.5.5", + "resolved": "https://registry.npmjs.org/vite/-/vite-4.5.5.tgz", + "integrity": "sha512-ifW3Lb2sMdX+WU91s3R0FyQlAyLxOzCSCP37ujw0+r5POeHPwe6udWVIElKQq8gk3t7b8rkmvqC6IHBpCff4GQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.18.10", + "postcss": "^8.4.27", + "rollup": "^3.27.1" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + }, + "peerDependencies": { + "@types/node": ">= 14", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/vite/node_modules/@esbuild/android-arm": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.18.20.tgz", + "integrity": "sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/android-arm64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.18.20.tgz", + "integrity": "sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/android-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.18.20.tgz", + "integrity": "sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/darwin-arm64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.18.20.tgz", + "integrity": "sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/darwin-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.18.20.tgz", + "integrity": "sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/freebsd-arm64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.20.tgz", + "integrity": "sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/freebsd-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.18.20.tgz", + "integrity": "sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-arm": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.18.20.tgz", + "integrity": "sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-arm64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.18.20.tgz", + "integrity": "sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-ia32": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.18.20.tgz", + "integrity": "sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-loong64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.18.20.tgz", + "integrity": "sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-mips64el": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.18.20.tgz", + "integrity": "sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-ppc64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.18.20.tgz", + "integrity": "sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-riscv64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.18.20.tgz", + "integrity": "sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-s390x": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.18.20.tgz", + "integrity": "sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/linux-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.18.20.tgz", + "integrity": "sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/netbsd-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.18.20.tgz", + "integrity": "sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/openbsd-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.18.20.tgz", + "integrity": "sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/sunos-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.18.20.tgz", + "integrity": "sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/win32-arm64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.18.20.tgz", + "integrity": "sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/win32-ia32": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.18.20.tgz", + "integrity": "sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/@esbuild/win32-x64": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.18.20.tgz", + "integrity": "sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/vite/node_modules/esbuild": { + "version": "0.18.20", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.18.20.tgz", + "integrity": "sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/android-arm": "0.18.20", + "@esbuild/android-arm64": "0.18.20", + "@esbuild/android-x64": "0.18.20", + "@esbuild/darwin-arm64": "0.18.20", + "@esbuild/darwin-x64": "0.18.20", + "@esbuild/freebsd-arm64": "0.18.20", + "@esbuild/freebsd-x64": "0.18.20", + "@esbuild/linux-arm": "0.18.20", + "@esbuild/linux-arm64": "0.18.20", + "@esbuild/linux-ia32": "0.18.20", + "@esbuild/linux-loong64": "0.18.20", + "@esbuild/linux-mips64el": "0.18.20", + "@esbuild/linux-ppc64": "0.18.20", + "@esbuild/linux-riscv64": "0.18.20", + "@esbuild/linux-s390x": "0.18.20", + "@esbuild/linux-x64": "0.18.20", + "@esbuild/netbsd-x64": "0.18.20", + "@esbuild/openbsd-x64": "0.18.20", + "@esbuild/sunos-x64": "0.18.20", + "@esbuild/win32-arm64": "0.18.20", + "@esbuild/win32-ia32": "0.18.20", + "@esbuild/win32-x64": "0.18.20" + } + }, + "node_modules/vite/node_modules/rollup": { + "version": "3.30.0", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-3.30.0.tgz", + "integrity": "sha512-kQvGasUgN+AlWGliFn2POSajRQEsULVYFGTvOZmK06d7vCD+YhZztt70kGk3qaeAXeWYL5eO7zx+rAubBc55eA==", + "dev": true, + "license": "MIT", + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=14.18.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/vue": { + "version": "3.5.44", + "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.44.tgz", + "integrity": "sha512-dvvmaOCG7lAMkJTPqPwWeGMsPS6DIsFsfZDUgBp9V6mHf9b3+/wyVwYR4Es+WV6uJC0FKRxp81Obcq0ZwUcGFQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@vue/compiler-dom": "3.5.44", + "@vue/compiler-sfc": "3.5.44", + "@vue/runtime-dom": "3.5.44", + "@vue/server-renderer": "3.5.44", + "@vue/shared": "3.5.44" + }, + "peerDependencies": { + "typescript": "*" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/vue-demi": { + "version": "0.14.10", + "resolved": "https://registry.npmjs.org/vue-demi/-/vue-demi-0.14.10.tgz", + "integrity": "sha512-nMZBOwuzabUO0nLgIcc6rycZEebF6eeUfaiQx9+WSk8e29IbLvPU9feI6tqW4kTo3hvoYAJkMh8n8D0fuISphg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "peer": true, + "bin": { + "vue-demi-fix": "bin/vue-demi-fix.js", + "vue-demi-switch": "bin/vue-demi-switch.js" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + }, + "peerDependencies": { + "@vue/composition-api": "^1.0.0-rc.1", + "vue": "^3.0.0-0 || ^2.6.0" + }, + "peerDependenciesMeta": { + "@vue/composition-api": { + "optional": true + } + } + }, + "node_modules/wcwidth": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz", + "integrity": "sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==", + "dev": true, + "license": "MIT", + "dependencies": { + "defaults": "^1.0.3" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/wrap-ansi/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/wrap-ansi/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/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/yaml": { + "version": "1.10.3", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.3.tgz", + "integrity": "sha512-vIYeF1u3CjlhAFekPPAk2h/Kv4T3mAkMox5OymRiJQB0spDP10LHvt+K7G9Ny6NuuMAb25/6n1qyUjAcGNf/AA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">= 6" + } + }, + "node_modules/yoctocolors-cjs": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/yoctocolors-cjs/-/yoctocolors-cjs-2.1.3.tgz", + "integrity": "sha512-U/PBtDf35ff0D8X8D0jfdzHYEPFxAI7jJlxZXwCSez5M3190m+QobIfh+sWDWSHMCWWJN2AWamkegn6vr6YBTw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zhead": { + "version": "2.2.4", + "resolved": "https://registry.npmjs.org/zhead/-/zhead-2.2.4.tgz", + "integrity": "sha512-8F0OI5dpWIA5IGG5NHUg9staDwz/ZPxZtvGVf01j7vHqSyZ0raHY+78atOVxRqb73AotX22uV1pXt3gYSstGag==", + "dev": true, + "license": "MIT", + "peer": true, + "funding": { + "url": "https://github.com/sponsors/harlan-zw" + } + }, + "node_modules/zod": { + "version": "3.24.1", + "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.1.tgz", + "integrity": "sha512-muH7gBL9sI1nciMZV67X5fTKKBLtwpZ5VBp1vsOQzj1MhrBZ4wlVCm3gedKZWLp0Oyel8sIGfeiz54Su+OVT+A==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..2eaff78 --- /dev/null +++ b/package.json @@ -0,0 +1,63 @@ +{ + "name": "directus-extension-generate-image-previews", + "description": "Pre-generate Directus image transforms: on upload, on demand, and via a scheduled resumable backfill, with an admin UI (progress, disk usage, maintenance window)", + "author": { + "name": "Rawman Grey", + "email": "rawman@locus.im", + "url": "https://locus.im" + }, + "icon": "extension", + "version": "0.1.0", + "keywords": [ + "directus", + "directus-extension", + "directus-extension-bundle" + ], + "type": "module", + "files": [ + "dist" + ], + "directus:extension": { + "type": "bundle", + "path": { + "app": "dist/app.js", + "api": "dist/api.js" + }, + "entries": [ + { + "type": "module", + "name": "image-previews", + "source": "src/module/index.ts" + }, + { + "type": "hook", + "name": "image-previews-hook", + "source": "src/hook/index.ts" + }, + { + "type": "endpoint", + "name": "image-previews-endpoint", + "source": "src/endpoint/index.ts" + } + ], + "host": "^10.10.0 || ^11.0.0" + }, + "scripts": { + "build": "directus-extension build", + "dev": "directus-extension build -w --no-minify", + "link": "directus-extension link", + "typecheck": "tsc --noEmit", + "test": "node --import tsx --test src/lib/*.test.ts", + "publish": "scp -r ./dist ./package.json land-nest:/home/oak/apps/directus/extensions/directus-extension-generate-image-previews/" + }, + "devDependencies": { + "@directus/extensions-sdk": "13.0.1", + "@types/node": "^22.13.5", + "tsx": "^4.19.2", + "typescript": "^5.7.3", + "vue": "^3.5.13" + }, + "dependencies": { + "object-hash": "^3.0.0" + } +} diff --git a/src/endpoint/index.ts b/src/endpoint/index.ts new file mode 100644 index 0000000..7a5e117 --- /dev/null +++ b/src/endpoint/index.ts @@ -0,0 +1,312 @@ +import { defineEndpoint } from '@directus/extensions-sdk'; +import type { Request, Response, NextFunction } from 'express'; +import { runBackfill, requestCancel } from '../lib/backfill'; +import { computePlan, getOps, recordOp } from '../lib/diagnostics'; +import { humanBytes, humanDuration, humanMs, toIso } from '../lib/format'; +import { buildRegistry, effectiveFormatsForPreset, formatsForPreset, loadCustomPresets } from '../lib/presets'; +import { mergeSettings, readSettings, writeSettings } from '../lib/settings'; +import { isLocked, readRun } from '../lib/state'; +import { previewExists, storageUsage } from '../lib/storage'; +import { SYSTEM_PRESETS } from '../lib/system-presets'; +import { isInWindow, nextWindow } from '../lib/window'; +import { warmFile } from '../lib/warmer'; + +const FILE_FIELDS = [ + 'id', + 'filename_disk', + 'type', + 'width', + 'height', + 'focal_point_x', + 'focal_point_y', + 'storage', +]; + +function asyncHandler(handler: (req: Request, res: Response) => Promise) { + return (req: Request, res: Response, next: NextFunction) => { + handler(req, res).catch(next); + }; +} + +function bucket(bytes: number, count: number) { + return { bytes, count, bytesHuman: humanBytes(bytes) }; +} + +export default defineEndpoint({ + id: 'image-previews', + handler: (router, context) => { + const { services, database, getSchema, env, logger } = context; + + router.use((req: Request, res: Response, next: NextFunction) => { + const accountability = (req as Request & { accountability?: { admin?: boolean } }).accountability; + + if (accountability?.admin === true) return next(); + + res.status(403).json({ error: 'admin access required' }); + }); + + router.get( + '/status', + asyncHandler(async (_req, res) => { + const settings = await readSettings(env); + const run = await readRun(env); + const next = nextWindow(settings.windowStart, settings.windowEnd); + + res.json({ + enabled: settings.enabled, + window: { start: settings.windowStart, end: settings.windowEnd }, + inWindow: isInWindow(settings.windowStart, settings.windowEnd), + nextWindow: next?.toISOString() ?? null, + nextWindowHuman: next?.toLocaleString() ?? null, + locked: await isLocked(env), + run: run + ? { + ...run, + startedAtIso: toIso(run.startedAt), + finishedAtIso: toIso(run.finishedAt), + startedAtHuman: run.startedAt ? new Date(run.startedAt).toLocaleString() : null, + finishedAtHuman: run.finishedAt ? new Date(run.finishedAt).toLocaleString() : null, + etaHuman: humanDuration(run.eta), + rateHuman: `${Math.round(run.rate)} items/min`, + } + : null, + }); + }), + ); + + router.get( + '/config', + asyncHandler(async (_req, res) => { + res.json(await readSettings(env)); + }), + ); + + router.put( + '/config', + asyncHandler(async (req, res) => { + try { + const current = await readSettings(env); + const merged = mergeSettings(current, req.body ?? {}); + const saved = await writeSettings(merged, env); + res.json(saved); + } catch (error) { + res.status(400).json({ error: error instanceof Error ? error.message : String(error) }); + } + }), + ); + + router.get( + '/presets', + asyncHandler(async (_req, res) => { + const schema = await getSchema(); + const settings = await readSettings(env); + const custom = await loadCustomPresets(new services['SettingsService']({ schema })); + const presets = buildRegistry(custom, null); + const systemKeys = new Set(SYSTEM_PRESETS.map((preset) => preset.key)); + const shadowedKeys = custom + .filter((preset) => systemKeys.has(preset.key)) + .map((preset) => preset.key); + + res.json({ + shadowedKeys, + presets: presets.map((preset) => ({ + key: preset.key, + format: preset.format ?? null, + effectiveFormats: effectiveFormatsForPreset(preset, settings.formats), + system: systemKeys.has(preset.key), + enabled: settings.presetKeys === null || settings.presetKeys.includes(preset.key), + })), + }); + }), + ); + + router.post( + '/run', + asyncHandler(async (req, res) => { + const settings = await readSettings(env); + const ignoreWindow = req.body?.ignoreWindow === true; + + if (!settings.enabled) { + res.status(409).json({ error: 'disabled' }); + return; + } + + if (!ignoreWindow && !isInWindow(settings.windowStart, settings.windowEnd)) { + const next = nextWindow(settings.windowStart, settings.windowEnd); + res.status(409).json({ + error: 'outside-window', + nextWindow: next?.toISOString() ?? null, + nextWindowHuman: next?.toLocaleString() ?? null, + }); + return; + } + + if (await isLocked(env)) { + res.status(409).json({ error: 'already-running' }); + return; + } + + const presetKeys = Array.isArray(req.body?.presets) ? (req.body.presets as string[]) : undefined; + + void runBackfill( + { services, database, getSchema, env, logger }, + { presetKeys, ignoreWindow }, + ).catch((error) => logger.error(error, 'image-previews: run failed')); + + res.status(202).json({ started: true }); + }), + ); + + router.post( + '/run/cancel', + asyncHandler(async (_req, res) => { + await requestCancel(env); + res.json({ cancelling: true }); + }), + ); + + router.get( + '/disk-usage', + asyncHandler(async (_req, res) => { + const usage = await storageUsage(env); + + res.json({ + previews: bucket(usage.previews.bytes, usage.previews.count), + originals: bucket(usage.originals.bytes, usage.originals.count), + total: bucket(usage.total.bytes, usage.total.count), + source: usage.source, + }); + }), + ); + + router.get( + '/ops', + asyncHandler(async (req, res) => { + const limit = Number(req.query.limit) || 50; + + res.json({ + ops: getOps(limit).map((op) => ({ + ...op, + tsIso: toIso(op.ts), + tsHuman: new Date(op.ts).toLocaleString(), + msHuman: humanMs(op.ms), + })), + }); + }), + ); + + router.post( + '/generate', + asyncHandler(async (req, res) => { + const fileId = req.body?.fileId; + + if (typeof fileId !== 'string' || fileId.length === 0) { + res.status(400).json({ error: 'fileId is required' }); + return; + } + + const settings = await readSettings(env); + const schema = await getSchema(); + const custom = await loadCustomPresets(new services['SettingsService']({ schema })); + const presetKeys = Array.isArray(req.body?.keys) ? (req.body.keys as string[]) : settings.presetKeys; + const formats = Array.isArray(req.body?.formats) ? (req.body.formats as string[]) : settings.formats; + const presets = buildRegistry(custom, presetKeys); + + const items = new services['ItemsService']('directus_files', { schema }); + + if (req.body?.dryRun === true) { + const file = await items.readOne(fileId, { fields: FILE_FIELDS }); + const plans = []; + + for (const preset of presets) { + for (const format of formatsForPreset(preset, formats)) { + const plan = await computePlan(file, preset, format); + plans.push({ + key: preset.key, + format, + effectiveFormat: plan.format, + filename: plan.filename, + exists: await previewExists(env, file.storage ?? null, plan.filename), + transforms: plan.transforms, + }); + } + } + + res.json({ dryRun: true, fileId, plans }); + return; + } + + const assets = new services['AssetsService']({ schema }); + const started = Date.now(); + const summary = await warmFile(assets, fileId, presets, { + concurrency: settings.concurrency, + formats, + onResult: (result) => + recordOp({ + ts: Date.now(), + fileId, + key: result.key, + format: result.format, + ok: result.ok, + ms: result.ms, + error: result.error, + }), + }); + + res.json({ + fileId, + ms: Date.now() - started, + msHuman: humanMs(Date.now() - started), + ...summary, + results: summary.results.map((result) => ({ ...result, msHuman: humanMs(result.ms) })), + }); + }), + ); + + router.get( + '/resolve-plan', + asyncHandler(async (req, res) => { + const fileId = typeof req.query.fileId === 'string' ? req.query.fileId : ''; + const key = typeof req.query.key === 'string' ? req.query.key : ''; + + if (!fileId || !key) { + res.status(400).json({ error: 'fileId and key are required' }); + return; + } + + const settings = await readSettings(env); + const schema = await getSchema(); + const custom = await loadCustomPresets(new services['SettingsService']({ schema })); + const presets = buildRegistry(custom, null); + const preset = presets.find((candidate) => candidate.key === key); + + if (!preset) { + const systemKeys = SYSTEM_PRESETS.map((candidate) => candidate.key); + const shadowed = custom.some((candidate) => candidate.key === key); + res.status(404).json({ + error: `unknown preset: ${key}`, + reason: shadowed && systemKeys.includes(key) ? 'shadowed-by-system' : 'not-found', + }); + return; + } + + const items = new services['ItemsService']('directus_files', { schema }); + const file = await items.readOne(fileId, { fields: FILE_FIELDS }); + const plans = []; + + for (const format of formatsForPreset(preset, settings.formats)) { + const plan = await computePlan(file, preset, format); + plans.push({ + format, + effectiveFormat: plan.format, + filename: plan.filename, + exists: await previewExists(env, file.storage ?? null, plan.filename), + transforms: plan.transforms, + }); + } + + res.json({ fileId, key, plans }); + }), + ); + }, +}); diff --git a/src/hook/index.ts b/src/hook/index.ts new file mode 100644 index 0000000..6807dc4 --- /dev/null +++ b/src/hook/index.ts @@ -0,0 +1,56 @@ +import { defineHook } from '@directus/extensions-sdk'; +import { recordOp } from '../lib/diagnostics'; +import { buildRegistry, isImageType, loadCustomPresets } from '../lib/presets'; +import { readSettings } from '../lib/settings'; +import { warmFile } from '../lib/warmer'; + +interface UploadMeta { + key?: string; + collection?: string; + payload?: { type?: string | null; collection?: string }; +} + +export default defineHook(({ action }, { services, getSchema, env, logger }) => { + action('files.upload', (meta) => { + void warmUpload(meta as UploadMeta).catch((error) => + logger.error(error, 'image-previews: upload warm failed'), + ); + }); + + async function warmUpload(meta: UploadMeta): Promise { + const settings = await readSettings(env); + + if (!settings.enabled || !settings.onUpload) return; + + const fileId = meta?.key; + const payload = meta?.payload; + + if (!fileId || !payload) return; + if (payload.collection && payload.collection !== 'directus_files') return; + if (!isImageType(payload.type)) return; + + const schema = await getSchema(); + const custom = await loadCustomPresets(new services['SettingsService']({ schema })); + const presets = buildRegistry(custom, settings.presetKeys); + + if (presets.length === 0) return; + + const assets = new services['AssetsService']({ schema }); + const summary = await warmFile(assets, fileId, presets, { + concurrency: settings.concurrency, + formats: settings.formats, + onResult: (result) => + recordOp({ + ts: Date.now(), + fileId, + key: result.key, + format: result.format, + ok: result.ok, + ms: result.ms, + error: result.error, + }), + }); + + if (settings.debug) logger.info({ fileId, summary }, 'image-previews: warmed upload'); + } +}); diff --git a/src/lib/backfill.ts b/src/lib/backfill.ts new file mode 100644 index 0000000..5891698 --- /dev/null +++ b/src/lib/backfill.ts @@ -0,0 +1,206 @@ +import { recordOp } from './diagnostics'; +import { buildRegistry, effectiveFormatsForPreset, isImageType, loadCustomPresets, tasksPerFile } from './presets'; +import { readSettings } from './settings'; +import { + acquireLock, + appendCompleted, + clearCancel, + completedKeyOf, + isCancelled, + loadCompleted, + readRun, + releaseLock, + requestCancel, + writeRun, +} from './state'; +import type { RunState } from './types'; +import { errorMessage, warmFile } from './warmer'; +import { isInWindow } from './window'; + +export interface BackfillDeps { + services: Record; + database: any; + getSchema: () => Promise; + env: Record; + logger: any; +} + +export interface BackfillOptions { + presetKeys?: string[] | null; + ignoreWindow?: boolean; +} + +export interface BackfillOutcome { + status: 'completed' | 'skipped' | 'failed'; + reason?: string; + run?: RunState; +} + +const PAGE_SIZE = 100; + +let inProcessRunning = false; + +async function countImageFiles(database: any): Promise { + try { + const rows = await database('directus_files').where('type', 'like', 'image/%').count({ count: '*' }); + const row = Array.isArray(rows) ? rows[0] : rows; + return Number(row?.count) || 0; + } catch { + return 0; + } +} + +export async function runBackfill(deps: BackfillDeps, options: BackfillOptions = {}): Promise { + if (inProcessRunning) return { status: 'skipped', reason: 'already-running' }; + + const settings = await readSettings(deps.env); + + if (!settings.enabled) return { status: 'skipped', reason: 'disabled' }; + + if (!options.ignoreWindow && !isInWindow(settings.windowStart, settings.windowEnd)) { + return { status: 'skipped', reason: 'outside-window' }; + } + + if (!(await acquireLock(deps.env))) return { status: 'skipped', reason: 'already-running' }; + + inProcessRunning = true; + await clearCancel(deps.env); + + try { + const schema = await deps.getSchema(); + const settingsService = new deps.services['SettingsService']({ schema }); + const custom = await loadCustomPresets(settingsService); + const presetKeys = options.presetKeys !== undefined ? options.presetKeys : settings.presetKeys; + const presets = buildRegistry(custom, presetKeys); + const formats = settings.formats; + const perFile = tasksPerFile(presets, formats); + const totalFiles = await countImageFiles(deps.database); + + const run: RunState = { + running: true, + startedAt: Date.now(), + finishedAt: null, + total: totalFiles * perFile, + done: 0, + generated: 0, + hits: 0, + failed: 0, + rate: 0, + eta: null, + cancelled: false, + }; + + await writeRun(run, deps.env); + + const completed = await loadCompleted(deps.env); + const items = new deps.services['ItemsService']('directus_files', { schema }); + const assets = new deps.services['AssetsService']({ schema }); + const started = Date.now(); + let page = 1; + + while (true) { + const files = await items.readByQuery({ + filter: { type: { _starts_with: 'image/' } }, + fields: [ 'id', 'filename_disk', 'type', 'width', 'height', 'focal_point_x', 'focal_point_y', 'storage' ], + limit: PAGE_SIZE, + page, + sort: [ 'id' ], + }); + + if (!Array.isArray(files) || files.length === 0) break; + + for (const file of files) { + if (await isCancelled(deps.env)) { + run.cancelled = true; + break; + } + + if (!isImageType(file.type)) continue; + + const pending = presets.filter((preset) => + effectiveFormatsForPreset(preset, formats).some( + (format) => !completed.has(completedKeyOf(file.id, preset.key, format)), + ), + ); + + const pendingTasks = pending.reduce( + (total, preset) => total + effectiveFormatsForPreset(preset, formats).length, + 0, + ); + const alreadyDone = perFile - pendingTasks; + + if (alreadyDone > 0) { + run.hits += alreadyDone; + run.done += alreadyDone; + } + + if (pending.length === 0) { + await writeRun(run, deps.env); + continue; + } + + const summary = await warmFile(assets, file.id, pending, { + concurrency: settings.concurrency, + formats, + onResult: (result) => + recordOp({ + ts: Date.now(), + fileId: file.id, + key: result.key, + format: result.format, + ok: result.ok, + ms: result.ms, + error: result.error, + }), + }); + + for (const result of summary.results) { + if (result.ok) { + completed.add(completedKeyOf(file.id, result.key, result.format)); + await appendCompleted( + { file_id: file.id, preset_key: result.key, format: result.format, ts: Date.now() }, + deps.env, + ); + run.generated += 1; + } else { + run.failed += 1; + } + + run.done += 1; + } + + const elapsedMinutes = (Date.now() - started) / 60000; + run.rate = elapsedMinutes > 0 ? run.done / elapsedMinutes : 0; + run.eta = run.rate > 0 ? Math.round(((run.total - run.done) / run.rate) * 60) : null; + await writeRun(run, deps.env); + } + + if (run.cancelled || files.length < PAGE_SIZE) break; + page += 1; + } + + run.running = false; + run.finishedAt = Date.now(); + await writeRun(run, deps.env); + + return { status: 'completed', run }; + } catch (error) { + deps.logger?.error?.(error, 'image-previews: backfill failed'); + const existing = await readRun(deps.env); + + if (existing) { + existing.running = false; + existing.finishedAt = Date.now(); + existing.error = errorMessage(error); + await writeRun(existing, deps.env); + } + + return { status: 'failed', reason: errorMessage(error) }; + } finally { + inProcessRunning = false; + await releaseLock(deps.env); + await clearCancel(deps.env); + } +} + +export { requestCancel }; diff --git a/src/lib/diagnostics.test.ts b/src/lib/diagnostics.test.ts new file mode 100644 index 0000000..a74a34f --- /dev/null +++ b/src/lib/diagnostics.test.ts @@ -0,0 +1,77 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { computePlan, getOps, recordOp, type PlanFile } from './diagnostics'; +import type { Preset } from './types'; + +const file: PlanFile = { + filename_disk: 'abc123.jpg', + type: 'image/jpeg', + width: 1200, + height: 800, + focal_point_x: null, + focal_point_y: null, + storage: 'local', +}; + +const preset: Preset = { + key: 'system-small-cover', + format: 'auto', + transforms: [ [ 'resize', { width: 64, height: 64, fit: 'cover' } ] ], +}; + +function utilsWith(format: string | undefined) { + return { + resolvePreset: () => + format ? [ [ 'toFormat', format, { quality: undefined } ], [ 'resize', { width: 64 } ] ] : [ [ 'resize', { width: 64 } ] ], + maybeExtractFormat: () => format, + }; +} + +test('computePlan predicts a hashed filename with the resolved extension', async () => { + const plan = await computePlan(file, preset, 'avif', { + utils: utilsWith('avif'), + hashFn: () => 'deadbeef', + }); + + assert.equal(plan.filename, 'abc123__deadbeef.avif'); + assert.equal(plan.format, 'avif'); + assert.equal(plan.transforms.length, 2); +}); + +test('computePlan without a toFormat keeps the original extension but still hashes the resize', async () => { + const plan = await computePlan(file, { key: 'resize-only', width: 100 }, null, { + utils: utilsWith(undefined), + hashFn: () => 'unused', + }); + + assert.equal(plan.filename, 'abc123__unused.jpg'); + assert.equal(plan.format, null); +}); + +test('computePlan passes acceptFormat into the transformation set', async () => { + let seen: Record | null = null; + + await computePlan(file, preset, 'webp', { + utils: { + resolvePreset: (transformation) => { + seen = transformation; + return [ [ 'toFormat', 'webp', {} ] ]; + }, + maybeExtractFormat: () => 'webp', + }, + hashFn: () => 'x', + }); + + assert.equal(seen?.['acceptFormat'], 'webp'); + assert.ok(seen?.['transformationParams']); +}); + +test('ops ring buffer is newest-first and bounded', () => { + recordOp({ ts: 1, fileId: 'a', key: 'k', format: 'avif', ok: true, ms: 1 }); + recordOp({ ts: 2, fileId: 'b', key: 'k', format: 'avif', ok: false, ms: 2, error: 'x' }); + + const ops = getOps(1); + assert.equal(ops.length, 1); + assert.equal(ops[0]?.fileId, 'b'); + assert.equal(getOps(0).length, 0); +}); diff --git a/src/lib/diagnostics.ts b/src/lib/diagnostics.ts new file mode 100644 index 0000000..9b4eb69 --- /dev/null +++ b/src/lib/diagnostics.ts @@ -0,0 +1,97 @@ +import { basename, extname } from 'node:path'; +import objectHash from 'object-hash'; +import type { Preset } from './types'; + +export interface PlanFile { + filename_disk: string; + type?: string | null; + width?: number | null; + height?: number | null; + focal_point_x?: number | null; + focal_point_y?: number | null; + storage?: string | null; +} + +export interface PlanResult { + filename: string; + format: string | null; + transforms: unknown[]; +} + +interface TransformUtils { + resolvePreset(transformation: Record, file: PlanFile): unknown[]; + maybeExtractFormat(transforms: unknown[]): string | undefined; +} + +export interface PlanDeps { + utils?: TransformUtils; + hashFn?: (value: unknown) => string; +} + +async function loadTransformUtils(): Promise { + const importer = new Function('return import("@directus/api/utils/transformations")') as () => Promise< + Record + >; + const module = await importer(); + const namespace = (module['TransformationUtils'] as Record | undefined) ?? module; + + const resolvePreset = (namespace['resolvePreset'] ?? module['resolvePreset']) as TransformUtils['resolvePreset']; + const maybeExtractFormat = (namespace['maybeExtractFormat'] ?? module['maybeExtractFormat']) as TransformUtils['maybeExtractFormat']; + + if (typeof resolvePreset !== 'function' || typeof maybeExtractFormat !== 'function') { + throw new Error('Unable to load Directus transformation utils'); + } + + return { resolvePreset, maybeExtractFormat }; +} + +export async function computePlan( + file: PlanFile, + preset: Preset, + acceptFormat: string | null, + deps: PlanDeps = {}, +): Promise { + const utils = deps.utils ?? (await loadTransformUtils()); + const hashFn = deps.hashFn ?? ((value: unknown) => objectHash(value)); + + const transformationParams: Record = { ...preset }; + const transformation: Record = { transformationParams }; + + if (acceptFormat) transformation['acceptFormat'] = acceptFormat; + + const transforms = utils.resolvePreset(transformation, file); + const suffix = transforms.length > 0 ? `__${hashFn(transforms)}` : ''; + const newFormat = utils.maybeExtractFormat(transforms); + const originalExtension = extname(file.filename_disk); + const base = basename(file.filename_disk, originalExtension); + const extension = newFormat ? `.${newFormat}` : originalExtension; + + return { + filename: `${base}${suffix}${extension}`, + format: newFormat ?? null, + transforms, + }; +} + +export interface OpRecord { + ts: number; + fileId: string; + key: string; + format: string | null; + ok: boolean; + ms: number; + error?: string; +} + +const MAX_OPS = 200; +const ops: OpRecord[] = []; + +export function recordOp(op: OpRecord): void { + ops.unshift(op); + + if (ops.length > MAX_OPS) ops.length = MAX_OPS; +} + +export function getOps(limit = 50): OpRecord[] { + return ops.slice(0, Math.max(0, Math.min(limit, MAX_OPS))); +} diff --git a/src/lib/format.test.ts b/src/lib/format.test.ts new file mode 100644 index 0000000..6fb0f33 --- /dev/null +++ b/src/lib/format.test.ts @@ -0,0 +1,31 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { humanBytes, humanDuration, humanMs, toIso } from './format'; + +test('humanBytes formats sizes', () => { + assert.equal(humanBytes(0), '0 B'); + assert.equal(humanBytes(512), '512 B'); + assert.equal(humanBytes(1024), '1.0 KB'); + assert.equal(humanBytes(1536), '1.5 KB'); + assert.equal(humanBytes(1024 * 1024), '1.0 MB'); +}); + +test('humanMs formats durations', () => { + assert.equal(humanMs(250), '250 ms'); + assert.equal(humanMs(1500), '1.5 s'); + assert.equal(humanMs(65000), '1 min 5 s'); +}); + +test('humanDuration formats seconds', () => { + assert.equal(humanDuration(null), '—'); + assert.equal(humanDuration(30), '30 s'); + assert.equal(humanDuration(90), '1 min 30 s'); + assert.equal(humanDuration(3700), '1 h 1 min'); +}); + +test('toIso returns null for empty values', () => { + assert.equal(toIso(null), null); + assert.equal(toIso(undefined), null); + assert.equal(toIso(0), null); + assert.equal(toIso(1792880701827), new Date(1792880701827).toISOString()); +}); diff --git a/src/lib/format.ts b/src/lib/format.ts new file mode 100644 index 0000000..050b330 --- /dev/null +++ b/src/lib/format.ts @@ -0,0 +1,34 @@ +export function humanBytes(bytes: number): string { + if (!Number.isFinite(bytes) || bytes <= 0) return '0 B'; + + const units = [ 'B', 'KB', 'MB', 'GB', 'TB', 'PB' ]; + const exponent = Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(1024))); + const value = bytes / Math.pow(1024, exponent); + + return `${value.toFixed(exponent === 0 ? 0 : 1)} ${units[exponent]}`; +} + +export function humanMs(ms: number): string { + if (!Number.isFinite(ms) || ms < 0) return '—'; + if (ms < 1000) return `${Math.round(ms)} ms`; + if (ms < 60000) return `${(ms / 1000).toFixed(1)} s`; + return `${Math.floor(ms / 60000)} min ${Math.round((ms % 60000) / 1000)} s`; +} + +export function humanDuration(seconds: number | null | undefined): string { + if (seconds === null || seconds === undefined || !Number.isFinite(seconds) || seconds < 0) return '—'; + if (seconds < 60) return `${Math.round(seconds)} s`; + + const minutes = Math.floor(seconds / 60); + const rest = Math.round(seconds % 60); + + if (minutes < 60) return rest > 0 ? `${minutes} min ${rest} s` : `${minutes} min`; + + const hours = Math.floor(minutes / 60); + return `${hours} h ${minutes % 60} min`; +} + +export function toIso(value: number | null | undefined): string | null { + if (!value || !Number.isFinite(value)) return null; + return new Date(value).toISOString(); +} diff --git a/src/lib/presets.test.ts b/src/lib/presets.test.ts new file mode 100644 index 0000000..f55beb2 --- /dev/null +++ b/src/lib/presets.test.ts @@ -0,0 +1,63 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { buildRegistry, effectiveFormatsForPreset, formatsForPreset, mergePresets, tasksPerFile, uniqueByKey } from './presets'; +import { SYSTEM_PRESETS } from './system-presets'; +import type { Preset } from './types'; + +test('system presets are the six expected keys', () => { + assert.deepEqual( + SYSTEM_PRESETS.map((preset) => preset.key), + [ + 'system-small-cover', + 'system-small-contain', + 'system-medium-cover', + 'system-medium-contain', + 'system-large-cover', + 'system-large-contain', + ], + ); +}); + +test('mergePresets appends custom after system', () => { + const custom: Preset[] = [ { key: 'custom', width: 100 } ]; + const merged = mergePresets(SYSTEM_PRESETS, custom); + assert.equal(merged.length, SYSTEM_PRESETS.length + 1); + assert.equal(merged[merged.length - 1]?.key, 'custom'); +}); + +test('uniqueByKey keeps the first occurrence (controller parity)', () => { + const custom: Preset[] = [ { key: 'system-small-cover', width: 999 } ]; + const merged = uniqueByKey(mergePresets(SYSTEM_PRESETS, custom)); + const small = merged.find((preset) => preset.key === 'system-small-cover'); + assert.equal(small?.width, undefined); + assert.equal(merged.filter((preset) => preset.key === 'system-small-cover').length, 1); +}); + +test('buildRegistry selects by key or returns all', () => { + const all = buildRegistry([], null); + assert.equal(all.length, 6); + + const selected = buildRegistry([], [ 'system-medium-cover' ]); + assert.deepEqual(selected.map((preset) => preset.key), [ 'system-medium-cover' ]); +}); + +test('formatsForPreset emits two variants for auto and one otherwise', () => { + const auto: Preset = { key: 'a', format: 'auto' }; + const fixed: Preset = { key: 'b', format: 'webp' }; + const none: Preset = { key: 'c', width: 100 }; + + assert.deepEqual(formatsForPreset(auto, [ 'avif', 'webp' ]), [ 'avif', 'webp' ]); + assert.deepEqual(formatsForPreset(fixed, [ 'avif', 'webp' ]), [ null ]); + assert.deepEqual(formatsForPreset(none, [ 'avif', 'webp' ]), [ null ]); +}); + +test('effectiveFormatsForPreset reports the real output format', () => { + assert.deepEqual(effectiveFormatsForPreset({ key: 'a', format: 'auto' }, [ 'avif', 'webp' ]), [ 'avif', 'webp' ]); + assert.deepEqual(effectiveFormatsForPreset({ key: 'b', format: 'png' }, [ 'avif', 'webp' ]), [ 'png' ]); + assert.deepEqual(effectiveFormatsForPreset({ key: 'c', width: 100 }, [ 'avif', 'webp' ]), [ null ]); +}); + +test('tasksPerFile counts variants across presets', () => { + assert.equal(tasksPerFile(SYSTEM_PRESETS, [ 'avif', 'webp' ]), 12); + assert.equal(tasksPerFile(SYSTEM_PRESETS, [ 'avif' ]), 6); +}); diff --git a/src/lib/presets.ts b/src/lib/presets.ts new file mode 100644 index 0000000..3712239 --- /dev/null +++ b/src/lib/presets.ts @@ -0,0 +1,58 @@ +import { SYSTEM_PRESETS } from './system-presets'; +import type { Preset } from './types'; + +export function mergePresets(system: Preset[], custom: Preset[]): Preset[] { + return [ ...system, ...custom ]; +} + +export function uniqueByKey(presets: Preset[]): Preset[] { + const seen = new Set(); + + return presets.filter((preset) => { + if (seen.has(preset.key)) return false; + seen.add(preset.key); + return true; + }); +} + +export function selectPresets(presets: Preset[], keys: string[] | null): Preset[] { + if (keys === null) return presets; + + const wanted = new Set(keys); + return presets.filter((preset) => wanted.has(preset.key)); +} + +export function buildRegistry(custom: Preset[], keys: string[] | null): Preset[] { + const merged = uniqueByKey(mergePresets(SYSTEM_PRESETS, custom)); + return selectPresets(merged, keys); +} + +export function formatsForPreset(preset: Preset, formats: string[]): (string | null)[] { + if (preset.format === 'auto') return formats.length > 0 ? [ ...formats ] : [ 'avif', 'webp' ]; + return [ null ]; +} + +export function effectiveFormat(preset: Preset, variant: string | null): string | null { + return variant ?? preset.format ?? null; +} + +export function effectiveFormatsForPreset(preset: Preset, formats: string[]): (string | null)[] { + return formatsForPreset(preset, formats).map((variant) => effectiveFormat(preset, variant)); +} + +export function tasksPerFile(presets: Preset[], formats: string[]): number { + return presets.reduce((total, preset) => total + formatsForPreset(preset, formats).length, 0); +} + +export function isImageType(type: unknown): boolean { + return typeof type === 'string' && type.startsWith('image/'); +} + +export async function loadCustomPresets(settingsService: { + readSingleton(query?: Record): Promise | null>; +}): Promise { + const settings = await settingsService.readSingleton({ fields: [ 'storage_asset_presets' ] }); + const list = settings?.['storage_asset_presets']; + + return Array.isArray(list) ? (list as Preset[]) : []; +} diff --git a/src/lib/settings.test.ts b/src/lib/settings.test.ts new file mode 100644 index 0000000..87fbd5c --- /dev/null +++ b/src/lib/settings.test.ts @@ -0,0 +1,69 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { envDefaults, mergeSettings, validateSettings } from './settings'; + +test('envDefaults applies safe defaults', () => { + const settings = envDefaults({}); + assert.equal(settings.enabled, true); + assert.equal(settings.windowStart, '01:00'); + assert.equal(settings.windowEnd, '04:00'); + assert.equal(settings.concurrency, 1); + assert.deepEqual(settings.formats, [ 'avif', 'webp' ]); + assert.equal(settings.onUpload, true); + assert.equal(settings.presetKeys, null); +}); + +test('envDefaults parses overrides', () => { + const settings = envDefaults({ + IMAGE_PREVIEWS_ENABLED: 'true', + IMAGE_PREVIEWS_CONCURRENCY: '4', + IMAGE_PREVIEWS_FORMATS: 'webp', + IMAGE_PREVIEWS_PRESETS: 'system-small-cover, system-large-cover', + IMAGE_PREVIEWS_ON_UPLOAD: '0', + }); + + assert.equal(settings.enabled, true); + assert.equal(settings.concurrency, 4); + assert.deepEqual(settings.formats, [ 'webp' ]); + assert.deepEqual(settings.presetKeys, [ 'system-small-cover', 'system-large-cover' ]); + assert.equal(settings.onUpload, false); +}); + +test('envDefaults tolerates Directus-coerced booleans and numbers', () => { + const settings = envDefaults({ + IMAGE_PREVIEWS_ENABLED: true, + IMAGE_PREVIEWS_CONCURRENCY: 3, + IMAGE_PREVIEWS_ON_UPLOAD: false, + }); + + assert.equal(settings.enabled, true); + assert.equal(settings.concurrency, 3); + assert.equal(settings.onUpload, false); +}); + +test('mergeSettings keeps base values for absent overrides', () => { + const base = envDefaults({}); + const merged = mergeSettings(base, { enabled: true }); + assert.equal(merged.enabled, true); + assert.equal(merged.concurrency, base.concurrency); + assert.deepEqual(merged.formats, base.formats); +}); + +test('validateSettings rejects invalid concurrency', () => { + const base = envDefaults({}); + assert.throws(() => validateSettings({ ...base, concurrency: 0 }), /concurrency/); + assert.throws(() => validateSettings({ ...base, concurrency: 99 }), /concurrency/); +}); + +test('validateSettings rejects invalid window and format', () => { + const base = envDefaults({}); + assert.throws(() => validateSettings({ ...base, windowStart: '25:00' }), /windowStart/); + assert.throws(() => validateSettings({ ...base, formats: [ 'bmp' ] }), /unsupported format/); +}); + +test('validateSettings normalises a valid payload', () => { + const base = envDefaults({}); + const result = validateSettings({ ...base, windowStart: '03:00', windowEnd: '05:30' }); + assert.equal(result.windowStart, '03:00'); + assert.equal(result.windowEnd, '05:30'); +}); diff --git a/src/lib/settings.ts b/src/lib/settings.ts new file mode 100644 index 0000000..7f41b34 --- /dev/null +++ b/src/lib/settings.ts @@ -0,0 +1,156 @@ +import { mkdir, readFile, writeFile } from 'node:fs/promises'; +import { dirname, isAbsolute, join } from 'node:path'; + +export interface Settings { + enabled: boolean; + windowStart: string | null; + windowEnd: string | null; + concurrency: number; + presetKeys: string[] | null; + formats: string[]; + onUpload: boolean; + debug: boolean; +} + +export interface EnvLike { + [ key: string ]: unknown; +} + +const DEFAULT_STATE_SUBDIR = '.image-previews'; +const DEFAULT_WINDOW_START = '01:00'; +const DEFAULT_WINDOW_END = '04:00'; + +function asString(value: unknown): string | null { + if (value === undefined || value === null) return null; + if (typeof value === 'string') return value; + if (typeof value === 'number' || typeof value === 'boolean') return String(value); + return null; +} + +export function stateDir(env: EnvLike = process.env): string { + const configured = asString(env['IMAGE_PREVIEWS_STATE_DIR']); + + if (configured && configured.length > 0) return configured; + + const root = asString(env['STORAGE_LOCAL_ROOT']) || '/directus/uploads'; + const absoluteRoot = isAbsolute(root) ? root : join(process.cwd(), root); + + return join(absoluteRoot, DEFAULT_STATE_SUBDIR); +} + +function parseBool(value: unknown, fallback: boolean): boolean { + const raw = asString(value); + if (raw === null || raw.trim() === '') return fallback; + return [ '1', 'true', 'yes', 'on' ].includes(raw.trim().toLowerCase()); +} + +function parseList(value: unknown): string[] | null { + const raw = asString(value); + if (raw === null || raw.trim() === '') return null; + + return raw + .split(',') + .map((part) => part.trim()) + .filter(Boolean); +} + +function parseNumber(value: unknown, fallback: number): number { + const raw = asString(value); + if (raw === null || raw.trim() === '') return fallback; + const parsed = Number(raw); + return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback; +} + +export function envDefaults(env: EnvLike = process.env): Settings { + return { + enabled: parseBool(env['IMAGE_PREVIEWS_ENABLED'], true), + windowStart: asString(env['IMAGE_PREVIEWS_WINDOW_START']) ?? DEFAULT_WINDOW_START, + windowEnd: asString(env['IMAGE_PREVIEWS_WINDOW_END']) ?? DEFAULT_WINDOW_END, + concurrency: parseNumber(env['IMAGE_PREVIEWS_CONCURRENCY'], 1), + presetKeys: parseList(env['IMAGE_PREVIEWS_PRESETS']), + formats: parseList(env['IMAGE_PREVIEWS_FORMATS']) ?? [ 'avif', 'webp' ], + onUpload: parseBool(env['IMAGE_PREVIEWS_ON_UPLOAD'], true), + debug: parseBool(env['IMAGE_PREVIEWS_DEBUG'], false), + }; +} + +export function settingsPath(env: EnvLike = process.env): string { + return join(stateDir(env), 'settings.json'); +} + +export function mergeSettings(base: Settings, override: Partial): Settings { + return { + ...base, + ...override, + formats: override.formats ?? base.formats, + presetKeys: override.presetKeys !== undefined ? override.presetKeys : base.presetKeys, + }; +} + +export async function readSettings(env: EnvLike = process.env): Promise { + const defaults = envDefaults(env); + + try { + const raw = await readFile(settingsPath(env), 'utf8'); + const parsed = JSON.parse(raw) as Partial; + return validateSettings(mergeSettings(defaults, parsed)); + } catch { + return defaults; + } +} + +export async function writeSettings(settings: Settings, env: EnvLike = process.env): Promise { + const validated = validateSettings(settings); + const target = settingsPath(env); + await mkdir(dirname(target), { recursive: true }); + await writeFile(target, `${JSON.stringify(validated, null, 2)}\n`, 'utf8'); + return validated; +} + +const TIME_PATTERN = /^([01]\d|2[0-3]):[0-5]\d$/; +const ALLOWED_FORMATS = [ 'avif', 'webp', 'jpg', 'jpeg', 'png' ]; + +export function validateSettings(settings: Settings): Settings { + if (typeof settings.enabled !== 'boolean') throw new Error('enabled must be a boolean'); + if (typeof settings.onUpload !== 'boolean') throw new Error('onUpload must be a boolean'); + if (typeof settings.debug !== 'boolean') throw new Error('debug must be a boolean'); + + if (settings.windowStart !== null && !TIME_PATTERN.test(settings.windowStart)) { + throw new Error('windowStart must be HH:MM or null'); + } + + if (settings.windowEnd !== null && !TIME_PATTERN.test(settings.windowEnd)) { + throw new Error('windowEnd must be HH:MM or null'); + } + + const concurrency = Number(settings.concurrency); + + if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 32) { + throw new Error('concurrency must be an integer between 1 and 32'); + } + + if (!Array.isArray(settings.formats) || settings.formats.length === 0) { + throw new Error('formats must be a non-empty array'); + } + + for (const format of settings.formats) { + if (!ALLOWED_FORMATS.includes(format)) throw new Error(`unsupported format: ${format}`); + } + + if (settings.presetKeys !== null) { + if (!Array.isArray(settings.presetKeys) || settings.presetKeys.some((key) => typeof key !== 'string')) { + throw new Error('presetKeys must be an array of strings or null'); + } + } + + return { + enabled: settings.enabled, + windowStart: settings.windowStart, + windowEnd: settings.windowEnd, + concurrency, + presetKeys: settings.presetKeys, + formats: [ ...settings.formats ], + onUpload: settings.onUpload, + debug: settings.debug, + }; +} diff --git a/src/lib/state.test.ts b/src/lib/state.test.ts new file mode 100644 index 0000000..aeb7b62 --- /dev/null +++ b/src/lib/state.test.ts @@ -0,0 +1,95 @@ +import assert from 'node:assert/strict'; +import { appendFile, mkdtemp, rm } from 'node:fs/promises'; +import { tmpdir } from 'node:os'; +import { join } from 'node:path'; +import { test } from 'node:test'; +import { + acquireLock, + appendCompleted, + completedKeyOf, + isCancelled, + loadCompleted, + readRun, + releaseLock, + requestCancel, + writeRun, +} from './state'; +import type { RunState } from './types'; + +async function withTempEnv(run: (env: Record) => Promise): Promise { + const dir = await mkdtemp(join(tmpdir(), 'image-previews-')); + + try { + await run({ IMAGE_PREVIEWS_STATE_DIR: dir }); + } finally { + await rm(dir, { recursive: true, force: true }); + } +} + +test('appendCompleted + loadCompleted round-trips and resumes', async () => { + await withTempEnv(async (env) => { + const empty = await loadCompleted(env); + assert.equal(empty.size, 0); + + await appendCompleted({ file_id: 'f1', preset_key: 'system-small-cover', format: 'avif', ts: 1 }, env); + await appendCompleted({ file_id: 'f1', preset_key: 'system-small-cover', format: 'webp', ts: 2 }, env); + + const completed = await loadCompleted(env); + assert.equal(completed.size, 2); + assert.ok(completed.has(completedKeyOf('f1', 'system-small-cover', 'avif'))); + assert.ok(completed.has(completedKeyOf('f1', 'system-small-cover', 'webp'))); + }); +}); + +test('loadCompleted tolerates corrupt lines', async () => { + await withTempEnv(async (env) => { + await appendFile(join(env['IMAGE_PREVIEWS_STATE_DIR'] as string, 'state.jsonl'), 'not-json\n', 'utf8'); + await appendCompleted({ file_id: 'f2', preset_key: 'k', format: null, ts: 1 }, env); + + const completed = await loadCompleted(env); + assert.equal(completed.size, 1); + }); +}); + +test('run state round-trips', async () => { + await withTempEnv(async (env) => { + assert.equal(await readRun(env), null); + + const run: RunState = { + running: true, + startedAt: 1, + finishedAt: null, + total: 10, + done: 2, + generated: 2, + hits: 0, + failed: 0, + rate: 1, + eta: 8, + cancelled: false, + }; + + await writeRun(run, env); + const loaded = await readRun(env); + assert.equal(loaded?.done, 2); + assert.equal(loaded?.total, 10); + }); +}); + +test('lock is exclusive and releasable', async () => { + await withTempEnv(async (env) => { + assert.equal(await acquireLock(env), true); + assert.equal(await acquireLock(env), false); + await releaseLock(env); + assert.equal(await acquireLock(env), true); + await releaseLock(env); + }); +}); + +test('cancel flag toggles', async () => { + await withTempEnv(async (env) => { + assert.equal(await isCancelled(env), false); + await requestCancel(env); + assert.equal(await isCancelled(env), true); + }); +}); diff --git a/src/lib/state.ts b/src/lib/state.ts new file mode 100644 index 0000000..09be302 --- /dev/null +++ b/src/lib/state.ts @@ -0,0 +1,107 @@ +import { appendFile, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises'; +import { join } from 'node:path'; +import { stateDir, type EnvLike } from './settings'; +import type { CompletedRecord, RunState } from './types'; + +const STALE_LOCK_MS = 6 * 60 * 60 * 1000; + +export function completedKey(record: CompletedRecord): string { + return completedKeyOf(record.file_id, record.preset_key, record.format); +} + +export function completedKeyOf(fileId: string, presetKey: string, format: string | null): string { + return `${fileId}::${presetKey}::${format ?? ''}`; +} + +export function stateFilePath(env: EnvLike, name: string): string { + return join(stateDir(env), name); +} + +export async function ensureStateDir(env: EnvLike): Promise { + await mkdir(stateDir(env), { recursive: true }); +} + +export async function loadCompleted(env: EnvLike): Promise> { + const completed = new Set(); + + try { + const raw = await readFile(stateFilePath(env, 'state.jsonl'), 'utf8'); + + for (const line of raw.split('\n')) { + if (!line.trim()) continue; + + try { + completed.add(completedKey(JSON.parse(line) as CompletedRecord)); + } catch { + continue; + } + } + } catch { + return completed; + } + + return completed; +} + +export async function appendCompleted(record: CompletedRecord, env: EnvLike): Promise { + await ensureStateDir(env); + await appendFile(stateFilePath(env, 'state.jsonl'), `${JSON.stringify(record)}\n`, 'utf8'); +} + +export async function readRun(env: EnvLike): Promise { + try { + return JSON.parse(await readFile(stateFilePath(env, 'run.json'), 'utf8')) as RunState; + } catch { + return null; + } +} + +export async function writeRun(run: RunState, env: EnvLike): Promise { + await ensureStateDir(env); + await writeFile(stateFilePath(env, 'run.json'), `${JSON.stringify(run, null, 2)}\n`, 'utf8'); +} + +async function lockAge(env: EnvLike): Promise { + try { + const info = JSON.parse(await readFile(stateFilePath(env, 'run.lock'), 'utf8')) as { ts?: number }; + return Date.now() - (Number(info.ts) || 0); + } catch { + return null; + } +} + +export async function isLocked(env: EnvLike): Promise { + const age = await lockAge(env); + return age !== null && age < STALE_LOCK_MS; +} + +export async function acquireLock(env: EnvLike): Promise { + await ensureStateDir(env); + + if (await isLocked(env)) return false; + + await writeFile(stateFilePath(env, 'run.lock'), JSON.stringify({ ts: Date.now(), pid: process.pid }), 'utf8'); + return true; +} + +export async function releaseLock(env: EnvLike): Promise { + await rm(stateFilePath(env, 'run.lock'), { force: true }); +} + +export async function requestCancel(env: EnvLike): Promise { + await ensureStateDir(env); + await writeFile(stateFilePath(env, 'cancel.flag'), String(Date.now()), 'utf8'); +} + +export async function clearCancel(env: EnvLike): Promise { + await rm(stateFilePath(env, 'cancel.flag'), { force: true }); +} + +export async function isCancelled(env: EnvLike): Promise { + try { + await stat(stateFilePath(env, 'cancel.flag')); + return true; + } catch { + return false; + } +} diff --git a/src/lib/storage.test.ts b/src/lib/storage.test.ts new file mode 100644 index 0000000..36bd1ad --- /dev/null +++ b/src/lib/storage.test.ts @@ -0,0 +1,42 @@ +import assert from 'node:assert/strict'; +import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'; +import { tmpdir } from 'node:os'; +import { join } from 'node:path'; +import { test } from 'node:test'; +import { isPreviewPath, isStatePath, storageUsage } from './storage'; + +test('isPreviewPath matches transform cache files only', () => { + assert.equal(isPreviewPath('id__0123456789abcdef0123456789abcdef01234567.avif'), true); + assert.equal(isPreviewPath('id__0123456789abcdef0123456789abcdef01234567.webp'), true); + assert.equal(isPreviewPath('id.jpg'), false); + assert.equal(isPreviewPath('state.jsonl'), false); +}); + +test('isStatePath detects the state directory', () => { + assert.equal(isStatePath('.image-previews/settings.json'), true); + assert.equal(isStatePath('.image-previews'), true); + assert.equal(isStatePath('abc.jpg'), false); +}); + +test('storageUsage splits previews and originals, excluding state', async () => { + const dir = await mkdtemp(join(tmpdir(), 'previews-usage-')); + + try { + await writeFile(join(dir, 'a__0123456789abcdef0123456789abcdef01234567.avif'), 'x'.repeat(10)); + await writeFile(join(dir, 'a.jpg'), 'y'.repeat(99)); + await mkdir(join(dir, '.image-previews')); + await writeFile(join(dir, '.image-previews', 'settings.json'), 'z'.repeat(500)); + + const usage = await storageUsage({ STORAGE_LOCAL_ROOT: dir, STORAGE_LOCATIONS: 'local' }); + + assert.equal(usage.source, 'local'); + assert.equal(usage.previews.count, 1); + assert.equal(usage.previews.bytes, 10); + assert.equal(usage.originals.count, 1); + assert.equal(usage.originals.bytes, 99); + assert.equal(usage.total.count, 2); + assert.equal(usage.total.bytes, 109); + } finally { + await rm(dir, { recursive: true, force: true }); + } +}); diff --git a/src/lib/storage.ts b/src/lib/storage.ts new file mode 100644 index 0000000..c429c2d --- /dev/null +++ b/src/lib/storage.ts @@ -0,0 +1,162 @@ +import { readdir, stat as fsStat } from 'node:fs/promises'; +import { isAbsolute, join } from 'node:path'; +import type { EnvLike } from './settings'; + +const PREVIEW_PATTERN = /__[0-9a-f]{8,}\.[a-z0-9]+$/i; +const STATE_DIR_NAME = '.image-previews'; + +function asString(value: unknown): string | null { + if (value === undefined || value === null) return null; + if (typeof value === 'string') return value; + if (typeof value === 'number' || typeof value === 'boolean') return String(value); + return null; +} + +export function isPreviewPath(path: string): boolean { + return PREVIEW_PATTERN.test(path); +} + +export function isStatePath(path: string): boolean { + return path === STATE_DIR_NAME || path.startsWith(`${STATE_DIR_NAME}/`) || path.includes(`/${STATE_DIR_NAME}/`); +} + +async function loadStorageManager(): Promise | null> { + try { + const importer = new Function('return import("@directus/api/storage/index")') as () => Promise>; + const module = await importer(); + const getStorage = module['getStorage'] as (() => Promise>) | undefined; + if (!getStorage) return null; + return await getStorage(); + } catch { + return null; + } +} + +function localStorageRoot(env: EnvLike): string { + const root = asString(env['STORAGE_LOCAL_ROOT']) || './uploads'; + return isAbsolute(root) ? root : join(process.cwd(), root); +} + +export interface Bucket { + bytes: number; + count: number; +} + +export interface StorageUsage { + previews: Bucket; + originals: Bucket; + total: Bucket; + source: 'storage' | 'local'; +} + +function emptyUsage(source: 'storage' | 'local'): StorageUsage { + return { + previews: { bytes: 0, count: 0 }, + originals: { bytes: 0, count: 0 }, + total: { bytes: 0, count: 0 }, + source, + }; +} + +function add(usage: StorageUsage, path: string, size: number): void { + if (isPreviewPath(path)) { + usage.previews.bytes += size; + usage.previews.count += 1; + } else { + usage.originals.bytes += size; + usage.originals.count += 1; + } + + usage.total.bytes += size; + usage.total.count += 1; +} + +async function walkLocal(root: string, usage: StorageUsage): Promise { + let entries; + + try { + entries = await readdir(root, { withFileTypes: true }); + } catch { + return; + } + + for (const entry of entries) { + const full = join(root, entry.name); + + if (entry.isDirectory()) { + if (entry.name === STATE_DIR_NAME) continue; + await walkLocal(full, usage); + continue; + } + + if (!entry.isFile()) continue; + + try { + const info = await fsStat(full); + add(usage, entry.name, info.size); + } catch { + continue; + } + } +} + +export async function storageUsage(env: EnvLike): Promise { + const manager = await loadStorageManager(); + + if (manager) { + const usage = emptyUsage('storage'); + + const locations = (asString(env['STORAGE_LOCATIONS']) || 'local') + .split(',') + .map((part) => part.trim()) + .filter(Boolean); + + for (const location of locations) { + try { + const driver = (manager['location'] as (name: string) => Record)(location); + const list = (driver['list'] as () => AsyncIterable)(); + + for await (const path of list) { + if (isStatePath(path)) continue; + + try { + const info = (await (driver['stat'] as (p: string) => Promise<{ size: number }>)(path)) as { + size: number; + }; + add(usage, path, Number(info?.size) || 0); + } catch { + continue; + } + } + } catch { + continue; + } + } + + return usage; + } + + const usage = emptyUsage('local'); + await walkLocal(localStorageRoot(env), usage); + return usage; +} + +export async function previewExists(env: EnvLike, location: string | null, filename: string): Promise { + const manager = await loadStorageManager(); + + if (manager && location) { + try { + const driver = (manager['location'] as (name: string) => Record)(location); + return await (driver['exists'] as (p: string) => Promise)(filename); + } catch { + return null; + } + } + + try { + await fsStat(join(localStorageRoot(env), filename)); + return true; + } catch { + return false; + } +} diff --git a/src/lib/system-presets.ts b/src/lib/system-presets.ts new file mode 100644 index 0000000..4f63ecf --- /dev/null +++ b/src/lib/system-presets.ts @@ -0,0 +1,36 @@ +import type { Preset } from './types'; + +export const SYSTEM_PRESETS: Preset[] = [ + { + key: 'system-small-cover', + format: 'auto', + transforms: [ [ 'resize', { width: 64, height: 64, fit: 'cover' } ] ], + }, + { + key: 'system-small-contain', + format: 'auto', + transforms: [ [ 'resize', { width: 64, fit: 'contain' } ] ], + }, + { + key: 'system-medium-cover', + format: 'auto', + transforms: [ [ 'resize', { width: 300, height: 300, fit: 'cover' } ] ], + }, + { + key: 'system-medium-contain', + format: 'auto', + transforms: [ [ 'resize', { width: 300, fit: 'contain' } ] ], + }, + { + key: 'system-large-cover', + format: 'auto', + transforms: [ [ 'resize', { width: 800, height: 800, fit: 'cover' } ] ], + }, + { + key: 'system-large-contain', + format: 'auto', + transforms: [ [ 'resize', { width: 800, fit: 'contain' } ] ], + }, +]; + +export const DEFAULT_FORMATS = [ 'avif', 'webp' ]; diff --git a/src/lib/types.ts b/src/lib/types.ts new file mode 100644 index 0000000..fe47c3c --- /dev/null +++ b/src/lib/types.ts @@ -0,0 +1,50 @@ +export interface Preset { + key: string; + format?: string; + quality?: number | string; + width?: number | string; + height?: number | string; + fit?: string; + withoutEnlargement?: boolean; + focal_point_x?: number | string | null; + focal_point_y?: number | string | null; + transforms?: unknown[]; + [key: string]: unknown; +} + +export interface WarmResultItem { + key: string; + format: string | null; + ok: boolean; + ms: number; + error?: string; +} + +export interface WarmSummary { + requested: number; + ok: number; + failed: number; + results: WarmResultItem[]; +} + +export interface CompletedRecord { + file_id: string; + preset_key: string; + format: string | null; + ts: number; +} + +export interface RunState { + running: boolean; + startedAt: number | null; + finishedAt: number | null; + total: number; + done: number; + generated: number; + hits: number; + failed: number; + rate: number; + eta: number | null; + cancelled: boolean; + error?: string; +} diff --git a/src/lib/warmer.test.ts b/src/lib/warmer.test.ts new file mode 100644 index 0000000..a6240cd --- /dev/null +++ b/src/lib/warmer.test.ts @@ -0,0 +1,92 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import type { Preset } from './types'; +import { warmFile, type AssetsLike } from './warmer'; + +const presets: Preset[] = [ + { key: 'system-small-cover', format: 'auto', transforms: [ [ 'resize', { width: 64, height: 64, fit: 'cover' } ] ] }, + { key: 'custom-fixed', format: 'webp', width: 200 }, +]; + +test('warmFile passes the full preset object and the accept variant', async () => { + const calls: Array> = []; + + const assets: AssetsLike = { + async getAsset(_id, transformation) { + calls.push(transformation ?? {}); + return { stream: { destroy() {} } }; + }, + }; + + const summary = await warmFile(assets, 'file-1', presets, { concurrency: 1, formats: [ 'avif', 'webp' ] }); + + assert.equal(summary.requested, 3); + assert.equal(summary.ok, 3); + assert.equal(calls.length, 3); + + const autoCalls = calls.filter((call) => (call['transformationParams'] as Preset).key === 'system-small-cover'); + assert.equal(autoCalls.length, 2); + assert.deepEqual( + autoCalls.map((call) => call['acceptFormat']).sort(), + [ 'avif', 'webp' ], + ); + assert.ok((autoCalls[0]?.['transformationParams'] as Preset).transforms); + + const fixed = calls.find((call) => (call['transformationParams'] as Preset).key === 'custom-fixed'); + assert.equal(fixed?.['acceptFormat'], undefined); +}); + +test('warmFile isolates per-task errors', async () => { + const assets: AssetsLike = { + async getAsset(_id, transformation) { + const preset = transformation?.['transformationParams'] as Preset; + if (preset.key === 'custom-fixed') throw new Error('boom'); + return { stream: { destroy() {} } }; + }, + }; + + const summary = await warmFile(assets, 'file-1', presets, { concurrency: 1, formats: [ 'avif', 'webp' ] }); + + assert.equal(summary.ok, 2); + assert.equal(summary.failed, 1); + assert.equal(summary.results.find((result) => result.key === 'custom-fixed')?.error, 'boom'); +}); + +test('warmFile respects the concurrency cap', async () => { + let active = 0; + let maxActive = 0; + + const assets: AssetsLike = { + async getAsset() { + active += 1; + maxActive = Math.max(maxActive, active); + await new Promise((resolve) => setTimeout(resolve, 10)); + active -= 1; + return { stream: { destroy() {} } }; + }, + }; + + await warmFile(assets, 'file-1', presets, { concurrency: 2, formats: [ 'avif', 'webp' ] }); + + assert.ok(maxActive <= 2, `maxActive=${maxActive}`); +}); + +test('warmFile releases the returned stream', async () => { + let destroyed = 0; + + const assets: AssetsLike = { + async getAsset() { + return { + stream: { + destroy() { + destroyed += 1; + }, + }, + }; + }, + }; + + await warmFile(assets, 'file-1', [ presets[0] as Preset ], { concurrency: 1, formats: [ 'avif' ] }); + + assert.equal(destroyed, 1); +}); diff --git a/src/lib/warmer.ts b/src/lib/warmer.ts new file mode 100644 index 0000000..89af8b1 --- /dev/null +++ b/src/lib/warmer.ts @@ -0,0 +1,110 @@ +import { effectiveFormat, formatsForPreset } from './presets'; +import type { Preset, WarmResultItem, WarmSummary } from './types'; + +export interface AssetsLike { + getAsset( + id: string, + transformation?: Record, + range?: unknown, + deferStream?: boolean, + ): Promise<{ stream?: unknown }>; +} + +export interface WarmOptions { + concurrency: number; + formats: string[]; + onResult?: (result: WarmResultItem) => void; +} + +interface WarmTask { + preset: Preset; + format: string | null; +} + +export function errorMessage(error: unknown): string { + if (error instanceof Error) return error.message; + if (typeof error === 'string') return error; + + try { + return JSON.stringify(error); + } catch { + return String(error); + } +} + +function releaseStream(stream: unknown): void { + const candidate = stream as { destroy?: () => void; unpipe?: () => void } | undefined; + + if (candidate && typeof candidate.destroy === 'function') { + candidate.destroy(); + } else if (candidate && typeof candidate.unpipe === 'function') { + candidate.unpipe(); + } +} + +export async function warmFile( + assets: AssetsLike, + fileId: string, + presets: Preset[], + options: WarmOptions, +): Promise { + const tasks: WarmTask[] = []; + + for (const preset of presets) { + for (const format of formatsForPreset(preset, options.formats)) { + tasks.push({ preset, format }); + } + } + + const results: WarmResultItem[] = new Array(tasks.length); + let cursor = 0; + + const workerCount = Math.max(1, Math.min(options.concurrency, tasks.length || 1)); + + const workers = Array.from({ length: workerCount }, async () => { + while (cursor < tasks.length) { + const index = cursor; + cursor += 1; + const task = tasks[index]; + + if (!task) break; + + const transformation: Record = { transformationParams: task.preset }; + + if (task.format) transformation['acceptFormat'] = task.format; + + const started = Date.now(); + const outputFormat = effectiveFormat(task.preset, task.format); + let result: WarmResultItem; + + try { + const asset = await assets.getAsset(fileId, transformation); + releaseStream(asset?.stream); + result = { key: task.preset.key, format: outputFormat, ok: true, ms: Date.now() - started }; + } catch (error) { + result = { + key: task.preset.key, + format: outputFormat, + ok: false, + ms: Date.now() - started, + error: errorMessage(error), + }; + } + + results[index] = result; + options.onResult?.(result); + } + }); + + await Promise.all(workers); + + const settled = results.filter((result): result is WarmResultItem => Boolean(result)); + const ok = settled.filter((result) => result.ok).length; + + return { + requested: tasks.length, + ok, + failed: settled.length - ok, + results: settled, + }; +} diff --git a/src/lib/window.test.ts b/src/lib/window.test.ts new file mode 100644 index 0000000..d0c667a --- /dev/null +++ b/src/lib/window.test.ts @@ -0,0 +1,47 @@ +import assert from 'node:assert/strict'; +import { test } from 'node:test'; +import { isInWindow, nextWindow, parseMinutes } from './window'; + +function at(hours: number, minutes: number): Date { + return new Date(2026, 9, 25, hours, minutes, 0, 0); +} + +test('parseMinutes parses HH:MM', () => { + assert.equal(parseMinutes('00:00'), 0); + assert.equal(parseMinutes('03:30'), 210); + assert.equal(parseMinutes('23:59'), 1439); + assert.equal(parseMinutes(null), null); + assert.equal(parseMinutes('bad'), null); +}); + +test('no window means always inside', () => { + assert.equal(isInWindow(null, null, at(12, 0)), true); + assert.equal(isInWindow('03:00', null, at(12, 0)), true); +}); + +test('daytime window', () => { + assert.equal(isInWindow('03:00', '05:00', at(2, 59)), false); + assert.equal(isInWindow('03:00', '05:00', at(3, 0)), true); + assert.equal(isInWindow('03:00', '05:00', at(4, 59)), true); + assert.equal(isInWindow('03:00', '05:00', at(5, 0)), false); +}); + +test('overnight window', () => { + assert.equal(isInWindow('23:00', '02:00', at(23, 30)), true); + assert.equal(isInWindow('23:00', '02:00', at(1, 30)), true); + assert.equal(isInWindow('23:00', '02:00', at(12, 0)), false); +}); + +test('nextWindow returns the upcoming start', () => { + const next = nextWindow('03:00', '05:00', at(12, 0)); + assert.ok(next); + assert.equal(next?.getDate(), 26); + assert.equal(next?.getHours(), 3); +}); + +test('nextWindow today when still before the start', () => { + const next = nextWindow('03:00', '05:00', at(1, 0)); + assert.ok(next); + assert.equal(next?.getDate(), 25); + assert.equal(next?.getHours(), 3); +}); diff --git a/src/lib/window.ts b/src/lib/window.ts new file mode 100644 index 0000000..d1e48cd --- /dev/null +++ b/src/lib/window.ts @@ -0,0 +1,32 @@ +export function parseMinutes(value: string | null): number | null { + if (value === null) return null; + const match = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(value); + if (!match) return null; + return Number(match[1]) * 60 + Number(match[2]); +} + +export function isInWindow(start: string | null, end: string | null, now: Date = new Date()): boolean { + const from = parseMinutes(start); + const to = parseMinutes(end); + + if (from === null || to === null) return true; + if (from === to) return true; + + const current = now.getHours() * 60 + now.getMinutes(); + + if (from < to) return current >= from && current < to; + + return current >= from || current < to; +} + +export function nextWindow(start: string | null, end: string | null, now: Date = new Date()): Date | null { + const from = parseMinutes(start); + if (from === null || parseMinutes(end) === null) return null; + + const next = new Date(now); + next.setHours(Math.floor(from / 60), from % 60, 0, 0); + + if (next.getTime() <= now.getTime()) next.setDate(next.getDate() + 1); + + return next; +} diff --git a/src/module/index.ts b/src/module/index.ts new file mode 100644 index 0000000..393da38 --- /dev/null +++ b/src/module/index.ts @@ -0,0 +1,14 @@ +import { defineModule } from '@directus/extensions-sdk'; +import ModuleComponent from './module.vue'; + +export default defineModule({ + id: 'image-previews', + name: 'Image Previews', + icon: 'image', + routes: [ + { + path: '', + component: ModuleComponent, + }, + ], +}); diff --git a/src/module/module.vue b/src/module/module.vue new file mode 100644 index 0000000..7e35517 --- /dev/null +++ b/src/module/module.vue @@ -0,0 +1,579 @@ + + + + + diff --git a/src/shims.d.ts b/src/shims.d.ts new file mode 100644 index 0000000..7e7372c --- /dev/null +++ b/src/shims.d.ts @@ -0,0 +1,11 @@ +declare module '*.vue' { + import type { DefineComponent } from 'vue'; + + const component: DefineComponent<{}, {}, any>; + export default component; +} + +declare module 'object-hash' { + const hash: (value: unknown) => string; + export default hash; +} diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..64735af --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,28 @@ +{ + "compilerOptions": { + "target": "ES2019", + "lib": ["ES2019", "DOM"], + "moduleResolution": "node", + "strict": true, + "noFallthroughCasesInSwitch": true, + "esModuleInterop": true, + "noImplicitAny": true, + "noImplicitThis": true, + "noImplicitReturns": true, + "noUnusedLocals": true, + "noUncheckedIndexedAccess": true, + "noUnusedParameters": true, + "alwaysStrict": true, + "strictNullChecks": true, + "strictFunctionTypes": true, + "strictBindCallApply": true, + "strictPropertyInitialization": true, + "resolveJsonModule": false, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "allowSyntheticDefaultImports": true, + "isolatedModules": true, + "rootDir": "./src" + }, + "include": ["./src/**/*.ts"] +}