From 9923878c5c8b68df7f132efd28f76ce5478a1f1a Mon Sep 17 00:00:00 2001 From: Xe Iaso Date: Mon, 17 Mar 2025 19:33:07 -0400 Subject: [PATCH] initial import from /x/ monorepo Signed-off-by: Xe Iaso --- .github/workflows/go.yml | 62 + .gitignore | 2 + Brewfile | 3 + LICENSE | 19 + README.md | 300 ++ cmd/anubis/.gitignore | 2 + cmd/anubis/CHANGELOG.md | 5 + cmd/anubis/botPolicies.json | 70 + cmd/anubis/decaymap.go | 87 + cmd/anubis/decaymap_test.go | 31 + cmd/anubis/index.templ | 159 ++ cmd/anubis/index_templ.go | 215 ++ cmd/anubis/internal/config/config.go | 99 + cmd/anubis/internal/config/config_test.go | 168 ++ .../config/testdata/bad/badregexes.json | 14 + .../internal/config/testdata/bad/invalid.json | 5 + .../internal/config/testdata/bad/nobots.json | 1 + .../testdata/good/challengemozilla.json | 9 + .../testdata/good/everything_blocked.json | 10 + cmd/anubis/internal/dnsbl/dnsbl.go | 95 + cmd/anubis/internal/dnsbl/dnsbl_test.go | 55 + .../internal/dnsbl/droneblresponse_string.go | 54 + cmd/anubis/js/main.mjs | 71 + cmd/anubis/js/proof-of-work.mjs | 62 + cmd/anubis/js/video.mjs | 16 + cmd/anubis/main.go | 574 ++++ cmd/anubis/policy.go | 146 + cmd/anubis/policy_test.go | 65 + cmd/anubis/static/img/happy.webp | Bin 0 -> 60572 bytes cmd/anubis/static/img/pensive.webp | Bin 0 -> 49148 bytes cmd/anubis/static/img/sad.webp | Bin 0 -> 50802 bytes cmd/anubis/static/js/main.mjs | 2 + cmd/anubis/static/js/main.mjs.br | Bin 0 -> 802 bytes cmd/anubis/static/js/main.mjs.gz | Bin 0 -> 985 bytes cmd/anubis/static/js/main.mjs.map | 7 + cmd/anubis/static/js/main.mjs.zst | Bin 0 -> 982 bytes cmd/anubis/static/robots.txt | 47 + cmd/anubis/static/testdata/black.mp4 | Bin 0 -> 1667 bytes doc.go | 8 + docs/policies.md | 77 + go.mod | 47 + go.sum | 141 + internal/headers.go | 20 + internal/slog.go | 24 + run/anubis.env.default | 5 + run/anubis@.service | 12 + var/.gitignore | 2 + xess/.gitignore | 1 + xess/package-lock.json | 2411 +++++++++++++++++ xess/package.json | 20 + xess/postcss.config.js | 8 + xess/static/geist.woff2 | Bin 0 -> 64184 bytes xess/static/iosevka-curly.woff2 | Bin 0 -> 19692 bytes xess/static/podkova.css | 7 + xess/static/podkova.woff2 | Bin 0 -> 60580 bytes xess/xess.css | 111 + xess/xess.go | 38 + xess/xess.min.css | 1 + xess/xess.templ | 41 + xess/xess_templ.go | 164 ++ yeetfile.js | 22 + 61 files changed, 5615 insertions(+) create mode 100644 .github/workflows/go.yml create mode 100644 .gitignore create mode 100644 Brewfile create mode 100644 LICENSE create mode 100644 README.md create mode 100644 cmd/anubis/.gitignore create mode 100644 cmd/anubis/CHANGELOG.md create mode 100644 cmd/anubis/botPolicies.json create mode 100644 cmd/anubis/decaymap.go create mode 100644 cmd/anubis/decaymap_test.go create mode 100644 cmd/anubis/index.templ create mode 100644 cmd/anubis/index_templ.go create mode 100644 cmd/anubis/internal/config/config.go create mode 100644 cmd/anubis/internal/config/config_test.go create mode 100644 cmd/anubis/internal/config/testdata/bad/badregexes.json create mode 100644 cmd/anubis/internal/config/testdata/bad/invalid.json create mode 100644 cmd/anubis/internal/config/testdata/bad/nobots.json create mode 100644 cmd/anubis/internal/config/testdata/good/challengemozilla.json create mode 100644 cmd/anubis/internal/config/testdata/good/everything_blocked.json create mode 100644 cmd/anubis/internal/dnsbl/dnsbl.go create mode 100644 cmd/anubis/internal/dnsbl/dnsbl_test.go create mode 100644 cmd/anubis/internal/dnsbl/droneblresponse_string.go create mode 100644 cmd/anubis/js/main.mjs create mode 100644 cmd/anubis/js/proof-of-work.mjs create mode 100644 cmd/anubis/js/video.mjs create mode 100644 cmd/anubis/main.go create mode 100644 cmd/anubis/policy.go create mode 100644 cmd/anubis/policy_test.go create mode 100644 cmd/anubis/static/img/happy.webp create mode 100644 cmd/anubis/static/img/pensive.webp create mode 100644 cmd/anubis/static/img/sad.webp create mode 100644 cmd/anubis/static/js/main.mjs create mode 100644 cmd/anubis/static/js/main.mjs.br create mode 100644 cmd/anubis/static/js/main.mjs.gz create mode 100644 cmd/anubis/static/js/main.mjs.map create mode 100644 cmd/anubis/static/js/main.mjs.zst create mode 100644 cmd/anubis/static/robots.txt create mode 100644 cmd/anubis/static/testdata/black.mp4 create mode 100644 doc.go create mode 100644 docs/policies.md create mode 100644 go.mod create mode 100644 go.sum create mode 100644 internal/headers.go create mode 100644 internal/slog.go create mode 100644 run/anubis.env.default create mode 100644 run/anubis@.service create mode 100644 var/.gitignore create mode 100644 xess/.gitignore create mode 100644 xess/package-lock.json create mode 100644 xess/package.json create mode 100644 xess/postcss.config.js create mode 100644 xess/static/geist.woff2 create mode 100644 xess/static/iosevka-curly.woff2 create mode 100644 xess/static/podkova.css create mode 100644 xess/static/podkova.woff2 create mode 100644 xess/xess.css create mode 100644 xess/xess.go create mode 100644 xess/xess.min.css create mode 100644 xess/xess.templ create mode 100644 xess/xess_templ.go create mode 100644 yeetfile.js diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml new file mode 100644 index 0000000..63f4ea8 --- /dev/null +++ b/.github/workflows/go.yml @@ -0,0 +1,62 @@ +name: Go + +on: + push: + branches: [ "main" ] + pull_request: + branches: [ "main" ] + +permissions: + contents: read + actions: write + +jobs: + build: + runs-on: alrest-techarohq + steps: + - uses: actions/checkout@v4 + + - name: build essential + run: | + sudo apt-get update + sudo apt-get install -y build-essential + + - name: Set up Homebrew + uses: Homebrew/actions/setup-homebrew@master + + - name: Setup Homebrew cellar cache + uses: actions/cache@v4 + with: + path: | + /home/linuxbrew/.linuxbrew/Cellar + /home/linuxbrew/.linuxbrew/bin + /home/linuxbrew/.linuxbrew/etc + /home/linuxbrew/.linuxbrew/include + /home/linuxbrew/.linuxbrew/lib + /home/linuxbrew/.linuxbrew/opt + /home/linuxbrew/.linuxbrew/sbin + /home/linuxbrew/.linuxbrew/share + /home/linuxbrew/.linuxbrew/var + key: ${{ runner.os }}-go-homebrew-cellar-${{ hashFiles('go.sum') }} + restore-keys: | + ${{ runner.os }}-go-homebrew-cellar- + + - name: Install Brew dependencies + run: | + brew bundle + + - name: Setup Golang caches + uses: actions/cache@v4 + with: + path: | + ~/.cache/go-build + ~/go/pkg/mod + key: ${{ runner.os }}-golang-${{ hashFiles('**/go.sum') }} + restore-keys: | + ${{ runner.os }}-golang- + + - name: Build + run: go build ./... + + - name: Test + run: go test ./... diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..105385c --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +.env +*.rpm \ No newline at end of file diff --git a/Brewfile b/Brewfile new file mode 100644 index 0000000..883ba6b --- /dev/null +++ b/Brewfile @@ -0,0 +1,3 @@ +# programming languages +brew "go@1.24" +brew "node" \ No newline at end of file diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..488b74f --- /dev/null +++ b/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2025 Xe Iaso + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..8e42ba1 --- /dev/null +++ b/README.md @@ -0,0 +1,300 @@ +# Anubis + +
+A smiling chibi dark-skinned anthro jackal with brown hair and tall ears looking victorious with a thumbs-up +
+ +![enbyware](https://pride-badges.pony.workers.dev/static/v1?label=enbyware&labelColor=%23555&stripeWidth=8&stripeColors=FCF434%2CFFFFFF%2C9C59D1%2C2C2C2C) +![GitHub Issues or Pull Requests by label](https://img.shields.io/github/issues/TecharoHQ/anubis) +![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/TecharoHQ/anubis) +![language count](https://img.shields.io/github/languages/count/TecharoHQ/anubis) +![repo size](https://img.shields.io/github/repo-size/TecharoHQ/anubis) + +Anubis [weighs the soul of your connection](https://en.wikipedia.org/wiki/Weighing_of_souls) using a sha256 proof-of-work challenge in order to protect upstream resources from scraper bots. + +Installing and using this will likely result in your website not being indexed by some search engines. This is considered a feature of Anubis, not a bug. + +This is a bit of a nuclear response, but AI scraper bots scraping so aggressively have forced my hand. I hate that I have to do this, but this is what we get for the modern Internet because bots don't conform to standards like robots.txt, even when they claim to. + +In most cases, you should not need this and can probably get by using Cloudflare to protect a given origin. However, for circumstances where you can't or won't use Cloudflare, Anubis is there for you. + +If you want to try this out, connect to [git.xeserv.us](https://git.xeserv.us). + +## Support + +If you run into any issues running Anubis, please [open an issue](https://github.com/Xe/x/issues/new?template=Blank+issue) and tag it with the Anubis tag. Please include all the information I would need to diagnose your issue. + +For live chat, please join the [Patreon](https://patreon.com/cadey) and ask in the Patron discord in the channel `#anubis`. + +## How Anubis works + +Anubis uses a proof-of-work challenge to ensure that clients are using a modern browser and are able to calculate SHA-256 checksums. Anubis has a customizable difficulty for this proof-of-work challenge, but defaults to 5 leading zeroes. + +```mermaid +--- +title: Challenge generation and validation +--- + +flowchart TD + Backend("Backend") + Fail("Fail") + + style PresentChallenge color:#FFFFFF, fill:#AA00FF, stroke:#AA00FF + style ValidateChallenge color:#FFFFFF, fill:#AA00FF, stroke:#AA00FF + style Backend color:#FFFFFF, stroke:#00C853, fill:#00C853 + style Fail color:#FFFFFF, stroke:#FF2962, fill:#FF2962 + + subgraph Server + PresentChallenge("Present Challenge") + ValidateChallenge("Validate Challenge") + end + + subgraph Client + Main("main.mjs") + Worker("Worker") + end + + Main -- Request challenge --> PresentChallenge + PresentChallenge -- Return challenge & difficulty --> Main + Main -- Spawn worker --> Worker + Worker -- Successful challenge --> Main + Main -- Validate challenge --> ValidateChallenge + ValidateChallenge -- Return cookie --> Backend + ValidateChallenge -- If anything is wrong --> Fail +``` + +### Challenge presentation + +Anubis decides to present a challenge using this logic: + +- User-Agent contains `"Mozilla"` +- Request path is not in `/.well-known`, `/robots.txt`, or `/favicon.ico` +- Request path is not obviously an RSS feed (ends with `.rss`, `.xml`, or `.atom`) + +This should ensure that git clients, RSS readers, and other low-harm clients can get through without issue, but high-risk clients such as browsers and AI scraper bots will get blocked. + +```mermaid +--- +title: Challenge presentation logic +--- + +flowchart LR + Request("Request") + Backend("Backend") + %%Fail("Fail") + PresentChallenge("Present +challenge") + HasMozilla{"Is browser +or scraper?"} + HasCookie{"Has cookie?"} + HasExpired{"Cookie expired?"} + HasSignature{"Has valid +signature?"} + RandomJitter{"Secondary +screening?"} + POWPass{"Proof of +work valid?"} + + style PresentChallenge color:#FFFFFF, fill:#AA00FF, stroke:#AA00FF + style Backend color:#FFFFFF, stroke:#00C853, fill:#00C853 + %%style Fail color:#FFFFFF, stroke:#FF2962, fill:#FF2962 + + Request --> HasMozilla + HasMozilla -- Yes --> HasCookie + HasMozilla -- No --> Backend + HasCookie -- Yes --> HasExpired + HasCookie -- No --> PresentChallenge + HasExpired -- Yes --> PresentChallenge + HasExpired -- No --> HasSignature + HasSignature -- Yes --> RandomJitter + HasSignature -- No --> PresentChallenge + RandomJitter -- Yes --> POWPass + RandomJitter -- No --> Backend + POWPass -- Yes --> Backend + PowPass -- No --> PresentChallenge + PresentChallenge -- Back again for another cycle --> Request +``` + +### Proof of passing challenges + +When a client passes a challenge, Anubis sets an HTTP cookie named `"within.website-x-cmd-anubis-auth"` containing a signed [JWT](https://jwt.io/) (JSON Web Token). This JWT contains the following claims: + +- `challenge`: The challenge string derived from user request metadata +- `nonce`: The nonce / iteration number used to generate the passing response +- `response`: The hash that passed Anubis' checks +- `iat`: When the token was issued +- `nbf`: One minute prior to when the token was issued +- `exp`: The token's expiry week after the token was issued + +This ensures that the token has enough metadata to prove that the token is valid (due to the token's signature), but also so that the server can independently prove the token is valid. This cookie is allowed to be set without triggering an EU cookie banner notification; but depending on facts and circumstances, you may wish to disclose this to your users. + +### Challenge format + +Challenges are formed by taking some user request metadata and using that to generate a SHA-256 checksum. The following request headers are used: + +- `Accept-Encoding`: The content encodings that the requestor supports, such as gzip. +- `Accept-Language`: The language that the requestor would prefer the server respond in, such as English. +- `X-Real-Ip`: The IP address of the requestor, as set by a reverse proxy server. +- `User-Agent`: The user agent string of the requestor. +- The current time in UTC rounded to the nearest week. +- The fingerprint (checksum) of Anubis' private ED25519 key. + +This forms a fingerprint of the requestor using metadata that any requestor already is sending. It also uses time as an input, which is known to both the server and requestor due to the nature of linear timelines. Depending on facts and circumstances, you may wish to disclose this to your users. + +### JWT signing + +Anubis uses an ed25519 keypair to sign the JWTs issued when challenges are passed. Anubis will generate a new ed25519 keypair every time it starts. At this time, there is no way to share this keypair between instance of Anubis, but that will be addressed in future versions. + +## Setting up Anubis + +Anubis is meant to sit between your reverse proxy (such as Nginx or Caddy) and your target service. One instance of Anubis must be used per service you are protecting. + +Anubis is shipped in the Docker image [`ghcr.io/xe/x/anubis:latest`](https://github.com/Xe/x/pkgs/container/x%2Fanubis). Other methods to install Anubis may exist, but the Docker image is currently the only supported method. + +The Docker image runs Anubis as user ID 1000 and group ID 1000. If you are mounting external volumes into Anubis' container, please be sure they are owned by or writable to this user/group. + +Anubis has very minimal system requirements. I suspect that 128Mi of ram may be sufficient for a large number of concurrent clients. Anubis may be a poor fit for apps that use WebSockets and maintain open connections, but I don't have enough real-world experience to know one way or another. + +Anubis uses these environment variables for configuration: + +| Environment Variable | Default value | Explanation | +| :------------------- | :------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `BIND` | `:8923` | The TCP port that Anubis listens on. | +| `DIFFICULTY` | `5` | The difficulty of the challenge, or the number of leading zeroes that must be in successful responses. | +| `METRICS_BIND` | `:9090` | The TCP port that Anubis serves Prometheus metrics on. | +| `POLICY_FNAME` | `/data/cfg/botPolicy.json` | The file containing [bot policy configuration](./docs/policies.md). See the bot policy documentation for more details. | +| `SERVE_ROBOTS_TXT` | `false` | If set `true`, Anubis will serve a default `robots.txt` file that disallows all known AI scrapers by name and then additionally disallows every scraper. This is useful if facts and circumstances make it difficult to change the underlying service to serve such a `robots.txt` file. | +| `TARGET` | `http://localhost:3923` | The URL of the service that Anubis should forward valid requests to. | + +### Policies + +Anubis has support for custom bot policies, matched by User-Agent string and request path. Check the [bot policy documentation](./docs/policies.md) for more information. + +### Docker compose + +Add Anubis to your compose file pointed at your service: + +```yaml +services: + anubis-nginx: + image: ghcr.io/xe/x/anubis:latest + environment: + BIND: ":8080" + DIFFICULTY: "5" + METRICS_BIND: ":9090" + SERVE_ROBOTS_TXT: "true" + TARGET: "http://nginx" + ports: + - 8080:8080 + nginx: + image: nginx + volumes: + - "./www:/usr/share/nginx/html" +``` + +### Kubernetes + +This example makes the following assumptions: + +- Your target service is listening on TCP port `5000`. +- Anubis will be listening on port `8080`. + +Attach Anubis to your Deployment: + +```yaml +containers: + # ... + - name: anubis + image: ghcr.io/xe/x/anubis:latest + imagePullPolicy: Always + env: + - name: "BIND" + value: ":8080" + - name: "DIFFICULTY" + value: "5" + - name: "METRICS_BIND" + value: ":9090" + - name: "SERVE_ROBOTS_TXT" + value: "true" + - name: "TARGET" + value: "http://localhost:5000" + resources: + limits: + cpu: 500m + memory: 128Mi + requests: + cpu: 250m + memory: 128Mi + securityContext: + runAsUser: 1000 + runAsGroup: 1000 + runAsNonRoot: true + allowPrivilegeEscalation: false + capabilities: + drop: + - ALL + seccompProfile: + type: RuntimeDefault +``` + +Then add a Service entry for Anubis: + +```diff +# ... + spec: + ports: ++ - protocol: TCP ++ port: 8080 ++ targetPort: 8080 ++ name: anubis +``` + +Then point your Ingress to the Anubis port: + +```diff + rules: + - host: git.xeserv.us + http: + paths: + - pathType: Prefix + path: "/" + backend: + service: + name: git + port: +- name: http ++ name: anubis +``` + +## Known caveats + +Anubis works with most programs without any issues as long as they're configured to trust `127.0.0.0/8` and `::1/128` as "valid proxy servers". Some combinations of reverse proxy and target application can have issues. This section documents them so that you can pattern-match and fix them. + +### Caddy + Gitea/Forgejo + +Gitea/Forgejo relies on the reverse proxy setting the `X-Real-Ip` header. Caddy does not do this out of the gate. Modify your Caddyfile like this: + +```diff + ellenjoe.int.within.lgbt { + # ... +- reverse_proxy http://localhost:3000 ++ reverse_proxy http://localhost:3000 { ++ header_up X-Real-Ip {remote_host} ++ } + # ... + } +``` + +Ensure that Gitea/Forgejo have `[security].REVERSE_PROXY_TRUSTED_PROXIES` set to the IP ranges that Anubis will appear from. Typically this is sufficient: + +```ini +[security] +REVERSE_PROXY_TRUSTED_PROXIES = 127.0.0.0/8,::1/128 +``` + +However if you are running Anubis in a separate Pod/Deployment in Kubernetes, you may have to adjust this to the IP range of the Pod space in your Container Networking Interface plugin: + +```ini +[security] +REVERSE_PROXY_TRUSTED_PROXIES = 10.192.0.0/12 +``` diff --git a/cmd/anubis/.gitignore b/cmd/anubis/.gitignore new file mode 100644 index 0000000..061bf12 --- /dev/null +++ b/cmd/anubis/.gitignore @@ -0,0 +1,2 @@ +*.rpm +anubis diff --git a/cmd/anubis/CHANGELOG.md b/cmd/anubis/CHANGELOG.md new file mode 100644 index 0000000..612bec1 --- /dev/null +++ b/cmd/anubis/CHANGELOG.md @@ -0,0 +1,5 @@ +# CHANGELOG + +## 2025-01-24 + +- Added support for custom bot policy documentation, allowing administrators to change how Anubis works to meet their needs. diff --git a/cmd/anubis/botPolicies.json b/cmd/anubis/botPolicies.json new file mode 100644 index 0000000..6e04a11 --- /dev/null +++ b/cmd/anubis/botPolicies.json @@ -0,0 +1,70 @@ +{ + "bots": [ + { + "name": "amazonbot", + "user_agent_regex": "Amazonbot", + "action": "DENY" + }, + { + "name": "googlebot", + "user_agent_regex": "\\+http\\:\\/\\/www\\.google\\.com/bot\\.html", + "action": "ALLOW" + }, + { + "name": "bingbot", + "user_agent_regex": "\\+http\\:\\/\\/www\\.bing\\.com/bingbot\\.htm", + "action": "ALLOW" + }, + { + "name": "qwantbot", + "user_agent_regex": "\\+https\\:\\/\\/help\\.qwant\\.com/bot/", + "action": "ALLOW" + }, + { + "name": "us-artificial-intelligence-scraper", + "user_agent_regex": "\\+https\\:\\/\\/github\\.com\\/US-Artificial-Intelligence\\/scraper", + "action": "DENY" + }, + { + "name": "well-known", + "path_regex": "^/.well-known/.*$", + "action": "ALLOW" + }, + { + "name": "favicon", + "path_regex": "^/favicon.ico$", + "action": "ALLOW" + }, + { + "name": "robots-txt", + "path_regex": "^/robots.txt$", + "action": "ALLOW" + }, + { + "name": "rss-readers", + "path_regex": ".*\\.(rss|xml|atom|json)$", + "action": "ALLOW" + }, + { + "name": "lightpanda", + "user_agent_regex": "^Lightpanda/.*$", + "action": "DENY" + }, + { + "name": "headless-chrome", + "user_agent_regex": "HeadlessChrome", + "action": "DENY" + }, + { + "name": "headless-chromium", + "user_agent_regex": "HeadlessChromium", + "action": "DENY" + }, + { + "name": "generic-browser", + "user_agent_regex": "Mozilla", + "action": "CHALLENGE" + } + ], + "dnsbl": true +} diff --git a/cmd/anubis/decaymap.go b/cmd/anubis/decaymap.go new file mode 100644 index 0000000..dcd2952 --- /dev/null +++ b/cmd/anubis/decaymap.go @@ -0,0 +1,87 @@ +package main + +import ( + "sync" + "time" +) + +func zilch[T any]() T { + var zero T + return zero +} + +// DecayMap is a lazy key->value map. It's a wrapper around a map and a mutex. If values exceed their time-to-live, they are pruned at Get time. +type DecayMap[K comparable, V any] struct { + data map[K]decayMapEntry[V] + lock sync.RWMutex +} + +type decayMapEntry[V any] struct { + Value V + expiry time.Time +} + +// NewDecayMap creates a new DecayMap of key type K and value type V. +// +// Key types must be comparable to work with maps. +func NewDecayMap[K comparable, V any]() *DecayMap[K, V] { + return &DecayMap[K, V]{ + data: make(map[K]decayMapEntry[V]), + } +} + +// expire forcibly expires a key by setting its time-to-live one second in the past. +func (m *DecayMap[K, V]) expire(key K) bool { + m.lock.RLock() + val, ok := m.data[key] + m.lock.RUnlock() + + if !ok { + return false + } + + m.lock.Lock() + val.expiry = time.Now().Add(-1 * time.Second) + m.data[key] = val + m.lock.Unlock() + + return true +} + +// Get gets a value from the DecayMap by key. +// +// If a value has expired, forcibly delete it if it was not updated. +func (m *DecayMap[K, V]) Get(key K) (V, bool) { + m.lock.RLock() + value, ok := m.data[key] + m.lock.RUnlock() + + if !ok { + return zilch[V](), false + } + + if time.Now().After(value.expiry) { + m.lock.Lock() + // Since previously reading m.data[key], the value may have been updated. + // Delete the entry only if the expiry time is still the same. + if m.data[key].expiry == value.expiry { + delete(m.data, key) + } + m.lock.Unlock() + + return zilch[V](), false + } + + return value.Value, true +} + +// Set sets a key value pair in the map. +func (m *DecayMap[K, V]) Set(key K, value V, ttl time.Duration) { + m.lock.Lock() + defer m.lock.Unlock() + + m.data[key] = decayMapEntry[V]{ + Value: value, + expiry: time.Now().Add(ttl), + } +} diff --git a/cmd/anubis/decaymap_test.go b/cmd/anubis/decaymap_test.go new file mode 100644 index 0000000..73e0626 --- /dev/null +++ b/cmd/anubis/decaymap_test.go @@ -0,0 +1,31 @@ +package main + +import ( + "testing" + "time" +) + +func TestDecayMap(t *testing.T) { + dm := NewDecayMap[string, string]() + + dm.Set("test", "hi", 5*time.Minute) + + val, ok := dm.Get("test") + if !ok { + t.Error("somehow the test key was not set") + } + + if val != "hi" { + t.Errorf("wanted value %q, got: %q", "hi", val) + } + + ok = dm.expire("test") + if !ok { + t.Error("somehow could not force-expire the test key") + } + + _, ok = dm.Get("test") + if ok { + t.Error("got value even though it was supposed to be expired") + } +} diff --git a/cmd/anubis/index.templ b/cmd/anubis/index.templ new file mode 100644 index 0000000..e2426d5 --- /dev/null +++ b/cmd/anubis/index.templ @@ -0,0 +1,159 @@ +package main + +import ( + "github.com/TecharoHQ/anubis" + "github.com/TecharoHQ/anubis/xess" +) + +templ base(title string, body templ.Component) { + + + + { title } + + + + + +
+
+

{ title }

+
+ @body + +
+ + +} + +templ index() { +
+ Loading...

+
") + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + return nil + }) +} + +func errorPage(message string) templ.Component { + return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) { + templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context + if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil { + return templ_7745c5c3_CtxErr + } + templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W) + if !templ_7745c5c3_IsBuffer { + defer func() { + templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer) + if templ_7745c5c3_Err == nil { + templ_7745c5c3_Err = templ_7745c5c3_BufErr + } + }() + } + ctx = templ.InitializeContext(ctx) + templ_7745c5c3_Var9 := templ.GetChildren(ctx) + if templ_7745c5c3_Var9 == nil { + templ_7745c5c3_Var9 = templ.NopComponent + } + ctx = templ.ClearChildren(ctx) + templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 10, "

") + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + var templ_7745c5c3_Var11 string + templ_7745c5c3_Var11, templ_7745c5c3_Err = templ.JoinStringErrs(message) + if templ_7745c5c3_Err != nil { + return templ.Error{Err: templ_7745c5c3_Err, FileName: `index.templ`, Line: 155, Col: 14} + } + _, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var11)) + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 12, ".

Go home

") + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + return nil + }) +} + +var _ = templruntime.GeneratedTemplate diff --git a/cmd/anubis/internal/config/config.go b/cmd/anubis/internal/config/config.go new file mode 100644 index 0000000..ad338ef --- /dev/null +++ b/cmd/anubis/internal/config/config.go @@ -0,0 +1,99 @@ +package config + +import ( + "errors" + "fmt" + "regexp" +) + +type Rule string + +const ( + RuleUnknown = "" + RuleAllow = "ALLOW" + RuleDeny = "DENY" + RuleChallenge = "CHALLENGE" +) + +type Bot struct { + Name string `json:"name"` + UserAgentRegex *string `json:"user_agent_regex"` + PathRegex *string `json:"path_regex"` + Action Rule `json:"action"` +} + +var ( + ErrNoBotRulesDefined = errors.New("config: must define at least one (1) bot rule") + ErrBotMustHaveName = errors.New("config.Bot: must set name") + ErrBotMustHaveUserAgentOrPath = errors.New("config.Bot: must set either user_agent_regex, path_regex") + ErrBotMustHaveUserAgentOrPathNotBoth = errors.New("config.Bot: must set either user_agent_regex, path_regex, and not both") + ErrUnknownAction = errors.New("config.Bot: unknown action") + ErrInvalidUserAgentRegex = errors.New("config.Bot: invalid user agent regex") + ErrInvalidPathRegex = errors.New("config.Bot: invalid path regex") +) + +func (b Bot) Valid() error { + var errs []error + + if b.Name == "" { + errs = append(errs, ErrBotMustHaveName) + } + + if b.UserAgentRegex == nil && b.PathRegex == nil { + errs = append(errs, ErrBotMustHaveUserAgentOrPath) + } + + if b.UserAgentRegex != nil && b.PathRegex != nil { + errs = append(errs, ErrBotMustHaveUserAgentOrPathNotBoth) + } + + if b.UserAgentRegex != nil { + if _, err := regexp.Compile(*b.UserAgentRegex); err != nil { + errs = append(errs, ErrInvalidUserAgentRegex, err) + } + } + + if b.PathRegex != nil { + if _, err := regexp.Compile(*b.PathRegex); err != nil { + errs = append(errs, ErrInvalidPathRegex, err) + } + } + + switch b.Action { + case RuleAllow, RuleChallenge, RuleDeny: + // okay + default: + errs = append(errs, fmt.Errorf("%w: %q", ErrUnknownAction, b.Action)) + } + + if len(errs) != 0 { + return fmt.Errorf("config: bot entry for %q is not valid:\n%w", b.Name, errors.Join(errs...)) + } + + return nil +} + +type Config struct { + Bots []Bot `json:"bots"` + DNSBL bool `json:"dnsbl"` +} + +func (c Config) Valid() error { + var errs []error + + if len(c.Bots) == 0 { + errs = append(errs, ErrNoBotRulesDefined) + } + + for _, b := range c.Bots { + if err := b.Valid(); err != nil { + errs = append(errs, err) + } + } + + if len(errs) != 0 { + return fmt.Errorf("config is not valid:\n%w", errors.Join(errs...)) + } + + return nil +} diff --git a/cmd/anubis/internal/config/config_test.go b/cmd/anubis/internal/config/config_test.go new file mode 100644 index 0000000..f362a76 --- /dev/null +++ b/cmd/anubis/internal/config/config_test.go @@ -0,0 +1,168 @@ +package config + +import ( + "encoding/json" + "errors" + "os" + "path/filepath" + "testing" +) + +func p[V any](v V) *V { return &v } + +func TestBotValid(t *testing.T) { + var tests = []struct { + name string + bot Bot + err error + }{ + { + name: "simple user agent", + bot: Bot{ + Name: "mozilla-ua", + Action: RuleChallenge, + UserAgentRegex: p("Mozilla"), + }, + err: nil, + }, + { + name: "simple path", + bot: Bot{ + Name: "well-known-path", + Action: RuleAllow, + PathRegex: p("^/.well-known/.*$"), + }, + err: nil, + }, + { + name: "no rule name", + bot: Bot{ + Action: RuleChallenge, + UserAgentRegex: p("Mozilla"), + }, + err: ErrBotMustHaveName, + }, + { + name: "no rule matcher", + bot: Bot{ + Name: "broken-rule", + Action: RuleAllow, + }, + err: ErrBotMustHaveUserAgentOrPath, + }, + { + name: "both user-agent and path", + bot: Bot{ + Name: "path-and-user-agent", + Action: RuleDeny, + UserAgentRegex: p("Mozilla"), + PathRegex: p("^/.secret-place/.*$"), + }, + err: ErrBotMustHaveUserAgentOrPathNotBoth, + }, + { + name: "unknown action", + bot: Bot{ + Name: "Unknown action", + Action: RuleUnknown, + UserAgentRegex: p("Mozilla"), + }, + err: ErrUnknownAction, + }, + { + name: "invalid user agent regex", + bot: Bot{ + Name: "mozilla-ua", + Action: RuleChallenge, + UserAgentRegex: p("a(b"), + }, + err: ErrInvalidUserAgentRegex, + }, + { + name: "invalid path regex", + bot: Bot{ + Name: "mozilla-ua", + Action: RuleChallenge, + PathRegex: p("a(b"), + }, + err: ErrInvalidPathRegex, + }, + } + + for _, cs := range tests { + cs := cs + t.Run(cs.name, func(t *testing.T) { + err := cs.bot.Valid() + if err == nil && cs.err == nil { + return + } + + if err == nil && cs.err != nil { + t.Errorf("didn't get an error, but wanted: %v", cs.err) + } + + if !errors.Is(err, cs.err) { + t.Logf("got wrong error from Valid()") + t.Logf("wanted: %v", cs.err) + t.Logf("got: %v", err) + t.Errorf("got invalid error from check") + } + }) + } +} + +func TestConfigValidKnownGood(t *testing.T) { + finfos, err := os.ReadDir("testdata/good") + if err != nil { + t.Fatal(err) + } + + for _, st := range finfos { + st := st + t.Run(st.Name(), func(t *testing.T) { + fin, err := os.Open(filepath.Join("testdata", "good", st.Name())) + if err != nil { + t.Fatal(err) + } + defer fin.Close() + + var c Config + if err := json.NewDecoder(fin).Decode(&c); err != nil { + t.Fatalf("can't decode file: %v", err) + } + + if err := c.Valid(); err != nil { + t.Fatal(err) + } + }) + } +} + +func TestConfigValidBad(t *testing.T) { + finfos, err := os.ReadDir("testdata/bad") + if err != nil { + t.Fatal(err) + } + + for _, st := range finfos { + st := st + t.Run(st.Name(), func(t *testing.T) { + fin, err := os.Open(filepath.Join("testdata", "bad", st.Name())) + if err != nil { + t.Fatal(err) + } + defer fin.Close() + + var c Config + if err := json.NewDecoder(fin).Decode(&c); err != nil { + t.Fatalf("can't decode file: %v", err) + } + + if err := c.Valid(); err == nil { + t.Fatal("validation should have failed but didn't somehow") + } else { + t.Log(err) + } + }) + } +} diff --git a/cmd/anubis/internal/config/testdata/bad/badregexes.json b/cmd/anubis/internal/config/testdata/bad/badregexes.json new file mode 100644 index 0000000..e85b85b --- /dev/null +++ b/cmd/anubis/internal/config/testdata/bad/badregexes.json @@ -0,0 +1,14 @@ +{ + "bots": [ + { + "name": "path-bad", + "path_regex": "a(b", + "action": "DENY" + }, + { + "name": "user-agent-bad", + "user_agent_regex": "a(b", + "action": "DENY" + } + ] +} \ No newline at end of file diff --git a/cmd/anubis/internal/config/testdata/bad/invalid.json b/cmd/anubis/internal/config/testdata/bad/invalid.json new file mode 100644 index 0000000..c5d1ff6 --- /dev/null +++ b/cmd/anubis/internal/config/testdata/bad/invalid.json @@ -0,0 +1,5 @@ +{ + "bots": [ + {} + ] +} \ No newline at end of file diff --git a/cmd/anubis/internal/config/testdata/bad/nobots.json b/cmd/anubis/internal/config/testdata/bad/nobots.json new file mode 100644 index 0000000..9e26dfe --- /dev/null +++ b/cmd/anubis/internal/config/testdata/bad/nobots.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/cmd/anubis/internal/config/testdata/good/challengemozilla.json b/cmd/anubis/internal/config/testdata/good/challengemozilla.json new file mode 100644 index 0000000..e9d34ee --- /dev/null +++ b/cmd/anubis/internal/config/testdata/good/challengemozilla.json @@ -0,0 +1,9 @@ +{ + "bots": [ + { + "name": "generic-browser", + "user_agent_regex": "Mozilla", + "action": "CHALLENGE" + } + ] +} \ No newline at end of file diff --git a/cmd/anubis/internal/config/testdata/good/everything_blocked.json b/cmd/anubis/internal/config/testdata/good/everything_blocked.json new file mode 100644 index 0000000..e1763e4 --- /dev/null +++ b/cmd/anubis/internal/config/testdata/good/everything_blocked.json @@ -0,0 +1,10 @@ +{ + "bots": [ + { + "name": "everything", + "user_agent_regex": ".*", + "action": "DENY" + } + ], + "dnsbl": false +} \ No newline at end of file diff --git a/cmd/anubis/internal/dnsbl/dnsbl.go b/cmd/anubis/internal/dnsbl/dnsbl.go new file mode 100644 index 0000000..60edd5c --- /dev/null +++ b/cmd/anubis/internal/dnsbl/dnsbl.go @@ -0,0 +1,95 @@ +package dnsbl + +import ( + "errors" + "fmt" + "net" + "strings" +) + +//go:generate go tool golang.org/x/tools/cmd/stringer -type=DroneBLResponse + +type DroneBLResponse byte + +const ( + AllGood DroneBLResponse = 0 + IRCDrone DroneBLResponse = 3 + Bottler DroneBLResponse = 5 + UnknownSpambotOrDrone DroneBLResponse = 6 + DDOSDrone DroneBLResponse = 7 + SOCKSProxy DroneBLResponse = 8 + HTTPProxy DroneBLResponse = 9 + ProxyChain DroneBLResponse = 10 + OpenProxy DroneBLResponse = 11 + OpenDNSResolver DroneBLResponse = 12 + BruteForceAttackers DroneBLResponse = 13 + OpenWingateProxy DroneBLResponse = 14 + CompromisedRouter DroneBLResponse = 15 + AutoRootingWorms DroneBLResponse = 16 + AutoDetectedBotIP DroneBLResponse = 17 + Unknown DroneBLResponse = 255 +) + +func Reverse(ip net.IP) string { + if ip.To4() != nil { + return reverse4(ip) + } + + return reverse6(ip) +} + +func reverse4(ip net.IP) string { + splitAddress := strings.Split(ip.String(), ".") + + // swap first and last octet + splitAddress[0], splitAddress[3] = splitAddress[3], splitAddress[0] + // swap middle octets + splitAddress[1], splitAddress[2] = splitAddress[2], splitAddress[1] + + return strings.Join(splitAddress, ".") +} + +func reverse6(ip net.IP) string { + ipBytes := []byte(ip) + var sb strings.Builder + + for i := len(ipBytes) - 1; i >= 0; i-- { + // Split the byte into two nibbles + highNibble := ipBytes[i] >> 4 + lowNibble := ipBytes[i] & 0x0F + + // Append the nibbles in reversed order + sb.WriteString(fmt.Sprintf("%x.%x.", lowNibble, highNibble)) + } + + return sb.String()[:len(sb.String())-1] +} + +func Lookup(ipStr string) (DroneBLResponse, error) { + ip := net.ParseIP(ipStr) + if ip == nil { + return Unknown, errors.New("dnsbl: input is not an IP address") + } + + revIP := Reverse(ip) + ".dnsbl.dronebl.org" + + ips, err := net.LookupIP(revIP) + if err != nil { + var dnserr *net.DNSError + if errors.As(err, &dnserr) { + if dnserr.IsNotFound { + return AllGood, nil + } + } + + return Unknown, err + } + + if len(ips) != 0 { + for _, ip := range ips { + return DroneBLResponse(ip.To4()[3]), nil + } + } + + return UnknownSpambotOrDrone, nil +} diff --git a/cmd/anubis/internal/dnsbl/dnsbl_test.go b/cmd/anubis/internal/dnsbl/dnsbl_test.go new file mode 100644 index 0000000..0ead488 --- /dev/null +++ b/cmd/anubis/internal/dnsbl/dnsbl_test.go @@ -0,0 +1,55 @@ +package dnsbl + +import ( + "fmt" + "net" + "testing" +) + +func TestReverse4(t *testing.T) { + cases := []struct { + inp, out string + }{ + {"1.2.3.4", "4.3.2.1"}, + } + + for _, cs := range cases { + t.Run(fmt.Sprintf("%s->%s", cs.inp, cs.out), func(t *testing.T) { + out := reverse4(net.ParseIP(cs.inp)) + + if out != cs.out { + t.Errorf("wanted %s\ngot: %s", cs.out, out) + } + }) + } +} + +func TestReverse6(t *testing.T) { + cases := []struct { + inp, out string + }{ + { + inp: "1234:5678:9ABC:DEF0:1234:5678:9ABC:DEF0", + out: "0.f.e.d.c.b.a.9.8.7.6.5.4.3.2.1.0.f.e.d.c.b.a.9.8.7.6.5.4.3.2.1", + }, + } + + for _, cs := range cases { + t.Run(fmt.Sprintf("%s->%s", cs.inp, cs.out), func(t *testing.T) { + out := reverse6(net.ParseIP(cs.inp)) + + if out != cs.out { + t.Errorf("wanted %s, got: %s", cs.out, out) + } + }) + } +} + +func TestLookup(t *testing.T) { + resp, err := Lookup("27.65.243.194") + if err != nil { + t.Fatalf("it broked: %v", err) + } + + t.Logf("response: %d", resp) +} diff --git a/cmd/anubis/internal/dnsbl/droneblresponse_string.go b/cmd/anubis/internal/dnsbl/droneblresponse_string.go new file mode 100644 index 0000000..5104dda --- /dev/null +++ b/cmd/anubis/internal/dnsbl/droneblresponse_string.go @@ -0,0 +1,54 @@ +// Code generated by "stringer -type=DroneBLResponse"; DO NOT EDIT. + +package dnsbl + +import "strconv" + +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[AllGood-0] + _ = x[IRCDrone-3] + _ = x[Bottler-5] + _ = x[UnknownSpambotOrDrone-6] + _ = x[DDOSDrone-7] + _ = x[SOCKSProxy-8] + _ = x[HTTPProxy-9] + _ = x[ProxyChain-10] + _ = x[OpenProxy-11] + _ = x[OpenDNSResolver-12] + _ = x[BruteForceAttackers-13] + _ = x[OpenWingateProxy-14] + _ = x[CompromisedRouter-15] + _ = x[AutoRootingWorms-16] + _ = x[AutoDetectedBotIP-17] + _ = x[Unknown-255] +} + +const ( + _DroneBLResponse_name_0 = "AllGood" + _DroneBLResponse_name_1 = "IRCDrone" + _DroneBLResponse_name_2 = "BottlerUnknownSpambotOrDroneDDOSDroneSOCKSProxyHTTPProxyProxyChainOpenProxyOpenDNSResolverBruteForceAttackersOpenWingateProxyCompromisedRouterAutoRootingWormsAutoDetectedBotIP" + _DroneBLResponse_name_3 = "Unknown" +) + +var ( + _DroneBLResponse_index_2 = [...]uint8{0, 7, 28, 37, 47, 56, 66, 75, 90, 109, 125, 142, 158, 175} +) + +func (i DroneBLResponse) String() string { + switch { + case i == 0: + return _DroneBLResponse_name_0 + case i == 3: + return _DroneBLResponse_name_1 + case 5 <= i && i <= 17: + i -= 5 + return _DroneBLResponse_name_2[_DroneBLResponse_index_2[i]:_DroneBLResponse_index_2[i+1]] + case i == 255: + return _DroneBLResponse_name_3 + default: + return "DroneBLResponse(" + strconv.FormatInt(int64(i), 10) + ")" + } +} diff --git a/cmd/anubis/js/main.mjs b/cmd/anubis/js/main.mjs new file mode 100644 index 0000000..3f2c652 --- /dev/null +++ b/cmd/anubis/js/main.mjs @@ -0,0 +1,71 @@ +import { process } from './proof-of-work.mjs'; +import { testVideo } from './video.mjs'; + +// from Xeact +const u = (url = "", params = {}) => { + let result = new URL(url, window.location.href); + Object.entries(params).forEach((kv) => { + let [k, v] = kv; + result.searchParams.set(k, v); + }); + return result.toString(); +}; + +const imageURL = (mood) => { + return `/.within.website/x/cmd/anubis/static/img/${mood}.webp`; +}; + +(async () => { + const status = document.getElementById('status'); + const image = document.getElementById('image'); + const title = document.getElementById('title'); + const spinner = document.getElementById('spinner'); + // const testarea = document.getElementById('testarea'); + + // const videoWorks = await testVideo(testarea); + // console.log(`videoWorks: ${videoWorks}`); + + // if (!videoWorks) { + // title.innerHTML = "Oh no!"; + // status.innerHTML = "Checks failed. Please check your browser's settings and try again."; + // image.src = imageURL("sad"); + // spinner.innerHTML = ""; + // spinner.style.display = "none"; + // return; + // } + + status.innerHTML = 'Calculating...'; + + const { challenge, difficulty } = await fetch("/.within.website/x/cmd/anubis/api/make-challenge", { method: "POST" }) + .then(r => { + if (!r.ok) { + throw new Error("Failed to fetch config"); + } + return r.json(); + }) + .catch(err => { + title.innerHTML = "Oh no!"; + status.innerHTML = `Failed to fetch config: ${err.message}`; + image.src = imageURL("sad"); + spinner.innerHTML = ""; + spinner.style.display = "none"; + throw err; + }); + + status.innerHTML = `Calculating...
Difficulty: ${difficulty}`; + + const t0 = Date.now(); + const { hash, nonce } = await process(challenge, difficulty); + const t1 = Date.now(); + + title.innerHTML = "Success!"; + status.innerHTML = `Done! Took ${t1 - t0}ms, ${nonce} iterations`; + image.src = imageURL("happy"); + spinner.innerHTML = ""; + spinner.style.display = "none"; + + setTimeout(() => { + const redir = window.location.href; + window.location.href = u("/.within.website/x/cmd/anubis/api/pass-challenge", { response: hash, nonce, redir, elapsedTime: t1 - t0 }); + }, 2000); +})(); \ No newline at end of file diff --git a/cmd/anubis/js/proof-of-work.mjs b/cmd/anubis/js/proof-of-work.mjs new file mode 100644 index 0000000..d71d2db --- /dev/null +++ b/cmd/anubis/js/proof-of-work.mjs @@ -0,0 +1,62 @@ +// https://dev.to/ratmd/simple-proof-of-work-in-javascript-3kgm + +export function process(data, difficulty = 5) { + return new Promise((resolve, reject) => { + let webWorkerURL = URL.createObjectURL(new Blob([ + '(', processTask(), ')()' + ], { type: 'application/javascript' })); + + let worker = new Worker(webWorkerURL); + + worker.onmessage = (event) => { + worker.terminate(); + resolve(event.data); + }; + + worker.onerror = (event) => { + worker.terminate(); + reject(); + }; + + worker.postMessage({ + data, + difficulty + }); + + URL.revokeObjectURL(webWorkerURL); + }); +} + +function processTask() { + return function () { + const sha256 = (text) => { + const encoded = new TextEncoder().encode(text); + return crypto.subtle.digest("SHA-256", encoded.buffer).then((result) => + Array.from(new Uint8Array(result)) + .map((c) => c.toString(16).padStart(2, "0")) + .join(""), + ); + }; + + addEventListener('message', async (event) => { + let data = event.data.data; + let difficulty = event.data.difficulty; + + let hash; + let nonce = 0; + do { + hash = await sha256(data + nonce++); + } while (hash.substring(0, difficulty) !== Array(difficulty + 1).join('0')); + + nonce -= 1; // last nonce was post-incremented + + postMessage({ + hash, + data, + difficulty, + nonce, + }); + }); + }.toString(); +} + diff --git a/cmd/anubis/js/video.mjs b/cmd/anubis/js/video.mjs new file mode 100644 index 0000000..59cde1e --- /dev/null +++ b/cmd/anubis/js/video.mjs @@ -0,0 +1,16 @@ +const videoElement = ``; + +export const testVideo = async (testarea) => { + testarea.innerHTML = videoElement; + return (await new Promise((resolve) => { + const video = document.getElementById('videotest'); + video.oncanplay = () => { + testarea.style.display = "none"; + resolve(true); + }; + video.onerror = (ev) => { + testarea.style.display = "none"; + resolve(false); + }; + })); +}; \ No newline at end of file diff --git a/cmd/anubis/main.go b/cmd/anubis/main.go new file mode 100644 index 0000000..45afeb2 --- /dev/null +++ b/cmd/anubis/main.go @@ -0,0 +1,574 @@ +package main + +import ( + "crypto/ed25519" + "crypto/rand" + "crypto/sha256" + "crypto/subtle" + "embed" + "encoding/hex" + "encoding/json" + "flag" + "fmt" + "io" + "log" + "log/slog" + "math" + mrand "math/rand" + "net/http" + "net/http/httputil" + "net/url" + "os" + "strconv" + "strings" + "time" + + "github.com/TecharoHQ/anubis" + "github.com/TecharoHQ/anubis/cmd/anubis/internal/config" + "github.com/TecharoHQ/anubis/cmd/anubis/internal/dnsbl" + "github.com/TecharoHQ/anubis/internal" + "github.com/TecharoHQ/anubis/xess" + "github.com/a-h/templ" + "github.com/facebookgo/flagenv" + "github.com/golang-jwt/jwt/v5" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promauto" + "github.com/prometheus/client_golang/prometheus/promhttp" +) + +var ( + bind = flag.String("bind", ":8923", "TCP port to bind HTTP to") + challengeDifficulty = flag.Int("difficulty", 5, "difficulty of the challenge") + metricsBind = flag.String("metrics-bind", ":9090", "TCP port to bind metrics to") + robotsTxt = flag.Bool("serve-robots-txt", false, "serve a robots.txt file that disallows all robots") + policyFname = flag.String("policy-fname", "", "full path to anubis policy document (defaults to a sensible built-in policy)") + slogLevel = flag.String("slog-level", "INFO", "logging level (see https://pkg.go.dev/log/slog#hdr-Levels)") + target = flag.String("target", "http://localhost:3923", "target to reverse proxy to") + healthcheck = flag.Bool("healthcheck", false, "run a health check against Anubis") + + //go:embed static botPolicies.json + static embed.FS + + challengesIssued = promauto.NewCounter(prometheus.CounterOpts{ + Name: "anubis_challenges_issued", + Help: "The total number of challenges issued", + }) + + challengesValidated = promauto.NewCounter(prometheus.CounterOpts{ + Name: "anubis_challenges_validated", + Help: "The total number of challenges validated", + }) + + droneBLHits = promauto.NewCounterVec(prometheus.CounterOpts{ + Name: "anubis_dronebl_hits", + Help: "The total number of hits from DroneBL", + }, []string{"status"}) + + failedValidations = promauto.NewCounter(prometheus.CounterOpts{ + Name: "anubis_failed_validations", + Help: "The total number of failed validations", + }) + + timeTaken = promauto.NewHistogram(prometheus.HistogramOpts{ + Name: "anubis_time_taken", + Help: "The time taken for a browser to generate a response (milliseconds)", + Buckets: prometheus.ExponentialBucketsRange(1, math.Pow(2, 18), 19), + }) +) + +const ( + cookieName = "within.website-x-cmd-anubis-auth" + staticPath = "/.within.website/x/cmd/anubis/" +) + +//go:generate go tool github.com/a-h/templ/cmd/templ generate +//go:generate esbuild js/main.mjs --sourcemap --minify --bundle --outfile=static/js/main.mjs +//go:generate gzip -f -k static/js/main.mjs +//go:generate zstd -f -k --ultra -22 static/js/main.mjs +//go:generate brotli -fZk static/js/main.mjs + +func doHealthCheck() error { + resp, err := http.Get("http://localhost" + *metricsBind + "/metrics") + if err != nil { + return fmt.Errorf("failed to fetch metrics: %w", err) + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return fmt.Errorf("unexpected status code: %d", resp.StatusCode) + } + + return nil +} + +func main() { + flagenv.Parse() + flag.Parse() + + internal.InitSlog(*slogLevel) + + if *healthcheck { + if err := doHealthCheck(); err != nil { + log.Fatal(err) + } + return + } + + s, err := New(*target, *policyFname) + if err != nil { + log.Fatal(err) + } + + fmt.Println("Rule error IDs:") + for _, rule := range s.policy.Bots { + if rule.Action != config.RuleDeny { + continue + } + + hash, err := rule.Hash() + if err != nil { + log.Fatalf("can't calculate checksum of rule %s: %v", rule.Name, err) + } + + fmt.Printf("* %s: %s\n", rule.Name, hash) + } + fmt.Println() + + mux := http.NewServeMux() + xess.Mount(mux) + + mux.Handle(staticPath, internal.UnchangingCache(http.StripPrefix(staticPath, http.FileServerFS(static)))) + + // mux.HandleFunc("GET /.within.website/x/cmd/anubis/static/js/main.mjs", serveMainJSWithBestEncoding) + + mux.HandleFunc("POST /.within.website/x/cmd/anubis/api/make-challenge", s.makeChallenge) + mux.HandleFunc("GET /.within.website/x/cmd/anubis/api/pass-challenge", s.passChallenge) + mux.HandleFunc("GET /.within.website/x/cmd/anubis/api/test-error", s.testError) + + if *robotsTxt { + mux.HandleFunc("/robots.txt", func(w http.ResponseWriter, r *http.Request) { + http.ServeFileFS(w, r, static, "static/robots.txt") + }) + + mux.HandleFunc("/.well-known/robots.txt", func(w http.ResponseWriter, r *http.Request) { + http.ServeFileFS(w, r, static, "static/robots.txt") + }) + } + + if *metricsBind != "" { + go metricsServer() + } + + mux.HandleFunc("/", s.maybeReverseProxy) + + slog.Info("listening", "url", "http://localhost"+*bind, "difficulty", *challengeDifficulty, "serveRobotsTXT", *robotsTxt, "target", *target, "version", anubis.Version) + log.Fatal(http.ListenAndServe(*bind, mux)) +} + +func metricsServer() { + http.DefaultServeMux.Handle("/metrics", promhttp.Handler()) + slog.Debug("listening for metrics", "url", "http://localhost"+*metricsBind) + log.Fatal(http.ListenAndServe(*metricsBind, nil)) +} + +func sha256sum(text string) (string, error) { + hash := sha256.New() + _, err := hash.Write([]byte(text)) + if err != nil { + return "", err + } + return hex.EncodeToString(hash.Sum(nil)), nil +} + +func (s *Server) challengeFor(r *http.Request) string { + fp := sha256.Sum256(s.priv.Seed()) + + data := fmt.Sprintf( + "Accept-Language=%s,X-Real-IP=%s,User-Agent=%s,WeekTime=%s,Fingerprint=%x,Difficulty=%d", + r.Header.Get("Accept-Language"), + r.Header.Get("X-Real-Ip"), + r.UserAgent(), + time.Now().UTC().Round(24*7*time.Hour).Format(time.RFC3339), + fp, + *challengeDifficulty, + ) + result, _ := sha256sum(data) + return result +} + +func New(target, policyFname string) (*Server, error) { + u, err := url.Parse(target) + if err != nil { + return nil, fmt.Errorf("failed to parse target URL: %w", err) + } + + pub, priv, err := ed25519.GenerateKey(rand.Reader) + if err != nil { + return nil, fmt.Errorf("failed to generate ed25519 key: %w", err) + } + + rp := httputil.NewSingleHostReverseProxy(u) + + var fin io.ReadCloser + + if policyFname != "" { + fin, err = os.Open(policyFname) + if err != nil { + return nil, fmt.Errorf("can't parse policy file %s: %w", policyFname, err) + } + } else { + policyFname = "(static)/botPolicies.json" + fin, err = static.Open("botPolicies.json") + if err != nil { + return nil, fmt.Errorf("[unexpected] can't parse builtin policy file %s: %w", policyFname, err) + } + } + + defer fin.Close() + + policy, err := parseConfig(fin, policyFname) + if err != nil { + return nil, err // parseConfig sets a fancy error for us + } + + return &Server{ + rp: rp, + priv: priv, + pub: pub, + policy: policy, + dnsblCache: NewDecayMap[string, dnsbl.DroneBLResponse](), + }, nil +} + +type Server struct { + rp *httputil.ReverseProxy + priv ed25519.PrivateKey + pub ed25519.PublicKey + policy *ParsedConfig + dnsblCache *DecayMap[string, dnsbl.DroneBLResponse] +} + +func (s *Server) maybeReverseProxy(w http.ResponseWriter, r *http.Request) { + cr, rule := s.check(r) + r.Header.Add("X-Anubis-Rule", cr.Name) + r.Header.Add("X-Anubis-Action", string(cr.Rule)) + lg := slog.With( + "check_result", cr, + "user_agent", r.UserAgent(), + "accept_language", r.Header.Get("Accept-Language"), + "priority", r.Header.Get("Priority"), + "x-forwarded-for", + r.Header.Get("X-Forwarded-For"), + "x-real-ip", r.Header.Get("X-Real-Ip"), + ) + policyApplications.WithLabelValues(cr.Name, string(cr.Rule)).Add(1) + + ip := r.Header.Get("X-Real-Ip") + + if s.policy.DNSBL && ip != "" { + resp, ok := s.dnsblCache.Get(ip) + if !ok { + lg.Debug("looking up ip in dnsbl") + resp, err := dnsbl.Lookup(ip) + if err != nil { + lg.Error("can't look up ip in dnsbl", "err", err) + } + s.dnsblCache.Set(ip, resp, 24*time.Hour) + droneBLHits.WithLabelValues(resp.String()).Inc() + } + + if resp != dnsbl.AllGood { + lg.Info("DNSBL hit", "status", resp.String()) + templ.Handler(base("Oh noes!", errorPage(fmt.Sprintf("DroneBL reported an entry: %s, see https://dronebl.org/lookup?ip=%s", resp.String(), ip))), templ.WithStatus(http.StatusOK)).ServeHTTP(w, r) + return + } + } + + switch cr.Rule { + case config.RuleAllow: + lg.Debug("allowing traffic to origin (explicit)") + s.rp.ServeHTTP(w, r) + return + case config.RuleDeny: + clearCookie(w) + lg.Info("explicit deny") + if rule == nil { + lg.Error("rule is nil, cannot calculate checksum") + templ.Handler(base("Oh noes!", errorPage("Other internal server error (contact the admin)")), templ.WithStatus(http.StatusInternalServerError)).ServeHTTP(w, r) + return + } + hash, err := rule.Hash() + if err != nil { + lg.Error("can't calculate checksum of rule", "err", err) + templ.Handler(base("Oh noes!", errorPage("Other internal server error (contact the admin)")), templ.WithStatus(http.StatusInternalServerError)).ServeHTTP(w, r) + return + } + lg.Debug("rule hash", "hash", hash) + templ.Handler(base("Oh noes!", errorPage(fmt.Sprintf("Access Denied: error code %s", hash))), templ.WithStatus(http.StatusOK)).ServeHTTP(w, r) + return + case config.RuleChallenge: + lg.Debug("challenge requested") + default: + clearCookie(w) + templ.Handler(base("Oh noes!", errorPage("Other internal server error (contact the admin)")), templ.WithStatus(http.StatusInternalServerError)).ServeHTTP(w, r) + return + } + + ckie, err := r.Cookie(cookieName) + if err != nil { + lg.Debug("cookie not found", "path", r.URL.Path) + clearCookie(w) + s.renderIndex(w, r) + return + } + + if err := ckie.Valid(); err != nil { + lg.Debug("cookie is invalid", "err", err) + clearCookie(w) + s.renderIndex(w, r) + return + } + + if time.Now().After(ckie.Expires) && !ckie.Expires.IsZero() { + lg.Debug("cookie expired", "path", r.URL.Path) + clearCookie(w) + s.renderIndex(w, r) + return + } + + token, err := jwt.ParseWithClaims(ckie.Value, jwt.MapClaims{}, func(token *jwt.Token) (interface{}, error) { + return s.pub, nil + }) + + if !token.Valid { + lg.Debug("invalid token", "path", r.URL.Path) + clearCookie(w) + s.renderIndex(w, r) + return + } + + claims := token.Claims.(jwt.MapClaims) + + exp, ok := claims["exp"].(float64) + if !ok { + lg.Debug("exp is not int64", "ok", ok, "typeof(exp)", fmt.Sprintf("%T", exp)) + clearCookie(w) + s.renderIndex(w, r) + return + } + + if exp := time.Unix(int64(exp), 0); time.Now().After(exp) { + lg.Debug("token has expired", "exp", exp.Format(time.RFC3339)) + clearCookie(w) + s.renderIndex(w, r) + return + } + + if token.Valid && randomJitter() { + r.Header.Add("X-Anubis-Status", "PASS-BRIEF") + lg.Debug("cookie is not enrolled into secondary screening") + s.rp.ServeHTTP(w, r) + return + } + + if claims["challenge"] != s.challengeFor(r) { + lg.Debug("invalid challenge", "path", r.URL.Path) + clearCookie(w) + s.renderIndex(w, r) + return + } + + var nonce int + + if v, ok := claims["nonce"].(float64); ok { + nonce = int(v) + } + + calcString := fmt.Sprintf("%s%d", s.challengeFor(r), nonce) + calculated, err := sha256sum(calcString) + if err != nil { + lg.Error("failed to calculate sha256sum", "path", r.URL.Path, "err", err) + clearCookie(w) + http.Error(w, err.Error(), http.StatusInternalServerError) + return + } + + if subtle.ConstantTimeCompare([]byte(claims["response"].(string)), []byte(calculated)) != 1 { + lg.Debug("invalid response", "path", r.URL.Path) + failedValidations.Inc() + clearCookie(w) + s.renderIndex(w, r) + return + } + + slog.Debug("all checks passed") + r.Header.Add("X-Anubis-Status", "PASS-FULL") + s.rp.ServeHTTP(w, r) +} + +func (s *Server) renderIndex(w http.ResponseWriter, r *http.Request) { + templ.Handler( + base("Making sure you're not a bot!", index()), + ).ServeHTTP(w, r) +} + +func (s *Server) makeChallenge(w http.ResponseWriter, r *http.Request) { + challenge := s.challengeFor(r) + difficulty := *challengeDifficulty + + lg := slog.With("user_agent", r.UserAgent(), "accept_language", r.Header.Get("Accept-Language"), "priority", r.Header.Get("Priority"), "x-forwarded-for", r.Header.Get("X-Forwarded-For"), "x-real-ip", r.Header.Get("X-Real-Ip")) + + json.NewEncoder(w).Encode(struct { + Challenge string `json:"challenge"` + Difficulty int `json:"difficulty"` + }{ + Challenge: challenge, + Difficulty: difficulty, + }) + lg.Debug("made challenge", "challenge", challenge, "difficulty", difficulty) + challengesIssued.Inc() +} + +func (s *Server) passChallenge(w http.ResponseWriter, r *http.Request) { + lg := slog.With("user_agent", r.UserAgent(), "accept_language", r.Header.Get("Accept-Language"), "priority", r.Header.Get("Priority"), "x-forwarded-for", r.Header.Get("X-Forwarded-For"), "x-real-ip", r.Header.Get("X-Real-Ip")) + + nonceStr := r.FormValue("nonce") + if nonceStr == "" { + clearCookie(w) + lg.Debug("no nonce") + templ.Handler(base("Oh noes!", errorPage("missing nonce")), templ.WithStatus(http.StatusInternalServerError)).ServeHTTP(w, r) + return + } + + elapsedTimeStr := r.FormValue("elapsedTime") + if elapsedTimeStr == "" { + clearCookie(w) + lg.Debug("no elapsedTime") + templ.Handler(base("Oh noes!", errorPage("missing elapsedTime")), templ.WithStatus(http.StatusInternalServerError)).ServeHTTP(w, r) + return + } + + elapsedTime, err := strconv.ParseFloat(elapsedTimeStr, 64) + if err != nil { + clearCookie(w) + lg.Debug("elapsedTime doesn't parse", "err", err) + templ.Handler(base("Oh noes!", errorPage("invalid elapsedTime")), templ.WithStatus(http.StatusInternalServerError)).ServeHTTP(w, r) + return + } + + lg.Info("challenge took", "elapsedTime", elapsedTime) + timeTaken.Observe(elapsedTime) + + response := r.FormValue("response") + redir := r.FormValue("redir") + + challenge := s.challengeFor(r) + + nonce, err := strconv.Atoi(nonceStr) + if err != nil { + clearCookie(w) + lg.Debug("nonce doesn't parse", "err", err) + templ.Handler(base("Oh noes!", errorPage("invalid nonce")), templ.WithStatus(http.StatusInternalServerError)).ServeHTTP(w, r) + return + } + + calcString := fmt.Sprintf("%s%d", challenge, nonce) + calculated, err := sha256sum(calcString) + if err != nil { + clearCookie(w) + lg.Debug("can't parse shasum", "err", err) + templ.Handler(base("Oh noes!", errorPage("failed to calculate sha256sum")), templ.WithStatus(http.StatusInternalServerError)).ServeHTTP(w, r) + return + } + + if subtle.ConstantTimeCompare([]byte(response), []byte(calculated)) != 1 { + clearCookie(w) + lg.Debug("hash does not match", "got", response, "want", calculated) + templ.Handler(base("Oh noes!", errorPage("invalid response")), templ.WithStatus(http.StatusForbidden)).ServeHTTP(w, r) + failedValidations.Inc() + return + } + + // compare the leading zeroes + if !strings.HasPrefix(response, strings.Repeat("0", *challengeDifficulty)) { + clearCookie(w) + lg.Debug("difficulty check failed", "response", response, "difficulty", *challengeDifficulty) + templ.Handler(base("Oh noes!", errorPage("invalid response")), templ.WithStatus(http.StatusForbidden)).ServeHTTP(w, r) + failedValidations.Inc() + return + } + + // generate JWT cookie + token := jwt.NewWithClaims(jwt.SigningMethodEdDSA, jwt.MapClaims{ + "challenge": challenge, + "nonce": nonce, + "response": response, + "iat": time.Now().Unix(), + "nbf": time.Now().Add(-1 * time.Minute).Unix(), + "exp": time.Now().Add(24 * 7 * time.Hour).Unix(), + }) + tokenString, err := token.SignedString(s.priv) + if err != nil { + lg.Error("failed to sign JWT", "err", err) + clearCookie(w) + templ.Handler(base("Oh noes!", errorPage("failed to sign JWT")), templ.WithStatus(http.StatusInternalServerError)).ServeHTTP(w, r) + return + } + + http.SetCookie(w, &http.Cookie{ + Name: cookieName, + Value: tokenString, + Expires: time.Now().Add(24 * 7 * time.Hour), + SameSite: http.SameSiteLaxMode, + Path: "/", + }) + + challengesValidated.Inc() + lg.Debug("challenge passed, redirecting to app") + http.Redirect(w, r, redir, http.StatusFound) +} + +func (s *Server) testError(w http.ResponseWriter, r *http.Request) { + err := r.FormValue("err") + templ.Handler(base("Oh noes!", errorPage(err)), templ.WithStatus(http.StatusInternalServerError)).ServeHTTP(w, r) +} + +func ohNoes(w http.ResponseWriter, r *http.Request, err error) { + slog.Error("super fatal error", "err", err) + templ.Handler(base("Oh noes!", errorPage("An internal server error happened")), templ.WithStatus(http.StatusInternalServerError)).ServeHTTP(w, r) +} + +func clearCookie(w http.ResponseWriter) { + http.SetCookie(w, &http.Cookie{ + Name: cookieName, + Value: "", + Expires: time.Now().Add(-1 * time.Hour), + MaxAge: -1, + SameSite: http.SameSiteLaxMode, + }) +} + +func randomJitter() bool { + return mrand.Intn(100) > 10 +} + +func serveMainJSWithBestEncoding(w http.ResponseWriter, r *http.Request) { + priorityList := []string{"zstd", "br", "gzip"} + enc2ext := map[string]string{ + "zstd": "zst", + "br": "br", + "gzip": "gz", + } + + for _, enc := range priorityList { + if strings.Contains(r.Header.Get("Accept-Encoding"), enc) { + w.Header().Set("Content-Type", "text/javascript") + w.Header().Set("Content-Encoding", enc) + http.ServeFileFS(w, r, static, "static/js/main.mjs."+enc2ext[enc]) + return + } + } + + w.Header().Set("Content-Type", "text/javascript") + http.ServeFileFS(w, r, static, "static/js/main.mjs") +} diff --git a/cmd/anubis/policy.go b/cmd/anubis/policy.go new file mode 100644 index 0000000..f636349 --- /dev/null +++ b/cmd/anubis/policy.go @@ -0,0 +1,146 @@ +package main + +import ( + "encoding/json" + "errors" + "fmt" + "io" + "log/slog" + "net/http" + "regexp" + + "github.com/TecharoHQ/anubis/cmd/anubis/internal/config" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promauto" +) + +var ( + policyApplications = promauto.NewCounterVec(prometheus.CounterOpts{ + Name: "anubis_policy_results", + Help: "The results of each policy rule", + }, []string{"rule", "action"}) +) + +type ParsedConfig struct { + orig config.Config + + Bots []Bot + DNSBL bool +} + +type Bot struct { + Name string + UserAgent *regexp.Regexp + Path *regexp.Regexp + Action config.Rule `json:"action"` +} + +func (b Bot) Hash() (string, error) { + var pathRex string + if b.Path != nil { + pathRex = b.Path.String() + } + var userAgentRex string + if b.UserAgent != nil { + userAgentRex = b.UserAgent.String() + } + + return sha256sum(fmt.Sprintf("%s::%s::%s", b.Name, pathRex, userAgentRex)) +} + +func parseConfig(fin io.Reader, fname string) (*ParsedConfig, error) { + var c config.Config + if err := json.NewDecoder(fin).Decode(&c); err != nil { + return nil, fmt.Errorf("can't parse policy config JSON %s: %w", fname, err) + } + + if err := c.Valid(); err != nil { + return nil, err + } + + var err error + + result := &ParsedConfig{ + orig: c, + } + + for _, b := range c.Bots { + if berr := b.Valid(); berr != nil { + err = errors.Join(err, berr) + continue + } + + var botParseErr error + parsedBot := Bot{ + Name: b.Name, + Action: b.Action, + } + + if b.UserAgentRegex != nil { + userAgent, err := regexp.Compile(*b.UserAgentRegex) + if err != nil { + botParseErr = errors.Join(botParseErr, fmt.Errorf("while compiling user agent regexp: %w", err)) + continue + } else { + parsedBot.UserAgent = userAgent + } + } + + if b.PathRegex != nil { + path, err := regexp.Compile(*b.PathRegex) + if err != nil { + botParseErr = errors.Join(botParseErr, fmt.Errorf("while compiling path regexp: %w", err)) + continue + } else { + parsedBot.Path = path + } + } + + result.Bots = append(result.Bots, parsedBot) + } + + if err != nil { + return nil, fmt.Errorf("errors validating policy config JSON %s: %w", fname, err) + } + + result.DNSBL = c.DNSBL + + return result, nil +} + +type CheckResult struct { + Name string + Rule config.Rule +} + +func (cr CheckResult) LogValue() slog.Value { + return slog.GroupValue( + slog.String("name", cr.Name), + slog.String("rule", string(cr.Rule))) +} + +func cr(name string, rule config.Rule) CheckResult { + return CheckResult{ + Name: name, + Rule: rule, + } +} + +// Check evaluates the list of rules, and returns the result +func (s *Server) check(r *http.Request) (CheckResult, *Bot) { + for _, b := range s.policy.Bots { + if b.UserAgent != nil { + if b.UserAgent.MatchString(r.UserAgent()) { + return cr("bot/"+b.Name, b.Action), &b + } + } + + if b.Path != nil { + if b.Path.MatchString(r.URL.Path) { + return cr("bot/"+b.Name, b.Action), &b + } + } + } + + return cr("default/allow", config.RuleAllow), nil +} diff --git a/cmd/anubis/policy_test.go b/cmd/anubis/policy_test.go new file mode 100644 index 0000000..9a5699e --- /dev/null +++ b/cmd/anubis/policy_test.go @@ -0,0 +1,65 @@ +package main + +import ( + "os" + "path/filepath" + "testing" +) + +func TestDefaultPolicyMustParse(t *testing.T) { + fin, err := static.Open("botPolicies.json") + if err != nil { + t.Fatal(err) + } + defer fin.Close() + + if _, err := parseConfig(fin, "botPolicies.json"); err != nil { + t.Fatalf("can't parse config: %v", err) + } +} + +func TestGoodConfigs(t *testing.T) { + finfos, err := os.ReadDir("internal/config/testdata/good") + if err != nil { + t.Fatal(err) + } + + for _, st := range finfos { + st := st + t.Run(st.Name(), func(t *testing.T) { + fin, err := os.Open(filepath.Join("internal", "config", "testdata", "good", st.Name())) + if err != nil { + t.Fatal(err) + } + defer fin.Close() + + if _, err := parseConfig(fin, fin.Name()); err != nil { + t.Fatal(err) + } + }) + } +} + +func TestBadConfigs(t *testing.T) { + finfos, err := os.ReadDir("internal/config/testdata/bad") + if err != nil { + t.Fatal(err) + } + + for _, st := range finfos { + st := st + t.Run(st.Name(), func(t *testing.T) { + fin, err := os.Open(filepath.Join("internal", "config", "testdata", "bad", st.Name())) + if err != nil { + t.Fatal(err) + } + defer fin.Close() + + if _, err := parseConfig(fin, fin.Name()); err == nil { + t.Fatal(err) + } else { + t.Log(err) + } + }) + } +} diff --git a/cmd/anubis/static/img/happy.webp b/cmd/anubis/static/img/happy.webp new file mode 100644 index 0000000000000000000000000000000000000000..8a4963164cb275b251284273624d79b6ffa8b969 GIT binary patch literal 60572 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

)b0z{~$5J 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 R<4{`r|H=3O00000001F(R1^RJ literal 0 HcmV?d00001 diff --git a/cmd/anubis/static/img/pensive.webp b/cmd/anubis/static/img/pensive.webp new file mode 100644 index 0000000000000000000000000000000000000000..dc3dff106b691c8734aff028b68d7de401021c03 GIT binary patch literal 49148 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 literal 0 HcmV?d00001 diff --git a/cmd/anubis/static/img/sad.webp b/cmd/anubis/static/img/sad.webp new file mode 100644 index 0000000000000000000000000000000000000000..95bebb691bbde01d6688123595cb9c19254add03 GIT binary patch literal 50802 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 XxmtnlV*md^yZ`_I0000000000%nMXB literal 0 HcmV?d00001 diff --git a/cmd/anubis/static/js/main.mjs b/cmd/anubis/static/js/main.mjs new file mode 100644 index 0000000..043f617 --- /dev/null +++ b/cmd/anubis/static/js/main.mjs @@ -0,0 +1,2 @@ +(()=>{function l(n,s=5){return new Promise((i,e)=>{let o=URL.createObjectURL(new Blob(["(",w(),")()"],{type:"application/javascript"})),t=new Worker(o);t.onmessage=r=>{t.terminate(),i(r.data)},t.onerror=r=>{t.terminate(),e()},t.postMessage({data:n,difficulty:s}),URL.revokeObjectURL(o)})}function w(){return function(){let n=s=>{let i=new TextEncoder().encode(s);return crypto.subtle.digest("SHA-256",i.buffer).then(e=>Array.from(new Uint8Array(e)).map(o=>o.toString(16).padStart(2,"0")).join(""))};addEventListener("message",async s=>{let i=s.data.data,e=s.data.difficulty,o,t=0;do o=await n(i+t++);while(o.substring(0,e)!==Array(e+1).join("0"));t-=1,postMessage({hash:o,data:i,difficulty:e,nonce:t})})}.toString()}var h=(n="",s={})=>{let i=new URL(n,window.location.href);return Object.entries(s).forEach(e=>{let[o,t]=e;i.searchParams.set(o,t)}),i.toString()},m=n=>`/.within.website/x/cmd/anubis/static/img/${n}.webp`;(async()=>{let n=document.getElementById("status"),s=document.getElementById("image"),i=document.getElementById("title"),e=document.getElementById("spinner");n.innerHTML="Calculating...";let{challenge:o,difficulty:t}=await fetch("/.within.website/x/cmd/anubis/api/make-challenge",{method:"POST"}).then(a=>{if(!a.ok)throw new Error("Failed to fetch config");return a.json()}).catch(a=>{throw i.innerHTML="Oh no!",n.innerHTML=`Failed to fetch config: ${a.message}`,s.src=m("sad"),e.innerHTML="",e.style.display="none",a});n.innerHTML=`Calculating...
Difficulty: ${t}`;let r=Date.now(),{hash:u,nonce:c}=await l(o,t),d=Date.now();i.innerHTML="Success!",n.innerHTML=`Done! Took ${d-r}ms, ${c} iterations`,s.src=m("happy"),e.innerHTML="",e.style.display="none",setTimeout(()=>{let a=window.location.href;window.location.href=h("/.within.website/x/cmd/anubis/api/pass-challenge",{response:u,nonce:c,redir:a,elapsedTime:d-r})},2e3)})();})(); +//# sourceMappingURL=main.mjs.map diff --git a/cmd/anubis/static/js/main.mjs.br b/cmd/anubis/static/js/main.mjs.br new file mode 100644 index 0000000000000000000000000000000000000000..27625da8d8e1ac10fbaf5f0c90388dc900210253 GIT binary patch literal 802 zcmV+-1Ks?w7&`zV+fwU)pO>R+(nP^qsy(_=%Bz~h%7qm009!o_9WD(dkjTPCkm#-U zUK~i6wtvurK2d9Q&hDvvuvrcw$)gb}dyAfv9P3hx*Q?n%4k9{M_&Zz8Rgj5d_J=!%A+xx zo=A$bBC*40%3!3zu&AW1AXSPm5Iuw&lsJamYdkYfut|luK%7x8!zLD}P(hCF3h`1e zun-*buDvvzU2g!7F|c*!9xF{m zGOwNPXA9==Y@27Y&!mF$7NiPHF$QN;_Htuvav@P&$(2+j_w$vY7XVH&7NQK|(UHvl zJnCTbON<6j#zbZrqBrft8e8SB!1<48>&!O(tMh%7G-KdQh1lh(oOj~oQCAynE-^y+ zOMP80c71LA#oVP@_@SZ=*7rtV;9Nu3A~mQ;Yk4sTSddQy;&ehP0&LiHwCwVhP1U7g zI(lP3tv4R^srMUUjWN(}HIMTgG!V$A$%R$)OUB-`V;A?72%I?YB#AG|;gDadBhAv-L4ae}EDbLl8x ztfKgWQ0apj#?mCYkR0iP3ZgC7&T|hv*p`?KC$8x}_#$|n4CbQn-q_D#*(E-tE=uLH zM#1V&D`Z)_v#+;VJoaB{MQ%s7-%l=V1>06H4yVzLPtsRo~`4TqeeL#f| g^pFbSbf=r^`fd+)WH67epWi-6MV)cCP8wQx2lH);%m4rY literal 0 HcmV?d00001 diff --git a/cmd/anubis/static/js/main.mjs.gz b/cmd/anubis/static/js/main.mjs.gz new file mode 100644 index 0000000000000000000000000000000000000000..3715f0b9f23d7f6ff6843bc64d46a7f83fa53ec9 GIT binary patch literal 985 zcmV;~119_*iwFqhuGnV)18rexZZ2(Va{!H0UvJws5P$EdP`Eyj2ty?qS`5}0pj|Sw zK!OBwiaitsOj9R|i9`w{71uEI-FK87#~#w64;D!Jc)Z`AJ4%_nSXaH((Kwqm)bb$T zv9*WTdz)EUW_RATCIF>|LkeynW=?+j=UQkFD#Gpj0d&MYP0=44H>Y0-C45O4CyX-k zjj!XXg9%Yx*BGtROZkI(QbBvuMKUnPqfD3ob^Z}Nb*zZO*%m@j3y>ZkjUs|?jm7sc zt)X6&Dk?Vc6bRls|4JDCQb6ZIyxHWU>vU~md1HWwk322@^1`Xkf+mw)U$oIuZJLY(SJ|0U=T{{q*7F z{M~!PjhOdU1)hmmgQXxZK6tNIqCyo$g1;CW{}|6GFeX~nQ712)h;ACau?u?ko{3JC z)2Mu;=bW4p40~|KQi7|YP-S`b1U6oq5COTPWJ@&RDy*!|Uf_h0Yf;|Ds`D%2ClN4d|x}|8`#)hKyQ0=7IXpfR%MhK{x zsGPr2x=u2rR9_MBHwlFi0hHJEo${&;xQP`1!Fo`>y@Gfvt-P4!VrgP+tXRT4mq+qE51P&X^+CCABRMPcEk|)$xEHF=oi8YE5_BQ`4qKm85Rp~#b7oX$@>V^<$u1k=>lR||$_cr{_2+@V<+947F-|c&ihKf*0jZIhw_&^)u|8;Jmn#DST($m#66V8 zPjKorstZu2q9zF}HuX9Dj#fdo#?PBP|1Ary_Zn^xDoTTcMz#tIXdglv&u{(%@gJ}0 HWCs8ME)(F0 literal 0 HcmV?d00001 diff --git a/cmd/anubis/static/js/main.mjs.map b/cmd/anubis/static/js/main.mjs.map new file mode 100644 index 0000000..d5b288f --- /dev/null +++ b/cmd/anubis/static/js/main.mjs.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../js/proof-of-work.mjs", "../../js/main.mjs"], + "sourcesContent": ["// https://dev.to/ratmd/simple-proof-of-work-in-javascript-3kgm\n\nexport function process(data, difficulty = 5) {\n return new Promise((resolve, reject) => {\n let webWorkerURL = URL.createObjectURL(new Blob([\n '(', processTask(), ')()'\n ], { type: 'application/javascript' }));\n\n let worker = new Worker(webWorkerURL);\n\n worker.onmessage = (event) => {\n worker.terminate();\n resolve(event.data);\n };\n\n worker.onerror = (event) => {\n worker.terminate();\n reject();\n };\n\n worker.postMessage({\n data,\n difficulty\n });\n\n URL.revokeObjectURL(webWorkerURL);\n });\n}\n\nfunction processTask() {\n return function () {\n const sha256 = (text) => {\n const encoded = new TextEncoder().encode(text);\n return crypto.subtle.digest(\"SHA-256\", encoded.buffer).then((result) =>\n Array.from(new Uint8Array(result))\n .map((c) => c.toString(16).padStart(2, \"0\"))\n .join(\"\"),\n );\n };\n\n addEventListener('message', async (event) => {\n let data = event.data.data;\n let difficulty = event.data.difficulty;\n\n let hash;\n let nonce = 0;\n do {\n hash = await sha256(data + nonce++);\n } while (hash.substring(0, difficulty) !== Array(difficulty + 1).join('0'));\n\n nonce -= 1; // last nonce was post-incremented\n\n postMessage({\n hash,\n data,\n difficulty,\n nonce,\n });\n });\n }.toString();\n}\n\n", "import { process } from './proof-of-work.mjs';\nimport { testVideo } from './video.mjs';\n\n// from Xeact\nconst u = (url = \"\", params = {}) => {\n let result = new URL(url, window.location.href);\n Object.entries(params).forEach((kv) => {\n let [k, v] = kv;\n result.searchParams.set(k, v);\n });\n return result.toString();\n};\n\nconst imageURL = (mood) => {\n return `/.within.website/x/cmd/anubis/static/img/${mood}.webp`;\n};\n\n(async () => {\n const status = document.getElementById('status');\n const image = document.getElementById('image');\n const title = document.getElementById('title');\n const spinner = document.getElementById('spinner');\n // const testarea = document.getElementById('testarea');\n\n // const videoWorks = await testVideo(testarea);\n // console.log(`videoWorks: ${videoWorks}`);\n\n // if (!videoWorks) {\n // title.innerHTML = \"Oh no!\";\n // status.innerHTML = \"Checks failed. Please check your browser's settings and try again.\";\n // image.src = imageURL(\"sad\");\n // spinner.innerHTML = \"\";\n // spinner.style.display = \"none\";\n // return;\n // }\n\n status.innerHTML = 'Calculating...';\n\n const { challenge, difficulty } = await fetch(\"/.within.website/x/cmd/anubis/api/make-challenge\", { method: \"POST\" })\n .then(r => {\n if (!r.ok) {\n throw new Error(\"Failed to fetch config\");\n }\n return r.json();\n })\n .catch(err => {\n title.innerHTML = \"Oh no!\";\n status.innerHTML = `Failed to fetch config: ${err.message}`;\n image.src = imageURL(\"sad\");\n spinner.innerHTML = \"\";\n spinner.style.display = \"none\";\n throw err;\n });\n\n status.innerHTML = `Calculating...
Difficulty: ${difficulty}`;\n\n const t0 = Date.now();\n const { hash, nonce } = await process(challenge, difficulty);\n const t1 = Date.now();\n\n title.innerHTML = \"Success!\";\n status.innerHTML = `Done! Took ${t1 - t0}ms, ${nonce} iterations`;\n image.src = imageURL(\"happy\");\n spinner.innerHTML = \"\";\n spinner.style.display = \"none\";\n\n setTimeout(() => {\n const redir = window.location.href;\n window.location.href = u(\"/.within.website/x/cmd/anubis/api/pass-challenge\", { response: hash, nonce, redir, elapsedTime: t1 - t0 });\n }, 2000);\n})();"], + "mappings": "MAEO,SAASA,EAAQC,EAAMC,EAAa,EAAG,CAC5C,OAAO,IAAI,QAAQ,CAACC,EAASC,IAAW,CACtC,IAAIC,EAAe,IAAI,gBAAgB,IAAI,KAAK,CAC9C,IAAKC,EAAY,EAAG,KACtB,EAAG,CAAE,KAAM,wBAAyB,CAAC,CAAC,EAElCC,EAAS,IAAI,OAAOF,CAAY,EAEpCE,EAAO,UAAaC,GAAU,CAC5BD,EAAO,UAAU,EACjBJ,EAAQK,EAAM,IAAI,CACpB,EAEAD,EAAO,QAAWC,GAAU,CAC1BD,EAAO,UAAU,EACjBH,EAAO,CACT,EAEAG,EAAO,YAAY,CACjB,KAAAN,EACA,WAAAC,CACF,CAAC,EAED,IAAI,gBAAgBG,CAAY,CAClC,CAAC,CACH,CAEA,SAASC,GAAc,CACrB,OAAO,UAAY,CACjB,IAAMG,EAAUC,GAAS,CACvB,IAAMC,EAAU,IAAI,YAAY,EAAE,OAAOD,CAAI,EAC7C,OAAO,OAAO,OAAO,OAAO,UAAWC,EAAQ,MAAM,EAAE,KAAMC,GAC3D,MAAM,KAAK,IAAI,WAAWA,CAAM,CAAC,EAC9B,IAAKC,GAAMA,EAAE,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,CAAC,EAC1C,KAAK,EAAE,CACZ,CACF,EAEA,iBAAiB,UAAW,MAAOL,GAAU,CAC3C,IAAIP,EAAOO,EAAM,KAAK,KAClBN,EAAaM,EAAM,KAAK,WAExBM,EACAC,EAAQ,EACZ,GACED,EAAO,MAAML,EAAOR,EAAOc,GAAO,QAC3BD,EAAK,UAAU,EAAGZ,CAAU,IAAM,MAAMA,EAAa,CAAC,EAAE,KAAK,GAAG,GAEzEa,GAAS,EAET,YAAY,CACV,KAAAD,EACA,KAAAb,EACA,WAAAC,EACA,MAAAa,CACF,CAAC,CACH,CAAC,CACH,EAAE,SAAS,CACb,CCxDA,IAAMC,EAAI,CAACC,EAAM,GAAIC,EAAS,CAAC,IAAM,CACnC,IAAIC,EAAS,IAAI,IAAIF,EAAK,OAAO,SAAS,IAAI,EAC9C,cAAO,QAAQC,CAAM,EAAE,QAASE,GAAO,CACrC,GAAI,CAACC,EAAGC,CAAC,EAAIF,EACbD,EAAO,aAAa,IAAIE,EAAGC,CAAC,CAC9B,CAAC,EACMH,EAAO,SAAS,CACzB,EAEMI,EAAYC,GACT,4CAA4CA,CAAI,SAGxD,SAAY,CACX,IAAMC,EAAS,SAAS,eAAe,QAAQ,EACzCC,EAAQ,SAAS,eAAe,OAAO,EACvCC,EAAQ,SAAS,eAAe,OAAO,EACvCC,EAAU,SAAS,eAAe,SAAS,EAejDH,EAAO,UAAY,iBAEnB,GAAM,CAAE,UAAAI,EAAW,WAAAC,CAAW,EAAI,MAAM,MAAM,mDAAoD,CAAE,OAAQ,MAAO,CAAC,EACjH,KAAKC,GAAK,CACT,GAAI,CAACA,EAAE,GACL,MAAM,IAAI,MAAM,wBAAwB,EAE1C,OAAOA,EAAE,KAAK,CAChB,CAAC,EACA,MAAMC,GAAO,CACZ,MAAAL,EAAM,UAAY,SAClBF,EAAO,UAAY,2BAA2BO,EAAI,OAAO,GACzDN,EAAM,IAAMH,EAAS,KAAK,EAC1BK,EAAQ,UAAY,GACpBA,EAAQ,MAAM,QAAU,OAClBI,CACR,CAAC,EAEHP,EAAO,UAAY,kCAAkCK,CAAU,GAE/D,IAAMG,EAAK,KAAK,IAAI,EACd,CAAE,KAAAC,EAAM,MAAAC,CAAM,EAAI,MAAMC,EAAQP,EAAWC,CAAU,EACrDO,EAAK,KAAK,IAAI,EAEpBV,EAAM,UAAY,WAClBF,EAAO,UAAY,cAAcY,EAAKJ,CAAE,OAAOE,CAAK,cACpDT,EAAM,IAAMH,EAAS,OAAO,EAC5BK,EAAQ,UAAY,GACpBA,EAAQ,MAAM,QAAU,OAExB,WAAW,IAAM,CACf,IAAMU,EAAQ,OAAO,SAAS,KAC9B,OAAO,SAAS,KAAOtB,EAAE,mDAAoD,CAAE,SAAUkB,EAAM,MAAAC,EAAO,MAAAG,EAAO,YAAaD,EAAKJ,CAAG,CAAC,CACrI,EAAG,GAAI,CACT,GAAG", + "names": ["process", "data", "difficulty", "resolve", "reject", "webWorkerURL", "processTask", "worker", "event", "sha256", "text", "encoded", "result", "c", "hash", "nonce", "u", "url", "params", "result", "kv", "k", "v", "imageURL", "mood", "status", "image", "title", "spinner", "challenge", "difficulty", "r", "err", "t0", "hash", "nonce", "process", "t1", "redir"] +} diff --git a/cmd/anubis/static/js/main.mjs.zst b/cmd/anubis/static/js/main.mjs.zst new file mode 100644 index 0000000000000000000000000000000000000000..3f27a9ef508bce52fa235d55db9aa10926b1757a GIT binary patch literal 982 zcmV;{11bC{wJ-f-WCleZ0Cv5vB=C0IFp7Y3-Ewm{8!@BPF<|M@>mNJFLc=8mhq5u2san;#q)m3ZR(VD95+<_6!jO}d z4a0bEitX$<*Huklp*I=3#`ab6H22?6xEFQbN%s4vHJe*9`vbmfty)jjMC|~wv6E=drUnoPor}_IKX9c zqknC##ex}m?AC$;Lcv1?$71h$Vd$;&BN%@HnV!+Nl71S%EUeY);K_x65X%siV(zD)s7s;=ZMl5)N(NXc_)7D%mnevsMpIw{SU0aS> z46@KbtTgd^c`tXu#D<`3j6EV$B{u_<%fyt(ukRG+5sXv{G)2k@WuJXyGf#5#oOu)x z2Pom>*tM#?Yxe8UC!MMh#i{F$pM@ds8e~}%bz-*VHD|s&KLC_Y&q<~yStodrOi_xl zabnsX0SX1+X{=Q(VG&%_D$qKm(mJh7hIYDj*_7{eR|-B**<*Sq?)Y^LMQP-7pPec? zpQ>2^m2`JF0V`X=ePhIMJdl$j#x<5{`Sw);PDiAA2?xp?X%MN@t(7eo)Tl(c=KZZ( zkosa1jMJYxk?QGYz^RD170}X&GB}E_u`$_B@^oF;B0D<$4zv<0#bUGPoCs(rFhXMx zGxd_VaFm9yQjk#~Nhl~b?Ti7~NCKL|T>-;hD0TP= zBhB?8oNiotDO81dr|ec_`gGuCMS}ayM`tbTm_h^uF>;7=-~-F>FI`-O9S1^42S?Fg zhvR<%cp6%fhNJ{gvpw|7j^ZJ{vWr>$66L`K!@bQk_C`&-PZ6mN7E0CMjzg~_}gc{9Bh61*24Gv z;QSwV2X3d$7kOA{#RZ^l31@}3gc7UqDhyjqI4oVdeDS%(Hs83q3C~D{Fl-j(FjcYT zuH&>8UB_)f*|oM@TUy%R-*5JlNENBfn}yz4qE(t*o2Bq6N}Ck9S>vG$WatU5RqVBR zq=K{vd!ATx)*LQ#nGTKeoIz{N83@thnew`7z|CF&w9HF0L?~uoN1kXp2*Sj(WS}CS zG73caTIM^-6CECQb&*LQp@Lhj(ljwZD}$9Nv;g65<~i7cjII^A@?5bX1dpY$erbA1 zNgj2A-O?}O*eL5Qy4-d(B8=DOX;JiK7lJ?532xFP#9qb}_D_oI6_d+=&tpPv!t@Ya{x{pBb0%`1N&+|E9E%|HLvtpY37Yy9!hkgx z{f_BB0@Nqu^<&TfL#OcYhNxc;#%W16 z0;ECIc= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@sindresorhus/merge-streams": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-2.3.0.tgz", + "integrity": "sha512-LtoMMhxAlorcGhmFYI+LhPgbPZCkgP6ra1YL604EeF6U98pLlQ3iWIGMdWSC+vWmPBWBNgmDBAhnAobLROJmwg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@trysound/sax": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/@trysound/sax/-/sax-0.2.0.tgz", + "integrity": "sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=10.13.0" + } + }, + "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/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/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "license": "ISC", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/autoprefixer": { + "version": "10.4.20", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.20.tgz", + "integrity": "sha512-XY25y5xSv/wEoqzDyXXME4AFfkZI0P23z6Fs3YgymDnKJkCGOnkL0iTxCa85UTqaSgfcqyf3UA6+c7wUvx/16g==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/autoprefixer" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.3", + "caniuse-lite": "^1.0.30001646", + "fraction.js": "^4.3.7", + "normalize-range": "^0.1.2", + "picocolors": "^1.0.1", + "postcss-value-parser": "^4.2.0" + }, + "bin": { + "autoprefixer": "bin/autoprefixer" + }, + "engines": { + "node": "^10 || ^12 || >=14" + }, + "peerDependencies": { + "postcss": "^8.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/binary-extensions": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz", + "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/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": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browserslist": { + "version": "4.24.4", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.4.tgz", + "integrity": "sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==", + "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": { + "caniuse-lite": "^1.0.30001688", + "electron-to-chromium": "^1.5.73", + "node-releases": "^2.0.19", + "update-browserslist-db": "^1.1.1" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "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.30001695", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001695.tgz", + "integrity": "sha512-vHyLade6wTgI2u1ec3WQBxv+2BrTERV28UXQu9LO6lZ9pYeMk34vjXFLOxo1A4UBA8XTL4njRQZdno/yYaSmWw==", + "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/chokidar": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz", + "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", + "dev": true, + "license": "MIT", + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/cliui": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", + "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", + "dev": true, + "license": "ISC", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.1", + "wrap-ansi": "^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/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.9.3", + "resolved": "https://registry.npmjs.org/colord/-/colord-2.9.3.tgz", + "integrity": "sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==", + "dev": true, + "license": "MIT" + }, + "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/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "node_modules/css-declaration-sorter": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-7.2.0.tgz", + "integrity": "sha512-h70rUM+3PNFuaBDTLe8wF/cdWu+dOZmb7pJt8Z2sedYbAcQVQV/tEchueg3GWxwqS0cxtbxmaHEdkNACqcvsow==", + "dev": true, + "license": "ISC", + "engines": { + "node": "^14 || ^16 || >=18" + }, + "peerDependencies": { + "postcss": "^8.0.9" + } + }, + "node_modules/css-select": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.1.0.tgz", + "integrity": "sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^6.1.0", + "domhandler": "^5.0.2", + "domutils": "^3.0.1", + "nth-check": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css-tree": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-2.3.1.tgz", + "integrity": "sha512-6Fv1DV/TYw//QF5IzQdqsNDjx/wc8TrMBZsqjL9eW01tWb7R7k/mq+/VXfJCl7SoD5emsJop9cOByJZfs8hYIw==", + "dev": true, + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.30", + "source-map-js": "^1.0.1" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0" + } + }, + "node_modules/css-what": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz", + "integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==", + "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": "7.0.6", + "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-7.0.6.tgz", + "integrity": "sha512-54woqx8SCbp8HwvNZYn68ZFAepuouZW4lTwiMVnBErM3VkO7/Sd4oTOt3Zz3bPx3kxQ36aISppyXj2Md4lg8bw==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssnano-preset-default": "^7.0.6", + "lilconfig": "^3.1.2" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/cssnano" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/cssnano-preset-advanced": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cssnano-preset-advanced/-/cssnano-preset-advanced-7.0.6.tgz", + "integrity": "sha512-wk/YPSv965EjpPNEGteiXZ32BKilJcYNnX4EGUd/AriVGgHL/y59uaWVJ/ZDx69jCNUrmwiBzioCV+SG5wk3PQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "autoprefixer": "^10.4.20", + "browserslist": "^4.23.3", + "cssnano-preset-default": "^7.0.6", + "postcss-discard-unused": "^7.0.3", + "postcss-merge-idents": "^7.0.0", + "postcss-reduce-idents": "^7.0.0", + "postcss-zindex": "^7.0.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/cssnano-preset-default": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-7.0.6.tgz", + "integrity": "sha512-ZzrgYupYxEvdGGuqL+JKOY70s7+saoNlHSCK/OGn1vB2pQK8KSET8jvenzItcY+kA7NoWvfbb/YhlzuzNKjOhQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.3", + "css-declaration-sorter": "^7.2.0", + "cssnano-utils": "^5.0.0", + "postcss-calc": "^10.0.2", + "postcss-colormin": "^7.0.2", + "postcss-convert-values": "^7.0.4", + "postcss-discard-comments": "^7.0.3", + "postcss-discard-duplicates": "^7.0.1", + "postcss-discard-empty": "^7.0.0", + "postcss-discard-overridden": "^7.0.0", + "postcss-merge-longhand": "^7.0.4", + "postcss-merge-rules": "^7.0.4", + "postcss-minify-font-values": "^7.0.0", + "postcss-minify-gradients": "^7.0.0", + "postcss-minify-params": "^7.0.2", + "postcss-minify-selectors": "^7.0.4", + "postcss-normalize-charset": "^7.0.0", + "postcss-normalize-display-values": "^7.0.0", + "postcss-normalize-positions": "^7.0.0", + "postcss-normalize-repeat-style": "^7.0.0", + "postcss-normalize-string": "^7.0.0", + "postcss-normalize-timing-functions": "^7.0.0", + "postcss-normalize-unicode": "^7.0.2", + "postcss-normalize-url": "^7.0.0", + "postcss-normalize-whitespace": "^7.0.0", + "postcss-ordered-values": "^7.0.1", + "postcss-reduce-initial": "^7.0.2", + "postcss-reduce-transforms": "^7.0.0", + "postcss-svgo": "^7.0.1", + "postcss-unique-selectors": "^7.0.3" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/cssnano-utils": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/cssnano-utils/-/cssnano-utils-5.0.0.tgz", + "integrity": "sha512-Uij0Xdxc24L6SirFr25MlwC2rCFX6scyUmuKpzI+JQ7cyqDEwD42fJ0xfB3yLfOnRDU5LKGgjQ9FA6LYh76GWQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/csso": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/csso/-/csso-5.0.5.tgz", + "integrity": "sha512-0LrrStPOdJj+SPCCrGhzryycLjwcgUSHBtxNA8aIDxf0GLsRh1cKYhB00Gd1lDOS4yGH69+SNn13+TWbVHETFQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "css-tree": "~2.2.0" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0", + "npm": ">=7.0.0" + } + }, + "node_modules/csso/node_modules/css-tree": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-2.2.1.tgz", + "integrity": "sha512-OA0mILzGc1kCOCSJerOeqDxDQ4HOh+G8NbOJFOTgOCzpw7fCBubk0fEyxp8AgOL/jvLgYA/uV0cMbe43ElF1JA==", + "dev": true, + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.28", + "source-map-js": "^1.0.1" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0", + "npm": ">=7.0.0" + } + }, + "node_modules/csso/node_modules/mdn-data": { + "version": "2.0.28", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.28.tgz", + "integrity": "sha512-aylIc7Z9y4yzHYAJNuESG3hfhC+0Ibp/MAMiaOZgNv4pmEdFyfZhhhny4MNiAfWdBQ1RQ2mfDWmM1x8SvGyp8g==", + "dev": true, + "license": "CC0-1.0" + }, + "node_modules/cuint": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/cuint/-/cuint-0.2.2.tgz", + "integrity": "sha512-d4ZVpCW31eWwCMe1YT3ur7mUDnTXbgwyzaL320DrcRT45rfjYxkt5QWLrmOJ+/UEAI2+fQgKe/fCjR8l4TpRgw==", + "dev": true, + "license": "MIT" + }, + "node_modules/dependency-graph": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/dependency-graph/-/dependency-graph-0.11.0.tgz", + "integrity": "sha512-JeMq7fEshyepOWDfcfHK06N3MhyPhz++vtqWhMT5O9A3K42rdsEDpfdVqjaqaAhsw6a+ZqeDvQVtD0hFHQWrzg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.6.0" + } + }, + "node_modules/dom-serializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz", + "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==", + "dev": true, + "license": "MIT", + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "entities": "^4.2.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": "5.0.3", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz", + "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "domelementtype": "^2.3.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "node_modules/domutils": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz", + "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "dom-serializer": "^2.0.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.5.83", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.83.tgz", + "integrity": "sha512-LcUDPqSt+V0QmI47XLzZrz5OqILSMGsPFkDYus22rIbgorSvBYEFqq854ltTmUdHkY92FSdAAvsh4jWEULMdfQ==", + "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": "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/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/fast-glob": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", + "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.8" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fastq": { + "version": "1.18.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.18.0.tgz", + "integrity": "sha512-QKHXPW0hD8g4UET03SdOdunzSouc9N4AuHdsX8XNcTsuz+yYFILVNIX4l9yHABMhiEI9Db0JTTIpu0wB+Y1QQw==", + "dev": true, + "license": "ISC", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dev": true, + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/fraction.js": { + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz", + "integrity": "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==", + "dev": true, + "license": "MIT", + "engines": { + "node": "*" + }, + "funding": { + "type": "patreon", + "url": "https://github.com/sponsors/rawify" + } + }, + "node_modules/fs-extra": { + "version": "11.3.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.0.tgz", + "integrity": "sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==", + "dev": true, + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=14.14" + } + }, + "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-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true, + "license": "ISC", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-stdin": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/get-stdin/-/get-stdin-9.0.0.tgz", + "integrity": "sha512-dVKBjfWisLAicarI2Sf+JuBE/DghV4UzNAVe9yhEJuzeREd3JhOTE9cUaJTeSa77fsbQUK3pcOpJfM59+VKZaA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/globby": { + "version": "14.0.2", + "resolved": "https://registry.npmjs.org/globby/-/globby-14.0.2.tgz", + "integrity": "sha512-s3Fq41ZVh7vbbe2PN3nrW7yC7U7MFVc5c98/iTl9c2GawNMKx/J648KQRW6WKkuU8GIbbh2IXfIRQjOZnXcTnw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@sindresorhus/merge-streams": "^2.1.0", + "fast-glob": "^3.3.2", + "ignore": "^5.2.4", + "path-type": "^5.0.0", + "slash": "^5.1.0", + "unicorn-magic": "^0.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/http-https": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/http-https/-/http-https-1.0.0.tgz", + "integrity": "sha512-o0PWwVCSp3O0wS6FvNr6xfBCHgt0m1tvPLFOCc2iFDKTRAXhB7m8klDf7ErowFH8POa6dVdGatKU5I1YYwzUyg==", + "dev": true, + "license": "ISC" + }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dev": true, + "license": "MIT", + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-core-module": { + "version": "2.16.1", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", + "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "dev": true, + "license": "MIT", + "dependencies": { + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-url": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/is-url/-/is-url-1.2.4.tgz", + "integrity": "sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==", + "dev": true, + "license": "MIT" + }, + "node_modules/jsonfile": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", + "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/lilconfig": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz", + "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antonk52" + } + }, + "node_modules/lodash.assign": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.assign/-/lodash.assign-4.2.0.tgz", + "integrity": "sha512-hFuH8TY+Yji7Eja3mGiuAxBqLagejScbG8GbG0j6o9vzn0YL14My+ktnqtZgFTosKymC9/44wP6s7xyuLfnClw==", + "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.trim": { + "version": "4.5.1", + "resolved": "https://registry.npmjs.org/lodash.trim/-/lodash.trim-4.5.1.tgz", + "integrity": "sha512-nJAlRl/K+eiOehWKDzoBVrSMhK0K3A3YQsUNXHQa5yIrKBAhsZgSu3KoAFoFT+mEgiyBHddZ0pRk1ITpIp90Wg==", + "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/make-dir": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz", + "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "semver": "^6.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mdn-data": { + "version": "2.0.30", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.30.tgz", + "integrity": "sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==", + "dev": true, + "license": "CC0-1.0" + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "dev": true, + "license": "MIT", + "dependencies": { + "braces": "^3.0.3", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/mime": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/mime/-/mime-2.5.2.tgz", + "integrity": "sha512-tqkh47FzKeCPD2PUiPB6pkbMzsCasjxAfC62/Wap5qrUWcb+sFasXUC5I3gYM5iBM8v/Qpn4UK0x+j0iHyFPDg==", + "dev": true, + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/minimatch": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.8.tgz", + "integrity": "sha512-6FsRAQsxQ61mw+qP1ZzbL9Bc78x2p5OqNgNpnoAFLTrX8n5Kxph0CsnhmKKNXTWjXqU5L0pGPR7hYk+XWZr60Q==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/nanoid": { + "version": "3.3.8", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz", + "integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "peer": true, + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/node-releases": { + "version": "2.0.19", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz", + "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==", + "dev": true, + "license": "MIT" + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/normalize-range": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz", + "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "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/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": "5.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-5.0.0.tgz", + "integrity": "sha512-5HviZNaZcfqP95rwpv+1HDgUamezbqdSYTyzjTvwtJSnIH+3vnbmWsItli8OFEndS984VT55M3jduxZbX351gg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/postcss": { + "version": "8.5.1", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.1.tgz", + "integrity": "sha512-6oz2beyjc5VMn/KV1pPw8fliQkhBXrVn1Z3TVyqZxU8kZpzEKhBdmCFqI6ZbmGtamQvQGuU1sgPTk8ZrXDD7jQ==", + "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", + "peer": true, + "dependencies": { + "nanoid": "^3.3.8", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/postcss-calc": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-10.1.0.tgz", + "integrity": "sha512-uQ/LDGsf3mgsSUEXmAt3VsCSHR3aKqtEIkmB+4PhzYwRYOW5MZs/GhCCFpsOtJJkP6EC6uGipbrnaTjqaJZcJw==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^7.0.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12 || ^20.9 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.38" + } + }, + "node_modules/postcss-cli": { + "version": "11.0.0", + "resolved": "https://registry.npmjs.org/postcss-cli/-/postcss-cli-11.0.0.tgz", + "integrity": "sha512-xMITAI7M0u1yolVcXJ9XTZiO9aO49mcoKQy6pCDFdMh9kGqhzLVpWxeD/32M/QBmkhcGypZFFOLNLmIW4Pg4RA==", + "dev": true, + "license": "MIT", + "dependencies": { + "chokidar": "^3.3.0", + "dependency-graph": "^0.11.0", + "fs-extra": "^11.0.0", + "get-stdin": "^9.0.0", + "globby": "^14.0.0", + "picocolors": "^1.0.0", + "postcss-load-config": "^5.0.0", + "postcss-reporter": "^7.0.0", + "pretty-hrtime": "^1.0.3", + "read-cache": "^1.0.0", + "slash": "^5.0.0", + "yargs": "^17.0.0" + }, + "bin": { + "postcss": "index.js" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "postcss": "^8.0.0" + } + }, + "node_modules/postcss-colormin": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-7.0.2.tgz", + "integrity": "sha512-YntRXNngcvEvDbEjTdRWGU606eZvB5prmHG4BF0yLmVpamXbpsRJzevyy6MZVyuecgzI2AWAlvFi8DAeCqwpvA==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.3", + "caniuse-api": "^3.0.0", + "colord": "^2.9.3", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-convert-values": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-7.0.4.tgz", + "integrity": "sha512-e2LSXPqEHVW6aoGbjV9RsSSNDO3A0rZLCBxN24zvxF25WknMPpX8Dm9UxxThyEbaytzggRuZxaGXqaOhxQ514Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.3", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-discard-comments": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-7.0.3.tgz", + "integrity": "sha512-q6fjd4WU4afNhWOA2WltHgCbkRhZPgQe7cXF74fuVB/ge4QbM9HEaOIzGSiMvM+g/cOsNAUGdf2JDzqA2F8iLA==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.1.2" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-discard-comments/node_modules/postcss-selector-parser": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-discard-duplicates": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-7.0.1.tgz", + "integrity": "sha512-oZA+v8Jkpu1ct/xbbrntHRsfLGuzoP+cpt0nJe5ED2FQF8n8bJtn7Bo28jSmBYwqgqnqkuSXJfSUEE7if4nClQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-discard-empty": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-7.0.0.tgz", + "integrity": "sha512-e+QzoReTZ8IAwhnSdp/++7gBZ/F+nBq9y6PomfwORfP7q9nBpK5AMP64kOt0bA+lShBFbBDcgpJ3X4etHg4lzA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-discard-overridden": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-7.0.0.tgz", + "integrity": "sha512-GmNAzx88u3k2+sBTZrJSDauR0ccpE24omTQCVmaTTZFz1du6AasspjaUPMJ2ud4RslZpoFKyf+6MSPETLojc6w==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-discard-unused": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/postcss-discard-unused/-/postcss-discard-unused-7.0.3.tgz", + "integrity": "sha512-OVxIMVMjkJ1anDTbHFSYUZnmoDWv3vF5JPZvr9hi6HjMNH/RjfR39IMeLThbIjrSb9ZLcwzqziU+XxFQkgF4Vw==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.1.2" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-discard-unused/node_modules/postcss-selector-parser": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-import": { + "version": "16.1.0", + "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-16.1.0.tgz", + "integrity": "sha512-7hsAZ4xGXl4MW+OKEWCnF6T5jqBw80/EE9aXg1r2yyn1RsVEU8EtKXbijEODa+rg7iih4bKf7vlvTGYR4CnPNg==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.0.0", + "read-cache": "^1.0.0", + "resolve": "^1.1.7" + }, + "engines": { + "node": ">=18.0.0" + }, + "peerDependencies": { + "postcss": "^8.0.0" + } + }, + "node_modules/postcss-import-url": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/postcss-import-url/-/postcss-import-url-7.2.0.tgz", + "integrity": "sha512-El61K/5+Rv753G9mBiHyQlOIN2mBfN0YHPMXLlgIo/m1+tPDLM32wd97WoUjc8FHUnC6EyyfVA8RDuKoyuVl0Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "http-https": "^1.0.0", + "is-url": "^1.2.4", + "lodash.assign": "^4.2.0", + "lodash.trim": "^4.5.1", + "resolve-relative-url": "^1.0.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "postcss": "^8.0.0" + } + }, + "node_modules/postcss-load-config": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-5.1.0.tgz", + "integrity": "sha512-G5AJ+IX0aD0dygOE0yFZQ/huFFMSNneyfp0e3/bT05a8OfPC5FUoZRPfGijUdGOJNMewJiwzcHJXFafFzeKFVA==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "lilconfig": "^3.1.1", + "yaml": "^2.4.2" + }, + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "jiti": ">=1.21.0", + "postcss": ">=8.0.9", + "tsx": "^4.8.1" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + }, + "postcss": { + "optional": true + }, + "tsx": { + "optional": true + } + } + }, + "node_modules/postcss-merge-idents": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-merge-idents/-/postcss-merge-idents-7.0.0.tgz", + "integrity": "sha512-Kr+DniMg0IsW7OGoaMB1Foreb3fIE2XcExCRynogQLngkpNVKTX5GlaxyEZDBB8bISeoztFHFK/GcQtFiPTnpQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssnano-utils": "^5.0.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-merge-longhand": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-7.0.4.tgz", + "integrity": "sha512-zer1KoZA54Q8RVHKOY5vMke0cCdNxMP3KBfDerjH/BYHh4nCIh+1Yy0t1pAEQF18ac/4z3OFclO+ZVH8azjR4A==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0", + "stylehacks": "^7.0.4" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-merge-rules": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-7.0.4.tgz", + "integrity": "sha512-ZsaamiMVu7uBYsIdGtKJ64PkcQt6Pcpep/uO90EpLS3dxJi6OXamIobTYcImyXGoW0Wpugh7DSD3XzxZS9JCPg==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.3", + "caniuse-api": "^3.0.0", + "cssnano-utils": "^5.0.0", + "postcss-selector-parser": "^6.1.2" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-merge-rules/node_modules/postcss-selector-parser": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-minify-font-values": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-7.0.0.tgz", + "integrity": "sha512-2ckkZtgT0zG8SMc5aoNwtm5234eUx1GGFJKf2b1bSp8UflqaeFzR50lid4PfqVI9NtGqJ2J4Y7fwvnP/u1cQog==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-minify-gradients": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-7.0.0.tgz", + "integrity": "sha512-pdUIIdj/C93ryCHew0UgBnL2DtUS3hfFa5XtERrs4x+hmpMYGhbzo6l/Ir5de41O0GaKVpK1ZbDNXSY6GkXvtg==", + "dev": true, + "license": "MIT", + "dependencies": { + "colord": "^2.9.3", + "cssnano-utils": "^5.0.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-minify-params": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-7.0.2.tgz", + "integrity": "sha512-nyqVLu4MFl9df32zTsdcLqCFfE/z2+f8GE1KHPxWOAmegSo6lpV2GNy5XQvrzwbLmiU7d+fYay4cwto1oNdAaQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.3", + "cssnano-utils": "^5.0.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-minify-selectors": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-7.0.4.tgz", + "integrity": "sha512-JG55VADcNb4xFCf75hXkzc1rNeURhlo7ugf6JjiiKRfMsKlDzN9CXHZDyiG6x/zGchpjQS+UAgb1d4nqXqOpmA==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "postcss-selector-parser": "^6.1.2" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-minify-selectors/node_modules/postcss-selector-parser": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-normalize-charset": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-7.0.0.tgz", + "integrity": "sha512-ABisNUXMeZeDNzCQxPxBCkXexvBrUHV+p7/BXOY+ulxkcjUZO0cp8ekGBwvIh2LbCwnWbyMPNJVtBSdyhM2zYQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-display-values": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-display-values/-/postcss-normalize-display-values-7.0.0.tgz", + "integrity": "sha512-lnFZzNPeDf5uGMPYgGOw7v0BfB45+irSRz9gHQStdkkhiM0gTfvWkWB5BMxpn0OqgOQuZG/mRlZyJxp0EImr2Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-positions": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-positions/-/postcss-normalize-positions-7.0.0.tgz", + "integrity": "sha512-I0yt8wX529UKIGs2y/9Ybs2CelSvItfmvg/DBIjTnoUSrPxSV7Z0yZ8ShSVtKNaV/wAY+m7bgtyVQLhB00A1NQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-repeat-style": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-7.0.0.tgz", + "integrity": "sha512-o3uSGYH+2q30ieM3ppu9GTjSXIzOrRdCUn8UOMGNw7Af61bmurHTWI87hRybrP6xDHvOe5WlAj3XzN6vEO8jLw==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-string": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-string/-/postcss-normalize-string-7.0.0.tgz", + "integrity": "sha512-w/qzL212DFVOpMy3UGyxrND+Kb0fvCiBBujiaONIihq7VvtC7bswjWgKQU/w4VcRyDD8gpfqUiBQ4DUOwEJ6Qg==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-timing-functions": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-7.0.0.tgz", + "integrity": "sha512-tNgw3YV0LYoRwg43N3lTe3AEWZ66W7Dh7lVEpJbHoKOuHc1sLrzMLMFjP8SNULHaykzsonUEDbKedv8C+7ej6g==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-unicode": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-7.0.2.tgz", + "integrity": "sha512-ztisabK5C/+ZWBdYC+Y9JCkp3M9qBv/XFvDtSw0d/XwfT3UaKeW/YTm/MD/QrPNxuecia46vkfEhewjwcYFjkg==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.3", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-url": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-7.0.0.tgz", + "integrity": "sha512-+d7+PpE+jyPX1hDQZYG+NaFD+Nd2ris6r8fPTBAjE8z/U41n/bib3vze8x7rKs5H1uEw5ppe9IojewouHk0klQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-whitespace": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-whitespace/-/postcss-normalize-whitespace-7.0.0.tgz", + "integrity": "sha512-37/toN4wwZErqohedXYqWgvcHUGlT8O/m2jVkAfAe9Bd4MzRqlBmXrJRePH0e9Wgnz2X7KymTgTOaaFizQe3AQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-ordered-values": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-7.0.1.tgz", + "integrity": "sha512-irWScWRL6nRzYmBOXReIKch75RRhNS86UPUAxXdmW/l0FcAsg0lvAXQCby/1lymxn/o0gVa6Rv/0f03eJOwHxw==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssnano-utils": "^5.0.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-reduce-idents": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-reduce-idents/-/postcss-reduce-idents-7.0.0.tgz", + "integrity": "sha512-ghFHqxigYW/bbfr+bXSDB5Tv3qPaYZZxiQh+Gne0NYRlTOzFft1V/DUvGFVJbFkackHleSjFdVXdlNB+5f3mKg==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-reduce-initial": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-7.0.2.tgz", + "integrity": "sha512-pOnu9zqQww7dEKf62Nuju6JgsW2V0KRNBHxeKohU+JkHd/GAH5uvoObqFLqkeB2n20mr6yrlWDvo5UBU5GnkfA==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.3", + "caniuse-api": "^3.0.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-reduce-transforms": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-7.0.0.tgz", + "integrity": "sha512-pnt1HKKZ07/idH8cpATX/ujMbtOGhUfE+m8gbqwJE05aTaNw8gbo34a2e3if0xc0dlu75sUOiqvwCGY3fzOHew==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-reporter": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/postcss-reporter/-/postcss-reporter-7.1.0.tgz", + "integrity": "sha512-/eoEylGWyy6/DOiMP5lmFRdmDKThqgn7D6hP2dXKJI/0rJSO1ADFNngZfDzxL0YAxFvws+Rtpuji1YIHj4mySA==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "picocolors": "^1.0.0", + "thenby": "^1.3.4" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-selector-parser": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.0.0.tgz", + "integrity": "sha512-9RbEr1Y7FFfptd/1eEdntyjMwLeghW1bHX9GWjXo19vx4ytPQhANltvVxDggzJl7mnWM+dX28kb6cyS/4iQjlQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-svgo": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-7.0.1.tgz", + "integrity": "sha512-0WBUlSL4lhD9rA5k1e5D8EN5wCEyZD6HJk0jIvRxl+FDVOMlJ7DePHYWGGVc5QRqrJ3/06FTXM0bxjmJpmTPSA==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0", + "svgo": "^3.3.2" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >= 18" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-unique-selectors": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-7.0.3.tgz", + "integrity": "sha512-J+58u5Ic5T1QjP/LDV9g3Cx4CNOgB5vz+kM6+OxHHhFACdcDeKhBXjQmB7fnIZM12YSTvsL0Opwco83DmacW2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.1.2" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-unique-selectors/node_modules/postcss-selector-parser": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-url": { + "version": "10.1.3", + "resolved": "https://registry.npmjs.org/postcss-url/-/postcss-url-10.1.3.tgz", + "integrity": "sha512-FUzyxfI5l2tKmXdYc6VTu3TWZsInayEKPbiyW+P6vmmIrrb4I6CGX0BFoewgYHLK+oIL5FECEK02REYRpBvUCw==", + "dev": true, + "license": "MIT", + "dependencies": { + "make-dir": "~3.1.0", + "mime": "~2.5.2", + "minimatch": "~3.0.4", + "xxhashjs": "~0.2.2" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "postcss": "^8.0.0" + } + }, + "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-zindex": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/postcss-zindex/-/postcss-zindex-7.0.0.tgz", + "integrity": "sha512-Agp+5C0qBZxT9S4k9iO/C9oqce3gvPJ/7av4JcAsDl17vsboSN60ncTokIYDtDMlVXvwuhFED3edoy1YG5O1+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/pretty-hrtime": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz", + "integrity": "sha512-66hKPCr+72mlfiSjlEB1+45IjXSqvVAIy6mocupoww4tBFE9R9IhwwUGoI4G++Tc9Aq+2rxOt0RFU6gPcrte0A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/punycode": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz", + "integrity": "sha512-RofWgt/7fL5wP1Y7fxE7/EmTLzQVnB0ycyibJ0OOHIlJqTNzglYFxVwETOcIoJqJmpDXJ9xImDv+Fq34F/d4Dw==", + "dev": true, + "license": "MIT" + }, + "node_modules/querystring": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz", + "integrity": "sha512-X/xY82scca2tau62i9mDyU9K+I+djTMUsvwf7xnUX5GLvVzgJybOJf4Y6o9Zx3oJK/LSXg5tTZBjwzqVPaPO2g==", + "deprecated": "The querystring API is considered Legacy. new code should use the URLSearchParams API instead.", + "dev": true, + "engines": { + "node": ">=0.4.x" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/read-cache": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", + "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "pify": "^2.3.0" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dev": true, + "license": "MIT", + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve": { + "version": "1.22.10", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz", + "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-core-module": "^2.16.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-relative-url": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/resolve-relative-url/-/resolve-relative-url-1.0.0.tgz", + "integrity": "sha512-zpcelQBAmrwckiyRmym9os1goECU3EzuTU/UrYkGzXV0i14n8FkyGUvwkOYA5klqVLq1Hz/EiFZMS7bZQdd+EA==", + "dev": true, + "license": "MIT", + "dependencies": { + "url": "0.10.x" + } + }, + "node_modules/reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "dev": true, + "license": "MIT", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/slash": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-5.1.0.tgz", + "integrity": "sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.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/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/stylehacks": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-7.0.4.tgz", + "integrity": "sha512-i4zfNrGMt9SB4xRK9L83rlsFCgdGANfeDAYacO1pkqcE7cRHPdWHwnKZVz7WY17Veq/FvyYsRAU++Ga+qDFIww==", + "dev": true, + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.3", + "postcss-selector-parser": "^6.1.2" + }, + "engines": { + "node": "^18.12.0 || ^20.9.0 || >=22.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/stylehacks/node_modules/postcss-selector-parser": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "dev": true, + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "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": "3.3.2", + "resolved": "https://registry.npmjs.org/svgo/-/svgo-3.3.2.tgz", + "integrity": "sha512-OoohrmuUlBs8B8o6MB2Aevn+pRIH9zDALSR+6hhqVfa6fRwG/Qw9VUMSMW9VNg2CFc/MTIfabtdOVl9ODIJjpw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@trysound/sax": "0.2.0", + "commander": "^7.2.0", + "css-select": "^5.1.0", + "css-tree": "^2.3.1", + "css-what": "^6.1.0", + "csso": "^5.0.5", + "picocolors": "^1.0.0" + }, + "bin": { + "svgo": "bin/svgo" + }, + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/svgo" + } + }, + "node_modules/thenby": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/thenby/-/thenby-1.3.4.tgz", + "integrity": "sha512-89Gi5raiWA3QZ4b2ePcEwswC3me9JIg+ToSgtE0JWeCynLnLxNr/f9G+xfo9K+Oj4AFdom8YNJjibIARTJmapQ==", + "dev": true, + "license": "Apache-2.0" + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/unicorn-magic": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.1.0.tgz", + "integrity": "sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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.1.2", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.2.tgz", + "integrity": "sha512-PPypAm5qvlD7XMZC3BujecnaOxwhrtoFR+Dqkk5Aa/6DssiH0ibKoketaj9w8LP7Bont1rYeoV5plxD7RTEPRg==", + "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/url": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/url/-/url-0.10.3.tgz", + "integrity": "sha512-hzSUW2q06EqL1gKM/a+obYHLIO6ct2hwPuviqTTOcfFVc61UbfJ2Q32+uGL/HCPxKqrdGB5QUwIe7UqlDgwsOQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "punycode": "1.3.2", + "querystring": "0.2.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/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/xxhashjs": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/xxhashjs/-/xxhashjs-0.2.2.tgz", + "integrity": "sha512-AkTuIuVTET12tpsVIQo+ZU6f/qDmKuRUcjaqR+OIvm+aCBsZ95i7UVY5WJ9TMsSaZ0DA2WxoZ4acu0sPH+OKAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "cuint": "^0.2.2" + } + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yaml": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.7.0.tgz", + "integrity": "sha512-+hSoy/QHluxmC9kCIJyL/uyFmLmc+e5CFR5Wa+bpIhIj85LVb9ZH2nVnqrHoSvKogwODv0ClqZkmiSSaIH5LTA==", + "dev": true, + "license": "ISC", + "bin": { + "yaml": "bin.mjs" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/yargs": { + "version": "17.7.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", + "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "cliui": "^8.0.1", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.3", + "y18n": "^5.0.5", + "yargs-parser": "^21.1.1" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "dev": true, + "license": "ISC", + "engines": { + "node": ">=12" + } + } + } +} diff --git a/xess/package.json b/xess/package.json new file mode 100644 index 0000000..2844ca5 --- /dev/null +++ b/xess/package.json @@ -0,0 +1,20 @@ +{ + "name": "@xeserv/xess", + "version": "1.0.0", + "description": "Xe's CSS", + "main": "index.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1", + "build": "postcss xess.css -o xess.min.css" + }, + "author": "", + "license": "ISC", + "devDependencies": { + "cssnano": "^7.0.6", + "cssnano-preset-advanced": "^7.0.6", + "postcss-cli": "^11.0.0", + "postcss-import": "^16.1.0", + "postcss-import-url": "^7.2.0", + "postcss-url": "^10.1.3" + } +} \ No newline at end of file diff --git a/xess/postcss.config.js b/xess/postcss.config.js new file mode 100644 index 0000000..7084661 --- /dev/null +++ b/xess/postcss.config.js @@ -0,0 +1,8 @@ +module.exports = { + plugins: [ + require("cssnano")({ + preset: "advanced", + }), + require("postcss-url")({ url: "inline" }), + ], +}; \ No newline at end of file diff --git a/xess/static/geist.woff2 b/xess/static/geist.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..6fd61c44dbbbede2b274bb765fb83f75c5e26872 GIT binary patch literal 64184 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≫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

WChu}hT zF6BtNTK9Qk(I-FOSab$Hg39&WF0KYXf#G*|G|d2CDe90olOM^ph#8eSJ;Q5ZM^gEj z{HcUg!vR4<20xN&VKcmX9i!4Bj%4#Q#3A+h2i=F30mQgZMkv zpT#&(1+G4^7R9T?KAOM_K~Mxff~tD6Mxqm~Uwd8!AHncw5CYRZphp;nnMt1lY-i~Pw+@Rp9-N;sGrD@h5w~W% zCcLVWRdNI}6hTX0PF{XNvJpV zCdld3B&S+#b?XV0RTHBl??%_a`nRLUHiV~C6Fq@LR^6Mww?-e&cY!1`Tm-zry1`yE zFwh5e`E<3NTw;;-2MK&QPCC)2mq`-T(W)`Av{JQH`G8%Z zPL8@{2|8Q0La45CxC>Pc94f>3y(v38V1>@<3{-@vG?P#xu=z-MKhe9ZYslgryB~1F zaMy0%z57q6Mo+`1F!ISqpGNQcuDn>xTLFtkYTD6Yu-?b? z;74GlR+m=Hauf=kwxDeV(CyzV`oB&@)qnHMZ+>fgKo5k!{N%0R)N&W0{jPfBlg1nCa2ukz`OW;hDO7b)2GbTIgAAhF*y=sLUafVz_cDLi z0i&5D@AuR_&J0Z-5NW0^5ndf^hhB4E3y1D3H4KI%8~vdY2WTP>@CKJvOZ1}Vch4)~ z6IgYnX}91;aJ&Kio90MZTMI*J>o)0zY69r|F0*B7|FZt%{FHYATq_89IAsDSc@6%e z4{P-StqL~RgD9Aee4b8juKkDuI&DnYh{kU`^(%zo``5B?m({2{!CxU13c~M9UOABl z%Rnl~pzkJ1{|WOwFGPA3pzDJ0 zk-Cca_rx2=^q=->M>9Ga>$BPAJ$l{ZMlGpLYY&x5Wq}ezS6GWCvyyiLxK14Mv!w-p zC#F_Jk3@SNtv&!wu{a(DsL+U|KT)ICB3#8U3ae_{d*7x<{>_R*bWco!YF z9$94=x2q+7>it#lI3uG|o0R72-k2}da5?l@d@Hny)Iwo#@6V)SZPwfrl_oi(x+s9> zYik%Hn?R^AZb=nuxB|ApPevKlS?cHIaaO=XL3>#o%OJ0MdF7OwACmSMa~vh_Ezpt$Wj?mBQmYjOgKUM;N#`0eJPc`EU6B)_yWZ1f z7;~<#zz!~3K701^WdJqet>6hu_FSByqN)GY3Y1=s7s+k4X_V&avzt#M5}DK01(ZLS zl0P3!&hV|~wIFGTkLLq%G3Sf$^FKT3h!`XdU6vZRC#hr9IWf+1a%O+TRj~5n$zXeUO?4mOc%bm34^g4m^$TfsH zE6_zWAA6K*M(DQ!IEFB|MaX3&$c-TXv8yFjSwTwlY-9YoagfpOlz~74Nsa-WH#_=k7(s~RNMm#JY?%0E&fb8V0lv59mjhu%ijL?_wo=P4s*K=T1 z74rM|qGJF93^W0>TQJNwR)+a7i`FhAs{sb=0Qo}}ZLW~F=lUS;*xD;Gh|9W}w0HlS zDnh6ak`q@AR~ zuHw1iQcQxJD;k>OQ?K!u*u)E|J53%2SS1EDN;fq5pVq4HRMwETZ`Z)MgfO{ehygP; zU(5IoGjbORHqa|1i(81{E2fwSNV}STP!W&$SjG;vP_H(nVX+k1y={Fn_fako z3r-dfOa%!akJD<6Xvwo`Pz6|~OtuH_2OzsHA~LeS`WCiXN!VSS`bBfzqp>#n`jQ0fe0p=E3ki2yX>>~pfp zap0~T*o*9~nJ|qUF*u!TU7SlSARQW}lfI9D_w*oREp|0US8K=QGh?NE?bz5zM}tcd z6pHFiCjKE86kJ6#UYlLxMig4N-KO;daZqfniGXoi9*!jonyTI)Azlc12Gr&D$>n1@ zMmoN7E-%l+B@>H31?gARpF=ODQ)w62g+!wD(p++M@GaYbY?v0gUo0}QD3#E}9`dvU zPo;$u79m}ms&RMhHJ^Y^L_8aWPyz0!j#KHOR*nx(?j6)2V-a1?U^;8t_}fYzw8L|FDad1jnZx(#o$Abr^MRXvR;YLWQ}<{t+6-pKANY#Hy<*Z}rgBIAKSLOsW&+`pZa zKV!J`Q+**VXZ(dd9nTm#4O(i{7ce{(RrU&&kw$nw!^i|RxVG<@kD!ngFxL4RDlCC; zql{Rtx|Fcpl+9Mwv7}YNk(sU+{|J5==Np6nUl>jEwr}2QnK&N5bQW>W-8GY*cJlv7 z3=%8-KY3WM`u5DZP6WIww71c-x?n@5;u$MmLQ*wrN><86B7{gnNg}cK7pf%+GA%%^CSggzIR7-{X{iBbgt;R#vWaP zz*y@`=G!}fQb6b;Ao`-I9(U1HMDHR91r+(a-tEa2Xb82PSs{~=ZJo6Qf^&}3jVAb~ z&^b=PhVi0eHo~RwZBU#)x@+Rb z6>em>(^byYW=#dxfPs?~H6CM_e=cH7Ihrq%pkTQO3;NE{4vo`Q#F|RqwH%TJCw${l zK9NI!J0SLwg(fk+?);yB#4Z=hq_!YgEDDjaYFY8+>=%FD4#JBCCLdX7QCwkiGzyUj zSK=^FDdL3h(dq9AuYVwdI4?N4uZVkxkYvt~R&dIA0g|NBflt#sa#GY?lQ*x3aJsD; zZ!VQ%$eIUkZqeuEp%jtCDp%TAFIaizHF$8nmv1d)crUjMMY} zIH{>usHil#O3yj@HTa~16(wqy)8$jZT&+3*WM}J-YfA?3ybhogp2E-Y`PYcFbn!#&zC7CcIoh3fjRfy4hD%t z`93%IYAII+W|`WVUya}R$3Xg-#hHfr3b}$QlY_0is4+MG^6L0};wQwC5@O~@NuQ05 zm7l7}TbC}epbEw;bpd#p-~hf=RT8$($4AK9hl?!}am>#71z?K;S(P`BTJW`+{3T;m z0pUC?zw{c+G)bM#;zS58NL;VU)e zEBY>9>F?Jy@VmI%)g1~hf=BM@K*YpcZSLCvfa~;?Eek=&iS#{kte|_*_8&g5kl=Lz zbIg{oT#Cm|Z|m4IX~Jn+$)a2h?&>t-G(c2f4`lG1HJF06q33b-XhNcXVl8$sE0?q^ zs&3-N^!&Sg{Ce>OhbsC5I57dP%xCf09}Z;JCFy(zve)*f`SAD7eV+n1GJn)T#2$2- zpyAu0UN5vhC@g$nEsRbMXv{T7FB=r*=$DcM?cZ2tSZDkm>Re39GRzeK!j!_%dHSQe z!c5U3`nHv#9sE-$@6_BPQzbanEn3Ld;AbC7;DGp zF?H0tzh@sO$GG+Q>1s8822dCn2ND+ji)VPIYxV*SdH53rhPdRB@e{fQ1$s3_GfPu3 zTG&fE(%f{kxT|oqT-(urdx3%9o;YqK*&qg+7ZY8_CARYm3@VCav9r8r(N%o3srd-0 zSE@kWp@K{Fg6;|9-EtQlR5lDYC=UYmO^v-?5~#-UAs?g($C<|!8()H#03-HY`0nr; zxCZ>%&qQZ}!e{nUCVik#gF85SS94sv$J_jf!K+z0$G&sN?%AH*7wpbVD|hLN-n700 zQ;W3CcmF9#vUJ+|YF7Zui8Y1BN!CtoRrQv;%9!i~sDK%YJm?k>RU{Xj#q4RvO1B>S zyd4n5{E1f(P$TKW#WGdq1w95+;s2klA0LWz*ZDA26O^!9%%P4m@jiOgs`*a!9Z;UE zIiI9od6)spA^uh!taD5VPYVSjGb-ZiVeQkCa~UoF%zq>3Sou?GruvFlR~gJ}EXH?C#2Web4e@)Yt>)pWUxp@it)jJ^N3B3x%wZ&2t$}L zsPyL~;G5X&`@-7y@(F8e^3FPkoHOHX5wE!bK6iYJOD*LX;&h>*Q2rMQ9v1|*m-q<3 z@S}D7=PN0jKXs^aZr!^(g>@b#o_5my4pW6ybd^g5Bob>Io#m|P`ZjTGpY47usu~|# z?U2{rLGPk>IzG7{(DZmTFd*E@!QQHrnM?dB%-SZ*n6s@Os2ZOjPh!xA5dElf@Klf` zd2Q#f%YpAP`&GM9_ zrmw=a`zwaM9-y;Gm8g1km1m9e3OJKdhbT;_j&$|wR9s_y&*b)o9-!!(kIV;}oA$Ri zJ@f{B^Yu$td#&M)o-<5ZiBzU7GwC+3cl-{3k+F#g+K2Yme9Y|Ga6 zmIZhLYCsqGC1*{Xt&&>HtCi&?rxN^r{6F~&9Iy(cVsX;`AFF0diCKSobWLeF5WwLuNXdrk&z!(8}DH4D3(tOK@h<% ziXsxDii-DkaPWWFvSqO1qe`Iu1Z;yK^>$rdLw$0C>Z<4cTm-(I(-T@F# zET)P7^8;8=v9I|)vPM(l zJtL-sQblD?zmYwx@kAs<%8 zMr=NFX7rDm2d@OEJ5AA*6>ead!LJZ^QSjn!YyQRm%2*?*SvR-88;kX0%jS=|CCf!y-(j{_Wz2WL4Vt zY$k*KeOmf;HiOB&-f=Pe@l@4*CaIz^;M>uXQSwYzTbgg~rMVB9e>MSGGElD1;x#RB zYL@r~#gojD=`xq4gNJ#@tuln>Mwz7Svsob7QBaH)(hM@@(79!(0`3psb3!X-*jzy-H5O9#rt`|!D&KLFrOAiqg&%Y{iOnXVP{ z=vp;bu)IK3Kpt*9mQlQhUBXwv5sKG-2g|M5G?7@U%YHjQ+&c~v1!JNdWt`Xz3JsV1 z?}bW)q?~;?yVgIpfG|5h%U*ha2wgY?7U@-1lSx+zwc!h;|0J?8))2c3R{adJFS~P8 z>X=eRc@dlG%4$sXT-tHeMrGHK@_%~v+tI`(-=&l+e!g=`h1=U^3(E zI4;eW`%_{-pAfH}%V78kxn-v{88%Fa`Pg7_u5~~V3JYf2EP{bhctBva&K5+%f&q(7 zFgp^SE!g@DR3vF6#xk+ogyMRl9xauyf%^fHr#2K-8Lkg|DE58eurAVg-!sQ%nC~h# z%${TRc;=eTv&&uP`EzXmuQzq7)tx4jx~o%dGJD*GI)BibxiY_y7m&z#A-`BA^NP74 zxr7_=3dIHn?IexfD?83CI5eNEW-zScx?*Vo1HYV<_D^oXwQM4YV6Isz)c8gu-y`R} z(W0vUncHkvHCK0;iteX=yPQ1E`HCNY27L0(a?TqL*yTYx!{eTzQEzj3wHE_i`!j)_%V6+T z#RZs}Cd2e0n`Gfbr)1tk@Bi#3JA^tL=87zsNVlM?eb;K#c%Sgr91E~?4VE zT6x--^=Rj*{pqwXGe?Q0nuZt-XaLhvW!N|0FWZezp{4ad^ZjF7%iDO6NayH8BK^;1 z^xe^!NG8ZiadujyJq81_!K4WgSf(zuW~OW99=CF+tYo{lDDQWH2?>9=1&z_dQ<4T65iLJ_Dn_zO{b)l6Z~X5&LIaVEaV# z;sCl}PI^Y_lE}0R?RI;uGZW7QV?GV<0Zrodl!QeeP{>)iMY*&rfVl$+2h1yWv}A8w z_rsoaFtr){Kp^|cpq5)}L!b@OsdPXod}Bo7K83EmQ$g3;wf^t*AU$XcNcgt!*)o_j z{!u!9Yijzpq>>h%Qsk!Ou6zzw#;vSwiBrk;?*T4%Hn6;v&ieiB3D*4;&AWRJ06B~< zql1mYswq4|)+>C@0tIbh21CQ4b2K_YTu*sKiJsDy>PmG0ML@d02m1eic52QW7BKu5 zUf;nvfKNl2wyRE7;_5raxdtYzhKi$clou~VGEM<$?6K@Ict5@~W!j?g z8dy|bw5VGn2Zw&$AW&}36+7>E--_iKlv_cLRq%e)?$$0dWf`%L`DwVVbGLU6?d*bc zE1u9nEot7)Be@LMS5PAwd_*-}(7Fc4o)l9}R|`G!PK2IsmQ$THJ*lRm(I(fddAH@s zy{plDIIwWPu#&FHq;zr1%L~w5<*7Ut?`pmfz`axdAJXe~18QO4VDTo{6l@Nr?-IzU z4@=DEkc3%p0yu4mkU80pz3&USz2L#|BV(yx0EFi;C5x@j*Im*uZ9%*B!35;ch+bZ{ zrrj-v3xKyUn9&kAaRsN|I$j)*GJO-fsWo$}T8vmtS3&tOi?X$xFxJ=DA1K$3dPlE>yLFP6?X$Ab$Q>NK2h;VYya zU~RHEW=F((xjI0x?`=4JW>CGuYO# z_)QrcZnj!}D?rv7JQ=oAR|OH^cn8sAJ2!C=(SFM1T8Tkx6bKb2vHm$zIYK$u^U$G@ zumeRftiIRfR4W+ead3uVck@2KIje-#-_jY19mH45iEABFR* zesYRZ@$q1h#Ad|Dsn~wZ*@6d+cI5T}WXAE_wUeXVKCph$Ftmt4A_N`Fi7+UPBm%eDQhWj0 z)ap0`Q9R%%p#AIEReEpidhC)5MZw1oKk~5xAArf&M*>9Ps=M$?C2QDon^n z(_urRhzZbkr~*(;L@!zx2Z^RDOHHb5UCi7Ok|u@#*|c4A+C(aQ*^Z2sk1A1%Nzna@ zg*U)L81TJiKQ|{f4T|qye+4{SCST!N5jkKZ;q>(<)G@a=?YKk6BuI1>i+k2tsND4>?UZMpD zJ=Ph>!mV=E2dKk*9;)39=P=ENrfU%Wvh@Xu3?T7ADuV!>hm?XfjnXG~wmc65ve|?1 zA-x5DEkM@P{81QeI2n?qFxdKo@OAPvi-5ve85LH_0H#&d)owBSvv%c2lCb7g&^%}B z&e5Yvg+lu6>N2d$f#8QhuF{k0+I$jtdHw$Q*jmPsqYVr~yMcEI$PA&$n#pIw&_Hq&0WpJkj>m?TJZ&FQqysUMT$xZ zfqP$a=SEHC9*NGQ3-Q*9)uK2PC~LL+T7axIb~E>s0u0WXxtnq+u3^#t;D{`<3n0F# zin#VK$$Tu>%TrM>7LKXev54|1C~xbi{NqVI^h85F*IUc9s$(nCKlUg;^31}~yU$Is zoJiE#mRRkU*3YUH9`7e`MoX>WK&g_a(e{X?VEz~x zTHSBWu$+g&hb8!~F1|UK5~X=AIuOMb(>>sXiwxDWHmlOpskWZ$6U($}XDcCUuIf_wK26c5SY64W2~a)>n|tYkiQdFGEf{{yD>)us6S&QE zL81%5(4vVBak$gHG@|462?RCr`ZT9?Ct1z+7*$LI)r_^f=a$oj%)yA|Dd2meSQ+KK zm4Ca@PKYR(m%R+-ckNsA0}l3CEd@>4I=8>O^DtVkTB>#R;OU&9H19q?;XgHoUGCh; zYpprS?toPTq=+d~s^4cjGymNKB5ESJU#fz1vNwI4_2P;G%Y4S|<8j}&I92sL$TlL< zcLpT*@7=6?p@7@qSJ9jPfc?*2%!8iC$rozBkb)`?cr;ps-Qou`+X)l_Tm>;q*!&8vu<)NAyI14ysLx z>!Ze0!x>Ca=h*jP4E+Od?UE(pyz_mCy%p1#m81h8&#S5ccK$=fYj2Y{4|mUoJE<;( z=y7M8yN;jt=o9RXMYZ%H7I{*}#+0Bn2VMHwmJ*@6J*xQ!KPK${*$=$u^S z1`rKW&OIpBM5yy}^GKTxvWyJXnt&+7?wnAmhW@SP5qYCcg*?96T26i2%2tVK98n_C zcag{2`W|)zv<8n;TXU1&G(>6fz68B!06L(jsLWXZ;vr%)>+ioN93zjM5)O$-bbn;=(PN?3I#P~Yb@cjS>-kl#l25wGpQ}E0b-_hh%h(z|u_uHNAbEUz zN~x_sFyIv4914pGmTEVck!aOcmjOov2m;raI^4BNkalvJoF=^FV)#mKeLWkxqZtyZ z!GJgvl#qQ51G1`>0~cy)CFEfUAZw&ht7bK!b?s?Zk*9eafz;C=j^Lg-cz$MifTR;% zT#iujdJ;l>;ENog8;*m=LH0;Oso%>p0J~G``KF8=6vZxbG#m#HRkkb66+i?Cf}F;@ z$RQ+c=#IxQnK6($Kch7yV@*c9YtS&cWED4-sA<;EgwZt%5%4b>a0KDy<+?+7GW)Cn zf*`yI?K=*!LU%@*A+%L~pKFqU{(XS(BD9az!0i-*_RLlpzj!0+1}g;(z^mNQHA2My zN%jU#bK<5N}4IkunSt}wnF~GMzp%JG(8Y=PlVwk-rwFJzW zevScRv0aH6OIAXd&L@$E8B`Wr2Z`)pozLDuHRFL#aM=>^Rs43jv^cN<+d=~ufHEeJ z>(n29jgnGMMhu$8whk4kAQ@|(VL~%xjR8dPt(?UavP8Jkn|!uAQ})hBL`NbB5&tW7 z4{stqfW>Q^xr9Jwy=N&?xP$po}06PXbBQKv+Swi|m!v*Ht1+|ja8 zzDg~iUr$I%;ghmwe^;CkV<(n8+#`8*I>E^&oD8Zbdqp^z*^a(rSnSmcU11FPUnhYe zty7kG62eJ0CttOM8re=`j^!XV{h6v_Ya)xaV?Ss}ie8Y2Cr4zVHL@z6Uil8IV>O}X z@G2U{dsPffz&~j!0rXq^o10EJL)h8kF5M+eU<2B-+6%3Eg^(I_jYc>Rqr*1CL7gb7 z!(%(&S@Y58XwVxhAr*OH*1Bk9HH#}dv}&0ahHJPL3#(O?7|AjbJD=?+VI@irydVL0 zxmW6HCQyX10!6Sp#>gGhIl7EghNc$PQVwE_%_G!<*+JF{B`LxaEmmmPgQWw#lka3v z5_CXq5<@(oZr-F%@{r*4-k|{FD-N0Iqco}5aFwPA&&KvBS7z8M#F;QnFTy{e(L}qF5=L>#lC(&sr9W=w0P1@?l0ffU#v^*kz!m&#a+^qw2N~LpMG2KFm%J*&H5Zw$ zu_#e}m%2J?)}3i}&RA{G&WsEnbNXzb?n_#K2H}wO1Jr%duS8PP;&*n%H$RqX1nrFz z&`K`hOV$#xwYueeS)$TNnDW4UP0lH7An02>(|=S@H1mJS#|Mh3XOI=hIRVa#lPFuU zTCHgMjk)c-KLD7*)*k672FjTvQ#Ubagjji$xqQfOkjPV|!<4l)3zE8xqD+HM3`{JK z%=zG(HTppkq_8xNh#0bHOHPpvnQ+KHFA#|;EhGvwF&QxCHgS?{am)>uU?SVHS~eU~ zvusD(Th6%ZomUPOHT544bm35#LzxZ^5fkn)!wS0yD7XMfBy3WK5W%7kn>neZpD;;& zB_9wJG{Sw#bnWx+-EAIwh11Tv_8Px!(@}FaH4II>;fV9D8K~%**%hj;T57HBDlN5L zyQpbDm2IJ*Zb8YuCW?BgWtX3`xr;X5?Tv4K>UxuAFIhV)dZ;8hyE&4r-7{NPJ$`H( zkg}b&eu_rq8zL}^(~1?CG&l1auAmoNsNH5qnrWpsdeYl^Er<7?Id|%8j zs#_Yr%8h>2fqx$8kzfM21j_GEpbC8hPy79`l?xteBX$ZpYJ5WRo0@mP$Ht zGDw=68Odgt$WdY^O3*o~Np0yjz1CLyJ!z$9L#5c1oGPWZ&ZmLn&($RBTfc|2oo=KD zx3kuU8}EnR-am_8l`hcpU-I5R>;1pu#DG!iZR!&Buhg7#-MJ<6-E;-Bq3cc;)>UvR zKoyQ5KST7$CQ?RG*ntZ(7am;LypVD$a0_Wl+6|h4=AnI-4EsrC<>pST__+kIxZK7I zhDC#TU)?@_%Dt-2H3cg|1FszFS(f(nudTJ7_om78C-c_mDE*XGlueZVl)IE~C_hpj zQ46ScY74cKI+OYV^%C_K^*Jqz#-~YXZsDh*D3MeY5p{^xi7ttLd@#Q3Z!fSPgK8iofzFd^ z*zY@*({P3y)hRhm$8Z8Cc7DxQ+rwD4+MVKCQYfKG_!5OgF9}GdN>)gYOGYJMNuEm? z(mLr3>5z1%^s@Ah^n2+qvS=AeRxaz6Etaj9?UH>cJ0UwKyCJ(L`&Ra=e5{-+uaYm5 zkI2u-zmz|c|E-8u;1uL9=Q9<8zthMR&5D(ZGm57O2dPH3BDayp%3`HQ*{l3S`8^tq z7NaOyk1j;_qfb=vs$!K%HCZ)VwNSN2wOw^sbxZYw>bZKXI$cds%hZ_KrS4MqtCy-T zsb6bw8lA?gY0>m)mTHb^o@iOxKJ8NNA5ae6a2tH2McNBk{y=^*Sx^DW> z^vIlPCY!}()LdikGS4-?!|A+Xeu?E{HmnJI3)_ud#s09wTO^hiw7lDcegb;H4@e)w z@o=v)(eVN4I+*SR{WOL4mvwELoL)`{N!bVlkaenG(i9o`K|j7ExdMuf_q#l(dndR} z*D&PQhPrm`A%xNOA#>WS={K48255YjH9Wn%iz{AShDb9WN}xT~wopXBln--ZQBrgG zrb-_o(T>a(W?Xq*lJH~Y#XD$!SHz31QV%JT7 zKLM%uBwFc~rjPLlPBGM=T~V5A!(VzkaSlB;YjdLExwKM1imGZ>)hxFKaj6XRLK0qe z|GJ@DKymXCZ>W`K+Bk%YNxD@g9u-$m9&>Z^Am4prv&#~>@%&cQ5ev;vD(wPpDaZD?ZefgI;eK~9;_<^uBeZ}GLk$3=sJ=~1^C|#66;k{j{Cm)% z_M>L3$tt8xmc|#*`pbZ?8&WCe=J1PTa zc*qLKHM{{-j^8ISEDfLNG0ra-5&}F4#6f-;3LBw9yW!-?b z+;lS!U12yqNyB!M(jH@-9=KfZb=l*&6FihH zh~5ZeOrRJIR^)V(6rPGk(Dkj&YU6{koG}irMok;R!|&yP*(>lT*@2?S)w^2n~zc1BV~Xk7di}RpvJ}V$;_VNSdrKVt zT?q7p4^9wU=>3EF*)PFaaBj!u%RxdqgX8>>R0AP6gD2us?F5FRz))WDL(OpfYT<`S zkL88#$nPHXw(gT4NHhR=h-u{rU3L3>@Y%r9HM}XK(A29_pz=KwfnTM9b9gM9Gd<-degUEE(G<%)aHxGfA6b5l z%h>9a1nnITagD~+4^?4!F#m4@nP=U)fjJ3oa*fwaQSvZ#kMn_7WaRzrrw)1*xW-WB zjzBfb7XN(;z38&RXxOQBnhW~xg>1F=e&a9*{-g8^OqIG8eWbVK_i>H(7lEezUeC0R zc%#aARaUB7Wsl!mx^9>AVn2VLwzG~8soskSC=DQ|wn*UtkbSpp)c@bXH+hf+JSha451moYU3as1trDcZ0I1bJ!Z9+TDRmubHvqs;I?kQ z^m-xL(#Ra&@|VEl&AB$NKq?WT$30b2dl9q^5K#@L0uM9MUCl+rFrKMYEk@5bt=SiZv(&XY^~$ z@QHQ;tN-?Jd%K862Hq^LWr5{j|Hz4MtYB*tEKHICI*dZ6PZ`ycRM9%Bmk0VQ;9E3 zfFOpAa7&y)$a@vXGZ43jY8f~ITXgwE3*(*>FVh4h{)>N}L zYEVX=DC$Y%g+AHWLFl7>N$7W*;ok(Wz&orr`9M`}q#0tXsje5qvU9JAATSOQO>b{%TbJF!^Z4bT zPP0?*tYOo9wVye63At%)KOBeLw0LWt0zJ8Qb6_pQ42sj2ZlKF1?T)G(t^l<9L-RdZ z3hzDG$|!~Hq5dO*tCRg+r0Z3+(rzL(j?2YlJ$dP;Pd{B+f)4Um#r*^2-rTn_?pwu} zSH+()n86AWrt)A$g-33^>dLj$Ge2OQnFt~rU}w6F(c7id*^XCl3uGEQZ~MJYLgZkET?t z!3o+zt6|d?03{s;;ZP%<|4`Yo6D_o211AfGJwgaFjBky{1{Nyn*jhp^xSqn4y8a`C zFwbn9VoM&^h749kfswTJ6`A>mw-n*l>xcH>X;T1B0hGs*lB;Bvhb~v!JR}>CloaV) zkd)f-`ZKI)&#<5x-3=4g|6@SsTGo!Qb6(9g;@kf4G>kj1+c-Sc4gHnq@VIW;NDUMc zAGDJyhQogT70-XosuN+;CDKw=1YR?5iN?xSo@HrBh-2!OOXMCQI&lOyRK-C-!$&(| zv$ExsU_)@2cD>pssyFL^<=b`R$+TQYvp;>qN1|Lv&}6%h8>6hcUieC35;wDLhk2%` zGE7%GX9JHs6^=0p1lshT&27x2l27~=u;4}k@rulbqBxiZX*$F7EY6mK6u<43fl8~w zR(S_%=qY$Ys}VK&h46;9M=#SgTRvT$y5ChhQe=Cxk{C!JHeLyleet5luu;Wst)r4? zdv%PYkQ9ttLHHf_#=gho#keN$SQYWw1*SWuUo?S7^9*XuMGO&UyBumwy-p^fLz&9= zyU0?9$IWqM1)X~Yz|o(*t01@@#UPfyoW_)z@=GIF<>Nqhwp+c97hPM|siTXeqV>qA zW=KR=8-H4JV7{S*_MNnL8P#RaI5Ofg1(~zKgrl5m?7|kb=Csv?{AS_VZP8LHa2(Fr%Z}y6{R}))Ths8I&gIT&(dWKvr9+=rPpMhr{wC+(hFxT z7dRnKq8T~|W91NKsB8$RiVaD((;j`$-6qQ;2bo?l)_!0`1xO4T>>N)A*h7ItN$+YB zrLI;Gj+(a7=SDE^Gmt1;)g}nJ=^x5KF|Cb+_w^`2M69Mc#z=uc2`u?Yg82Wu!a2=0 ziXKu2b3=yJe|u=mJBf}2B&L;`Yu5O9Bo$75EPMRp5+COms*{yd8g$mCt~Kyj7FDXY zPV&}(oD%t2wYojUAhZk_Z?x#U8>1nb3%f%pAx}_a+n=N)0r+J1ANRn_D&je*D}k*$$GZ15_iLT zOc0JkDYNAsEf)j9T@I|M^ZTl$jyW$2lC%qDPETRqOH@JWmGd^8F?$KIjq92kzoBvk zYb5H{uMr+z=2_S>Er`KC~9Pp(z)Z`tSZI1YoL$ilgrfWG#q$zDNOapL;@ zd*tl=LM>m+GLl!jyj$<~7q4noxk-C!?f-E@VzTLR(>a`X9~LYcS&l5Ho3Gz0H4T`c zZ)OkKo)UZLqFMBV>BO|A(UtoxMkTai7SB=lU?$cWHu|H+&Nn6KsrPh<<8NPq*OwJbxpG}*T{?1O!0*vUY6ZK-_^tD=Gk8z!c%=KT?K zGWL7mFu8(2XuDI$4mj)<7Sv-tR8SQqWS$*AOzMcHV-d(G0N}GYr5lMI>`14 z^0TYL!SqtDszWuu2~f=9yU&GY1D>yg`ve*+DroJ{8CxvF|KG<$%2f6i)j%T*ik)TEjvb!rbKoLRpc_|{8AdGNe zg;kYVQ$oysH?cwQ$)0B)YC4-I@dgRi2Qy$j@7F=2;;Kl~3TVeY`n%{8Rnr{PP#{ny zOD;$DAl!)jaeKXL|2}*4wvW7g-F%7JMKT;<-+c z4_~6$yoh(xd7(88;iJ|vvvip^`(7`yCYGG0lbq)eZJX!WD*twtQYYGak3{TjUAlJp zk#tO*=^%b~!p9fX^?V@3M4N%S)^Gt@1{v91CzGld8QOiPKN6dou~EK&aettvGj;yg z+J&I`^Y&*raso%GSOnHVyK;EFw=7#k=zmXmUr>eWN$BH8S#z%aUj%Qw? z2jpILvWZ;(Qzl~Qm#Zah{RAJz@MX(U@i$XLRkUVy;NAQ_sTae11IBO&t4P@)enn|o zX@pO+z}kN$>f6rz2=Nh9id0j#vBMOOCm5UZ{bQD(z;vX!>s6(X4H5*e`>r@0vrsB? z=UyQov>}Y2L0Tn->Qd%z<`Gj7#G#6q$4m6&YS~jt1Xlj<@ z7ULi+?H_~L51J2~sC>5`)5d9p4J`G>BZ@_!JHDa9Ssw(c!PY*EA=S^Qj+#e{H;rSg znwZ21Ow27%CRP?39AYqQ15PL`q&*aO#Ty>a>S{I5z@%Q8JXZa_;&|Zum9Rg`u;l;} z{O0@LW3D7OqMOX$f2V?N!R2RIgO3C!+8MIr2k5P)z1qUCbPUGZ>phj7{iQrMAV;In zhGG(KbxEZ)#Vi~(=jC%l8Kwm}XBSizi3W$%a`J`1DZY9^)w**i8CiYB!OkKrsAOtP z%mTLHHK`CogP;$?))9fvLu#*DjWr{?KLQHXzCh8ZeDN0K_*GO9JWi@acNAd|Cp9e% z;`;?vc{oqUN?(X#!%VUVA_fX)pesHtR>vxZ3F)j@%#OC_R+hF=Bu|<6{>f$;E-!lv z4PvQ&4sEb#f3}i4v8Ie#otxp!>*%lE&QuKplcmJ(bf3T9hzYDuY0$FiPV{nJ-%Hy;P$rNnbkL*eOQb4{!b7??%$w#z`fQOD` z>|2{Xfl)fAkoW^bQ4}0!EY@#cU*^8o-_ca_FJV-g&Zh9&6kq?Do;8YI@D5f}(Y1)> zSq#4ZFJrDhUk|;5*(Z{e^9|HN`{at$a)2KnW@Vs@bb|yGsd7gWGk*DVw2-Oa_Fx-Y z1kI!)ap8N!v*rF|%``X7SD*2h0|!UJQoJ%A@Mv}@F6Q+LbE0eu?o%%C@)N5Xu45sw zb{^Uem5&T$m``j!)TAt#+wufyimFazA%RXHX{m;$ocbVOiq-^`%MLm+Wwn zncQ9QbgTBiy?0%f3(hAi2=4zsDuQPEq@O65Qw1)1pC6nR7XJ)j;{)yGbKV3Zhu!QL z#iZQ05#sxg<=f?e-rGmN)}^h|qO&5s2qanS#*S4h+fR#^Yr8ZU0vKU;a`GwqoA(vG z?u>TY^<>WyQoFB@R_i&$owM1|_m#_~rVS3(o1>!_E+XPyk_>46WSxOc@HD++J{+V_ z$97CoJe(rE$NpDb)%`_6oTd5k#;itbTAn}uu$rL}+oY&KS%CVmff5S5)YLEBR79Tv3+EeL{F;^%5=X*S2-X z=A9dIsef&{-9jc10ompO{WHoiq9y+c3>iMU9*9I#N*yoy1}GQ0Vbl%&PpB;N6Jh2v zKby@7L@3Er{?4CRlh_KPTXnXFbd^0aymC;3YkQPM=BHqhyOmm_lQP9BZ5g5p*+1Fe z-fnjLJ*A^#@80(q@Qf{6zX^pqbLhy2#-!L1E((yrH0fZ%u6ht*-7?R5ywGU2DVmE z6ag-2`nYWsWVH(dOL}XzcsX>38@Ce!0lw|Eu`NQPay4y8r8it6n|g^|n}sBd3}{<$ zN3V_uqL;0?1N%|TUcKTKoGKg0~!ra%+QAuB`U#e97|4L}Vpwnr@z`14^S}yHo`gqBO>hD)qQ(x61#y z+lbcFTM3AjmuK{_v`ylz9L^y^&8$zpf9$#&A4jxo+K_luXC}F*oe~hiY!l|?C76ZS z&b95$iDSH?q~0d$W9(vS%hR((-OggA|1AphOV>2lB{nRj!(NGJNL`er+e1VW|)*-+|Ra*;Ed>D$Gz3sglI#|bXDe94AJzS|n_ z-7PxhdVG4Tq(XDCOZYL~5T2Tgwdm)?%uPmJ+qx)?YO^={rcZMDR(ac2br3!Y1$DTRPpY%6i`#`a`r9HYjg(--CXz8g3rLiiJ#@CfU)HGQ^+Q?3V zh|olb3cgn@uxZcst8t`qK(Q#wEYJ@*kGoA($h9&9-+#c4fq7pk#r%sW=P<)Osi%_K zw5<65IV~w-k{1kpCI>F|QqvSMBydrI5HE|eG$Y24ST0L zxV9cuGQ&2-GWum7gk3piX?U&P29s$ctExTES%JmnmX(DZ;y6CaqCE;dIk)8u@xXQe z$YBL3!?i2Fi|<2}R?}Aa1Gex@oqw0ppFH_|kN@{nLYo0zp51@%_VkpRO8I2<`(@=@ z@_(eUwq6KCOXH%-dGh+EDn45QA7gu~{3Ev!7dFOqqv@<~#JSX{7D&ReI5zEoDz!#; zGm$;s`XeV2cJj(u>-i7Q&wtODKby5@pO5*ok8``)!%Oknu6{p%soPIaHo6oUJrg3?@IX7hiNab=T=!t+mkNhj*R^ko zcf5?}c5SoqPhY6vkikR9alay#2T+Vr=HH8J{jWkw*?-UD016MzNHk+3E`~6{INhyu zrq4c%R%l_7xi4=1&i0f272siRahk-KkrC@a$-tXF5B**R#?uffgQF1qUiCP8aeuIw zOONv%Gq;^bSFOw+%=QnJ4|?E^<;cHEZe@%Q{LEZ1h21@5=OX(X033tUGWUBwS1_vL zd|mvb`|%cwuf1PA{CKniyUzfY9J}JGwkeg`|MO>ot-K0&>Oz28Ej3KbD5ys ziW3yg(Np)wiMX=iSHJTT6243A%b0}Jou*uqMF_u-M^9neSoUYlSyj*SE*@UD5h0UV zbR%(i)M&V5!7?T^OJ2e!q3|M$T#Fe3+(1Fe+!v#rB*OQyEOhpwSU>u8lBVqt3WR9} zS5si#=S1d~Pm0y3*Ok0O^oi<)V-Trpf#~&Sba6O$PsB-n_MYM4S4H$85L%0g-GX+f zM()P*!nv_b)%O-QcpdoPc+N|meu;=YeVL_ssdHdqg52?eepE^7)pE7YGSQ=y#$>kN zY??;bhb)jmB~8<1eMGvZjm!w~oC7}~5%JlO{XJd6`LojUVi-L6X%#|Qv8jL7UKIK-CBH%<-U0C@0`a> z3vYC%qTvUQAoNGexvWic>q5oept@pjyr5;}Sfq{w0I)8COG{-#&qDOsa(*YWFDuWL z8?5fqaye2oKY9v;kbjtGtBm~=0QBq2v@Qw#u-TYUx~3C4)8^9{({cQkON+K?)=Q-H zYzZc_8-s+$gb6TpsZiLmrA-8%UMl`ks%ko`J>rOE<)4Lq@V#7<(D#2>8}Z(6khrZZ z;THuS)n%PYkrBv6h*?ixqTOb5eBqgSIkc!23Jz&p8*>N`nOt-M$sb5bHCRNNQkA_# zr}<&RwDHZa32i?~gFNN%Q?Uln^srVp@Onfm;Z&3bkcyL{XjOUG`RHo>Sciko9-v8SxMfV!p=>vg!a=4%o5_P{2Qp9gx$ z8C6V>wML>K;}Z0~0}kjV*Om1X*+c$^>e`#&Y5~2uP38&?h>>z3m7`>JsRfO1r;aCQ#?a`rfv)ioF zAaLy{BY9i7u8fGA&{ZHEDk!kIxFn{(EWlo=mFsEFk+&R|5ymESTH`8O$~ZwZtIK+Q zw7MeYiVc&SXjy6362x>loI#%ri)MxB!gp${-ODqMwXIc$Uz5*| z!#BPj7b=$=;DIorB)ejy;2h1wov5n%ySS$BHPK^vC(9y`$?PaEt2|BaH3NLF8Rs{4 zEUvfSYwi`aKy_;p4!|Lj2L3H00jfhJ_*V#gJd~|`ucSBO7|VOqu+5L4uq^vxrPpEC zOKxei?BMJD*>H3-xFTEE!|N^M`)|yKhbTD&L2{8sh0(b+LwoA8iFT8R3UrWCIw{tl zVI_1LX%gL!)aC>-R4U`pz@?f<2>k>O*YrY?3d~Nh?2?6Z?vjOio(RR(^MqjdJ_lxH~`HFC5*So_DdP5EqxN zh7m?W-*b%p;WiS#^I_%DHbL8r(z8vS)V&+@O`uwDQoQKD-snXD{_lfArG-yZI8o%{FG+xym|kvpk= z{FTLZ@Yv<4HvITb7@dPsv}@akbjaEHhe*qJyVK*-bX_<4;O-Fex9VBy4AnBw`~ugr z4qALqhW6c>ky1!{A;S)~`A#rkTK3zJCQ4M?rXSIdv#wWN%BaZYkT5Q11j?oCdNHD| zl@o!{JPn54wi+Uo?#bPn2iw3>wNshJEi47}s=lueg~zY*WaoO<4FX-gzk7cSqHI7S zei|~$)txda(~ahV-OXJR-qx+R4wn0vA2fbfoAu3Mv*5llJD&B6^ji~qNgimd@jJ^- z-}!XkMspK?*Vpb6>)Vc!A%qY2WoV8ZLI{;wA)|3L!$UkQxlHd_8Xl>g^#=^XJij|N zV7>lmuEvj#(MN%T)}8?HRT?CanBykc4G!_-X3jBCTP$-Jbl9@&v5e`Lvxn>(%chyo z23xFm8z@w$BhRW&h(20}Hlp31AY%}D86_3w3MLu0&1pcAE_1qS4{ZxTwj%hq*6)yb^n`wS}e-82cbt_Sa&Xz@M> zX5U*3Bdk=6(&NYwnA4`gW0TXjG?98w~fs( z-R|V6E&T7y2CGrxv*Y4J-#xs#*SCHr%cR;JS|Gvj{8O7XRvA(`f3b8l1Iern*6pCN zUaS@z=c-*U=YAMsu$dMsZeomrUvh5rgN%sZA`G3E%sJVQO(3UOn73sAvuP3}>1;ykA8%*`4B9MC((J|9H=64)&(Hh6$xzPihNz|j7+}3r+WZ@Lf-YJ|P zgBK~q!3it_c(mQ__ro6x1WoR;v9wH9r^)KmZbR8_xr7y9ZI~T*T0^o;5A-9tVy0Exnec^gzDqupc zy^?J^&JP1;k=`Y)N3hwNAYkf-W%BTxgF$~QA4DfRO2yCZ#$eiDvv@t3&)c07ez8l; z=XO)J0xH@d<5Hvig*CAkXtw$xKYODL2wAR%)Xg9SKGzU*@e-Td@WZr7f1E70mvHQ^K+73oQVAgk{yEV4?Cu6Gl@hIJR>Gmf$1~>N}8>Cwt zM5-S$R$pCR1qtR`6cMG~SZru+ks$E#JfbJP_6^2hC8fWK_ zf~-EC1}9sOkUK|w`z1O$87|k8(bqfmDGl8vo_l&z4M&LcQF%j-7O!dF@QsNOqVM=| z5=XwDt9FKAWraC_0$adCo`>YZG>mw??%rP5TUHFj!D__f21I1VkXM{E{Uu$BWMTq`8tue;IhAbkIQu zO!%snalq><&3?_kJLDHpPai6~FfhW#l*+hb?#JStjS%%0;S8uDQ1kguhhhC@=3 zkDBwQ_lc#u( z93eTbJG(o5)m`GDnB2Z)mme2oBl9ny1pn&^ct3ONvnmpc^58gv+|pRH-P%ut1LyMK zD>APk#Dc-$u`Ydk<0m!__}1jUB8D8aDxV^(dol<|D5zAMhe}+geu-WpfxA|2=(cTD zHIchmlEX^+sOs3M)$%Ifw$Ic1gha_4kYDh{R;jBQJ5OA}IJD!rG6K%D*qM80Ib3A< zH1s^7YDKr z7!n{b9$-PG!y%_)RCmgJ-_C=5oXr2lW+!@A=s$WmWeCeq1kr0(OSt!?=c8`%MUPu| zCc~nGKR#h>(&SYj$F;i`lZl1nrl}E%Q8{Y+C7KZ(=F%@eZ@O$4zV1tUsE=~+chSN$ z@V|slTy7pkMnI>TG~2#Fx{Fn=xMRDYQW^wZVXQhBcyKz(-yvZQOjWc(8Oy35&{2ME z>^P1y1#<@^NW@@fe8k2aB=*Yj0Vl}6|-9*h5G zIQgX2sxBjfo4UKzVu205kzYfr1oNO?rW4-i`R!n9C8&8W-k5Cixt#<3eE^ydpA@!{LzX}@KZ zrq1cT4dPjajhrbCrD6CfliXv?#2=jD3}-kaGjYZW3d>Z;eL5bIIq3pAdr~4Ke`RnE zQ6|MdkGX)sf#;L(+!j3Cg?WN#6mZ55rIco>B4P~+dOtBhj;bZTbNqdLN1ke&`>2(T`>5U$6s&u3b-@*_kBY zPZZYLC(j(uue{+w2TM7&_co1|ImzCA3|-FBKgq{4Hto^z6OreA4EF4Ecev0n`2ty< zjb`^BitY4Kwvmp@=|DAzOZa=J4<3S>{y3<>K>QK^yv*LIozK75ve5sN_bxLB76G1r z1&{qyJ_O>w7!R4)66K$=BWOl~|NZ4o*9mz%3LQsqdh2?9c3%Gj8K2o24B2eJNucOB zse&+$NvXit)6vJli60IlSM|<5ny9aC30FsA=RRp6R*8k4%2afg8NQ6&R-e^{ke{HU z&Hj@@U;Oza7=eLM=ri@guCHXp#L~!8@M2r4Q=v_(g{_PwuUXY1a;fmz#2-tLDB!(+ zy{a!J5FXEk&_=+=NMsc+#S{pm#fJmlIwrEPtj^H-V2j1yDh5-pcXGRp6y<$eQ}a)| ztYMxvxaD6U%HY8&11X%dhAs;H0yoCI@>t?0s@0C_@_V0ug326t$JpgLXvNTTR)7D> zGx)44LPS6nbY0?~EO4`ZCgf|wCrPMZ)Y6aKl_{;-N?UMi>r-t>_lW{iE2Rc= zHRU;$7p6pk+^IBSno0^e>^4x&VVx9baOF&?k66qii^jAxqg%PJL-$s`zv@niX0`3A zPkue_YMlRe+{*ey`z*z0_dBjf{8%@ha5{@4oh7wOd|F*m56LqzP;``>8I=m|)4Ul4 zp?hkoW;x=vt`KjVpqKuV`LM1YFcJdRC%6c zS?23NlNH+9Lc6Z3NOi7%CX2=v<4uI)W?FMDBb@i~(&kgo+PmlW+ z5f}R5HH9Ko%<*7A(O4yN;my`u(?i7>hUuElXo9>HM7bt!*_^;F<#^(CIAvJWt66Zz zYaz;rA?P$NQ?+7j5dxHvGAk4`DGmoyYsEQ0LLZaGA$LOWwNsTcBASv)L+v;-v2><& z73jAai=>=jR4)VJ<6@W#>%<4IkMSG&x6-4Vh2>QilguaVk@^)dyPKD4p{eOTa!07N z{nQp~d%rE&mTrr-eNBRod+A8`LO|~?+WXWV*4}*&SwK$GJxR-QuM1D``jFNV5~kjT z-p3Lf2G-9_mdO7#PK>mCxcuQ5( z4~z&L)i!0rlGph9C^j&# zMH;)c=5D9NmP;-LYjw>1ZrnwI8pmdJV^q^K2LqR-1@7678GT^@4rlyhK1+G~s_195 z3r8*99-9LNl7=byva_~!_4e_DK{yW=Vi6@gFfiQu(vL1$(pgA@C}sk?ki+sQ-zbGR2a9F(mB$=oiiPJ4kk~SG%Tw7#u!RS? zH5I}UTi|AMtGolAth>7Q`T96qSzE-}tO)$lOuiw0RbW>a-i22actg-;A{L`a*0PFpW>fo|zgtg^POpJ_gL|w}O zNPeLSVAwLdP=?~thRXsobn_99y|%3>Vfq^!pZ{Yczf)EAK$Ai(h!t-a>A@6SnKLQ7U$v+6)v+w>)*mJU)EQnN z%c|;@4R39-=U#eDVdYKvy6-xdI+W%EvPzYuXKbDK!C6>rcDJ$(=y7^gM=CH!AnFpe zpmiImDy7?1$ImSkqQ(VaC_QCFhc<*}h($HVq}KgrTE>Bh%V-xlt`{nzh41y674=Hy z*)$EO(u9`GRvKwwKr-5#@Z_Q->RH?LRNjrWd#%8Z8@%tfys8^xl+UwmhLq6wV8$*T zX_9|ox9&P~#bM^f^Z9}k{#usN`m7Rdp5MyuruLAH^1#ENIqGV3PAT-S@ZYvh^3%bDc1h)X|+vKtc1)W%IJr5anoImM$K zYix5&yVcllar0%vkl!oG?*XDLBXoeD7Xr^KAzbLOv)rv#W%#PZdb?59Td^D=O26O= zygz4a)pLbu9@(uHv(gv7i3y3HshA6YP}fs2Op839%7Yn|-X31Md!C0?$Z{>z)UCaD z&UnA#xH*SHUZOO=qIVJqrlcQFOEVNjzIe@Dn|vX zTxn89`h=cY5TvL_byX^ILRg@2#TOUr5!ICq$yBn<=P zFgS^kQrKr^*4bhId|uQ4ibtQEGkfvvH||&n<=uRCAYZEwwbr>?a*H_09xLC822ZRQ zXP{8cWni_Gu3TX?ZH!;cfH4@Sii(_^ZXAIgM>HSsrYgt3wQZri>pS)gA}<@HlmERk|84)Q)SIpkZQ+r?7Q^)hkIU{51KT^fHb%^1Gov9bOekx|Un# zK@6z?X+kuXH-wU+(;h|PE~`wuWEa&LdXP+T3D5K-G};5B+m$Z%0&cdLnVdd2JB6}H zZUbXXu%~nI#;>!UC2u3KoKKyZ-|S_1341wtR3Hmw2;P9(_FBJHe934t+rOmJg?^hx z&OX6vPk@lA5C&Fk+7}HkGcVPw_}X+7P+{re%XpogU&%20h)hbpB48>qP)GB<-AnRc z(g7K#hBC;X+QN-FKeIz=qv=RygZ0u7A@pwue44yd!99!3Cv<$^f`2%qhm*q)Vwf&A zT`%TEx!z2Rd4i!G5d<=(g`3J*kGm@OZ2LX$y=0h&I0*}dYQF${^d@wYIfoX2k}aUHBSh0jvisuxha@?wg)6e&zm<|r zdag6P#d`C2q^MtyDm!1}eCt-!zZnrGe9$zL${eyCcxy%_C7GCl*PlY1;H&E$EeNX2 zyxxX^Aqa{!EMk$Z>rGv&s`5k~hPXWPe3tPS*vjIttsd~upp%b4?1H^G(Iyc1rQ#3- ziv#x|=-;#kbWr^1lLsQ5FR@P?DLdF1myba7dt%>NqWqZ9B;7#ZA-8tw@kfh5A$oHz zahl4^9YY{Y8$BGK;nGW|S<^En>0*&ujP=y{?snRix5;O z*K|AlHq*9c(VrjqkK61(bVv+=p*aAUK0v)Ho^{hEV@cF`_ID4-5@_G=@!)de>zwb)8;6mGI3}~9bK8`opw}4A$nG*s#S^ON0P&emJIFQbIUV57|v}xhY(W& zosL<;1P-OHX?U4#4nSJZOsA&FuIt~7LcdQQN;6vY-$UjI&rT<9IzOUCMCn8qrc64a z@hPa$bibDwRnJS1k+SR+t#)&CNDt@TBD5u0ev?Iu`D;H!KUvr2=;|c>xyVT|=rb=!gns&HW+<6C*oDBIAcf$^n&$BIi&f28%>WuzNYY$%%9 zRM(T%m1rD|)!$P!<=1GY&U^Hl<-6kTe@bHZiAeW-Nn!Lr`@Y z!o zK==#a0L@&Gq~Mz240pn$Pfc=4>Zcadm&R#>2Fmjk#kFxb#@b6>bH5)&o-}CNT$@lj zh;{wOe#9il3T|Rr{Z0@CQ-V19`qiV$l<-4|N{%+~|Dw)!lC9X>!>`XjxKPQPlh0r} zZXSjwbAg<{$ny=kKGU5kRHtE%Y@jv#M8Pac4?GK(NnH5fIu=$qcSc*&)vpO0v6w=P?M`U zngjP!9ANSAA!L408936VyIB{Q!=59S0YOq4V$R&6id2DgjEcqz%@J3&I0RkJ7Ry2s z{8RRM5MgUrNRKIK`^}DZYUkPU1)mpZA~N%v6x*cH8p>5`kK8LRT*SpKwMZnUjA_6RWt$8Baa@4=rm^c! zj)`aCRv&FDT5DqkSIB|a32?4r@G|HCi?|=ZM;fSpd5eYAY)sNAQv8GM+=auUrbQ8A zU1HX36qt`Ey3DFFCv$@7g74d!Jju1r{MbGjb_R*%lCi3`bY&`;lqLj$?=~_-2IKzR zh#U3|FfT=_IkCy-Rg0$0;R!ZW&dBLQ;BP^fSx&b1Fn6b&vy5l{wFRrP&R7>e0tZ4rsi>i?UyEDEiq6hca^Tl4+< z#t@T`F4Q2o~n&V`jNZe^qU`5p6a zE4b*IGhyYU;)yI=XVP~q%6}igeDB_?)lx8&W5N(Pa`J>0T&xAjd`gP{ox$P$E6&B7cP7ZE>Lu2>6=ldoxK7lyIp1TmM!trwS=>SbmvS8w5>cQkK1k!1gy)f3LO$@0WJF zL7rXc^`iOwBfQTJG>#UtQ)kv_6raeky(f2{kT`D*dW&#^XSCH$spq;$6b?(OPJ@U6 z;PxBY@yXfwzH4GkMp7@8=+_Hh+_skP1y>dPcF(S z$E*tzPLIt_sEEe9@k8zx&^Lbsr>Yf*tN>V{3!Il1!{3_Vt*^rPsOk?b2acwNa z(Bqpn_vc26@~?)~cmze_I@VmM=uJ`A2*ArO_)6^7Wc)2(j>Eoryl%2)I6za=_5k~y z2axk;0s$v}Q;wROz)zR z`To`%{X9NDU6?#Qk3ke*&AV8CV1^Mq#xriD;~*_7pErtQZSGfhPcC#pa1)hUyl$Gd zaj;nPTdbzFPFl7oHLb;l;<7zGA#i(H_^E{vGIc#@8cfPS?2hBVDcK)>h!^Xj{)+qu zEj;-wGu&ND(ejoguLHxGkh~u^AOe;$`K2fdC>OU$fB%QI!^-YNvQNein%8N7 zxs!^5%UEil#eHs(E0%}Q_L)!*9Eeo5aGtB}LDgy=sJdG1mT{@J;7RiHB@%r_N-qJ! zKZ8!KZ0sW9?bd_|Ox7oif8EWzkSMo0O;{6c?JT3}gea(o zQ&Ry7S%qveN!k)|xa4PNM~xjjHW7Hso)-15-re0SZtMHE-wt`Q`iEzL;e^8AhBGMm zB^+NNVsj#e*6gMQq=D>;3ax})WDZ-RtHZR4YXd}C})^Em< z+ucfFJHpJFZ8Vv2%-!ATr_HB4P8H5)HuDf?&mpvAzSk|SpV|9wPrPm*h9>s1W;Tme zSy0T}F|)no0MLSvH{*=1$WMt)207{Z66DMYp?UsH(P1&a0{C-va%&gkM5&9YAU*E)^lsiwZC;asmx3@$JrLjIOT^`sJ639?5 z4F8+HE79#Hmsdj`hB$~D$V)oDN?PkW{PikLXKUF=*EP+yy(%rn$R1M!liP=%3BYo> zB1}du{}th2jIZ<0v4^qpl_}hhbN167-MfOh0XkC&Y|0=0VLd)9|M!*emvqAOe(e>K zZl3xe4Z%rvnLC96j6W=rwDy6!_RykBk-#XhYfl{KZqtTW)xc}I+MfvVq>N7}OOjz6 zI(-~O9B=wJKmW`v33n#|zsUom2fM5|&E42Em&% z`%{#}-*Fb5?3W;I{f7)9d=21MHwn?^Gn@0*#Sfi=4=?pwg}Y&b(A)7RZaD0_+~5l` z>+Dm?vyUX=>xRPUWpM9~4H^goCw!0$`4Cf1ln-=2rOWjQA3>+52>Ht<0=@3{DtG^| zg_BPngiT}r#nzCNRu+=SeYALr$O?*g)jD@L{IP2w^wFM_a&B5+9b&#S)4(AXbI($< zW_ccQmBBhXe~y&)d}W$fQ>(`Vde1U7_*;Is(4B8xo7E|$4td&wyA}-}Kk<~g#|uRbE0urqk|LX0i>!s`>5v}0$U$HyU$49AmOX5 zDk51tu^6gnED(r?EPB=;(z9B#m0CZ};zQGKO0(c=sDK|>o5v}*f8c9`sgl^Y!g(%P zC=uo!RDGEka!@jWP5RO+2sUFzEFJQ7FIYRUz@_$@YL^#Rg7pb}S=VQ6BKl-=m@}Z$ zcseE^9fi_;r!L^_$phS)nIXlUrSe%?(OH}?TEgpEI(O*a5FywnaV))afEADJ+DYt| z*PuCFB;Z)`TeM8xgLouj@|i9a<)1&8|ng@@^WQUbT%#n@e{)9>@Am zwClTLH{P!2X~*+qQ*yq^Q3M%ED~pWhpe3-1PbDIV_q30NT2q8!nkX6+!9`76p11m} z;&Edq%FA4-xlyL<%vS)FnT>>&jDJL>I;VRBxj-#!8Kf?swPw0V{=z7ZUxoC}05`YjI;1Z_^V+ z#J4$<2>0S_E>cQA3CzvYHT3=_xVatG2(+={yygEE>EccWZ+)!gh}5fO07*3|s9$zA z3ZxHreiWZ^5;B7}-|%Lcoct`9S;AQ+xlMpc_n)H&Yy_p=vjH5-Fxz+rM>i~NE@4c`QU4F zfE8LtNe6Rh7%29Y&q2PPC^*}(C|$_ia6W0il4pOJ`2^?;{+s-RkB9LLIM<&Q%%g9~ z2Z8KltDnC^8MBYcKTrB3W5;?cYh~bzfzPWsm!s)2v#SX(DH&w4_3;zP+{rHY)~BLN zT)%a+JwJ|;0FM6fw08$z`*0@d%r%C+Cgx^J$$awqX#1@$W+YCE!b?7ddBE0pN;fX6 zEo4=OvSX*X(W5)f{!Uj$<$Bs{#fO;X-n}-=OsnEaPhgkfoS$MW~A)~E^C1e z0_Rj4By9b-LCV?78)P~!a)VrYt87p(HGPAUyQzV zlh}#O-@u_WeuDtHu^S{X7?`gY(FG1I5nbR?farpFZXbz%MEu;DLIbFKaMV47oxxF; zg1+7?F1_;dM&Mkqg7pK$fdG4&jKSF7BvYbx{R2C6;2xlI(m(_3Aekhyg+_e-I`_s&4?b$@MroHM3tLU4 zlGS)53qzVRLf9+$GV|fyGW!CNZ%rejpz5QCF<=kIazhgAsbG z>>Z#sywj|RB;%f6HwA;i%6MZ`?ugK~eWqv7)AJ$r*704^18pb1IsfMY0!c_pG91HA z3KB_4DpI2(0jwcNy69uj$subSPgIIjU&Oo~GI6o+dOz+^*d8dGu;f`W@ccP9=-bXOR22e$lZ}z zqqn*%U4~3qvgOD{ktbh)LPd&|BuQ$eGUY0gCGU5Yolu3UT8&zDDQxK{4I0xHX1iuB zTD57f#k)FnxuzSfiT2cNFS_gcYIC608Zd&{whtl>>31uAKMa7uvY`w`I)Q1V4j&ma zZo;IgI-S94vU6^`oai@Bpo5uxSH8a z#!<3R(Bx{~NIM%%p)nL2We+9FuvDm0qfUb+E!uSG(yK)+oo2w0QLSp-YsT$l!ju^t za~8Eh_KX#}{kd&4mo*lL2MB^@Q>FDI1U2RrAhaTAq^hRQX+FQDE%zjKhM{@X=5Q^| zYUpat9f%BJaYIFrlIBwcDU)&v7zOnQL1u=`>;qWPaGrbxwG62Z3iNftf*9Fd8}#K>bcVw6PJL& zB@sxJlr$Q^fLNT2tQ_91oRr8*=0ZN)>-_C6bK zw6AX%j$mQ9soyP~x{MmbLEPNh*0{5~w_j)6>oKloi`&0;r`zifhGBFt^2V`v%oC?fhIUEu9=)$Ly-K_ORi0)F3%=#>$W@2SsY{iC^WA`)r3_Z@>t@ zfZz{SQDXPImBEz2SU4d`N>S1>vdsC@KWWOenULqLj~2X=?;ZT--uPhN>u_MsyakJv zEL-u-OY0L1^ieyE{%!jXc>U0u5OlvUxI9RWFA$2vRCs`&o}+45eV0BBQ(>h`4W$yE zh+cV35}T+*uQ3OC0+8Adt7|-hUi2jvZkgG9;m16;B7|itGZ`*HfgI0V&6JeL&VnHkj_5} zX@AWawX`e{h308w+TF&CD^U$dJXtxu8>Y_flHF62Mv(~IdPaL(8Lb~RU4l4*)pC;1 z!quK?jGNG6yU%YR$nTA~fgvP@!o3$~iLtMqd#Gie-y4j)8Mk2$QIA@y$Nx4-Qi{s*&k26gs^;WBUzR~A_cP04OsdZ0>JQ{&Sp>Svn79^1N z`RGD3=m;`a`+a{Vn1;1LPI}x8p9kl#$)gcSlwQ3v7_6=z2Jh-&TslQRwKwa0xH#_R zJ8K26?Ebn>I@%olecz^s|MiBa=f^9T7Nt?>GFC&3Bw; zR7~j{-Rmux-L7wAyLfMRl$O%)p3%k&4;L%xNomnE_5}f=U@-I|B(wmusw^F?i|mM5 zA~TT#Suk=U7sW0F5H-%Z452*Dh{mloZOEtrY~$S4LF*!?Wn8GnEjNM&qsZbEQaTYP zq!FtmByIbY$qXZ($M8jxnqLs?=O3rIMRI%*y(+RyWH#DDM(unwE-b{9>ndiMfS8a* ztg-+RCZrLoY(RtwX-wC?A|P3d41rjM0is|!^cbNDXkh6O(FZ*mqi8Bik^l?<25cMK zhP8#r3sX$Fu1p(Zs;k2}q{}Jhy5gqYfCv-P$OVYGu1p(Z%5`Ph5L2!z(}q}?4YlY% zXj_HUF0&?;`FY>eTlGggAR3nYl;0p7e1I1wXX@bv8v#=j=w_ME#6fiTXK} zQ`NlZOaf&93oh^hV7?dJ0sA9Mc3u zi4i9e>tEU^(gI1G!$U=nZ9do4lXE1BqJa=~$rr(T1O$R5sYSU^jP!xJuya^c`uO@7 z@Di)D0c!WB;n#>yg~28ojmRrk&3RflE&3x##`e~b(P8)?s7*tAATFnTDYb&%~{4I|0$#Je#> z{r2wGsZV2dcq0p549Du8M#t&bKbX}BWDqm*_NLoWahyEbkmO3aa|FWMHXsrjsfQ4P zfR6HV#z{boI0^4+VC>STL_l@N>TGG)xHd`2@!N*l4A1rsFSpb0`{bzCZe7Ux5Y_v~ z9*CL2o=KaorHg64A$1%QM`EKvE=AKCT6e;wRJ1j8gIhB~cw!TTa z%~Sm_?JM`0b%ogvQewRRe2`-^$h7Yp>cdYz*6Uv=@_Dv(6pXy8P~I`4y&sN+T-zz$ Zt~emFYo&}!yR5z6UO0X;|N9RXFaW>2e8>O* literal 0 HcmV?d00001 diff --git a/xess/xess.css b/xess/xess.css new file mode 100644 index 0000000..631c8c1 --- /dev/null +++ b/xess/xess.css @@ -0,0 +1,111 @@ +@font-face { + font-family: "Geist"; + font-style: normal; + font-weight: 100 900; + font-display: swap; + src: url("./static/geist.woff2") format("woff2"); +} + +@font-face { + font-family: "Podkova"; + font-style: normal; + font-weight: 400 800; + font-display: swap; + src: url("./static/podkova.woff2") format("woff2"); +} + +@font-face { + font-family: "Iosevka Curly"; + font-style: monospace; + font-display: swap; + src: url("./static/iosevka-curly.woff2") format("woff2"); +} + +main { + font-family: Geist, sans-serif; + max-width: 50rem; + padding: 2rem; + margin: auto; +} + +@media only screen and (max-device-width: 736px) { + main { + padding: 0; + } +} + +::selection { + background: #d3869b; +} + +body { + background: #1d2021; + color: #f9f5d7; +} + +pre { + background-color: #3c3836; + padding: 1em; + border: 0; + font-family: Iosevka Curly Iaso, monospace; +} + +a, +a:active, +a:visited { + color: #b16286; + background-color: #282828; +} + +h1, +h2, +h3, +h4, +h5 { + margin-bottom: 0.1rem; + font-family: Podkova, serif; +} + +blockquote { + border-left: 1px solid #bdae93; + margin: 0.5em 10px; + padding: 0.5em 10px; +} + +footer { + text-align: center; +} + +@media (prefers-color-scheme: light) { + body { + background: #f9f5d7; + color: #1d2021; + } + + pre { + background-color: #ebdbb2; + padding: 1em; + border: 0; + } + + a, + a:active, + a:visited { + color: #b16286; + background-color: #fbf1c7; + } + + h1, + h2, + h3, + h4, + h5 { + margin-bottom: 0.1rem; + } + + blockquote { + border-left: 1px solid #655c54; + margin: 0.5em 10px; + padding: 0.5em 10px; + } +} diff --git a/xess/xess.go b/xess/xess.go new file mode 100644 index 0000000..301767b --- /dev/null +++ b/xess/xess.go @@ -0,0 +1,38 @@ +// Package xess vendors a copy of Xess and makes it available at /.xess/xess.css +// +// This is intended to be used as a vendored package in other projects. +package xess + +import ( + "embed" + "net/http" + "path/filepath" + + "github.com/TecharoHQ/anubis" + "github.com/TecharoHQ/anubis/internal" +) + +//go:generate go run github.com/a-h/templ/cmd/templ@latest generate +//go:generate npm ci +//go:generate npm run build + +var ( + //go:embed xess.min.css xess.css static + Static embed.FS + + URL = "/.within.website/x/xess/xess.css" +) + +func init() { + Mount(http.DefaultServeMux) + + if anubis.Version != "devel" { + URL = filepath.Join(filepath.Dir(URL), "xess.min.css") + } + + URL = URL + "?cachebuster=" + anubis.Version +} + +func Mount(mux *http.ServeMux) { + mux.Handle("/.within.website/x/xess/", internal.UnchangingCache(http.StripPrefix("/.within.website/x/xess/", http.FileServerFS(Static)))) +} diff --git a/xess/xess.min.css b/xess/xess.min.css new file mode 100644 index 0000000..deee50c --- /dev/null +++ b/xess/xess.min.css @@ -0,0 +1 @@ +@font-face{font-display:swap;font-family:Geist;font-style:normal;font-weight:100 900;src:url("data:font/woff2;base64,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") format("woff2")}@font-face{font-display:swap;font-family:Podkova;font-style:normal;font-weight:400 800;src:url("data:font/woff2;base64,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") format("woff2")}@font-face{font-display:swap;font-family:Iosevka Curly;font-style:monospace;src:url("data:font/woff2;base64,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") format("woff2")}main{font-family:Geist,sans-serif;margin:auto;max-width:50rem;padding:2rem}@media only screen and (max-device-width:736px){main{padding:0}}::selection{background:#d3869b}body{background:#1d2021;color:#f9f5d7}pre{background-color:#3c3836;border:0;font-family:Iosevka Curly Iaso,monospace;padding:1em}a,a:active,a:visited{background-color:#282828;color:#b16286}h1,h2,h3,h4,h5{font-family:Podkova,serif;margin-bottom:.1rem}blockquote{border-left:1px solid #bdae93;margin:.5em 10px;padding:.5em 10px}footer{text-align:center}@media (prefers-color-scheme:light){body{background:#f9f5d7;color:#1d2021}pre{background-color:#ebdbb2;border:0;padding:1em}a,a:active,a:visited{background-color:#fbf1c7;color:#b16286}h1,h2,h3,h4,h5{margin-bottom:.1rem}blockquote{border-left:1px solid #655c54;margin:.5em 10px;padding:.5em 10px}} \ No newline at end of file diff --git a/xess/xess.templ b/xess/xess.templ new file mode 100644 index 0000000..4c010b7 --- /dev/null +++ b/xess/xess.templ @@ -0,0 +1,41 @@ +package xess + +templ Base(title string, headArea, navBar, bodyArea, footer templ.Component) { + + + + { title } + + + if headArea != nil { + @headArea + } + + +

+ if navBar != nil { + + } +

{ title }

+ @bodyArea + if footer != nil { +
+ @footer +
+ } +
+ + +} + +templ Simple(title string, body templ.Component) { + @Base( + title, + nil, + nil, + body, + nil, + ) +} diff --git a/xess/xess_templ.go b/xess/xess_templ.go new file mode 100644 index 0000000..a01a382 --- /dev/null +++ b/xess/xess_templ.go @@ -0,0 +1,164 @@ +// Code generated by templ - DO NOT EDIT. + +// templ: version: v0.3.833 +package xess + +//lint:file-ignore SA4006 This context is only used if a nested component is present. + +import "github.com/a-h/templ" +import templruntime "github.com/a-h/templ/runtime" + +func Base(title string, headArea, navBar, bodyArea, footer templ.Component) templ.Component { + return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) { + templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context + if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil { + return templ_7745c5c3_CtxErr + } + templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W) + if !templ_7745c5c3_IsBuffer { + defer func() { + templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer) + if templ_7745c5c3_Err == nil { + templ_7745c5c3_Err = templ_7745c5c3_BufErr + } + }() + } + ctx = templ.InitializeContext(ctx) + templ_7745c5c3_Var1 := templ.GetChildren(ctx) + if templ_7745c5c3_Var1 == nil { + templ_7745c5c3_Var1 = templ.NopComponent + } + ctx = templ.ClearChildren(ctx) + templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 1, "") + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + var templ_7745c5c3_Var2 string + templ_7745c5c3_Var2, templ_7745c5c3_Err = templ.JoinStringErrs(title) + if templ_7745c5c3_Err != nil { + return templ.Error{Err: templ_7745c5c3_Err, FileName: `xess.templ`, Line: 7, Col: 17} + } + _, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var2)) + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 2, "") + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + if headArea != nil { + templ_7745c5c3_Err = headArea.Render(ctx, templ_7745c5c3_Buffer) + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + } + templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 4, "
") + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + if navBar != nil { + templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 5, "") + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + } + templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 7, "

") + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + var templ_7745c5c3_Var4 string + templ_7745c5c3_Var4, templ_7745c5c3_Err = templ.JoinStringErrs(title) + if templ_7745c5c3_Err != nil { + return templ.Error{Err: templ_7745c5c3_Err, FileName: `xess.templ`, Line: 21, Col: 15} + } + _, templ_7745c5c3_Err = templ_7745c5c3_Buffer.WriteString(templ.EscapeString(templ_7745c5c3_Var4)) + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 8, "

") + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + templ_7745c5c3_Err = bodyArea.Render(ctx, templ_7745c5c3_Buffer) + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + if footer != nil { + templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 9, "") + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + } + templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 11, "
") + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + return nil + }) +} + +func Simple(title string, body templ.Component) templ.Component { + return templruntime.GeneratedTemplate(func(templ_7745c5c3_Input templruntime.GeneratedComponentInput) (templ_7745c5c3_Err error) { + templ_7745c5c3_W, ctx := templ_7745c5c3_Input.Writer, templ_7745c5c3_Input.Context + if templ_7745c5c3_CtxErr := ctx.Err(); templ_7745c5c3_CtxErr != nil { + return templ_7745c5c3_CtxErr + } + templ_7745c5c3_Buffer, templ_7745c5c3_IsBuffer := templruntime.GetBuffer(templ_7745c5c3_W) + if !templ_7745c5c3_IsBuffer { + defer func() { + templ_7745c5c3_BufErr := templruntime.ReleaseBuffer(templ_7745c5c3_Buffer) + if templ_7745c5c3_Err == nil { + templ_7745c5c3_Err = templ_7745c5c3_BufErr + } + }() + } + ctx = templ.InitializeContext(ctx) + templ_7745c5c3_Var5 := templ.GetChildren(ctx) + if templ_7745c5c3_Var5 == nil { + templ_7745c5c3_Var5 = templ.NopComponent + } + ctx = templ.ClearChildren(ctx) + templ_7745c5c3_Err = Base( + title, + nil, + nil, + body, + nil, + ).Render(ctx, templ_7745c5c3_Buffer) + if templ_7745c5c3_Err != nil { + return templ_7745c5c3_Err + } + return nil + }) +} + +var _ = templruntime.GeneratedTemplate diff --git a/yeetfile.js b/yeetfile.js new file mode 100644 index 0000000..730e7d1 --- /dev/null +++ b/yeetfile.js @@ -0,0 +1,22 @@ +go.install(); + +["amd64", "arm64"].forEach(goarch => rpm.build({ + name: "anubis", + description: "Anubis weighs the souls of incoming HTTP requests and uses a sha256 proof-of-work challenge in order to protect upstream resources from scraper bots.", + homepage: "https://xeiaso.net/blog/2025/anubis", + license: "MIT", + goarch, + + build: (out) => { + // install Anubis binary + go.build("-o", `${out}/usr/bin/anubis`); + + // install systemd unit + yeet.run("mkdir", "-p", `${out}/usr/lib/systemd/system`); + yeet.run("cp", "run/anubis@.service", `${out}/usr/lib/systemd/system/anubis@.service`); + + // install default config + yeet.run("mkdir", "-p", `${out}/etc/anubis`); + yeet.run("cp", "run/anubis.env.default", `${out}/etc/anubis/anubis-default.env`); + }, +})); \ No newline at end of file