@juangadm/pre-post 0.3.0 → 1.1.0

package/README.md

@@ -1,272 +1,213 @@
 # pre-post
 
-Visual diff tool that captures pre/post screenshots for PRs. Use it as a Claude Code skill for automatic visual documentation, or run it directly from the CLI.
-
-> Originally forked from [before-and-after](https://github.com/vercel-labs/before-and-after) by [James Clements](https://github.com/jamesclement) / Vercel Labs.
-
-## What Changed from the Original
-
-| Area | before-and-after | pre-post |
-|------|-----------------|----------|
-| Browser engine | `agent-browser` (Vercel-proprietary) | **Playwright** (direct dependency) |
-| Screenshot quality | 1x | **2x retina** (`deviceScaleFactor: 2`) |
-| Route detection | Manual | **Automatic** from `git diff` (Next.js App/Pages Router, generic fallback) |
-| Responsive capture | Single viewport | **Desktop + mobile** per route (`--responsive`) |
-| CLI subcommands | URL pairs only | `detect`, `compare`, `run` subcommands |
-| Skill orchestration | Basic capture | Full workflow: route detection, Claude refinement, user approval, PR posting |
-| Font/animation handling | None | Waits for `document.fonts.ready`, disables CSS animations |
-
-## How It Works
-
-```mermaid
-flowchart TD
-    A[pre-post] --> B{Mode?}
-
-    B -->|Manual| C["pre-post url1 url2"]
-    B -->|Subcommand| D{"detect | compare | run"}
-    B -->|Claude Code Skill| E["/pre-post"]
-
-    D -->|detect| F["Git: diff, staged, unstaged, untracked"]
-    D -->|compare| J
-    D -->|run| F
-
-    F --> G{Detect framework}
-    G -->|Next.js App Router| H[Map files → routes]
-    G -->|Next.js Pages Router| H
-    G -->|Generic| H
-    H --> I{Routes found?}
-    I -->|Yes| J[Route list with confidence]
-    I -->|No| J2["Default to /"]
-    J2 --> J
-
-    E --> E1[Pre-flight checks]
-    E1 --> F
-    E1 --> K[Claude refines routes]
-    K --> K1[User approves routes]
-    K1 --> J
-
-    C --> L[Playwright]
-    J --> L
-
-    L --> M{Launch Chromium}
-    M -->|"PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH"| M1[Custom path — fail hard if invalid]
-    M -->|Auto-detect| M2[System Chrome → Bundled → Cached]
-    M1 --> P[Navigate + wait for network idle]
-    M2 --> P
-
-    P --> Q[Disable CSS animations]
-    Q --> R[Wait for document.fonts.ready]
-    R --> S[Take 2x retina screenshot]
-
-    S --> T[Save to ~/Downloads]
-    T --> T1{--markdown?}
-    T1 -->|No| U[Done]
-    T1 -->|Yes| V{Upload method}
-    V -->|Default| W["git-native: commit to .pre-post/"]
-    V -->|--upload-url| Y["HTTP: 0x0.st / Vercel Blob / PUT"]
-    W --> X[Build blob+SHA URL]
-    Y --> X
-    X --> Z[Markdown table]
-
-    Z --> Z1{Skill mode?}
-    Z1 -->|Yes| Z2[User approves screenshots]
-    Z2 --> Z3["gh pr edit — append to PR body"]
-    Z1 -->|No| Z4[Copy to clipboard]
-
-    style A fill:#4f46e5,color:#fff
-    style L fill:#2563eb,color:#fff
-    style S fill:#059669,color:#fff
-```
-
-## Prerequisites
-
-- **Node.js** 18+
-- **Chromium** — install once via Playwright:
-
-```bash
-npx playwright install chromium
-```
-
-## CI / Sandboxed Environments
-
-pre-post needs a Chromium binary. In restricted environments where `npx playwright install chromium` fails (CDN blocked):
-
-```bash
-# Point to a pre-installed Chrome/Chromium binary
-export PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH=/path/to/chrome
-
-# This is treated as an explicit override — pre-post will fail with a
-# clear error if the path is wrong, rather than silently falling back.
-```
+Before/after screenshots for pull requests. One command detects the routes your branch
+changed, captures each one before and after, uploads the images to GitHub, and puts them at
+the top of the PR description where a reviewer can judge them at a glance.
 
-When no custom path is set, pre-post auto-detects in order: system Chrome, bundled Playwright Chromium, then any builds in `~/.cache/ms-playwright/`.
+It works out both sides itself, cheapest option first:
 
-If no browser is available at all, use image-only mode:
-
-```bash
-pre-post before.png after.png --markdown
-```
-
-**Proxy URLs**: If your git remote uses a proxy (e.g., `http://proxy@host/git/owner/repo`), set the repo explicitly:
-
-```bash
-export GH_REPO=owner/repo
-```
-
-**Google Fonts**: Container egress proxies typically block `fonts.googleapis.com`.
-Screenshots will render with system font fallbacks. This is cosmetic only —
-`document.fonts.ready` still resolves and layout is preserved.
+| | Pre (the baseline) | Post (this branch) |
+|---|---|---|
+| 1 | `--before` | `--after` |
+| 2 | `before` in `.pre-post.json` | the preview deployment for this commit |
+| 3 | the production deployment for the base commit | a local dev server |
+| 4 | whatever is on production now | |
+| 5 | the base commit, served locally | |
+
+Rows 2 to 4 need no dev environment at all, which is the point: a preview deployment and a
+production URL are enough for anyone who can open the PR. Deployments come from the GitHub
+Deployments API, so Vercel, Cloudflare Pages, Netlify and Render all work with no extra
+token and nothing to configure; a host that records only a commit status is read from the
+deployment bot's own PR comment instead. Row 4 covers repositories that do not deploy every
+push to their default branch, so nothing is deployed at the fork point — it prints which
+commit Pre actually came from rather than implying the base.
+
+pre-post never guesses a baseline. If no deployment can be found it says so and tells you
+the one flag that fixes it, because a baseline that is quietly the wrong site reads as 100%
+changed on every route and looks exactly like a real result.
+
+The last baseline needs no network at all: it checks the base commit into a throwaway
+worktree and boots its dev script. That keeps pre-post working inside a sandboxed agent
+container, a CI job, or behind an egress allowlist — and it compares against exactly what
+the branch forked from, rendered in the same browser as the Post side.
+
+> Originally forked from [before-and-after](https://github.com/vercel-labs/before-and-after) by James Clements / Vercel Labs.
+
+```
+$ npx -y @juangadm/pre-post@latest pr
+
+Routes (nextjs-app, 41ms): /, /pricing
+  /                           medium src/app/page.tsx imports src/components/ui/button.tsx (2 hops)
+  /pricing                    medium src/app/pricing/page.tsx imports src/components/ui/button.tsx (2 hops)
+Capturing 8 screenshots (2 route(s) × 2 viewport(s)) ...
+  changed  /pricing @ mobile (1.42%, 1811ms)
+  changed  /pricing @ desktop (0.64%, 2036ms)
+  same     / @ mobile (0.00%, 1990ms)
+  same     / @ desktop (0.00%, 2211ms)
+Publishing 10 image(s) to acme/web@pre-post-assets ...
+Updated PR description: https://github.com/acme/web/pull/42
+pre-post · PR #42 · 2 route(s) · 2 viewport(s) · 6.8s
+  /         desktop  no change
+  /         mobile   no change
+  /pricing  desktop  0.64% changed
+  /pricing  mobile   1.4% changed
+Comment: https://github.com/acme/web/pull/42
+```
+
+## How it works
+
+1. **Routes.** Diffs the branch against the merge base with `main` — fetching that branch
+   first when the checkout does not have it, which is the normal shape in CI and in the
+   web/sandbox editors. When no shared history can be established it stops with one
+   sentence rather than reporting an empty diff, and `--base <ref>` names the commit
+   directly. Then it follows the import
+   graph: a change to `components/ui/button.tsx` marks every page that imports it. Next.js
+   App Router and Pages Router, Vite apps (React Router, file-based `src/pages`), and a
+   generic fallback. Monorepos are handled by picking the app that owns the changed files.
+2. **Capture.** Playwright + Chromium headless shell. The page's own clock is held
+   still while it loads and then run forward by a fixed budget, so a page that animates
+   on a timer is photographed at the same frame on both sides however fast each host
+   answered. Reduced motion, animations finished, caret hidden, fonts and images settled,
+   layout stable, lazy content primed. 2x device scale, full page (capped at 2400 CSS
+   px), desktop (add mobile with `-r`).
+   All routes and viewports run concurrently.
+3. **Diff.** Pure-JS pixel comparison in worker threads. Reports the percentage changed,
+   the bounding box, and a tight crop of the changed region. A route counts as changed when
+   the painted difference covers at least `minChangedArea` CSS pixels² (default 100, roughly
+   a third of a 16px icon) or at least `threshold` of the canvas — the first rule is what
+   decides on a page, the second on a small image.
+4. **Layout shift.** A padding change near the top of a page moves everything below it, and
+   pixel diffing counts every moved pixel as changed: a change a designer would call
+   "slightly roomier" reads as most of the page repainted, and the crop is suppressed just
+   when it would be most useful. So the two sides are checked for a single vertical offset
+   first — how far the content moved, and from which row. When one is found, Pre is re-spaced
+   into Post's layout and the two are compared there: the crop comes from that pair, and the
+   comment says `Content shifted down 48px` instead of quoting a percentage. Rows Post gained
+   are left as background rather than skipped, so content inserted above the shift — the
+   banner that caused it — still reads as new rather than as nothing. The offset is only
+   accepted when it accounts for most of the difference across the rows both sides share.
+   The raw numbers are left alone: a move is a visual change, and reporting less of one would
+   hide it. Reflow, where content moves both across and down, has no single offset to find,
+   so it is reported the way it always was.
+5. **Publish.** Images go to a `pre-post-assets` branch in the same repository via the GitHub
+   API, as one commit per run. Nothing is committed to the PR branch, no CI is triggered,
+   and the blob URLs render on private repos — a screenshot is visible to exactly whoever
+   can see the repository. `pre-post prune` removes images for PRs closed more than 90 days
+   ago, but note that it commits a deletion rather than rewriting history: the older commits
+   still hold the blobs, so a link handed out earlier keeps working. Treat anything captured
+   as permanent, and think twice before pointing pre-post at a preview holding real data.
+6. **Describe.** The images go in a delimited block at the top of the PR description,
+   replaced in place on every run and leaving your own text untouched. Changed routes show
+   a Pre/Post crop with the full page collapsed underneath; unchanged routes fold into a
+   single line. If the PR cannot be edited — a fork, a read-only token — it falls back to
+   one sticky comment.
 
 ## Install
 
-```bash
-npm install -D @juangadm/pre-post
-```
-
-## Basic Use
-
-### As a Claude Code Skill (recommended)
-
-After making visual UI changes, say `/pre-post` or "take pre and post screenshots". Claude will:
-
-1. Detect affected routes from your git diff
-2. Propose routes for your approval
-3. Capture desktop + mobile screenshots (production vs localhost)
-4. Show you the screenshots for approval
-5. Upload and append markdown to your PR
+Nothing to install. `npx -y @juangadm/pre-post@latest pr` downloads the CLI and, on first
+use, the Chromium headless shell (~80 MB). You need Node 20+ and a GitHub token: either
+`gh auth login` or `GH_TOKEN`.
 
-### From the CLI
-
-Capture any two URLs:
-
-```bash
-pre-post site.com localhost:3000
-```
-
-Use existing images:
+As a Claude Code skill:
 
 ```bash
-pre-post before.png after.png
+npx skills add juangadm/pre-post -y
 ```
 
-## CLI Subcommands
-
-### `detect` -- Route Detection
+Then say `/pre-post` after making UI changes.
 
-Detect affected routes from git changes:
+## Usage
 
 ```bash
-pre-post detect                        # Auto-detect framework
-pre-post detect --framework nextjs-app  # Force framework
-```
-
-Outputs JSON with route paths, confidence levels, and source files.
+pre-post pr                                  # everything, on the current branch's PR
+pre-post pr --before https://acme.com        # pin the baseline (saved to .pre-post.json)
+pre-post pr --no-local-baseline              # never build the base commit locally
+pre-post pr --routes /pricing,/docs          # explicit routes
+pre-post pr --viewports desktop,1440x900     # custom viewports
+pre-post pr --dry-run                        # capture + diff locally, post nothing
+pre-post pr --json                           # machine-readable output
 
-### `compare` -- URL Comparison
-
-Compare pre/post states across routes:
-
-```bash
-pre-post compare --before-base https://prod.com --after-base http://localhost:3000
-pre-post compare --before-base URL --after-base URL --routes /dashboard,/settings
-pre-post compare --before-base URL --after-base URL --responsive  # Desktop + mobile
+pre-post https://acme.com http://localhost:3000 --routes /pricing   # ad-hoc comparison
+pre-post before.png after.png                # diff two images
+pre-post detect                              # which routes does this branch touch?
+pre-post login https://staging.acme.com      # sign in once; the session is reused
+pre-post prune --days 90                     # clean up the assets branch
+pre-post doctor                              # browser, token, dev server, config
 ```
 
-### `run` -- Full Auto
+When something needs a human, the CLI exits with code 3 and one sentence saying what to do
+(log in, start the dev server, pass `--before`). Re-running picks up where it left off.
 
-Combines `detect` + `compare`:
+Exit codes, so a script or an agent can branch on them:
 
-```bash
-pre-post run --before-base https://prod.com --after-base http://localhost:3000
-```
+| code | meaning |
+|---|---|
+| 0 | done; for `doctor`, `pre-post pr` can run |
+| 1 | the run failed — every capture errored, or an unexpected error; for `doctor`, a required check failed |
+| 2 | the arguments could not be parsed |
+| 3 | something needs a human; the message says what |
 
-## Options
-
-Capture a specific element using a CSS selector:
-
-```bash
-pre-post url1 url2 ".hero"
-```
-
-Use different selectors for pre and post:
-
-```bash
-pre-post url1 url2 ".old" ".new"
-```
-
-Capture at mobile (375x812), tablet (768x1024), or custom viewport:
-
-```bash
-pre-post url1 url2 --mobile
-pre-post url1 url2 --size 1920x1080
-```
+`doctor` marks a check **FAIL** only when `pre-post pr` has no way to proceed without it —
+the browser, a GitHub token, and being inside a git repository. Everything else prints as
+**note**: no dev server running, or no `--before` saved, narrows *which* strategy a run
+picks rather than stopping it, so those never change the exit code.
 
-Capture the entire scrollable page:
+Results go into a delimited block at the top of the PR description, which re-runs replace in
+place, leaving your own text untouched. If the PR cannot be edited — a fork, a read-only
+token — it falls back to a single sticky comment.
 
-```bash
-pre-post url1 url2 --full
-```
+## Configuration
 
-Output a markdown table for PR descriptions:
+Optional `.pre-post.json` in the repo root:
 
-```bash
-pre-post url1 url2 --markdown
+```json
+{
+  "before": "https://acme.com",
+  "routes": ["/"],
+  "samples": { "/blog/[slug]": "/blog/hello-world" },
+  "viewports": ["desktop"],
+  "fullPage": true,
+  "maxHeight": 2400,
+  "scale": 2,
+  "threshold": 0.001,
+  "minChangedArea": 100,
+  "maxRoutes": 6,
+  "ignore": ["apps/docs"],
+  "headers": {},
+  "assetsBranch": "pre-post-assets"
+}
 ```
 
-Save to a custom location:
+Environment:
 
-```bash
-pre-post url1 url2 --output ./screenshots
-```
+| Variable | Purpose |
+|---|---|
+| `GH_TOKEN` / `GITHUB_TOKEN` | GitHub token (default: `gh auth token`) |
+| `VERCEL_AUTOMATION_BYPASS_SECRET` | Bypass Vercel Deployment Protection on preview and production URLs |
+| `PRE_POST_CONCURRENCY` | Parallel pages (default 6) |
+| `PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH` | Use a specific Chromium binary |
+| `GH_REPO` | `owner/repo` when the remote URL cannot be parsed |
 
-Upload to a custom image storage service:
+## Library
 
-```bash
-pre-post url1 url2 --markdown --upload-url https://my-s3-bucket.amazonaws.com
+```ts
+import { runPr, captureScreenshot, diffImages, detectRoutesForRepo } from '@juangadm/pre-post';
 ```
 
-By default, `--markdown` commits screenshots to the PR branch (under `.pre-post/`) and serves them via GitHub blob URLs pinned to the commit SHA. This works for both public and private repos. Use `--upload-url` to point at your own storage instead. It auto-detects the protocol for 0x0.st, Vercel Blob, and any generic PUT endpoint (like S3). Screenshots auto-append to the PR body, newest on top.
-
-## Route Detection
-
-Pre-post automatically maps `git diff --name-only` to affected UI routes:
-
-| Changed File | Detected Route | Confidence |
-|---|---|---|
-| `app/page.tsx` | `/` | high |
-| `app/dashboard/page.tsx` | `/dashboard` | high |
-| `app/(marketing)/about/page.tsx` | `/about` (strips route groups) | high |
-| `app/blog/[slug]/page.tsx` | `/blog/[slug]` | high |
-| `app/dashboard/layout.tsx` | `/dashboard` | medium |
-| `app/dashboard/components/Chart.tsx` | `/dashboard` | medium |
-| `globals.css`, `tailwind.config.ts` | `/` | low |
-| `app/api/*`, `middleware.ts` | Skipped (no visual) | -- |
-
-Supports:
-- **Next.js App Router** (route groups, dynamic segments, parallel routes, catch-all)
-- **Next.js Pages Router** (`pages/`, `_app.tsx`, `_document.tsx`)
-- **Generic fallback** (defaults to `/`)
-
-## Add Skill
-
-Install as an agent skill using the [`skills` CLI](https://github.com/vercel-labs/skills):
+## Development
 
 ```bash
-npx skills add juangadm/pre-post          # interactive — pick your agent(s)
-npx skills add juangadm/pre-post -y       # auto-install to all universal agents
-npx skills add juangadm/pre-post -y -g    # install globally (all projects)
+pnpm install
+pnpm build
+pnpm test:unit
+TEST_BROWSER=true pnpm test        # needs a Chromium; npx playwright-core install chromium-headless-shell
 ```
 
-This copies `skill/SKILL.md` into the appropriate directory for your agent (e.g., `.claude/skills/` for Claude Code, `.agents/skills/` for Amp/Codex/Gemini CLI, etc.).
-
-The skill uses `gh` to detect the associated PR and Playwright for screenshots.
-
-> **Note:** The npm package (`@juangadm/pre-post`) is published on [npmjs.com](https://www.npmjs.com/package/@juangadm/pre-post), not GitHub Packages — so the "Packages" section on the GitHub repo page will show none.
-
-## Credits
-
-- Original [before-and-after](https://github.com/vercel-labs/before-and-after) by [James Clements](https://github.com/jamesclement) at [Vercel Labs](https://github.com/vercel-labs)
-- Browser automation powered by [Playwright](https://playwright.dev/)
+pnpm and npm cannot share a `node_modules`. pnpm builds a symlinked tree that npm
+cannot read, so `npm install` over it fails with `Cannot read properties of null
+(reading 'edgesOut')`, which names none of that. Run `rm -rf node_modules
+site/node_modules` before switching either way. npm also installs the CLI only —
+`site/` is a pnpm workspace member, so use pnpm to work on the site.
 
 ## License
 

package/dist/baseline.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Serve the PR's base commit locally, as the "Pre" side.
+ *
+ * This is the baseline that always works: it needs no deployment, no
+ * production URL and no network, so it is what keeps pre-post usable inside a
+ * sandbox — a cloud agent container, a CI job, or any box behind an egress
+ * allowlist. It is also the most honest comparison available, because both
+ * sides then render in the same environment with the same fonts and the same
+ * browser, leaving the diff as the only variable.
+ *
+ * The cost is time: a checkout, an install and a dev-server boot. So callers
+ * reach for it after a reachable deployment, not before one.
+ */
+export interface LocalBaseline {
+    url: string;
+    /** Stop the dev server and delete the worktree. Safe to call twice. */
+    stop: () => Promise<void>;
+}
+interface PackageManager {
+    bin: string;
+    install: string[];
+    /** Build `run <script>` argv, appending extra args the way this manager wants. */
+    run: (script: string, args: string[]) => string[];
+}
+/**
+ * Which package manager this tree *declares*, from its `packageManager` field
+ * or its lockfile. Defaults to npm.
+ *
+ * The field wins over the lockfile because it is the deliberate statement: a
+ * repository mid-migration can carry two lockfiles, but it names one manager.
+ */
+export declare function detectPackageManager(dir: string, repoRoot?: string): PackageManager;
+/**
+ * Is `bin` runnable here?
+ *
+ * A PATH scan rather than a `--version` subprocess: this answers before every
+ * local baseline, and spawning a process to learn that a process cannot be
+ * spawned is the wrong shape.
+ */
+export declare function onPath(bin: string, env?: NodeJS.ProcessEnv): boolean;
+export interface ManagerChoice {
+    /** The manager to run, or null when neither it nor npm is installed here. */
+    pm: PackageManager | null;
+    /** What the repository declares. Differs from `pm` when we fell back. */
+    declared: PackageManager;
+}
+/**
+ * The manager to actually run: what the repository declares, if it is installed.
+ *
+ * Declaring pnpm does not put pnpm on PATH. On a real machine it was not there,
+ * and the local baseline — the fallback that exists for when nothing is
+ * deployed — died on `pnpm install` with no hint that the missing piece was
+ * pnpm itself. The same shell could still build the CLI, so the tool ran while
+ * its last resort could not.
+ *
+ * npm ships with Node, so it is the fallback with the best odds of being
+ * present. It will not honour a pnpm or yarn lockfile, so the baseline it
+ * installs can drift from the locked versions — worth saying out loud, and
+ * still far better than no baseline at all.
+ */
+export declare function resolvePackageManager(dir: string, repoRoot?: string, has?: (bin: string) => boolean): ManagerChoice;
+/**
+ * The directory to actually serve.
+ *
+ * The app root is detected from the files a branch changed, which answers
+ * "which routes moved" — not "which package can be served". A PR touching only
+ * the CLI resolves to the repo root, which has no dev script even though the
+ * site next door does. So prefer the detected directory and otherwise take the
+ * nearest package that can start a server.
+ */
+export declare function servableDir(treeRoot: string, appPrefix?: string): {
+    dir: string;
+    script: string;
+} | null;
+/**
+ * Copy the working checkout's local env files into a throwaway worktree.
+ *
+ * .env files are gitignored, so a fresh worktree of the base commit has none.
+ * An app that needs one to boot then either never starts or serves an error
+ * page — and an error page diffed against the real branch reports a wall of
+ * changes the PR never made, which is worse than reporting no baseline at all.
+ *
+ * Only ever writes inside `to`, and returns names, never values: these files
+ * are exactly the ones that hold secrets.
+ */
+export declare function copyEnvFiles(from: string, to: string, appPrefix?: string): string[];
+/** An OS-assigned free port. */
+export declare function freePort(): Promise<number>;
+export interface BaselineOptions {
+    repoRoot: string;
+    /** Commit to serve. Omit to serve the working tree as it stands. */
+    sha?: string;
+    /** Directory holding the app's package.json, relative to the repo root. */
+    appPrefix?: string;
+    /** Budget for install + boot. */
+    timeoutMs?: number;
+    /** Injectable for tests; defaults to a real PATH scan. */
+    pathHas?: (bin: string) => boolean;
+    log?: (msg: string) => void;
+}
+/**
+ * Check out `sha` into a throwaway worktree, install, and start its dev server.
+ *
+ * Returns null when this repo cannot be served this way (no dev script, no
+ * install, server never came up). Callers treat that as "try the next option",
+ * so every failure path cleans up after itself and stays quiet.
+ */
+export declare function serveBaseCommit(opts: BaselineOptions): Promise<LocalBaseline | null>;
+/**
+ * Boot this repository's dev server without one already running.
+ *
+ * The working tree is what the author is looking at, uncommitted edits and all,
+ * so it is the honest "Post" when nothing is deployed. Serving it needs no
+ * worktree and usually no install, which is why it is cheaper than the base
+ * side it gets paired with.
+ */
+export declare function serveWorkingTree(opts: Omit<BaselineOptions, 'sha'>): Promise<LocalBaseline | null>;
+export {};
+//# sourceMappingURL=baseline.d.ts.map

package/dist/baseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline.d.ts","sourceRoot":"","sources":["../src/baseline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAUH,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,uEAAuE;IACvE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAGD,UAAU,cAAc;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,kFAAkF;IAClF,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;CACnD;AAgBD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,cAAc,CAUnF;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAUjF;AAED,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,EAAE,EAAE,cAAc,GAAG,IAAI,CAAC;IAC1B,yEAAyE;IACzE,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,MAAM,EACX,QAAQ,CAAC,EAAE,MAAM,EACjB,GAAG,GAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAgB,GACrC,aAAa,CAIf;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAUxG;AAKD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBnF;AAED,gCAAgC;AAChC,wBAAgB,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAS1C;AAgBD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iCAAiC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACnC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAE1F;AAED;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAExG"}