diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 604a646e3c40..a463d2a5ae69 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -196,11 +196,11 @@ jobs: # Cargo honors that via `[lints]`, Bazel via the clippy-ported config. - name: Clippy (workspace lint policy on opted-in crates) run: | - bazelisk query "kind('rust_library|rust_shared_library', //crates/pi-ast/... + //crates/pi-iso/... + //crates/pi-natives/... + //crates/pi-shell/... + //crates/pi-voice/... + //crates/pi-walker/...)" \ + bazelisk query "kind('rust_library|rust_shared_library', //crates/pi-ast/... + //crates/pi-iso/... + //crates/pi-natives/... + //crates/pi-shell/... + //crates/pi-vcs/... + //crates/pi-voice/... + //crates/pi-walker/...)" \ | xargs bazelisk --bazelrc="${{ steps.cache.outputs.rc }}" build --config=clippy-strict -- - name: Clippy (default lints elsewhere) run: | - bazelisk query "kind('rust_library|rust_shared_library', //crates/... - (//crates/pi-ast/... + //crates/pi-iso/... + //crates/pi-natives/... + //crates/pi-shell/... + //crates/pi-voice/... + //crates/pi-walker/...) - //crates/pi-builtins/... - //crates/vendor/brush-core/...)" \ + bazelisk query "kind('rust_library|rust_shared_library', //crates/... - (//crates/pi-ast/... + //crates/pi-iso/... + //crates/pi-natives/... + //crates/pi-shell/... + //crates/pi-vcs/... + //crates/pi-voice/... + //crates/pi-walker/...) - //crates/pi-builtins/... - //crates/vendor/brush-core/...)" \ | xargs bazelisk --bazelrc="${{ steps.cache.outputs.rc }}" build --config=clippy -- - name: Clippy (manifest allows on ported pi-builtins) run: | @@ -343,10 +343,7 @@ jobs: OMP_TEST_CONCURRENCY: "4" run: | bun run ci:test:ts:workspace - # Not `test:scripts`: scripts/musl-release.test.ts fails on main - # (its install.sh smoke-check executes a fake binary), so running - # the whole group here would red this job on an unrelated break. - bun test scripts/ci-test-ts.test.ts scripts/release.test.ts + bun run test:scripts test_coding_agent_singleton: name: Test coding-agent singleton/global-state (TS) @@ -624,12 +621,14 @@ jobs: os: macos-15-intel, target_id: darwin-x64, binary_path: packages/coding-agent/binaries/omp-darwin-x64, + worker_path: "", native_targets: darwin-x64-baseline, } - { - os: macos-14, + os: macos-15, target_id: darwin-arm64, binary_path: packages/coding-agent/binaries/omp-darwin-arm64, + worker_path: packages/coding-agent/binaries/omp-stt-nemotron-darwin-arm64, native_targets: darwin-arm64, } runs-on: ${{ matrix.os }} @@ -672,7 +671,13 @@ jobs: APPLE_API_KEY_ID: ${{ secrets.APPLE_API_KEY_ID }} APPLE_API_ISSUER_ID: ${{ secrets.APPLE_API_ISSUER_ID }} APPLE_API_KEY: ${{ secrets.APPLE_API_KEY }} - run: bash scripts/ci-macos-sign.sh "${{ matrix.binary_path }}" + run: | + bash scripts/ci-macos-sign.sh "${{ matrix.binary_path }}" + # The stt-nemotron worker is a standalone stdin-protocol Mach-O. + # Immediate EOF exercises dyld and hardened-runtime launch safely. + if [ -n "${{ matrix.worker_path }}" ]; then + bash scripts/ci-macos-sign.sh --stdin-eof-launch-check "${{ matrix.worker_path }}" + fi - name: Smoke release binary run: | runtime_dir="$(mktemp -d)" @@ -693,6 +698,17 @@ jobs: with: name: omp-binary-${{ matrix.target_id }} path: ${{ matrix.binary_path }} + - name: Upload release STT worker artifact + # Separate artifact name (v4 upload-artifact cannot append to an + # existing artifact); the release_github download merges every + # omp-binary-* artifact into binaries/, where the omp-* globs pick + # the worker up for checksums and release publishing. + if: matrix.worker_path != '' + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1 + with: + name: omp-binary-${{ matrix.target_id }}-stt-worker + path: ${{ matrix.worker_path }} + if-no-files-found: error # Publishes the five @oh-my-pi/pi-natives- leaf packages once # validation passes and every binary built. Runs on one linux runner: leaf @@ -794,6 +810,8 @@ jobs: # Generated after every other release asset is in place and before # the release is created, so SHA256SUMS.txt itself ships as an asset # and covers every other file uploaded alongside it. + - name: Require macOS arm64 STT worker + run: test -f packages/coding-agent/binaries/omp-stt-nemotron-darwin-arm64 - name: Generate checksums run: | bun run ci:release:checksums SHA256SUMS.txt \ @@ -820,7 +838,7 @@ jobs: if: ${{ needs.release_metadata.outputs.is-release == 'true' && !cancelled() && needs.release_github.result == 'success' }} needs: [release_metadata, release_github] - runs-on: macos-14 + runs-on: macos-15 permissions: contents: read env: @@ -834,16 +852,30 @@ jobs: run: | codesign -dvvv ./omp-darwin-arm64 codesign --verify --strict --verbose=4 ./omp-darwin-arm64 + lipo -verify_arch arm64 ./omp-darwin-arm64 runtime_dir="$(mktemp -d)" HOME="$runtime_dir/home" XDG_DATA_HOME="$runtime_dir/xdg" ./omp-darwin-arm64 --version HOME="$runtime_dir/home" XDG_DATA_HOME="$runtime_dir/xdg" ./omp-darwin-arm64 --smoke-test + - name: Verify published stt-nemotron worker (macOS arm64) + # The worker must exist as its own downloadable, signature-valid + # asset — every darwin-arm64 consumer installs it beside omp. + run: | + curl -fsSL -o stt-nemotron "https://github.com/${{ github.repository }}/releases/download/${{ needs.release_metadata.outputs.release-tag }}/omp-stt-nemotron-darwin-arm64" + chmod +x stt-nemotron + file stt-nemotron | grep -q "Mach-O" + codesign --verify --strict --verbose=4 ./stt-nemotron + lipo -verify_arch arm64 ./stt-nemotron + ./stt-nemotron &1 | grep -qE "flags=.*adhoc|Signature=adhoc"; then - echo "published binary is still ad-hoc signed (Developer ID signing did not run)" >&2 - exit 1 - fi + for binary in ./omp-darwin-arm64 ./stt-nemotron; do + authority="$(codesign -dvvv "$binary" 2>&1 | sed -n '/^Authority=/{s/^Authority=//;p;q;}')" + if [ -z "$authority" ] || ! printf '%s\n' "$authority" | grep -q '^Developer ID Application:'; then + echo "$binary is not signed with a Developer ID Application identity" >&2 + exit 1 + fi + done # Gatekeeper assessment: a notarized Developer ID binary is accepted. # Informational — a bare (unstapled) Mach-O relies on the online ticket # lookup, so surface the result without gating the release on it. diff --git a/.omp/tools/bun.lock b/.omp/tools/bun.lock new file mode 100644 index 000000000000..2dc1d53a3640 --- /dev/null +++ b/.omp/tools/bun.lock @@ -0,0 +1,40 @@ +{ + "lockfileVersion": 2, + "configVersion": 1, + "workspaces": { + "": { + "name": "omp-project-tools", + "dependencies": { + "@napi-rs/canvas": "^1.0.8", + "kitty-vt-wasm": "^0.2.0", + }, + }, + }, + "packages": { + "@napi-rs/canvas": ["@napi-rs/canvas@1.0.8", "", { "optionalDependencies": { "@napi-rs/canvas-android-arm64": "1.0.8", "@napi-rs/canvas-darwin-arm64": "1.0.8", "@napi-rs/canvas-darwin-x64": "1.0.8", "@napi-rs/canvas-linux-arm-gnueabihf": "1.0.8", "@napi-rs/canvas-linux-arm64-gnu": "1.0.8", "@napi-rs/canvas-linux-arm64-musl": "1.0.8", "@napi-rs/canvas-linux-riscv64-gnu": "1.0.8", "@napi-rs/canvas-linux-x64-gnu": "1.0.8", "@napi-rs/canvas-linux-x64-musl": "1.0.8", "@napi-rs/canvas-win32-arm64-msvc": "1.0.8", "@napi-rs/canvas-win32-x64-msvc": "1.0.8" } }, "sha512-/SaLcvlqGWdm0HSCWMgHu7cjJiQXfP8/mOY+6dUyV9flQz7sPBBZ+ed2zYtoukojPmxOaL7bm+d/G4GeWWoN7g=="], + + "@napi-rs/canvas-android-arm64": ["@napi-rs/canvas-android-arm64@1.0.8", "", { "os": "android", "cpu": "arm64" }, "sha512-5+nkh8i3gt6lqS/d2jTZ1xAn6tdgtB4Lf1mW6T0Qm5/rXNwBuV1sAEyLEWan5o9gJPU/GuvHR3rvSeZ+FaGrbw=="], + + "@napi-rs/canvas-darwin-arm64": ["@napi-rs/canvas-darwin-arm64@1.0.8", "", { "os": "darwin", "cpu": "arm64" }, "sha512-7jQ47gi+fZ7KJmfc/5rNyy1CYw/cu4kZ0KPIYbo9UUgSdW0bKQJpt+WihEor6s4Lyp7+xc3a+3HeyXmAEbbnPg=="], + + "@napi-rs/canvas-darwin-x64": ["@napi-rs/canvas-darwin-x64@1.0.8", "", { "os": "darwin", "cpu": "x64" }, "sha512-rRjDMZs9pIRKGxgijwezplKc1RnJsqUokrA9h88bbTkqQ+7ePj0ZN4ZnZDy8Vu0tXs7KRlI2tQLaK4mx9QlxHg=="], + + "@napi-rs/canvas-linux-arm-gnueabihf": ["@napi-rs/canvas-linux-arm-gnueabihf@1.0.8", "", { "os": "linux", "cpu": "arm" }, "sha512-jGcCd+8ra6Q61xKqZeiItujTpp9a9eRLcQ0jW6qYNku+WpupqOPFPY0SrsuSnXFviJwkpKYT9p7QrB4lsf3LNQ=="], + + "@napi-rs/canvas-linux-arm64-gnu": ["@napi-rs/canvas-linux-arm64-gnu@1.0.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-od6I2Y7kU7i1SwZYG2EKW8rWz6JiedtPpko4WEe1DDsiikrfaotVBCRaUTM5/yeZKaZ92EatoAS+5xG+6uJlYA=="], + + "@napi-rs/canvas-linux-arm64-musl": ["@napi-rs/canvas-linux-arm64-musl@1.0.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-yYkPbJDJiWj6N0gASA3CAvRypZmVpJnxU0DQg3aBhneLDQde9TPLKADsQkobNoJUtTT/lj46aWpzT48PDb3Qcg=="], + + "@napi-rs/canvas-linux-riscv64-gnu": ["@napi-rs/canvas-linux-riscv64-gnu@1.0.8", "", { "os": "linux", "cpu": "none" }, "sha512-PB00MSKAp4VwK/xwe6duKxRKmH8UH4GIl1pqHSbxng0jnU9Dr7FwaDypDiqwNFZ774N+8G7mJLGuLtg9NTcQsg=="], + + "@napi-rs/canvas-linux-x64-gnu": ["@napi-rs/canvas-linux-x64-gnu@1.0.8", "", { "os": "linux", "cpu": "x64" }, "sha512-TWM2XWJoitLiIPCvgJh7SriC+L/T9qkYCVzC66AidsZy0QP1hkKzBzVwshCdcA3q6fIn3yE0ISbq4lMJSy8jFw=="], + + "@napi-rs/canvas-linux-x64-musl": ["@napi-rs/canvas-linux-x64-musl@1.0.8", "", { "os": "linux", "cpu": "x64" }, "sha512-hb20MxKXXb5IB7AAwN8UHz9WRsa2HmdZfjsDCzjElwJoeV1aotVEwFU4FrFQcYQVzsJQLeaCc/2Qdt/0Q72mMg=="], + + "@napi-rs/canvas-win32-arm64-msvc": ["@napi-rs/canvas-win32-arm64-msvc@1.0.8", "", { "os": "win32", "cpu": "arm64" }, "sha512-WwPN08IXE4SkL+FhJyPz/iFnycMAUkbphFIT4cmKLlvbSU0Zfn1R7BGJ3Hqky1S89QUYc0Q4IOScXb/42Re9wQ=="], + + "@napi-rs/canvas-win32-x64-msvc": ["@napi-rs/canvas-win32-x64-msvc@1.0.8", "", { "os": "win32", "cpu": "x64" }, "sha512-XkrVqKb+pxyba7kjy2LJvABFVBTE0DNpEl7MrG4OYUmaWarrXH+t54z/Czj2YxCKtizYTV4mg6phNm3x24qjhQ=="], + + "kitty-vt-wasm": ["kitty-vt-wasm@0.2.0", "", {}, "sha512-RJNzy9r5ql8CKkocjkg0FKC1MZoWM0R8leb2VB5hsgrP/4HHlumeODHriOw4Jk2dDsCOmPxWuwFQyqDiy0m8Kw=="], + } +} diff --git a/.omp/tools/package.json b/.omp/tools/package.json new file mode 100644 index 000000000000..49e9237acacd --- /dev/null +++ b/.omp/tools/package.json @@ -0,0 +1,8 @@ +{ + "name": "omp-project-tools", + "private": true, + "dependencies": { + "@napi-rs/canvas": "^1.0.8", + "kitty-vt-wasm": "^0.2.0" + } +} diff --git a/.omp/tools/tui.ts b/.omp/tools/tui.ts new file mode 100644 index 000000000000..40c8b90558c9 --- /dev/null +++ b/.omp/tools/tui.ts @@ -0,0 +1,1369 @@ +/** + * Project-local `tui` tool: run and debug pi-tui apps headlessly. Each session + * spawns a TypeScript/JavaScript entry or executable on a Bun-native PTY — a + * real controlling terminal, so capability probes, SIGWINCH resizes, and + * immediate-mode hosts all behave as in production — with `OMP_TUI_DEBUG` + * pointed at the unix socket served by an omp/pi-tui host. Injected input + * rides the app's own input path, while renderer and component queries inspect + * the last painted frame. + * + * kitty's real terminal core (screen.c + vt-parser.c via kitty-vt-wasm) + * tracks every PTY byte, so `screen` (and the socketless `text` fallback) + * render any app's display exactly as kitty would — SGR, rewrap-on-resize, + * scrollback, graphemes/wide chars — and input ops echo an after-screenshot. + * Query replies the core generates (DA, DECRQSS, XTGETTCAP, OSC color queries) + * are written back to the child, so capability probes resolve as on a real + * terminal instead of timing out. + * + * Sessions live in this module for the lifetime of the agent session; the + * child and its terminal are torn down on `stop` or shutdown. + */ + +import { mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import * as net from "node:net"; +import { inflateSync } from "node:zlib"; +import type * as CanvasModule from "@napi-rs/canvas"; +import type * as KittyVt from "kitty-vt-wasm"; +import type { Color, KittyEvent, KittyTerminal } from "kitty-vt-wasm"; +import { tmpdir } from "node:os"; +import { join, resolve } from "node:path"; + +/** Minimal slice of the host schema builder (`omp.zod`) this tool uses. */ +interface Schema { + describe(text: string): Schema; + optional(): Schema; +} +interface SchemaBuilder { + object(shape: Record): Schema; + string(): Schema; + boolean(): Schema; + number(): Schema; + array(item: Schema): Schema; +} +/** Minimal slice of `CustomToolAPI` this tool uses. */ +interface ToolHost { + cwd: string; + zod: SchemaBuilder; +} +interface ToolUpdate { + content: { type: "text"; text: string }[]; + details?: Record; +} +interface ToolResult { + content: ( + | { type: "text"; text: string } + | { type: "image"; data: string; mimeType: string } + )[]; + details?: Record; +} + +/** Parameter object accepted by the tool's `execute`. */ +export interface TuiParams { + op: + | "start" + | "stop" + | "list" + | "text" + | "screen" + | "frame" + | "tree" + | "values" + | "info" + | "keys" + | "type" + | "paste" + | "mouse" + | "send" + | "resize" + | "raw" + | "shot"; + name?: string; + file?: string; + bin?: string; + args?: string[]; + rows?: number; + cols?: number; + keys?: string; + text?: string; + x?: number; + y?: number; + action?: string; + peek?: number; + clear?: boolean; + quiet?: boolean; + timeout?: number; +} + +// ─── VT screen emulator ────────────────────────────────────────────────────── + +/** Lazily loaded kitty-vt-wasm module: a missing install degrades `start`, not module load. */ +let vtApi: Promise | null = null; + +function loadVt() { + // Lazy import: a missing optional install must degrade `start`, not fail tool load. + vtApi ??= import("kitty-vt-wasm").catch((error) => { + vtApi = null; + throw new Error( + `screen emulation needs kitty-vt-wasm — run \`bun install\` in .omp/tools (${error})`, + ); + }); + return vtApi; +} +/** Decoded kitty-graphics command (the lib exports it only inside the event union). */ +type GraphicsCommand = Extract; + +/** + * kitty's row/column diacritics (gen/rowcolumn-diacritics.txt): the Nth + * combining mark on a U+10EEEE image-placeholder cell encodes tile row/col N. + */ +const ROWCOL_DIACRITICS = + "0305,030D,030E,0310,0312,033D,033E,033F,0346,034A,034B,034C,0350,0351,0352,0357,035B,0363," + + "0364,0365,0366,0367,0368,0369,036A,036B,036C,036D,036E,036F,0483,0484,0485,0486,0487,0592," + + "0593,0594,0595,0597,0598,0599,059C,059D,059E,059F,05A0,05A1,05A8,05A9,05AB,05AC,05AF,05C4," + + "0610,0611,0612,0613,0614,0615,0616,0617,0657,0658,0659,065A,065B,065D,065E,06D6,06D7,06D8," + + "06D9,06DA,06DB,06DC,06DF,06E0,06E1,06E2,06E4,06E7,06E8,06EB,06EC,0730,0732,0733,0735,0736," + + "073A,073D,073F,0740,0741,0743,0745,0747,0749,074A,07EB,07EC,07ED,07EE,07EF,07F0,07F1,07F3," + + "0816,0817,0818,0819,081B,081C,081D,081E,081F,0820,0821,0822,0823,0825,0826,0827,0829,082A," + + "082B,082C,082D,0951,0953,0954,0F82,0F83,0F86,0F87,135D,135E,135F,17DD,193A,1A17,1A75,1A76," + + "1A77,1A78,1A79,1A7A,1A7B,1A7C,1B6B,1B6D,1B6E,1B6F,1B70,1B71,1B72,1B73,1CD0,1CD1,1CD2,1CDA," + + "1CDB,1CE0,1DC0,1DC1,1DC3,1DC4,1DC5,1DC6,1DC7,1DC8,1DC9,1DCB,1DCC,1DD1,1DD2,1DD3,1DD4,1DD5," + + "1DD6,1DD7,1DD8,1DD9,1DDA,1DDB,1DDC,1DDD,1DDE,1DDF,1DE0,1DE1,1DE2,1DE3,1DE4,1DE5,1DE6,1DFE," + + "20D0,20D1,20D4,20D5,20D6,20D7,20DB,20DC,20E1,20E7,20E9,20F0,2CEF,2CF0,2CF1,2DE0,2DE1,2DE2," + + "2DE3,2DE4,2DE5,2DE6,2DE7,2DE8,2DE9,2DEA,2DEB,2DEC,2DED,2DEE,2DEF,2DF0,2DF1,2DF2,2DF3,2DF4," + + "2DF5,2DF6,2DF7,2DF8,2DF9,2DFA,2DFB,2DFC,2DFD,2DFE,2DFF,A66F,A67C,A67D,A6F0,A6F1,A8E0,A8E1," + + "A8E2,A8E3,A8E4,A8E5,A8E6,A8E7,A8E8,A8E9,A8EA,A8EB,A8EC,A8ED,A8EE,A8EF,A8F0,A8F1,AAB0,AAB2," + + "AAB3,AAB7,AAB8,AABE,AABF,AAC1,FE20,FE21,FE22,FE23,FE24,FE25,FE26,10A0F,10A38,1D185,1D186," + + "1D187,1D188,1D189,1D1AA,1D1AB,1D1AC,1D1AD,1D242,1D243,1D244"; + +/** Combining-mark codepoint → row/column index for image placeholders. */ +const rowcolIndex = new Map(); +ROWCOL_DIACRITICS.split(",").forEach((hex, index) => { + rowcolIndex.set(Number.parseInt(hex, 16), index); +}); + +/** kitty image-placeholder cell (U+10EEEE + diacritics), scrubbed in text snapshots. */ +const PLACEHOLDER_RE = /\u{10EEEE}\p{M}*/gu; + +/** One completed kitty-graphics transmission (pixels for `shot`). */ +interface StoredImage { + bytes: Uint8Array; + /** kitty `f=`: 100 png, 32 rgba, 24 rgb. */ + format: number; + width: number; + height: number; +} + +// ─── PNG rasterizer ────────────────────────────────────────────────────────── +// +// `shot` rasterizes the emulator grid with @napi-rs/canvas (prebuilt Skia): +// real system fonts with an explicit fallback stack (Menlo → nerd font → +// braille → CJK → emoji), so icons, spinners, and wide text render as a +// terminal would. Powerline separators (U+E0B0–E0B3) are drawn as vector +// paths because font metrics leave gaps at cell edges. Imported lazily so a +// missing install degrades only `shot`, not the tool. + +/** Cell pixel geometry. */ +const CW = 16; +const CH = 32; +/** Font size whose Menlo advance (~0.602 em) fits the 16px cell. */ +const FONT_PX = 26; +/** Baseline offset inside a cell (Menlo 26px ascent ≈ 24.2px). */ +const BASELINE = 24; +const DEF_FG = 0xd4d4d4; +const DEF_BG = 0x101418; + +/** Lazily loaded canvas module + resolved font-family stack. */ +let canvasApi: { + create: typeof CanvasModule.createCanvas; + load: typeof CanvasModule.loadImage; + stack: string; +} | null = null; + +/** + * Loads @napi-rs/canvas and builds the fallback font stack from the fonts + * actually installed: Menlo, first nerd font, braille, CJK, emoji. + */ +async function loadCanvas() { + if (canvasApi) return canvasApi; + let mod: typeof CanvasModule; + try { + // Lazy import: a missing optional install must degrade `shot`, not fail tool load. + mod = await import("@napi-rs/canvas"); + } catch (error) { + throw new Error( + `shot needs @napi-rs/canvas — run \`bun install\` in .omp/tools (${error})`, + ); + } + const families = mod.GlobalFonts.families.map((entry) => entry.family); + const stack = ["Menlo"]; + const nerd = + families.find((family) => /nerd font mono/i.test(family)) ?? + families.find((family) => /nerd font/i.test(family)); + if (nerd) stack.push(nerd); + for (const wanted of [ + "Apple Braille", + "PingFang SC", + "Hiragino Sans", + "Noto Sans CJK SC", + "Apple Color Emoji", + "Noto Color Emoji", + ]) { + if (families.includes(wanted)) stack.push(wanted); + } + canvasApi = { + create: mod.createCanvas, + load: mod.loadImage, + stack: stack.map((family) => `"${family}"`).join(", "), + }; + return canvasApi; +} + +/** 0xRRGGBB → CSS hex color. */ +function css(rgb: number): string { + return `#${rgb.toString(16).padStart(6, "0")}`; +} + +/** Per-channel linear blend of two 0xRRGGBB colors. */ +function lerpColor(from: number, to: number, t: number): number { + const channel = (shift: number) => { + const a = (from >> shift) & 0xff; + const b = (to >> shift) & 0xff; + return Math.round(a + (b - a) * t) << shift; + }; + return channel(16) | channel(8) | channel(0); +} + +/** + * Terminal emulation fed every PTY byte: kitty's real core (screen.c + + * vt-parser.c compiled to wasm via kitty-vt-wasm), so SGR, rewrap-on-resize, + * scrollback, graphemes, and wide chars behave exactly as in kitty. Any + * session — omp-tui host or not — can be read as plain text (`snapshot`) or + * rasterized to pixels (`png`). Backs the `screen`/`shot` ops, the socketless + * `text` fallback, and the after-screenshot on input ops. Query replies the + * core emits (DA, DECRQSS, XTGETTCAP, OSC color queries) surface on + * `onReply` for the session to write back to the child. + */ +export class Screen { + /** Sink for terminal→child bytes (query replies); wired to the session PTY. */ + onReply: ((bytes: Uint8Array) => void) | null = null; + #term: KittyTerminal; + /** Completed image transmissions by image id (insertion order backs eviction). */ + #images = new Map(); + /** In-flight chunked transmission; continuation commands carry no id. */ + #pending: { + id: number; + format: number; + compressed: number; + width: number; + height: number; + chunks: Buffer[]; + } | null = null; + + constructor(term: KittyTerminal) { + this.#term = term; + } + + /** Loads the wasm module (cached process-wide) and allocates a terminal. */ + static async create(cols: number, rows: number): Promise { + const vt = await loadVt(); + const term = await vt.KittyTerminal.create({ + columns: cols, + rows, + scrollback: 2000, + }); + const screen = new Screen(term); + term.onOutput = (bytes) => screen.onReply?.(bytes); + // Image transmissions are kept for `shot`; the handler also keeps + // core logs and other host events off the host's stderr. + term.onEvent = (event) => { + if (event.type === "graphics_command") screen.#graphics(event); + }; + return screen; + } + /** + * Accumulates kitty-graphics transmissions. Chunked payloads (`m=1`) + * arrive as separate commands whose continuations carry no id; pixels are + * stored per image for the `shot` rasterizer. + */ + #graphics(cmd: GraphicsCommand) { + if (!this.#pending) { + // Only transmissions carry pixels; queries/puts/deletes do not. + if (cmd.action !== "t" && cmd.action !== "T") return; + this.#pending = { + id: cmd.id || cmd.image_number, + format: cmd.format, + compressed: cmd.compressed, + width: cmd.data_width, + height: cmd.data_height, + chunks: [], + }; + } + const pending = this.#pending; + if (cmd.payload) pending.chunks.push(Buffer.from(cmd.payload, "base64")); + if (cmd.more) return; + this.#pending = null; + let bytes: Buffer = + pending.chunks.length === 1 + ? pending.chunks[0] + : Buffer.concat(pending.chunks); + if (pending.compressed) { + try { + bytes = inflateSync(bytes); + } catch { + return; + } + } + this.#images.set(pending.id, { + bytes, + format: pending.format, + width: pending.width, + height: pending.height, + }); + // Bound retained pixels: drop the oldest transmissions past 128. + if (this.#images.size > 128) { + const oldest = this.#images.keys().next().value; + if (oldest !== undefined) this.#images.delete(oldest); + } + } + + feed(chunk: Uint8Array) { + this.#term.write(chunk); + } + + /** Resize with kitty's real semantics: content rewraps and refills from scrollback. */ + resize(cols: number, rows: number) { + this.#term.resize(cols, rows); + } + + /** Frees the native terminal. */ + dispose() { + this.#term.dispose(); + } + + /** Resolves a decoded color against the palette; null = terminal default. */ + #rgb(color: Color, fallback: number): number { + if (!color) return fallback; + return "rgb" in color ? color.rgb : this.#term.paletteColor(color.index); + } + + /** Decodes a stored transmission to a drawable: PNG via Skia, raw RGB(A) via ImageData. */ + async #decodeImage( + create: typeof CanvasModule.createCanvas, + load: typeof CanvasModule.loadImage, + image: StoredImage, + ): Promise { + if (image.format === 100) { + try { + return await load(Buffer.from(image.bytes)); + } catch { + return null; + } + } + const channels = image.format === 24 ? 3 : 4; + const { width, height } = image; + if (!width || !height || image.bytes.length < width * height * channels) + return null; + const off = create(width, height); + const ctx = off.getContext("2d"); + const data = ctx.createImageData(width, height); + for (let i = 0, j = 0; i < width * height; i++, j += channels) { + data.data[i * 4] = image.bytes[j]; + data.data[i * 4 + 1] = image.bytes[j + 1]; + data.data[i * 4 + 2] = image.bytes[j + 2]; + data.data[i * 4 + 3] = channels === 4 ? image.bytes[j + 3] : 255; + } + ctx.putImageData(data, 0, 0); + return off; + } + + /** Plain-text screen: header, optional scrollback tail, then the viewport. */ + snapshot(history = 0): string { + const term = this.#term; + const cursor = term.cursor; + const out = [ + `── screen ${term.columns}x${term.rows}` + + `${term.isMainScreen ? "" : ", alt screen"}` + + `, cursor=[${cursor.x},${cursor.y}]${cursor.visible ? "" : " hidden"}` + + `, scrollback=${term.scrollbackLength} ──`, + ]; + if (history > 0) { + const total = term.scrollbackLength; + for (let i = Math.max(0, total - history); i < total; i++) { + out.push( + `┆${(term.scrollbackLine(i) ?? "").replace(PLACEHOLDER_RE, "▒")}`, + ); + } + } + for (let y = 0; y < term.rows; y++) + out.push(`│${term.line(y).replace(PLACEHOLDER_RE, "▒")}`); + return out.join("\n"); + } + + /** Rasterizes the viewport to a PNG via Skia with real system fonts. */ + async png(): Promise { + const { create, load, stack } = await loadCanvas(); + const term = this.#term; + const cols = term.columns; + const rows = term.rows; + const defFg = this.#rgb(term.defaultFg, DEF_FG); + const defBg = this.#rgb(term.defaultBg, DEF_BG); + const width = cols * CW; + const height = rows * CH; + const canvas = create(width, height); + const ctx = canvas.getContext("2d"); + ctx.fillStyle = css(defBg); + ctx.fillRect(0, 0, width, height); + // Resolve each cell's paint once; draw backgrounds before any text so + // glyph overhang (italics, wide fallback) never sits under a + // neighbor's background. + const cells: { + px: number; + py: number; + ch: string; + fg: number; + deco: number; + bold: boolean; + italic: boolean; + underline: number; + strike: boolean; + span: number; + }[] = []; + // kitty unicode image placeholders collected off the grid (drawn as tiles). + const holders: { + px: number; + py: number; + id: number; + row: number; + col: number; + }[] = []; + for (let y = 0; y < rows; y++) { + for (let x = 0; x < cols; x++) { + const cell = term.cell(x, y); + // Wide-char continuations are drawn by their lead cell. + if (!cell || cell.wideTrail) continue; + let fg = this.#rgb(cell.fg, defFg); + let bg = cell.bg ? this.#rgb(cell.bg, defBg) : null; + if (cell.reverse) { + const swap = fg; + fg = bg ?? defBg; + bg = swap; + } + if (cell.dim) fg = lerpColor(fg, bg ?? defBg, 0.45); + const span = cell.wide ? 2 : 1; + const px = x * CW; + const py = y * CH; + if (bg !== null) { + ctx.fillStyle = css(bg); + ctx.fillRect(px, py, span * CW, CH); + } + if (cell.ch.codePointAt(0) === 0x10eeee) { + // Image placeholder: fg encodes the image id, combining + // diacritics the tile row/col; omitted diacritics continue + // the previous cell's run (kitty spec). + const id = cell.fg + ? "rgb" in cell.fg + ? cell.fg.rgb + : cell.fg.index + : 0; + const row = rowcolIndex.get(cell.combining[0]?.codePointAt(0) ?? -1); + const col = rowcolIndex.get(cell.combining[1]?.codePointAt(0) ?? -1); + const prev = holders.at(-1); + const run = prev && prev.id === id && prev.py === py; + holders.push({ + px, + py, + id, + row: row ?? (run ? prev.row : 0), + col: col ?? (run ? prev.col + 1 : 0), + }); + continue; + } + cells.push({ + px, + py, + ch: cell.ch ? cell.ch + cell.combining.join("") : " ", + fg, + deco: cell.decorationFg ? this.#rgb(cell.decorationFg, fg) : fg, + bold: cell.bold, + italic: cell.italic, + underline: cell.underline, + strike: cell.strikethrough, + span, + }); + } + } + // Decode every image referenced by a placement or placeholder cell. + const placements = term.graphicsPlacements(); + const drawable = new Map< + number, + CanvasModule.Image | CanvasModule.Canvas + >(); + const wanted = new Set(holders.map((holder) => holder.id)); + for (const placement of placements) { + if (!placement.unicodePlacement) wanted.add(placement.imageId); + } + for (const id of wanted) { + const stored = this.#images.get(id); + if (!stored) continue; + const image = await this.#decodeImage(create, load, stored); + if (image) drawable.set(id, image); + } + const direct = placements + .filter((placement) => !placement.unicodePlacement) + .sort((a, b) => a.zIndex - b.zIndex); + const drawDirect = (placement: (typeof direct)[number]) => { + const image = drawable.get(placement.imageId); + if (!image) return; + // Natural-size placements (numCols/numRows 0): the wasm core + // assumes 10x20px cells when sizing them. + const spanCols = placement.numCols || Math.ceil(image.width / 10); + const spanRows = placement.numRows || Math.ceil(image.height / 20); + ctx.drawImage( + image, + placement.col * CW, + placement.row * CH, + spanCols * CW, + spanRows * CH, + ); + }; + // kitty z-order: negative z-index draws under text, the rest above. + for (const placement of direct) + if (placement.zIndex < 0) drawDirect(placement); + for (const { + px, + py, + ch, + fg, + deco, + bold, + italic, + underline, + strike, + span, + } of cells) { + if (underline) { + // Coarse style fidelity: double gets two bars; straight, + // curly, dotted, and dashed all render as one. + ctx.fillStyle = css(deco); + if (underline === 2) { + ctx.fillRect(px, py + 27, span * CW, 1); + ctx.fillRect(px, py + 30, span * CW, 1); + } else { + ctx.fillRect(px, py + 28, span * CW, 2); + } + } + ctx.fillStyle = css(fg); + if (strike) ctx.fillRect(px, py + 15, span * CW, 2); + if (ch === " ") continue; + const cp = ch.codePointAt(0) ?? 0; + if (cp >= 0xe0b0 && cp <= 0xe0b3) { + // Powerline separators as vector paths: font metrics leave + // gaps at cell edges, which reads as broken bands. + ctx.beginPath(); + if (cp <= 0xe0b1) { + ctx.moveTo(px, py); + ctx.lineTo(px + CW, py + CH / 2); + ctx.lineTo(px, py + CH); + } else { + ctx.moveTo(px + CW, py); + ctx.lineTo(px, py + CH / 2); + ctx.lineTo(px + CW, py + CH); + } + if (cp === 0xe0b0 || cp === 0xe0b2) { + ctx.closePath(); + ctx.fill(); + } else { + ctx.lineWidth = 2; + ctx.strokeStyle = css(fg); + ctx.stroke(); + } + continue; + } + ctx.font = + `${italic ? "italic " : ""}${bold ? "bold " : ""}` + + `${FONT_PX}px ${stack}`; + ctx.fillText(ch, px, py + BASELINE); + } + for (const placement of direct) + if (placement.zIndex >= 0) drawDirect(placement); + // Placeholder tiles: scale each image to its virtual grid (or the max + // extent seen) and draw the cell's slice. + const grids = new Map(); + for (const placement of placements) { + if ( + placement.unicodePlacement && + placement.numCols && + placement.numRows + ) { + grids.set(placement.imageId, { + cols: placement.numCols, + rows: placement.numRows, + }); + } + } + for (const holder of holders) { + const grid = grids.get(holder.id) ?? { cols: 0, rows: 0 }; + grid.cols = Math.max(grid.cols, holder.col + 1); + grid.rows = Math.max(grid.rows, holder.row + 1); + grids.set(holder.id, grid); + } + for (const holder of holders) { + const image = drawable.get(holder.id); + const grid = grids.get(holder.id); + if (!image || !grid) continue; + const sw = image.width / grid.cols; + const sh = image.height / grid.rows; + ctx.drawImage( + image, + holder.col * sw, + holder.row * sh, + sw, + sh, + holder.px, + holder.py, + CW, + CH, + ); + } + const cursor = term.cursor; + if (cursor.visible) { + ctx.globalAlpha = 0.4; + ctx.fillStyle = "#ffffff"; + ctx.fillRect(cursor.x * CW, cursor.y * CH, CW, CH); + ctx.globalAlpha = 1; + } + return canvas.toBuffer("image/png"); + } +} + +// ─── Sessions ──────────────────────────────────────────────────────────────── + +interface Waiter { + resolve(value: Record): void; + reject(error: Error): void; + timer: NodeJS.Timeout; +} + +/** The slice of `Bun.spawn`'s PTY handle this tool touches. */ +interface TerminalHandle { + write(data: string | Uint8Array): void; + resize(cols: number, rows: number): void; + close(): void; +} + +/** The slice of Bun's PTY-backed subprocess this tool touches. */ +interface Child { + pid: number; + exited: Promise; + terminal: TerminalHandle; + kill(signal?: number | NodeJS.Signals): void; +} + +interface Session { + name: string; + target: string; + proc: Child; + cols: number; + rows: number; + dir: string; + screen: Screen; + sock: net.Socket | null; + sockBuf: string; + waiters: Waiter[]; + raw: Buffer[]; + rawBytes: number; + exit: number | null; +} + +const sessions = new Map(); + +/** Appends one PTY chunk to the session's capped raw capture. */ +function capture(session: Session, chunk: Uint8Array) { + session.screen.feed(chunk); + const bytes = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength); + session.raw.push(bytes); + session.rawBytes += bytes.length; + // Cap the capture at 8 MiB, dropping the oldest chunks. + while (session.rawBytes > 8 * 1024 * 1024 && session.raw.length > 1) { + session.rawBytes -= session.raw[0].length; + session.raw.shift(); + } +} + +function connectSocket( + session: Session, + path: string, + timeoutMs: number, +): Promise { + const deadline = Date.now() + timeoutMs; + const { promise, resolve } = Promise.withResolvers(); + const attempt = () => { + const sock = net.createConnection(path); + sock.on("connect", () => { + sock.setEncoding("utf8"); + sock.on("data", (data: string) => { + session.sockBuf += data; + for (;;) { + const index = session.sockBuf.indexOf("\n"); + if (index < 0) return; + const line = session.sockBuf.slice(0, index); + session.sockBuf = session.sockBuf.slice(index + 1); + const waiter = session.waiters.shift(); + if (!waiter) continue; + clearTimeout(waiter.timer); + try { + waiter.resolve(JSON.parse(line)); + } catch (error) { + waiter.reject(new Error(`bad response line: ${error}`)); + } + } + }); + sock.on("close", () => { + if (session.sock === sock) session.sock = null; + }); + sock.on("error", () => {}); + session.sock = sock; + resolve(true); + }); + sock.on("error", () => { + sock.destroy(); + if (Date.now() >= deadline || session.exit !== null) resolve(false); + else setTimeout(attempt, 150); + }); + }; + attempt(); + return promise; +} + +/** Sends one debug request and awaits its response line. */ +function request( + session: Session, + body: Record, + timeoutMs = 10_000, +): Promise> { + const sock = session.sock; + if (!sock) { + return Promise.reject( + new Error( + `session "${session.name}" has no debug socket — the app is not an ` + + "omp-tui host (or exited). screen/raw/send/resize/stop still work.", + ), + ); + } + const { promise, resolve, reject } = + Promise.withResolvers>(); + const timer = setTimeout(() => { + const index = session.waiters.findIndex((waiter) => waiter.timer === timer); + if (index >= 0) session.waiters.splice(index, 1); + reject(new Error(`debug request timed out: ${JSON.stringify(body)}`)); + }, timeoutMs); + session.waiters.push({ resolve, reject, timer }); + sock.write(`${JSON.stringify(body)}\n`); + return promise; +} + +function need(session: string | undefined): Session { + const name = session ?? "main"; + const found = sessions.get(name); + if (!found) { + const names = [...sessions.keys()].join(", ") || "none"; + throw new Error(`no session "${name}" (running: ${names})`); + } + return found; +} + +function sleep(ms: number): Promise { + const { promise, resolve } = Promise.withResolvers(); + setTimeout(() => resolve(null), ms); + return promise; +} + +async function stopSession(session: Session): Promise { + try { + if (session.sock) { + await request(session, { op: "quit" }, 2_000); + } else if (session.exit === null) { + // Non-omp-tui apps have no debug socket; Ctrl-C is the + // conventional quit chord. + session.proc.terminal.write("\x03"); + } + } catch { + // Fall through to signals. + } + const exited = await Promise.race([session.proc.exited, sleep(2_000)]); + if (exited === null) { + session.proc.kill("SIGKILL"); + await session.proc.exited.catch(() => {}); + } + session.sock?.destroy(); + session.proc.terminal.close(); + session.screen.dispose(); + rmSync(session.dir, { recursive: true, force: true }); + sessions.delete(session.name); + return exited ?? -9; +} + +// ─── Response narrowing ────────────────────────────────────────────────────── + +/** The string rows of a `lines` response field; anything else is empty. */ +function stringLines(value: unknown): string[] { + if (!Array.isArray(value)) return []; + return value.filter((line): line is string => typeof line === "string"); +} + +/** Reads one property of an unknown JSON value; `undefined` when absent. */ +function field(value: unknown, name: string): unknown { + if (value && typeof value === "object" && name in value) { + return Reflect.get(value, name); + } + return undefined; +} + +// ─── Rendering helpers ─────────────────────────────────────────────────────── + +function screenshotText(response: Record): string { + const lines = stringLines(response.lines); + const header = + `── viewport (window_top=${response.window_top}` + + `${response.alt_screen ? ", alt screen" : ""}` + + `${response.cursor ? `, cursor=${JSON.stringify(response.cursor)}` : ""}) ──`; + return `${header}\n${lines.map((line) => `│${line}`).join("\n")}`; +} + +/** + * After-input screenshot: the renderer's viewport when a debug socket exists + * (and answers), else the emulator's screen. + */ +async function settled( + session: Session, + note: string, + waitMs = 180, +): Promise { + await sleep(waitMs); + if (session.sock) { + try { + const shot = await request(session, { op: "text" }, 3_000); + if (shot.ok !== false) return `${note}\n${screenshotText(shot)}`; + } catch { + // Renderer unavailable; fall back to the emulator. + } + } + return `${note}\n${session.screen.snapshot()}`; +} + +/** Renders one `tree` response node (and its children) as outline rows. */ +function renderTree(node: unknown, depth: number, out: string[]) { + if (!node || typeof node !== "object") return; + const rect = field(node, "rect"); + const id = field(node, "id"); + const flags = [ + field(node, "focused") === true ? "FOCUSED" : "", + field(node, "focusable") === true ? "focusable" : "", + field(node, "hidden") === true ? "hidden" : "", + ] + .filter(Boolean) + .join(" "); + out.push( + " ".repeat(depth) + + `${field(node, "kind")}${typeof id === "string" ? `#${id}` : ""}` + + (Array.isArray(rect) + ? ` [${rect[0]},${rect[1]} ${rect[2]}x${rect[3]}]` + : "") + + (flags ? ` ${flags}` : ""), + ); + const children = field(node, "children"); + if (Array.isArray(children)) { + for (const child of children) renderTree(child, depth + 1, out); + } +} + +const SEQUENCES: Record = { + alt_enter: "\x1b[?1049h", + alt_leave: "\x1b[?1049l", + clear_scrollback: "\x1b[3J", + sync_begin: "\x1b[?2026h", + sync_end: "\x1b[?2026l", + mouse_on: "\x1b[?1003h", + mouse_off: "\x1b[?1003l", + cursor_hide: "\x1b[?25l", + cursor_show: "\x1b[?25h", +}; + +function count(haystack: Buffer, needle: string): number { + const bytes = Buffer.from(needle, "latin1"); + let total = 0; + let from = 0; + for (;;) { + const index = haystack.indexOf(bytes, from); + if (index < 0) return total; + total += 1; + from = index + bytes.length; + } +} + +/** Escapes control bytes so raw terminal output is printable. */ +function visible(bytes: Buffer): string { + let out = ""; + for (const byte of bytes) { + if (byte === 0x1b) out += "\\e"; + else if (byte === 0x0a) out += "\n"; + else if (byte === 0x0d) out += "\\r"; + else if (byte < 0x20 || byte === 0x7f) + out += `\\x${byte.toString(16).padStart(2, "0")}`; + else out += String.fromCharCode(byte); + } + return out; +} + +/** Unescapes `\e`, `\r`, `\n`, `\t`, and `\xNN` in a `send` payload. */ +function unescapeBytes(text: string): Buffer { + const out: number[] = []; + for (let index = 0; index < text.length; index++) { + if (text[index] !== "\\") { + out.push(...Buffer.from(text[index], "utf8")); + continue; + } + const next = text[index + 1]; + if (next === "e") { + out.push(0x1b); + index++; + } else if (next === "r") { + out.push(0x0d); + index++; + } else if (next === "n") { + out.push(0x0a); + index++; + } else if (next === "t") { + out.push(0x09); + index++; + } else if (next === "x") { + out.push(Number.parseInt(text.slice(index + 2, index + 4), 16)); + index += 3; + } else { + out.push(0x5c); + } + } + return Buffer.from(out); +} + +// ─── Tool ──────────────────────────────────────────────────────────────────── + +const factory = (omp: ToolHost) => { + const startSession = async (params: TuiParams): Promise => { + const name = params.name ?? "main"; + if (sessions.has(name)) { + throw new Error(`session "${name}" already running; stop it first`); + } + if (params.file && params.bin) { + throw new Error("start takes `file` or `bin`, not both"); + } + // Default target: this repo's own TUI, omp itself. + const file = params.bin ? undefined : (params.file ?? "packages/coding-agent/src/cli.ts"); + const target = file ?? params.bin ?? ""; + const command = file + ? [process.execPath, resolve(omp.cwd, file), ...(params.args ?? [])] + : [target, ...(params.args ?? [])]; + + const rows = params.rows ?? 30; + const cols = params.cols ?? 100; + const dir = mkdtempSync(join(tmpdir(), `omp-tui-${name}-`)); + const sockPath = join(dir, "debug.sock"); + const screen = await Screen.create(cols, rows); + // The PTY data callback closes over `session`; Bun.spawn returns + // synchronously and the callback fires on the event loop, so the + // binding is assigned before the first chunk can arrive. + let session: Session; + let proc: Child; + try { + const spawned = Bun.spawn(command, { + cwd: omp.cwd, + env: { + ...process.env, + OMP_TUI_DEBUG: sockPath, + TERM: "xterm-256color", + COLORTERM: "truecolor", + }, + terminal: { + cols, + rows, + data(_terminal, chunk) { + capture(session, chunk); + }, + }, + }); + const terminal = spawned.terminal; + if (!terminal) throw new Error("Bun.spawn did not create a PTY"); + proc = { + pid: spawned.pid, + exited: spawned.exited, + terminal, + kill(signal) { + spawned.kill(signal); + }, + }; + } catch (error) { + screen.dispose(); + rmSync(dir, { recursive: true, force: true }); + throw error; + } + // Route the core's query replies (DA, DECRQSS, OSC color queries) back + // to the child: capability probes resolve as on a real terminal. + screen.onReply = (bytes) => proc.terminal.write(bytes); + session = { + name, + target, + proc, + cols, + rows, + dir, + screen, + sock: null, + sockBuf: "", + waiters: [], + raw: [], + rawBytes: 0, + exit: null, + }; + proc.exited.then((code) => { + session.exit = code; + }); + sessions.set(name, session); + + const deadline = Date.now() + (params.timeout ?? 15) * 1000; + const connected = await connectSocket( + session, + sockPath, + (params.timeout ?? 15) * 1000, + ); + if (session.exit !== null) { + const tail = visible(Buffer.concat(session.raw)).slice(-3000); + await stopSession(session).catch(() => {}); + throw new Error( + `"${target}" exited immediately (code ${session.exit}).\n` + + `terminal tail: ${tail || "(empty)"}`, + ); + } + let text = `session "${name}": ${target} pid=${proc.pid} pty=${cols}x${rows}`; + if (connected) { + // The socket binds at terminal entry, before the first frame + // paints; retry until the snapshot exists so `start` reliably + // returns the opening screenshot. + let shot = await request(session, { op: "text" }); + while ( + shot.ok === false && + String(shot.error ?? "").includes("no frame painted yet") && + session.exit === null && + Date.now() < deadline + ) { + await sleep(50); + shot = await request(session, { op: "text" }); + } + text += `\n${screenshotText(shot)}`; + } else { + text += + "\n(no debug socket: app is not an omp-tui host; `send` injects " + + "input, `screen` renders the emulated display)" + + `\n${session.screen.snapshot()}`; + } + return text; + }; + + return { + name: "tui", + label: "TUI Debug", + description: + "Run and debug omp/pi-tui apps headlessly on a real PTY plus the " + + "OMP_TUI_DEBUG socket. Start defaults to omp itself " + + "(packages/coding-agent/src/cli.ts); override with file (a TS/JS entry, e.g. " + + "file: \"packages/tui/examples/debug-demo.ts\") or bin (an executable name/path), plus optional rows/cols and args. Any omp/pi-tui app serves " + + "OMP_TUI_DEBUG. Ops: text (viewport screenshot as plain text), screen " + + "(plain-text screen from kitty's real terminal core — works for any app, no " + + "debug socket needed; peek=N prepends N scrollback lines), frame (full " + + "document), tree (component tree with ids/rects/focus), values (widget " + + "values JSON), info, keys (spec like \"tab C-c enter 'literal'\"), type " + + "(literal text through the input decoder), paste (bracketed paste), mouse " + + "(x,y,action: click|right-click|middle-click|move|drag|release|wheel-up|" + + "wheel-down), send (raw bytes to the terminal, \\e/\\xNN escapes), resize " + + "(cols,rows delivered via SIGWINCH), raw (exact captured byte stream: " + + "escape-sequence stats + escaped tail — prefer text/screen unless " + + "auditing escapes), shot (pixel screenshot of the emulated screen — real " + + "colors/styles as a PNG image, rasterized in-process), stop, list. " + + "Input ops (keys/type/paste/mouse/send/" + + "resize) return an after-screenshot of the resulting display (quiet:true " + + "skips it). Sessions persist across calls; injected input rides the " + + "app's real input path.", + parameters: omp.zod.object({ + op: omp.zod + .string() + .describe( + "operation: start | stop | list | text | screen | shot | frame | tree | values | info | keys | type | paste | mouse | send | resize | raw", + ), + name: omp.zod + .string() + .optional() + .describe("session name (default: main)"), + file: omp.zod + .string() + .optional() + .describe("start: TS/JS entry path relative to cwd (default: packages/coding-agent/src/cli.ts — omp itself)"), + bin: omp.zod + .string() + .optional() + .describe("start: executable name or path"), + args: omp.zod + .array(omp.zod.string()) + .optional() + .describe("start: program argv"), + rows: omp.zod + .number() + .optional() + .describe("start/resize: pty rows (default 30)"), + cols: omp.zod + .number() + .optional() + .describe("start/resize: pty cols (default 100)"), + keys: omp.zod + .string() + .optional() + .describe("keys: spec, e.g. \"tab tab enter C-c pgdn 'hello'\""), + text: omp.zod + .string() + .optional() + .describe("type/paste/send: payload text"), + x: omp.zod.number().optional().describe("mouse: zero-based column"), + y: omp.zod.number().optional().describe("mouse: zero-based viewport row"), + action: omp.zod + .string() + .optional() + .describe("mouse: gesture (default click)"), + peek: omp.zod + .number() + .optional() + .describe( + "screen: scrollback lines to include; raw: tail bytes (default 2000)", + ), + clear: omp.zod + .boolean() + .optional() + .describe("raw: reset capture after reading"), + quiet: omp.zod + .boolean() + .optional() + .describe("input ops: skip the after-screenshot"), + timeout: omp.zod + .number() + .optional() + .describe("start: socket wait seconds (default 15)"), + }), + + async execute( + _toolCallId: string, + params: TuiParams, + _onUpdate?: (update: ToolUpdate) => void, + ): Promise { + const reply = ( + text: string, + details?: Record, + ): ToolResult => ({ + content: [{ type: "text", text }], + details, + }); + + switch (params.op) { + case "start": + return reply(await startSession(params)); + case "list": { + const rows = [...sessions.values()].map( + (session) => + `${session.name}: ${session.target} pid=${session.proc.pid} ` + + `${session.cols}x${session.rows} ` + + `${session.exit === null ? "running" : `exited(${session.exit})`}` + + `${session.sock ? "" : " (no socket)"}`, + ); + return reply(rows.join("\n") || "no sessions"); + } + case "stop": { + const session = need(params.name); + const code = await stopSession(session); + return reply(`stopped "${session.name}" (exit ${code})`); + } + case "text": { + const session = need(params.name); + if (!session.sock) + return reply(session.screen.snapshot(params.peek ?? 0)); + const response = await request(session, { op: "text" }); + return reply(screenshotText(response), response); + } + case "screen": { + return reply(need(params.name).screen.snapshot(params.peek ?? 0)); + } + case "shot": { + const session = need(params.name); + const png = join( + tmpdir(), + `omp-tui-${session.name}-${Date.now()}.png`, + ); + const bytes = await session.screen.png(); + writeFileSync(png, bytes); + return { + content: [ + { + type: "image", + data: bytes.toString("base64"), + mimeType: "image/png", + }, + { type: "text", text: `screenshot saved: ${png}` }, + ], + }; + } + case "frame": { + const response = await request(need(params.name), { op: "frame" }); + const lines = stringLines(response.lines); + return reply(lines.map((line) => `│${line}`).join("\n"), response); + } + case "tree": { + const response = await request(need(params.name), { op: "tree" }); + const out: string[] = []; + renderTree(field(response.tree, "root"), 0, out); + const overlays = field(response.tree, "overlays"); + if (Array.isArray(overlays)) { + for (const layer of overlays) { + out.push( + `overlay #${field(layer, "overlay")} ` + + `band=${JSON.stringify(field(layer, "band"))}` + + `${field(layer, "hidden") === true ? " hidden" : ""}`, + ); + renderTree(field(layer, "root"), 1, out); + } + } + return reply(out.join("\n"), response); + } + case "values": + case "info": { + const response = await request(need(params.name), { op: params.op }); + return reply(JSON.stringify(response, null, 1), response); + } + case "keys": { + if (!params.keys) throw new Error("keys op needs `keys`"); + const session = need(params.name); + const response = await request(session, { + op: "keys", + keys: params.keys, + }); + if (!response.ok) throw new Error(String(response.error)); + const note = `injected ${response.injected} events`; + return reply( + params.quiet ? note : await settled(session, note), + response, + ); + } + case "type": { + if (params.text === undefined) + throw new Error("type op needs `text`"); + const session = need(params.name); + const response = await request(session, { + op: "bytes", + data: params.text, + }); + if (!response.ok) throw new Error(String(response.error)); + const note = `typed ${params.text.length} chars`; + return reply( + params.quiet ? note : await settled(session, note), + response, + ); + } + case "paste": { + if (params.text === undefined) + throw new Error("paste op needs `text`"); + const session = need(params.name); + const response = await request(session, { + op: "paste", + text: params.text, + }); + if (!response.ok) throw new Error(String(response.error)); + return reply( + params.quiet ? "pasted" : await settled(session, "pasted"), + response, + ); + } + case "mouse": { + if (params.x === undefined || params.y === undefined) { + throw new Error("mouse op needs `x` and `y`"); + } + const session = need(params.name); + const response = await request(session, { + op: "mouse", + x: params.x, + y: params.y, + action: params.action ?? "click", + }); + if (!response.ok) throw new Error(String(response.error)); + const note = `mouse ${params.action ?? "click"} at ${params.x},${params.y}`; + return reply( + params.quiet ? note : await settled(session, note), + response, + ); + } + case "send": { + if (params.text === undefined) + throw new Error("send op needs `text`"); + const session = need(params.name); + const bytes = unescapeBytes(params.text); + session.proc.terminal.write(bytes); + const note = `sent ${bytes.length} bytes to the terminal`; + return reply(params.quiet ? note : await settled(session, note)); + } + case "resize": { + const session = need(params.name); + const rows = params.rows ?? session.rows; + const cols = params.cols ?? session.cols; + session.proc.terminal.resize(cols, rows); + session.screen.resize(cols, rows); + session.cols = cols; + session.rows = rows; + const note = `resized to ${cols}x${rows}; SIGWINCH delivered`; + return reply(params.quiet ? note : await settled(session, note, 350)); + } + case "raw": { + const session = need(params.name); + const blob = Buffer.concat(session.raw); + const stats: Record = { bytes: blob.length }; + for (const key in SEQUENCES) { + const total = count(blob, SEQUENCES[key]); + if (total > 0) stats[key] = total; + } + if (params.clear) { + session.raw = []; + session.rawBytes = 0; + } + const peek = params.peek ?? 2000; + const tail = peek > 0 ? visible(blob.subarray(-peek)) : ""; + return reply( + `${JSON.stringify(stats)}${tail ? `\n── tail ──\n${tail}` : ""}`, + { stats }, + ); + } + default: + throw new Error(`unknown op ${JSON.stringify(params.op)}`); + } + }, + + onSession(event: { reason?: string }) { + if (event.reason === "shutdown") { + for (const session of sessions.values()) { + try { + session.proc.kill("SIGKILL"); + session.proc.terminal.close(); + session.screen.dispose(); + rmSync(session.dir, { recursive: true, force: true }); + } catch { + // Best-effort teardown. + } + } + sessions.clear(); + } + }, + }; +}; + +export default factory; diff --git a/AGENTS.md b/AGENTS.md index f85bcd74efb6..4d7d91a39290 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -171,18 +171,37 @@ Manual reader loops only when the protocol requires it (SSE, streaming JSON-RPC) - **String width**: `Bun.stringWidth(text, { countAnsiEscapeCodes?: false })`. - **Wrapping**: `Bun.wrapAnsi(text, width, { wordWrap, hard, trim })`. +## Model/Provider Policy Lives in KDL + +**NEVER hard-code model- or provider-conditional policy in TypeScript.** No `id.includes("claude")`, no model-name regexes, no per-model lookup tables (effort ladders, pricing, context windows, modalities, API routing, quirk flags). All of it belongs in the KDL rule tree at `packages/catalog/src/compat/rules/`, compiled by `bun run gen:compat` into the committed `rules.json` and resolved at build time via `resolveModelPolicy`/`buildModel`. + +Ownership strata (see `src/compat/rules/README.md`): + +- `taxonomy/*.kdl` — identity: class membership, families, revision extraction, reviewed overrides, suffix collapse. +- `classes/*.kdl` — model-lineage truths (behavior inherent to a model line, on any host). +- `providers/*.kdl` — deployment contracts (behavior a host imposes), plus documented exact-id residue. +- `runtime/behavior.kdl` — heuristics that run before/outside exact model lookup (`api-routes`, `model-limits`, `exclude-models`, `pricing-peer`, hosted defaults). + +Rules for TS code: + +- Branching on model identity in TS is allowed **only** through structured facts from `classifyModel()` (`class`/`family`/`revision`/effort facts) — never through string matching on ids, and prefer a KDL axis when one can express the policy. +- Discovery mappers map authoritative upstream fields as reported; seed neutral values only for fields the upstream omits or misreports **and** KDL explicitly owns via a correction axis (`input-modalities`, `cost-patch`, `limits-patch`, `context-window-floor`, thinking axes). Assert rule-owned corrections through `buildModel`; raw discovery specs remain the right assertion surface for parsing/normalization contracts. +- An id that no selector can isolate gets an exact-id `models` residue rule with a comment — never a special case in TS. +- Equal-rank rule overlaps throw `AmbiguousOverlapError` at resolve time; fix with an explicit `priority=` in KDL, not code. +- After editing rules: `bun run gen:compat` and commit `rules.json` alongside the `.kdl` change. + ## Generated Files -**NEVER edit `packages/catalog/src/models.json` directly.** It is generated from upstream sources (stencil.so, provider catalog discovery, OpenCode docs) by `packages/catalog/scripts/generate-models.ts` and the descriptors/resolvers in `packages/catalog/src/provider-models/`. Hand-edits get overwritten on the next regen. +**NEVER edit `packages/catalog/src/models.json` directly.** It is generated from upstream sources (stencil.so, provider catalog discovery, OpenCode docs) by `packages/catalog/scripts/generate-models.ts` and the descriptors/resolvers in `packages/catalog/src/provider-models/`. Hand-edits get overwritten on the next regen. The same applies to `packages/catalog/src/compat/rules.json`, compiled from the KDL tree by `bun run gen:compat`. To change an entry, fix the source: -- **Resolution rules / per-id overrides** → relevant resolver in `packages/catalog/src/provider-models/openai-compat.ts` (e.g. `createOpenCodeApiResolution`'s id-override map). +- **Model/provider policy** (identity, thinking ladders, wire quirks, modality/limit/pricing corrections, API routing, roster exclusions) → the KDL tree in `packages/catalog/src/compat/rules/` (see the section above). - **Provider catalog entries** (default model, discovery factory/flags) → the `CATALOG_PROVIDERS` table in `packages/catalog/src/provider-models/descriptors.ts`. -- **Generator-level fixups** (premium multipliers, codex pricing fallback, fallback models, post-processing) → `packages/catalog/scripts/generate-models.ts`. -- **Thinking metadata / generated policies** → `packages/catalog/src/model-thinking.ts` (`applyGeneratedModelPolicies`); model-id classification (family/version parsing) lives in `packages/catalog/src/identity/classify.ts`. +- **Discovery/request plumbing** (endpoint shapes, auth, response parsing) → the mappers in `packages/catalog/src/provider-models/openai-compat.ts`. +- **Generator wiring** (upstream merges, premium multipliers, post-processing order) → `packages/catalog/scripts/generate-models.ts`. -Regenerate with `bun run gen:models` and commit `models.json` alongside the source change. Add a regression test against the **resolver/descriptor**, not the bundled JSON, so it survives upstream metadata shifts. +Regenerate with `bun run gen:compat` and/or `bun run gen:models` and commit the generated files alongside the source change. Add a regression test against the **rule/descriptor/mapper**, not the bundled JSON, so it survives upstream metadata shifts. ## Logging and CLI Output diff --git a/Cargo.lock b/Cargo.lock index cdbb2dbd52fc..734e9c01092c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -534,6 +534,12 @@ version = "1.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06" +[[package]] +name = "beef" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1" + [[package]] name = "bigdecimal" version = "0.4.10" @@ -623,6 +629,15 @@ dependencies = [ "wyz", ] +[[package]] +name = "blake2" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe" +dependencies = [ + "digest 0.10.7", +] + [[package]] name = "blake2b_simd" version = "1.0.5" @@ -643,7 +658,7 @@ dependencies = [ "cc", "cfg-if", "constant_time_eq", - "cpufeatures 0.3.0", + "cpufeatures 0.3.1", ] [[package]] @@ -697,27 +712,25 @@ dependencies = [ [[package]] name = "bon" -version = "3.9.3" +version = "3.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a602c73c7b0148ec6d12af6fd5cc7a46e2eacc8878271a999abac56eed12f561" +checksum = "9e3fac94a66da67200398458a25412bcc3f9b6443b5119a6cad9cf3ccfcd8cc6" dependencies = [ "bon-macros", - "rustversion", ] [[package]] name = "bon-macros" -version = "3.9.3" +version = "3.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6dee98b0db6a962de883bf5d20362dee4d7ca0d12fe39a7c6c73c844e1cd7c1f" +checksum = "d4654961ad0494e4774c5c60b4cb4cd0ae9b9d92d039d901638b1dba97ebebf5" dependencies = [ - "darling 0.23.0", + "darling 0.24.1", "ident_case", "prettyplease", "proc-macro2", "quote", - "rustversion", - "syn 2.0.119", + "syn 3.0.4", ] [[package]] @@ -1042,12 +1055,12 @@ dependencies = [ [[package]] name = "chacha20" -version = "0.10.1" +version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d524456ba66e72eb8b115ff89e01e497f8e6d11d78b70b1aa13c0fbd97540a81" +checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" dependencies = [ "cfg-if", - "cpufeatures 0.3.0", + "cpufeatures 0.3.1", "rand_core 0.10.1", ] @@ -1159,6 +1172,15 @@ dependencies = [ "error-code", ] +[[package]] +name = "clru" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "197fd99cb113a8d5d9b6376f3aa817f32c1078f2343b714fff7d2ca44fdf67d5" +dependencies = [ + "hashbrown 0.16.1", +] + [[package]] name = "cmake" version = "0.1.58" @@ -1366,9 +1388,9 @@ dependencies = [ [[package]] name = "cpufeatures" -version = "0.3.0" +version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201" +checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566" dependencies = [ "libc", ] @@ -1409,6 +1431,15 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "crossbeam-channel" +version = "0.5.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d85363c37faeca707aef026efa9f3b34d077bce547e48f770770625c6013679e" +dependencies = [ + "crossbeam-utils", +] + [[package]] name = "crossbeam-deque" version = "0.8.7" @@ -1525,12 +1556,12 @@ dependencies = [ [[package]] name = "darling" -version = "0.23.0" +version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d" +checksum = "ed17f5901b6630b993ca003def43f2f8ef4014fc13b047b57aad617ff32bc2ec" dependencies = [ - "darling_core 0.23.0", - "darling_macro 0.23.0", + "darling_core 0.24.1", + "darling_macro 0.24.1", ] [[package]] @@ -1549,15 +1580,15 @@ dependencies = [ [[package]] name = "darling_core" -version = "0.23.0" +version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0" +checksum = "6837e2cf7485aaae18f86181d2f0e9a7ed297a025e220aeabf63fdebd3a2ddff" dependencies = [ "ident_case", "proc-macro2", "quote", "strsim", - "syn 2.0.119", + "syn 3.0.4", ] [[package]] @@ -1573,13 +1604,13 @@ dependencies = [ [[package]] name = "darling_macro" -version = "0.23.0" +version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d" +checksum = "2ac7135c3ef02b2f7833bbeb1be5ba7f966dcde8a87c6b87f65a778d71a02785" dependencies = [ - "darling_core 0.23.0", + "darling_core 0.24.1", "quote", - "syn 2.0.119", + "syn 3.0.4", ] [[package]] @@ -1852,7 +1883,7 @@ dependencies = [ "rustls", "sec1", "sha1", - "sha2", + "sha2 0.10.9", "thiserror 1.0.69", "tokio", "webrtc-util", @@ -2037,6 +2068,16 @@ version = "3.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7" +[[package]] +name = "etcetera" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de48cc4d1c1d97a20fd819def54b890cadde72ed3ad0c614822a0a433361be96" +dependencies = [ + "cfg-if", + "windows-sys 0.61.2", +] + [[package]] name = "euclid" version = "0.22.14" @@ -2099,6 +2140,16 @@ dependencies = [ "regex-syntax", ] +[[package]] +name = "faster-hex" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73" +dependencies = [ + "heapless 0.8.0", + "serde", +] + [[package]] name = "fastrand" version = "2.5.0" @@ -2182,12 +2233,13 @@ checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99" [[package]] name = "flate2" -version = "1.1.9" +version = "1.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c" +checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb" dependencies = [ "crc32fast", - "miniz_oxide", + "miniz_oxide 0.9.1", + "zlib-rs", ] [[package]] @@ -2531,46 +2583,866 @@ dependencies = [ name = "getrandom" version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + +[[package]] +name = "getrandom" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "r-efi 6.0.0", + "rand_core 0.10.1", + "wasm-bindgen", +] + +[[package]] +name = "ghash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1" +dependencies = [ + "opaque-debug", + "polyval", +] + +[[package]] +name = "gif" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159" +dependencies = [ + "color_quant", + "weezl", +] + +[[package]] +name = "gix" +version = "0.85.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa8b2e38ebfc4484dfef8580ddcaf8abb7285e6f3eb6413ff6775d104ae96ca6" +dependencies = [ + "gix-actor", + "gix-attributes", + "gix-command", + "gix-commitgraph", + "gix-config", + "gix-date", + "gix-diff", + "gix-dir", + "gix-discover", + "gix-error", + "gix-features", + "gix-filter", + "gix-fs", + "gix-glob", + "gix-hash", + "gix-hashtable", + "gix-ignore", + "gix-index", + "gix-lock", + "gix-merge", + "gix-object", + "gix-odb", + "gix-pack", + "gix-path", + "gix-pathspec", + "gix-protocol", + "gix-ref", + "gix-refspec", + "gix-revision", + "gix-revwalk", + "gix-sec", + "gix-shallow", + "gix-status", + "gix-submodule", + "gix-tempfile", + "gix-trace", + "gix-traverse", + "gix-url", + "gix-utils", + "gix-validate", + "gix-worktree", + "gix-worktree-state", + "gix-worktree-stream", + "nonempty", + "smallvec", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-actor" +version = "0.41.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f9308ad6fd35b2a865cbe4117ac61b2be59e4a9ef1621c7a9794f7c8e52c5b" +dependencies = [ + "bstr", + "gix-date", + "gix-error", +] + +[[package]] +name = "gix-attributes" +version = "0.33.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39b40888d0ed415c0744a6cdc61eebf0304c9d26ab726725b718443c322e5ba4" +dependencies = [ + "bstr", + "gix-glob", + "gix-path", + "gix-quote", + "gix-trace", + "kstring", + "smallvec", + "thiserror 2.0.20", + "unicode-bom", +] + +[[package]] +name = "gix-bitmap" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7cd1d118d0f5d88b96e6f6e13b566475fef4797ead4a02c26fed36c1375066f7" +dependencies = [ + "gix-error", +] + +[[package]] +name = "gix-chunk" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2a871e5cab12ba568845714473505deefffb3c04eb47f4708ce344cd459c1cc" +dependencies = [ + "gix-error", +] + +[[package]] +name = "gix-command" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf4363accdf6ef7ba861871d2d521ab7418a04aaaed919fadb022af71d379b12" +dependencies = [ + "bstr", + "gix-path", + "gix-quote", + "gix-trace", + "shell-words", +] + +[[package]] +name = "gix-commitgraph" +version = "0.37.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f675d0df484a7f6a47e64bd6f311af489d947c0323b0564f36d14f3d7762abb" +dependencies = [ + "bstr", + "gix-chunk", + "gix-error", + "gix-hash", + "memmap2", + "nonempty", +] + +[[package]] +name = "gix-config" +version = "0.58.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a29bf266c4cdaf759e535c24ad4ce655b987aeb6911075643403cc7cc5ade583" +dependencies = [ + "bstr", + "gix-config-value", + "gix-features", + "gix-glob", + "gix-path", + "gix-ref", + "gix-sec", + "smallvec", + "thiserror 2.0.20", + "unicode-bom", +] + +[[package]] +name = "gix-config-value" +version = "0.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed42168329552f6c2e5df09665c104199d45d84bedb53683738a49b57fe1baab" +dependencies = [ + "bitflags 2.13.1", + "bstr", + "gix-path", + "libc", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-date" +version = "0.15.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e47b9e8cdc688296609b706428de570f88b1e0eed7156dde7b4a89d26fa4567" +dependencies = [ + "bstr", + "gix-error", + "itoa", + "jiff", +] + +[[package]] +name = "gix-diff" +version = "0.65.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92c6d56c94edf92d78203a1cd416f770e35e10b6955ede6b9d7d0c22ff88a5f3" +dependencies = [ + "bstr", + "gix-attributes", + "gix-command", + "gix-filter", + "gix-fs", + "gix-hash", + "gix-imara-diff", + "gix-index", + "gix-object", + "gix-path", + "gix-pathspec", + "gix-tempfile", + "gix-trace", + "gix-traverse", + "gix-worktree", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-dir" +version = "0.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20098fba2b9c6e29361ccb4c0379d42dfb81fc7f86f7ab11f2dff4528c0bf01f" +dependencies = [ + "bstr", + "gix-discover", + "gix-fs", + "gix-ignore", + "gix-index", + "gix-object", + "gix-path", + "gix-pathspec", + "gix-trace", + "gix-utils", + "gix-worktree", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-discover" +version = "0.53.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d624d5b23b10c1d85337645227abe353ac95ab8ff66a7bdd5ce689b2db33a722" +dependencies = [ + "bstr", + "dunce", + "gix-fs", + "gix-path", + "gix-ref", + "gix-sec", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-error" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a9292309fd944e71b2a3c96d3c03a6feb8852db646febdde7cbb9f79cb5f329" +dependencies = [ + "bstr", +] + +[[package]] +name = "gix-features" +version = "0.48.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1849ae154d38bc403185be14fa871e38e3c93ee606875d94e207fdb9fba52dbc" +dependencies = [ + "bytes", + "crc32fast", + "crossbeam-channel", + "gix-path", + "gix-trace", + "gix-utils", + "libc", + "once_cell", + "parking_lot", + "prodash", + "thiserror 2.0.20", + "walkdir", + "zlib-rs", +] + +[[package]] +name = "gix-filter" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6644fb2ef97928c278675b239f366b457103d7e436f811d27331a8daf212759c" +dependencies = [ + "bstr", + "encoding_rs", + "gix-attributes", + "gix-command", + "gix-hash", + "gix-object", + "gix-packetline", + "gix-path", + "gix-quote", + "gix-trace", + "gix-utils", + "smallvec", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-fs" +version = "0.21.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6cdff46db8798e47e2f727d84b9379aac5add3dd3d9d0b07bb4d7d5d640771fe" +dependencies = [ + "bstr", + "fastrand", + "gix-features", + "gix-path", + "gix-utils", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-glob" +version = "0.26.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1fcb8ef5b16bcf874abe9b68d8abb3c0493c876d367ab824151f30a0f3f3756" +dependencies = [ + "bitflags 2.13.1", + "bstr", + "gix-features", + "gix-path", +] + +[[package]] +name = "gix-hash" +version = "0.25.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb0926d3819c837750b4e03c7754901e73f68b8c9b690753a6372a1bed4eedce" +dependencies = [ + "faster-hex", + "gix-features", + "sha1-checked", + "sha2 0.11.0", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-hashtable" +version = "0.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e261d54091f0d1c729bc83f54548c071bdec60a697de1e58e88bdfd7a99d24e" +dependencies = [ + "gix-hash", + "hashbrown 0.17.1", + "parking_lot", +] + +[[package]] +name = "gix-ignore" +version = "0.21.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d491bab9bf2c9f341dc754f425c31d5d3f63aca615312167b82e1deeaca97d8d" +dependencies = [ + "bstr", + "gix-glob", + "gix-path", + "gix-trace", + "unicode-bom", +] + +[[package]] +name = "gix-imara-diff" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c91d8cffac8849493a82233811bd02b2b183b8cf39bf704de0fa0841b737595" +dependencies = [ + "bstr", + "hashbrown 0.17.1", +] + +[[package]] +name = "gix-index" +version = "0.53.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36d45f82ec5a4d7542ea595e9ad16e03e26c8cb4f221e5bc9fcdcf469f63a681" +dependencies = [ + "bitflags 2.13.1", + "bstr", + "filetime", + "fnv", + "gix-bitmap", + "gix-features", + "gix-fs", + "gix-hash", + "gix-lock", + "gix-object", + "gix-traverse", + "gix-utils", + "gix-validate", + "hashbrown 0.17.1", + "itoa", + "libc", + "memmap2", + "rustix 1.1.4", + "smallvec", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-lock" +version = "23.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c9dedd9e90b0d47624d2ed241d394e09294118364e87b9b7e5f1fe755f3c2c" +dependencies = [ + "gix-tempfile", + "gix-utils", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-merge" +version = "0.18.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4b529a5dc509175fe277643a1c50b38de69f24b5a50f9c4e7f854c7fc7d1acc7" +dependencies = [ + "bstr", + "gix-command", + "gix-diff", + "gix-filter", + "gix-fs", + "gix-hash", + "gix-imara-diff", + "gix-index", + "gix-object", + "gix-path", + "gix-quote", + "gix-revision", + "gix-revwalk", + "gix-tempfile", + "gix-trace", + "gix-worktree", + "nonempty", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-object" +version = "0.62.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "019b38afc3eac1e41f9fe09a327664b313ba4a120fa5f40e3678795d0e42783e" +dependencies = [ + "bstr", + "gix-actor", + "gix-date", + "gix-features", + "gix-hash", + "gix-hashtable", + "gix-utils", + "gix-validate", + "itoa", + "smallvec", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-odb" +version = "0.82.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7fadc59f6fa0f9dd445eceee61060a2b59ca557f48da9fc677f567db535b782a" +dependencies = [ + "arc-swap", + "gix-features", + "gix-fs", + "gix-hash", + "gix-hashtable", + "gix-object", + "gix-pack", + "gix-path", + "gix-quote", + "memmap2", + "parking_lot", + "tempfile", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-pack" +version = "0.72.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca3e7f1726cd2c0cd1cf1fc20be8a8e623f0b163f1f8d6fc836cfb9bc8cd758b" +dependencies = [ + "clru", + "gix-chunk", + "gix-error", + "gix-features", + "gix-hash", + "gix-hashtable", + "gix-object", + "gix-path", + "memmap2", + "smallvec", + "thiserror 2.0.20", + "uluru", +] + +[[package]] +name = "gix-packetline" +version = "0.21.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b217dd0ee0c4021ecf169a4a519b1b4f80d15e3f3765f3dc466223dc0ac891d7" +dependencies = [ + "bstr", + "faster-hex", + "gix-trace", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-path" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b075e730586bba7341304d6fc1b4efc1d10cf64532622521c0e07f30e661046" +dependencies = [ + "bstr", + "gix-trace", + "gix-validate", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-pathspec" +version = "0.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3050783b41ee11511e1e8fb35623df81806194f4030395f14f48ea37c2798c9f" +dependencies = [ + "bitflags 2.13.1", + "bstr", + "gix-attributes", + "gix-config-value", + "gix-glob", + "gix-path", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-protocol" +version = "0.63.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "978468bae4ea2df20c72db3b20d0bdb548a0c1090b85a83643b553e6e0e041f2" +dependencies = [ + "bstr", + "gix-date", + "gix-features", + "gix-hash", + "gix-ref", + "gix-shallow", + "gix-transport", + "gix-utils", + "maybe-async", + "nonempty", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-quote" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6e541fc33cc2b783b7979040d445a0c86a2eca747c8faea4ca84230d06ae6ef" +dependencies = [ + "bstr", + "gix-error", + "gix-utils", +] + +[[package]] +name = "gix-ref" +version = "0.65.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9bbfbce1dfd7d7f8469ddef6d3518376aff664348f153cbe0fc3e58ef993d24e" +dependencies = [ + "gix-actor", + "gix-features", + "gix-fs", + "gix-hash", + "gix-lock", + "gix-object", + "gix-path", + "gix-tempfile", + "gix-utils", + "gix-validate", + "memmap2", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-refspec" +version = "0.43.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7bc36a4fb1a1540b59cf2da498783080743fa274b02a3f19ca444fc4015a9d4f" +dependencies = [ + "bstr", + "gix-error", + "gix-glob", + "gix-hash", + "gix-revision", + "gix-validate", + "smallvec", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-revision" +version = "0.47.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "885075c3c21eb9c06e0be3b3728ba5932c04e1c1011dcee7c81801980e3e986f" +dependencies = [ + "bitflags 2.13.1", + "bstr", + "gix-commitgraph", + "gix-date", + "gix-error", + "gix-hash", + "gix-hashtable", + "gix-object", + "gix-revwalk", + "gix-trace", + "nonempty", +] + +[[package]] +name = "gix-revwalk" +version = "0.33.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f11fe7ca2585193d3d70bbe0be175a2008d883a704cc7a55e454e113e689455" +dependencies = [ + "gix-commitgraph", + "gix-date", + "gix-error", + "gix-hash", + "gix-hashtable", + "gix-object", + "smallvec", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-sec" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af4fe6c152c1d50aea36f299825702cd37e303307832fec1d0fdd5844e47ce2f" +dependencies = [ + "bitflags 2.13.1", + "gix-path", + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "gix-shallow" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a292fc2fe548c5dfa575479d16b445b0ddf1dd2f56f1fec6aed386f82553cd97" +dependencies = [ + "bstr", + "gix-hash", + "gix-lock", + "nonempty", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-status" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aec3293f75db1212f99217832cbc70c30faeb95cefc97c7f1a17fd3bcf13a72e" +dependencies = [ + "bstr", + "filetime", + "gix-diff", + "gix-dir", + "gix-features", + "gix-filter", + "gix-fs", + "gix-hash", + "gix-index", + "gix-object", + "gix-path", + "gix-pathspec", + "gix-worktree", + "portable-atomic", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-submodule" +version = "0.32.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7f9f594f7cbda0b38ba6b633b3e9a7b7901acdc5d27bc186a16633800cd1ac8" +dependencies = [ + "bstr", + "gix-config", + "gix-path", + "gix-pathspec", + "gix-refspec", + "gix-url", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-tempfile" +version = "23.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ef60812443484e67bf84e444cc71b4c78ae62deb822221774a4fa0c57fdb17f" +dependencies = [ + "dashmap", + "gix-fs", + "libc", + "parking_lot", + "tempfile", +] + +[[package]] +name = "gix-trace" +version = "0.1.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "be3eb81d9dc914335923e50d52829c551feefd6a72d176c4130c546b67a60814" + +[[package]] +name = "gix-transport" +version = "0.57.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "186874f7ad1fb2f9a2f2aa9c2dabc7f9dd087bef74c1a0eee2b4a9cf0248fcb3" +dependencies = [ + "bstr", + "gix-command", + "gix-features", + "gix-packetline", + "gix-quote", + "gix-sec", + "gix-url", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-traverse" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5062cca8f2977565bbaf666ec31dbdb9bc9d9293beb65f9bec52e6c1121b62a1" +dependencies = [ + "bitflags 2.13.1", + "gix-commitgraph", + "gix-date", + "gix-hash", + "gix-hashtable", + "gix-object", + "gix-revwalk", + "smallvec", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-url" +version = "0.36.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57d68e70e96da0e5f9c871f1566349e0fd0e1a20bb483c7f54af1dd0b85b4b29" +dependencies = [ + "bstr", + "gix-path", + "percent-encoding", + "thiserror 2.0.20", +] + +[[package]] +name = "gix-utils" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0da1c46491b49458a446cc76f0085860f8164c2290742e0aa8c653ce67240a97" +dependencies = [ + "bstr", + "fastrand", + "getrandom 0.4.3", + "unicode-normalization", +] + +[[package]] +name = "gix-validate" +version = "0.11.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4dae8780f63ed8a803b8bdabbd7aa5f5c5d74592c8b50eed875c1bb4f6545a6a" dependencies = [ - "cfg-if", - "libc", - "r-efi 5.3.0", - "wasip2", + "bstr", ] [[package]] -name = "getrandom" -version = "0.4.3" +name = "gix-worktree" +version = "0.54.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" +checksum = "92399ed66f259592050c6ed9dc80105e095a2f8e87e6b83d98aa2e21d8e27036" dependencies = [ - "cfg-if", - "js-sys", - "libc", - "r-efi 6.0.0", - "rand_core 0.10.1", - "wasm-bindgen", + "bstr", + "gix-attributes", + "gix-fs", + "gix-glob", + "gix-hash", + "gix-ignore", + "gix-index", + "gix-object", + "gix-path", + "gix-validate", ] [[package]] -name = "ghash" -version = "0.5.1" +name = "gix-worktree-state" +version = "0.32.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1" +checksum = "c0f926b6a249bdb0086b307c704b7abd9d643e08f98040efe6467f00bb6d2ef5" dependencies = [ - "opaque-debug", - "polyval", + "bstr", + "gix-features", + "gix-filter", + "gix-fs", + "gix-index", + "gix-object", + "gix-path", + "gix-worktree", + "io-close", + "thiserror 2.0.20", ] [[package]] -name = "gif" -version = "0.14.2" +name = "gix-worktree-stream" +version = "0.34.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159" +checksum = "55f3a878c89a05470ad98c644b0015777c530da24854dd29e41fe4f41176840f" dependencies = [ - "color_quant", - "weezl", + "gix-attributes", + "gix-error", + "gix-features", + "gix-filter", + "gix-fs", + "gix-hash", + "gix-object", + "gix-path", + "gix-traverse", + "parking_lot", ] [[package]] @@ -2765,6 +3637,21 @@ name = "hashbrown" version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "allocator-api2", + "equivalent", + "foldhash 0.2.0", +] + +[[package]] +name = "heapless" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad" +dependencies = [ + "hash32", + "stable_deref_trait", +] [[package]] name = "heapless" @@ -2837,9 +3724,9 @@ checksum = "c9356095b4b41197bba32173600e1582792cda618f65d12f68e2e77d273413c5" [[package]] name = "html-to-markdown-rs" -version = "3.11.4" +version = "3.11.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6331a4c21bc99309e5863092660c08505c426eb1158e0472013487ecff85412b" +checksum = "c5fe2583aad3e87439e40d841fed327a60892bb9946da1e3a5788ee7f0f4fe3c" dependencies = [ "ahash", "astral-tl", @@ -3298,12 +4185,14 @@ checksum = "964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5" [[package]] name = "indexmap" -version = "2.14.0" +version = "2.14.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" +checksum = "07aa2048142242915a31d35844fb311e0e53fcca590c3a0a40dcf1b841fa09eb" dependencies = [ "equivalent", "hashbrown 0.17.1", + "serde", + "serde_core", ] [[package]] @@ -3412,6 +4301,16 @@ dependencies = [ "webrtc-util", ] +[[package]] +name = "interim" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9ce9099a85f468663d3225bf87e85d0548968441e1db12248b996b24f0f5b5a" +dependencies = [ + "chrono", + "logos", +] + [[package]] name = "intl-memoizer" version = "0.5.3" @@ -3431,6 +4330,16 @@ dependencies = [ "unic-langid", ] +[[package]] +name = "io-close" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cadcf447f06744f8ce713d2d6239bb5bde2c357a452397a9ed90c625da390bc" +dependencies = [ + "libc", + "winapi", +] + [[package]] name = "ipnet" version = "2.12.1" @@ -3461,6 +4370,15 @@ dependencies = [ "either", ] +[[package]] +name = "itertools" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc" +dependencies = [ + "either", +] + [[package]] name = "itoa" version = "1.0.18" @@ -3571,6 +4489,65 @@ dependencies = [ "jiff-tzdb", ] +[[package]] +name = "jj-lib" +version = "0.44.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d58fe15e3acbc89de606b7a10b284498ed908d09f3b7bdf560ca6f92e3a8d63" +dependencies = [ + "async-trait", + "blake2", + "bstr", + "chrono", + "clru", + "digest 0.10.7", + "dunce", + "either", + "etcetera", + "futures", + "gix", + "gix-ignore", + "globset", + "hashbrown 0.17.1", + "indexmap", + "interim", + "itertools 0.15.0", + "jj-lib-proc-macros", + "maplit", + "memchr", + "once_cell", + "pest", + "pest_derive", + "pollster", + "prost", + "rand 0.10.2", + "rand_chacha 0.10.0", + "rayon", + "ref-cast", + "regex", + "rustix 1.1.4", + "same-file", + "serde", + "smallvec", + "strsim", + "tempfile", + "thiserror 2.0.20", + "toml_edit", + "tracing", + "winreg 0.56.0", +] + +[[package]] +name = "jj-lib-proc-macros" +version = "0.44.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d68a9ec87af36ba808fa818f5f1f041cce01df9eb0e21690e854fe612640060e" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.4", +] + [[package]] name = "jobserver" version = "0.1.35" @@ -3637,6 +4614,15 @@ dependencies = [ "libc", ] +[[package]] +name = "kstring" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "558bf9508a558512042d3095138b1f7b8fe90c5467d94f9f1da28b3731c5dbd1" +dependencies = [ + "static_assertions", +] + [[package]] name = "kurbo" version = "0.13.1" @@ -3689,9 +4675,9 @@ checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" [[package]] name = "libredox" -version = "0.1.20" +version = "0.1.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28d0a00925a9f930d679b6789b721e3a7f9ed110f41b86d2497caa780c3a070a" +checksum = "d7955dfc218a8afb29dfeffd540e3a6e96baeb94fe7138228dd7cc6937fbbf96" dependencies = [ "libc", ] @@ -3790,6 +4776,40 @@ version = "0.4.34" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6" +[[package]] +name = "logos" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff472f899b4ec2d99161c51f60ff7075eeb3097069a36050d8037a6325eb8154" +dependencies = [ + "logos-derive", +] + +[[package]] +name = "logos-codegen" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "192a3a2b90b0c05b27a0b2c43eecdb7c415e29243acc3f89cc8247a5b693045c" +dependencies = [ + "beef", + "fnv", + "lazy_static", + "proc-macro2", + "quote", + "regex-syntax", + "rustc_version", + "syn 2.0.119", +] + +[[package]] +name = "logos-derive" +version = "0.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "605d9697bcd5ef3a42d38efc51541aa3d6a4a25f7ab6d1ed0da5ac632a26b470" +dependencies = [ + "logos-codegen", +] + [[package]] name = "lopdf" version = "0.42.0" @@ -3813,7 +4833,7 @@ dependencies = [ "rand 0.10.2", "rangemap", "rayon", - "sha2", + "sha2 0.10.9", "stringprep", "thiserror 2.0.20", "time", @@ -3831,6 +4851,12 @@ dependencies = [ "nu-ansi-term", ] +[[package]] +name = "maplit" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d" + [[package]] name = "markup5ever" version = "0.39.0" @@ -3842,6 +4868,17 @@ dependencies = [ "web_atoms", ] +[[package]] +name = "maybe-async" +version = "0.2.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "746873a384ad60adc5db74471dfaba74bd278afbdcfd81db93fafcdfc8b5ca0c" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "md-5" version = "0.10.6" @@ -3901,6 +4938,16 @@ dependencies = [ "simd-adler32", ] +[[package]] +name = "miniz_oxide" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b63fbc4a50860e98e7b2aa7804ded1db5cbc3aff9193adaff57a6931bf7c4b4c" +dependencies = [ + "adler2", + "simd-adler32", +] + [[package]] name = "mio" version = "1.2.2" @@ -4102,6 +5149,12 @@ dependencies = [ "memchr", ] +[[package]] +name = "nonempty" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9737e026353e5cd0736f98eddae28665118eb6f6600902a7f50db585621fecb6" + [[package]] name = "normalize-path" version = "0.2.1" @@ -4610,7 +5663,7 @@ dependencies = [ "ecdsa", "elliptic-curve", "primeorder", - "sha2", + "sha2 0.10.9", ] [[package]] @@ -4622,7 +5675,7 @@ dependencies = [ "ecdsa", "elliptic-curve", "primeorder", - "sha2", + "sha2 0.10.9", ] [[package]] @@ -4901,7 +5954,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d" dependencies = [ "phf_shared 0.11.3", - "rand 0.8.7", + "rand 0.8.8", ] [[package]] @@ -4979,7 +6032,7 @@ dependencies = [ [[package]] name = "pi-ast" -version = "18.0.4" +version = "18.0.11" dependencies = [ "anyhow", "ast-grep-core", @@ -5049,7 +6102,7 @@ dependencies = [ [[package]] name = "pi-builtins" -version = "18.0.4" +version = "18.0.11" dependencies = [ "ansi-width", "anyhow", @@ -5116,6 +6169,8 @@ dependencies = [ "rustix 1.1.4", "self_cell", "serde_json", + "sha2 0.10.9", + "sha3", "similar 3.2.0", "smallvec", "strum", @@ -5134,7 +6189,7 @@ dependencies = [ [[package]] name = "pi-iso" -version = "18.0.4" +version = "18.0.11" dependencies = [ "async-trait", "libc", @@ -5146,7 +6201,7 @@ dependencies = [ [[package]] name = "pi-natives" -version = "18.0.4" +version = "18.0.11" dependencies = [ "anyhow", "arboard", @@ -5168,7 +6223,7 @@ dependencies = [ "grep-pcre2", "grep-regex", "grep-searcher", - "heapless", + "heapless 0.9.3", "html-to-markdown-rs", "icy_sixel", "ignore", @@ -5190,6 +6245,7 @@ dependencies = [ "pi-ast", "pi-iso", "pi-shell", + "pi-vcs", "pi-voice", "pi-walker", "pipewire", @@ -5222,7 +6278,7 @@ dependencies = [ [[package]] name = "pi-shell" -version = "18.0.4" +version = "18.0.11" dependencies = [ "anyhow", "brush-core", @@ -5248,9 +6304,22 @@ dependencies = [ "xxhash-rust", ] +[[package]] +name = "pi-vcs" +version = "18.0.11" +dependencies = [ + "gix", + "jj-lib", + "libc", + "tempfile", + "thiserror 2.0.20", + "tokio", + "tokio-util", +] + [[package]] name = "pi-voice" -version = "18.0.4" +version = "18.0.11" dependencies = [ "audiopus_sys", "bytes", @@ -5265,7 +6334,7 @@ dependencies = [ [[package]] name = "pi-walker" -version = "18.0.4" +version = "18.0.11" dependencies = [ "dashmap", "globset", @@ -5369,7 +6438,7 @@ dependencies = [ "crc32fast", "fdeflate", "flate2", - "miniz_oxide", + "miniz_oxide 0.8.9", ] [[package]] @@ -5386,6 +6455,12 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "pollster" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc6355899e1c9462875b6757c79f3caa011a1fdae12bbb1a2e72dd1f234f8336" + [[package]] name = "poly1305" version = "0.8.0" @@ -5498,12 +6573,12 @@ dependencies = [ [[package]] name = "prettyplease" -version = "0.2.37" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +checksum = "2bfe0f4c752e450fc2faf62654f1c134747922825d5b04ca717b8874f41a40c0" dependencies = [ "proc-macro2", - "syn 2.0.119", + "syn 3.0.4", ] [[package]] @@ -5557,6 +6632,38 @@ dependencies = [ "hex", ] +[[package]] +name = "prodash" +version = "31.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "962200e2d7d551451297d9fdce85138374019ada198e30ea9ede38034e27604c" +dependencies = [ + "parking_lot", +] + +[[package]] +name = "prost" +version = "0.14.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "528ac67416ff8646872a3c02cad9cc4ee5dc9f9540c9b10771855c95cb2e5ae1" +dependencies = [ + "bytes", + "prost-derive", +] + +[[package]] +name = "prost-derive" +version = "0.14.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf" +dependencies = [ + "anyhow", + "itertools 0.14.0", + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "ptr_meta" version = "0.3.2" @@ -5654,9 +6761,9 @@ dependencies = [ [[package]] name = "rand" -version = "0.8.7" +version = "0.8.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22f6172bdec972074665ed81ed53b71da00bfc44b65a753cfde883ec4c702a1a" +checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c" dependencies = [ "rand_core 0.6.4", ] @@ -5667,7 +6774,7 @@ version = "0.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41" dependencies = [ - "rand_chacha", + "rand_chacha 0.9.0", "rand_core 0.9.5", ] @@ -5677,7 +6784,7 @@ version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80" dependencies = [ - "chacha20 0.10.1", + "chacha20 0.10.2", "getrandom 0.4.3", "rand_core 0.10.1", ] @@ -5692,6 +6799,16 @@ dependencies = [ "rand_core 0.9.5", ] +[[package]] +name = "rand_chacha" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3e6af7f3e25ded52c41df4e0b1af2d047e45896c2f3281792ed68a1c243daedb" +dependencies = [ + "ppv-lite86", + "rand_core 0.10.1", +] + [[package]] name = "rand_core" version = "0.6.4" @@ -6252,6 +7369,16 @@ dependencies = [ "digest 0.10.7", ] +[[package]] +name = "sha1-checked" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89f599ac0c323ebb1c6082821a54962b839832b03984598375bff3975b804423" +dependencies = [ + "digest 0.10.7", + "sha1", +] + [[package]] name = "sha2" version = "0.10.9" @@ -6261,6 +7388,27 @@ dependencies = [ "cfg-if", "cpufeatures 0.2.17", "digest 0.10.7", + "sha2-asm", +] + +[[package]] +name = "sha2" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.1", + "digest 0.11.3", +] + +[[package]] +name = "sha2-asm" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b845214d6175804686b2bd482bcffe96651bb2d1200742b712003504a2dac1ab" +dependencies = [ + "cc", ] [[package]] @@ -6964,8 +8112,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6975367e4d2ef766d86af01ffad14b622fecc8d4357a998fbc4deb6e9bacaf9b" dependencies = [ "indexmap", + "serde_core", + "serde_spanned", "toml_datetime", "toml_parser", + "toml_writer", "winnow 1.0.4", ] @@ -7705,6 +8856,15 @@ dependencies = [ "syn 2.0.119", ] +[[package]] +name = "uluru" +version = "3.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c8a2469e56e6e5095c82ccd3afb98dad95f7af7929aab6d8ba8d6e0f73657da" +dependencies = [ + "arrayvec", +] + [[package]] name = "unic-langid" version = "0.9.6" @@ -7735,6 +8895,12 @@ version = "0.3.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5" +[[package]] +name = "unicode-bom" +version = "2.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7eec5d1121208364f6793f7d2e222bf75a915c19557537745b195b253dd64217" + [[package]] name = "unicode-ident" version = "1.0.24" @@ -7923,7 +9089,7 @@ dependencies = [ "rustc-hash 2.1.3", "rustix 1.1.4", "sha1", - "sha2", + "sha2 0.10.9", "sha3", "sm3", "thiserror 2.0.20", @@ -7949,9 +9115,9 @@ dependencies = [ [[package]] name = "uuid" -version = "1.25.0" +version = "1.26.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f053576934f05a761a402421fbbe3d425d9366f75f978806a037b3ca481abecc" +checksum = "b5772d71c9be8a8a6ac2117d949c5b224c1b72241bb611d9a3012edcf8af7812" dependencies = [ "getrandom 0.4.3", "js-sys", @@ -8237,7 +9403,7 @@ dependencies = [ "sdp", "serde", "serde_json", - "sha2", + "sha2 0.10.9", "smol_str", "stun", "thiserror 1.0.69", @@ -8403,9 +9569,9 @@ dependencies = [ [[package]] name = "wide" -version = "1.6.1" +version = "1.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "de2aaf408e58689c2096682331b1f42bb2d9f2ed6b11560407d023cd0a6c634e" +checksum = "8cf05ca94c9fba0c51316899caa1d1e74a064fc310a5efa7375e614343d415be" dependencies = [ "bytemuck", "safe_arch", @@ -9378,6 +10544,12 @@ dependencies = [ "syn 3.0.4", ] +[[package]] +name = "zlib-rs" +version = "0.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12" + [[package]] name = "zmij" version = "1.0.23" diff --git a/Cargo.toml b/Cargo.toml index fcbe19e42967..218196e04ba5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,6 +9,7 @@ members = [ "crates/pi-iso", "crates/pi-natives", "crates/pi-shell", + "crates/pi-vcs", "crates/pi-voice", "crates/pi-walker", "crates/vendor/brush-core", @@ -16,7 +17,7 @@ members = [ resolver = "3" [workspace.package] -version = "18.0.4" +version = "18.0.11" edition = "2024" license = "MIT" authors = ["Stencil Labs, Inc."] @@ -184,6 +185,10 @@ verbose_bit_mask = "allow" # Explicit bit patterns can be clearer than hex # ────────────────────────────────────────────────────────────────────────────── default_trait_access = "allow" # Default::default() sometimes clearer significant_drop_tightening = "allow" # We pay attention to this already +# ────────────────────────────────────────────────────────────────────────────── +# Tests & Assertions +# ────────────────────────────────────────────────────────────────────────────── +assert_is_empty = "allow" # `is_empty()` states intent without brittle type annotations # ────────────────────────────────────────────────────────────────────────────── # Documentation @@ -207,6 +212,7 @@ pi-iso = { path = "crates/pi-iso" } pi-shell = { path = "crates/pi-shell" } pi-voice = { path = "crates/pi-voice" } pi-walker = { path = "crates/pi-walker" } +pi-vcs = { path = "crates/pi-vcs" } brush-core = { path = "crates/vendor/brush-core" } pi-builtins = { path = "crates/pi-builtins" } @@ -234,6 +240,7 @@ toml = "1.1" # Error Handling # ────────────────────────────────────────────────────────────────────────────── anyhow = "1.0" +thiserror = "2" bytes = "1" # ────────────────────────────────────────────────────────────────────────────── @@ -358,6 +365,29 @@ tiktoken-rs = "0.11" # Shell Parsing # ────────────────────────────────────────────────────────────────────────────── brush-parser = "0.3" +# ────────────────────────────────────────────────────────────────────────────── +# Version Control (in-process git + jujutsu) +# ────────────────────────────────────────────────────────────────────────────── +# gix is pinned to the minor jj-lib depends on so both VCS backends share one +# gitoxide stack in the binary. No transport/credential features: network ops +# (clone/fetch/push) deliberately shell out to the git CLI for auth parity. +gix = { version = "0.85", default-features = false, features = [ + "attributes", + "blob-diff", + "dirwalk", + "excludes", + "index", + "max-performance-safe", + "merge", + "revision", + "sha1", + "sha256", + "status", + "tree-editor", + "worktree-mutation", + "zlib-rs", +] } +jj-lib = { version = "0.44", default-features = false, features = ["git"] } # ────────────────────────────────────────────────────────────────────────────── # AST & Tree-Sitter diff --git a/MODULE.bazel b/MODULE.bazel index 893ccdcfc086..e8ee3de6b5d1 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -205,6 +205,19 @@ crate.annotation( crate = "pcre2-sys", build_script_env = {"PCRE2_SYS_STATIC": "1"}, ) +# sha2-asm's build script compiles SHA-256 assembly with cc-rs flags zig cc +# rejects (the launcher appends its glibc suffix to the rust-style --target +# triple; -march values parse as zig's cpu+feature syntax). The shim rewrites +# both and execs the real $CC. Scoped to the zig-built linux aarch64 triples, +# so apple (host Xcode) builds never see it. +crate.annotation( + crate = "sha2-asm", + build_script_data = ["@@//bazel/toolchains:sha2-asm-cc.sh"], + build_script_env = { + "CC_aarch64_unknown_linux_gnu": "$${pwd}/bazel/toolchains/sha2-asm-cc.sh", + "CC_aarch64_unknown_linux_musl": "$${pwd}/bazel/toolchains/sha2-asm-cc.sh", + }, +) # tree-sitter-just's scanner.c hard-errors when NDEBUG is set (opt-mode cc # default). cc-rs appends env CFLAGS after its computed flags, so -UNDEBUG wins. diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock index 99814485a5be..646fc1e3faa3 100644 --- a/MODULE.bazel.lock +++ b/MODULE.bazel.lock @@ -479,7 +479,7 @@ "@@rules_rust+//crate_universe:extensions.bzl%crate": { "general": { "bzlTransitiveDigest": "4e0uNkFgykXeLgcLZkqWKJbzzSSYqEPlPhfMFR3V4Mw=", - "usagesDigest": "74WputailSckV0+HMkQIzw91NVrFzu07cSn0C9C8D2c=", + "usagesDigest": "I8WHoVZDTxg9Afqzhy390tJfZCtcEL/Ih6kCN2qVDO0=", "recordedInputs": [ "ENV:CARGO_BAZEL_DEBUG \\0", "ENV:CARGO_BAZEL_GENERATOR_SHA256 \\0", @@ -502,15 +502,16 @@ "REPO_MAPPING:rules_rust+,bazel_skylib bazel_skylib+", "REPO_MAPPING:rules_rust+,bazel_tools bazel_tools", "REPO_MAPPING:rules_rust+,rules_cc rules_cc+", - "FILE:@@//Cargo.lock d3dc253128d435936cffb08ceaddf7b2b431e17f2c8f75ae56a6ff325f0c58dc", - "FILE:@@//Cargo.toml a8ef2ea0d3c3a16b26e4894eaf436176eccbb126be74a9606599b31fe998f217", + "FILE:@@//Cargo.lock 2dce00133dd87fa2a4bd98b878b745ffb5a5d4ca2dfd3bb5bf9d66ed1083ca6b", + "FILE:@@//Cargo.toml 206ff5aa12f0040c1b4f71876bdda1a026964668824c63f8e377c3076f931865", "FILE:@@//crates/pi-ast/Cargo.toml c92143c3446eaa79ed71f40fc847df4103fb925bd15f2753428907e71ad0812b", - "FILE:@@//crates/pi-builtins/Cargo.toml ff088283764d2f5e6e4688829ffa48e3664b9a79739b750b1053fd29ae2f313d", + "FILE:@@//crates/pi-builtins/Cargo.toml 6f1ecc3a4335bed37871ec30503e21ab65d796b2621da13f3c49aaa2f4618b72", "FILE:@@//crates/pi-walker/Cargo.toml 29449165412f875914c11ea4af850b2a50ce414a0aee3cf2e29744b91617d711", "FILE:@@//crates/pi-iso/Cargo.toml dd072e047104c2aff9fed7b2ecb60137abe68e94243a40a7dc7bb731bfe8a990", - "FILE:@@//crates/pi-natives/Cargo.toml e76d494bbe6493f63b86f8ca64f7485659c11a5a8e2486ab90a730a621bf3cb6", + "FILE:@@//crates/pi-natives/Cargo.toml 55417d95825256ad2cd5b767c1a8b0afca7d7b3129624fb13e4f45ae322aa701", "FILE:@@//crates/pi-shell/Cargo.toml 8a95bfd01e041ba1feb4c0ab2e4142aacd8d156b62578f67d1975fdb3b18ff00", "FILE:@@//crates/vendor/brush-core/Cargo.toml cc50ec81f548f8ca4a3fd2b280665319dba66df9cbc9bd15c3edd6266bc3269c", + "FILE:@@//crates/pi-vcs/Cargo.toml f16ca5881f0626c86052a986b73255597d697de80b8ab6abd0bf9b18df96999f", "FILE:@@//crates/pi-voice/Cargo.toml afa89598aa320847fc0e799bdd5b3425870a7d614c6d1df841485e2b7c1f303e" ], "generatedRepoSpecs": { @@ -518,9 +519,9 @@ "repoRuleId": "@@rules_rust+//crate_universe/private:crates_vendor.bzl%crates_vendor_remote_repository", "attributes": { "contents": { - "BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nexports_files(\n [\n \"cargo-bazel.json\",\n \"crates.bzl\",\n \"defs.bzl\",\n ] + glob(\n allow_empty = True,\n include = [\"*.bazel\"],\n ),\n)\n\nfilegroup(\n name = \"srcs\",\n srcs = glob(\n allow_empty = True,\n include = [\n \"*.bazel\",\n \"*.bzl\",\n ],\n ),\n)\n\n# Workspace Member Dependencies\nalias(\n name = \"ansi-width-0.1.0\",\n actual = \"@crates__ansi-width-0.1.0//:ansi_width\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ansi-width\",\n actual = \"@crates__ansi-width-0.1.0//:ansi_width\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"anyhow-1.0.104\",\n actual = \"@crates__anyhow-1.0.104//:anyhow\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"anyhow\",\n actual = \"@crates__anyhow-1.0.104//:anyhow\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"arboard-3.6.1\",\n actual = \"@crates__arboard-3.6.1//:arboard\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"arboard\",\n actual = \"@crates__arboard-3.6.1//:arboard\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"argmax-0.3.1\",\n actual = \"@crates__argmax-0.3.1//:argmax\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"argmax\",\n actual = \"@crates__argmax-0.3.1//:argmax\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ashpd-0.11.1\",\n actual = \"@crates__ashpd-0.11.1//:ashpd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ashpd\",\n actual = \"@crates__ashpd-0.11.1//:ashpd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ast-grep-core-0.39.9\",\n actual = \"@crates__ast-grep-core-0.39.9//:ast_grep_core\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ast-grep-core\",\n actual = \"@crates__ast-grep-core-0.39.9//:ast_grep_core\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"async-recursion-1.1.1\",\n actual = \"@crates__async-recursion-1.1.1//:async_recursion\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"async-recursion\",\n actual = \"@crates__async-recursion-1.1.1//:async_recursion\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"async-trait-0.1.92\",\n actual = \"@crates__async-trait-0.1.92//:async_trait\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"async-trait\",\n actual = \"@crates__async-trait-0.1.92//:async_trait\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"atspi-0.30.0\",\n actual = \"@crates__atspi-0.30.0//:atspi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"atspi\",\n actual = \"@crates__atspi-0.30.0//:atspi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"audiopus_sys-0.2.2\",\n actual = \"@crates__audiopus_sys-0.2.2//:audiopus_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"audiopus_sys\",\n actual = \"@crates__audiopus_sys-0.2.2//:audiopus_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"base64-0.22.1\",\n actual = \"@crates__base64-0.22.1//:base64\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"base64\",\n actual = \"@crates__base64-0.22.1//:base64\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bigdecimal-0.4.10\",\n actual = \"@crates__bigdecimal-0.4.10//:bigdecimal\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bigdecimal\",\n actual = \"@crates__bigdecimal-0.4.10//:bigdecimal\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"binary-heap-plus-0.5.0\",\n actual = \"@crates__binary-heap-plus-0.5.0//:binary_heap_plus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"binary-heap-plus\",\n actual = \"@crates__binary-heap-plus-0.5.0//:binary_heap_plus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bon-3.9.3\",\n actual = \"@crates__bon-3.9.3//:bon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bon\",\n actual = \"@crates__bon-3.9.3//:bon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"brush-parser-0.3.0\",\n actual = \"@crates__brush-parser-0.3.0//:brush_parser\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"brush-parser-0.4.0\",\n actual = \"@crates__brush-parser-0.4.0//:brush_parser\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bstr-1.13.1\",\n actual = \"@crates__bstr-1.13.1//:bstr\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bstr\",\n actual = \"@crates__bstr-1.13.1//:bstr\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bytecount-0.6.9\",\n actual = \"@crates__bytecount-0.6.9//:bytecount\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bytecount\",\n actual = \"@crates__bytecount-0.6.9//:bytecount\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bytes-1.12.1\",\n actual = \"@crates__bytes-1.12.1//:bytes\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bytes\",\n actual = \"@crates__bytes-1.12.1//:bytes\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"cached-0.59.0\",\n actual = \"@crates__cached-0.59.0//:cached\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"cached\",\n actual = \"@crates__cached-0.59.0//:cached\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"cfg-if-1.0.4\",\n actual = \"@crates__cfg-if-1.0.4//:cfg_if\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"cfg-if\",\n actual = \"@crates__cfg-if-1.0.4//:cfg_if\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"check_elevation-0.2.7\",\n actual = \"@crates__check_elevation-0.2.7//:check_elevation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"check_elevation\",\n actual = \"@crates__check_elevation-0.2.7//:check_elevation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"chrono-0.4.45\",\n actual = \"@crates__chrono-0.4.45//:chrono\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"chrono\",\n actual = \"@crates__chrono-0.4.45//:chrono\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap-4.6.6\",\n actual = \"@crates__clap-4.6.6//:clap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap\",\n actual = \"@crates__clap-4.6.6//:clap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clipboard-win-5.4.1\",\n actual = \"@crates__clipboard-win-5.4.1//:clipboard_win\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clipboard-win\",\n actual = \"@crates__clipboard-win-5.4.1//:clipboard_win\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"codesnake-0.2.1\",\n actual = \"@crates__codesnake-0.2.1//:codesnake\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"codesnake\",\n actual = \"@crates__codesnake-0.2.1//:codesnake\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"color-print-0.3.7\",\n actual = \"@crates__color-print-0.3.7//:color_print\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"color-print\",\n actual = \"@crates__color-print-0.3.7//:color_print\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"command-fds-0.3.3\",\n actual = \"@crates__command-fds-0.3.3//:command_fds\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"command-fds\",\n actual = \"@crates__command-fds-0.3.3//:command_fds\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"compare-0.1.0\",\n actual = \"@crates__compare-0.1.0//:compare\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"compare\",\n actual = \"@crates__compare-0.1.0//:compare\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"core-graphics-0.25.0\",\n actual = \"@crates__core-graphics-0.25.0//:core_graphics\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"core-graphics\",\n actual = \"@crates__core-graphics-0.25.0//:core_graphics\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"dashmap-6.2.1\",\n actual = \"@crates__dashmap-6.2.1//:dashmap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"dashmap\",\n actual = \"@crates__dashmap-6.2.1//:dashmap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"dns-lookup-3.0.1\",\n actual = \"@crates__dns-lookup-3.0.1//:dns_lookup\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"dns-lookup\",\n actual = \"@crates__dns-lookup-3.0.1//:dns_lookup\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"enigo-0.6.1\",\n actual = \"@crates__enigo-0.6.1//:enigo\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"enigo\",\n actual = \"@crates__enigo-0.6.1//:enigo\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"faccess-0.2.4\",\n actual = \"@crates__faccess-0.2.4//:faccess\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"faccess\",\n actual = \"@crates__faccess-0.2.4//:faccess\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fancy-regex-0.16.2\",\n actual = \"@crates__fancy-regex-0.16.2//:fancy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fancy-regex-0.17.0\",\n actual = \"@crates__fancy-regex-0.17.0//:fancy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"filetime-0.2.29\",\n actual = \"@crates__filetime-0.2.29//:filetime\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"filetime\",\n actual = \"@crates__filetime-0.2.29//:filetime\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"flume-0.11.1\",\n actual = \"@crates__flume-0.11.1//:flume\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"flume\",\n actual = \"@crates__flume-0.11.1//:flume\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"foldhash-0.2.0\",\n actual = \"@crates__foldhash-0.2.0//:foldhash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"foldhash\",\n actual = \"@crates__foldhash-0.2.0//:foldhash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fontdue-0.9.4\",\n actual = \"@crates__fontdue-0.9.4//:fontdue\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fontdue\",\n actual = \"@crates__fontdue-0.9.4//:fontdue\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"foreign-types-0.5.0\",\n actual = \"@crates__foreign-types-0.5.0//:foreign_types\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"foreign-types\",\n actual = \"@crates__foreign-types-0.5.0//:foreign_types\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fs_extra-1.3.0\",\n actual = \"@crates__fs_extra-1.3.0//:fs_extra\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fs_extra\",\n actual = \"@crates__fs_extra-1.3.0//:fs_extra\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"futures-0.3.34\",\n actual = \"@crates__futures-0.3.34//:futures\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"futures\",\n actual = \"@crates__futures-0.3.34//:futures\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"getrandom-0.4.3\",\n actual = \"@crates__getrandom-0.4.3//:getrandom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"getrandom\",\n actual = \"@crates__getrandom-0.4.3//:getrandom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"glob-0.3.4\",\n actual = \"@crates__glob-0.3.4//:glob\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"glob\",\n actual = \"@crates__glob-0.3.4//:glob\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"globset-0.4.20\",\n actual = \"@crates__globset-0.4.20//:globset\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"globset\",\n actual = \"@crates__globset-0.4.20//:globset\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-cli-0.1.12\",\n actual = \"@crates__grep-cli-0.1.12//:grep_cli\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-cli\",\n actual = \"@crates__grep-cli-0.1.12//:grep_cli\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-matcher-0.1.9\",\n actual = \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-matcher\",\n actual = \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-pcre2-0.1.10\",\n actual = \"@crates__grep-pcre2-0.1.10//:grep_pcre2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-pcre2\",\n actual = \"@crates__grep-pcre2-0.1.10//:grep_pcre2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-printer-0.3.1\",\n actual = \"@crates__grep-printer-0.3.1//:grep_printer\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-printer\",\n actual = \"@crates__grep-printer-0.3.1//:grep_printer\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-regex-0.1.14\",\n actual = \"@crates__grep-regex-0.1.14//:grep_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-regex\",\n actual = \"@crates__grep-regex-0.1.14//:grep_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-searcher-0.1.17\",\n actual = \"@crates__grep-searcher-0.1.17//:grep_searcher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-searcher\",\n actual = \"@crates__grep-searcher-0.1.17//:grep_searcher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"heapless-0.9.3\",\n actual = \"@crates__heapless-0.9.3//:heapless\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"heapless\",\n actual = \"@crates__heapless-0.9.3//:heapless\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hex-0.4.3\",\n actual = \"@crates__hex-0.4.3//:hex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hex\",\n actual = \"@crates__hex-0.4.3//:hex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hifijson-0.2.3\",\n actual = \"@crates__hifijson-0.2.3//:hifijson\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hifijson\",\n actual = \"@crates__hifijson-0.2.3//:hifijson\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hostname-0.4.2\",\n actual = \"@crates__hostname-0.4.2//:hostname\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hostname\",\n actual = \"@crates__hostname-0.4.2//:hostname\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"html-to-markdown-rs-3.11.3\",\n actual = \"@crates__html-to-markdown-rs-3.11.3//:html_to_markdown_rs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"html-to-markdown-rs\",\n actual = \"@crates__html-to-markdown-rs-3.11.3//:html_to_markdown_rs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"icy_sixel-0.5.1\",\n actual = \"@crates__icy_sixel-0.5.1//:icy_sixel\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"icy_sixel\",\n actual = \"@crates__icy_sixel-0.5.1//:icy_sixel\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ignore-0.4.33\",\n actual = \"@crates__ignore-0.4.33//:ignore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ignore\",\n actual = \"@crates__ignore-0.4.33//:ignore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"image-0.25.10\",\n actual = \"@crates__image-0.25.10//:image\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"image\",\n actual = \"@crates__image-0.25.10//:image\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"indicatif-0.18.6\",\n actual = \"@crates__indicatif-0.18.6//:indicatif\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"indicatif\",\n actual = \"@crates__indicatif-0.18.6//:indicatif\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"inferno-0.12.8\",\n actual = \"@crates__inferno-0.12.8//:inferno\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"inferno\",\n actual = \"@crates__inferno-0.12.8//:inferno\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"inherent-1.0.14\",\n actual = \"@crates__inherent-1.0.14//:inherent\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"inherent\",\n actual = \"@crates__inherent-1.0.14//:inherent\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"itertools-0.14.0\",\n actual = \"@crates__itertools-0.14.0//:itertools\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"itertools\",\n actual = \"@crates__itertools-0.14.0//:itertools\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-core-2.2.1\",\n actual = \"@crates__jaq-core-2.2.1//:jaq_core\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-core\",\n actual = \"@crates__jaq-core-2.2.1//:jaq_core\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-json-1.1.3\",\n actual = \"@crates__jaq-json-1.1.3//:jaq_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-json\",\n actual = \"@crates__jaq-json-1.1.3//:jaq_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-std-2.1.2\",\n actual = \"@crates__jaq-std-2.1.2//:jaq_std\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-std\",\n actual = \"@crates__jaq-std-2.1.2//:jaq_std\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jiff-0.2.35\",\n actual = \"@crates__jiff-0.2.35//:jiff\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jiff\",\n actual = \"@crates__jiff-0.2.35//:jiff\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"libc-0.2.189\",\n actual = \"@crates__libc-0.2.189//:libc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"libc\",\n actual = \"@crates__libc-0.2.189//:libc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lscolors-0.21.0\",\n actual = \"@crates__lscolors-0.21.0//:lscolors\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lscolors\",\n actual = \"@crates__lscolors-0.21.0//:lscolors\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"memchr-2.8.3\",\n actual = \"@crates__memchr-2.8.3//:memchr\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"memchr\",\n actual = \"@crates__memchr-2.8.3//:memchr\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"memmap2-0.9.11\",\n actual = \"@crates__memmap2-0.9.11//:memmap2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"memmap2\",\n actual = \"@crates__memmap2-0.9.11//:memmap2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi-3.12.2\",\n actual = \"@crates__napi-3.12.2//:napi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi\",\n actual = \"@crates__napi-3.12.2//:napi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi-build-2.4.1\",\n actual = \"@crates__napi-build-2.4.1//:napi_build\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi-build\",\n actual = \"@crates__napi-build-2.4.1//:napi_build\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi-derive-3.6.3\",\n actual = \"@crates__napi-derive-3.6.3//:napi_derive\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi-derive\",\n actual = \"@crates__napi-derive-3.6.3//:napi_derive\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nix-0.31.3\",\n actual = \"@crates__nix-0.31.3//:nix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nix\",\n actual = \"@crates__nix-0.31.3//:nix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nom-8.0.0\",\n actual = \"@crates__nom-8.0.0//:nom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nom\",\n actual = \"@crates__nom-8.0.0//:nom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"normalize-path-0.2.1\",\n actual = \"@crates__normalize-path-0.2.1//:normalize_path\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"normalize-path\",\n actual = \"@crates__normalize-path-0.2.1//:normalize_path\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"notify-8.2.0\",\n actual = \"@crates__notify-8.2.0//:notify\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"notify\",\n actual = \"@crates__notify-8.2.0//:notify\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"num-bigint-0.4.8\",\n actual = \"@crates__num-bigint-0.4.8//:num_bigint\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"num-bigint\",\n actual = \"@crates__num-bigint-0.4.8//:num_bigint\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"num-traits-0.2.19\",\n actual = \"@crates__num-traits-0.2.19//:num_traits\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"num-traits\",\n actual = \"@crates__num-traits-0.2.19//:num_traits\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-0.6.4\",\n actual = \"@crates__objc2-0.6.4//:objc2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2\",\n actual = \"@crates__objc2-0.6.4//:objc2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-app-kit-0.3.2\",\n actual = \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-app-kit\",\n actual = \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-application-services-0.3.2\",\n actual = \"@crates__objc2-application-services-0.3.2//:objc2_application_services\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-application-services\",\n actual = \"@crates__objc2-application-services-0.3.2//:objc2_application_services\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-core-foundation-0.3.2\",\n actual = \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-core-foundation\",\n actual = \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-core-graphics-0.3.2\",\n actual = \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-core-graphics\",\n actual = \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-foundation-0.3.2\",\n actual = \"@crates__objc2-foundation-0.3.2//:objc2_foundation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-foundation\",\n actual = \"@crates__objc2-foundation-0.3.2//:objc2_foundation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"onig-6.5.3\",\n actual = \"@crates__onig-6.5.3//:onig\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"onig\",\n actual = \"@crates__onig-6.5.3//:onig\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"opus-0.3.1\",\n actual = \"@crates__opus-0.3.1//:opus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"opus\",\n actual = \"@crates__opus-0.3.1//:opus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"os_display-0.1.4\",\n actual = \"@crates__os_display-0.1.4//:os_display\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"os_display\",\n actual = \"@crates__os_display-0.1.4//:os_display\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"os_pipe-1.2.3\",\n actual = \"@crates__os_pipe-1.2.3//:os_pipe\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"os_pipe\",\n actual = \"@crates__os_pipe-1.2.3//:os_pipe\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"parking_lot-0.12.5\",\n actual = \"@crates__parking_lot-0.12.5//:parking_lot\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"parking_lot\",\n actual = \"@crates__parking_lot-0.12.5//:parking_lot\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"parse_datetime-0.14.0\",\n actual = \"@crates__parse_datetime-0.14.0//:parse_datetime\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"parse_datetime\",\n actual = \"@crates__parse_datetime-0.14.0//:parse_datetime\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pdf-inspector-1.17.0\",\n actual = \"@crates__pdf-inspector-1.17.0//:pdf_inspector\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pdf-inspector\",\n actual = \"@crates__pdf-inspector-1.17.0//:pdf_inspector\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"phf-0.13.1\",\n actual = \"@crates__phf-0.13.1//:phf\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"phf\",\n actual = \"@crates__phf-0.13.1//:phf\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pi-shell-18.0.0\",\n actual = \"@crates__pi-shell-18.0.0//:pi_shell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pi-shell\",\n actual = \"@crates__pi-shell-18.0.0//:pi_shell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"platform-info-2.1.0\",\n actual = \"@crates__platform-info-2.1.0//:platform_info\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"platform-info\",\n actual = \"@crates__platform-info-2.1.0//:platform_info\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"png-0.18.1\",\n actual = \"@crates__png-0.18.1//:png\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"png\",\n actual = \"@crates__png-0.18.1//:png\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"portable-pty-0.9.0\",\n actual = \"@crates__portable-pty-0.9.0//:portable_pty\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"portable-pty\",\n actual = \"@crates__portable-pty-0.9.0//:portable_pty\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pretty_assertions-1.4.1\",\n actual = \"@crates__pretty_assertions-1.4.1//:pretty_assertions\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pretty_assertions\",\n actual = \"@crates__pretty_assertions-1.4.1//:pretty_assertions\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"procfs-0.18.0\",\n actual = \"@crates__procfs-0.18.0//:procfs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"procfs\",\n actual = \"@crates__procfs-0.18.0//:procfs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rand-0.10.2\",\n actual = \"@crates__rand-0.10.2//:rand\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rand\",\n actual = \"@crates__rand-0.10.2//:rand\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rayon-1.12.0\",\n actual = \"@crates__rayon-1.12.0//:rayon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rayon\",\n actual = \"@crates__rayon-1.12.0//:rayon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex-1.13.1\",\n actual = \"@crates__regex-1.13.1//:regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex\",\n actual = \"@crates__regex-1.13.1//:regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"reis-0.5.0\",\n actual = \"@crates__reis-0.5.0//:reis\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"reis\",\n actual = \"@crates__reis-0.5.0//:reis\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rlimit-0.11.0\",\n actual = \"@crates__rlimit-0.11.0//:rlimit\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rlimit\",\n actual = \"@crates__rlimit-0.11.0//:rlimit\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rpds-1.2.1\",\n actual = \"@crates__rpds-1.2.1//:rpds\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rpds\",\n actual = \"@crates__rpds-1.2.1//:rpds\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rustc-hash-2.1.3\",\n actual = \"@crates__rustc-hash-2.1.3//:rustc_hash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rustc-hash\",\n actual = \"@crates__rustc-hash-2.1.3//:rustc_hash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rustix-1.1.4\",\n actual = \"@crates__rustix-1.1.4//:rustix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rustix\",\n actual = \"@crates__rustix-1.1.4//:rustix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"self_cell-1.3.0\",\n actual = \"@crates__self_cell-1.3.0//:self_cell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"self_cell\",\n actual = \"@crates__self_cell-1.3.0//:self_cell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde-1.0.229\",\n actual = \"@crates__serde-1.0.229//:serde\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde\",\n actual = \"@crates__serde-1.0.229//:serde\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_json-1.0.151\",\n actual = \"@crates__serde_json-1.0.151//:serde_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_json\",\n actual = \"@crates__serde_json-1.0.151//:serde_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"similar-3.2.0\",\n actual = \"@crates__similar-3.2.0//:similar\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"similar\",\n actual = \"@crates__similar-3.2.0//:similar\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"smallvec-1.15.2\",\n actual = \"@crates__smallvec-1.15.2//:smallvec\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"smallvec\",\n actual = \"@crates__smallvec-1.15.2//:smallvec\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum-0.28.0\",\n actual = \"@crates__strum-0.28.0//:strum\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum\",\n actual = \"@crates__strum-0.28.0//:strum\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum_macros-0.28.0\",\n actual = \"@crates__strum_macros-0.28.0//:strum_macros\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum_macros\",\n actual = \"@crates__strum_macros-0.28.0//:strum_macros\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"syntect-5.3.0\",\n actual = \"@crates__syntect-5.3.0//:syntect\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"syntect\",\n actual = \"@crates__syntect-5.3.0//:syntect\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tempfile-3.27.0\",\n actual = \"@crates__tempfile-3.27.0//:tempfile\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tempfile\",\n actual = \"@crates__tempfile-3.27.0//:tempfile\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"terminfo-0.9.0\",\n actual = \"@crates__terminfo-0.9.0//:terminfo\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"terminfo\",\n actual = \"@crates__terminfo-0.9.0//:terminfo\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"thiserror-2.0.20\",\n actual = \"@crates__thiserror-2.0.20//:thiserror\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"thiserror\",\n actual = \"@crates__thiserror-2.0.20//:thiserror\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tiktoken-rs-0.11.0\",\n actual = \"@crates__tiktoken-rs-0.11.0//:tiktoken_rs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tiktoken-rs\",\n actual = \"@crates__tiktoken-rs-0.11.0//:tiktoken_rs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tokio-1.53.1\",\n actual = \"@crates__tokio-1.53.1//:tokio\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tokio\",\n actual = \"@crates__tokio-1.53.1//:tokio\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tokio-util-0.7.19\",\n actual = \"@crates__tokio-util-0.7.19//:tokio_util\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tokio-util\",\n actual = \"@crates__tokio-util-0.7.19//:tokio_util\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"toml-1.1.4+spec-1.1.0\",\n actual = \"@crates__toml-1.1.4-spec-1.1.0//:toml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"toml\",\n actual = \"@crates__toml-1.1.4-spec-1.1.0//:toml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tracing-0.1.44\",\n actual = \"@crates__tracing-0.1.44//:tracing\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tracing\",\n actual = \"@crates__tracing-0.1.44//:tracing\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-0.25.10\",\n actual = \"@crates__tree-sitter-0.25.10//:tree_sitter\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter\",\n actual = \"@crates__tree-sitter-0.25.10//:tree_sitter\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-astro-next-0.1.1\",\n actual = \"@crates__tree-sitter-astro-next-0.1.1//:tree_sitter_astro_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_astro-0.1.1\",\n actual = \"@crates__tree-sitter-astro-next-0.1.1//:tree_sitter_astro_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_astro\",\n actual = \"@crates__tree-sitter-astro-next-0.1.1//:tree_sitter_astro_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-bash-0.25.1\",\n actual = \"@crates__tree-sitter-bash-0.25.1//:tree_sitter_bash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-bash\",\n actual = \"@crates__tree-sitter-bash-0.25.1//:tree_sitter_bash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-c-0.24.2\",\n actual = \"@crates__tree-sitter-c-0.24.2//:tree_sitter_c\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-c\",\n actual = \"@crates__tree-sitter-c-0.24.2//:tree_sitter_c\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-c-sharp-0.23.5\",\n actual = \"@crates__tree-sitter-c-sharp-0.23.5//:tree_sitter_c_sharp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-c-sharp\",\n actual = \"@crates__tree-sitter-c-sharp-0.23.5//:tree_sitter_c_sharp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-clojure-0.1.0\",\n actual = \"@crates__tree-sitter-clojure-0.1.0//:tree_sitter_clojure\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-clojure\",\n actual = \"@crates__tree-sitter-clojure-0.1.0//:tree_sitter_clojure\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-cmake-0.7.4\",\n actual = \"@crates__tree-sitter-cmake-0.7.4//:tree_sitter_cmake\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-cmake\",\n actual = \"@crates__tree-sitter-cmake-0.7.4//:tree_sitter_cmake\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-cpp-0.23.4\",\n actual = \"@crates__tree-sitter-cpp-0.23.4//:tree_sitter_cpp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-cpp\",\n actual = \"@crates__tree-sitter-cpp-0.23.4//:tree_sitter_cpp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-css-0.25.0\",\n actual = \"@crates__tree-sitter-css-0.25.0//:tree_sitter_css\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-css\",\n actual = \"@crates__tree-sitter-css-0.25.0//:tree_sitter_css\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-dart-0.2.0\",\n actual = \"@crates__tree-sitter-dart-0.2.0//:tree_sitter_dart\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-dart\",\n actual = \"@crates__tree-sitter-dart-0.2.0//:tree_sitter_dart\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-diff-0.1.0\",\n actual = \"@crates__tree-sitter-diff-0.1.0//:tree_sitter_diff\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-diff\",\n actual = \"@crates__tree-sitter-diff-0.1.0//:tree_sitter_diff\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-dockerfile-updated-0.2.0\",\n actual = \"@crates__tree-sitter-dockerfile-updated-0.2.0//:tree_sitter_dockerfile_updated\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_dockerfile-0.2.0\",\n actual = \"@crates__tree-sitter-dockerfile-updated-0.2.0//:tree_sitter_dockerfile_updated\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_dockerfile\",\n actual = \"@crates__tree-sitter-dockerfile-updated-0.2.0//:tree_sitter_dockerfile_updated\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-elisp-1.7.2\",\n actual = \"@crates__tree-sitter-elisp-1.7.2//:tree_sitter_elisp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-elisp\",\n actual = \"@crates__tree-sitter-elisp-1.7.2//:tree_sitter_elisp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-elixir-0.3.5\",\n actual = \"@crates__tree-sitter-elixir-0.3.5//:tree_sitter_elixir\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-elixir\",\n actual = \"@crates__tree-sitter-elixir-0.3.5//:tree_sitter_elixir\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-erlang-0.16.0\",\n actual = \"@crates__tree-sitter-erlang-0.16.0//:tree_sitter_erlang\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-erlang\",\n actual = \"@crates__tree-sitter-erlang-0.16.0//:tree_sitter_erlang\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-fortran-0.6.0\",\n actual = \"@crates__tree-sitter-fortran-0.6.0//:tree_sitter_fortran\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-fortran\",\n actual = \"@crates__tree-sitter-fortran-0.6.0//:tree_sitter_fortran\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-go-0.25.0\",\n actual = \"@crates__tree-sitter-go-0.25.0//:tree_sitter_go\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-go\",\n actual = \"@crates__tree-sitter-go-0.25.0//:tree_sitter_go\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-graphql-0.1.0\",\n actual = \"@crates__tree-sitter-graphql-0.1.0//:tree_sitter_graphql\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-graphql\",\n actual = \"@crates__tree-sitter-graphql-0.1.0//:tree_sitter_graphql\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-haskell-0.23.1\",\n actual = \"@crates__tree-sitter-haskell-0.23.1//:tree_sitter_haskell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-haskell\",\n actual = \"@crates__tree-sitter-haskell-0.23.1//:tree_sitter_haskell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-hcl-1.1.0\",\n actual = \"@crates__tree-sitter-hcl-1.1.0//:tree_sitter_hcl\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-hcl\",\n actual = \"@crates__tree-sitter-hcl-1.1.0//:tree_sitter_hcl\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-html-0.23.2\",\n actual = \"@crates__tree-sitter-html-0.23.2//:tree_sitter_html\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-html\",\n actual = \"@crates__tree-sitter-html-0.23.2//:tree_sitter_html\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ini-1.4.0\",\n actual = \"@crates__tree-sitter-ini-1.4.0//:tree_sitter_ini\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ini\",\n actual = \"@crates__tree-sitter-ini-1.4.0//:tree_sitter_ini\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-java-0.23.5\",\n actual = \"@crates__tree-sitter-java-0.23.5//:tree_sitter_java\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-java\",\n actual = \"@crates__tree-sitter-java-0.23.5//:tree_sitter_java\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-javascript-0.25.0\",\n actual = \"@crates__tree-sitter-javascript-0.25.0//:tree_sitter_javascript\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-javascript\",\n actual = \"@crates__tree-sitter-javascript-0.25.0//:tree_sitter_javascript\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-json-0.24.8\",\n actual = \"@crates__tree-sitter-json-0.24.8//:tree_sitter_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-json\",\n actual = \"@crates__tree-sitter-json-0.24.8//:tree_sitter_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-julia-0.23.1\",\n actual = \"@crates__tree-sitter-julia-0.23.1//:tree_sitter_julia\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-julia\",\n actual = \"@crates__tree-sitter-julia-0.23.1//:tree_sitter_julia\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-just-0.2.0\",\n actual = \"@crates__tree-sitter-just-0.2.0//:tree_sitter_just\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-just\",\n actual = \"@crates__tree-sitter-just-0.2.0//:tree_sitter_just\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-kotlin-sg-0.4.1\",\n actual = \"@crates__tree-sitter-kotlin-sg-0.4.1//:tree_sitter_kotlin_sg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_kotlin-0.4.1\",\n actual = \"@crates__tree-sitter-kotlin-sg-0.4.1//:tree_sitter_kotlin_sg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_kotlin\",\n actual = \"@crates__tree-sitter-kotlin-sg-0.4.1//:tree_sitter_kotlin_sg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-lua-0.5.0\",\n actual = \"@crates__tree-sitter-lua-0.5.0//:tree_sitter_lua\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-lua\",\n actual = \"@crates__tree-sitter-lua-0.5.0//:tree_sitter_lua\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-make-1.1.1\",\n actual = \"@crates__tree-sitter-make-1.1.1//:tree_sitter_make\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-make\",\n actual = \"@crates__tree-sitter-make-1.1.1//:tree_sitter_make\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-md-0.5.3\",\n actual = \"@crates__tree-sitter-md-0.5.3//:tree_sitter_md\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-md\",\n actual = \"@crates__tree-sitter-md-0.5.3//:tree_sitter_md\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-nix-0.3.0\",\n actual = \"@crates__tree-sitter-nix-0.3.0//:tree_sitter_nix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-nix\",\n actual = \"@crates__tree-sitter-nix-0.3.0//:tree_sitter_nix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-objc-3.0.2\",\n actual = \"@crates__tree-sitter-objc-3.0.2//:tree_sitter_objc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-objc\",\n actual = \"@crates__tree-sitter-objc-3.0.2//:tree_sitter_objc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ocaml-0.24.2\",\n actual = \"@crates__tree-sitter-ocaml-0.24.2//:tree_sitter_ocaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ocaml\",\n actual = \"@crates__tree-sitter-ocaml-0.24.2//:tree_sitter_ocaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-odin-1.3.0\",\n actual = \"@crates__tree-sitter-odin-1.3.0//:tree_sitter_odin\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-odin\",\n actual = \"@crates__tree-sitter-odin-1.3.0//:tree_sitter_odin\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-php-0.24.2\",\n actual = \"@crates__tree-sitter-php-0.24.2//:tree_sitter_php\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-php\",\n actual = \"@crates__tree-sitter-php-0.24.2//:tree_sitter_php\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-powershell-0.26.4\",\n actual = \"@crates__tree-sitter-powershell-0.26.4//:tree_sitter_powershell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-powershell\",\n actual = \"@crates__tree-sitter-powershell-0.26.4//:tree_sitter_powershell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-proto-0.4.0\",\n actual = \"@crates__tree-sitter-proto-0.4.0//:tree_sitter_proto\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-proto\",\n actual = \"@crates__tree-sitter-proto-0.4.0//:tree_sitter_proto\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-python-0.25.0\",\n actual = \"@crates__tree-sitter-python-0.25.0//:tree_sitter_python\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-python\",\n actual = \"@crates__tree-sitter-python-0.25.0//:tree_sitter_python\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-r-1.3.0\",\n actual = \"@crates__tree-sitter-r-1.3.0//:tree_sitter_r\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-r\",\n actual = \"@crates__tree-sitter-r-1.3.0//:tree_sitter_r\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-regex-0.25.0\",\n actual = \"@crates__tree-sitter-regex-0.25.0//:tree_sitter_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-regex\",\n actual = \"@crates__tree-sitter-regex-0.25.0//:tree_sitter_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ruby-0.23.1\",\n actual = \"@crates__tree-sitter-ruby-0.23.1//:tree_sitter_ruby\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ruby\",\n actual = \"@crates__tree-sitter-ruby-0.23.1//:tree_sitter_ruby\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-rust-0.24.2\",\n actual = \"@crates__tree-sitter-rust-0.24.2//:tree_sitter_rust\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-rust\",\n actual = \"@crates__tree-sitter-rust-0.24.2//:tree_sitter_rust\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-scala-0.26.2\",\n actual = \"@crates__tree-sitter-scala-0.26.2//:tree_sitter_scala\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-scala\",\n actual = \"@crates__tree-sitter-scala-0.26.2//:tree_sitter_scala\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-sequel-0.3.11\",\n actual = \"@crates__tree-sitter-sequel-0.3.11//:tree_sitter_sequel\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_sql-0.3.11\",\n actual = \"@crates__tree-sitter-sequel-0.3.11//:tree_sitter_sequel\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_sql\",\n actual = \"@crates__tree-sitter-sequel-0.3.11//:tree_sitter_sequel\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-solidity-1.2.13\",\n actual = \"@crates__tree-sitter-solidity-1.2.13//:tree_sitter_solidity\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-solidity\",\n actual = \"@crates__tree-sitter-solidity-1.2.13//:tree_sitter_solidity\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-starlark-1.3.0\",\n actual = \"@crates__tree-sitter-starlark-1.3.0//:tree_sitter_starlark\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-starlark\",\n actual = \"@crates__tree-sitter-starlark-1.3.0//:tree_sitter_starlark\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-svelte-next-0.1.1\",\n actual = \"@crates__tree-sitter-svelte-next-0.1.1//:tree_sitter_svelte_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_svelte-0.1.1\",\n actual = \"@crates__tree-sitter-svelte-next-0.1.1//:tree_sitter_svelte_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_svelte\",\n actual = \"@crates__tree-sitter-svelte-next-0.1.1//:tree_sitter_svelte_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-swift-0.7.3\",\n actual = \"@crates__tree-sitter-swift-0.7.3//:tree_sitter_swift\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-swift\",\n actual = \"@crates__tree-sitter-swift-0.7.3//:tree_sitter_swift\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-tlaplus-1.5.0\",\n actual = \"@crates__tree-sitter-tlaplus-1.5.0//:tree_sitter_tlaplus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-tlaplus\",\n actual = \"@crates__tree-sitter-tlaplus-1.5.0//:tree_sitter_tlaplus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-toml-ng-0.7.0\",\n actual = \"@crates__tree-sitter-toml-ng-0.7.0//:tree_sitter_toml_ng\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-toml-ng\",\n actual = \"@crates__tree-sitter-toml-ng-0.7.0//:tree_sitter_toml_ng\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-typescript-0.23.2\",\n actual = \"@crates__tree-sitter-typescript-0.23.2//:tree_sitter_typescript\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-typescript\",\n actual = \"@crates__tree-sitter-typescript-0.23.2//:tree_sitter_typescript\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-verilog-1.0.3\",\n actual = \"@crates__tree-sitter-verilog-1.0.3//:tree_sitter_verilog\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-verilog\",\n actual = \"@crates__tree-sitter-verilog-1.0.3//:tree_sitter_verilog\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-vue-next-0.1.0\",\n actual = \"@crates__tree-sitter-vue-next-0.1.0//:tree_sitter_vue_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_vue-0.1.0\",\n actual = \"@crates__tree-sitter-vue-next-0.1.0//:tree_sitter_vue_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_vue\",\n actual = \"@crates__tree-sitter-vue-next-0.1.0//:tree_sitter_vue_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-xml-0.7.0\",\n actual = \"@crates__tree-sitter-xml-0.7.0//:tree_sitter_xml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-xml\",\n actual = \"@crates__tree-sitter-xml-0.7.0//:tree_sitter_xml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-yaml-0.7.2\",\n actual = \"@crates__tree-sitter-yaml-0.7.2//:tree_sitter_yaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-yaml\",\n actual = \"@crates__tree-sitter-yaml-0.7.2//:tree_sitter_yaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-zig-1.1.2\",\n actual = \"@crates__tree-sitter-zig-1.1.2//:tree_sitter_zig\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-zig\",\n actual = \"@crates__tree-sitter-zig-1.1.2//:tree_sitter_zig\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uiautomation-0.25.0\",\n actual = \"@crates__uiautomation-0.25.0//:uiautomation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uiautomation\",\n actual = \"@crates__uiautomation-0.25.0//:uiautomation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uucore-0.8.0\",\n actual = \"@crates__uucore-0.8.0//:uucore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uucore\",\n actual = \"@crates__uucore-0.8.0//:uucore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uuid-1.24.1\",\n actual = \"@crates__uuid-1.24.1//:uuid\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uuid\",\n actual = \"@crates__uuid-1.24.1//:uuid\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uutils_term_grid-0.8.0\",\n actual = \"@crates__uutils_term_grid-0.8.0//:term_grid\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uutils_term_grid\",\n actual = \"@crates__uutils_term_grid-0.8.0//:term_grid\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uzers-0.12.2\",\n actual = \"@crates__uzers-0.12.2//:uzers\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uzers\",\n actual = \"@crates__uzers-0.12.2//:uzers\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"webrtc-0.17.2\",\n actual = \"@crates__webrtc-0.17.2//:webrtc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"webrtc\",\n actual = \"@crates__webrtc-0.17.2//:webrtc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"whoami-2.1.3\",\n actual = \"@crates__whoami-2.1.3//:whoami\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"whoami\",\n actual = \"@crates__whoami-2.1.3//:whoami\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"windows-sys-0.59.0\",\n actual = \"@crates__windows-sys-0.59.0//:windows_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"windows-sys-0.61.2\",\n actual = \"@crates__windows-sys-0.61.2//:windows_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"winreg-0.56.0\",\n actual = \"@crates__winreg-0.56.0//:winreg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"winreg\",\n actual = \"@crates__winreg-0.56.0//:winreg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"x11rb-0.13.2\",\n actual = \"@crates__x11rb-0.13.2//:x11rb\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"x11rb\",\n actual = \"@crates__x11rb-0.13.2//:x11rb\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xcap-0.9.6\",\n actual = \"@crates__xcap-0.9.6//:xcap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xcap\",\n actual = \"@crates__xcap-0.9.6//:xcap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xkeysym-0.2.1\",\n actual = \"@crates__xkeysym-0.2.1//:xkeysym\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xkeysym\",\n actual = \"@crates__xkeysym-0.2.1//:xkeysym\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xutf-1.4.0\",\n actual = \"@crates__xutf-1.4.0//:xutf\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xutf\",\n actual = \"@crates__xutf-1.4.0//:xutf\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xxhash-rust-0.8.18\",\n actual = \"@crates__xxhash-rust-0.8.18//:xxhash_rust\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xxhash-rust\",\n actual = \"@crates__xxhash-rust-0.8.18//:xxhash_rust\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"yansi-1.0.1\",\n actual = \"@crates__yansi-1.0.1//:yansi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"yansi\",\n actual = \"@crates__yansi-1.0.1//:yansi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"zstd-0.13.3\",\n actual = \"@crates__zstd-0.13.3//:zstd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"zstd\",\n actual = \"@crates__zstd-0.13.3//:zstd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"zune-jpeg-0.5.15\",\n actual = \"@crates__zune-jpeg-0.5.15//:zune_jpeg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"zune-jpeg\",\n actual = \"@crates__zune-jpeg-0.5.15//:zune_jpeg\",\n tags = [\"manual\"],\n)\n", + "BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nexports_files(\n [\n \"cargo-bazel.json\",\n \"crates.bzl\",\n \"defs.bzl\",\n ] + glob(\n allow_empty = True,\n include = [\"*.bazel\"],\n ),\n)\n\nfilegroup(\n name = \"srcs\",\n srcs = glob(\n allow_empty = True,\n include = [\n \"*.bazel\",\n \"*.bzl\",\n ],\n ),\n)\n\n# Workspace Member Dependencies\nalias(\n name = \"ansi-width-0.1.0\",\n actual = \"@crates__ansi-width-0.1.0//:ansi_width\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ansi-width\",\n actual = \"@crates__ansi-width-0.1.0//:ansi_width\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"anyhow-1.0.104\",\n actual = \"@crates__anyhow-1.0.104//:anyhow\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"anyhow\",\n actual = \"@crates__anyhow-1.0.104//:anyhow\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"arboard-3.6.1\",\n actual = \"@crates__arboard-3.6.1//:arboard\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"arboard\",\n actual = \"@crates__arboard-3.6.1//:arboard\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"argmax-0.3.1\",\n actual = \"@crates__argmax-0.3.1//:argmax\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"argmax\",\n actual = \"@crates__argmax-0.3.1//:argmax\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ashpd-0.11.1\",\n actual = \"@crates__ashpd-0.11.1//:ashpd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ashpd\",\n actual = \"@crates__ashpd-0.11.1//:ashpd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ast-grep-core-0.39.9\",\n actual = \"@crates__ast-grep-core-0.39.9//:ast_grep_core\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ast-grep-core\",\n actual = \"@crates__ast-grep-core-0.39.9//:ast_grep_core\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"async-recursion-1.1.1\",\n actual = \"@crates__async-recursion-1.1.1//:async_recursion\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"async-recursion\",\n actual = \"@crates__async-recursion-1.1.1//:async_recursion\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"async-trait-0.1.92\",\n actual = \"@crates__async-trait-0.1.92//:async_trait\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"async-trait\",\n actual = \"@crates__async-trait-0.1.92//:async_trait\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"atspi-0.30.0\",\n actual = \"@crates__atspi-0.30.0//:atspi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"atspi\",\n actual = \"@crates__atspi-0.30.0//:atspi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"audiopus_sys-0.2.2\",\n actual = \"@crates__audiopus_sys-0.2.2//:audiopus_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"audiopus_sys\",\n actual = \"@crates__audiopus_sys-0.2.2//:audiopus_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"base64-0.22.1\",\n actual = \"@crates__base64-0.22.1//:base64\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"base64\",\n actual = \"@crates__base64-0.22.1//:base64\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bigdecimal-0.4.10\",\n actual = \"@crates__bigdecimal-0.4.10//:bigdecimal\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bigdecimal\",\n actual = \"@crates__bigdecimal-0.4.10//:bigdecimal\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"binary-heap-plus-0.5.0\",\n actual = \"@crates__binary-heap-plus-0.5.0//:binary_heap_plus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"binary-heap-plus\",\n actual = \"@crates__binary-heap-plus-0.5.0//:binary_heap_plus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bon-3.10.0\",\n actual = \"@crates__bon-3.10.0//:bon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bon\",\n actual = \"@crates__bon-3.10.0//:bon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"brush-parser-0.3.0\",\n actual = \"@crates__brush-parser-0.3.0//:brush_parser\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"brush-parser-0.4.0\",\n actual = \"@crates__brush-parser-0.4.0//:brush_parser\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bstr-1.13.1\",\n actual = \"@crates__bstr-1.13.1//:bstr\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bstr\",\n actual = \"@crates__bstr-1.13.1//:bstr\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bytecount-0.6.9\",\n actual = \"@crates__bytecount-0.6.9//:bytecount\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bytecount\",\n actual = \"@crates__bytecount-0.6.9//:bytecount\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bytes-1.12.1\",\n actual = \"@crates__bytes-1.12.1//:bytes\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"bytes\",\n actual = \"@crates__bytes-1.12.1//:bytes\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"cached-0.59.0\",\n actual = \"@crates__cached-0.59.0//:cached\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"cached\",\n actual = \"@crates__cached-0.59.0//:cached\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"cfg-if-1.0.4\",\n actual = \"@crates__cfg-if-1.0.4//:cfg_if\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"cfg-if\",\n actual = \"@crates__cfg-if-1.0.4//:cfg_if\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"check_elevation-0.2.7\",\n actual = \"@crates__check_elevation-0.2.7//:check_elevation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"check_elevation\",\n actual = \"@crates__check_elevation-0.2.7//:check_elevation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"chrono-0.4.45\",\n actual = \"@crates__chrono-0.4.45//:chrono\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"chrono\",\n actual = \"@crates__chrono-0.4.45//:chrono\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap-4.6.6\",\n actual = \"@crates__clap-4.6.6//:clap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clap\",\n actual = \"@crates__clap-4.6.6//:clap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clipboard-win-5.4.1\",\n actual = \"@crates__clipboard-win-5.4.1//:clipboard_win\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"clipboard-win\",\n actual = \"@crates__clipboard-win-5.4.1//:clipboard_win\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"codesnake-0.2.1\",\n actual = \"@crates__codesnake-0.2.1//:codesnake\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"codesnake\",\n actual = \"@crates__codesnake-0.2.1//:codesnake\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"color-print-0.3.7\",\n actual = \"@crates__color-print-0.3.7//:color_print\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"color-print\",\n actual = \"@crates__color-print-0.3.7//:color_print\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"command-fds-0.3.3\",\n actual = \"@crates__command-fds-0.3.3//:command_fds\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"command-fds\",\n actual = \"@crates__command-fds-0.3.3//:command_fds\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"compare-0.1.0\",\n actual = \"@crates__compare-0.1.0//:compare\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"compare\",\n actual = \"@crates__compare-0.1.0//:compare\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"core-graphics-0.25.0\",\n actual = \"@crates__core-graphics-0.25.0//:core_graphics\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"core-graphics\",\n actual = \"@crates__core-graphics-0.25.0//:core_graphics\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"dashmap-6.2.1\",\n actual = \"@crates__dashmap-6.2.1//:dashmap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"dashmap\",\n actual = \"@crates__dashmap-6.2.1//:dashmap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"dns-lookup-3.0.1\",\n actual = \"@crates__dns-lookup-3.0.1//:dns_lookup\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"dns-lookup\",\n actual = \"@crates__dns-lookup-3.0.1//:dns_lookup\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"enigo-0.6.1\",\n actual = \"@crates__enigo-0.6.1//:enigo\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"enigo\",\n actual = \"@crates__enigo-0.6.1//:enigo\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"faccess-0.2.4\",\n actual = \"@crates__faccess-0.2.4//:faccess\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"faccess\",\n actual = \"@crates__faccess-0.2.4//:faccess\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fancy-regex-0.16.2\",\n actual = \"@crates__fancy-regex-0.16.2//:fancy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fancy-regex-0.17.0\",\n actual = \"@crates__fancy-regex-0.17.0//:fancy_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"filetime-0.2.29\",\n actual = \"@crates__filetime-0.2.29//:filetime\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"filetime\",\n actual = \"@crates__filetime-0.2.29//:filetime\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"flume-0.11.1\",\n actual = \"@crates__flume-0.11.1//:flume\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"flume\",\n actual = \"@crates__flume-0.11.1//:flume\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"foldhash-0.2.0\",\n actual = \"@crates__foldhash-0.2.0//:foldhash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"foldhash\",\n actual = \"@crates__foldhash-0.2.0//:foldhash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fontdue-0.9.4\",\n actual = \"@crates__fontdue-0.9.4//:fontdue\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fontdue\",\n actual = \"@crates__fontdue-0.9.4//:fontdue\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"foreign-types-0.5.0\",\n actual = \"@crates__foreign-types-0.5.0//:foreign_types\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"foreign-types\",\n actual = \"@crates__foreign-types-0.5.0//:foreign_types\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fs_extra-1.3.0\",\n actual = \"@crates__fs_extra-1.3.0//:fs_extra\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"fs_extra\",\n actual = \"@crates__fs_extra-1.3.0//:fs_extra\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"futures-0.3.34\",\n actual = \"@crates__futures-0.3.34//:futures\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"futures\",\n actual = \"@crates__futures-0.3.34//:futures\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"getrandom-0.4.3\",\n actual = \"@crates__getrandom-0.4.3//:getrandom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"getrandom\",\n actual = \"@crates__getrandom-0.4.3//:getrandom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"gix-0.85.0\",\n actual = \"@crates__gix-0.85.0//:gix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"gix\",\n actual = \"@crates__gix-0.85.0//:gix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"glob-0.3.4\",\n actual = \"@crates__glob-0.3.4//:glob\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"glob\",\n actual = \"@crates__glob-0.3.4//:glob\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"globset-0.4.20\",\n actual = \"@crates__globset-0.4.20//:globset\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"globset\",\n actual = \"@crates__globset-0.4.20//:globset\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-cli-0.1.12\",\n actual = \"@crates__grep-cli-0.1.12//:grep_cli\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-cli\",\n actual = \"@crates__grep-cli-0.1.12//:grep_cli\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-matcher-0.1.9\",\n actual = \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-matcher\",\n actual = \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-pcre2-0.1.10\",\n actual = \"@crates__grep-pcre2-0.1.10//:grep_pcre2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-pcre2\",\n actual = \"@crates__grep-pcre2-0.1.10//:grep_pcre2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-printer-0.3.1\",\n actual = \"@crates__grep-printer-0.3.1//:grep_printer\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-printer\",\n actual = \"@crates__grep-printer-0.3.1//:grep_printer\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-regex-0.1.14\",\n actual = \"@crates__grep-regex-0.1.14//:grep_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-regex\",\n actual = \"@crates__grep-regex-0.1.14//:grep_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-searcher-0.1.17\",\n actual = \"@crates__grep-searcher-0.1.17//:grep_searcher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"grep-searcher\",\n actual = \"@crates__grep-searcher-0.1.17//:grep_searcher\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"heapless-0.9.3\",\n actual = \"@crates__heapless-0.9.3//:heapless\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"heapless\",\n actual = \"@crates__heapless-0.9.3//:heapless\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hex-0.4.3\",\n actual = \"@crates__hex-0.4.3//:hex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hex\",\n actual = \"@crates__hex-0.4.3//:hex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hifijson-0.2.3\",\n actual = \"@crates__hifijson-0.2.3//:hifijson\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hifijson\",\n actual = \"@crates__hifijson-0.2.3//:hifijson\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hostname-0.4.2\",\n actual = \"@crates__hostname-0.4.2//:hostname\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"hostname\",\n actual = \"@crates__hostname-0.4.2//:hostname\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"html-to-markdown-rs-3.11.4\",\n actual = \"@crates__html-to-markdown-rs-3.11.4//:html_to_markdown_rs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"html-to-markdown-rs\",\n actual = \"@crates__html-to-markdown-rs-3.11.4//:html_to_markdown_rs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"icy_sixel-0.5.1\",\n actual = \"@crates__icy_sixel-0.5.1//:icy_sixel\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"icy_sixel\",\n actual = \"@crates__icy_sixel-0.5.1//:icy_sixel\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ignore-0.4.33\",\n actual = \"@crates__ignore-0.4.33//:ignore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"ignore\",\n actual = \"@crates__ignore-0.4.33//:ignore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"image-0.25.10\",\n actual = \"@crates__image-0.25.10//:image\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"image\",\n actual = \"@crates__image-0.25.10//:image\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"indicatif-0.18.6\",\n actual = \"@crates__indicatif-0.18.6//:indicatif\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"indicatif\",\n actual = \"@crates__indicatif-0.18.6//:indicatif\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"inferno-0.12.8\",\n actual = \"@crates__inferno-0.12.8//:inferno\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"inferno\",\n actual = \"@crates__inferno-0.12.8//:inferno\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"inherent-1.0.14\",\n actual = \"@crates__inherent-1.0.14//:inherent\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"inherent\",\n actual = \"@crates__inherent-1.0.14//:inherent\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"itertools-0.14.0\",\n actual = \"@crates__itertools-0.14.0//:itertools\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"itertools\",\n actual = \"@crates__itertools-0.14.0//:itertools\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-core-2.2.1\",\n actual = \"@crates__jaq-core-2.2.1//:jaq_core\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-core\",\n actual = \"@crates__jaq-core-2.2.1//:jaq_core\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-json-1.1.3\",\n actual = \"@crates__jaq-json-1.1.3//:jaq_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-json\",\n actual = \"@crates__jaq-json-1.1.3//:jaq_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-std-2.1.2\",\n actual = \"@crates__jaq-std-2.1.2//:jaq_std\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jaq-std\",\n actual = \"@crates__jaq-std-2.1.2//:jaq_std\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jiff-0.2.35\",\n actual = \"@crates__jiff-0.2.35//:jiff\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jiff\",\n actual = \"@crates__jiff-0.2.35//:jiff\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jj-lib-0.44.0\",\n actual = \"@crates__jj-lib-0.44.0//:jj_lib\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"jj-lib\",\n actual = \"@crates__jj-lib-0.44.0//:jj_lib\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"libc-0.2.189\",\n actual = \"@crates__libc-0.2.189//:libc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"libc\",\n actual = \"@crates__libc-0.2.189//:libc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lscolors-0.21.0\",\n actual = \"@crates__lscolors-0.21.0//:lscolors\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"lscolors\",\n actual = \"@crates__lscolors-0.21.0//:lscolors\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"memchr-2.8.3\",\n actual = \"@crates__memchr-2.8.3//:memchr\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"memchr\",\n actual = \"@crates__memchr-2.8.3//:memchr\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"memmap2-0.9.11\",\n actual = \"@crates__memmap2-0.9.11//:memmap2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"memmap2\",\n actual = \"@crates__memmap2-0.9.11//:memmap2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi-3.12.2\",\n actual = \"@crates__napi-3.12.2//:napi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi\",\n actual = \"@crates__napi-3.12.2//:napi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi-build-2.4.1\",\n actual = \"@crates__napi-build-2.4.1//:napi_build\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi-build\",\n actual = \"@crates__napi-build-2.4.1//:napi_build\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi-derive-3.6.3\",\n actual = \"@crates__napi-derive-3.6.3//:napi_derive\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"napi-derive\",\n actual = \"@crates__napi-derive-3.6.3//:napi_derive\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nix-0.31.3\",\n actual = \"@crates__nix-0.31.3//:nix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nix\",\n actual = \"@crates__nix-0.31.3//:nix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nom-8.0.0\",\n actual = \"@crates__nom-8.0.0//:nom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"nom\",\n actual = \"@crates__nom-8.0.0//:nom\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"normalize-path-0.2.1\",\n actual = \"@crates__normalize-path-0.2.1//:normalize_path\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"normalize-path\",\n actual = \"@crates__normalize-path-0.2.1//:normalize_path\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"notify-8.2.0\",\n actual = \"@crates__notify-8.2.0//:notify\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"notify\",\n actual = \"@crates__notify-8.2.0//:notify\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"num-bigint-0.4.8\",\n actual = \"@crates__num-bigint-0.4.8//:num_bigint\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"num-bigint\",\n actual = \"@crates__num-bigint-0.4.8//:num_bigint\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"num-traits-0.2.19\",\n actual = \"@crates__num-traits-0.2.19//:num_traits\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"num-traits\",\n actual = \"@crates__num-traits-0.2.19//:num_traits\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-0.6.4\",\n actual = \"@crates__objc2-0.6.4//:objc2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2\",\n actual = \"@crates__objc2-0.6.4//:objc2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-app-kit-0.3.2\",\n actual = \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-app-kit\",\n actual = \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-application-services-0.3.2\",\n actual = \"@crates__objc2-application-services-0.3.2//:objc2_application_services\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-application-services\",\n actual = \"@crates__objc2-application-services-0.3.2//:objc2_application_services\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-core-foundation-0.3.2\",\n actual = \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-core-foundation\",\n actual = \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-core-graphics-0.3.2\",\n actual = \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-core-graphics\",\n actual = \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-foundation-0.3.2\",\n actual = \"@crates__objc2-foundation-0.3.2//:objc2_foundation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"objc2-foundation\",\n actual = \"@crates__objc2-foundation-0.3.2//:objc2_foundation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"onig-6.5.3\",\n actual = \"@crates__onig-6.5.3//:onig\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"onig\",\n actual = \"@crates__onig-6.5.3//:onig\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"opus-0.3.1\",\n actual = \"@crates__opus-0.3.1//:opus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"opus\",\n actual = \"@crates__opus-0.3.1//:opus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"os_display-0.1.4\",\n actual = \"@crates__os_display-0.1.4//:os_display\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"os_display\",\n actual = \"@crates__os_display-0.1.4//:os_display\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"os_pipe-1.2.3\",\n actual = \"@crates__os_pipe-1.2.3//:os_pipe\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"os_pipe\",\n actual = \"@crates__os_pipe-1.2.3//:os_pipe\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"parking_lot-0.12.5\",\n actual = \"@crates__parking_lot-0.12.5//:parking_lot\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"parking_lot\",\n actual = \"@crates__parking_lot-0.12.5//:parking_lot\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"parse_datetime-0.14.0\",\n actual = \"@crates__parse_datetime-0.14.0//:parse_datetime\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"parse_datetime\",\n actual = \"@crates__parse_datetime-0.14.0//:parse_datetime\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pdf-inspector-1.17.0\",\n actual = \"@crates__pdf-inspector-1.17.0//:pdf_inspector\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pdf-inspector\",\n actual = \"@crates__pdf-inspector-1.17.0//:pdf_inspector\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"phf-0.13.1\",\n actual = \"@crates__phf-0.13.1//:phf\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"phf\",\n actual = \"@crates__phf-0.13.1//:phf\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pi-shell-18.0.9\",\n actual = \"@crates__pi-shell-18.0.9//:pi_shell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pi-shell\",\n actual = \"@crates__pi-shell-18.0.9//:pi_shell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"platform-info-2.1.0\",\n actual = \"@crates__platform-info-2.1.0//:platform_info\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"platform-info\",\n actual = \"@crates__platform-info-2.1.0//:platform_info\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"png-0.18.1\",\n actual = \"@crates__png-0.18.1//:png\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"png\",\n actual = \"@crates__png-0.18.1//:png\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"portable-pty-0.9.0\",\n actual = \"@crates__portable-pty-0.9.0//:portable_pty\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"portable-pty\",\n actual = \"@crates__portable-pty-0.9.0//:portable_pty\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pretty_assertions-1.4.1\",\n actual = \"@crates__pretty_assertions-1.4.1//:pretty_assertions\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"pretty_assertions\",\n actual = \"@crates__pretty_assertions-1.4.1//:pretty_assertions\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"procfs-0.18.0\",\n actual = \"@crates__procfs-0.18.0//:procfs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"procfs\",\n actual = \"@crates__procfs-0.18.0//:procfs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rand-0.10.2\",\n actual = \"@crates__rand-0.10.2//:rand\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rand\",\n actual = \"@crates__rand-0.10.2//:rand\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rayon-1.12.0\",\n actual = \"@crates__rayon-1.12.0//:rayon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rayon\",\n actual = \"@crates__rayon-1.12.0//:rayon\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex-1.13.1\",\n actual = \"@crates__regex-1.13.1//:regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"regex\",\n actual = \"@crates__regex-1.13.1//:regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"reis-0.5.0\",\n actual = \"@crates__reis-0.5.0//:reis\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"reis\",\n actual = \"@crates__reis-0.5.0//:reis\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"resvg-0.48.1\",\n actual = \"@crates__resvg-0.48.1//:resvg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"resvg\",\n actual = \"@crates__resvg-0.48.1//:resvg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rlimit-0.11.0\",\n actual = \"@crates__rlimit-0.11.0//:rlimit\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rlimit\",\n actual = \"@crates__rlimit-0.11.0//:rlimit\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rpds-1.2.1\",\n actual = \"@crates__rpds-1.2.1//:rpds\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rpds\",\n actual = \"@crates__rpds-1.2.1//:rpds\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rustc-hash-2.1.3\",\n actual = \"@crates__rustc-hash-2.1.3//:rustc_hash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rustc-hash\",\n actual = \"@crates__rustc-hash-2.1.3//:rustc_hash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rustix-1.1.4\",\n actual = \"@crates__rustix-1.1.4//:rustix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"rustix\",\n actual = \"@crates__rustix-1.1.4//:rustix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"self_cell-1.3.0\",\n actual = \"@crates__self_cell-1.3.0//:self_cell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"self_cell\",\n actual = \"@crates__self_cell-1.3.0//:self_cell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde-1.0.229\",\n actual = \"@crates__serde-1.0.229//:serde\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde\",\n actual = \"@crates__serde-1.0.229//:serde\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_json-1.0.151\",\n actual = \"@crates__serde_json-1.0.151//:serde_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"serde_json\",\n actual = \"@crates__serde_json-1.0.151//:serde_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"sha2-0.10.9\",\n actual = \"@crates__sha2-0.10.9//:sha2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"sha2\",\n actual = \"@crates__sha2-0.10.9//:sha2\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"sha3-0.10.9\",\n actual = \"@crates__sha3-0.10.9//:sha3\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"sha3\",\n actual = \"@crates__sha3-0.10.9//:sha3\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"similar-3.2.0\",\n actual = \"@crates__similar-3.2.0//:similar\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"similar\",\n actual = \"@crates__similar-3.2.0//:similar\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"smallvec-1.15.2\",\n actual = \"@crates__smallvec-1.15.2//:smallvec\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"smallvec\",\n actual = \"@crates__smallvec-1.15.2//:smallvec\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum-0.28.0\",\n actual = \"@crates__strum-0.28.0//:strum\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum\",\n actual = \"@crates__strum-0.28.0//:strum\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum_macros-0.28.0\",\n actual = \"@crates__strum_macros-0.28.0//:strum_macros\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"strum_macros\",\n actual = \"@crates__strum_macros-0.28.0//:strum_macros\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"syntect-5.3.0\",\n actual = \"@crates__syntect-5.3.0//:syntect\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"syntect\",\n actual = \"@crates__syntect-5.3.0//:syntect\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tempfile-3.27.0\",\n actual = \"@crates__tempfile-3.27.0//:tempfile\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tempfile\",\n actual = \"@crates__tempfile-3.27.0//:tempfile\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"terminfo-0.9.0\",\n actual = \"@crates__terminfo-0.9.0//:terminfo\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"terminfo\",\n actual = \"@crates__terminfo-0.9.0//:terminfo\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"thiserror-2.0.20\",\n actual = \"@crates__thiserror-2.0.20//:thiserror\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"thiserror\",\n actual = \"@crates__thiserror-2.0.20//:thiserror\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tiktoken-rs-0.11.0\",\n actual = \"@crates__tiktoken-rs-0.11.0//:tiktoken_rs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tiktoken-rs\",\n actual = \"@crates__tiktoken-rs-0.11.0//:tiktoken_rs\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tokio-1.53.1\",\n actual = \"@crates__tokio-1.53.1//:tokio\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tokio\",\n actual = \"@crates__tokio-1.53.1//:tokio\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tokio-util-0.7.19\",\n actual = \"@crates__tokio-util-0.7.19//:tokio_util\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tokio-util\",\n actual = \"@crates__tokio-util-0.7.19//:tokio_util\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"toml-1.1.4+spec-1.1.0\",\n actual = \"@crates__toml-1.1.4-spec-1.1.0//:toml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"toml\",\n actual = \"@crates__toml-1.1.4-spec-1.1.0//:toml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tracing-0.1.44\",\n actual = \"@crates__tracing-0.1.44//:tracing\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tracing\",\n actual = \"@crates__tracing-0.1.44//:tracing\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-0.25.10\",\n actual = \"@crates__tree-sitter-0.25.10//:tree_sitter\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter\",\n actual = \"@crates__tree-sitter-0.25.10//:tree_sitter\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-astro-next-0.1.1\",\n actual = \"@crates__tree-sitter-astro-next-0.1.1//:tree_sitter_astro_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_astro-0.1.1\",\n actual = \"@crates__tree-sitter-astro-next-0.1.1//:tree_sitter_astro_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_astro\",\n actual = \"@crates__tree-sitter-astro-next-0.1.1//:tree_sitter_astro_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-bash-0.25.1\",\n actual = \"@crates__tree-sitter-bash-0.25.1//:tree_sitter_bash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-bash\",\n actual = \"@crates__tree-sitter-bash-0.25.1//:tree_sitter_bash\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-c-0.24.2\",\n actual = \"@crates__tree-sitter-c-0.24.2//:tree_sitter_c\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-c\",\n actual = \"@crates__tree-sitter-c-0.24.2//:tree_sitter_c\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-c-sharp-0.23.5\",\n actual = \"@crates__tree-sitter-c-sharp-0.23.5//:tree_sitter_c_sharp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-c-sharp\",\n actual = \"@crates__tree-sitter-c-sharp-0.23.5//:tree_sitter_c_sharp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-clojure-0.1.0\",\n actual = \"@crates__tree-sitter-clojure-0.1.0//:tree_sitter_clojure\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-clojure\",\n actual = \"@crates__tree-sitter-clojure-0.1.0//:tree_sitter_clojure\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-cmake-0.7.4\",\n actual = \"@crates__tree-sitter-cmake-0.7.4//:tree_sitter_cmake\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-cmake\",\n actual = \"@crates__tree-sitter-cmake-0.7.4//:tree_sitter_cmake\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-cpp-0.23.4\",\n actual = \"@crates__tree-sitter-cpp-0.23.4//:tree_sitter_cpp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-cpp\",\n actual = \"@crates__tree-sitter-cpp-0.23.4//:tree_sitter_cpp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-css-0.25.0\",\n actual = \"@crates__tree-sitter-css-0.25.0//:tree_sitter_css\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-css\",\n actual = \"@crates__tree-sitter-css-0.25.0//:tree_sitter_css\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-dart-0.2.0\",\n actual = \"@crates__tree-sitter-dart-0.2.0//:tree_sitter_dart\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-dart\",\n actual = \"@crates__tree-sitter-dart-0.2.0//:tree_sitter_dart\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-diff-0.1.0\",\n actual = \"@crates__tree-sitter-diff-0.1.0//:tree_sitter_diff\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-diff\",\n actual = \"@crates__tree-sitter-diff-0.1.0//:tree_sitter_diff\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-dockerfile-updated-0.2.0\",\n actual = \"@crates__tree-sitter-dockerfile-updated-0.2.0//:tree_sitter_dockerfile_updated\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_dockerfile-0.2.0\",\n actual = \"@crates__tree-sitter-dockerfile-updated-0.2.0//:tree_sitter_dockerfile_updated\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_dockerfile\",\n actual = \"@crates__tree-sitter-dockerfile-updated-0.2.0//:tree_sitter_dockerfile_updated\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-elisp-1.7.2\",\n actual = \"@crates__tree-sitter-elisp-1.7.2//:tree_sitter_elisp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-elisp\",\n actual = \"@crates__tree-sitter-elisp-1.7.2//:tree_sitter_elisp\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-elixir-0.3.5\",\n actual = \"@crates__tree-sitter-elixir-0.3.5//:tree_sitter_elixir\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-elixir\",\n actual = \"@crates__tree-sitter-elixir-0.3.5//:tree_sitter_elixir\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-erlang-0.16.0\",\n actual = \"@crates__tree-sitter-erlang-0.16.0//:tree_sitter_erlang\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-erlang\",\n actual = \"@crates__tree-sitter-erlang-0.16.0//:tree_sitter_erlang\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-fortran-0.6.0\",\n actual = \"@crates__tree-sitter-fortran-0.6.0//:tree_sitter_fortran\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-fortran\",\n actual = \"@crates__tree-sitter-fortran-0.6.0//:tree_sitter_fortran\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-go-0.25.0\",\n actual = \"@crates__tree-sitter-go-0.25.0//:tree_sitter_go\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-go\",\n actual = \"@crates__tree-sitter-go-0.25.0//:tree_sitter_go\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-graphql-0.1.0\",\n actual = \"@crates__tree-sitter-graphql-0.1.0//:tree_sitter_graphql\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-graphql\",\n actual = \"@crates__tree-sitter-graphql-0.1.0//:tree_sitter_graphql\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-haskell-0.23.1\",\n actual = \"@crates__tree-sitter-haskell-0.23.1//:tree_sitter_haskell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-haskell\",\n actual = \"@crates__tree-sitter-haskell-0.23.1//:tree_sitter_haskell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-hcl-1.1.0\",\n actual = \"@crates__tree-sitter-hcl-1.1.0//:tree_sitter_hcl\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-hcl\",\n actual = \"@crates__tree-sitter-hcl-1.1.0//:tree_sitter_hcl\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-html-0.23.2\",\n actual = \"@crates__tree-sitter-html-0.23.2//:tree_sitter_html\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-html\",\n actual = \"@crates__tree-sitter-html-0.23.2//:tree_sitter_html\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ini-1.4.0\",\n actual = \"@crates__tree-sitter-ini-1.4.0//:tree_sitter_ini\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ini\",\n actual = \"@crates__tree-sitter-ini-1.4.0//:tree_sitter_ini\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-java-0.23.5\",\n actual = \"@crates__tree-sitter-java-0.23.5//:tree_sitter_java\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-java\",\n actual = \"@crates__tree-sitter-java-0.23.5//:tree_sitter_java\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-javascript-0.25.0\",\n actual = \"@crates__tree-sitter-javascript-0.25.0//:tree_sitter_javascript\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-javascript\",\n actual = \"@crates__tree-sitter-javascript-0.25.0//:tree_sitter_javascript\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-json-0.24.8\",\n actual = \"@crates__tree-sitter-json-0.24.8//:tree_sitter_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-json\",\n actual = \"@crates__tree-sitter-json-0.24.8//:tree_sitter_json\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-julia-0.23.1\",\n actual = \"@crates__tree-sitter-julia-0.23.1//:tree_sitter_julia\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-julia\",\n actual = \"@crates__tree-sitter-julia-0.23.1//:tree_sitter_julia\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-just-0.2.0\",\n actual = \"@crates__tree-sitter-just-0.2.0//:tree_sitter_just\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-just\",\n actual = \"@crates__tree-sitter-just-0.2.0//:tree_sitter_just\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-kotlin-sg-0.4.1\",\n actual = \"@crates__tree-sitter-kotlin-sg-0.4.1//:tree_sitter_kotlin_sg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_kotlin-0.4.1\",\n actual = \"@crates__tree-sitter-kotlin-sg-0.4.1//:tree_sitter_kotlin_sg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_kotlin\",\n actual = \"@crates__tree-sitter-kotlin-sg-0.4.1//:tree_sitter_kotlin_sg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-lua-0.5.0\",\n actual = \"@crates__tree-sitter-lua-0.5.0//:tree_sitter_lua\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-lua\",\n actual = \"@crates__tree-sitter-lua-0.5.0//:tree_sitter_lua\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-make-1.1.1\",\n actual = \"@crates__tree-sitter-make-1.1.1//:tree_sitter_make\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-make\",\n actual = \"@crates__tree-sitter-make-1.1.1//:tree_sitter_make\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-md-0.5.3\",\n actual = \"@crates__tree-sitter-md-0.5.3//:tree_sitter_md\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-md\",\n actual = \"@crates__tree-sitter-md-0.5.3//:tree_sitter_md\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-nix-0.3.0\",\n actual = \"@crates__tree-sitter-nix-0.3.0//:tree_sitter_nix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-nix\",\n actual = \"@crates__tree-sitter-nix-0.3.0//:tree_sitter_nix\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-objc-3.0.2\",\n actual = \"@crates__tree-sitter-objc-3.0.2//:tree_sitter_objc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-objc\",\n actual = \"@crates__tree-sitter-objc-3.0.2//:tree_sitter_objc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ocaml-0.24.2\",\n actual = \"@crates__tree-sitter-ocaml-0.24.2//:tree_sitter_ocaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ocaml\",\n actual = \"@crates__tree-sitter-ocaml-0.24.2//:tree_sitter_ocaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-odin-1.3.0\",\n actual = \"@crates__tree-sitter-odin-1.3.0//:tree_sitter_odin\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-odin\",\n actual = \"@crates__tree-sitter-odin-1.3.0//:tree_sitter_odin\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-php-0.24.2\",\n actual = \"@crates__tree-sitter-php-0.24.2//:tree_sitter_php\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-php\",\n actual = \"@crates__tree-sitter-php-0.24.2//:tree_sitter_php\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-powershell-0.26.4\",\n actual = \"@crates__tree-sitter-powershell-0.26.4//:tree_sitter_powershell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-powershell\",\n actual = \"@crates__tree-sitter-powershell-0.26.4//:tree_sitter_powershell\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-proto-0.4.0\",\n actual = \"@crates__tree-sitter-proto-0.4.0//:tree_sitter_proto\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-proto\",\n actual = \"@crates__tree-sitter-proto-0.4.0//:tree_sitter_proto\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-python-0.25.0\",\n actual = \"@crates__tree-sitter-python-0.25.0//:tree_sitter_python\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-python\",\n actual = \"@crates__tree-sitter-python-0.25.0//:tree_sitter_python\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-r-1.3.0\",\n actual = \"@crates__tree-sitter-r-1.3.0//:tree_sitter_r\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-r\",\n actual = \"@crates__tree-sitter-r-1.3.0//:tree_sitter_r\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-regex-0.25.0\",\n actual = \"@crates__tree-sitter-regex-0.25.0//:tree_sitter_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-regex\",\n actual = \"@crates__tree-sitter-regex-0.25.0//:tree_sitter_regex\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ruby-0.23.1\",\n actual = \"@crates__tree-sitter-ruby-0.23.1//:tree_sitter_ruby\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-ruby\",\n actual = \"@crates__tree-sitter-ruby-0.23.1//:tree_sitter_ruby\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-rust-0.24.2\",\n actual = \"@crates__tree-sitter-rust-0.24.2//:tree_sitter_rust\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-rust\",\n actual = \"@crates__tree-sitter-rust-0.24.2//:tree_sitter_rust\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-scala-0.26.2\",\n actual = \"@crates__tree-sitter-scala-0.26.2//:tree_sitter_scala\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-scala\",\n actual = \"@crates__tree-sitter-scala-0.26.2//:tree_sitter_scala\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-sequel-0.3.11\",\n actual = \"@crates__tree-sitter-sequel-0.3.11//:tree_sitter_sequel\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_sql-0.3.11\",\n actual = \"@crates__tree-sitter-sequel-0.3.11//:tree_sitter_sequel\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_sql\",\n actual = \"@crates__tree-sitter-sequel-0.3.11//:tree_sitter_sequel\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-solidity-1.2.13\",\n actual = \"@crates__tree-sitter-solidity-1.2.13//:tree_sitter_solidity\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-solidity\",\n actual = \"@crates__tree-sitter-solidity-1.2.13//:tree_sitter_solidity\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-starlark-1.3.0\",\n actual = \"@crates__tree-sitter-starlark-1.3.0//:tree_sitter_starlark\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-starlark\",\n actual = \"@crates__tree-sitter-starlark-1.3.0//:tree_sitter_starlark\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-svelte-next-0.1.1\",\n actual = \"@crates__tree-sitter-svelte-next-0.1.1//:tree_sitter_svelte_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_svelte-0.1.1\",\n actual = \"@crates__tree-sitter-svelte-next-0.1.1//:tree_sitter_svelte_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_svelte\",\n actual = \"@crates__tree-sitter-svelte-next-0.1.1//:tree_sitter_svelte_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-swift-0.7.3\",\n actual = \"@crates__tree-sitter-swift-0.7.3//:tree_sitter_swift\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-swift\",\n actual = \"@crates__tree-sitter-swift-0.7.3//:tree_sitter_swift\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-tlaplus-1.5.0\",\n actual = \"@crates__tree-sitter-tlaplus-1.5.0//:tree_sitter_tlaplus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-tlaplus\",\n actual = \"@crates__tree-sitter-tlaplus-1.5.0//:tree_sitter_tlaplus\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-toml-ng-0.7.0\",\n actual = \"@crates__tree-sitter-toml-ng-0.7.0//:tree_sitter_toml_ng\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-toml-ng\",\n actual = \"@crates__tree-sitter-toml-ng-0.7.0//:tree_sitter_toml_ng\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-typescript-0.23.2\",\n actual = \"@crates__tree-sitter-typescript-0.23.2//:tree_sitter_typescript\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-typescript\",\n actual = \"@crates__tree-sitter-typescript-0.23.2//:tree_sitter_typescript\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-verilog-1.0.3\",\n actual = \"@crates__tree-sitter-verilog-1.0.3//:tree_sitter_verilog\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-verilog\",\n actual = \"@crates__tree-sitter-verilog-1.0.3//:tree_sitter_verilog\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-vue-next-0.1.0\",\n actual = \"@crates__tree-sitter-vue-next-0.1.0//:tree_sitter_vue_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_vue-0.1.0\",\n actual = \"@crates__tree-sitter-vue-next-0.1.0//:tree_sitter_vue_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree_sitter_vue\",\n actual = \"@crates__tree-sitter-vue-next-0.1.0//:tree_sitter_vue_next\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-xml-0.7.0\",\n actual = \"@crates__tree-sitter-xml-0.7.0//:tree_sitter_xml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-xml\",\n actual = \"@crates__tree-sitter-xml-0.7.0//:tree_sitter_xml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-yaml-0.7.2\",\n actual = \"@crates__tree-sitter-yaml-0.7.2//:tree_sitter_yaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-yaml\",\n actual = \"@crates__tree-sitter-yaml-0.7.2//:tree_sitter_yaml\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-zig-1.1.2\",\n actual = \"@crates__tree-sitter-zig-1.1.2//:tree_sitter_zig\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"tree-sitter-zig\",\n actual = \"@crates__tree-sitter-zig-1.1.2//:tree_sitter_zig\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uiautomation-0.25.0\",\n actual = \"@crates__uiautomation-0.25.0//:uiautomation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uiautomation\",\n actual = \"@crates__uiautomation-0.25.0//:uiautomation\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uucore-0.8.0\",\n actual = \"@crates__uucore-0.8.0//:uucore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uucore\",\n actual = \"@crates__uucore-0.8.0//:uucore\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uuid-1.26.0\",\n actual = \"@crates__uuid-1.26.0//:uuid\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uuid\",\n actual = \"@crates__uuid-1.26.0//:uuid\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uutils_term_grid-0.8.0\",\n actual = \"@crates__uutils_term_grid-0.8.0//:term_grid\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uutils_term_grid\",\n actual = \"@crates__uutils_term_grid-0.8.0//:term_grid\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uzers-0.12.2\",\n actual = \"@crates__uzers-0.12.2//:uzers\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"uzers\",\n actual = \"@crates__uzers-0.12.2//:uzers\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"webrtc-0.17.2\",\n actual = \"@crates__webrtc-0.17.2//:webrtc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"webrtc\",\n actual = \"@crates__webrtc-0.17.2//:webrtc\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"whoami-2.1.3\",\n actual = \"@crates__whoami-2.1.3//:whoami\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"whoami\",\n actual = \"@crates__whoami-2.1.3//:whoami\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"windows-sys-0.59.0\",\n actual = \"@crates__windows-sys-0.59.0//:windows_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"windows-sys-0.61.2\",\n actual = \"@crates__windows-sys-0.61.2//:windows_sys\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"winreg-0.56.0\",\n actual = \"@crates__winreg-0.56.0//:winreg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"winreg\",\n actual = \"@crates__winreg-0.56.0//:winreg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"x11rb-0.13.2\",\n actual = \"@crates__x11rb-0.13.2//:x11rb\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"x11rb\",\n actual = \"@crates__x11rb-0.13.2//:x11rb\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xcap-0.9.6\",\n actual = \"@crates__xcap-0.9.6//:xcap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xcap\",\n actual = \"@crates__xcap-0.9.6//:xcap\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xkeysym-0.2.1\",\n actual = \"@crates__xkeysym-0.2.1//:xkeysym\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xkeysym\",\n actual = \"@crates__xkeysym-0.2.1//:xkeysym\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xutf-1.4.0\",\n actual = \"@crates__xutf-1.4.0//:xutf\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xutf\",\n actual = \"@crates__xutf-1.4.0//:xutf\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xxhash-rust-0.8.18\",\n actual = \"@crates__xxhash-rust-0.8.18//:xxhash_rust\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"xxhash-rust\",\n actual = \"@crates__xxhash-rust-0.8.18//:xxhash_rust\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"yansi-1.0.1\",\n actual = \"@crates__yansi-1.0.1//:yansi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"yansi\",\n actual = \"@crates__yansi-1.0.1//:yansi\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"zstd-0.13.3\",\n actual = \"@crates__zstd-0.13.3//:zstd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"zstd\",\n actual = \"@crates__zstd-0.13.3//:zstd\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"zune-jpeg-0.5.15\",\n actual = \"@crates__zune-jpeg-0.5.15//:zune_jpeg\",\n tags = [\"manual\"],\n)\n\nalias(\n name = \"zune-jpeg\",\n actual = \"@crates__zune-jpeg-0.5.15//:zune_jpeg\",\n tags = [\"manual\"],\n)\n", "alias_rules.bzl": "\"\"\"Alias that transitions its target to `compilation_mode=opt`. Use `transition_alias=\"opt\"` to enable.\"\"\"\n\nload(\"@rules_cc//cc:defs.bzl\", \"CcInfo\")\nload(\"@rules_rust//rust:rust_common.bzl\", \"COMMON_PROVIDERS\")\n\ndef _transition_alias_impl(ctx):\n # `ctx.attr.actual` is a list of 1 item due to the transition\n providers = [ctx.attr.actual[0][provider] for provider in COMMON_PROVIDERS]\n if CcInfo in ctx.attr.actual[0]:\n providers.append(ctx.attr.actual[0][CcInfo])\n return providers\n\ndef _change_compilation_mode(compilation_mode):\n def _change_compilation_mode_impl(_settings, _attr):\n return {\n \"//command_line_option:compilation_mode\": compilation_mode,\n }\n\n return transition(\n implementation = _change_compilation_mode_impl,\n inputs = [],\n outputs = [\n \"//command_line_option:compilation_mode\",\n ],\n )\n\ndef _transition_alias_rule(compilation_mode):\n return rule(\n implementation = _transition_alias_impl,\n provides = COMMON_PROVIDERS,\n attrs = {\n \"actual\": attr.label(\n mandatory = True,\n doc = \"`rust_library()` target to transition to `compilation_mode=opt`.\",\n providers = COMMON_PROVIDERS,\n cfg = _change_compilation_mode(compilation_mode),\n ),\n \"_allowlist_function_transition\": attr.label(\n default = \"@bazel_tools//tools/allowlists/function_transition_allowlist\",\n ),\n },\n doc = \"Transitions a Rust library crate to the `compilation_mode=opt`.\",\n )\n\ntransition_alias_dbg = _transition_alias_rule(\"dbg\")\ntransition_alias_fastbuild = _transition_alias_rule(\"fastbuild\")\ntransition_alias_opt = _transition_alias_rule(\"opt\")\n", - "crates.bzl": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\"\"\"\n# `crates_repository` API\n\n- [aliases](#aliases)\n- [crate_edition](#crate_edition)\n- [crate_deps](#crate_deps)\n- [all_crate_deps](#all_crate_deps)\n- [crate_repositories](#crate_repositories)\n\n\"\"\"\n\nload(\"@bazel_tools//tools/build_defs/repo:git.bzl\", \"git_repository\")\nload(\"@bazel_tools//tools/build_defs/repo:http.bzl\", \"http_archive\")\nload(\"@bazel_tools//tools/build_defs/repo:utils.bzl\", \"maybe\")\nload(\"@bazel_skylib//lib:selects.bzl\", \"selects\")\nload(\"@rules_rust//crate_universe:defs.bzl\", \"crates_vendor_remote_repository\", \"local_crate_mirror\")\n\n###############################################################################\n# MACROS API\n###############################################################################\n\n# An identifier that represent common dependencies (unconditional).\n_COMMON_CONDITION = \"\"\n\ndef _flatten_dependency_maps(all_dependency_maps):\n \"\"\"Flatten a list of dependency maps into one dictionary.\n\n Dependency maps have the following structure:\n\n ```python\n DEPENDENCIES_MAP = {\n # The first key in the map is a Bazel package\n # name of the workspace this file is defined in.\n \"workspace_member_package\": {\n\n # Not all dependencies are supported for all platforms.\n # the condition key is the condition required to be true\n # on the host platform.\n \"condition\": {\n\n # An alias to a crate target. # The label of the crate target the\n # Aliases are only crate names. # package name refers to.\n \"package_name\": \"@full//:label\",\n }\n }\n }\n ```\n\n Args:\n all_dependency_maps (list): A list of dicts as described above\n\n Returns:\n dict: A dictionary as described above\n \"\"\"\n dependencies = {}\n\n for workspace_deps_map in all_dependency_maps:\n for pkg_name, conditional_deps_map in workspace_deps_map.items():\n if pkg_name not in dependencies:\n non_frozen_map = dict()\n for key, values in conditional_deps_map.items():\n non_frozen_map.update({key: dict(values.items())})\n dependencies.setdefault(pkg_name, non_frozen_map)\n continue\n\n for condition, deps_map in conditional_deps_map.items():\n # If the condition has not been recorded, do so and continue\n if condition not in dependencies[pkg_name]:\n dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))\n continue\n\n # Alert on any miss-matched dependencies\n inconsistent_entries = []\n for crate_name, crate_label in deps_map.items():\n existing = dependencies[pkg_name][condition].get(crate_name)\n if existing and existing != crate_label:\n inconsistent_entries.append((crate_name, existing, crate_label))\n dependencies[pkg_name][condition].update({crate_name: crate_label})\n\n return dependencies\n\ndef crate_deps(deps, package_name = None):\n \"\"\"Finds the fully qualified label of the requested crates for the package where this macro is called.\n\n Args:\n deps (list): The desired list of crate targets.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()`.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if not deps:\n return []\n\n if package_name == None:\n package_name = native.package_name()\n\n # Join both sets of dependencies\n dependencies = _flatten_dependency_maps([\n _NORMAL_DEPENDENCIES,\n _NORMAL_DEV_DEPENDENCIES,\n _PROC_MACRO_DEPENDENCIES,\n _PROC_MACRO_DEV_DEPENDENCIES,\n _BUILD_DEPENDENCIES,\n _BUILD_PROC_MACRO_DEPENDENCIES,\n ]).pop(package_name, {})\n\n # Combine all conditional packages so we can easily index over a flat list\n # TODO: Perhaps this should actually return select statements and maintain\n # the conditionals of the dependencies\n flat_deps = {}\n for deps_set in dependencies.values():\n for crate_name, crate_label in deps_set.items():\n flat_deps.update({crate_name: crate_label})\n\n missing_crates = []\n crate_targets = []\n for crate_target in deps:\n if crate_target not in flat_deps:\n missing_crates.append(crate_target)\n else:\n crate_targets.append(flat_deps[crate_target])\n\n if missing_crates:\n fail(\"Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`\".format(\n missing_crates,\n package_name,\n dependencies,\n ))\n\n return crate_targets\n\ndef crate_edition(package_name = None):\n \"\"\"Finds the Rust edition for the package where this macro is called.\n\n Args:\n package_name (str, optional): The package name whose edition should be\n looked up. Defaults to `native.package_name()` when unset.\n\n Returns:\n str: The Rust edition declared by the package's Cargo.toml file.\n \"\"\"\n if package_name == None:\n package_name = native.package_name()\n\n if package_name not in _CRATE_EDITIONS:\n fail(\"Tried to get crate_edition for package \" + package_name + \" but that package had no Cargo.toml file\")\n\n return _CRATE_EDITIONS[package_name]\n\ndef all_crate_deps(\n normal = False, \n normal_dev = False, \n proc_macro = False, \n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Finds the fully qualified label of all requested direct crate dependencies \\\n for the package where this macro is called.\n\n If no parameters are set, all normal dependencies are returned. Setting any one flag will\n otherwise impact the contents of the returned list.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list.\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_dependency_maps = []\n if normal:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n if normal_dev:\n all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)\n if proc_macro:\n all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)\n if proc_macro_dev:\n all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)\n if build:\n all_dependency_maps.append(_BUILD_DEPENDENCIES)\n if build_proc_macro:\n all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)\n\n # Default to always using normal dependencies\n if not all_dependency_maps:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n\n dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)\n\n if not dependencies:\n if dependencies == None:\n fail(\"Tried to get all_crate_deps for package \" + package_name + \" but that package had no Cargo.toml file\")\n else:\n return []\n\n crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())\n for condition, deps in dependencies.items():\n crate_deps += selects.with_or({\n tuple(_CONDITIONS[condition]): deps.values(),\n \"//conditions:default\": [],\n })\n\n return crate_deps\n\ndef aliases(\n normal = False,\n normal_dev = False,\n proc_macro = False,\n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Produces a map of Crate alias names to their original label\n\n If no dependency kinds are specified, `normal` and `proc_macro` are used by default.\n Setting any one flag will otherwise determine the contents of the returned dict.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list..\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n dict: The aliases of all associated packages\n \"\"\"\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_aliases_maps = []\n if normal:\n all_aliases_maps.append(_NORMAL_ALIASES)\n if normal_dev:\n all_aliases_maps.append(_NORMAL_DEV_ALIASES)\n if proc_macro:\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n if proc_macro_dev:\n all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)\n if build:\n all_aliases_maps.append(_BUILD_ALIASES)\n if build_proc_macro:\n all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)\n\n # Default to always using normal aliases\n if not all_aliases_maps:\n all_aliases_maps.append(_NORMAL_ALIASES)\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n\n aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)\n\n if not aliases:\n return dict()\n\n common_items = aliases.pop(_COMMON_CONDITION, {}).items()\n\n # If there are only common items in the dictionary, immediately return them\n if not len(aliases.keys()) == 1:\n return dict(common_items)\n\n # Build a single select statement where each conditional has accounted for the\n # common set of aliases.\n crate_aliases = {\"//conditions:default\": dict(common_items)}\n for condition, deps in aliases.items():\n condition_triples = _CONDITIONS[condition]\n for triple in condition_triples:\n if triple in crate_aliases:\n crate_aliases[triple].update(deps)\n else:\n crate_aliases.update({triple: dict(deps.items() + common_items)})\n\n return select(crate_aliases)\n\n###############################################################################\n# WORKSPACE MEMBER DEPS, ALIASES, AND EDITIONS\n###############################################################################\n\n_CRATE_EDITIONS = {\n \"crates/vendor/brush-core\": \"2024\",\n \"crates/pi-ast\": \"2024\",\n \"crates/pi-builtins\": \"2024\",\n \"crates/pi-iso\": \"2024\",\n \"crates/pi-natives\": \"2024\",\n \"crates/pi-shell\": \"2024\",\n \"crates/pi-voice\": \"2024\",\n \"crates/pi-walker\": \"2024\",\n}\n\n_NORMAL_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n \"bon\": Label(\"//bon-3.9.3\"),\n \"brush-parser\": Label(\"//brush-parser-0.4.0\"),\n \"cached\": Label(\"//cached-0.59.0\"),\n \"cfg-if\": Label(\"//cfg-if-1.0.4\"),\n \"chrono\": Label(\"//chrono-0.4.45\"),\n \"clap\": Label(\"//clap-4.6.6\"),\n \"color-print\": Label(\"//color-print-0.3.7\"),\n \"fancy-regex\": Label(\"//fancy-regex-0.17.0\"),\n \"futures\": Label(\"//futures-0.3.34\"),\n \"itertools\": Label(\"//itertools-0.14.0\"),\n \"normalize-path\": Label(\"//normalize-path-0.2.1\"),\n \"rand\": Label(\"//rand-0.10.2\"),\n \"rpds\": Label(\"//rpds-1.2.1\"),\n \"strum\": Label(\"//strum-0.28.0\"),\n \"thiserror\": Label(\"//thiserror-2.0.20\"),\n \"tokio-util\": Label(\"//tokio-util-0.7.19\"),\n \"tracing\": Label(\"//tracing-0.1.44\"),\n },\n \"cfg(any(unix, windows))\": {\n \"hostname\": Label(\"//hostname-0.4.2\"),\n \"tokio\": Label(\"//tokio-1.53.1\"),\n },\n \"cfg(target_family = \\\"wasm\\\")\": {\n \"tokio\": Label(\"//tokio-1.53.1\"),\n },\n \"cfg(unix)\": {\n \"command-fds\": Label(\"//command-fds-0.3.3\"),\n \"libc\": Label(\"//libc-0.2.189\"),\n \"nix\": Label(\"//nix-0.31.3\"),\n \"terminfo\": Label(\"//terminfo-0.9.0\"),\n \"uzers\": Label(\"//uzers-0.12.2\"),\n },\n \"cfg(windows)\": {\n \"check_elevation\": Label(\"//check_elevation-0.2.7\"),\n \"whoami\": Label(\"//whoami-2.1.3\"),\n \"windows-sys\": Label(\"//windows-sys-0.59.0\"),\n },\n \"wasm32-unknown-unknown\": {\n \"getrandom\": Label(\"//getrandom-0.4.3\"),\n \"uuid\": Label(\"//uuid-1.24.1\"),\n },\n },\n \"crates/pi-ast\": {\n _COMMON_CONDITION: {\n \"anyhow\": Label(\"//anyhow-1.0.104\"),\n \"ast-grep-core\": Label(\"//ast-grep-core-0.39.9\"),\n \"globset\": Label(\"//globset-0.4.20\"),\n \"ignore\": Label(\"//ignore-0.4.33\"),\n \"phf\": Label(\"//phf-0.13.1\"),\n \"serde\": Label(\"//serde-1.0.229\"),\n \"tree-sitter\": Label(\"//tree-sitter-0.25.10\"),\n \"tree_sitter_astro\": Label(\"//tree-sitter-astro-next-0.1.1\"),\n \"tree-sitter-bash\": Label(\"//tree-sitter-bash-0.25.1\"),\n \"tree-sitter-c\": Label(\"//tree-sitter-c-0.24.2\"),\n \"tree-sitter-c-sharp\": Label(\"//tree-sitter-c-sharp-0.23.5\"),\n \"tree-sitter-clojure\": Label(\"//tree-sitter-clojure-0.1.0\"),\n \"tree-sitter-cmake\": Label(\"//tree-sitter-cmake-0.7.4\"),\n \"tree-sitter-cpp\": Label(\"//tree-sitter-cpp-0.23.4\"),\n \"tree-sitter-css\": Label(\"//tree-sitter-css-0.25.0\"),\n \"tree-sitter-dart\": Label(\"//tree-sitter-dart-0.2.0\"),\n \"tree-sitter-diff\": Label(\"//tree-sitter-diff-0.1.0\"),\n \"tree_sitter_dockerfile\": Label(\"//tree-sitter-dockerfile-updated-0.2.0\"),\n \"tree-sitter-elisp\": Label(\"//tree-sitter-elisp-1.7.2\"),\n \"tree-sitter-elixir\": Label(\"//tree-sitter-elixir-0.3.5\"),\n \"tree-sitter-erlang\": Label(\"//tree-sitter-erlang-0.16.0\"),\n \"tree-sitter-fortran\": Label(\"//tree-sitter-fortran-0.6.0\"),\n \"tree-sitter-go\": Label(\"//tree-sitter-go-0.25.0\"),\n \"tree-sitter-graphql\": Label(\"//tree-sitter-graphql-0.1.0\"),\n \"tree-sitter-haskell\": Label(\"//tree-sitter-haskell-0.23.1\"),\n \"tree-sitter-hcl\": Label(\"//tree-sitter-hcl-1.1.0\"),\n \"tree-sitter-html\": Label(\"//tree-sitter-html-0.23.2\"),\n \"tree-sitter-ini\": Label(\"//tree-sitter-ini-1.4.0\"),\n \"tree-sitter-java\": Label(\"//tree-sitter-java-0.23.5\"),\n \"tree-sitter-javascript\": Label(\"//tree-sitter-javascript-0.25.0\"),\n \"tree-sitter-json\": Label(\"//tree-sitter-json-0.24.8\"),\n \"tree-sitter-julia\": Label(\"//tree-sitter-julia-0.23.1\"),\n \"tree-sitter-just\": Label(\"//tree-sitter-just-0.2.0\"),\n \"tree_sitter_kotlin\": Label(\"//tree-sitter-kotlin-sg-0.4.1\"),\n \"tree-sitter-lua\": Label(\"//tree-sitter-lua-0.5.0\"),\n \"tree-sitter-make\": Label(\"//tree-sitter-make-1.1.1\"),\n \"tree-sitter-md\": Label(\"//tree-sitter-md-0.5.3\"),\n \"tree-sitter-nix\": Label(\"//tree-sitter-nix-0.3.0\"),\n \"tree-sitter-objc\": Label(\"//tree-sitter-objc-3.0.2\"),\n \"tree-sitter-ocaml\": Label(\"//tree-sitter-ocaml-0.24.2\"),\n \"tree-sitter-odin\": Label(\"//tree-sitter-odin-1.3.0\"),\n \"tree-sitter-php\": Label(\"//tree-sitter-php-0.24.2\"),\n \"tree-sitter-powershell\": Label(\"//tree-sitter-powershell-0.26.4\"),\n \"tree-sitter-proto\": Label(\"//tree-sitter-proto-0.4.0\"),\n \"tree-sitter-python\": Label(\"//tree-sitter-python-0.25.0\"),\n \"tree-sitter-r\": Label(\"//tree-sitter-r-1.3.0\"),\n \"tree-sitter-regex\": Label(\"//tree-sitter-regex-0.25.0\"),\n \"tree-sitter-ruby\": Label(\"//tree-sitter-ruby-0.23.1\"),\n \"tree-sitter-rust\": Label(\"//tree-sitter-rust-0.24.2\"),\n \"tree-sitter-scala\": Label(\"//tree-sitter-scala-0.26.2\"),\n \"tree_sitter_sql\": Label(\"//tree-sitter-sequel-0.3.11\"),\n \"tree-sitter-solidity\": Label(\"//tree-sitter-solidity-1.2.13\"),\n \"tree-sitter-starlark\": Label(\"//tree-sitter-starlark-1.3.0\"),\n \"tree_sitter_svelte\": Label(\"//tree-sitter-svelte-next-0.1.1\"),\n \"tree-sitter-swift\": Label(\"//tree-sitter-swift-0.7.3\"),\n \"tree-sitter-tlaplus\": Label(\"//tree-sitter-tlaplus-1.5.0\"),\n \"tree-sitter-toml-ng\": Label(\"//tree-sitter-toml-ng-0.7.0\"),\n \"tree-sitter-typescript\": Label(\"//tree-sitter-typescript-0.23.2\"),\n \"tree-sitter-verilog\": Label(\"//tree-sitter-verilog-1.0.3\"),\n \"tree_sitter_vue\": Label(\"//tree-sitter-vue-next-0.1.0\"),\n \"tree-sitter-xml\": Label(\"//tree-sitter-xml-0.7.0\"),\n \"tree-sitter-yaml\": Label(\"//tree-sitter-yaml-0.7.2\"),\n \"tree-sitter-zig\": Label(\"//tree-sitter-zig-1.1.2\"),\n \"xxhash-rust\": Label(\"//xxhash-rust-0.8.18\"),\n },\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n \"ansi-width\": Label(\"//ansi-width-0.1.0\"),\n \"argmax\": Label(\"//argmax-0.3.1\"),\n \"bigdecimal\": Label(\"//bigdecimal-0.4.10\"),\n \"binary-heap-plus\": Label(\"//binary-heap-plus-0.5.0\"),\n \"brush-parser\": Label(\"//brush-parser-0.4.0\"),\n \"bstr\": Label(\"//bstr-1.13.1\"),\n \"bytecount\": Label(\"//bytecount-0.6.9\"),\n \"cfg-if\": Label(\"//cfg-if-1.0.4\"),\n \"chrono\": Label(\"//chrono-0.4.45\"),\n \"clap\": Label(\"//clap-4.6.6\"),\n \"codesnake\": Label(\"//codesnake-0.2.1\"),\n \"compare\": Label(\"//compare-0.1.0\"),\n \"faccess\": Label(\"//faccess-0.2.4\"),\n \"fancy-regex\": Label(\"//fancy-regex-0.17.0\"),\n \"filetime\": Label(\"//filetime-0.2.29\"),\n \"flume\": Label(\"//flume-0.11.1\"),\n \"foldhash\": Label(\"//foldhash-0.2.0\"),\n \"fs_extra\": Label(\"//fs_extra-1.3.0\"),\n \"futures\": Label(\"//futures-0.3.34\"),\n \"glob\": Label(\"//glob-0.3.4\"),\n \"globset\": Label(\"//globset-0.4.20\"),\n \"grep-cli\": Label(\"//grep-cli-0.1.12\"),\n \"grep-matcher\": Label(\"//grep-matcher-0.1.9\"),\n \"grep-pcre2\": Label(\"//grep-pcre2-0.1.10\"),\n \"grep-printer\": Label(\"//grep-printer-0.3.1\"),\n \"grep-regex\": Label(\"//grep-regex-0.1.14\"),\n \"grep-searcher\": Label(\"//grep-searcher-0.1.17\"),\n \"hex\": Label(\"//hex-0.4.3\"),\n \"hifijson\": Label(\"//hifijson-0.2.3\"),\n \"hostname\": Label(\"//hostname-0.4.2\"),\n \"ignore\": Label(\"//ignore-0.4.33\"),\n \"indicatif\": Label(\"//indicatif-0.18.6\"),\n \"itertools\": Label(\"//itertools-0.14.0\"),\n \"jaq-core\": Label(\"//jaq-core-2.2.1\"),\n \"jaq-json\": Label(\"//jaq-json-1.1.3\"),\n \"jaq-std\": Label(\"//jaq-std-2.1.2\"),\n \"jiff\": Label(\"//jiff-0.2.35\"),\n \"libc\": Label(\"//libc-0.2.189\"),\n \"lscolors\": Label(\"//lscolors-0.21.0\"),\n \"memchr\": Label(\"//memchr-2.8.3\"),\n \"memmap2\": Label(\"//memmap2-0.9.11\"),\n \"nom\": Label(\"//nom-8.0.0\"),\n \"num-bigint\": Label(\"//num-bigint-0.4.8\"),\n \"num-traits\": Label(\"//num-traits-0.2.19\"),\n \"onig\": Label(\"//onig-6.5.3\"),\n \"os_display\": Label(\"//os_display-0.1.4\"),\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"parse_datetime\": Label(\"//parse_datetime-0.14.0\"),\n \"platform-info\": Label(\"//platform-info-2.1.0\"),\n \"rand\": Label(\"//rand-0.10.2\"),\n \"rayon\": Label(\"//rayon-1.12.0\"),\n \"regex\": Label(\"//regex-1.13.1\"),\n \"rustc-hash\": Label(\"//rustc-hash-2.1.3\"),\n \"self_cell\": Label(\"//self_cell-1.3.0\"),\n \"serde_json\": Label(\"//serde_json-1.0.151\"),\n \"similar\": Label(\"//similar-3.2.0\"),\n \"smallvec\": Label(\"//smallvec-1.15.2\"),\n \"strum\": Label(\"//strum-0.28.0\"),\n \"tempfile\": Label(\"//tempfile-3.27.0\"),\n \"thiserror\": Label(\"//thiserror-2.0.20\"),\n \"tokio-util\": Label(\"//tokio-util-0.7.19\"),\n \"tracing\": Label(\"//tracing-0.1.44\"),\n \"uucore\": Label(\"//uucore-0.8.0\"),\n \"uutils_term_grid\": Label(\"//uutils_term_grid-0.8.0\"),\n \"xutf\": Label(\"//xutf-1.4.0\"),\n \"yansi\": Label(\"//yansi-1.0.1\"),\n },\n \"cfg(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"))\": {\n \"procfs\": Label(\"//procfs-0.18.0\"),\n },\n \"cfg(any(unix, windows))\": {\n \"tokio\": Label(\"//tokio-1.53.1\"),\n },\n \"cfg(target_family = \\\"wasm\\\")\": {\n \"tokio\": Label(\"//tokio-1.53.1\"),\n },\n \"cfg(unix)\": {\n \"dns-lookup\": Label(\"//dns-lookup-3.0.1\"),\n \"nix\": Label(\"//nix-0.31.3\"),\n \"notify\": Label(\"//notify-8.2.0\"),\n \"rlimit\": Label(\"//rlimit-0.11.0\"),\n \"rustix\": Label(\"//rustix-1.1.4\"),\n },\n \"cfg(windows)\": {\n \"notify\": Label(\"//notify-8.2.0\"),\n \"rustix\": Label(\"//rustix-1.1.4\"),\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n },\n },\n \"crates/pi-iso\": {\n _COMMON_CONDITION: {\n \"similar\": Label(\"//similar-3.2.0\"),\n \"tokio\": Label(\"//tokio-1.53.1\"),\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n },\n \"cfg(unix)\": {\n \"libc\": Label(\"//libc-0.2.189\"),\n },\n \"cfg(windows)\": {\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n },\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n \"anyhow\": Label(\"//anyhow-1.0.104\"),\n \"arboard\": Label(\"//arboard-3.6.1\"),\n \"ast-grep-core\": Label(\"//ast-grep-core-0.39.9\"),\n \"base64\": Label(\"//base64-0.22.1\"),\n \"clap\": Label(\"//clap-4.6.6\"),\n \"flume\": Label(\"//flume-0.11.1\"),\n \"fontdue\": Label(\"//fontdue-0.9.4\"),\n \"futures\": Label(\"//futures-0.3.34\"),\n \"globset\": Label(\"//globset-0.4.20\"),\n \"grep-matcher\": Label(\"//grep-matcher-0.1.9\"),\n \"grep-pcre2\": Label(\"//grep-pcre2-0.1.10\"),\n \"grep-regex\": Label(\"//grep-regex-0.1.14\"),\n \"grep-searcher\": Label(\"//grep-searcher-0.1.17\"),\n \"heapless\": Label(\"//heapless-0.9.3\"),\n \"html-to-markdown-rs\": Label(\"//html-to-markdown-rs-3.11.3\"),\n \"icy_sixel\": Label(\"//icy_sixel-0.5.1\"),\n \"ignore\": Label(\"//ignore-0.4.33\"),\n \"image\": Label(\"//image-0.25.10\"),\n \"inferno\": Label(\"//inferno-0.12.8\"),\n \"napi\": Label(\"//napi-3.12.2\"),\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"pdf-inspector\": Label(\"//pdf-inspector-1.17.0\"),\n \"phf\": Label(\"//phf-0.13.1\"),\n \"png\": Label(\"//png-0.18.1\"),\n \"portable-pty\": Label(\"//portable-pty-0.9.0\"),\n \"rayon\": Label(\"//rayon-1.12.0\"),\n \"regex\": Label(\"//regex-1.13.1\"),\n \"serde\": Label(\"//serde-1.0.229\"),\n \"serde_json\": Label(\"//serde_json-1.0.151\"),\n \"smallvec\": Label(\"//smallvec-1.15.2\"),\n \"syntect\": Label(\"//syntect-5.3.0\"),\n \"tokio\": Label(\"//tokio-1.53.1\"),\n \"tokio-util\": Label(\"//tokio-util-0.7.19\"),\n \"toml\": Label(\"//toml-1.1.4+spec-1.1.0\"),\n \"xutf\": Label(\"//xutf-1.4.0\"),\n \"xxhash-rust\": Label(\"//xxhash-rust-0.8.18\"),\n \"zstd\": Label(\"//zstd-0.13.3\"),\n \"zune-jpeg\": Label(\"//zune-jpeg-0.5.15\"),\n },\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"windows\\\"))\": {\n \"enigo\": Label(\"//enigo-0.6.1\"),\n \"xcap\": Label(\"//xcap-0.9.6\"),\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n \"ashpd\": Label(\"//ashpd-0.11.1\"),\n \"atspi\": Label(\"//atspi-0.30.0\"),\n \"reis\": Label(\"//reis-0.5.0\"),\n \"x11rb\": Label(\"//x11rb-0.13.2\"),\n \"xkeysym\": Label(\"//xkeysym-0.2.1\"),\n },\n \"cfg(target_os = \\\"macos\\\")\": {\n \"core-graphics\": Label(\"//core-graphics-0.25.0\"),\n \"foreign-types\": Label(\"//foreign-types-0.5.0\"),\n \"objc2\": Label(\"//objc2-0.6.4\"),\n \"objc2-app-kit\": Label(\"//objc2-app-kit-0.3.2\"),\n \"objc2-application-services\": Label(\"//objc2-application-services-0.3.2\"),\n \"objc2-core-foundation\": Label(\"//objc2-core-foundation-0.3.2\"),\n \"objc2-core-graphics\": Label(\"//objc2-core-graphics-0.3.2\"),\n \"objc2-foundation\": Label(\"//objc2-foundation-0.3.2\"),\n \"tempfile\": Label(\"//tempfile-3.27.0\"),\n },\n \"cfg(unix)\": {\n \"libc\": Label(\"//libc-0.2.189\"),\n },\n \"cfg(windows)\": {\n \"clipboard-win\": Label(\"//clipboard-win-5.4.1\"),\n \"uiautomation\": Label(\"//uiautomation-0.25.0\"),\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n \"winreg\": Label(\"//winreg-0.56.0\"),\n },\n },\n \"crates/pi-shell\": {\n _COMMON_CONDITION: {\n \"anyhow\": Label(\"//anyhow-1.0.104\"),\n \"brush-parser\": Label(\"//brush-parser-0.3.0\"),\n \"bytes\": Label(\"//bytes-1.12.1\"),\n \"clap\": Label(\"//clap-4.6.6\"),\n \"flume\": Label(\"//flume-0.11.1\"),\n \"jiff\": Label(\"//jiff-0.2.35\"),\n \"os_pipe\": Label(\"//os_pipe-1.2.3\"),\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"regex\": Label(\"//regex-1.13.1\"),\n \"serde\": Label(\"//serde-1.0.229\"),\n \"serde_json\": Label(\"//serde_json-1.0.151\"),\n \"tokio\": Label(\"//tokio-1.53.1\"),\n \"tokio-util\": Label(\"//tokio-util-0.7.19\"),\n \"toml\": Label(\"//toml-1.1.4+spec-1.1.0\"),\n \"xxhash-rust\": Label(\"//xxhash-rust-0.8.18\"),\n },\n \"cfg(unix)\": {\n \"libc\": Label(\"//libc-0.2.189\"),\n },\n \"cfg(windows)\": {\n \"smallvec\": Label(\"//smallvec-1.15.2\"),\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n \"winreg\": Label(\"//winreg-0.56.0\"),\n },\n },\n \"crates/pi-voice\": {\n _COMMON_CONDITION: {\n \"audiopus_sys\": Label(\"//audiopus_sys-0.2.2\"),\n \"bytes\": Label(\"//bytes-1.12.1\"),\n \"flume\": Label(\"//flume-0.11.1\"),\n \"opus\": Label(\"//opus-0.3.1\"),\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"tokio\": Label(\"//tokio-1.53.1\"),\n \"webrtc\": Label(\"//webrtc-0.17.2\"),\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n \"libc\": Label(\"//libc-0.2.189\"),\n },\n \"cfg(target_os = \\\"windows\\\")\": {\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n },\n },\n \"crates/pi-walker\": {\n _COMMON_CONDITION: {\n \"dashmap\": Label(\"//dashmap-6.2.1\"),\n \"globset\": Label(\"//globset-0.4.20\"),\n \"ignore\": Label(\"//ignore-0.4.33\"),\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"rayon\": Label(\"//rayon-1.12.0\"),\n },\n \"cfg(unix)\": {\n \"libc\": Label(\"//libc-0.2.189\"),\n },\n \"cfg(windows)\": {\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n },\n },\n}\n\n\n_NORMAL_ALIASES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n },\n \"cfg(any(unix, windows))\": {\n },\n \"cfg(target_family = \\\"wasm\\\")\": {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n \"wasm32-unknown-unknown\": {\n },\n },\n \"crates/pi-ast\": {\n _COMMON_CONDITION: {\n Label(\"//tree-sitter-astro-next-0.1.1\"): \"tree_sitter_astro\",\n Label(\"//tree-sitter-dockerfile-updated-0.2.0\"): \"tree_sitter_dockerfile\",\n Label(\"//tree-sitter-kotlin-sg-0.4.1\"): \"tree_sitter_kotlin\",\n Label(\"//tree-sitter-sequel-0.3.11\"): \"tree_sitter_sql\",\n Label(\"//tree-sitter-svelte-next-0.1.1\"): \"tree_sitter_svelte\",\n Label(\"//tree-sitter-vue-next-0.1.0\"): \"tree_sitter_vue\",\n },\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n },\n \"cfg(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"))\": {\n },\n \"cfg(any(unix, windows))\": {\n },\n \"cfg(target_family = \\\"wasm\\\")\": {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n },\n \"crates/pi-iso\": {\n _COMMON_CONDITION: {\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n },\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"windows\\\"))\": {\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n },\n \"cfg(target_os = \\\"macos\\\")\": {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n },\n \"crates/pi-shell\": {\n _COMMON_CONDITION: {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n },\n \"crates/pi-voice\": {\n _COMMON_CONDITION: {\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n },\n \"cfg(target_os = \\\"windows\\\")\": {\n },\n },\n \"crates/pi-walker\": {\n _COMMON_CONDITION: {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n },\n}\n\n\n_NORMAL_DEV_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n \"anyhow\": Label(\"//anyhow-1.0.104\"),\n \"pretty_assertions\": Label(\"//pretty_assertions-1.4.1\"),\n \"tempfile\": Label(\"//tempfile-3.27.0\"),\n },\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n \"anyhow\": Label(\"//anyhow-1.0.104\"),\n \"pretty_assertions\": Label(\"//pretty_assertions-1.4.1\"),\n },\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n \"fancy-regex\": Label(\"//fancy-regex-0.16.2\"),\n \"tiktoken-rs\": Label(\"//tiktoken-rs-0.11.0\"),\n },\n },\n \"crates/pi-shell\": {\n _COMMON_CONDITION: {\n \"tempfile\": Label(\"//tempfile-3.27.0\"),\n },\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_NORMAL_DEV_ALIASES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-shell\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_PROC_MACRO_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n \"async-recursion\": Label(\"//async-recursion-1.1.1\"),\n \"async-trait\": Label(\"//async-trait-0.1.92\"),\n \"inherent\": Label(\"//inherent-1.0.14\"),\n \"strum_macros\": Label(\"//strum_macros-0.28.0\"),\n },\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n \"strum_macros\": Label(\"//strum_macros-0.28.0\"),\n },\n },\n \"crates/pi-iso\": {\n _COMMON_CONDITION: {\n \"async-trait\": Label(\"//async-trait-0.1.92\"),\n },\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n \"napi-derive\": Label(\"//napi-derive-3.6.3\"),\n },\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_PROC_MACRO_ALIASES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_PROC_MACRO_DEV_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_PROC_MACRO_DEV_ALIASES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-shell\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_BUILD_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n \"napi-build\": Label(\"//napi-build-2.4.1\"),\n \"serde\": Label(\"//serde-1.0.229\"),\n \"serde_json\": Label(\"//serde_json-1.0.151\"),\n },\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_BUILD_ALIASES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_ALIASES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_CONDITIONS = {\n \"aarch64-apple-darwin\": [\"@@//bazel/triples:aarch64-apple-darwin\"],\n \"aarch64-linux-android\": [],\n \"aarch64-pc-windows-gnullvm\": [],\n \"aarch64-unknown-linux-gnu\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\"],\n \"aarch64-unknown-linux-musl\": [\"@@//bazel/triples:aarch64-unknown-linux-musl\"],\n \"cfg(all(all(target_arch = \\\"aarch64\\\", target_endian = \\\"little\\\"), target_os = \\\"windows\\\"))\": [],\n \"cfg(all(all(target_arch = \\\"aarch64\\\", target_endian = \\\"little\\\"), target_vendor = \\\"apple\\\", any(target_os = \\\"ios\\\", target_os = \\\"macos\\\", target_os = \\\"tvos\\\", target_os = \\\"visionos\\\", target_os = \\\"watchos\\\")))\": [\"@@//bazel/triples:aarch64-apple-darwin\"],\n \"cfg(all(any(all(target_arch = \\\"aarch64\\\", target_endian = \\\"little\\\"), all(target_arch = \\\"arm\\\", target_endian = \\\"little\\\")), any(target_os = \\\"android\\\", target_os = \\\"linux\\\")))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\"],\n \"cfg(all(any(target_arch = \\\"x86_64\\\", target_arch = \\\"arm64ec\\\"), target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(all(any(target_os = \\\"android\\\", target_os = \\\"linux\\\"), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", target_arch = \\\"s390x\\\"), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), not(any(all(target_os = \\\"linux\\\", target_env = \\\"\\\"), getrandom_backend = \\\"custom\\\", getrandom_backend = \\\"linux_raw\\\", getrandom_backend = \\\"rdrand\\\", getrandom_backend = \\\"rndr\\\"))))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(not(curve25519_dalek_backend = \\\"fiat\\\"), not(curve25519_dalek_backend = \\\"serial\\\"), target_arch = \\\"x86_64\\\"))\": [\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(not(rustix_use_libc), not(miri), target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\"))))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(not(rustix_use_libc), not(miri), target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", target_arch = \\\"s390x\\\"), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\"))))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(not(windows), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"cfg(all(not(windows), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", target_arch = \\\"s390x\\\"), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_os = \\\"android\\\"))\": [],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_os = \\\"linux\\\"))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\"],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_vendor = \\\"apple\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\"],\n \"cfg(all(target_arch = \\\"loongarch64\\\", target_os = \\\"linux\\\"))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"unknown\\\"))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"wasi\\\", target_env = \\\"p2\\\"))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"gnu\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86_64\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [\"@@//bazel/triples:x86_64-unknown-linux-gnu\"],\n \"cfg(all(target_arch = \\\"x86_64\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(all(target_family = \\\"wasm\\\", target_os = \\\"unknown\\\"))\": [],\n \"cfg(all(target_os = \\\"linux\\\", not(target_env = \\\"ohos\\\")))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(target_os = \\\"uefi\\\", getrandom_backend = \\\"efi_rng\\\"))\": [],\n \"cfg(all(unix, not(any(target_os = \\\"macos\\\", target_os = \\\"android\\\", target_os = \\\"emscripten\\\"))))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(unix, not(target_os = \\\"macos\\\")))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any())\": [],\n \"cfg(any(target_arch = \\\"aarch64\\\", target_arch = \\\"x86\\\", target_arch = \\\"x86_64\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_arch = \\\"aarch64\\\", target_arch = \\\"x86_64\\\", target_arch = \\\"x86\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_arch = \\\"arm\\\", target_pointer_width = \\\"32\\\", target_pointer_width = \\\"64\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_arch = \\\"x86\\\", target_arch = \\\"x86_64\\\"))\": [\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_arch = \\\"x86_64\\\", target_arch = \\\"x86\\\"))\": [\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_os = \\\"android\\\", target_os = \\\"linux\\\"))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_os = \\\"android\\\", target_os = \\\"linux\\\", target_os = \\\"macos\\\", target_os = \\\"hurd\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_os = \\\"dragonfly\\\", target_os = \\\"freebsd\\\", target_os = \\\"hurd\\\", target_os = \\\"illumos\\\", target_os = \\\"cygwin\\\", all(target_os = \\\"horizon\\\", target_arch = \\\"arm\\\")))\": [],\n \"cfg(any(target_os = \\\"freebsd\\\", target_os = \\\"dragonfly\\\"))\": [],\n \"cfg(any(target_os = \\\"freebsd\\\", target_os = \\\"netbsd\\\"))\": [],\n \"cfg(any(target_os = \\\"freebsd\\\", target_os = \\\"openbsd\\\", target_os = \\\"netbsd\\\", target_os = \\\"dragonflybsd\\\", target_os = \\\"ios\\\"))\": [],\n \"cfg(any(target_os = \\\"haiku\\\", target_os = \\\"redox\\\", target_os = \\\"nto\\\", target_os = \\\"aix\\\"))\": [],\n \"cfg(any(target_os = \\\"ios\\\", target_os = \\\"visionos\\\", target_os = \\\"watchos\\\", target_os = \\\"tvos\\\"))\": [],\n \"cfg(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"openbsd\\\", target_os = \\\"vita\\\", target_os = \\\"emscripten\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"windows\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(any(unix, target_os = \\\"fuchsia\\\", target_os = \\\"vxworks\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(unix, target_os = \\\"hermit\\\", target_os = \\\"wasi\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(unix, target_os = \\\"redox\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(unix, target_os = \\\"wasi\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(unix, windows))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(windows, target_os = \\\"linux\\\"))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(curve25519_dalek_backend = \\\"fiat\\\")\": [],\n \"cfg(not(all(target_arch = \\\"arm\\\", target_os = \\\"none\\\")))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(not(any(target_os = \\\"android\\\", target_os = \\\"linux\\\")))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(not(target_arch = \\\"wasm32\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(not(target_has_atomic = \\\"ptr\\\"))\": [],\n \"cfg(not(target_os = \\\"windows\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(not(windows))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(target_arch = \\\"aarch64\\\")\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\"],\n \"cfg(target_arch = \\\"spirv\\\")\": [],\n \"cfg(target_arch = \\\"wasm32\\\")\": [],\n \"cfg(target_arch = \\\"x86\\\")\": [],\n \"cfg(target_arch = \\\"x86_64\\\")\": [\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(target_family = \\\"wasm\\\")\": [],\n \"cfg(target_os = \\\"android\\\")\": [],\n \"cfg(target_os = \\\"freebsd\\\")\": [],\n \"cfg(target_os = \\\"haiku\\\")\": [],\n \"cfg(target_os = \\\"hermit\\\")\": [],\n \"cfg(target_os = \\\"linux\\\")\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(target_os = \\\"macos\\\")\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"cfg(target_os = \\\"netbsd\\\")\": [],\n \"cfg(target_os = \\\"redox\\\")\": [],\n \"cfg(target_os = \\\"solaris\\\")\": [],\n \"cfg(target_os = \\\"vxworks\\\")\": [],\n \"cfg(target_os = \\\"wasi\\\")\": [],\n \"cfg(target_os = \\\"windows\\\")\": [\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(target_vendor = \\\"apple\\\")\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"cfg(unix)\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(windows)\": [\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(windows_raw_dylib)\": [],\n \"i686-pc-windows-gnu\": [],\n \"i686-pc-windows-gnullvm\": [],\n \"wasm32-unknown-unknown\": [],\n \"x86_64-apple-darwin\": [\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"x86_64-pc-windows-gnu\": [],\n \"x86_64-pc-windows-gnullvm\": [],\n \"x86_64-pc-windows-msvc\": [\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"x86_64-unknown-linux-gnu\": [\"@@//bazel/triples:x86_64-unknown-linux-gnu\"],\n \"x86_64-unknown-linux-musl\": [\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n}\n\n###############################################################################\n\ndef crate_repositories():\n \"\"\"A macro for defining repositories for all generated crates.\n\n Returns:\n A list of repos visible to the module through the module extension.\n \"\"\"\n maybe(\n crates_vendor_remote_repository,\n name = \"crates\",\n # Lean interface: just point at `crates.bzl`; the repo rule\n # derives the sibling `BUILD.bazel` and `defs.bzl`.\n crates_module = Label(\"@crates//crates:crates.bzl\"),\n )\n maybe(\n http_archive,\n name = \"crates__adler2-2.0.1\",\n sha256 = \"320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/adler2/2.0.1/download\"],\n strip_prefix = \"adler2-2.0.1\",\n build_file = Label(\"@crates//crates:BUILD.adler2-2.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__aead-0.5.2\",\n sha256 = \"d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aead/0.5.2/download\"],\n strip_prefix = \"aead-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.aead-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__aes-0.8.4\",\n sha256 = \"b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aes/0.8.4/download\"],\n strip_prefix = \"aes-0.8.4\",\n build_file = Label(\"@crates//crates:BUILD.aes-0.8.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__aes-gcm-0.10.3\",\n sha256 = \"831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aes-gcm/0.10.3/download\"],\n strip_prefix = \"aes-gcm-0.10.3\",\n build_file = Label(\"@crates//crates:BUILD.aes-gcm-0.10.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ahash-0.8.12\",\n sha256 = \"5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ahash/0.8.12/download\"],\n strip_prefix = \"ahash-0.8.12\",\n build_file = Label(\"@crates//crates:BUILD.ahash-0.8.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__aho-corasick-1.1.5\",\n sha256 = \"c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aho-corasick/1.1.5/download\"],\n strip_prefix = \"aho-corasick-1.1.5\",\n build_file = Label(\"@crates//crates:BUILD.aho-corasick-1.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__allocator-api2-0.2.21\",\n sha256 = \"683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/allocator-api2/0.2.21/download\"],\n strip_prefix = \"allocator-api2-0.2.21\",\n build_file = Label(\"@crates//crates:BUILD.allocator-api2-0.2.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__android_system_properties-0.1.6\",\n sha256 = \"ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/android_system_properties/0.1.6/download\"],\n strip_prefix = \"android_system_properties-0.1.6\",\n build_file = Label(\"@crates//crates:BUILD.android_system_properties-0.1.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__annotate-snippets-0.11.5\",\n sha256 = \"710e8eae58854cdc1790fcb56cca04d712a17be849eeb81da2a724bf4bae2bc4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/annotate-snippets/0.11.5/download\"],\n strip_prefix = \"annotate-snippets-0.11.5\",\n build_file = Label(\"@crates//crates:BUILD.annotate-snippets-0.11.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ansi-width-0.1.0\",\n sha256 = \"219e3ce6f2611d83b51ec2098a12702112c29e57203a6b0a0929b2cddb486608\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ansi-width/0.1.0/download\"],\n strip_prefix = \"ansi-width-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.ansi-width-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstream-1.0.0\",\n sha256 = \"824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstream/1.0.0/download\"],\n strip_prefix = \"anstream-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstream-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-1.0.14\",\n sha256 = \"940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle/1.0.14/download\"],\n strip_prefix = \"anstyle-1.0.14\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-1.0.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-parse-1.0.0\",\n sha256 = \"52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-parse/1.0.0/download\"],\n strip_prefix = \"anstyle-parse-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-parse-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-query-1.1.5\",\n sha256 = \"40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-query/1.1.5/download\"],\n strip_prefix = \"anstyle-query-1.1.5\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-query-1.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-wincon-3.0.11\",\n sha256 = \"291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-wincon/3.0.11/download\"],\n strip_prefix = \"anstyle-wincon-3.0.11\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-wincon-3.0.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anyhow-1.0.104\",\n sha256 = \"330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anyhow/1.0.104/download\"],\n strip_prefix = \"anyhow-1.0.104\",\n build_file = Label(\"@crates//crates:BUILD.anyhow-1.0.104.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__arboard-3.6.1\",\n sha256 = \"0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/arboard/3.6.1/download\"],\n strip_prefix = \"arboard-3.6.1\",\n build_file = Label(\"@crates//crates:BUILD.arboard-3.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__arc-swap-1.9.2\",\n sha256 = \"c049c0be4daef0b145cb3555416b3b8ef5b7888a38aea1a3a155801fe7b0810b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/arc-swap/1.9.2/download\"],\n strip_prefix = \"arc-swap-1.9.2\",\n build_file = Label(\"@crates//crates:BUILD.arc-swap-1.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__archery-1.2.3\",\n sha256 = \"33ca55ee147b1926dbea904f50fe4902494e97bc742205abbbf10c709e43815f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/archery/1.2.3/download\"],\n strip_prefix = \"archery-1.2.3\",\n build_file = Label(\"@crates//crates:BUILD.archery-1.2.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__argmax-0.3.1\",\n sha256 = \"5b7e3ef5e3a7f2c5e5a49d90ad087c03d38258e75155daac64deb62c50972c66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/argmax/0.3.1/download\"],\n strip_prefix = \"argmax-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.argmax-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__arrayvec-0.7.8\",\n sha256 = \"d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/arrayvec/0.7.8/download\"],\n strip_prefix = \"arrayvec-0.7.8\",\n build_file = Label(\"@crates//crates:BUILD.arrayvec-0.7.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ashpd-0.11.1\",\n sha256 = \"d2f3f79755c74fd155000314eb349864caa787c6592eace6c6882dad873d9c39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ashpd/0.11.1/download\"],\n strip_prefix = \"ashpd-0.11.1\",\n build_file = Label(\"@crates//crates:BUILD.ashpd-0.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__asn1-rs-0.6.2\",\n sha256 = \"5493c3bedbacf7fd7382c6346bbd66687d12bbaad3a89a2d2c303ee6cf20b048\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/asn1-rs/0.6.2/download\"],\n strip_prefix = \"asn1-rs-0.6.2\",\n build_file = Label(\"@crates//crates:BUILD.asn1-rs-0.6.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__asn1-rs-derive-0.5.1\",\n sha256 = \"965c2d33e53cb6b267e148a4cb0760bc01f4904c1cd4bb4002a085bb016d1490\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/asn1-rs-derive/0.5.1/download\"],\n strip_prefix = \"asn1-rs-derive-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.asn1-rs-derive-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__asn1-rs-impl-0.2.0\",\n sha256 = \"7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/asn1-rs-impl/0.2.0/download\"],\n strip_prefix = \"asn1-rs-impl-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.asn1-rs-impl-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ast-grep-core-0.39.9\",\n sha256 = \"057ae90e7256ebf85f840b1638268df0142c9d19467d500b790631fd301acc27\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ast-grep-core/0.39.9/download\"],\n strip_prefix = \"ast-grep-core-0.39.9\",\n build_file = Label(\"@crates//crates:BUILD.ast-grep-core-0.39.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__astral-tl-0.7.11\",\n sha256 = \"d90933ffb0f97e2fc2e0de21da9d3f20597b804012d199843a6fe7c2810d28f3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/astral-tl/0.7.11/download\"],\n strip_prefix = \"astral-tl-0.7.11\",\n build_file = Label(\"@crates//crates:BUILD.astral-tl-0.7.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-broadcast-0.7.2\",\n sha256 = \"435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-broadcast/0.7.2/download\"],\n strip_prefix = \"async-broadcast-0.7.2\",\n build_file = Label(\"@crates//crates:BUILD.async-broadcast-0.7.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-channel-2.5.0\",\n sha256 = \"924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-channel/2.5.0/download\"],\n strip_prefix = \"async-channel-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.async-channel-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-executor-1.14.0\",\n sha256 = \"c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-executor/1.14.0/download\"],\n strip_prefix = \"async-executor-1.14.0\",\n build_file = Label(\"@crates//crates:BUILD.async-executor-1.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-io-2.6.0\",\n sha256 = \"456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-io/2.6.0/download\"],\n strip_prefix = \"async-io-2.6.0\",\n build_file = Label(\"@crates//crates:BUILD.async-io-2.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-lock-3.4.2\",\n sha256 = \"290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-lock/3.4.2/download\"],\n strip_prefix = \"async-lock-3.4.2\",\n build_file = Label(\"@crates//crates:BUILD.async-lock-3.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-process-2.5.0\",\n sha256 = \"fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-process/2.5.0/download\"],\n strip_prefix = \"async-process-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.async-process-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-recursion-1.1.1\",\n sha256 = \"3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-recursion/1.1.1/download\"],\n strip_prefix = \"async-recursion-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.async-recursion-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-signal-0.2.14\",\n sha256 = \"52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-signal/0.2.14/download\"],\n strip_prefix = \"async-signal-0.2.14\",\n build_file = Label(\"@crates//crates:BUILD.async-signal-0.2.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-task-4.7.1\",\n sha256 = \"8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-task/4.7.1/download\"],\n strip_prefix = \"async-task-4.7.1\",\n build_file = Label(\"@crates//crates:BUILD.async-task-4.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-trait-0.1.92\",\n sha256 = \"82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-trait/0.1.92/download\"],\n strip_prefix = \"async-trait-0.1.92\",\n build_file = Label(\"@crates//crates:BUILD.async-trait-0.1.92.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__atomic-waker-1.1.2\",\n sha256 = \"1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/atomic-waker/1.1.2/download\"],\n strip_prefix = \"atomic-waker-1.1.2\",\n build_file = Label(\"@crates//crates:BUILD.atomic-waker-1.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__atspi-0.30.0\",\n sha256 = \"6bf601cccedfffec598ec2db1f9d6745885458bccc0e8916d7023f017c94b3d0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/atspi/0.30.0/download\"],\n strip_prefix = \"atspi-0.30.0\",\n build_file = Label(\"@crates//crates:BUILD.atspi-0.30.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__atspi-common-0.14.0\",\n sha256 = \"f8a79bed3f5b408ce3152f36e07327a845e6ed5d7e2821a89264037dbcc11daf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/atspi-common/0.14.0/download\"],\n strip_prefix = \"atspi-common-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.atspi-common-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__atspi-connection-0.14.0\",\n sha256 = \"8fab8e4f574f5a7d3af280b38eff25fb6f47a537dac9ae39ce152f52b19fb10b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/atspi-connection/0.14.0/download\"],\n strip_prefix = \"atspi-connection-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.atspi-connection-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__atspi-proxies-0.14.0\",\n sha256 = \"53403acd3ab2fdb5914f6558da22e540fc07656fce5510f8c02be0e6ef68413e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/atspi-proxies/0.14.0/download\"],\n strip_prefix = \"atspi-proxies-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.atspi-proxies-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__audiopus_sys-0.2.2\",\n patch_args = [\n \"-p1\",\n ],\n patches = [\n \"@@//bazel/patches:audiopus-sys-libdir.patch\",\n ],\n sha256 = \"62314a1546a2064e033665d658e88c620a62904be945f8147e6b16c3db9f8651\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/audiopus_sys/0.2.2/download\"],\n strip_prefix = \"audiopus_sys-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.audiopus_sys-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__autocfg-1.5.1\",\n sha256 = \"f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/autocfg/1.5.1/download\"],\n strip_prefix = \"autocfg-1.5.1\",\n build_file = Label(\"@crates//crates:BUILD.autocfg-1.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base16ct-0.2.0\",\n sha256 = \"4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base16ct/0.2.0/download\"],\n strip_prefix = \"base16ct-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.base16ct-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64-0.22.1\",\n sha256 = \"72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64/0.22.1/download\"],\n strip_prefix = \"base64-0.22.1\",\n build_file = Label(\"@crates//crates:BUILD.base64-0.22.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64-0.23.1\",\n sha256 = \"ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64/0.23.1/download\"],\n strip_prefix = \"base64-0.23.1\",\n build_file = Label(\"@crates//crates:BUILD.base64-0.23.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64-simd-0.8.0\",\n sha256 = \"339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64-simd/0.8.0/download\"],\n strip_prefix = \"base64-simd-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.base64-simd-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64ct-1.8.3\",\n sha256 = \"2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64ct/1.8.3/download\"],\n strip_prefix = \"base64ct-1.8.3\",\n build_file = Label(\"@crates//crates:BUILD.base64ct-1.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bigdecimal-0.4.10\",\n sha256 = \"4d6867f1565b3aad85681f1015055b087fcfd840d6aeee6eee7f2da317603695\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bigdecimal/0.4.10/download\"],\n strip_prefix = \"bigdecimal-0.4.10\",\n build_file = Label(\"@crates//crates:BUILD.bigdecimal-0.4.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__binary-heap-plus-0.5.0\",\n sha256 = \"e4551d8382e911ecc0d0f0ffb602777988669be09447d536ff4388d1def11296\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/binary-heap-plus/0.5.0/download\"],\n strip_prefix = \"binary-heap-plus-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.binary-heap-plus-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bincode-1.3.3\",\n sha256 = \"b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bincode/1.3.3/download\"],\n strip_prefix = \"bincode-1.3.3\",\n build_file = Label(\"@crates//crates:BUILD.bincode-1.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bindgen-0.72.1\",\n sha256 = \"993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bindgen/0.72.1/download\"],\n strip_prefix = \"bindgen-0.72.1\",\n build_file = Label(\"@crates//crates:BUILD.bindgen-0.72.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-set-0.8.0\",\n sha256 = \"08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-set/0.8.0/download\"],\n strip_prefix = \"bit-set-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-set-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-vec-0.8.0\",\n sha256 = \"5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-vec/0.8.0/download\"],\n strip_prefix = \"bit-vec-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-vec-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-1.3.2\",\n sha256 = \"bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/1.3.2/download\"],\n strip_prefix = \"bitflags-1.3.2\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-1.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-2.13.1\",\n sha256 = \"b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/2.13.1/download\"],\n strip_prefix = \"bitflags-2.13.1\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-2.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitvec-1.1.1\",\n sha256 = \"ddcec3d12c579d40898fe0a9a358a803c23e9c52ca3c425707f81c9436211837\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitvec/1.1.1/download\"],\n strip_prefix = \"bitvec-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.bitvec-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__blake2b_simd-1.0.5\",\n sha256 = \"3560a7b1951efe814fcd721938313adc56753ca39f4b23847d7e9a2402f5dbff\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/blake2b_simd/1.0.5/download\"],\n strip_prefix = \"blake2b_simd-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.blake2b_simd-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__blake3-1.8.7\",\n sha256 = \"6d9e454fc11f76977dc803893aff6304ed33d6a26efae8696573bea74baa27ae\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/blake3/1.8.7/download\"],\n strip_prefix = \"blake3-1.8.7\",\n build_file = Label(\"@crates//crates:BUILD.blake3-1.8.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__block-buffer-0.10.4\",\n sha256 = \"3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/block-buffer/0.10.4/download\"],\n strip_prefix = \"block-buffer-0.10.4\",\n build_file = Label(\"@crates//crates:BUILD.block-buffer-0.10.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__block-buffer-0.12.1\",\n sha256 = \"d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/block-buffer/0.12.1/download\"],\n strip_prefix = \"block-buffer-0.12.1\",\n build_file = Label(\"@crates//crates:BUILD.block-buffer-0.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__block-padding-0.3.3\",\n sha256 = \"a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/block-padding/0.3.3/download\"],\n strip_prefix = \"block-padding-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.block-padding-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__block2-0.6.2\",\n sha256 = \"cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/block2/0.6.2/download\"],\n strip_prefix = \"block2-0.6.2\",\n build_file = Label(\"@crates//crates:BUILD.block2-0.6.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__blocking-1.6.2\",\n sha256 = \"e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/blocking/1.6.2/download\"],\n strip_prefix = \"blocking-1.6.2\",\n build_file = Label(\"@crates//crates:BUILD.blocking-1.6.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bon-3.9.3\",\n sha256 = \"a602c73c7b0148ec6d12af6fd5cc7a46e2eacc8878271a999abac56eed12f561\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bon/3.9.3/download\"],\n strip_prefix = \"bon-3.9.3\",\n build_file = Label(\"@crates//crates:BUILD.bon-3.9.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bon-macros-3.9.3\",\n sha256 = \"6dee98b0db6a962de883bf5d20362dee4d7ca0d12fe39a7c6c73c844e1cd7c1f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bon-macros/3.9.3/download\"],\n strip_prefix = \"bon-macros-3.9.3\",\n build_file = Label(\"@crates//crates:BUILD.bon-macros-3.9.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__brush-parser-0.3.0\",\n sha256 = \"f7367124d4f38fdcd65f4b815bda7caeb3de377b9cd95ffa1b23627989c93718\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/brush-parser/0.3.0/download\"],\n strip_prefix = \"brush-parser-0.3.0\",\n build_file = Label(\"@crates//crates:BUILD.brush-parser-0.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__brush-parser-0.4.0\",\n sha256 = \"9f64b19efc02f0dd6cac1d462e20a1098f425f09cb13624efbb1b7d63f061735\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/brush-parser/0.4.0/download\"],\n strip_prefix = \"brush-parser-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.brush-parser-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bstr-1.13.1\",\n sha256 = \"6bb31b46c14244e20ee9984b11bf5c992b91fb6939fea616e3512c8baecdbe5f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bstr/1.13.1/download\"],\n strip_prefix = \"bstr-1.13.1\",\n build_file = Label(\"@crates//crates:BUILD.bstr-1.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bumpalo-3.20.3\",\n sha256 = \"72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bumpalo/3.20.3/download\"],\n strip_prefix = \"bumpalo-3.20.3\",\n build_file = Label(\"@crates//crates:BUILD.bumpalo-3.20.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__by_address-1.2.1\",\n sha256 = \"64fa3c856b712db6612c019f14756e64e4bcea13337a6b33b696333a9eaa2d06\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/by_address/1.2.1/download\"],\n strip_prefix = \"by_address-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.by_address-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytecheck-0.8.3\",\n sha256 = \"26333eeac754f0ad8a6bcd0eb0ac012156302e4e16b852b72ee399aea4f12c29\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytecheck/0.8.3/download\"],\n strip_prefix = \"bytecheck-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.bytecheck-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytecheck_derive-0.8.3\",\n sha256 = \"46d07918caa9eeaaf06b7873925c53a61daac173539b4f7715090745e44e4e69\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytecheck_derive/0.8.3/download\"],\n strip_prefix = \"bytecheck_derive-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.bytecheck_derive-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytecount-0.6.9\",\n sha256 = \"175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytecount/0.6.9/download\"],\n strip_prefix = \"bytecount-0.6.9\",\n build_file = Label(\"@crates//crates:BUILD.bytecount-0.6.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytemuck-1.25.2\",\n sha256 = \"95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytemuck/1.25.2/download\"],\n strip_prefix = \"bytemuck-1.25.2\",\n build_file = Label(\"@crates//crates:BUILD.bytemuck-1.25.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytemuck_derive-1.12.0\",\n sha256 = \"fc0e56a716f1e132ff6bf4bdac1c944a3fcdc1cae65f70a4a2a1ac3b401d2d1f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytemuck_derive/1.12.0/download\"],\n strip_prefix = \"bytemuck_derive-1.12.0\",\n build_file = Label(\"@crates//crates:BUILD.bytemuck_derive-1.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__byteorder-1.5.0\",\n sha256 = \"1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/byteorder/1.5.0/download\"],\n strip_prefix = \"byteorder-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.byteorder-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__byteorder-lite-0.1.0\",\n sha256 = \"8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/byteorder-lite/0.1.0/download\"],\n strip_prefix = \"byteorder-lite-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.byteorder-lite-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytes-1.12.1\",\n sha256 = \"fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytes/1.12.1/download\"],\n strip_prefix = \"bytes-1.12.1\",\n build_file = Label(\"@crates//crates:BUILD.bytes-1.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cached-0.56.0\",\n sha256 = \"801927ee168e17809ab8901d9f01f700cd7d8d6a6527997fee44e4b0327a253c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cached/0.56.0/download\"],\n strip_prefix = \"cached-0.56.0\",\n build_file = Label(\"@crates//crates:BUILD.cached-0.56.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cached-0.59.0\",\n sha256 = \"53b6f5d101f0f6322c8646a45b7c581a673e476329040d97565815c2461dd0c4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cached/0.59.0/download\"],\n strip_prefix = \"cached-0.59.0\",\n build_file = Label(\"@crates//crates:BUILD.cached-0.59.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cached_proc_macro-0.25.0\",\n sha256 = \"9225bdcf4e4a9a4c08bf16607908eb2fbf746828d5e0b5e019726dbf6571f201\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cached_proc_macro/0.25.0/download\"],\n strip_prefix = \"cached_proc_macro-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.cached_proc_macro-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cached_proc_macro-0.27.0\",\n sha256 = \"8ebcf9c75f17a17d55d11afc98e46167d4790a263f428891b8705ab2f793eca3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cached_proc_macro/0.27.0/download\"],\n strip_prefix = \"cached_proc_macro-0.27.0\",\n build_file = Label(\"@crates//crates:BUILD.cached_proc_macro-0.27.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cached_proc_macro_types-0.1.1\",\n sha256 = \"ade8366b8bd5ba243f0a58f036cc0ca8a2f069cff1a2351ef1cac6b083e16fc0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cached_proc_macro_types/0.1.1/download\"],\n strip_prefix = \"cached_proc_macro_types-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.cached_proc_macro_types-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__calendrical_calculations-0.2.4\",\n sha256 = \"5abbd6eeda6885048d357edc66748eea6e0268e3dd11f326fff5bd248d779c26\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/calendrical_calculations/0.2.4/download\"],\n strip_prefix = \"calendrical_calculations-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.calendrical_calculations-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cbc-0.1.2\",\n sha256 = \"26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cbc/0.1.2/download\"],\n strip_prefix = \"cbc-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.cbc-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cc-1.2.67\",\n sha256 = \"e17dd265a7d0f31ef544e1b20e03add05d3b45b491b633b10d67145d2acc1a38\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cc/1.2.67/download\"],\n strip_prefix = \"cc-1.2.67\",\n build_file = Label(\"@crates//crates:BUILD.cc-1.2.67.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ccm-0.5.0\",\n sha256 = \"9ae3c82e4355234767756212c570e29833699ab63e6ffd161887314cc5b43847\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ccm/0.5.0/download\"],\n strip_prefix = \"ccm-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.ccm-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cexpr-0.6.0\",\n sha256 = \"6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cexpr/0.6.0/download\"],\n strip_prefix = \"cexpr-0.6.0\",\n build_file = Label(\"@crates//crates:BUILD.cexpr-0.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg-expr-0.20.9\",\n sha256 = \"fe4ece8474b5f766c63426647e7b4b316b67431ade1036a8313cee24a03ae917\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg-expr/0.20.9/download\"],\n strip_prefix = \"cfg-expr-0.20.9\",\n build_file = Label(\"@crates//crates:BUILD.cfg-expr-0.20.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg-if-1.0.4\",\n sha256 = \"9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg-if/1.0.4/download\"],\n strip_prefix = \"cfg-if-1.0.4\",\n build_file = Label(\"@crates//crates:BUILD.cfg-if-1.0.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg_aliases-0.1.1\",\n sha256 = \"fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg_aliases/0.1.1/download\"],\n strip_prefix = \"cfg_aliases-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.cfg_aliases-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg_aliases-0.2.2\",\n sha256 = \"f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg_aliases/0.2.2/download\"],\n strip_prefix = \"cfg_aliases-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.cfg_aliases-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chacha20-0.10.1\",\n sha256 = \"d524456ba66e72eb8b115ff89e01e497f8e6d11d78b70b1aa13c0fbd97540a81\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chacha20/0.10.1/download\"],\n strip_prefix = \"chacha20-0.10.1\",\n build_file = Label(\"@crates//crates:BUILD.chacha20-0.10.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chacha20-0.9.1\",\n sha256 = \"c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chacha20/0.9.1/download\"],\n strip_prefix = \"chacha20-0.9.1\",\n build_file = Label(\"@crates//crates:BUILD.chacha20-0.9.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chacha20poly1305-0.10.1\",\n sha256 = \"10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chacha20poly1305/0.10.1/download\"],\n strip_prefix = \"chacha20poly1305-0.10.1\",\n build_file = Label(\"@crates//crates:BUILD.chacha20poly1305-0.10.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__check_elevation-0.2.7\",\n sha256 = \"a7fe1fbbd8bd3174109071530f12932ff471eeff30d83e9c485d6ff424ac534b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/check_elevation/0.2.7/download\"],\n strip_prefix = \"check_elevation-0.2.7\",\n build_file = Label(\"@crates//crates:BUILD.check_elevation-0.2.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chrono-0.4.45\",\n sha256 = \"1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chrono/0.4.45/download\"],\n strip_prefix = \"chrono-0.4.45\",\n build_file = Label(\"@crates//crates:BUILD.chrono-0.4.45.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cipher-0.4.4\",\n sha256 = \"773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cipher/0.4.4/download\"],\n strip_prefix = \"cipher-0.4.4\",\n build_file = Label(\"@crates//crates:BUILD.cipher-0.4.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clang-sys-1.9.1\",\n sha256 = \"157a8ba7b480713b56f4c09fd13fc3e0a22a5dfab8097ba61cbc5feef950788a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clang-sys/1.9.1/download\"],\n strip_prefix = \"clang-sys-1.9.1\",\n build_file = Label(\"@crates//crates:BUILD.clang-sys-1.9.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap-4.6.6\",\n sha256 = \"473c7e07f409a8d772161724aa8db6a765a2532a70f9667eeb7b49d3d02fbdca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap/4.6.6/download\"],\n strip_prefix = \"clap-4.6.6\",\n build_file = Label(\"@crates//crates:BUILD.clap-4.6.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_builder-4.6.6\",\n sha256 = \"7b48fea5a88e9ae728a2dcbedbfc0e730f7d60da42e1cb049a83c9fb8b789889\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_builder/4.6.6/download\"],\n strip_prefix = \"clap_builder-4.6.6\",\n build_file = Label(\"@crates//crates:BUILD.clap_builder-4.6.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_derive-4.6.4\",\n sha256 = \"d012d2b9d65aca7f18f4d9878a045bc17899bba951561ba5ec3c2ba1eed9a061\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_derive/4.6.4/download\"],\n strip_prefix = \"clap_derive-4.6.4\",\n build_file = Label(\"@crates//crates:BUILD.clap_derive-4.6.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_lex-1.1.0\",\n sha256 = \"c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_lex/1.1.0/download\"],\n strip_prefix = \"clap_lex-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.clap_lex-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clipboard-win-5.4.1\",\n sha256 = \"bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clipboard-win/5.4.1/download\"],\n strip_prefix = \"clipboard-win-5.4.1\",\n build_file = Label(\"@crates//crates:BUILD.clipboard-win-5.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cmake-0.1.58\",\n sha256 = \"c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cmake/0.1.58/download\"],\n strip_prefix = \"cmake-0.1.58\",\n build_file = Label(\"@crates//crates:BUILD.cmake-0.1.58.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codesnake-0.2.1\",\n sha256 = \"2205f7f6d3de68ecf4c291c789b3edf07b6569268abd0188819086f71ae42225\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codesnake/0.2.1/download\"],\n strip_prefix = \"codesnake-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.codesnake-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__color-print-0.3.7\",\n sha256 = \"3aa954171903797d5623e047d9ab69d91b493657917bdfb8c2c80ecaf9cdb6f4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/color-print/0.3.7/download\"],\n strip_prefix = \"color-print-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.color-print-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__color-print-proc-macro-0.3.7\",\n sha256 = \"692186b5ebe54007e45a59aea47ece9eb4108e141326c304cdc91699a7118a22\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/color-print-proc-macro/0.3.7/download\"],\n strip_prefix = \"color-print-proc-macro-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.color-print-proc-macro-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__color_quant-1.1.0\",\n sha256 = \"3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/color_quant/1.1.0/download\"],\n strip_prefix = \"color_quant-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.color_quant-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__colorchoice-1.0.5\",\n sha256 = \"1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/colorchoice/1.0.5/download\"],\n strip_prefix = \"colorchoice-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.colorchoice-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__command-fds-0.3.3\",\n sha256 = \"1b60b5124979fccd9addd89d8b97a1d6eebb4950694520c75ddd722535ea443f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/command-fds/0.3.3/download\"],\n strip_prefix = \"command-fds-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.command-fds-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__compare-0.1.0\",\n sha256 = \"120133d4db2ec47efe2e26502ee984747630c67f51974fca0b6c1340cf2368d3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/compare/0.1.0/download\"],\n strip_prefix = \"compare-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.compare-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__concurrent-queue-2.5.0\",\n sha256 = \"4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/concurrent-queue/2.5.0/download\"],\n strip_prefix = \"concurrent-queue-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.concurrent-queue-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__console-0.16.4\",\n sha256 = \"4fe5f465a4f6fee88fad41b85d990f84c835335e85b5d9e6e63e0d06d28cba7c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/console/0.16.4/download\"],\n strip_prefix = \"console-0.16.4\",\n build_file = Label(\"@crates//crates:BUILD.console-0.16.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__const-oid-0.10.2\",\n sha256 = \"a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/const-oid/0.10.2/download\"],\n strip_prefix = \"const-oid-0.10.2\",\n build_file = Label(\"@crates//crates:BUILD.const-oid-0.10.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__const-oid-0.9.6\",\n sha256 = \"c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/const-oid/0.9.6/download\"],\n strip_prefix = \"const-oid-0.9.6\",\n build_file = Label(\"@crates//crates:BUILD.const-oid-0.9.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__const-random-0.1.18\",\n sha256 = \"87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/const-random/0.1.18/download\"],\n strip_prefix = \"const-random-0.1.18\",\n build_file = Label(\"@crates//crates:BUILD.const-random-0.1.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__const-random-macro-0.1.16\",\n sha256 = \"f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/const-random-macro/0.1.16/download\"],\n strip_prefix = \"const-random-macro-0.1.16\",\n build_file = Label(\"@crates//crates:BUILD.const-random-macro-0.1.16.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__constant_time_eq-0.4.2\",\n sha256 = \"3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/constant_time_eq/0.4.2/download\"],\n strip_prefix = \"constant_time_eq-0.4.2\",\n build_file = Label(\"@crates//crates:BUILD.constant_time_eq-0.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__convert_case-0.11.0\",\n sha256 = \"affbf0190ed2caf063e3def54ff444b449371d55c58e513a95ab98eca50adb49\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/convert_case/0.11.0/download\"],\n strip_prefix = \"convert_case-0.11.0\",\n build_file = Label(\"@crates//crates:BUILD.convert_case-0.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__convert_case-0.8.0\",\n sha256 = \"baaaa0ecca5b51987b9423ccdc971514dd8b0bb7b4060b983d3664dad3f1f89f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/convert_case/0.8.0/download\"],\n strip_prefix = \"convert_case-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.convert_case-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cookie-factory-0.3.3\",\n sha256 = \"9885fa71e26b8ab7855e2ec7cae6e9b380edff76cd052e07c683a0319d51b3a2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cookie-factory/0.3.3/download\"],\n strip_prefix = \"cookie-factory-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.cookie-factory-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__core-foundation-0.10.1\",\n sha256 = \"b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/core-foundation/0.10.1/download\"],\n strip_prefix = \"core-foundation-0.10.1\",\n build_file = Label(\"@crates//crates:BUILD.core-foundation-0.10.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__core-foundation-sys-0.8.7\",\n sha256 = \"773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/core-foundation-sys/0.8.7/download\"],\n strip_prefix = \"core-foundation-sys-0.8.7\",\n build_file = Label(\"@crates//crates:BUILD.core-foundation-sys-0.8.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__core-graphics-0.25.0\",\n sha256 = \"064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/core-graphics/0.25.0/download\"],\n strip_prefix = \"core-graphics-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.core-graphics-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__core-graphics-types-0.2.0\",\n sha256 = \"3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/core-graphics-types/0.2.0/download\"],\n strip_prefix = \"core-graphics-types-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.core-graphics-types-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__core_maths-0.1.1\",\n sha256 = \"77745e017f5edba1a9c1d854f6f3a52dac8a12dd5af5d2f54aecf61e43d80d30\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/core_maths/0.1.1/download\"],\n strip_prefix = \"core_maths-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.core_maths-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cpufeatures-0.2.17\",\n sha256 = \"59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cpufeatures/0.2.17/download\"],\n strip_prefix = \"cpufeatures-0.2.17\",\n build_file = Label(\"@crates//crates:BUILD.cpufeatures-0.2.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cpufeatures-0.3.0\",\n sha256 = \"8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cpufeatures/0.3.0/download\"],\n strip_prefix = \"cpufeatures-0.3.0\",\n build_file = Label(\"@crates//crates:BUILD.cpufeatures-0.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crc-3.4.0\",\n sha256 = \"5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crc/3.4.0/download\"],\n strip_prefix = \"crc-3.4.0\",\n build_file = Label(\"@crates//crates:BUILD.crc-3.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crc-catalog-2.5.0\",\n sha256 = \"217698eaf96b4a3f0bc4f3662aaa55bdf913cd54d7204591faa790070c6d0853\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crc-catalog/2.5.0/download\"],\n strip_prefix = \"crc-catalog-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.crc-catalog-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crc-fast-1.8.2\",\n sha256 = \"85d9be5297a59f1b7651fd2711a1f4461929f53b182b394df0df15b3a387ef51\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crc-fast/1.8.2/download\"],\n strip_prefix = \"crc-fast-1.8.2\",\n build_file = Label(\"@crates//crates:BUILD.crc-fast-1.8.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crc32fast-1.5.0\",\n sha256 = \"9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crc32fast/1.5.0/download\"],\n strip_prefix = \"crc32fast-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.crc32fast-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-deque-0.8.7\",\n sha256 = \"5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-deque/0.8.7/download\"],\n strip_prefix = \"crossbeam-deque-0.8.7\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-deque-0.8.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-epoch-0.9.20\",\n sha256 = \"2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-epoch/0.9.20/download\"],\n strip_prefix = \"crossbeam-epoch-0.9.20\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-epoch-0.9.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-utils-0.8.22\",\n sha256 = \"61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-utils/0.8.22/download\"],\n strip_prefix = \"crossbeam-utils-0.8.22\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-utils-0.8.22.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crunchy-0.2.4\",\n sha256 = \"460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crunchy/0.2.4/download\"],\n strip_prefix = \"crunchy-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.crunchy-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crypto-bigint-0.5.5\",\n sha256 = \"0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crypto-bigint/0.5.5/download\"],\n strip_prefix = \"crypto-bigint-0.5.5\",\n build_file = Label(\"@crates//crates:BUILD.crypto-bigint-0.5.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crypto-common-0.1.7\",\n sha256 = \"78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crypto-common/0.1.7/download\"],\n strip_prefix = \"crypto-common-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.crypto-common-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crypto-common-0.2.2\",\n sha256 = \"ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crypto-common/0.2.2/download\"],\n strip_prefix = \"crypto-common-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.crypto-common-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ctor-1.0.13\",\n sha256 = \"914a755b7c2d4af2bdcff7ce1739e2db9a1b81a9b07123d8015786ae03c0980d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ctor/1.0.13/download\"],\n strip_prefix = \"ctor-1.0.13\",\n build_file = Label(\"@crates//crates:BUILD.ctor-1.0.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ctr-0.9.2\",\n sha256 = \"0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ctr/0.9.2/download\"],\n strip_prefix = \"ctr-0.9.2\",\n build_file = Label(\"@crates//crates:BUILD.ctr-0.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__curve25519-dalek-4.1.3\",\n sha256 = \"97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/curve25519-dalek/4.1.3/download\"],\n strip_prefix = \"curve25519-dalek-4.1.3\",\n build_file = Label(\"@crates//crates:BUILD.curve25519-dalek-4.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__curve25519-dalek-derive-0.1.1\",\n sha256 = \"f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/curve25519-dalek-derive/0.1.1/download\"],\n strip_prefix = \"curve25519-dalek-derive-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.curve25519-dalek-derive-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling-0.20.11\",\n sha256 = \"fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling/0.20.11/download\"],\n strip_prefix = \"darling-0.20.11\",\n build_file = Label(\"@crates//crates:BUILD.darling-0.20.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling-0.23.0\",\n sha256 = \"25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling/0.23.0/download\"],\n strip_prefix = \"darling-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_core-0.20.11\",\n sha256 = \"0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_core/0.20.11/download\"],\n strip_prefix = \"darling_core-0.20.11\",\n build_file = Label(\"@crates//crates:BUILD.darling_core-0.20.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_core-0.23.0\",\n sha256 = \"9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_core/0.23.0/download\"],\n strip_prefix = \"darling_core-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling_core-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_macro-0.20.11\",\n sha256 = \"fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_macro/0.20.11/download\"],\n strip_prefix = \"darling_macro-0.20.11\",\n build_file = Label(\"@crates//crates:BUILD.darling_macro-0.20.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_macro-0.23.0\",\n sha256 = \"ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_macro/0.23.0/download\"],\n strip_prefix = \"darling_macro-0.23.0\",\n build_file = Label(\"@crates//crates:BUILD.darling_macro-0.23.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dashmap-6.2.1\",\n sha256 = \"e6361d5c062261c78a176addb82d4c821ae42bed6089de0e12603cd25de2059c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dashmap/6.2.1/download\"],\n strip_prefix = \"dashmap-6.2.1\",\n build_file = Label(\"@crates//crates:BUILD.dashmap-6.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__data-encoding-2.11.1\",\n sha256 = \"4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/data-encoding/2.11.1/download\"],\n strip_prefix = \"data-encoding-2.11.1\",\n build_file = Label(\"@crates//crates:BUILD.data-encoding-2.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__data-encoding-macro-0.1.21\",\n sha256 = \"c6a127ecbb3c4632e1525380e04c0c3fcf8dcb44d32a79ea290d8a36906edcd8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/data-encoding-macro/0.1.21/download\"],\n strip_prefix = \"data-encoding-macro-0.1.21\",\n build_file = Label(\"@crates//crates:BUILD.data-encoding-macro-0.1.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__data-encoding-macro-internal-0.1.19\",\n sha256 = \"c54e03a951783e8b327515db3f2a2fd0e3bed362a96b066f341ce66ed49b4ead\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/data-encoding-macro-internal/0.1.19/download\"],\n strip_prefix = \"data-encoding-macro-internal-0.1.19\",\n build_file = Label(\"@crates//crates:BUILD.data-encoding-macro-internal-0.1.19.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__defmt-1.1.1\",\n sha256 = \"e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/defmt/1.1.1/download\"],\n strip_prefix = \"defmt-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.defmt-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__defmt-macros-1.1.1\",\n sha256 = \"bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/defmt-macros/1.1.1/download\"],\n strip_prefix = \"defmt-macros-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.defmt-macros-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__defmt-parser-1.0.0\",\n sha256 = \"10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/defmt-parser/1.0.0/download\"],\n strip_prefix = \"defmt-parser-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.defmt-parser-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__der-0.7.10\",\n sha256 = \"e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/der/0.7.10/download\"],\n strip_prefix = \"der-0.7.10\",\n build_file = Label(\"@crates//crates:BUILD.der-0.7.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__der-parser-9.0.0\",\n sha256 = \"5cd0a5c643689626bec213c4d8bd4d96acc8ffdb4ad4bb6bc16abf27d5f4b553\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/der-parser/9.0.0/download\"],\n strip_prefix = \"der-parser-9.0.0\",\n build_file = Label(\"@crates//crates:BUILD.der-parser-9.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__deranged-0.5.8\",\n sha256 = \"7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/deranged/0.5.8/download\"],\n strip_prefix = \"deranged-0.5.8\",\n build_file = Label(\"@crates//crates:BUILD.deranged-0.5.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__diff-0.1.13\",\n sha256 = \"56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/diff/0.1.13/download\"],\n strip_prefix = \"diff-0.1.13\",\n build_file = Label(\"@crates//crates:BUILD.diff-0.1.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__digest-0.10.7\",\n sha256 = \"9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/digest/0.10.7/download\"],\n strip_prefix = \"digest-0.10.7\",\n build_file = Label(\"@crates//crates:BUILD.digest-0.10.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__digest-0.11.3\",\n sha256 = \"f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/digest/0.11.3/download\"],\n strip_prefix = \"digest-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.digest-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dispatch2-0.3.1\",\n sha256 = \"1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dispatch2/0.3.1/download\"],\n strip_prefix = \"dispatch2-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.dispatch2-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__displaydoc-0.2.7\",\n sha256 = \"c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/displaydoc/0.2.7/download\"],\n strip_prefix = \"displaydoc-0.2.7\",\n build_file = Label(\"@crates//crates:BUILD.displaydoc-0.2.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dlib-0.5.3\",\n sha256 = \"ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dlib/0.5.3/download\"],\n strip_prefix = \"dlib-0.5.3\",\n build_file = Label(\"@crates//crates:BUILD.dlib-0.5.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dns-lookup-3.0.1\",\n sha256 = \"6e39034cee21a2f5bbb66ba0e3689819c4bb5d00382a282006e802a7ffa6c41d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dns-lookup/3.0.1/download\"],\n strip_prefix = \"dns-lookup-3.0.1\",\n build_file = Label(\"@crates//crates:BUILD.dns-lookup-3.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__downcast-rs-1.2.1\",\n sha256 = \"75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/downcast-rs/1.2.1/download\"],\n strip_prefix = \"downcast-rs-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.downcast-rs-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__drm-0.14.1\",\n sha256 = \"80bc8c5c6c2941f70a55c15f8d9f00f9710ebda3ffda98075f996a0e6c92756f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/drm/0.14.1/download\"],\n strip_prefix = \"drm-0.14.1\",\n build_file = Label(\"@crates//crates:BUILD.drm-0.14.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__drm-0.15.0\",\n sha256 = \"7a41816e58f47f49acfd956651055ddcf137c4882c2098c30c448817af21183a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/drm/0.15.0/download\"],\n strip_prefix = \"drm-0.15.0\",\n build_file = Label(\"@crates//crates:BUILD.drm-0.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__drm-ffi-0.9.1\",\n sha256 = \"51a91c9b32ac4e8105dec255e849e0d66e27d7c34d184364fb93e469db08f690\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/drm-ffi/0.9.1/download\"],\n strip_prefix = \"drm-ffi-0.9.1\",\n build_file = Label(\"@crates//crates:BUILD.drm-ffi-0.9.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__drm-fourcc-2.2.0\",\n sha256 = \"0aafbcdb8afc29c1a7ee5fbe53b5d62f4565b35a042a662ca9fecd0b54dae6f4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/drm-fourcc/2.2.0/download\"],\n strip_prefix = \"drm-fourcc-2.2.0\",\n build_file = Label(\"@crates//crates:BUILD.drm-fourcc-2.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__drm-sys-0.8.1\",\n sha256 = \"ecc8e1361066d91f5ffccff060a3c3be9c3ecde15be2959c1937595f7a82a9f8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/drm-sys/0.8.1/download\"],\n strip_prefix = \"drm-sys-0.8.1\",\n build_file = Label(\"@crates//crates:BUILD.drm-sys-0.8.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dtls-0.17.2\",\n sha256 = \"01a431e87fc386bd5e02deb554a013f97bc406e47a7d8e97efb7c6366b980e9c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dtls/0.17.2/download\"],\n strip_prefix = \"dtls-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.dtls-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dunce-1.0.5\",\n sha256 = \"92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dunce/1.0.5/download\"],\n strip_prefix = \"dunce-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.dunce-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dyn-clone-1.0.20\",\n sha256 = \"d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dyn-clone/1.0.20/download\"],\n strip_prefix = \"dyn-clone-1.0.20\",\n build_file = Label(\"@crates//crates:BUILD.dyn-clone-1.0.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ecb-0.1.2\",\n sha256 = \"1a8bfa975b1aec2145850fcaa1c6fe269a16578c44705a532ae3edc92b8881c7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ecb/0.1.2/download\"],\n strip_prefix = \"ecb-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.ecb-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ecdsa-0.16.9\",\n sha256 = \"ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ecdsa/0.16.9/download\"],\n strip_prefix = \"ecdsa-0.16.9\",\n build_file = Label(\"@crates//crates:BUILD.ecdsa-0.16.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__either-1.18.0\",\n sha256 = \"252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/either/1.18.0/download\"],\n strip_prefix = \"either-1.18.0\",\n build_file = Label(\"@crates//crates:BUILD.either-1.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__elliptic-curve-0.13.8\",\n sha256 = \"b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/elliptic-curve/0.13.8/download\"],\n strip_prefix = \"elliptic-curve-0.13.8\",\n build_file = Label(\"@crates//crates:BUILD.elliptic-curve-0.13.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__encode_unicode-1.0.0\",\n sha256 = \"34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/encode_unicode/1.0.0/download\"],\n strip_prefix = \"encode_unicode-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.encode_unicode-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__encoding_rs-0.8.35\",\n sha256 = \"75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/encoding_rs/0.8.35/download\"],\n strip_prefix = \"encoding_rs-0.8.35\",\n build_file = Label(\"@crates//crates:BUILD.encoding_rs-0.8.35.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__encoding_rs_io-0.1.8\",\n sha256 = \"fba3fe847045ecff794b9c138293a80db914678c453ad63fbf0c6a9eb6e00b22\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/encoding_rs_io/0.1.8/download\"],\n strip_prefix = \"encoding_rs_io-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.encoding_rs_io-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__endi-1.1.1\",\n sha256 = \"66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/endi/1.1.1/download\"],\n strip_prefix = \"endi-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.endi-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__enigo-0.6.1\",\n sha256 = \"71c6c56e50f7acae2906a0dcbb34529ca647e40421119ad5d12e7f8ba6e50010\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/enigo/0.6.1/download\"],\n strip_prefix = \"enigo-0.6.1\",\n build_file = Label(\"@crates//crates:BUILD.enigo-0.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__enumflags2-0.7.12\",\n sha256 = \"1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/enumflags2/0.7.12/download\"],\n strip_prefix = \"enumflags2-0.7.12\",\n build_file = Label(\"@crates//crates:BUILD.enumflags2-0.7.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__enumflags2_derive-0.7.12\",\n sha256 = \"67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/enumflags2_derive/0.7.12/download\"],\n strip_prefix = \"enumflags2_derive-0.7.12\",\n build_file = Label(\"@crates//crates:BUILD.enumflags2_derive-0.7.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__env_filter-2.0.0\",\n sha256 = \"900d271a03799a1ee8d1ca9b19893b48ca674a9284fefcfb85f05e74ed314217\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/env_filter/2.0.0/download\"],\n strip_prefix = \"env_filter-2.0.0\",\n build_file = Label(\"@crates//crates:BUILD.env_filter-2.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__env_logger-0.11.11\",\n sha256 = \"de671bd27a75a797dc9ae289ba1e77276e75e2026408aab65185384e2d5cd3f6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/env_logger/0.11.11/download\"],\n strip_prefix = \"env_logger-0.11.11\",\n build_file = Label(\"@crates//crates:BUILD.env_logger-0.11.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__equivalent-1.0.2\",\n sha256 = \"877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/equivalent/1.0.2/download\"],\n strip_prefix = \"equivalent-1.0.2\",\n build_file = Label(\"@crates//crates:BUILD.equivalent-1.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__errno-0.3.14\",\n sha256 = \"39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/errno/0.3.14/download\"],\n strip_prefix = \"errno-0.3.14\",\n build_file = Label(\"@crates//crates:BUILD.errno-0.3.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__error-code-3.4.0\",\n sha256 = \"0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/error-code/3.4.0/download\"],\n strip_prefix = \"error-code-3.4.0\",\n build_file = Label(\"@crates//crates:BUILD.error-code-3.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__event-listener-5.4.2\",\n sha256 = \"5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/event-listener/5.4.2/download\"],\n strip_prefix = \"event-listener-5.4.2\",\n build_file = Label(\"@crates//crates:BUILD.event-listener-5.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__event-listener-strategy-0.5.4\",\n sha256 = \"8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/event-listener-strategy/0.5.4/download\"],\n strip_prefix = \"event-listener-strategy-0.5.4\",\n build_file = Label(\"@crates//crates:BUILD.event-listener-strategy-0.5.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__faccess-0.2.4\",\n sha256 = \"59ae66425802d6a903e268ae1a08b8c38ba143520f227a205edf4e9c7e3e26d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/faccess/0.2.4/download\"],\n strip_prefix = \"faccess-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.faccess-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fancy-regex-0.16.2\",\n sha256 = \"998b056554fbe42e03ae0e152895cd1a7e1002aec800fdc6635d20270260c46f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fancy-regex/0.16.2/download\"],\n strip_prefix = \"fancy-regex-0.16.2\",\n build_file = Label(\"@crates//crates:BUILD.fancy-regex-0.16.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fancy-regex-0.17.0\",\n sha256 = \"72cf461f865c862bb7dc573f643dd6a2b6842f7c30b07882b56bd148cc2761b8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fancy-regex/0.17.0/download\"],\n strip_prefix = \"fancy-regex-0.17.0\",\n build_file = Label(\"@crates//crates:BUILD.fancy-regex-0.17.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fastrand-2.5.0\",\n sha256 = \"da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fastrand/2.5.0/download\"],\n strip_prefix = \"fastrand-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.fastrand-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fax-0.2.7\",\n sha256 = \"caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fax/0.2.7/download\"],\n strip_prefix = \"fax-0.2.7\",\n build_file = Label(\"@crates//crates:BUILD.fax-0.2.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fdeflate-0.3.7\",\n sha256 = \"1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fdeflate/0.3.7/download\"],\n strip_prefix = \"fdeflate-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.fdeflate-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ff-0.13.1\",\n sha256 = \"c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ff/0.13.1/download\"],\n strip_prefix = \"ff-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.ff-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fiat-crypto-0.2.9\",\n sha256 = \"28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fiat-crypto/0.2.9/download\"],\n strip_prefix = \"fiat-crypto-0.2.9\",\n build_file = Label(\"@crates//crates:BUILD.fiat-crypto-0.2.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__filedescriptor-0.8.3\",\n sha256 = \"e40758ed24c9b2eeb76c35fb0aebc66c626084edd827e07e1552279814c6682d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/filedescriptor/0.8.3/download\"],\n strip_prefix = \"filedescriptor-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.filedescriptor-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__filetime-0.2.29\",\n sha256 = \"5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/filetime/0.2.29/download\"],\n strip_prefix = \"filetime-0.2.29\",\n build_file = Label(\"@crates//crates:BUILD.filetime-0.2.29.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__find-msvc-tools-0.1.11\",\n sha256 = \"d45db016d36b838f563236e9193d0ee6ce38f3f68b6c94e914b4929c96bbb890\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/find-msvc-tools/0.1.11/download\"],\n strip_prefix = \"find-msvc-tools-0.1.11\",\n build_file = Label(\"@crates//crates:BUILD.find-msvc-tools-0.1.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fixed_decimal-0.7.2\",\n sha256 = \"79c3c892f121fff406e5dd6b28c1b30096b95111c30701a899d4f2b18da6d1bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fixed_decimal/0.7.2/download\"],\n strip_prefix = \"fixed_decimal-0.7.2\",\n build_file = Label(\"@crates//crates:BUILD.fixed_decimal-0.7.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fixedbitset-0.5.7\",\n sha256 = \"1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fixedbitset/0.5.7/download\"],\n strip_prefix = \"fixedbitset-0.5.7\",\n build_file = Label(\"@crates//crates:BUILD.fixedbitset-0.5.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__flate2-1.1.9\",\n sha256 = \"843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/flate2/1.1.9/download\"],\n strip_prefix = \"flate2-1.1.9\",\n build_file = Label(\"@crates//crates:BUILD.flate2-1.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-0.17.0\",\n sha256 = \"8137a6d5a2c50d6b0ebfcb9aaa91a28154e0a70605f112d30cb0cd4a78670477\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent/0.17.0/download\"],\n strip_prefix = \"fluent-0.17.0\",\n build_file = Label(\"@crates//crates:BUILD.fluent-0.17.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-bundle-0.16.0\",\n sha256 = \"01203cb8918f5711e73891b347816d932046f95f54207710bda99beaeb423bf4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent-bundle/0.16.0/download\"],\n strip_prefix = \"fluent-bundle-0.16.0\",\n build_file = Label(\"@crates//crates:BUILD.fluent-bundle-0.16.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-langneg-0.13.1\",\n sha256 = \"7eebbe59450baee8282d71676f3bfed5689aeab00b27545e83e5f14b1195e8b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent-langneg/0.13.1/download\"],\n strip_prefix = \"fluent-langneg-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.fluent-langneg-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-syntax-0.12.0\",\n sha256 = \"54f0d287c53ffd184d04d8677f590f4ac5379785529e5e08b1c8083acdd5c198\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent-syntax/0.12.0/download\"],\n strip_prefix = \"fluent-syntax-0.12.0\",\n build_file = Label(\"@crates//crates:BUILD.fluent-syntax-0.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__flume-0.11.1\",\n sha256 = \"da0e4dd2a88388a1f4ccc7c9ce104604dab68d9f408dc34cd45823d5a9069095\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/flume/0.11.1/download\"],\n strip_prefix = \"flume-0.11.1\",\n build_file = Label(\"@crates//crates:BUILD.flume-0.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fnv-1.0.7\",\n sha256 = \"3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fnv/1.0.7/download\"],\n strip_prefix = \"fnv-1.0.7\",\n build_file = Label(\"@crates//crates:BUILD.fnv-1.0.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.1.5\",\n sha256 = \"d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.1.5/download\"],\n strip_prefix = \"foldhash-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.2.0\",\n sha256 = \"77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.2.0/download\"],\n strip_prefix = \"foldhash-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fontdue-0.9.4\",\n sha256 = \"7894823fa221401399e2598f8b63f81ac77ff5c63248b7656779bff1632d7d3d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fontdue/0.9.4/download\"],\n strip_prefix = \"fontdue-0.9.4\",\n build_file = Label(\"@crates//crates:BUILD.fontdue-0.9.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foreign-types-0.5.0\",\n sha256 = \"d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foreign-types/0.5.0/download\"],\n strip_prefix = \"foreign-types-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.foreign-types-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foreign-types-macros-0.2.4\",\n sha256 = \"ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foreign-types-macros/0.2.4/download\"],\n strip_prefix = \"foreign-types-macros-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.foreign-types-macros-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foreign-types-shared-0.3.1\",\n sha256 = \"aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foreign-types-shared/0.3.1/download\"],\n strip_prefix = \"foreign-types-shared-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.foreign-types-shared-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__form_urlencoded-1.2.2\",\n sha256 = \"cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/form_urlencoded/1.2.2/download\"],\n strip_prefix = \"form_urlencoded-1.2.2\",\n build_file = Label(\"@crates//crates:BUILD.form_urlencoded-1.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fs_extra-1.3.0\",\n sha256 = \"42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fs_extra/1.3.0/download\"],\n strip_prefix = \"fs_extra-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.fs_extra-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fsevent-sys-4.1.0\",\n sha256 = \"76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fsevent-sys/4.1.0/download\"],\n strip_prefix = \"fsevent-sys-4.1.0\",\n build_file = Label(\"@crates//crates:BUILD.fsevent-sys-4.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__funty-2.0.0\",\n sha256 = \"e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/funty/2.0.0/download\"],\n strip_prefix = \"funty-2.0.0\",\n build_file = Label(\"@crates//crates:BUILD.funty-2.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-0.3.34\",\n sha256 = \"9a31d2a3fbaaeb2af2368bbdd904aa8e812d3c04a1ee10d3171f52d556e5d0a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures/0.3.34/download\"],\n strip_prefix = \"futures-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-channel-0.3.34\",\n sha256 = \"b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-channel/0.3.34/download\"],\n strip_prefix = \"futures-channel-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-channel-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-core-0.3.34\",\n sha256 = \"92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-core/0.3.34/download\"],\n strip_prefix = \"futures-core-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-core-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-executor-0.3.34\",\n sha256 = \"031b47cf1a3c6cc8bc2fc76cd437f521619387907d469316e7c0bc278f1f5432\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-executor/0.3.34/download\"],\n strip_prefix = \"futures-executor-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-executor-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-io-0.3.34\",\n sha256 = \"53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-io/0.3.34/download\"],\n strip_prefix = \"futures-io-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-io-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-lite-2.6.1\",\n sha256 = \"f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-lite/2.6.1/download\"],\n strip_prefix = \"futures-lite-2.6.1\",\n build_file = Label(\"@crates//crates:BUILD.futures-lite-2.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-macro-0.3.34\",\n sha256 = \"9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-macro/0.3.34/download\"],\n strip_prefix = \"futures-macro-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-macro-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-sink-0.3.34\",\n sha256 = \"1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-sink/0.3.34/download\"],\n strip_prefix = \"futures-sink-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-sink-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-task-0.3.34\",\n sha256 = \"cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-task/0.3.34/download\"],\n strip_prefix = \"futures-task-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-task-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-util-0.3.34\",\n sha256 = \"0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-util/0.3.34/download\"],\n strip_prefix = \"futures-util-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-util-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gbm-0.18.0\",\n sha256 = \"ce852e998d3ca5e4a97014fb31c940dc5ef344ec7d364984525fd11e8a547e6a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gbm/0.18.0/download\"],\n strip_prefix = \"gbm-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.gbm-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gbm-sys-0.4.0\",\n sha256 = \"c13a5f2acc785d8fb6bf6b7ab6bfb0ef5dad4f4d97e8e70bb8e470722312f76f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gbm-sys/0.4.0/download\"],\n strip_prefix = \"gbm-sys-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.gbm-sys-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__generic-array-0.14.7\",\n sha256 = \"85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/generic-array/0.14.7/download\"],\n strip_prefix = \"generic-array-0.14.7\",\n build_file = Label(\"@crates//crates:BUILD.generic-array-0.14.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gethostname-1.1.0\",\n sha256 = \"1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gethostname/1.1.0/download\"],\n strip_prefix = \"gethostname-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.gethostname-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.2.17\",\n sha256 = \"ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.2.17/download\"],\n strip_prefix = \"getrandom-0.2.17\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.2.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.3.4\",\n sha256 = \"899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.3.4/download\"],\n strip_prefix = \"getrandom-0.3.4\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.3.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.4.3\",\n sha256 = \"300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.4.3/download\"],\n strip_prefix = \"getrandom-0.4.3\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.4.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ghash-0.5.1\",\n sha256 = \"f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ghash/0.5.1/download\"],\n strip_prefix = \"ghash-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.ghash-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gif-0.14.2\",\n sha256 = \"ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gif/0.14.2/download\"],\n strip_prefix = \"gif-0.14.2\",\n build_file = Label(\"@crates//crates:BUILD.gif-0.14.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gl-0.14.0\",\n sha256 = \"a94edab108827d67608095e269cf862e60d920f144a5026d3dbcfd8b877fb404\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gl/0.14.0/download\"],\n strip_prefix = \"gl-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.gl-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gl_generator-0.14.0\",\n sha256 = \"1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gl_generator/0.14.0/download\"],\n strip_prefix = \"gl_generator-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.gl_generator-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__glob-0.3.4\",\n sha256 = \"e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/glob/0.3.4/download\"],\n strip_prefix = \"glob-0.3.4\",\n build_file = Label(\"@crates//crates:BUILD.glob-0.3.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__globset-0.4.20\",\n sha256 = \"07c34a9410465b45bd9787443bc7370f37735bad04b0f0cd57ff1a3186c98988\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/globset/0.4.20/download\"],\n strip_prefix = \"globset-0.4.20\",\n build_file = Label(\"@crates//crates:BUILD.globset-0.4.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-cli-0.1.12\",\n sha256 = \"cf32d263c5d5cc2a23ce587097f5ddafdb188492ba2e6fb638eaccdc22453631\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-cli/0.1.12/download\"],\n strip_prefix = \"grep-cli-0.1.12\",\n build_file = Label(\"@crates//crates:BUILD.grep-cli-0.1.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-matcher-0.1.9\",\n sha256 = \"f9417543f4870fc8f1c8e1af870afae2431007626d9e703fce6471c468d33847\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-matcher/0.1.9/download\"],\n strip_prefix = \"grep-matcher-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.grep-matcher-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-pcre2-0.1.10\",\n sha256 = \"b752bb6f57dd3716e55b63a33ca05b5825c3d66cd427468874a5564af6ca365c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-pcre2/0.1.10/download\"],\n strip_prefix = \"grep-pcre2-0.1.10\",\n build_file = Label(\"@crates//crates:BUILD.grep-pcre2-0.1.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-printer-0.3.1\",\n sha256 = \"fd76035e87871f51c1ee5b793e32122b3ccf9c692662d9622ef1686ff5321acb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-printer/0.3.1/download\"],\n strip_prefix = \"grep-printer-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.grep-printer-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-regex-0.1.14\",\n sha256 = \"0ce0c256c3ad82bcc07b812c15a45ec1d398122e8e15124f96695234db7112ef\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-regex/0.1.14/download\"],\n strip_prefix = \"grep-regex-0.1.14\",\n build_file = Label(\"@crates//crates:BUILD.grep-regex-0.1.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-searcher-0.1.17\",\n sha256 = \"72348823a0eafc4bc2e9051064f28b5b42cc100b571b3a35d67918d711efcbc6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-searcher/0.1.17/download\"],\n strip_prefix = \"grep-searcher-0.1.17\",\n build_file = Label(\"@crates//crates:BUILD.grep-searcher-0.1.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__group-0.13.0\",\n sha256 = \"f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/group/0.13.0/download\"],\n strip_prefix = \"group-0.13.0\",\n build_file = Label(\"@crates//crates:BUILD.group-0.13.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__half-2.7.1\",\n sha256 = \"6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/half/2.7.1/download\"],\n strip_prefix = \"half-2.7.1\",\n build_file = Label(\"@crates//crates:BUILD.half-2.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hash32-0.3.1\",\n sha256 = \"47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hash32/0.3.1/download\"],\n strip_prefix = \"hash32-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.hash32-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.14.5\",\n sha256 = \"e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.14.5/download\"],\n strip_prefix = \"hashbrown-0.14.5\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.14.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.15.5\",\n sha256 = \"9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.15.5/download\"],\n strip_prefix = \"hashbrown-0.15.5\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.15.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.16.1\",\n sha256 = \"841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.16.1/download\"],\n strip_prefix = \"hashbrown-0.16.1\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.16.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.17.1\",\n sha256 = \"ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.17.1/download\"],\n strip_prefix = \"hashbrown-0.17.1\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.17.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__heapless-0.9.3\",\n sha256 = \"25ba4bd83f9415b58b4ed8dc5714c76e626a105be4646c02630ad730ad3b5aa4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/heapless/0.9.3/download\"],\n strip_prefix = \"heapless-0.9.3\",\n build_file = Label(\"@crates//crates:BUILD.heapless-0.9.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__heck-0.5.0\",\n sha256 = \"2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/heck/0.5.0/download\"],\n strip_prefix = \"heck-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.heck-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hermit-abi-0.5.2\",\n sha256 = \"fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hermit-abi/0.5.2/download\"],\n strip_prefix = \"hermit-abi-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.hermit-abi-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hex-0.4.3\",\n sha256 = \"7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hex/0.4.3/download\"],\n strip_prefix = \"hex-0.4.3\",\n build_file = Label(\"@crates//crates:BUILD.hex-0.4.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hifijson-0.2.3\",\n sha256 = \"0a7763b98ba8a24f59e698bf9ab197e7676c640d6455d1580b4ce7dc560f0f0d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hifijson/0.2.3/download\"],\n strip_prefix = \"hifijson-0.2.3\",\n build_file = Label(\"@crates//crates:BUILD.hifijson-0.2.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hkdf-0.12.4\",\n sha256 = \"7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hkdf/0.12.4/download\"],\n strip_prefix = \"hkdf-0.12.4\",\n build_file = Label(\"@crates//crates:BUILD.hkdf-0.12.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hmac-0.12.1\",\n sha256 = \"6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hmac/0.12.1/download\"],\n strip_prefix = \"hmac-0.12.1\",\n build_file = Label(\"@crates//crates:BUILD.hmac-0.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hostname-0.4.2\",\n sha256 = \"617aaa3557aef3810a6369d0a99fac8a080891b68bd9f9812a1eeda0c0730cbd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hostname/0.4.2/download\"],\n strip_prefix = \"hostname-0.4.2\",\n build_file = Label(\"@crates//crates:BUILD.hostname-0.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__html-escape-0.2.15\",\n sha256 = \"c9356095b4b41197bba32173600e1582792cda618f65d12f68e2e77d273413c5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/html-escape/0.2.15/download\"],\n strip_prefix = \"html-escape-0.2.15\",\n build_file = Label(\"@crates//crates:BUILD.html-escape-0.2.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__html-to-markdown-rs-3.11.3\",\n sha256 = \"187d8352a854d055faf1e6574bd14d8c3e429a1c1a73462793155ce63a845fb4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/html-to-markdown-rs/3.11.3/download\"],\n strip_prefix = \"html-to-markdown-rs-3.11.3\",\n build_file = Label(\"@crates//crates:BUILD.html-to-markdown-rs-3.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__html5ever-0.39.0\",\n sha256 = \"46a1761807faccc9a19e86944bbf40610014066306f96edcdedc2fb714bcb7b8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/html5ever/0.39.0/download\"],\n strip_prefix = \"html5ever-0.39.0\",\n build_file = Label(\"@crates//crates:BUILD.html5ever-0.39.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hybrid-array-0.4.14\",\n sha256 = \"707114b52a152fa7bdb290cd7cd5912d9467273b6d74e21b8d81aca1f8533f6b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hybrid-array/0.4.14/download\"],\n strip_prefix = \"hybrid-array-0.4.14\",\n build_file = Label(\"@crates//crates:BUILD.hybrid-array-0.4.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__iana-time-zone-0.1.65\",\n sha256 = \"e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/iana-time-zone/0.1.65/download\"],\n strip_prefix = \"iana-time-zone-0.1.65\",\n build_file = Label(\"@crates//crates:BUILD.iana-time-zone-0.1.65.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__iana-time-zone-haiku-0.1.2\",\n sha256 = \"f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/iana-time-zone-haiku/0.1.2/download\"],\n strip_prefix = \"iana-time-zone-haiku-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.iana-time-zone-haiku-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_calendar-2.3.0\",\n sha256 = \"58655df2f728e46e4eee80bddebefacf52ec3e77cdb925014b47c5a5905eb55c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_calendar/2.3.0/download\"],\n strip_prefix = \"icu_calendar-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_calendar-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_calendar_data-2.3.0\",\n sha256 = \"dc00caaa3fb3201ff7a18aa458e8c3ab042b9da154cfdf948bdde3936c31c36e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_calendar_data/2.3.0/download\"],\n strip_prefix = \"icu_calendar_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_calendar_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_collator-2.3.1\",\n sha256 = \"08984ed58ac439ebf3e13d2cf26b0c46a60afcd21721c1d14087c0b240344dda\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_collator/2.3.1/download\"],\n strip_prefix = \"icu_collator-2.3.1\",\n build_file = Label(\"@crates//crates:BUILD.icu_collator-2.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_collator_data-2.3.0\",\n sha256 = \"f7d7e54efdddeb1208c08dd5d32b53a879ac00d2d3d051b2255fd26821d16368\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_collator_data/2.3.0/download\"],\n strip_prefix = \"icu_collator_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_collator_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_collections-2.3.0\",\n sha256 = \"fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_collections/2.3.0/download\"],\n strip_prefix = \"icu_collections-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_collections-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_datetime-2.3.0\",\n sha256 = \"c44df99c4c5297b05653d1a1629f13bdc9fd4044acfbbaf30b15194a1eed4cd6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_datetime/2.3.0/download\"],\n strip_prefix = \"icu_datetime-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_datetime-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_datetime_data-2.3.0\",\n sha256 = \"8bb5555f6e4b42233f58564351ce16d73e9e6ebfce6bdcf29875d0cfc554d6a8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_datetime_data/2.3.0/download\"],\n strip_prefix = \"icu_datetime_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_datetime_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_decimal-2.3.0\",\n sha256 = \"9eb8f655bba2d0c0459e43a5b0e6cd3cd388109898fb3d85d048165e8b0abd08\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_decimal/2.3.0/download\"],\n strip_prefix = \"icu_decimal-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_decimal-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_decimal_data-2.3.0\",\n sha256 = \"e4c887fc7d4c297cf3f9436864af9e3dba7f8be9415a6c2a7f392f3b1636298c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_decimal_data/2.3.0/download\"],\n strip_prefix = \"icu_decimal_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_decimal_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_locale-2.3.1\",\n sha256 = \"785f595c61ef57169a467eeed7b4b6936a66f6cacbb116a96ee86da983251bf4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_locale/2.3.1/download\"],\n strip_prefix = \"icu_locale-2.3.1\",\n build_file = Label(\"@crates//crates:BUILD.icu_locale-2.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_locale_core-2.3.0\",\n sha256 = \"d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_locale_core/2.3.0/download\"],\n strip_prefix = \"icu_locale_core-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_locale_core-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_locale_data-2.3.0\",\n sha256 = \"d37d91460e362a5cf58907cd7ce871411775ee6294e49a5cc8e6cec16dfa75ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_locale_data/2.3.0/download\"],\n strip_prefix = \"icu_locale_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_locale_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_locale_fallback-2.3.0\",\n sha256 = \"251af8e57c9400e3eb58242fe5b8b1152b2a64fdf4cf632f923c38ccee6f2fa9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_locale_fallback/2.3.0/download\"],\n strip_prefix = \"icu_locale_fallback-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_locale_fallback-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_locale_fallback_data-2.3.0\",\n sha256 = \"decf2a22ec8fa68f1a0c1129a3f8583f8f8bc24e8b9ccbe98ead99f62a4dc3a8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_locale_fallback_data/2.3.0/download\"],\n strip_prefix = \"icu_locale_fallback_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_locale_fallback_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_normalizer-2.3.0\",\n sha256 = \"12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_normalizer/2.3.0/download\"],\n strip_prefix = \"icu_normalizer-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_normalizer-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_normalizer_data-2.3.0\",\n sha256 = \"1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_normalizer_data/2.3.0/download\"],\n strip_prefix = \"icu_normalizer_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_normalizer_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_pattern-0.5.0\",\n sha256 = \"2b3db611446bd92c246b03e4aa0bafa71ddb194af431ddbb42b9d70e4bfce1a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_pattern/0.5.0/download\"],\n strip_prefix = \"icu_pattern-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_pattern-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_plurals-2.3.0\",\n sha256 = \"e475e6766ef87b1d3c1f97be6363995b0bfaeddbc789671615df598a97ff0593\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_plurals/2.3.0/download\"],\n strip_prefix = \"icu_plurals-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_plurals-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_plurals_data-2.3.0\",\n sha256 = \"1251aa39a95e1333888e499b1263e1c196447a28948acf5bdabd82c046f153bf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_plurals_data/2.3.0/download\"],\n strip_prefix = \"icu_plurals_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_plurals_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_properties-2.3.0\",\n sha256 = \"7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_properties/2.3.0/download\"],\n strip_prefix = \"icu_properties-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_properties-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_properties_data-2.3.0\",\n sha256 = \"e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_properties_data/2.3.0/download\"],\n strip_prefix = \"icu_properties_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_properties_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_provider-2.3.1\",\n sha256 = \"d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_provider/2.3.1/download\"],\n strip_prefix = \"icu_provider-2.3.1\",\n build_file = Label(\"@crates//crates:BUILD.icu_provider-2.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_time-2.3.0\",\n sha256 = \"af37e1c3b9f3ab564b619fdf4b22de169f6381eb0f7048e3ca454290c438126b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_time/2.3.0/download\"],\n strip_prefix = \"icu_time-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_time-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_time_data-2.3.0\",\n sha256 = \"005ff86fa5851a77fc0a977b72d717f777bd9230415a247219d7898aefb1517a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_time_data/2.3.0/download\"],\n strip_prefix = \"icu_time_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_time_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icy_sixel-0.5.1\",\n sha256 = \"4bfb5a63225620b59df34a235d1fb56ff7b766909c3212a8ff927511a22b181d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icy_sixel/0.5.1/download\"],\n strip_prefix = \"icy_sixel-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.icy_sixel-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ident_case-1.0.1\",\n sha256 = \"b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ident_case/1.0.1/download\"],\n strip_prefix = \"ident_case-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.ident_case-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__idna-1.1.0\",\n sha256 = \"3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/idna/1.1.0/download\"],\n strip_prefix = \"idna-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.idna-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__idna_adapter-1.2.2\",\n sha256 = \"cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/idna_adapter/1.2.2/download\"],\n strip_prefix = \"idna_adapter-1.2.2\",\n build_file = Label(\"@crates//crates:BUILD.idna_adapter-1.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ignore-0.4.33\",\n sha256 = \"00b69833ed729dc5aa7d19541d96d6cf8e9137194207a04916d658e43168402f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ignore/0.4.33/download\"],\n strip_prefix = \"ignore-0.4.33\",\n build_file = Label(\"@crates//crates:BUILD.ignore-0.4.33.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__image-0.25.10\",\n sha256 = \"85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/image/0.25.10/download\"],\n strip_prefix = \"image-0.25.10\",\n build_file = Label(\"@crates//crates:BUILD.image-0.25.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__image-webp-0.2.4\",\n sha256 = \"525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/image-webp/0.2.4/download\"],\n strip_prefix = \"image-webp-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.image-webp-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__include_dir-0.7.4\",\n sha256 = \"923d117408f1e49d914f1a379a309cffe4f18c05cf4e3d12e613a15fc81bd0dd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/include_dir/0.7.4/download\"],\n strip_prefix = \"include_dir-0.7.4\",\n build_file = Label(\"@crates//crates:BUILD.include_dir-0.7.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__include_dir_macros-0.7.4\",\n sha256 = \"7cab85a7ed0bd5f0e76d93846e0147172bed2e2d3f859bcc33a8d9699cad1a75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/include_dir_macros/0.7.4/download\"],\n strip_prefix = \"include_dir_macros-0.7.4\",\n build_file = Label(\"@crates//crates:BUILD.include_dir_macros-0.7.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__indenter-0.3.4\",\n sha256 = \"964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/indenter/0.3.4/download\"],\n strip_prefix = \"indenter-0.3.4\",\n build_file = Label(\"@crates//crates:BUILD.indenter-0.3.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__indexmap-2.14.0\",\n sha256 = \"d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/indexmap/2.14.0/download\"],\n strip_prefix = \"indexmap-2.14.0\",\n build_file = Label(\"@crates//crates:BUILD.indexmap-2.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__indicatif-0.18.6\",\n sha256 = \"9433806cd6b4ec1aba79c021c7e4c58fb4c3b9977c085062e611ac929998fb0c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/indicatif/0.18.6/download\"],\n strip_prefix = \"indicatif-0.18.6\",\n build_file = Label(\"@crates//crates:BUILD.indicatif-0.18.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__inferno-0.12.8\",\n sha256 = \"0c460d4fa06223667240720ab69a8045133755ae6dfbe100cf481b95e3a014f1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/inferno/0.12.8/download\"],\n strip_prefix = \"inferno-0.12.8\",\n build_file = Label(\"@crates//crates:BUILD.inferno-0.12.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__inherent-1.0.14\",\n sha256 = \"bee2c455ca60511a054699102d40ce7153621cb2429558f9eaa600e4499b5984\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/inherent/1.0.14/download\"],\n strip_prefix = \"inherent-1.0.14\",\n build_file = Label(\"@crates//crates:BUILD.inherent-1.0.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__inotify-0.11.5\",\n sha256 = \"4cc00ea907cab49550b7da656f80ebb97be1b997d931fbcd28d39734e17ce592\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/inotify/0.11.5/download\"],\n strip_prefix = \"inotify-0.11.5\",\n build_file = Label(\"@crates//crates:BUILD.inotify-0.11.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__inotify-sys-0.1.8\",\n sha256 = \"c033f80b2c113cdf91ab7a33faa9cbc014726dcad99880c8609af2a370edf37d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/inotify-sys/0.1.8/download\"],\n strip_prefix = \"inotify-sys-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.inotify-sys-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__inout-0.1.4\",\n sha256 = \"879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/inout/0.1.4/download\"],\n strip_prefix = \"inout-0.1.4\",\n build_file = Label(\"@crates//crates:BUILD.inout-0.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__insta-1.48.0\",\n sha256 = \"86f0f8fee8c926415c58d6ae43a08523a26faccb2323f5e6b644fe7dd4ef6b82\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/insta/1.48.0/download\"],\n strip_prefix = \"insta-1.48.0\",\n build_file = Label(\"@crates//crates:BUILD.insta-1.48.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__interceptor-0.17.2\",\n sha256 = \"88c11a956a48159f7fe539b8198f12b4db9b709ae5f94385b840db38f97fed74\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/interceptor/0.17.2/download\"],\n strip_prefix = \"interceptor-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.interceptor-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__intl-memoizer-0.5.3\",\n sha256 = \"310da2e345f5eb861e7a07ee182262e94975051db9e4223e909ba90f392f163f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/intl-memoizer/0.5.3/download\"],\n strip_prefix = \"intl-memoizer-0.5.3\",\n build_file = Label(\"@crates//crates:BUILD.intl-memoizer-0.5.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__intl_pluralrules-7.0.2\",\n sha256 = \"078ea7b7c29a2b4df841a7f6ac8775ff6074020c6776d48491ce2268e068f972\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/intl_pluralrules/7.0.2/download\"],\n strip_prefix = \"intl_pluralrules-7.0.2\",\n build_file = Label(\"@crates//crates:BUILD.intl_pluralrules-7.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ipnet-2.12.1\",\n sha256 = \"6a756c3fac73139e83f14c2d742155dd2b78d3ee56597b419a0579b7bdd6dd78\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ipnet/2.12.1/download\"],\n strip_prefix = \"ipnet-2.12.1\",\n build_file = Label(\"@crates//crates:BUILD.ipnet-2.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__is_terminal_polyfill-1.70.2\",\n sha256 = \"a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/is_terminal_polyfill/1.70.2/download\"],\n strip_prefix = \"is_terminal_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.is_terminal_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.13.0\",\n sha256 = \"413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.13.0/download\"],\n strip_prefix = \"itertools-0.13.0\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.13.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.14.0\",\n sha256 = \"2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.14.0/download\"],\n strip_prefix = \"itertools-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itoa-1.0.18\",\n sha256 = \"8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itoa/1.0.18/download\"],\n strip_prefix = \"itoa-1.0.18\",\n build_file = Label(\"@crates//crates:BUILD.itoa-1.0.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jaq-core-2.2.1\",\n sha256 = \"77526a72eb79412c29fd141767a6549bbfcb1cb40e00556fe16532d5e878e098\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jaq-core/2.2.1/download\"],\n strip_prefix = \"jaq-core-2.2.1\",\n build_file = Label(\"@crates//crates:BUILD.jaq-core-2.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jaq-json-1.1.3\",\n sha256 = \"01dbdbd07b076e8403abac68ce7744d93e2ecd953bbc44bf77bf00e1e81172bc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jaq-json/1.1.3/download\"],\n strip_prefix = \"jaq-json-1.1.3\",\n build_file = Label(\"@crates//crates:BUILD.jaq-json-1.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jaq-std-2.1.2\",\n sha256 = \"2c264fe397c981705976c71f1bfe020382b9eda52ae950e57fe885e147bdd67d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jaq-std/2.1.2/download\"],\n strip_prefix = \"jaq-std-2.1.2\",\n build_file = Label(\"@crates//crates:BUILD.jaq-std-2.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-0.2.35\",\n sha256 = \"668b7183bd07af9a4885f5c35b0cc5c83c4607a913c16b7e17291832910d2dcc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff/0.2.35/download\"],\n strip_prefix = \"jiff-0.2.35\",\n build_file = Label(\"@crates//crates:BUILD.jiff-0.2.35.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-core-0.1.0\",\n sha256 = \"7feca88439efe53da3754500c1851dedf3cb36c524dd5cf8225cc0794de95d09\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff-core/0.1.0/download\"],\n strip_prefix = \"jiff-core-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.jiff-core-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-icu-0.2.2\",\n sha256 = \"0e67c2beaae8b10a82d849b9aabb698a43a682f32b17bcdc035d5ecadb44d646\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff-icu/0.2.2/download\"],\n strip_prefix = \"jiff-icu-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.jiff-icu-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-static-0.2.35\",\n sha256 = \"3a69dcb3a21cfb32ce1cd056169337ca284af0766dd766e7878819b251a49204\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff-static/0.2.35/download\"],\n strip_prefix = \"jiff-static-0.2.35\",\n build_file = Label(\"@crates//crates:BUILD.jiff-static-0.2.35.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-tzdb-0.1.8\",\n sha256 = \"142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff-tzdb/0.1.8/download\"],\n strip_prefix = \"jiff-tzdb-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.jiff-tzdb-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-tzdb-platform-0.1.3\",\n sha256 = \"875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff-tzdb-platform/0.1.3/download\"],\n strip_prefix = \"jiff-tzdb-platform-0.1.3\",\n build_file = Label(\"@crates//crates:BUILD.jiff-tzdb-platform-0.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jobserver-0.1.35\",\n sha256 = \"1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jobserver/0.1.35/download\"],\n strip_prefix = \"jobserver-0.1.35\",\n build_file = Label(\"@crates//crates:BUILD.jobserver-0.1.35.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__js-sys-0.3.104\",\n sha256 = \"0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/js-sys/0.3.104/download\"],\n strip_prefix = \"js-sys-0.3.104\",\n build_file = Label(\"@crates//crates:BUILD.js-sys-0.3.104.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__keccak-0.1.6\",\n sha256 = \"cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/keccak/0.1.6/download\"],\n strip_prefix = \"keccak-0.1.6\",\n build_file = Label(\"@crates//crates:BUILD.keccak-0.1.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__khronos-egl-6.0.0\",\n sha256 = \"6aae1df220ece3c0ada96b8153459b67eebe9ae9212258bb0134ae60416fdf76\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/khronos-egl/6.0.0/download\"],\n strip_prefix = \"khronos-egl-6.0.0\",\n build_file = Label(\"@crates//crates:BUILD.khronos-egl-6.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__khronos_api-3.1.0\",\n sha256 = \"e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/khronos_api/3.1.0/download\"],\n strip_prefix = \"khronos_api-3.1.0\",\n build_file = Label(\"@crates//crates:BUILD.khronos_api-3.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__kqueue-1.2.1\",\n sha256 = \"8d763e5b24120b4ddf50de6c92308156765aabfbbccebf401da7cff2d70a41ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/kqueue/1.2.1/download\"],\n strip_prefix = \"kqueue-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.kqueue-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__kqueue-sys-1.1.2\",\n sha256 = \"07293a4e297ac234359b510362495713f75ea345d5307140414f20c69ffeb087\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/kqueue-sys/1.1.2/download\"],\n strip_prefix = \"kqueue-sys-1.1.2\",\n build_file = Label(\"@crates//crates:BUILD.kqueue-sys-1.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy_static-1.5.0\",\n sha256 = \"bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy_static/1.5.0/download\"],\n strip_prefix = \"lazy_static-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy_static-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libc-0.2.189\",\n sha256 = \"3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libc/0.2.189/download\"],\n strip_prefix = \"libc-0.2.189\",\n build_file = Label(\"@crates//crates:BUILD.libc-0.2.189.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libloading-0.8.9\",\n sha256 = \"d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libloading/0.8.9/download\"],\n strip_prefix = \"libloading-0.8.9\",\n build_file = Label(\"@crates//crates:BUILD.libloading-0.8.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libloading-0.9.0\",\n sha256 = \"754ca22de805bb5744484a5b151a9e1a8e837d5dc232c2d7d8c2e3492edc8b60\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libloading/0.9.0/download\"],\n strip_prefix = \"libloading-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.libloading-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libm-0.2.16\",\n sha256 = \"b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libm/0.2.16/download\"],\n strip_prefix = \"libm-0.2.16\",\n build_file = Label(\"@crates//crates:BUILD.libm-0.2.16.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libredox-0.1.20\",\n sha256 = \"28d0a00925a9f930d679b6789b721e3a7f9ed110f41b86d2497caa780c3a070a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libredox/0.1.20/download\"],\n strip_prefix = \"libredox-0.1.20\",\n build_file = Label(\"@crates//crates:BUILD.libredox-0.1.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libspa-0.9.2\",\n sha256 = \"b6b8cfa2a7656627b4c92c6b9ef929433acd673d5ab3708cda1b18478ac00df4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libspa/0.9.2/download\"],\n strip_prefix = \"libspa-0.9.2\",\n build_file = Label(\"@crates//crates:BUILD.libspa-0.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libspa-sys-0.9.2\",\n sha256 = \"901049455d2eb6decf9058235d745237952f4804bc584c5fcb41412e6adcc6e0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libspa-sys/0.9.2/download\"],\n strip_prefix = \"libspa-sys-0.9.2\",\n build_file = Label(\"@crates//crates:BUILD.libspa-sys-0.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libwayshot-xcap-0.3.3\",\n sha256 = \"ea8a46e4d016ef464e386e4970f5415fe0939c2d63abe0c2f539c05ef88c5fe5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libwayshot-xcap/0.3.3/download\"],\n strip_prefix = \"libwayshot-xcap-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.libwayshot-xcap-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linked-hash-map-0.5.6\",\n sha256 = \"0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linked-hash-map/0.5.6/download\"],\n strip_prefix = \"linked-hash-map-0.5.6\",\n build_file = Label(\"@crates//crates:BUILD.linked-hash-map-0.5.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linux-raw-sys-0.12.1\",\n sha256 = \"32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linux-raw-sys/0.12.1/download\"],\n strip_prefix = \"linux-raw-sys-0.12.1\",\n build_file = Label(\"@crates//crates:BUILD.linux-raw-sys-0.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linux-raw-sys-0.4.15\",\n sha256 = \"d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linux-raw-sys/0.4.15/download\"],\n strip_prefix = \"linux-raw-sys-0.4.15\",\n build_file = Label(\"@crates//crates:BUILD.linux-raw-sys-0.4.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linux-raw-sys-0.9.4\",\n sha256 = \"cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linux-raw-sys/0.9.4/download\"],\n strip_prefix = \"linux-raw-sys-0.9.4\",\n build_file = Label(\"@crates//crates:BUILD.linux-raw-sys-0.9.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__litemap-0.8.3\",\n sha256 = \"47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/litemap/0.8.3/download\"],\n strip_prefix = \"litemap-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.litemap-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lock_api-0.4.14\",\n sha256 = \"224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lock_api/0.4.14/download\"],\n strip_prefix = \"lock_api-0.4.14\",\n build_file = Label(\"@crates//crates:BUILD.lock_api-0.4.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__log-0.4.33\",\n sha256 = \"0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/log/0.4.33/download\"],\n strip_prefix = \"log-0.4.33\",\n build_file = Label(\"@crates//crates:BUILD.log-0.4.33.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lopdf-0.42.0\",\n sha256 = \"25aab26d99567469098e64a02f42679f8965c6401263eefa31d8f2dcc37a221c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lopdf/0.42.0/download\"],\n strip_prefix = \"lopdf-0.42.0\",\n build_file = Label(\"@crates//crates:BUILD.lopdf-0.42.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lscolors-0.21.0\",\n sha256 = \"d60e266dfb1426eb2d24792602e041131fdc0236bb7007abc0e589acafd60929\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lscolors/0.21.0/download\"],\n strip_prefix = \"lscolors-0.21.0\",\n build_file = Label(\"@crates//crates:BUILD.lscolors-0.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__markup5ever-0.39.0\",\n sha256 = \"7122d987ec5f704ee56f6e5b41a7d93722e9aae27ae07cafa4036c4d3f9757de\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/markup5ever/0.39.0/download\"],\n strip_prefix = \"markup5ever-0.39.0\",\n build_file = Label(\"@crates//crates:BUILD.markup5ever-0.39.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__md-5-0.10.6\",\n sha256 = \"d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/md-5/0.10.6/download\"],\n strip_prefix = \"md-5-0.10.6\",\n build_file = Label(\"@crates//crates:BUILD.md-5-0.10.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memchr-2.8.3\",\n sha256 = \"cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memchr/2.8.3/download\"],\n strip_prefix = \"memchr-2.8.3\",\n build_file = Label(\"@crates//crates:BUILD.memchr-2.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memmap2-0.9.11\",\n sha256 = \"d1219ed1b7f229ee7104d281dd01d6802fe28bb6e95d292942c4daacdeb798c0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memmap2/0.9.11/download\"],\n strip_prefix = \"memmap2-0.9.11\",\n build_file = Label(\"@crates//crates:BUILD.memmap2-0.9.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memoffset-0.7.1\",\n sha256 = \"5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memoffset/0.7.1/download\"],\n strip_prefix = \"memoffset-0.7.1\",\n build_file = Label(\"@crates//crates:BUILD.memoffset-0.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memoffset-0.9.1\",\n sha256 = \"488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memoffset/0.9.1/download\"],\n strip_prefix = \"memoffset-0.9.1\",\n build_file = Label(\"@crates//crates:BUILD.memoffset-0.9.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__minimal-lexical-0.2.1\",\n sha256 = \"68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/minimal-lexical/0.2.1/download\"],\n strip_prefix = \"minimal-lexical-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.minimal-lexical-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__miniz_oxide-0.8.9\",\n sha256 = \"1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/miniz_oxide/0.8.9/download\"],\n strip_prefix = \"miniz_oxide-0.8.9\",\n build_file = Label(\"@crates//crates:BUILD.miniz_oxide-0.8.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__mio-1.2.2\",\n sha256 = \"30d65c71f1ce40ab09135ce117d742b9f8a19ff91a41a8b57ed50bc2de59c427\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/mio/1.2.2/download\"],\n strip_prefix = \"mio-1.2.2\",\n build_file = Label(\"@crates//crates:BUILD.mio-1.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__moxcms-0.8.1\",\n sha256 = \"bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/moxcms/0.8.1/download\"],\n strip_prefix = \"moxcms-0.8.1\",\n build_file = Label(\"@crates//crates:BUILD.moxcms-0.8.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__munge-0.4.7\",\n sha256 = \"5e17401f259eba956ca16491461b6e8f72913a0a114e39736ce404410f915a0c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/munge/0.4.7/download\"],\n strip_prefix = \"munge-0.4.7\",\n build_file = Label(\"@crates//crates:BUILD.munge-0.4.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__munge_macro-0.4.7\",\n sha256 = \"4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/munge_macro/0.4.7/download\"],\n strip_prefix = \"munge_macro-0.4.7\",\n build_file = Label(\"@crates//crates:BUILD.munge_macro-0.4.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nanorand-0.7.0\",\n sha256 = \"6a51313c5820b0b02bd422f4b44776fbf47961755c74ce64afc73bfad10226c3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nanorand/0.7.0/download\"],\n strip_prefix = \"nanorand-0.7.0\",\n build_file = Label(\"@crates//crates:BUILD.nanorand-0.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__napi-3.12.2\",\n sha256 = \"58c5f4d5375213fdb7be2655e152386e82f026f9a5ba36a75556e11359aafe09\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/napi/3.12.2/download\"],\n strip_prefix = \"napi-3.12.2\",\n build_file = Label(\"@crates//crates:BUILD.napi-3.12.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__napi-build-2.4.1\",\n sha256 = \"60fdf9b392c50e7c4170fa633bd909490ed7835cea4c046776d1a4dd8d2ae0ab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/napi-build/2.4.1/download\"],\n strip_prefix = \"napi-build-2.4.1\",\n build_file = Label(\"@crates//crates:BUILD.napi-build-2.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__napi-derive-3.6.3\",\n sha256 = \"0fa55ea69990c90b888e9e77044410e304ce7f35de599dc6d0b5c1923d2e59af\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/napi-derive/3.6.3/download\"],\n strip_prefix = \"napi-derive-3.6.3\",\n build_file = Label(\"@crates//crates:BUILD.napi-derive-3.6.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__napi-derive-backend-6.1.2\",\n sha256 = \"df4056ac7c18e4438ccf0edaed4340ca0d269278c8ec19284f7b23cb039fd0ae\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/napi-derive-backend/6.1.2/download\"],\n strip_prefix = \"napi-derive-backend-6.1.2\",\n build_file = Label(\"@crates//crates:BUILD.napi-derive-backend-6.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__napi-sys-3.3.0\",\n sha256 = \"85fbf1fa9f1babfe396d74bbbf52b3643770243e8f5b0b46715d4caf7f0dfc9a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/napi-sys/3.3.0/download\"],\n strip_prefix = \"napi-sys-3.3.0\",\n build_file = Label(\"@crates//crates:BUILD.napi-sys-3.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__new_debug_unreachable-1.0.6\",\n sha256 = \"650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/new_debug_unreachable/1.0.6/download\"],\n strip_prefix = \"new_debug_unreachable-1.0.6\",\n build_file = Label(\"@crates//crates:BUILD.new_debug_unreachable-1.0.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.24.3\",\n sha256 = \"fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.24.3/download\"],\n strip_prefix = \"nix-0.24.3\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.24.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.26.4\",\n sha256 = \"598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.26.4/download\"],\n strip_prefix = \"nix-0.26.4\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.26.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.28.0\",\n sha256 = \"ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.28.0/download\"],\n strip_prefix = \"nix-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.30.1\",\n sha256 = \"74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.30.1/download\"],\n strip_prefix = \"nix-0.30.1\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.30.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.31.3\",\n sha256 = \"cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.31.3/download\"],\n strip_prefix = \"nix-0.31.3\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.31.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nohash-hasher-0.2.0\",\n sha256 = \"2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nohash-hasher/0.2.0/download\"],\n strip_prefix = \"nohash-hasher-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.nohash-hasher-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nom-7.1.3\",\n sha256 = \"d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nom/7.1.3/download\"],\n strip_prefix = \"nom-7.1.3\",\n build_file = Label(\"@crates//crates:BUILD.nom-7.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nom-8.0.0\",\n sha256 = \"df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nom/8.0.0/download\"],\n strip_prefix = \"nom-8.0.0\",\n build_file = Label(\"@crates//crates:BUILD.nom-8.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__normalize-path-0.2.1\",\n sha256 = \"f5438dd2b2ff4c6df6e1ce22d825ed2fa93ee2922235cc45186991717f0a892d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/normalize-path/0.2.1/download\"],\n strip_prefix = \"normalize-path-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.normalize-path-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__notify-8.2.0\",\n sha256 = \"4d3d07927151ff8575b7087f245456e549fea62edf0ec4e565a5ee50c8402bc3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/notify/8.2.0/download\"],\n strip_prefix = \"notify-8.2.0\",\n build_file = Label(\"@crates//crates:BUILD.notify-8.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__notify-types-2.1.0\",\n sha256 = \"42b8cfee0e339a0337359f3c88165702ac6e600dc01c0cc9579a92d62b08477a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/notify-types/2.1.0/download\"],\n strip_prefix = \"notify-types-2.1.0\",\n build_file = Label(\"@crates//crates:BUILD.notify-types-2.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nu-ansi-term-0.50.3\",\n sha256 = \"7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nu-ansi-term/0.50.3/download\"],\n strip_prefix = \"nu-ansi-term-0.50.3\",\n build_file = Label(\"@crates//crates:BUILD.nu-ansi-term-0.50.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-bigint-0.4.8\",\n sha256 = \"c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-bigint/0.4.8/download\"],\n strip_prefix = \"num-bigint-0.4.8\",\n build_file = Label(\"@crates//crates:BUILD.num-bigint-0.4.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-conv-0.2.2\",\n sha256 = \"521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-conv/0.2.2/download\"],\n strip_prefix = \"num-conv-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.num-conv-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-format-0.4.4\",\n sha256 = \"a652d9771a63711fd3c3deb670acfbe5c30a4072e664d7a3bf5a9e1056ac72c3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-format/0.4.4/download\"],\n strip_prefix = \"num-format-0.4.4\",\n build_file = Label(\"@crates//crates:BUILD.num-format-0.4.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-integer-0.1.47\",\n sha256 = \"7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-integer/0.1.47/download\"],\n strip_prefix = \"num-integer-0.1.47\",\n build_file = Label(\"@crates//crates:BUILD.num-integer-0.1.47.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-traits-0.2.19\",\n sha256 = \"071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-traits/0.2.19/download\"],\n strip_prefix = \"num-traits-0.2.19\",\n build_file = Label(\"@crates//crates:BUILD.num-traits-0.2.19.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-0.6.4\",\n sha256 = \"3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2/0.6.4/download\"],\n strip_prefix = \"objc2-0.6.4\",\n build_file = Label(\"@crates//crates:BUILD.objc2-0.6.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-app-kit-0.3.2\",\n sha256 = \"d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-app-kit/0.3.2/download\"],\n strip_prefix = \"objc2-app-kit-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-app-kit-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-application-services-0.3.2\",\n sha256 = \"69282c2b5bc58fba07cb9de2113619532eb551e98efe3d8d695509ef45fbd53b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-application-services/0.3.2/download\"],\n strip_prefix = \"objc2-application-services-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-application-services-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-av-foundation-0.3.2\",\n sha256 = \"478ae33fcac9df0a18db8302387c666b8ef08a3e2d62b510ca4fc278a384b6c0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-av-foundation/0.3.2/download\"],\n strip_prefix = \"objc2-av-foundation-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-av-foundation-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-avf-audio-0.3.2\",\n sha256 = \"13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-avf-audio/0.3.2/download\"],\n strip_prefix = \"objc2-avf-audio-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-avf-audio-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-cloud-kit-0.3.2\",\n sha256 = \"73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-cloud-kit/0.3.2/download\"],\n strip_prefix = \"objc2-cloud-kit-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-cloud-kit-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-audio-0.3.2\",\n sha256 = \"e1eebcea8b0dbff5f7c8504f3107c68fc061a3eb44932051c8cf8a68d969c3b2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-audio/0.3.2/download\"],\n strip_prefix = \"objc2-core-audio-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-audio-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-audio-types-0.3.2\",\n sha256 = \"5a89f2ec274a0cf4a32642b2991e8b351a404d290da87bb6a9a9d8632490bd1c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-audio-types/0.3.2/download\"],\n strip_prefix = \"objc2-core-audio-types-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-audio-types-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-data-0.3.2\",\n sha256 = \"0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-data/0.3.2/download\"],\n strip_prefix = \"objc2-core-data-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-data-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-foundation-0.3.2\",\n sha256 = \"2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-foundation/0.3.2/download\"],\n strip_prefix = \"objc2-core-foundation-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-foundation-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-graphics-0.3.2\",\n sha256 = \"e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-graphics/0.3.2/download\"],\n strip_prefix = \"objc2-core-graphics-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-graphics-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-image-0.3.2\",\n sha256 = \"e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-image/0.3.2/download\"],\n strip_prefix = \"objc2-core-image-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-image-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-media-0.3.2\",\n sha256 = \"05ec576860167a15dd9fce7fbee7512beb4e31f532159d3482d1f9c6caedf31d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-media/0.3.2/download\"],\n strip_prefix = \"objc2-core-media-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-media-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-services-0.3.2\",\n sha256 = \"583300ad934cba24ff5292aee751ecc070f7ca6b39a574cc21b7b5e588e06a0b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-services/0.3.2/download\"],\n strip_prefix = \"objc2-core-services-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-services-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-text-0.3.2\",\n sha256 = \"0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-text/0.3.2/download\"],\n strip_prefix = \"objc2-core-text-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-text-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-video-0.3.2\",\n sha256 = \"d425caf1df73233f29fd8a5c3e5edbc30d2d4307870f802d18f00d83dc5141a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-video/0.3.2/download\"],\n strip_prefix = \"objc2-core-video-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-video-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-encode-4.1.0\",\n sha256 = \"ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-encode/4.1.0/download\"],\n strip_prefix = \"objc2-encode-4.1.0\",\n build_file = Label(\"@crates//crates:BUILD.objc2-encode-4.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-foundation-0.3.2\",\n sha256 = \"e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-foundation/0.3.2/download\"],\n strip_prefix = \"objc2-foundation-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-foundation-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-image-io-0.3.2\",\n sha256 = \"32b0446e98cf4a784cc7a0177715ff317eeaa8463841c616cfc78aa4f953c4ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-image-io/0.3.2/download\"],\n strip_prefix = \"objc2-image-io-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-image-io-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-io-surface-0.3.2\",\n sha256 = \"180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-io-surface/0.3.2/download\"],\n strip_prefix = \"objc2-io-surface-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-io-surface-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-media-toolbox-0.3.2\",\n sha256 = \"edd9fdde720df3da7046bb9097811000c1e7ab5cd579fa89d96b27d56781fb30\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-media-toolbox/0.3.2/download\"],\n strip_prefix = \"objc2-media-toolbox-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-media-toolbox-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-metal-0.3.2\",\n sha256 = \"a0125f776a10d00af4152d74616409f0d4a2053a6f57fa5b7d6aa2854ac04794\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-metal/0.3.2/download\"],\n strip_prefix = \"objc2-metal-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-metal-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-quartz-core-0.3.2\",\n sha256 = \"96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-quartz-core/0.3.2/download\"],\n strip_prefix = \"objc2-quartz-core-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-quartz-core-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-security-0.3.2\",\n sha256 = \"709fe137109bd1e8b5a99390f77a7d8b2961dafc1a1c5db8f2e60329ad6d895a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-security/0.3.2/download\"],\n strip_prefix = \"objc2-security-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-security-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-system-configuration-0.3.2\",\n sha256 = \"7216bd11cbda54ccabcab84d523dc93b858ec75ecfb3a7d89513fa22464da396\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-system-configuration/0.3.2/download\"],\n strip_prefix = \"objc2-system-configuration-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-system-configuration-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__oid-registry-0.7.1\",\n sha256 = \"a8d8034d9489cdaf79228eb9f6a3b8d7bb32ba00d6645ebd48eef4077ceb5bd9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/oid-registry/0.7.1/download\"],\n strip_prefix = \"oid-registry-0.7.1\",\n build_file = Label(\"@crates//crates:BUILD.oid-registry-0.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell-1.21.4\",\n sha256 = \"9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell/1.21.4/download\"],\n strip_prefix = \"once_cell-1.21.4\",\n build_file = Label(\"@crates//crates:BUILD.once_cell-1.21.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell_polyfill-1.70.2\",\n sha256 = \"384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell_polyfill/1.70.2/download\"],\n strip_prefix = \"once_cell_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.once_cell_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__onig-6.5.3\",\n sha256 = \"0cc3cbf698f9438986c11a880c90a6d04b9de27575afd28bbf45b154b6c709e2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/onig/6.5.3/download\"],\n strip_prefix = \"onig-6.5.3\",\n build_file = Label(\"@crates//crates:BUILD.onig-6.5.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__onig_sys-69.9.3\",\n sha256 = \"1e68317604e77e53b85896388e1a803c1d21b74c899ec9e5e1112db90735edd7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/onig_sys/69.9.3/download\"],\n strip_prefix = \"onig_sys-69.9.3\",\n build_file = Label(\"@crates//crates:BUILD.onig_sys-69.9.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__opaque-debug-0.3.1\",\n sha256 = \"c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/opaque-debug/0.3.1/download\"],\n strip_prefix = \"opaque-debug-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.opaque-debug-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__opus-0.3.1\",\n sha256 = \"4d3809943dff6fbad5f0484449ea26bdb9cb7d8efdf26ed50d3c7f227f69eb5c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/opus/0.3.1/download\"],\n strip_prefix = \"opus-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.opus-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ordered-float-5.4.0\",\n sha256 = \"c860fd3227ca4ac3cc032e2cd20cba3f02ccdf4b610538f8ee6584d56bb62e96\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ordered-float/5.4.0/download\"],\n strip_prefix = \"ordered-float-5.4.0\",\n build_file = Label(\"@crates//crates:BUILD.ordered-float-5.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ordered-stream-0.2.0\",\n sha256 = \"9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ordered-stream/0.2.0/download\"],\n strip_prefix = \"ordered-stream-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.ordered-stream-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__os_display-0.1.4\",\n sha256 = \"ad5fd71b79026fb918650dde6d125000a233764f1c2f1659a1c71118e33ea08f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/os_display/0.1.4/download\"],\n strip_prefix = \"os_display-0.1.4\",\n build_file = Label(\"@crates//crates:BUILD.os_display-0.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__os_pipe-1.2.3\",\n sha256 = \"7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/os_pipe/1.2.3/download\"],\n strip_prefix = \"os_pipe-1.2.3\",\n build_file = Label(\"@crates//crates:BUILD.os_pipe-1.2.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__outref-0.5.2\",\n sha256 = \"1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/outref/0.5.2/download\"],\n strip_prefix = \"outref-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.outref-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__p256-0.13.2\",\n sha256 = \"c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/p256/0.13.2/download\"],\n strip_prefix = \"p256-0.13.2\",\n build_file = Label(\"@crates//crates:BUILD.p256-0.13.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__p384-0.13.1\",\n sha256 = \"fe42f1670a52a47d448f14b6a5c61dd78fce51856e68edaa38f7ae3a46b8d6b6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/p384/0.13.1/download\"],\n strip_prefix = \"p384-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.p384-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__palette-0.7.7\",\n sha256 = \"ddeed8580d347d2abf3dcf06a5f0b3dc020258338526b277847cd4248a70fc64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/palette/0.7.7/download\"],\n strip_prefix = \"palette-0.7.7\",\n build_file = Label(\"@crates//crates:BUILD.palette-0.7.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__palette_derive-0.7.7\",\n sha256 = \"88537020289b719d81be994ccf1bbf4990f477e2f69ee52fe3e45f43a02e56be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/palette_derive/0.7.7/download\"],\n strip_prefix = \"palette_derive-0.7.7\",\n build_file = Label(\"@crates//crates:BUILD.palette_derive-0.7.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__palette_math-0.7.7\",\n sha256 = \"6e6eb142958d64335fb0e345c5b9ead2ecd6fc438c307e9d7d3c4fd428dbaf12\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/palette_math/0.7.7/download\"],\n strip_prefix = \"palette_math-0.7.7\",\n build_file = Label(\"@crates//crates:BUILD.palette_math-0.7.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__parking-2.2.1\",\n sha256 = \"f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/parking/2.2.1/download\"],\n strip_prefix = \"parking-2.2.1\",\n build_file = Label(\"@crates//crates:BUILD.parking-2.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__parking_lot-0.12.5\",\n sha256 = \"93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/parking_lot/0.12.5/download\"],\n strip_prefix = \"parking_lot-0.12.5\",\n build_file = Label(\"@crates//crates:BUILD.parking_lot-0.12.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__parking_lot_core-0.9.12\",\n sha256 = \"2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/parking_lot_core/0.9.12/download\"],\n strip_prefix = \"parking_lot_core-0.9.12\",\n build_file = Label(\"@crates//crates:BUILD.parking_lot_core-0.9.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__parse_datetime-0.14.0\",\n sha256 = \"413775a7eac2261d2211a79d10ef275e5b6f7b527eec42ad09adce2ffa92b6e5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/parse_datetime/0.14.0/download\"],\n strip_prefix = \"parse_datetime-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.parse_datetime-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pcre2-0.2.11\",\n sha256 = \"9e970b0fcce0c7ee6ef662744ff711f21ccd6f11b7cf03cd187a80e89797fc67\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pcre2/0.2.11/download\"],\n strip_prefix = \"pcre2-0.2.11\",\n build_file = Label(\"@crates//crates:BUILD.pcre2-0.2.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pcre2-sys-0.2.10\",\n sha256 = \"18b9073c1a2549bd409bf4a32c94d903bb1a09bf845bc306ae148897fa0760a4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pcre2-sys/0.2.10/download\"],\n strip_prefix = \"pcre2-sys-0.2.10\",\n build_file = Label(\"@crates//crates:BUILD.pcre2-sys-0.2.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pdf-inspector-1.17.0\",\n sha256 = \"6cdfc6057e1b38a2ae84490c5e64abc5c81738d4d5ac1ccc55cf1a2c9b87334e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pdf-inspector/1.17.0/download\"],\n strip_prefix = \"pdf-inspector-1.17.0\",\n build_file = Label(\"@crates//crates:BUILD.pdf-inspector-1.17.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__peg-0.8.6\",\n sha256 = \"0aad070be5b63aa72103f2fcdd70a83adbd5e90112ce5b574171ff1c65501773\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/peg/0.8.6/download\"],\n strip_prefix = \"peg-0.8.6\",\n build_file = Label(\"@crates//crates:BUILD.peg-0.8.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__peg-macros-0.8.6\",\n sha256 = \"ddd8ef6825cae95355031ae26a99b616a2a21f22ba2de0197c43dfb05acbe7ee\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/peg-macros/0.8.6/download\"],\n strip_prefix = \"peg-macros-0.8.6\",\n build_file = Label(\"@crates//crates:BUILD.peg-macros-0.8.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__peg-runtime-0.8.6\",\n sha256 = \"7011d97b484a5ebdc4b1fdb3b12d5e4bbbea56e9d22b688f2e79e04b65a7d8a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/peg-runtime/0.8.6/download\"],\n strip_prefix = \"peg-runtime-0.8.6\",\n build_file = Label(\"@crates//crates:BUILD.peg-runtime-0.8.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pem-3.0.6\",\n sha256 = \"1d30c53c26bc5b31a98cd02d20f25a7c8567146caf63ed593a9d87b2775291be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pem/3.0.6/download\"],\n strip_prefix = \"pem-3.0.6\",\n build_file = Label(\"@crates//crates:BUILD.pem-3.0.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pem-rfc7468-0.7.0\",\n sha256 = \"88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pem-rfc7468/0.7.0/download\"],\n strip_prefix = \"pem-rfc7468-0.7.0\",\n build_file = Label(\"@crates//crates:BUILD.pem-rfc7468-0.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__percent-encoding-2.3.2\",\n sha256 = \"9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/percent-encoding/2.3.2/download\"],\n strip_prefix = \"percent-encoding-2.3.2\",\n build_file = Label(\"@crates//crates:BUILD.percent-encoding-2.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pest-2.9.0\",\n sha256 = \"5a07a60cc7a4d00c91f95c685609d1d2f79050e6804b70ebedd7650f0b839bcf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pest/2.9.0/download\"],\n strip_prefix = \"pest-2.9.0\",\n build_file = Label(\"@crates//crates:BUILD.pest-2.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pest_derive-2.9.0\",\n sha256 = \"b3a83744a5c8455b8b3e0dc5031362780a347c878bdd11584d1a8984228cc88d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pest_derive/2.9.0/download\"],\n strip_prefix = \"pest_derive-2.9.0\",\n build_file = Label(\"@crates//crates:BUILD.pest_derive-2.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pest_generator-2.9.0\",\n sha256 = \"e0cd3451aa3de60d4b9a1e736885e4dea6b31617598026f12256ad566d63304a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pest_generator/2.9.0/download\"],\n strip_prefix = \"pest_generator-2.9.0\",\n build_file = Label(\"@crates//crates:BUILD.pest_generator-2.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pest_meta-2.9.0\",\n sha256 = \"e04d3a0849e241d7dfce834c83b1c5edc8622009e8dd51a12ba1927c32f05496\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pest_meta/2.9.0/download\"],\n strip_prefix = \"pest_meta-2.9.0\",\n build_file = Label(\"@crates//crates:BUILD.pest_meta-2.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__petgraph-0.8.3\",\n sha256 = \"8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/petgraph/0.8.3/download\"],\n strip_prefix = \"petgraph-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.petgraph-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf-0.11.3\",\n sha256 = \"1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf/0.11.3/download\"],\n strip_prefix = \"phf-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.phf-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf-0.13.1\",\n sha256 = \"c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf/0.13.1/download\"],\n strip_prefix = \"phf-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.phf-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf-0.14.0\",\n sha256 = \"010378780309880b08997fae13be7834dba947d36393bd372f2b1556deb2a2f6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf/0.14.0/download\"],\n strip_prefix = \"phf-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.phf-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_codegen-0.11.3\",\n sha256 = \"aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_codegen/0.11.3/download\"],\n strip_prefix = \"phf_codegen-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.phf_codegen-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_codegen-0.13.1\",\n sha256 = \"49aa7f9d80421bca176ca8dbfebe668cc7a2684708594ec9f3c0db0805d5d6e1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_codegen/0.13.1/download\"],\n strip_prefix = \"phf_codegen-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.phf_codegen-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_generator-0.11.3\",\n sha256 = \"3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_generator/0.11.3/download\"],\n strip_prefix = \"phf_generator-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.phf_generator-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_generator-0.13.1\",\n sha256 = \"135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_generator/0.13.1/download\"],\n strip_prefix = \"phf_generator-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.phf_generator-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_generator-0.14.0\",\n sha256 = \"aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_generator/0.14.0/download\"],\n strip_prefix = \"phf_generator-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.phf_generator-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_macros-0.13.1\",\n sha256 = \"812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_macros/0.13.1/download\"],\n strip_prefix = \"phf_macros-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.phf_macros-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_macros-0.14.0\",\n sha256 = \"5fa8d0ca26d424d27630da600c6624696e7dec8bf7b3b492b383c5dc49e5e085\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_macros/0.14.0/download\"],\n strip_prefix = \"phf_macros-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.phf_macros-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_shared-0.11.3\",\n sha256 = \"67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_shared/0.11.3/download\"],\n strip_prefix = \"phf_shared-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.phf_shared-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_shared-0.13.1\",\n sha256 = \"e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_shared/0.13.1/download\"],\n strip_prefix = \"phf_shared-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.phf_shared-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_shared-0.14.0\",\n sha256 = \"c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_shared/0.14.0/download\"],\n strip_prefix = \"phf_shared-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.phf_shared-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pin-project-lite-0.2.17\",\n sha256 = \"a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pin-project-lite/0.2.17/download\"],\n strip_prefix = \"pin-project-lite-0.2.17\",\n build_file = Label(\"@crates//crates:BUILD.pin-project-lite-0.2.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pin-utils-0.1.0\",\n sha256 = \"8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pin-utils/0.1.0/download\"],\n strip_prefix = \"pin-utils-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.pin-utils-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__piper-0.2.5\",\n sha256 = \"c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/piper/0.2.5/download\"],\n strip_prefix = \"piper-0.2.5\",\n build_file = Label(\"@crates//crates:BUILD.piper-0.2.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pipewire-0.9.2\",\n sha256 = \"9688b89abf11d756499f7c6190711d6dbe5a3acdb30c8fbf001d6596d06a8d44\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pipewire/0.9.2/download\"],\n strip_prefix = \"pipewire-0.9.2\",\n build_file = Label(\"@crates//crates:BUILD.pipewire-0.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pipewire-sys-0.9.2\",\n sha256 = \"cb028afee0d6ca17020b090e3b8fa2d7de23305aef975c7e5192a5050246ea36\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pipewire-sys/0.9.2/download\"],\n strip_prefix = \"pipewire-sys-0.9.2\",\n build_file = Label(\"@crates//crates:BUILD.pipewire-sys-0.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pkcs8-0.10.2\",\n sha256 = \"f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pkcs8/0.10.2/download\"],\n strip_prefix = \"pkcs8-0.10.2\",\n build_file = Label(\"@crates//crates:BUILD.pkcs8-0.10.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pkg-config-0.3.34\",\n sha256 = \"f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pkg-config/0.3.34/download\"],\n strip_prefix = \"pkg-config-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.pkg-config-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__platform-info-2.1.0\",\n sha256 = \"9368d62437c8cbb7c31ee37fd8c08a7d390e09a3ff75698a674953f46705ffcb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/platform-info/2.1.0/download\"],\n strip_prefix = \"platform-info-2.1.0\",\n build_file = Label(\"@crates//crates:BUILD.platform-info-2.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__png-0.18.1\",\n sha256 = \"60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/png/0.18.1/download\"],\n strip_prefix = \"png-0.18.1\",\n build_file = Label(\"@crates//crates:BUILD.png-0.18.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__polling-3.11.0\",\n sha256 = \"5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/polling/3.11.0/download\"],\n strip_prefix = \"polling-3.11.0\",\n build_file = Label(\"@crates//crates:BUILD.polling-3.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__poly1305-0.8.0\",\n sha256 = \"8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/poly1305/0.8.0/download\"],\n strip_prefix = \"poly1305-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.poly1305-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__polyval-0.6.2\",\n sha256 = \"9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/polyval/0.6.2/download\"],\n strip_prefix = \"polyval-0.6.2\",\n build_file = Label(\"@crates//crates:BUILD.polyval-0.6.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__portable-atomic-1.15.0\",\n sha256 = \"05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/portable-atomic/1.15.0/download\"],\n strip_prefix = \"portable-atomic-1.15.0\",\n build_file = Label(\"@crates//crates:BUILD.portable-atomic-1.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__portable-atomic-util-0.2.7\",\n sha256 = \"c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/portable-atomic-util/0.2.7/download\"],\n strip_prefix = \"portable-atomic-util-0.2.7\",\n build_file = Label(\"@crates//crates:BUILD.portable-atomic-util-0.2.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__portable-pty-0.9.0\",\n sha256 = \"b4a596a2b3d2752d94f51fac2d4a96737b8705dddd311a32b9af47211f08671e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/portable-pty/0.9.0/download\"],\n strip_prefix = \"portable-pty-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.portable-pty-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__potential_utf-0.1.6\",\n sha256 = \"d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/potential_utf/0.1.6/download\"],\n strip_prefix = \"potential_utf-0.1.6\",\n build_file = Label(\"@crates//crates:BUILD.potential_utf-0.1.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__powerfmt-0.2.0\",\n sha256 = \"439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/powerfmt/0.2.0/download\"],\n strip_prefix = \"powerfmt-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.powerfmt-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ppv-lite86-0.2.21\",\n sha256 = \"85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ppv-lite86/0.2.21/download\"],\n strip_prefix = \"ppv-lite86-0.2.21\",\n build_file = Label(\"@crates//crates:BUILD.ppv-lite86-0.2.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__precomputed-hash-0.1.1\",\n sha256 = \"925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/precomputed-hash/0.1.1/download\"],\n strip_prefix = \"precomputed-hash-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.precomputed-hash-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pretty_assertions-1.4.1\",\n sha256 = \"3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pretty_assertions/1.4.1/download\"],\n strip_prefix = \"pretty_assertions-1.4.1\",\n build_file = Label(\"@crates//crates:BUILD.pretty_assertions-1.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__prettyplease-0.2.37\",\n sha256 = \"479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/prettyplease/0.2.37/download\"],\n strip_prefix = \"prettyplease-0.2.37\",\n build_file = Label(\"@crates//crates:BUILD.prettyplease-0.2.37.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__primeorder-0.13.6\",\n sha256 = \"353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/primeorder/0.13.6/download\"],\n strip_prefix = \"primeorder-0.13.6\",\n build_file = Label(\"@crates//crates:BUILD.primeorder-0.13.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__proc-macro-crate-3.5.0\",\n sha256 = \"e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/proc-macro-crate/3.5.0/download\"],\n strip_prefix = \"proc-macro-crate-3.5.0\",\n build_file = Label(\"@crates//crates:BUILD.proc-macro-crate-3.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__proc-macro2-1.0.107\",\n sha256 = \"985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/proc-macro2/1.0.107/download\"],\n strip_prefix = \"proc-macro2-1.0.107\",\n build_file = Label(\"@crates//crates:BUILD.proc-macro2-1.0.107.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__procfs-0.18.0\",\n sha256 = \"25485360a54d6861439d60facef26de713b1e126bf015ec8f98239467a2b82f7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/procfs/0.18.0/download\"],\n strip_prefix = \"procfs-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.procfs-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__procfs-core-0.18.0\",\n sha256 = \"e6401bf7b6af22f78b563665d15a22e9aef27775b79b149a66ca022468a4e405\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/procfs-core/0.18.0/download\"],\n strip_prefix = \"procfs-core-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.procfs-core-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ptr_meta-0.3.2\",\n sha256 = \"743da816b98c921cdbe8628ef7381b76f25ecf4da599fc80aca90eae7ef70cc0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ptr_meta/0.3.2/download\"],\n strip_prefix = \"ptr_meta-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.ptr_meta-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ptr_meta_derive-0.3.2\",\n sha256 = \"1c8d9ca532f185d5d4db7a7c9d51420b452168ea1c2b913953281bd6fe1fcbd0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ptr_meta_derive/0.3.2/download\"],\n strip_prefix = \"ptr_meta_derive-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.ptr_meta_derive-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pxfm-0.1.30\",\n sha256 = \"d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pxfm/0.1.30/download\"],\n strip_prefix = \"pxfm-0.1.30\",\n build_file = Label(\"@crates//crates:BUILD.pxfm-0.1.30.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quantette-0.6.0\",\n sha256 = \"ba5d37e94c17b8870a5b936001d2845a6782a22ebdb1706c84294eca777f6729\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quantette/0.6.0/download\"],\n strip_prefix = \"quantette-0.6.0\",\n build_file = Label(\"@crates//crates:BUILD.quantette-0.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quick-error-2.0.1\",\n sha256 = \"a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quick-error/2.0.1/download\"],\n strip_prefix = \"quick-error-2.0.1\",\n build_file = Label(\"@crates//crates:BUILD.quick-error-2.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quick-xml-0.41.0\",\n sha256 = \"e660451e55124f798a69a5af3f49ccfbefbd41910eefd25caf2393e1f3473ec1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quick-xml/0.41.0/download\"],\n strip_prefix = \"quick-xml-0.41.0\",\n build_file = Label(\"@crates//crates:BUILD.quick-xml-0.41.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quote-1.0.47\",\n sha256 = \"1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quote/1.0.47/download\"],\n strip_prefix = \"quote-1.0.47\",\n build_file = Label(\"@crates//crates:BUILD.quote-1.0.47.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__r-efi-5.3.0\",\n sha256 = \"69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/r-efi/5.3.0/download\"],\n strip_prefix = \"r-efi-5.3.0\",\n build_file = Label(\"@crates//crates:BUILD.r-efi-5.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__r-efi-6.0.0\",\n sha256 = \"f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/r-efi/6.0.0/download\"],\n strip_prefix = \"r-efi-6.0.0\",\n build_file = Label(\"@crates//crates:BUILD.r-efi-6.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__radium-0.7.0\",\n sha256 = \"dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/radium/0.7.0/download\"],\n strip_prefix = \"radium-0.7.0\",\n build_file = Label(\"@crates//crates:BUILD.radium-0.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rancor-0.1.3\",\n sha256 = \"9b534442d0fcdb55d66f373d9cac6d33b6293a2335bc2136dbd06ce0e87d2572\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rancor/0.1.3/download\"],\n strip_prefix = \"rancor-0.1.3\",\n build_file = Label(\"@crates//crates:BUILD.rancor-0.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand-0.10.2\",\n sha256 = \"c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand/0.10.2/download\"],\n strip_prefix = \"rand-0.10.2\",\n build_file = Label(\"@crates//crates:BUILD.rand-0.10.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand-0.8.7\",\n sha256 = \"22f6172bdec972074665ed81ed53b71da00bfc44b65a753cfde883ec4c702a1a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand/0.8.7/download\"],\n strip_prefix = \"rand-0.8.7\",\n build_file = Label(\"@crates//crates:BUILD.rand-0.8.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand-0.9.5\",\n sha256 = \"b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand/0.9.5/download\"],\n strip_prefix = \"rand-0.9.5\",\n build_file = Label(\"@crates//crates:BUILD.rand-0.9.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand_chacha-0.9.0\",\n sha256 = \"d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand_chacha/0.9.0/download\"],\n strip_prefix = \"rand_chacha-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.rand_chacha-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand_core-0.10.1\",\n sha256 = \"63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand_core/0.10.1/download\"],\n strip_prefix = \"rand_core-0.10.1\",\n build_file = Label(\"@crates//crates:BUILD.rand_core-0.10.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand_core-0.6.4\",\n sha256 = \"ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand_core/0.6.4/download\"],\n strip_prefix = \"rand_core-0.6.4\",\n build_file = Label(\"@crates//crates:BUILD.rand_core-0.6.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand_core-0.9.5\",\n sha256 = \"76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand_core/0.9.5/download\"],\n strip_prefix = \"rand_core-0.9.5\",\n build_file = Label(\"@crates//crates:BUILD.rand_core-0.9.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand_xoshiro-0.8.1\",\n sha256 = \"662effc7698e08ea324d3acccf8d9d7f7bf79b9785e270a174ea36e56900c91d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand_xoshiro/0.8.1/download\"],\n strip_prefix = \"rand_xoshiro-0.8.1\",\n build_file = Label(\"@crates//crates:BUILD.rand_xoshiro-0.8.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rangemap-1.8.0\",\n sha256 = \"a611d15b50743feb4c76b7d03edcb0e64f399c26961e4efe6975bc398be6aa3d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rangemap/1.8.0/download\"],\n strip_prefix = \"rangemap-1.8.0\",\n build_file = Label(\"@crates//crates:BUILD.rangemap-1.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-1.12.0\",\n sha256 = \"fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon/1.12.0/download\"],\n strip_prefix = \"rayon-1.12.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-1.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-core-1.13.0\",\n sha256 = \"22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon-core/1.13.0/download\"],\n strip_prefix = \"rayon-core-1.13.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-core-1.13.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rcgen-0.13.2\",\n sha256 = \"75e669e5202259b5314d1ea5397316ad400819437857b90861765f24c4cf80a2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rcgen/0.13.2/download\"],\n strip_prefix = \"rcgen-0.13.2\",\n build_file = Label(\"@crates//crates:BUILD.rcgen-0.13.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__redox_syscall-0.5.18\",\n sha256 = \"ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/redox_syscall/0.5.18/download\"],\n strip_prefix = \"redox_syscall-0.5.18\",\n build_file = Label(\"@crates//crates:BUILD.redox_syscall-0.5.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ref-cast-1.0.27\",\n sha256 = \"7e440fb4e4b4147295338efb76001ab9e4efc0e5839df2c47fc5ac2381d365c3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ref-cast/1.0.27/download\"],\n strip_prefix = \"ref-cast-1.0.27\",\n build_file = Label(\"@crates//crates:BUILD.ref-cast-1.0.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ref-cast-impl-1.0.27\",\n sha256 = \"92ecd8964f8453721699a1ed72037b0db49ce2f5a5138486ee89bed6f67cdf3a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ref-cast-impl/1.0.27/download\"],\n strip_prefix = \"ref-cast-impl-1.0.27\",\n build_file = Label(\"@crates//crates:BUILD.ref-cast-impl-1.0.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-1.13.1\",\n sha256 = \"f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex/1.13.1/download\"],\n strip_prefix = \"regex-1.13.1\",\n build_file = Label(\"@crates//crates:BUILD.regex-1.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-automata-0.4.18\",\n sha256 = \"ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-automata/0.4.18/download\"],\n strip_prefix = \"regex-automata-0.4.18\",\n build_file = Label(\"@crates//crates:BUILD.regex-automata-0.4.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-lite-0.1.9\",\n sha256 = \"cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-lite/0.1.9/download\"],\n strip_prefix = \"regex-lite-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.regex-lite-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-syntax-0.8.11\",\n sha256 = \"d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-syntax/0.8.11/download\"],\n strip_prefix = \"regex-syntax-0.8.11\",\n build_file = Label(\"@crates//crates:BUILD.regex-syntax-0.8.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__reis-0.5.0\",\n sha256 = \"00939c5c526a1b4054ef8d9d96b3f92227f08ca355965e986741b556eda6d289\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/reis/0.5.0/download\"],\n strip_prefix = \"reis-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.reis-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rend-0.5.4\",\n sha256 = \"663ba70707f96e871406fe10d68128412e619b06d1d47cb91c3a4c6501176240\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rend/0.5.4/download\"],\n strip_prefix = \"rend-0.5.4\",\n build_file = Label(\"@crates//crates:BUILD.rend-0.5.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rfc6979-0.4.0\",\n sha256 = \"f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rfc6979/0.4.0/download\"],\n strip_prefix = \"rfc6979-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.rfc6979-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rgb-0.8.53\",\n sha256 = \"47b34b781b31e5d73e9fbc8689c70551fd1ade9a19e3e28cfec8580a79290cc4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rgb/0.8.53/download\"],\n strip_prefix = \"rgb-0.8.53\",\n build_file = Label(\"@crates//crates:BUILD.rgb-0.8.53.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ring-0.17.14\",\n sha256 = \"a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ring/0.17.14/download\"],\n strip_prefix = \"ring-0.17.14\",\n build_file = Label(\"@crates//crates:BUILD.ring-0.17.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rkyv-0.8.18\",\n sha256 = \"d9776093b7ca170454ab1406954f7b7d97a57c51dc6c0642957fb2ef25c2d399\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rkyv/0.8.18/download\"],\n strip_prefix = \"rkyv-0.8.18\",\n build_file = Label(\"@crates//crates:BUILD.rkyv-0.8.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rkyv_derive-0.8.18\",\n sha256 = \"1c25ef604ac7dd839d44d64648952ea23c97866f124ff671b0ed2cf3ad9bb06e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rkyv_derive/0.8.18/download\"],\n strip_prefix = \"rkyv_derive-0.8.18\",\n build_file = Label(\"@crates//crates:BUILD.rkyv_derive-0.8.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rlimit-0.11.0\",\n sha256 = \"f35ee2729c56bb610f6dba436bf78135f728b7373bdffae2ec815b2d3eb98cc3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rlimit/0.11.0/download\"],\n strip_prefix = \"rlimit-0.11.0\",\n build_file = Label(\"@crates//crates:BUILD.rlimit-0.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rpds-1.2.1\",\n sha256 = \"e025feb26210bc196b908e72deb063b1b4000754304341cbc168a1e72c857ebc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rpds/1.2.1/download\"],\n strip_prefix = \"rpds-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.rpds-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rtcp-0.17.2\",\n sha256 = \"adad7f6a501162881032fc84b4bc78ae11f1b30748180b9f5cbe8810bf613aab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rtcp/0.17.2/download\"],\n strip_prefix = \"rtcp-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.rtcp-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rtp-0.17.2\",\n sha256 = \"149329e78ada26b5e174a4c281a7a7e5c8bda6008adc90daddd6f98fce56db29\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rtp/0.17.2/download\"],\n strip_prefix = \"rtp-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.rtp-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustc-hash-1.1.0\",\n sha256 = \"08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustc-hash/1.1.0/download\"],\n strip_prefix = \"rustc-hash-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.rustc-hash-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustc-hash-2.1.3\",\n sha256 = \"6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustc-hash/2.1.3/download\"],\n strip_prefix = \"rustc-hash-2.1.3\",\n build_file = Label(\"@crates//crates:BUILD.rustc-hash-2.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustc_version-0.4.1\",\n sha256 = \"cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustc_version/0.4.1/download\"],\n strip_prefix = \"rustc_version-0.4.1\",\n build_file = Label(\"@crates//crates:BUILD.rustc_version-0.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rusticata-macros-4.1.0\",\n sha256 = \"faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rusticata-macros/4.1.0/download\"],\n strip_prefix = \"rusticata-macros-4.1.0\",\n build_file = Label(\"@crates//crates:BUILD.rusticata-macros-4.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustix-0.38.44\",\n sha256 = \"fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustix/0.38.44/download\"],\n strip_prefix = \"rustix-0.38.44\",\n build_file = Label(\"@crates//crates:BUILD.rustix-0.38.44.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustix-1.1.4\",\n sha256 = \"b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustix/1.1.4/download\"],\n strip_prefix = \"rustix-1.1.4\",\n build_file = Label(\"@crates//crates:BUILD.rustix-1.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustls-0.23.43\",\n sha256 = \"0283386ce02abc0151e1761d08802dfe86c173b0b494af5cbc086574e453da06\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustls/0.23.43/download\"],\n strip_prefix = \"rustls-0.23.43\",\n build_file = Label(\"@crates//crates:BUILD.rustls-0.23.43.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustls-pki-types-1.15.1\",\n sha256 = \"2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustls-pki-types/1.15.1/download\"],\n strip_prefix = \"rustls-pki-types-1.15.1\",\n build_file = Label(\"@crates//crates:BUILD.rustls-pki-types-1.15.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustls-webpki-0.103.15\",\n sha256 = \"f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustls-webpki/0.103.15/download\"],\n strip_prefix = \"rustls-webpki-0.103.15\",\n build_file = Label(\"@crates//crates:BUILD.rustls-webpki-0.103.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustversion-1.0.23\",\n sha256 = \"cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustversion/1.0.23/download\"],\n strip_prefix = \"rustversion-1.0.23\",\n build_file = Label(\"@crates//crates:BUILD.rustversion-1.0.23.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__safe_arch-1.2.0\",\n sha256 = \"42c6efa15875e6ecb39ca61fb0b0c1a40b84fac5a5ffe71eef7d1000c8eb3f5f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/safe_arch/1.2.0/download\"],\n strip_prefix = \"safe_arch-1.2.0\",\n build_file = Label(\"@crates//crates:BUILD.safe_arch-1.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__same-file-1.0.6\",\n sha256 = \"93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/same-file/1.0.6/download\"],\n strip_prefix = \"same-file-1.0.6\",\n build_file = Label(\"@crates//crates:BUILD.same-file-1.0.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__scoped-tls-1.0.1\",\n sha256 = \"e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/scoped-tls/1.0.1/download\"],\n strip_prefix = \"scoped-tls-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.scoped-tls-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__scopeguard-1.2.0\",\n sha256 = \"94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/scopeguard/1.2.0/download\"],\n strip_prefix = \"scopeguard-1.2.0\",\n build_file = Label(\"@crates//crates:BUILD.scopeguard-1.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sdp-0.17.2\",\n sha256 = \"66b6eecfa5151edef84d544ff3885dff98e5b5fe97586757a4b5118bde51c958\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sdp/0.17.2/download\"],\n strip_prefix = \"sdp-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.sdp-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sec1-0.7.3\",\n sha256 = \"d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sec1/0.7.3/download\"],\n strip_prefix = \"sec1-0.7.3\",\n build_file = Label(\"@crates//crates:BUILD.sec1-0.7.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__self_cell-1.3.0\",\n sha256 = \"2ab42ca02749e120097e328d91d415325bdf43b1c72c4c8badf37375fe40a813\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/self_cell/1.3.0/download\"],\n strip_prefix = \"self_cell-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.self_cell-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__semver-1.0.28\",\n sha256 = \"8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/semver/1.0.28/download\"],\n strip_prefix = \"semver-1.0.28\",\n build_file = Label(\"@crates//crates:BUILD.semver-1.0.28.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde-1.0.229\",\n sha256 = \"4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde/1.0.229/download\"],\n strip_prefix = \"serde-1.0.229\",\n build_file = Label(\"@crates//crates:BUILD.serde-1.0.229.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_core-1.0.229\",\n sha256 = \"67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_core/1.0.229/download\"],\n strip_prefix = \"serde_core-1.0.229\",\n build_file = Label(\"@crates//crates:BUILD.serde_core-1.0.229.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_derive-1.0.229\",\n sha256 = \"e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_derive/1.0.229/download\"],\n strip_prefix = \"serde_derive-1.0.229\",\n build_file = Label(\"@crates//crates:BUILD.serde_derive-1.0.229.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_json-1.0.151\",\n sha256 = \"c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_json/1.0.151/download\"],\n strip_prefix = \"serde_json-1.0.151\",\n build_file = Label(\"@crates//crates:BUILD.serde_json-1.0.151.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_repr-0.1.21\",\n sha256 = \"8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_repr/0.1.21/download\"],\n strip_prefix = \"serde_repr-0.1.21\",\n build_file = Label(\"@crates//crates:BUILD.serde_repr-0.1.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_spanned-1.1.1\",\n sha256 = \"6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_spanned/1.1.1/download\"],\n strip_prefix = \"serde_spanned-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.serde_spanned-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serial2-0.2.38\",\n sha256 = \"b16809bc35793b19ce4e0c53924bc0dce3937f15487997cfdaed936004180730\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serial2/0.2.38/download\"],\n strip_prefix = \"serial2-0.2.38\",\n build_file = Label(\"@crates//crates:BUILD.serial2-0.2.38.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sha1-0.10.7\",\n sha256 = \"a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sha1/0.10.7/download\"],\n strip_prefix = \"sha1-0.10.7\",\n build_file = Label(\"@crates//crates:BUILD.sha1-0.10.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sha2-0.10.9\",\n sha256 = \"a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sha2/0.10.9/download\"],\n strip_prefix = \"sha2-0.10.9\",\n build_file = Label(\"@crates//crates:BUILD.sha2-0.10.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sha3-0.10.9\",\n sha256 = \"77fd7028345d415a4034cf8777cd4f8ab1851274233b45f84e3d955502d93874\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sha3/0.10.9/download\"],\n strip_prefix = \"sha3-0.10.9\",\n build_file = Label(\"@crates//crates:BUILD.sha3-0.10.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shared_library-0.1.9\",\n sha256 = \"5a9e7e0f2bfae24d8a5b5a66c5b257a83c7412304311512a0c054cd5e619da11\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shared_library/0.1.9/download\"],\n strip_prefix = \"shared_library-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.shared_library-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shell-words-1.1.1\",\n sha256 = \"dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shell-words/1.1.1/download\"],\n strip_prefix = \"shell-words-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.shell-words-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shlex-1.3.0\",\n sha256 = \"0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shlex/1.3.0/download\"],\n strip_prefix = \"shlex-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.shlex-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shlex-2.0.1\",\n sha256 = \"f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shlex/2.0.1/download\"],\n strip_prefix = \"shlex-2.0.1\",\n build_file = Label(\"@crates//crates:BUILD.shlex-2.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__signal-hook-registry-1.4.8\",\n sha256 = \"c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/signal-hook-registry/1.4.8/download\"],\n strip_prefix = \"signal-hook-registry-1.4.8\",\n build_file = Label(\"@crates//crates:BUILD.signal-hook-registry-1.4.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__signature-2.2.0\",\n sha256 = \"77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/signature/2.2.0/download\"],\n strip_prefix = \"signature-2.2.0\",\n build_file = Label(\"@crates//crates:BUILD.signature-2.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__simd-adler32-0.3.10\",\n sha256 = \"3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/simd-adler32/0.3.10/download\"],\n strip_prefix = \"simd-adler32-0.3.10\",\n build_file = Label(\"@crates//crates:BUILD.simd-adler32-0.3.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__simdutf8-0.1.5\",\n sha256 = \"e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/simdutf8/0.1.5/download\"],\n strip_prefix = \"simdutf8-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.simdutf8-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__similar-2.7.0\",\n sha256 = \"bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/similar/2.7.0/download\"],\n strip_prefix = \"similar-2.7.0\",\n build_file = Label(\"@crates//crates:BUILD.similar-2.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__similar-3.2.0\",\n sha256 = \"4f66ca1f7aca2474dc10c942eb22feffc897735f54cd1db90138c2fddb490987\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/similar/3.2.0/download\"],\n strip_prefix = \"similar-3.2.0\",\n build_file = Label(\"@crates//crates:BUILD.similar-3.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__siphasher-1.0.3\",\n sha256 = \"8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/siphasher/1.0.3/download\"],\n strip_prefix = \"siphasher-1.0.3\",\n build_file = Label(\"@crates//crates:BUILD.siphasher-1.0.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__slab-0.4.12\",\n sha256 = \"0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/slab/0.4.12/download\"],\n strip_prefix = \"slab-0.4.12\",\n build_file = Label(\"@crates//crates:BUILD.slab-0.4.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sm3-0.5.0\",\n sha256 = \"da6a89ba31723d185fd7413b98c576a575f356d9b84729d8ecb6ead60000a5b6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sm3/0.5.0/download\"],\n strip_prefix = \"sm3-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.sm3-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__smallvec-1.15.2\",\n sha256 = \"8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/smallvec/1.15.2/download\"],\n strip_prefix = \"smallvec-1.15.2\",\n build_file = Label(\"@crates//crates:BUILD.smallvec-1.15.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__smol_str-0.2.2\",\n sha256 = \"dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/smol_str/0.2.2/download\"],\n strip_prefix = \"smol_str-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.smol_str-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__socket2-0.5.10\",\n sha256 = \"e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/socket2/0.5.10/download\"],\n strip_prefix = \"socket2-0.5.10\",\n build_file = Label(\"@crates//crates:BUILD.socket2-0.5.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__socket2-0.6.5\",\n sha256 = \"c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/socket2/0.6.5/download\"],\n strip_prefix = \"socket2-0.6.5\",\n build_file = Label(\"@crates//crates:BUILD.socket2-0.6.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__spin-0.10.1\",\n sha256 = \"023a211cb3138dbc438680b32560ad89f699977624c9f8dbb95a47d5b4c07dd3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/spin/0.10.1/download\"],\n strip_prefix = \"spin-0.10.1\",\n build_file = Label(\"@crates//crates:BUILD.spin-0.10.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__spin-0.9.9\",\n sha256 = \"3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/spin/0.9.9/download\"],\n strip_prefix = \"spin-0.9.9\",\n build_file = Label(\"@crates//crates:BUILD.spin-0.9.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__spki-0.7.3\",\n sha256 = \"d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/spki/0.7.3/download\"],\n strip_prefix = \"spki-0.7.3\",\n build_file = Label(\"@crates//crates:BUILD.spki-0.7.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__stable_deref_trait-1.2.1\",\n sha256 = \"6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/stable_deref_trait/1.2.1/download\"],\n strip_prefix = \"stable_deref_trait-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.stable_deref_trait-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__static_assertions-1.1.0\",\n sha256 = \"a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/static_assertions/1.1.0/download\"],\n strip_prefix = \"static_assertions-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.static_assertions-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__str_stack-0.1.1\",\n sha256 = \"7f446288b699d66d0fd2e30d1cfe7869194312524b3b9252594868ed26ef056a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/str_stack/0.1.1/download\"],\n strip_prefix = \"str_stack-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.str_stack-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__streaming-iterator-0.1.9\",\n sha256 = \"2b2231b7c3057d5e4ad0156fb3dc807d900806020c5ffa3ee6ff2c8c76fb8520\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/streaming-iterator/0.1.9/download\"],\n strip_prefix = \"streaming-iterator-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.streaming-iterator-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__string_cache-0.9.0\",\n sha256 = \"a18596f8c785a729f2819c0f6a7eae6ebeebdfffbfe4214ae6b087f690e31901\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/string_cache/0.9.0/download\"],\n strip_prefix = \"string_cache-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.string_cache-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__string_cache_codegen-0.6.1\",\n sha256 = \"585635e46db231059f76c5849798146164652513eb9e8ab2685939dd90f29b69\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/string_cache_codegen/0.6.1/download\"],\n strip_prefix = \"string_cache_codegen-0.6.1\",\n build_file = Label(\"@crates//crates:BUILD.string_cache_codegen-0.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__stringprep-0.1.5\",\n sha256 = \"7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/stringprep/0.1.5/download\"],\n strip_prefix = \"stringprep-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.stringprep-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strsim-0.11.1\",\n sha256 = \"7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strsim/0.11.1/download\"],\n strip_prefix = \"strsim-0.11.1\",\n build_file = Label(\"@crates//crates:BUILD.strsim-0.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum-0.28.0\",\n sha256 = \"9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum/0.28.0/download\"],\n strip_prefix = \"strum-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum_macros-0.28.0\",\n sha256 = \"ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum_macros/0.28.0/download\"],\n strip_prefix = \"strum_macros-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum_macros-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__stun-0.17.2\",\n sha256 = \"2e3b8d5ad1dd4c8cd0595440f26521a71dd593cb5873ee8e06b91510b7d97269\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/stun/0.17.2/download\"],\n strip_prefix = \"stun-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.stun-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__substring-1.4.5\",\n sha256 = \"42ee6433ecef213b2e72f587ef64a2f5943e7cd16fbd82dbe8bc07486c534c86\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/substring/1.4.5/download\"],\n strip_prefix = \"substring-1.4.5\",\n build_file = Label(\"@crates//crates:BUILD.substring-1.4.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__subtle-2.6.1\",\n sha256 = \"13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/subtle/2.6.1/download\"],\n strip_prefix = \"subtle-2.6.1\",\n build_file = Label(\"@crates//crates:BUILD.subtle-2.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__syn-2.0.119\",\n sha256 = \"872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/syn/2.0.119/download\"],\n strip_prefix = \"syn-2.0.119\",\n build_file = Label(\"@crates//crates:BUILD.syn-2.0.119.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__syn-3.0.3\",\n sha256 = \"53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/syn/3.0.3/download\"],\n strip_prefix = \"syn-3.0.3\",\n build_file = Label(\"@crates//crates:BUILD.syn-3.0.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__synstructure-0.13.2\",\n sha256 = \"728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/synstructure/0.13.2/download\"],\n strip_prefix = \"synstructure-0.13.2\",\n build_file = Label(\"@crates//crates:BUILD.synstructure-0.13.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__syntect-5.3.0\",\n sha256 = \"656b45c05d95a5704399aeef6bd0ddec7b2b3531b7c9e900abbf7c4d2190c925\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/syntect/5.3.0/download\"],\n strip_prefix = \"syntect-5.3.0\",\n build_file = Label(\"@crates//crates:BUILD.syntect-5.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__system-deps-7.0.8\",\n sha256 = \"396a35feb67335377e0251fcbc1092fc85c484bd4e3a7a54319399da127796e7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/system-deps/7.0.8/download\"],\n strip_prefix = \"system-deps-7.0.8\",\n build_file = Label(\"@crates//crates:BUILD.system-deps-7.0.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tap-1.0.1\",\n sha256 = \"55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tap/1.0.1/download\"],\n strip_prefix = \"tap-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.tap-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__target-lexicon-0.13.5\",\n sha256 = \"adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/target-lexicon/0.13.5/download\"],\n strip_prefix = \"target-lexicon-0.13.5\",\n build_file = Label(\"@crates//crates:BUILD.target-lexicon-0.13.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tempfile-3.27.0\",\n sha256 = \"32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tempfile/3.27.0/download\"],\n strip_prefix = \"tempfile-3.27.0\",\n build_file = Label(\"@crates//crates:BUILD.tempfile-3.27.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tendril-0.5.1\",\n sha256 = \"5fed54709c5b3a53d09bb1c113ea4f5ceafd1e772ddcb0030a82e1d56c087b08\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tendril/0.5.1/download\"],\n strip_prefix = \"tendril-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.tendril-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__termcolor-1.4.1\",\n sha256 = \"06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/termcolor/1.4.1/download\"],\n strip_prefix = \"termcolor-1.4.1\",\n build_file = Label(\"@crates//crates:BUILD.termcolor-1.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__terminal_size-0.4.4\",\n sha256 = \"230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/terminal_size/0.4.4/download\"],\n strip_prefix = \"terminal_size-0.4.4\",\n build_file = Label(\"@crates//crates:BUILD.terminal_size-0.4.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__terminfo-0.9.0\",\n sha256 = \"d4ea810f0692f9f51b382fff5893887bb4580f5fa246fde546e0b13e7fcee662\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/terminfo/0.9.0/download\"],\n strip_prefix = \"terminfo-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.terminfo-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-1.0.69\",\n sha256 = \"b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror/1.0.69/download\"],\n strip_prefix = \"thiserror-1.0.69\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-1.0.69.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-2.0.20\",\n sha256 = \"ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror/2.0.20/download\"],\n strip_prefix = \"thiserror-2.0.20\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-2.0.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-impl-1.0.69\",\n sha256 = \"4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror-impl/1.0.69/download\"],\n strip_prefix = \"thiserror-impl-1.0.69\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-impl-1.0.69.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-impl-2.0.20\",\n sha256 = \"bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror-impl/2.0.20/download\"],\n strip_prefix = \"thiserror-impl-2.0.20\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-impl-2.0.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tiff-0.11.3\",\n sha256 = \"b63feaf3343d35b6ca4d50483f94843803b0f51634937cc2ec519fc32232bc52\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tiff/0.11.3/download\"],\n strip_prefix = \"tiff-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.tiff-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tiktoken-rs-0.11.0\",\n sha256 = \"fac4a168cfc1d8ed65bf17a6ee0843ad9a68f863c63c0fb2fa7eab67838782ee\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tiktoken-rs/0.11.0/download\"],\n strip_prefix = \"tiktoken-rs-0.11.0\",\n build_file = Label(\"@crates//crates:BUILD.tiktoken-rs-0.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-0.3.55\",\n sha256 = \"cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time/0.3.55/download\"],\n strip_prefix = \"time-0.3.55\",\n build_file = Label(\"@crates//crates:BUILD.time-0.3.55.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-core-0.1.9\",\n sha256 = \"9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time-core/0.1.9/download\"],\n strip_prefix = \"time-core-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.time-core-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-macros-0.2.32\",\n sha256 = \"7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time-macros/0.2.32/download\"],\n strip_prefix = \"time-macros-0.2.32\",\n build_file = Label(\"@crates//crates:BUILD.time-macros-0.2.32.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tiny-keccak-2.0.2\",\n sha256 = \"2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tiny-keccak/2.0.2/download\"],\n strip_prefix = \"tiny-keccak-2.0.2\",\n build_file = Label(\"@crates//crates:BUILD.tiny-keccak-2.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinystr-0.8.4\",\n sha256 = \"b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinystr/0.8.4/download\"],\n strip_prefix = \"tinystr-0.8.4\",\n build_file = Label(\"@crates//crates:BUILD.tinystr-0.8.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec-1.12.0\",\n sha256 = \"bb4ebadaa0af04fab11ae01eb5f9fdb5f9c5b875506e210e71c07873528baa7f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec/1.12.0/download\"],\n strip_prefix = \"tinyvec-1.12.0\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec-1.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec_macros-0.1.1\",\n sha256 = \"1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec_macros/0.1.1/download\"],\n strip_prefix = \"tinyvec_macros-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec_macros-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tokio-1.53.1\",\n sha256 = \"202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tokio/1.53.1/download\"],\n strip_prefix = \"tokio-1.53.1\",\n build_file = Label(\"@crates//crates:BUILD.tokio-1.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tokio-macros-2.7.2\",\n sha256 = \"78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tokio-macros/2.7.2/download\"],\n strip_prefix = \"tokio-macros-2.7.2\",\n build_file = Label(\"@crates//crates:BUILD.tokio-macros-2.7.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tokio-util-0.7.19\",\n sha256 = \"494815d09bf52b5548659851081238f0ca39ff638363907596da739561c62c52\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tokio-util/0.7.19/download\"],\n strip_prefix = \"tokio-util-0.7.19\",\n build_file = Label(\"@crates//crates:BUILD.tokio-util-0.7.19.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml-1.1.4-spec-1.1.0\",\n sha256 = \"3aace63f4bbcdfc2c965b059de67119c89c4017a70d633be6c104910f67056f5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml/1.1.4+spec-1.1.0/download\"],\n strip_prefix = \"toml-1.1.4+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml-1.1.4+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_datetime-1.1.1-spec-1.1.0\",\n sha256 = \"3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_datetime/1.1.1+spec-1.1.0/download\"],\n strip_prefix = \"toml_datetime-1.1.1+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_datetime-1.1.1+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_edit-0.25.13-spec-1.1.0\",\n sha256 = \"6975367e4d2ef766d86af01ffad14b622fecc8d4357a998fbc4deb6e9bacaf9b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_edit/0.25.13+spec-1.1.0/download\"],\n strip_prefix = \"toml_edit-0.25.13+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_edit-0.25.13+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_parser-1.1.3-spec-1.1.0\",\n sha256 = \"1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_parser/1.1.3+spec-1.1.0/download\"],\n strip_prefix = \"toml_parser-1.1.3+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_parser-1.1.3+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_writer-1.1.2-spec-1.1.0\",\n sha256 = \"7d56353a2a665ad0f41a421187180aab746c8c325620617ad883a99a1cbe66d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_writer/1.1.2+spec-1.1.0/download\"],\n strip_prefix = \"toml_writer-1.1.2+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_writer-1.1.2+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tracing-0.1.44\",\n sha256 = \"63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tracing/0.1.44/download\"],\n strip_prefix = \"tracing-0.1.44\",\n build_file = Label(\"@crates//crates:BUILD.tracing-0.1.44.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tracing-attributes-0.1.31\",\n sha256 = \"7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tracing-attributes/0.1.31/download\"],\n strip_prefix = \"tracing-attributes-0.1.31\",\n build_file = Label(\"@crates//crates:BUILD.tracing-attributes-0.1.31.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tracing-core-0.1.36\",\n sha256 = \"db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tracing-core/0.1.36/download\"],\n strip_prefix = \"tracing-core-0.1.36\",\n build_file = Label(\"@crates//crates:BUILD.tracing-core-0.1.36.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-0.25.10\",\n sha256 = \"78f873475d258561b06f1c595d93308a7ed124d9977cb26b148c2084a4a3cc87\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter/0.25.10/download\"],\n strip_prefix = \"tree-sitter-0.25.10\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-0.25.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-astro-next-0.1.1\",\n sha256 = \"794a4a59fc2d88e49b4bc41fef9522d77184a36f4e68bbaf545cd1eb2364c46e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-astro-next/0.1.1/download\"],\n strip_prefix = \"tree-sitter-astro-next-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-astro-next-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-bash-0.25.1\",\n sha256 = \"9e5ec769279cc91b561d3df0d8a5deb26b0ad40d183127f409494d6d8fc53062\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-bash/0.25.1/download\"],\n strip_prefix = \"tree-sitter-bash-0.25.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-bash-0.25.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-c-0.24.2\",\n sha256 = \"a9b2eb57a55fed6b00812912e730b7a275cf4fe98bfd6a5d76263d4438371728\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-c/0.24.2/download\"],\n strip_prefix = \"tree-sitter-c-0.24.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-c-0.24.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-c-sharp-0.23.5\",\n sha256 = \"c1aac67f1ad71de1d6d39708d34811081c26dfa495658de6c14c34200849357c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-c-sharp/0.23.5/download\"],\n strip_prefix = \"tree-sitter-c-sharp-0.23.5\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-c-sharp-0.23.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-clojure-0.1.0\",\n sha256 = \"4004884cc509449a1d78fa3e1f02b4e953d0a8065984445304795e72e885338c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-clojure/0.1.0/download\"],\n strip_prefix = \"tree-sitter-clojure-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-clojure-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-cmake-0.7.4\",\n sha256 = \"164e0c4f4236ec5ceff14824a5528615cf462e100467e49826442ff57d327061\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-cmake/0.7.4/download\"],\n strip_prefix = \"tree-sitter-cmake-0.7.4\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-cmake-0.7.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-cpp-0.23.4\",\n sha256 = \"df2196ea9d47b4ab4a31b9297eaa5a5d19a0b121dceb9f118f6790ad0ab94743\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-cpp/0.23.4/download\"],\n strip_prefix = \"tree-sitter-cpp-0.23.4\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-cpp-0.23.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-css-0.25.0\",\n sha256 = \"a5cbc5e18f29a2c6d6435891f42569525cf95435a3e01c2f1947abcde178686f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-css/0.25.0/download\"],\n strip_prefix = \"tree-sitter-css-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-css-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-dart-0.2.0\",\n sha256 = \"325dd1e24ee9ee21111e9c43680ae7d6010aaa9f282b048a99b9c7163c1cf553\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-dart/0.2.0/download\"],\n strip_prefix = \"tree-sitter-dart-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-dart-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-diff-0.1.0\",\n sha256 = \"dfe1e5ca280a65dfe5ba4205c1bcc84edf486464fed315db53dee6da9a335889\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-diff/0.1.0/download\"],\n strip_prefix = \"tree-sitter-diff-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-diff-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-dockerfile-updated-0.2.0\",\n sha256 = \"5e61eb704364be179ab9be89e2891c8e77c0041eca5891a5c04164a21f6df7a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-dockerfile-updated/0.2.0/download\"],\n strip_prefix = \"tree-sitter-dockerfile-updated-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-dockerfile-updated-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-elisp-1.7.2\",\n sha256 = \"6b8b82ab7474028f20d2119285566f219209ebdbeec767fa28025b70f94f8cf3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-elisp/1.7.2/download\"],\n strip_prefix = \"tree-sitter-elisp-1.7.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-elisp-1.7.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-elixir-0.3.5\",\n sha256 = \"66dd064a762ed95bfc29857fa3cb7403bb1e5cb88112de0f6341b7e47284ba40\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-elixir/0.3.5/download\"],\n strip_prefix = \"tree-sitter-elixir-0.3.5\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-elixir-0.3.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-erlang-0.16.0\",\n sha256 = \"ceb442e728225d601db0661f60d64e166bd9b9a55c587f71d4e4f27378717cce\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-erlang/0.16.0/download\"],\n strip_prefix = \"tree-sitter-erlang-0.16.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-erlang-0.16.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-fortran-0.6.0\",\n sha256 = \"ea5fea41363a9b59666001dc26c4b356d4e164da27c6ce31145e00aba6bf9b16\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-fortran/0.6.0/download\"],\n strip_prefix = \"tree-sitter-fortran-0.6.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-fortran-0.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-go-0.25.0\",\n sha256 = \"c8560a4d2f835cc0d4d2c2e03cbd0dde2f6114b43bc491164238d333e28b16ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-go/0.25.0/download\"],\n strip_prefix = \"tree-sitter-go-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-go-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-graphql-0.1.0\",\n sha256 = \"efedc4cac157161cc23a0adc4553a2cedc908e1cd754b6cd033a919bb81ce5d6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-graphql/0.1.0/download\"],\n strip_prefix = \"tree-sitter-graphql-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-graphql-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-haskell-0.23.1\",\n sha256 = \"977c51e504548cba13fc27cb5a2edab2124cf6716a1934915d07ab99523b05a4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-haskell/0.23.1/download\"],\n strip_prefix = \"tree-sitter-haskell-0.23.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-haskell-0.23.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-hcl-1.1.0\",\n sha256 = \"5a7b2cc3d7121553b84309fab9d11b3ff3d420403eef9ae50f9fd1cd9d9cf012\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-hcl/1.1.0/download\"],\n strip_prefix = \"tree-sitter-hcl-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-hcl-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-html-0.23.2\",\n sha256 = \"261b708e5d92061ede329babaaa427b819329a9d427a1d710abb0f67bbef63ee\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-html/0.23.2/download\"],\n strip_prefix = \"tree-sitter-html-0.23.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-html-0.23.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-ini-1.4.0\",\n sha256 = \"387f79682cd53b7c0a5777c96e601a02b9965a787984ef86dbb8952bdab2d62f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-ini/1.4.0/download\"],\n strip_prefix = \"tree-sitter-ini-1.4.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-ini-1.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-java-0.23.5\",\n sha256 = \"0aa6cbcdc8c679b214e616fd3300da67da0e492e066df01bcf5a5921a71e90d6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-java/0.23.5/download\"],\n strip_prefix = \"tree-sitter-java-0.23.5\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-java-0.23.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-javascript-0.25.0\",\n sha256 = \"68204f2abc0627a90bdf06e605f5c470aa26fdcb2081ea553a04bdad756693f5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-javascript/0.25.0/download\"],\n strip_prefix = \"tree-sitter-javascript-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-javascript-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-json-0.24.8\",\n sha256 = \"4d727acca406c0020cffc6cf35516764f36c8e3dc4408e5ebe2cb35a947ec471\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-json/0.24.8/download\"],\n strip_prefix = \"tree-sitter-json-0.24.8\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-json-0.24.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-julia-0.23.1\",\n sha256 = \"4144731a178812ee867619b1e98b3b91e54c1652304b26e5ebe3175b701de323\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-julia/0.23.1/download\"],\n strip_prefix = \"tree-sitter-julia-0.23.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-julia-0.23.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-just-0.2.0\",\n sha256 = \"bd46794f2c270f43d73b2f2c8c256992471f3493c903604da0886df984771920\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-just/0.2.0/download\"],\n strip_prefix = \"tree-sitter-just-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-just-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-kotlin-sg-0.4.1\",\n sha256 = \"c06ec43ae3c12165d4ac08afe4e1f5fc6757ffe274fa7bd5af9007ef11ba4319\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-kotlin-sg/0.4.1/download\"],\n strip_prefix = \"tree-sitter-kotlin-sg-0.4.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-kotlin-sg-0.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-language-0.1.7\",\n sha256 = \"009994f150cc0cd50ff54917d5bc8bffe8cad10ca10d81c34da2ec421ae61782\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-language/0.1.7/download\"],\n strip_prefix = \"tree-sitter-language-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-language-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-lua-0.5.0\",\n sha256 = \"8daaf5f4235188a58603c39760d5fa5d4b920d36a299c934adddae757f32a10c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-lua/0.5.0/download\"],\n strip_prefix = \"tree-sitter-lua-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-lua-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-make-1.1.1\",\n sha256 = \"c5998dc7cbcbdab19fae8aefef982bf2d6544513d8d2e69cc44aec4c63810104\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-make/1.1.1/download\"],\n strip_prefix = \"tree-sitter-make-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-make-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-md-0.5.3\",\n sha256 = \"2efd398be546456c814598ee56c0f51769a77241511b4a58077815d120afa882\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-md/0.5.3/download\"],\n strip_prefix = \"tree-sitter-md-0.5.3\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-md-0.5.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-nix-0.3.0\",\n sha256 = \"4952a9733f3a98f6683a0ccd1035d84ab7a52f7e84eeed58548d86765ad92de3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-nix/0.3.0/download\"],\n strip_prefix = \"tree-sitter-nix-0.3.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-nix-0.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-objc-3.0.2\",\n sha256 = \"9ca8bb556423fc176f0535e79d525f783a6684d3c9da81bf9d905303c129e1d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-objc/3.0.2/download\"],\n strip_prefix = \"tree-sitter-objc-3.0.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-objc-3.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-ocaml-0.24.2\",\n sha256 = \"7d19db582b3855f56b5f9ec484170fbfb9ee60b938ec7720d76d2ee788e8b640\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-ocaml/0.24.2/download\"],\n strip_prefix = \"tree-sitter-ocaml-0.24.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-ocaml-0.24.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-odin-1.3.0\",\n sha256 = \"24db210fe9ba2237c71c5030d7b146c7025420ba72dd8013d13cd822c3a8d77a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-odin/1.3.0/download\"],\n strip_prefix = \"tree-sitter-odin-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-odin-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-php-0.24.2\",\n sha256 = \"0d8c17c3ab69052c5eeaa7ff5cd972dd1bc25d1b97ee779fec391ad3b5df5592\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-php/0.24.2/download\"],\n strip_prefix = \"tree-sitter-php-0.24.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-php-0.24.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-powershell-0.26.4\",\n sha256 = \"3faf304d44b9ddd4a7d97804bb8de7daf564336dd5a526dc6de5b39238243022\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-powershell/0.26.4/download\"],\n strip_prefix = \"tree-sitter-powershell-0.26.4\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-powershell-0.26.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-proto-0.4.0\",\n sha256 = \"2e410ccb5fa3cbd6bf7b8e512ecf7ad9d5254395b822bfe9f751b50fa978f31c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-proto/0.4.0/download\"],\n strip_prefix = \"tree-sitter-proto-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-proto-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-python-0.25.0\",\n sha256 = \"6bf85fd39652e740bf60f46f4cda9492c3a9ad75880575bf14960f775cb74a1c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-python/0.25.0/download\"],\n strip_prefix = \"tree-sitter-python-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-python-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-r-1.3.0\",\n sha256 = \"ffc9954ec870dcad6cffdd302b405306c68cf031ed79a78cd9746f6740d9fe20\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-r/1.3.0/download\"],\n strip_prefix = \"tree-sitter-r-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-r-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-regex-0.25.0\",\n sha256 = \"bd8a59be9f0ac131fd8f062eaaba14882b2fa5a6a7882a20134cb1d60df2e625\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-regex/0.25.0/download\"],\n strip_prefix = \"tree-sitter-regex-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-regex-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-ruby-0.23.1\",\n sha256 = \"be0484ea4ef6bb9c575b4fdabde7e31340a8d2dbc7d52b321ac83da703249f95\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-ruby/0.23.1/download\"],\n strip_prefix = \"tree-sitter-ruby-0.23.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-ruby-0.23.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-rust-0.24.2\",\n sha256 = \"439e577dbe07423ec2582ac62c7531120dbfccfa6e5f92406f93dd271a120e45\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-rust/0.24.2/download\"],\n strip_prefix = \"tree-sitter-rust-0.24.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-rust-0.24.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-scala-0.26.2\",\n sha256 = \"24e0ab4505990bfe30051761d40a7bf4033ce5a81c9eda9e20e987a5cdc84826\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-scala/0.26.2/download\"],\n strip_prefix = \"tree-sitter-scala-0.26.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-scala-0.26.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-sequel-0.3.11\",\n sha256 = \"9d198ad3c319c02e43c21efa1ec796b837afcb96ffaef1a40c1978fbdcec7d17\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-sequel/0.3.11/download\"],\n strip_prefix = \"tree-sitter-sequel-0.3.11\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-sequel-0.3.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-solidity-1.2.13\",\n sha256 = \"4eacf8875b70879f0cb670c60b233ad0b68752d9e1474e6c3ef168eea8a90b25\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-solidity/1.2.13/download\"],\n strip_prefix = \"tree-sitter-solidity-1.2.13\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-solidity-1.2.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-starlark-1.3.0\",\n sha256 = \"8934f282d085cc4b9ee28aa688aa3fbe8aa3766201c2a6252f411d45b4c3a721\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-starlark/1.3.0/download\"],\n strip_prefix = \"tree-sitter-starlark-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-starlark-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-svelte-next-0.1.1\",\n sha256 = \"56f88190d0743e897c3e148a7e241aba0a8844b8afe816943851426e3f7b9753\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-svelte-next/0.1.1/download\"],\n strip_prefix = \"tree-sitter-svelte-next-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-svelte-next-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-swift-0.7.3\",\n sha256 = \"fe36052155b9dd69ca82b3b8f1b4ccfb2d867125ac1a4db1dd7331829242668c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-swift/0.7.3/download\"],\n strip_prefix = \"tree-sitter-swift-0.7.3\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-swift-0.7.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-tlaplus-1.5.0\",\n sha256 = \"ddaacc0337bfee38f233a91a704dc36b887a0c385348163f65344d64b73f79e1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-tlaplus/1.5.0/download\"],\n strip_prefix = \"tree-sitter-tlaplus-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-tlaplus-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-toml-ng-0.7.0\",\n sha256 = \"e9adc2c898ae49730e857d75be403da3f92bb81d8e37a2f918a08dd10de5ebb1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-toml-ng/0.7.0/download\"],\n strip_prefix = \"tree-sitter-toml-ng-0.7.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-toml-ng-0.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-typescript-0.23.2\",\n sha256 = \"6c5f76ed8d947a75cc446d5fccd8b602ebf0cde64ccf2ffa434d873d7a575eff\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-typescript/0.23.2/download\"],\n strip_prefix = \"tree-sitter-typescript-0.23.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-typescript-0.23.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-verilog-1.0.3\",\n sha256 = \"d4e7e0360395852f1f6ff5b7b82c72dc6557d181073188df1d60ec469ea69c66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-verilog/1.0.3/download\"],\n strip_prefix = \"tree-sitter-verilog-1.0.3\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-verilog-1.0.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-vue-next-0.1.0\",\n sha256 = \"e9ac89acaa8165aaabfa8ae9683aa423b0d2bf42c815dae5ca031a36a75525f1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-vue-next/0.1.0/download\"],\n strip_prefix = \"tree-sitter-vue-next-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-vue-next-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-xml-0.7.0\",\n sha256 = \"e670041f591d994f54d597ddcd8f4ebc930e282c4c76a42268743b71f0c8b6b3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-xml/0.7.0/download\"],\n strip_prefix = \"tree-sitter-xml-0.7.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-xml-0.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-yaml-0.7.2\",\n sha256 = \"53c223db85f05e34794f065454843b0668ebc15d240ada63e2b5939f43ce7c97\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-yaml/0.7.2/download\"],\n strip_prefix = \"tree-sitter-yaml-0.7.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-yaml-0.7.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-zig-1.1.2\",\n sha256 = \"ab11fc124851b0db4dd5e55983bbd9631192e93238389dcd44521715e5d53e28\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-zig/1.1.2/download\"],\n strip_prefix = \"tree-sitter-zig-1.1.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-zig-1.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree_magic_mini-3.2.2\",\n sha256 = \"b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree_magic_mini/3.2.2/download\"],\n strip_prefix = \"tree_magic_mini-3.2.2\",\n build_file = Label(\"@crates//crates:BUILD.tree_magic_mini-3.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__triomphe-0.1.16\",\n sha256 = \"b40688ea6389c8171614b25491f71d4a27946e0c7ce2da1c6de27e25abf1a0ae\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/triomphe/0.1.16/download\"],\n strip_prefix = \"triomphe-0.1.16\",\n build_file = Label(\"@crates//crates:BUILD.triomphe-0.1.16.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ttf-parser-0.25.1\",\n sha256 = \"d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ttf-parser/0.25.1/download\"],\n strip_prefix = \"ttf-parser-0.25.1\",\n build_file = Label(\"@crates//crates:BUILD.ttf-parser-0.25.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__turn-0.17.2\",\n sha256 = \"d99249a493335eb44c4d7943a8751b22561a82c9903d8eb2d29780b3927880a7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/turn/0.17.2/download\"],\n strip_prefix = \"turn-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.turn-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__type-map-0.5.1\",\n sha256 = \"cb30dbbd9036155e74adad6812e9898d03ec374946234fbcebd5dfc7b9187b90\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/type-map/0.5.1/download\"],\n strip_prefix = \"type-map-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.type-map-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__typed-arena-2.0.2\",\n sha256 = \"6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/typed-arena/2.0.2/download\"],\n strip_prefix = \"typed-arena-2.0.2\",\n build_file = Label(\"@crates//crates:BUILD.typed-arena-2.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__typenum-1.20.1\",\n sha256 = \"b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/typenum/1.20.1/download\"],\n strip_prefix = \"typenum-1.20.1\",\n build_file = Label(\"@crates//crates:BUILD.typenum-1.20.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ucd-trie-0.1.7\",\n sha256 = \"2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ucd-trie/0.1.7/download\"],\n strip_prefix = \"ucd-trie-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.ucd-trie-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uds_windows-1.2.1\",\n sha256 = \"f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uds_windows/1.2.1/download\"],\n strip_prefix = \"uds_windows-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.uds_windows-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uiautomation-0.25.0\",\n sha256 = \"c68495a701b9f2f21f29353ac446f0d27dd0d7ce97aa9ccf9061bca0446cd744\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uiautomation/0.25.0/download\"],\n strip_prefix = \"uiautomation-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.uiautomation-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uiautomation_derive-0.7.8\",\n sha256 = \"ffcc4d404aa1c03a848f95cf5feadc3e63946d7f095bf388770b85550093d388\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uiautomation_derive/0.7.8/download\"],\n strip_prefix = \"uiautomation_derive-0.7.8\",\n build_file = Label(\"@crates//crates:BUILD.uiautomation_derive-0.7.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unic-langid-0.9.6\",\n sha256 = \"a28ba52c9b05311f4f6e62d5d9d46f094bd6e84cb8df7b3ef952748d752a7d05\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unic-langid/0.9.6/download\"],\n strip_prefix = \"unic-langid-0.9.6\",\n build_file = Label(\"@crates//crates:BUILD.unic-langid-0.9.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unic-langid-impl-0.9.6\",\n sha256 = \"dce1bf08044d4b7a94028c93786f8566047edc11110595914de93362559bc658\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unic-langid-impl/0.9.6/download\"],\n strip_prefix = \"unic-langid-impl-0.9.6\",\n build_file = Label(\"@crates//crates:BUILD.unic-langid-impl-0.9.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicase-2.9.0\",\n sha256 = \"dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicase/2.9.0/download\"],\n strip_prefix = \"unicase-2.9.0\",\n build_file = Label(\"@crates//crates:BUILD.unicase-2.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-bidi-0.3.18\",\n sha256 = \"5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-bidi/0.3.18/download\"],\n strip_prefix = \"unicode-bidi-0.3.18\",\n build_file = Label(\"@crates//crates:BUILD.unicode-bidi-0.3.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-ident-1.0.24\",\n sha256 = \"e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-ident/1.0.24/download\"],\n strip_prefix = \"unicode-ident-1.0.24\",\n build_file = Label(\"@crates//crates:BUILD.unicode-ident-1.0.24.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-normalization-0.1.25\",\n sha256 = \"5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-normalization/0.1.25/download\"],\n strip_prefix = \"unicode-normalization-0.1.25\",\n build_file = Label(\"@crates//crates:BUILD.unicode-normalization-0.1.25.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-properties-0.1.4\",\n sha256 = \"7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-properties/0.1.4/download\"],\n strip_prefix = \"unicode-properties-0.1.4\",\n build_file = Label(\"@crates//crates:BUILD.unicode-properties-0.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-segmentation-1.13.3\",\n sha256 = \"c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-segmentation/1.13.3/download\"],\n strip_prefix = \"unicode-segmentation-1.13.3\",\n build_file = Label(\"@crates//crates:BUILD.unicode-segmentation-1.13.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-width-0.1.14\",\n sha256 = \"7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-width/0.1.14/download\"],\n strip_prefix = \"unicode-width-0.1.14\",\n build_file = Label(\"@crates//crates:BUILD.unicode-width-0.1.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-width-0.2.2\",\n sha256 = \"b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-width/0.2.2/download\"],\n strip_prefix = \"unicode-width-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.unicode-width-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unit-prefix-0.5.2\",\n sha256 = \"81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unit-prefix/0.5.2/download\"],\n strip_prefix = \"unit-prefix-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.unit-prefix-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__universal-hash-0.5.1\",\n sha256 = \"fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/universal-hash/0.5.1/download\"],\n strip_prefix = \"universal-hash-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.universal-hash-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__untrusted-0.9.0\",\n sha256 = \"8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/untrusted/0.9.0/download\"],\n strip_prefix = \"untrusted-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.untrusted-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__url-2.5.8\",\n sha256 = \"ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/url/2.5.8/download\"],\n strip_prefix = \"url-2.5.8\",\n build_file = Label(\"@crates//crates:BUILD.url-2.5.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__urlencoding-2.1.3\",\n sha256 = \"daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/urlencoding/2.1.3/download\"],\n strip_prefix = \"urlencoding-2.1.3\",\n build_file = Label(\"@crates//crates:BUILD.urlencoding-2.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf16_iter-1.0.5\",\n sha256 = \"c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf16_iter/1.0.5/download\"],\n strip_prefix = \"utf16_iter-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.utf16_iter-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf8-chars-3.0.7\",\n sha256 = \"92498c67ea3511b37eccff13b573ed871faf0ce9c4056ab032bd01a681f445a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf8-chars/3.0.7/download\"],\n strip_prefix = \"utf8-chars-3.0.7\",\n build_file = Label(\"@crates//crates:BUILD.utf8-chars-3.0.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf8_iter-1.0.4\",\n sha256 = \"b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf8_iter/1.0.4/download\"],\n strip_prefix = \"utf8_iter-1.0.4\",\n build_file = Label(\"@crates//crates:BUILD.utf8_iter-1.0.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf8parse-0.2.2\",\n sha256 = \"06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf8parse/0.2.2/download\"],\n strip_prefix = \"utf8parse-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.utf8parse-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uucore-0.8.0\",\n sha256 = \"07d779636d827cde4100f0e65ff3fd23b0b1f1195055475c6e6813d425f30c8e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uucore/0.8.0/download\"],\n strip_prefix = \"uucore-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.uucore-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uucore_procs-0.8.0\",\n sha256 = \"da865e8a648b260dbd89fca76d0801995877ab27a4e259b6dec30ba9743b86ab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uucore_procs/0.8.0/download\"],\n strip_prefix = \"uucore_procs-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.uucore_procs-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uuid-1.24.1\",\n sha256 = \"2cefc03fd367c0c6d4305de1b312cf00248c4114f4a0418ce6a6af769e3b0bd9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uuid/1.24.1/download\"],\n strip_prefix = \"uuid-1.24.1\",\n build_file = Label(\"@crates//crates:BUILD.uuid-1.24.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uutils_term_grid-0.8.0\",\n sha256 = \"382d49b39de4a115f203305057741126b09a615892d773a2d419a2b816e30e39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uutils_term_grid/0.8.0/download\"],\n strip_prefix = \"uutils_term_grid-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.uutils_term_grid-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uzers-0.12.2\",\n sha256 = \"0b8275fb1afee25b4111d2dc8b5c505dbbc4afd0b990cb96deb2d88bff8be18d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uzers/0.12.2/download\"],\n strip_prefix = \"uzers-0.12.2\",\n build_file = Label(\"@crates//crates:BUILD.uzers-0.12.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__version-compare-0.2.1\",\n sha256 = \"03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/version-compare/0.2.1/download\"],\n strip_prefix = \"version-compare-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.version-compare-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__version_check-0.9.5\",\n sha256 = \"0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/version_check/0.9.5/download\"],\n strip_prefix = \"version_check-0.9.5\",\n build_file = Label(\"@crates//crates:BUILD.version_check-0.9.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__vsimd-0.8.0\",\n sha256 = \"5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/vsimd/0.8.0/download\"],\n strip_prefix = \"vsimd-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.vsimd-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__waitgroup-0.1.2\",\n sha256 = \"d1f50000a783467e6c0200f9d10642f4bc424e39efc1b770203e88b488f79292\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/waitgroup/0.1.2/download\"],\n strip_prefix = \"waitgroup-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.waitgroup-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__walkdir-2.5.0\",\n sha256 = \"29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/walkdir/2.5.0/download\"],\n strip_prefix = \"walkdir-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.walkdir-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasi-0.11.1-wasi-snapshot-preview1\",\n sha256 = \"ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasi/0.11.1+wasi-snapshot-preview1/download\"],\n strip_prefix = \"wasi-0.11.1+wasi-snapshot-preview1\",\n build_file = Label(\"@crates//crates:BUILD.wasi-0.11.1+wasi-snapshot-preview1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasi-0.14.7-wasi-0.2.4\",\n sha256 = \"883478de20367e224c0090af9cf5f9fa85bed63a95c1abf3afc5c083ebc06e8c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasi/0.14.7+wasi-0.2.4/download\"],\n strip_prefix = \"wasi-0.14.7+wasi-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.wasi-0.14.7+wasi-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasip2-1.0.4-wasi-0.2.12\",\n sha256 = \"b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasip2/1.0.4+wasi-0.2.12/download\"],\n strip_prefix = \"wasip2-1.0.4+wasi-0.2.12\",\n build_file = Label(\"@crates//crates:BUILD.wasip2-1.0.4+wasi-0.2.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasite-1.0.2\",\n sha256 = \"66fe902b4a6b8028a753d5424909b764ccf79b7a209eac9bf97e59cda9f71a42\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasite/1.0.2/download\"],\n strip_prefix = \"wasite-1.0.2\",\n build_file = Label(\"@crates//crates:BUILD.wasite-1.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-0.2.127\",\n sha256 = \"1b70935747edd64d89de3efa29d73789b806c15798f8e7dca4d8ac356b50ce70\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen/0.2.127/download\"],\n strip_prefix = \"wasm-bindgen-0.2.127\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-0.2.127.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-0.2.127\",\n sha256 = \"77775f8f3f7217702089053b94958f8f54061a3f663417df76e19cbdcca29bc1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro/0.2.127/download\"],\n strip_prefix = \"wasm-bindgen-macro-0.2.127\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-0.2.127.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-support-0.2.127\",\n sha256 = \"e11d33f857dc2fb11b8bc75aee111aa9cbeb12cd9f25efd3d4c2a3dd4e235284\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro-support/0.2.127/download\"],\n strip_prefix = \"wasm-bindgen-macro-support-0.2.127\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-support-0.2.127.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-shared-0.2.127\",\n sha256 = \"7ef64dbcc55df09c7e5a46182d181c2cfa3e925f3da937ea764728b4bbb9dcbf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-shared/0.2.127/download\"],\n strip_prefix = \"wasm-bindgen-shared-0.2.127\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-shared-0.2.127.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-backend-0.3.17\",\n sha256 = \"38a91b4eaddff87b1cd1074985e3713da4af2c49742d1b356b2c01670a67a078\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-backend/0.3.17/download\"],\n strip_prefix = \"wayland-backend-0.3.17\",\n build_file = Label(\"@crates//crates:BUILD.wayland-backend-0.3.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-client-0.31.15\",\n sha256 = \"e3c36a0f861ad76d0901f2800b46321410d9f73f2ea88aac0650d86c32688073\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-client/0.31.15/download\"],\n strip_prefix = \"wayland-client-0.31.15\",\n build_file = Label(\"@crates//crates:BUILD.wayland-client-0.31.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-protocols-0.32.13\",\n sha256 = \"23d0c813de3daa2ed6520af85a3bd49b0e722a3078506899aa9686fea58dc4b6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-protocols/0.32.13/download\"],\n strip_prefix = \"wayland-protocols-0.32.13\",\n build_file = Label(\"@crates//crates:BUILD.wayland-protocols-0.32.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-protocols-wlr-0.3.12\",\n sha256 = \"eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-protocols-wlr/0.3.12/download\"],\n strip_prefix = \"wayland-protocols-wlr-0.3.12\",\n build_file = Label(\"@crates//crates:BUILD.wayland-protocols-wlr-0.3.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-scanner-0.31.11\",\n sha256 = \"338e30461b3a2b67d70eb30a6d89f8e0c93a833e07d2ae89085cd070c4a00ac0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-scanner/0.31.11/download\"],\n strip_prefix = \"wayland-scanner-0.31.11\",\n build_file = Label(\"@crates//crates:BUILD.wayland-scanner-0.31.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-server-0.31.14\",\n sha256 = \"0dde9c29be0f723a573977de51ee455bf3dfa03652730a74f9dd3b337e374d75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-server/0.31.14/download\"],\n strip_prefix = \"wayland-server-0.31.14\",\n build_file = Label(\"@crates//crates:BUILD.wayland-server-0.31.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-sys-0.31.11\",\n sha256 = \"d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-sys/0.31.11/download\"],\n strip_prefix = \"wayland-sys-0.31.11\",\n build_file = Label(\"@crates//crates:BUILD.wayland-sys-0.31.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__web-sys-0.3.104\",\n sha256 = \"c435338968042f4f59a557f690a253676d47ce13ceb55d70100e7facf6620a30\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/web-sys/0.3.104/download\"],\n strip_prefix = \"web-sys-0.3.104\",\n build_file = Label(\"@crates//crates:BUILD.web-sys-0.3.104.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__web-time-1.1.0\",\n sha256 = \"5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/web-time/1.1.0/download\"],\n strip_prefix = \"web-time-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.web-time-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__web_atoms-0.2.6\",\n sha256 = \"ba8b815c1b593dc0baf78dd0f4fc8fdb2de53198fb1163738093e9a311c33fb3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/web_atoms/0.2.6/download\"],\n strip_prefix = \"web_atoms-0.2.6\",\n build_file = Label(\"@crates//crates:BUILD.web_atoms-0.2.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-0.17.2\",\n sha256 = \"baaacdf9d96224d7b6e2872ba065578f38775f7634367e3ac2cc87c7271da433\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc/0.17.2/download\"],\n strip_prefix = \"webrtc-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-data-0.17.2\",\n sha256 = \"bd470286275809f2fcfcdb1e73ef5f1500be82eff7fe98150ce81b20aad5a2a4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-data/0.17.2/download\"],\n strip_prefix = \"webrtc-data-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-data-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-ice-0.17.2\",\n sha256 = \"5b7fd30f52e6fda8664779b84b7904b2553b76fee24d9ca665e774ae32b13f53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-ice/0.17.2/download\"],\n strip_prefix = \"webrtc-ice-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-ice-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-mdns-0.17.2\",\n sha256 = \"91ffa0ea00c0fae979aafa5db285fec5eeb360e1ea246ebec529ba4e09f8e03e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-mdns/0.17.2/download\"],\n strip_prefix = \"webrtc-mdns-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-mdns-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-media-0.17.2\",\n sha256 = \"26a6c7335bdd03dc023cb9a3bd7966866d969c92c86987b73aa16dfa39c7ca29\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-media/0.17.2/download\"],\n strip_prefix = \"webrtc-media-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-media-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-sctp-0.17.2\",\n sha256 = \"1c4b637f0d8eb96d900ac0f79b3060ddd21ca88dfefa467e96e67ab0016f2574\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-sctp/0.17.2/download\"],\n strip_prefix = \"webrtc-sctp-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-sctp-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-srtp-0.17.2\",\n sha256 = \"45d2b667a0b5d04eebcb7cb22fd51b2af3721f418097b496e72de16386c8d0c3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-srtp/0.17.2/download\"],\n strip_prefix = \"webrtc-srtp-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-srtp-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-util-0.17.2\",\n sha256 = \"1beae0b4f24969741c26ca282a257dc5823bd9cbe608f7e3ca3775102d323ad9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-util/0.17.2/download\"],\n strip_prefix = \"webrtc-util-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-util-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__weezl-0.1.12\",\n sha256 = \"a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/weezl/0.1.12/download\"],\n strip_prefix = \"weezl-0.1.12\",\n build_file = Label(\"@crates//crates:BUILD.weezl-0.1.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__whoami-2.1.3\",\n sha256 = \"626c4bac6755d76ffc12cb01b2eac751db1996b9e0041de9aa02c8c211ddc82c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/whoami/2.1.3/download\"],\n strip_prefix = \"whoami-2.1.3\",\n build_file = Label(\"@crates//crates:BUILD.whoami-2.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wide-1.6.1\",\n sha256 = \"de2aaf408e58689c2096682331b1f42bb2d9f2ed6b11560407d023cd0a6c634e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wide/1.6.1/download\"],\n strip_prefix = \"wide-1.6.1\",\n build_file = Label(\"@crates//crates:BUILD.wide-1.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__widestring-1.2.1\",\n sha256 = \"72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/widestring/1.2.1/download\"],\n strip_prefix = \"widestring-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.widestring-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wild-2.2.1\",\n sha256 = \"a3131afc8c575281e1e80f36ed6a092aa502c08b18ed7524e86fbbb12bb410e1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wild/2.2.1/download\"],\n strip_prefix = \"wild-2.2.1\",\n build_file = Label(\"@crates//crates:BUILD.wild-2.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-0.3.9\",\n sha256 = \"5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi/0.3.9/download\"],\n strip_prefix = \"winapi-0.3.9\",\n build_file = Label(\"@crates//crates:BUILD.winapi-0.3.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-i686-pc-windows-gnu-0.4.0\",\n sha256 = \"ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi-i686-pc-windows-gnu/0.4.0/download\"],\n strip_prefix = \"winapi-i686-pc-windows-gnu-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-util-0.1.11\",\n sha256 = \"c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi-util/0.1.11/download\"],\n strip_prefix = \"winapi-util-0.1.11\",\n build_file = Label(\"@crates//crates:BUILD.winapi-util-0.1.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-x86_64-pc-windows-gnu-0.4.0\",\n sha256 = \"712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download\"],\n strip_prefix = \"winapi-x86_64-pc-windows-gnu-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-0.51.1\",\n sha256 = \"ca229916c5ee38c2f2bc1e9d8f04df975b4bd93f9955dc69fabb5d91270045c9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows/0.51.1/download\"],\n strip_prefix = \"windows-0.51.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-0.51.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-0.61.3\",\n sha256 = \"9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows/0.61.3/download\"],\n strip_prefix = \"windows-0.61.3\",\n build_file = Label(\"@crates//crates:BUILD.windows-0.61.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-0.62.2\",\n sha256 = \"527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows/0.62.2/download\"],\n strip_prefix = \"windows-0.62.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-0.62.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-collections-0.2.0\",\n sha256 = \"3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-collections/0.2.0/download\"],\n strip_prefix = \"windows-collections-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-collections-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-collections-0.3.2\",\n sha256 = \"23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-collections/0.3.2/download\"],\n strip_prefix = \"windows-collections-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-collections-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-core-0.51.1\",\n sha256 = \"f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-core/0.51.1/download\"],\n strip_prefix = \"windows-core-0.51.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-core-0.51.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-core-0.61.2\",\n sha256 = \"c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-core/0.61.2/download\"],\n strip_prefix = \"windows-core-0.61.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-core-0.61.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-core-0.62.2\",\n sha256 = \"b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-core/0.62.2/download\"],\n strip_prefix = \"windows-core-0.62.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-core-0.62.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-future-0.2.1\",\n sha256 = \"fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-future/0.2.1/download\"],\n strip_prefix = \"windows-future-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-future-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-future-0.3.2\",\n sha256 = \"e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-future/0.3.2/download\"],\n strip_prefix = \"windows-future-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-future-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-implement-0.60.2\",\n sha256 = \"053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-implement/0.60.2/download\"],\n strip_prefix = \"windows-implement-0.60.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-implement-0.60.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-interface-0.59.3\",\n sha256 = \"3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-interface/0.59.3/download\"],\n strip_prefix = \"windows-interface-0.59.3\",\n build_file = Label(\"@crates//crates:BUILD.windows-interface-0.59.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-link-0.1.3\",\n sha256 = \"5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-link/0.1.3/download\"],\n strip_prefix = \"windows-link-0.1.3\",\n build_file = Label(\"@crates//crates:BUILD.windows-link-0.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-link-0.2.1\",\n sha256 = \"f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-link/0.2.1/download\"],\n strip_prefix = \"windows-link-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-link-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-numerics-0.2.0\",\n sha256 = \"9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-numerics/0.2.0/download\"],\n strip_prefix = \"windows-numerics-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-numerics-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-numerics-0.3.1\",\n sha256 = \"6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-numerics/0.3.1/download\"],\n strip_prefix = \"windows-numerics-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-numerics-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-result-0.3.4\",\n sha256 = \"56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-result/0.3.4/download\"],\n strip_prefix = \"windows-result-0.3.4\",\n build_file = Label(\"@crates//crates:BUILD.windows-result-0.3.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-result-0.4.1\",\n sha256 = \"7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-result/0.4.1/download\"],\n strip_prefix = \"windows-result-0.4.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-result-0.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-strings-0.4.2\",\n sha256 = \"56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-strings/0.4.2/download\"],\n strip_prefix = \"windows-strings-0.4.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-strings-0.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-strings-0.5.1\",\n sha256 = \"7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-strings/0.5.1/download\"],\n strip_prefix = \"windows-strings-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-strings-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.52.0\",\n sha256 = \"282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.52.0/download\"],\n strip_prefix = \"windows-sys-0.52.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.52.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.59.0\",\n sha256 = \"1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.59.0/download\"],\n strip_prefix = \"windows-sys-0.59.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.59.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.60.2\",\n sha256 = \"f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.60.2/download\"],\n strip_prefix = \"windows-sys-0.60.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.60.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.61.2\",\n sha256 = \"ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.61.2/download\"],\n strip_prefix = \"windows-sys-0.61.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.61.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-targets-0.48.5\",\n sha256 = \"9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-targets/0.48.5/download\"],\n strip_prefix = \"windows-targets-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows-targets-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-targets-0.52.6\",\n sha256 = \"9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-targets/0.52.6/download\"],\n strip_prefix = \"windows-targets-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows-targets-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-targets-0.53.5\",\n sha256 = \"4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-targets/0.53.5/download\"],\n strip_prefix = \"windows-targets-0.53.5\",\n build_file = Label(\"@crates//crates:BUILD.windows-targets-0.53.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-threading-0.1.0\",\n sha256 = \"b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-threading/0.1.0/download\"],\n strip_prefix = \"windows-threading-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-threading-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-threading-0.2.1\",\n sha256 = \"3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-threading/0.2.1/download\"],\n strip_prefix = \"windows-threading-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-threading-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_gnullvm-0.48.5\",\n sha256 = \"2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_gnullvm/0.48.5/download\"],\n strip_prefix = \"windows_aarch64_gnullvm-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_gnullvm-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_gnullvm-0.52.6\",\n sha256 = \"32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_gnullvm-0.53.1\",\n sha256 = \"a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_gnullvm/0.53.1/download\"],\n strip_prefix = \"windows_aarch64_gnullvm-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_gnullvm-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_msvc-0.48.5\",\n sha256 = \"dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_msvc/0.48.5/download\"],\n strip_prefix = \"windows_aarch64_msvc-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_msvc-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_msvc-0.52.6\",\n sha256 = \"09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_msvc-0.53.1\",\n sha256 = \"b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_msvc/0.53.1/download\"],\n strip_prefix = \"windows_aarch64_msvc-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_msvc-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnu-0.48.5\",\n sha256 = \"a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnu/0.48.5/download\"],\n strip_prefix = \"windows_i686_gnu-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnu-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnu-0.52.6\",\n sha256 = \"8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnu/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnu-0.53.1\",\n sha256 = \"960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnu/0.53.1/download\"],\n strip_prefix = \"windows_i686_gnu-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnu-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnullvm-0.52.6\",\n sha256 = \"0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnullvm-0.53.1\",\n sha256 = \"fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnullvm/0.53.1/download\"],\n strip_prefix = \"windows_i686_gnullvm-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnullvm-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_msvc-0.48.5\",\n sha256 = \"8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_msvc/0.48.5/download\"],\n strip_prefix = \"windows_i686_msvc-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_msvc-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_msvc-0.52.6\",\n sha256 = \"240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_msvc/0.52.6/download\"],\n strip_prefix = \"windows_i686_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_msvc-0.53.1\",\n sha256 = \"1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_msvc/0.53.1/download\"],\n strip_prefix = \"windows_i686_msvc-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_msvc-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnu-0.48.5\",\n sha256 = \"53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnu/0.48.5/download\"],\n strip_prefix = \"windows_x86_64_gnu-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnu-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnu-0.52.6\",\n sha256 = \"147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnu/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnu-0.53.1\",\n sha256 = \"9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnu/0.53.1/download\"],\n strip_prefix = \"windows_x86_64_gnu-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnu-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnullvm-0.48.5\",\n sha256 = \"0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnullvm/0.48.5/download\"],\n strip_prefix = \"windows_x86_64_gnullvm-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnullvm-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnullvm-0.52.6\",\n sha256 = \"24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnullvm-0.53.1\",\n sha256 = \"0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnullvm/0.53.1/download\"],\n strip_prefix = \"windows_x86_64_gnullvm-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnullvm-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_msvc-0.48.5\",\n sha256 = \"ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_msvc/0.48.5/download\"],\n strip_prefix = \"windows_x86_64_msvc-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_msvc-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_msvc-0.52.6\",\n sha256 = \"589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_msvc-0.53.1\",\n sha256 = \"d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_msvc/0.53.1/download\"],\n strip_prefix = \"windows_x86_64_msvc-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_msvc-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-0.7.15\",\n sha256 = \"df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/0.7.15/download\"],\n strip_prefix = \"winnow-0.7.15\",\n build_file = Label(\"@crates//crates:BUILD.winnow-0.7.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-1.0.4\",\n sha256 = \"23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/1.0.4/download\"],\n strip_prefix = \"winnow-1.0.4\",\n build_file = Label(\"@crates//crates:BUILD.winnow-1.0.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winreg-0.10.1\",\n sha256 = \"80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winreg/0.10.1/download\"],\n strip_prefix = \"winreg-0.10.1\",\n build_file = Label(\"@crates//crates:BUILD.winreg-0.10.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winreg-0.56.0\",\n sha256 = \"7d6f32a0ff4a9f6f01231eb2059cc85479330739333e0e58cadf03b6af2cca10\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winreg/0.56.0/download\"],\n strip_prefix = \"winreg-0.56.0\",\n build_file = Label(\"@crates//crates:BUILD.winreg-0.56.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-0.57.1\",\n sha256 = \"1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen/0.57.1/download\"],\n strip_prefix = \"wit-bindgen-0.57.1\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-0.57.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wl-clipboard-rs-0.9.3\",\n sha256 = \"e9651471a32e87d96ef3a127715382b2d11cc7c8bb9822ded8a7cc94072eb0a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wl-clipboard-rs/0.9.3/download\"],\n strip_prefix = \"wl-clipboard-rs-0.9.3\",\n build_file = Label(\"@crates//crates:BUILD.wl-clipboard-rs-0.9.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__write16-1.0.0\",\n sha256 = \"d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/write16/1.0.0/download\"],\n strip_prefix = \"write16-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.write16-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__writeable-0.6.4\",\n sha256 = \"3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/writeable/0.6.4/download\"],\n strip_prefix = \"writeable-0.6.4\",\n build_file = Label(\"@crates//crates:BUILD.writeable-0.6.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wyz-0.5.1\",\n sha256 = \"05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wyz/0.5.1/download\"],\n strip_prefix = \"wyz-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.wyz-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__x11rb-0.13.2\",\n sha256 = \"9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/x11rb/0.13.2/download\"],\n strip_prefix = \"x11rb-0.13.2\",\n build_file = Label(\"@crates//crates:BUILD.x11rb-0.13.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__x11rb-protocol-0.13.2\",\n sha256 = \"ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/x11rb-protocol/0.13.2/download\"],\n strip_prefix = \"x11rb-protocol-0.13.2\",\n build_file = Label(\"@crates//crates:BUILD.x11rb-protocol-0.13.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__x25519-dalek-2.0.1\",\n sha256 = \"c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/x25519-dalek/2.0.1/download\"],\n strip_prefix = \"x25519-dalek-2.0.1\",\n build_file = Label(\"@crates//crates:BUILD.x25519-dalek-2.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__x509-parser-0.16.0\",\n sha256 = \"fcbc162f30700d6f3f82a24bf7cc62ffe7caea42c0b2cba8bf7f3ae50cf51f69\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/x509-parser/0.16.0/download\"],\n strip_prefix = \"x509-parser-0.16.0\",\n build_file = Label(\"@crates//crates:BUILD.x509-parser-0.16.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xattr-1.6.1\",\n sha256 = \"32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xattr/1.6.1/download\"],\n strip_prefix = \"xattr-1.6.1\",\n build_file = Label(\"@crates//crates:BUILD.xattr-1.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xcap-0.9.6\",\n sha256 = \"b6ad471d5ba232bc276382d26a9d3b837d6853b7df389058b5bb1e94dcdd248c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xcap/0.9.6/download\"],\n strip_prefix = \"xcap-0.9.6\",\n build_file = Label(\"@crates//crates:BUILD.xcap-0.9.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xcb-1.7.1\",\n sha256 = \"a6c2ad15e0e922856ee89afe862b8992334bbe7953adad56cd1199358cb30566\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xcb/1.7.1/download\"],\n strip_prefix = \"xcb-1.7.1\",\n build_file = Label(\"@crates//crates:BUILD.xcb-1.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xkbcommon-0.9.0\",\n sha256 = \"a7a974f48060a14e95705c01f24ad9c3345022f4d97441b8a36beb7ed5c4a02d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xkbcommon/0.9.0/download\"],\n strip_prefix = \"xkbcommon-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.xkbcommon-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xkeysym-0.2.1\",\n sha256 = \"b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xkeysym/0.2.1/download\"],\n strip_prefix = \"xkeysym-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.xkeysym-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xml-rs-0.8.29\",\n sha256 = \"e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xml-rs/0.8.29/download\"],\n strip_prefix = \"xml-rs-0.8.29\",\n build_file = Label(\"@crates//crates:BUILD.xml-rs-0.8.29.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xutf-1.4.0\",\n sha256 = \"a14f3ca7038796715a5f5fd1c22aac21423b4f86fd9ef5585ef1744a5cfc573e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xutf/1.4.0/download\"],\n strip_prefix = \"xutf-1.4.0\",\n build_file = Label(\"@crates//crates:BUILD.xutf-1.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xxhash-rust-0.8.18\",\n sha256 = \"aee1b19627c7c60102ab80d3a9cbe18de90bfe03bfa6c3715447681f0e8c8af6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xxhash-rust/0.8.18/download\"],\n strip_prefix = \"xxhash-rust-0.8.18\",\n build_file = Label(\"@crates//crates:BUILD.xxhash-rust-0.8.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yaml-rust-0.4.5\",\n sha256 = \"56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yaml-rust/0.4.5/download\"],\n strip_prefix = \"yaml-rust-0.4.5\",\n build_file = Label(\"@crates//crates:BUILD.yaml-rust-0.4.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yansi-1.0.1\",\n sha256 = \"cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yansi/1.0.1/download\"],\n strip_prefix = \"yansi-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.yansi-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yasna-0.5.2\",\n sha256 = \"e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yasna/0.5.2/download\"],\n strip_prefix = \"yasna-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.yasna-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yoke-0.8.3\",\n sha256 = \"709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yoke/0.8.3/download\"],\n strip_prefix = \"yoke-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.yoke-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yoke-derive-0.8.2\",\n sha256 = \"de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yoke-derive/0.8.2/download\"],\n strip_prefix = \"yoke-derive-0.8.2\",\n build_file = Label(\"@crates//crates:BUILD.yoke-derive-0.8.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__z85-3.0.7\",\n sha256 = \"c6e61e59a957b7ccee15d2049f86e8bfd6f66968fcd88f018950662d9b86e675\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/z85/3.0.7/download\"],\n strip_prefix = \"z85-3.0.7\",\n build_file = Label(\"@crates//crates:BUILD.z85-3.0.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus-5.19.0\",\n sha256 = \"5db4be7c075cb421e4b7ee645541604239bd243ba7c357511f4ff3a74b555907\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus/5.19.0/download\"],\n strip_prefix = \"zbus-5.19.0\",\n build_file = Label(\"@crates//crates:BUILD.zbus-5.19.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus-lockstep-0.5.2\",\n sha256 = \"6998de05217a084b7578728a9443d04ea4cd80f2a0839b8d78770b76ccd45863\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus-lockstep/0.5.2/download\"],\n strip_prefix = \"zbus-lockstep-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.zbus-lockstep-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus-lockstep-macros-0.5.2\",\n sha256 = \"10da05367f3a7b7553c8cdf8fa91aee6b64afebe32b51c95177957efc47ca3a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus-lockstep-macros/0.5.2/download\"],\n strip_prefix = \"zbus-lockstep-macros-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.zbus-lockstep-macros-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus_macros-5.19.0\",\n sha256 = \"2990635d09ade6df1868f72f8cac69a876a90981e8bd3c40b1be413f8dc88f40\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus_macros/5.19.0/download\"],\n strip_prefix = \"zbus_macros-5.19.0\",\n build_file = Label(\"@crates//crates:BUILD.zbus_macros-5.19.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus_names-4.3.4\",\n sha256 = \"d8bf88b4a3ff53e883001e0e0115b297a9d53c31b9c1edd2bfdd853e3428624e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus_names/4.3.4/download\"],\n strip_prefix = \"zbus_names-4.3.4\",\n build_file = Label(\"@crates//crates:BUILD.zbus_names-4.3.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus_xml-5.2.1\",\n sha256 = \"d1586c021a01ca0a9216dcd874e546382e156a5cbab5fab6cb5f10087e22682a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus_xml/5.2.1/download\"],\n strip_prefix = \"zbus_xml-5.2.1\",\n build_file = Label(\"@crates//crates:BUILD.zbus_xml-5.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zcheapstr-1.1.0\",\n sha256 = \"d1afec51604565183aeb5c54c20aeab286120d4e4460f7f76e3e8bb8c0d99473\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zcheapstr/1.1.0/download\"],\n strip_prefix = \"zcheapstr-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.zcheapstr-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-0.8.56\",\n sha256 = \"556764e583adb45a9f8d413c2a147fa7e8d821e48e12b14fd560b607998b75eb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy/0.8.56/download\"],\n strip_prefix = \"zerocopy-0.8.56\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-0.8.56.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-derive-0.8.56\",\n sha256 = \"f2ab42fc20575779bd240faa45f94a74256f755c0fa9e89f0ede20d91d0cdfc1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy-derive/0.8.56/download\"],\n strip_prefix = \"zerocopy-derive-0.8.56\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-derive-0.8.56.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerofrom-0.1.8\",\n sha256 = \"0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerofrom/0.1.8/download\"],\n strip_prefix = \"zerofrom-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.zerofrom-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerofrom-derive-0.1.7\",\n sha256 = \"11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerofrom-derive/0.1.7/download\"],\n strip_prefix = \"zerofrom-derive-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.zerofrom-derive-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zeroize-1.9.0\",\n sha256 = \"e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zeroize/1.9.0/download\"],\n strip_prefix = \"zeroize-1.9.0\",\n build_file = Label(\"@crates//crates:BUILD.zeroize-1.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zeroize_derive-1.5.0\",\n sha256 = \"3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zeroize_derive/1.5.0/download\"],\n strip_prefix = \"zeroize_derive-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.zeroize_derive-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerotrie-0.2.5\",\n sha256 = \"4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerotrie/0.2.5/download\"],\n strip_prefix = \"zerotrie-0.2.5\",\n build_file = Label(\"@crates//crates:BUILD.zerotrie-0.2.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerovec-0.11.8\",\n sha256 = \"bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerovec/0.11.8/download\"],\n strip_prefix = \"zerovec-0.11.8\",\n build_file = Label(\"@crates//crates:BUILD.zerovec-0.11.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerovec-derive-0.11.6\",\n sha256 = \"34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerovec-derive/0.11.6/download\"],\n strip_prefix = \"zerovec-derive-0.11.6\",\n build_file = Label(\"@crates//crates:BUILD.zerovec-derive-0.11.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zmij-1.0.23\",\n sha256 = \"29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zmij/1.0.23/download\"],\n strip_prefix = \"zmij-1.0.23\",\n build_file = Label(\"@crates//crates:BUILD.zmij-1.0.23.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zstd-0.13.3\",\n sha256 = \"e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zstd/0.13.3/download\"],\n strip_prefix = \"zstd-0.13.3\",\n build_file = Label(\"@crates//crates:BUILD.zstd-0.13.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zstd-safe-7.2.4\",\n sha256 = \"8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zstd-safe/7.2.4/download\"],\n strip_prefix = \"zstd-safe-7.2.4\",\n build_file = Label(\"@crates//crates:BUILD.zstd-safe-7.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zstd-sys-2.0.16-zstd.1.5.7\",\n sha256 = \"91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zstd-sys/2.0.16+zstd.1.5.7/download\"],\n strip_prefix = \"zstd-sys-2.0.16+zstd.1.5.7\",\n build_file = Label(\"@crates//crates:BUILD.zstd-sys-2.0.16+zstd.1.5.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zune-core-0.5.3\",\n sha256 = \"d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zune-core/0.5.3/download\"],\n strip_prefix = \"zune-core-0.5.3\",\n build_file = Label(\"@crates//crates:BUILD.zune-core-0.5.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zune-jpeg-0.5.15\",\n sha256 = \"27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zune-jpeg/0.5.15/download\"],\n strip_prefix = \"zune-jpeg-0.5.15\",\n build_file = Label(\"@crates//crates:BUILD.zune-jpeg-0.5.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zvariant-5.15.0\",\n sha256 = \"c1d34c27cc6cdd1f458427519dd6b8612f7b7e3f7b9a0b2355d041dda9869147\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zvariant/5.15.0/download\"],\n strip_prefix = \"zvariant-5.15.0\",\n build_file = Label(\"@crates//crates:BUILD.zvariant-5.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zvariant_derive-5.15.0\",\n sha256 = \"864155e69b4352db0c7f374917bf45d1e0c8d17659c8b3dbf9795f3673f8c497\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zvariant_derive/5.15.0/download\"],\n strip_prefix = \"zvariant_derive-5.15.0\",\n build_file = Label(\"@crates//crates:BUILD.zvariant_derive-5.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zvariant_utils-4.2.0\",\n sha256 = \"bad0294361a320b694a328460dc73add56c306150f5cb6bfafc44446120008a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zvariant_utils/4.2.0/download\"],\n strip_prefix = \"zvariant_utils-4.2.0\",\n build_file = Label(\"@crates//crates:BUILD.zvariant_utils-4.2.0.bazel\"),\n )\n\n return [\n struct(repo = \"crates\", is_dev_dep = False),\n struct(repo=\"crates__ansi-width-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__anyhow-1.0.104\", is_dev_dep = False),\n struct(repo=\"crates__arboard-3.6.1\", is_dev_dep = False),\n struct(repo=\"crates__argmax-0.3.1\", is_dev_dep = False),\n struct(repo=\"crates__ashpd-0.11.1\", is_dev_dep = False),\n struct(repo=\"crates__ast-grep-core-0.39.9\", is_dev_dep = False),\n struct(repo=\"crates__async-recursion-1.1.1\", is_dev_dep = False),\n struct(repo=\"crates__async-trait-0.1.92\", is_dev_dep = False),\n struct(repo=\"crates__atspi-0.30.0\", is_dev_dep = False),\n struct(repo=\"crates__audiopus_sys-0.2.2\", is_dev_dep = False),\n struct(repo=\"crates__base64-0.22.1\", is_dev_dep = False),\n struct(repo=\"crates__bigdecimal-0.4.10\", is_dev_dep = False),\n struct(repo=\"crates__binary-heap-plus-0.5.0\", is_dev_dep = False),\n struct(repo=\"crates__bon-3.9.3\", is_dev_dep = False),\n struct(repo=\"crates__brush-parser-0.3.0\", is_dev_dep = False),\n struct(repo=\"crates__brush-parser-0.4.0\", is_dev_dep = False),\n struct(repo=\"crates__bstr-1.13.1\", is_dev_dep = False),\n struct(repo=\"crates__bytecount-0.6.9\", is_dev_dep = False),\n struct(repo=\"crates__bytes-1.12.1\", is_dev_dep = False),\n struct(repo=\"crates__cached-0.59.0\", is_dev_dep = False),\n struct(repo=\"crates__cfg-if-1.0.4\", is_dev_dep = False),\n struct(repo=\"crates__check_elevation-0.2.7\", is_dev_dep = False),\n struct(repo=\"crates__chrono-0.4.45\", is_dev_dep = False),\n struct(repo=\"crates__clap-4.6.6\", is_dev_dep = False),\n struct(repo=\"crates__clipboard-win-5.4.1\", is_dev_dep = False),\n struct(repo=\"crates__codesnake-0.2.1\", is_dev_dep = False),\n struct(repo=\"crates__color-print-0.3.7\", is_dev_dep = False),\n struct(repo=\"crates__command-fds-0.3.3\", is_dev_dep = False),\n struct(repo=\"crates__compare-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__core-graphics-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__dashmap-6.2.1\", is_dev_dep = False),\n struct(repo=\"crates__dns-lookup-3.0.1\", is_dev_dep = False),\n struct(repo=\"crates__enigo-0.6.1\", is_dev_dep = False),\n struct(repo=\"crates__faccess-0.2.4\", is_dev_dep = False),\n struct(repo=\"crates__fancy-regex-0.17.0\", is_dev_dep = False),\n struct(repo=\"crates__filetime-0.2.29\", is_dev_dep = False),\n struct(repo=\"crates__flume-0.11.1\", is_dev_dep = False),\n struct(repo=\"crates__foldhash-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__fontdue-0.9.4\", is_dev_dep = False),\n struct(repo=\"crates__foreign-types-0.5.0\", is_dev_dep = False),\n struct(repo=\"crates__fs_extra-1.3.0\", is_dev_dep = False),\n struct(repo=\"crates__futures-0.3.34\", is_dev_dep = False),\n struct(repo=\"crates__getrandom-0.4.3\", is_dev_dep = False),\n struct(repo=\"crates__glob-0.3.4\", is_dev_dep = False),\n struct(repo=\"crates__globset-0.4.20\", is_dev_dep = False),\n struct(repo=\"crates__grep-cli-0.1.12\", is_dev_dep = False),\n struct(repo=\"crates__grep-matcher-0.1.9\", is_dev_dep = False),\n struct(repo=\"crates__grep-pcre2-0.1.10\", is_dev_dep = False),\n struct(repo=\"crates__grep-printer-0.3.1\", is_dev_dep = False),\n struct(repo=\"crates__grep-regex-0.1.14\", is_dev_dep = False),\n struct(repo=\"crates__grep-searcher-0.1.17\", is_dev_dep = False),\n struct(repo=\"crates__heapless-0.9.3\", is_dev_dep = False),\n struct(repo=\"crates__hex-0.4.3\", is_dev_dep = False),\n struct(repo=\"crates__hifijson-0.2.3\", is_dev_dep = False),\n struct(repo=\"crates__hostname-0.4.2\", is_dev_dep = False),\n struct(repo=\"crates__html-to-markdown-rs-3.11.3\", is_dev_dep = False),\n struct(repo=\"crates__icy_sixel-0.5.1\", is_dev_dep = False),\n struct(repo=\"crates__ignore-0.4.33\", is_dev_dep = False),\n struct(repo=\"crates__image-0.25.10\", is_dev_dep = False),\n struct(repo=\"crates__indicatif-0.18.6\", is_dev_dep = False),\n struct(repo=\"crates__inferno-0.12.8\", is_dev_dep = False),\n struct(repo=\"crates__inherent-1.0.14\", is_dev_dep = False),\n struct(repo=\"crates__itertools-0.14.0\", is_dev_dep = False),\n struct(repo=\"crates__jaq-core-2.2.1\", is_dev_dep = False),\n struct(repo=\"crates__jaq-json-1.1.3\", is_dev_dep = False),\n struct(repo=\"crates__jaq-std-2.1.2\", is_dev_dep = False),\n struct(repo=\"crates__jiff-0.2.35\", is_dev_dep = False),\n struct(repo=\"crates__libc-0.2.189\", is_dev_dep = False),\n struct(repo=\"crates__lscolors-0.21.0\", is_dev_dep = False),\n struct(repo=\"crates__memchr-2.8.3\", is_dev_dep = False),\n struct(repo=\"crates__memmap2-0.9.11\", is_dev_dep = False),\n struct(repo=\"crates__napi-3.12.2\", is_dev_dep = False),\n struct(repo=\"crates__napi-build-2.4.1\", is_dev_dep = False),\n struct(repo=\"crates__napi-derive-3.6.3\", is_dev_dep = False),\n struct(repo=\"crates__nix-0.31.3\", is_dev_dep = False),\n struct(repo=\"crates__nom-8.0.0\", is_dev_dep = False),\n struct(repo=\"crates__normalize-path-0.2.1\", is_dev_dep = False),\n struct(repo=\"crates__notify-8.2.0\", is_dev_dep = False),\n struct(repo=\"crates__num-bigint-0.4.8\", is_dev_dep = False),\n struct(repo=\"crates__num-traits-0.2.19\", is_dev_dep = False),\n struct(repo=\"crates__objc2-0.6.4\", is_dev_dep = False),\n struct(repo=\"crates__objc2-app-kit-0.3.2\", is_dev_dep = False),\n struct(repo=\"crates__objc2-application-services-0.3.2\", is_dev_dep = False),\n struct(repo=\"crates__objc2-core-foundation-0.3.2\", is_dev_dep = False),\n struct(repo=\"crates__objc2-core-graphics-0.3.2\", is_dev_dep = False),\n struct(repo=\"crates__objc2-foundation-0.3.2\", is_dev_dep = False),\n struct(repo=\"crates__onig-6.5.3\", is_dev_dep = False),\n struct(repo=\"crates__opus-0.3.1\", is_dev_dep = False),\n struct(repo=\"crates__os_display-0.1.4\", is_dev_dep = False),\n struct(repo=\"crates__os_pipe-1.2.3\", is_dev_dep = False),\n struct(repo=\"crates__parking_lot-0.12.5\", is_dev_dep = False),\n struct(repo=\"crates__parse_datetime-0.14.0\", is_dev_dep = False),\n struct(repo=\"crates__pdf-inspector-1.17.0\", is_dev_dep = False),\n struct(repo=\"crates__phf-0.13.1\", is_dev_dep = False),\n struct(repo=\"crates__platform-info-2.1.0\", is_dev_dep = False),\n struct(repo=\"crates__png-0.18.1\", is_dev_dep = False),\n struct(repo=\"crates__portable-pty-0.9.0\", is_dev_dep = False),\n struct(repo=\"crates__procfs-0.18.0\", is_dev_dep = False),\n struct(repo=\"crates__rand-0.10.2\", is_dev_dep = False),\n struct(repo=\"crates__rayon-1.12.0\", is_dev_dep = False),\n struct(repo=\"crates__regex-1.13.1\", is_dev_dep = False),\n struct(repo=\"crates__reis-0.5.0\", is_dev_dep = False),\n struct(repo=\"crates__rlimit-0.11.0\", is_dev_dep = False),\n struct(repo=\"crates__rpds-1.2.1\", is_dev_dep = False),\n struct(repo=\"crates__rustc-hash-2.1.3\", is_dev_dep = False),\n struct(repo=\"crates__rustix-1.1.4\", is_dev_dep = False),\n struct(repo=\"crates__self_cell-1.3.0\", is_dev_dep = False),\n struct(repo=\"crates__serde-1.0.229\", is_dev_dep = False),\n struct(repo=\"crates__serde_json-1.0.151\", is_dev_dep = False),\n struct(repo=\"crates__similar-3.2.0\", is_dev_dep = False),\n struct(repo=\"crates__smallvec-1.15.2\", is_dev_dep = False),\n struct(repo=\"crates__strum-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__strum_macros-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__syntect-5.3.0\", is_dev_dep = False),\n struct(repo=\"crates__tempfile-3.27.0\", is_dev_dep = False),\n struct(repo=\"crates__terminfo-0.9.0\", is_dev_dep = False),\n struct(repo=\"crates__thiserror-2.0.20\", is_dev_dep = False),\n struct(repo=\"crates__tokio-1.53.1\", is_dev_dep = False),\n struct(repo=\"crates__tokio-util-0.7.19\", is_dev_dep = False),\n struct(repo=\"crates__toml-1.1.4-spec-1.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tracing-0.1.44\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-0.25.10\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-astro-next-0.1.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-bash-0.25.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-c-0.24.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-c-sharp-0.23.5\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-clojure-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-cmake-0.7.4\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-cpp-0.23.4\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-css-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-dart-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-diff-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-dockerfile-updated-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-elisp-1.7.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-elixir-0.3.5\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-erlang-0.16.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-fortran-0.6.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-go-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-graphql-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-haskell-0.23.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-hcl-1.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-html-0.23.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-ini-1.4.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-java-0.23.5\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-javascript-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-json-0.24.8\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-julia-0.23.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-just-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-kotlin-sg-0.4.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-lua-0.5.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-make-1.1.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-md-0.5.3\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-nix-0.3.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-objc-3.0.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-ocaml-0.24.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-odin-1.3.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-php-0.24.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-powershell-0.26.4\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-proto-0.4.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-python-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-r-1.3.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-regex-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-ruby-0.23.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-rust-0.24.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-scala-0.26.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-sequel-0.3.11\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-solidity-1.2.13\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-starlark-1.3.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-svelte-next-0.1.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-swift-0.7.3\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-tlaplus-1.5.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-toml-ng-0.7.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-typescript-0.23.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-verilog-1.0.3\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-vue-next-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-xml-0.7.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-yaml-0.7.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-zig-1.1.2\", is_dev_dep = False),\n struct(repo=\"crates__uiautomation-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__uucore-0.8.0\", is_dev_dep = False),\n struct(repo=\"crates__uuid-1.24.1\", is_dev_dep = False),\n struct(repo=\"crates__uutils_term_grid-0.8.0\", is_dev_dep = False),\n struct(repo=\"crates__uzers-0.12.2\", is_dev_dep = False),\n struct(repo=\"crates__webrtc-0.17.2\", is_dev_dep = False),\n struct(repo=\"crates__whoami-2.1.3\", is_dev_dep = False),\n struct(repo=\"crates__windows-sys-0.59.0\", is_dev_dep = False),\n struct(repo=\"crates__windows-sys-0.61.2\", is_dev_dep = False),\n struct(repo=\"crates__winreg-0.56.0\", is_dev_dep = False),\n struct(repo=\"crates__x11rb-0.13.2\", is_dev_dep = False),\n struct(repo=\"crates__xcap-0.9.6\", is_dev_dep = False),\n struct(repo=\"crates__xkeysym-0.2.1\", is_dev_dep = False),\n struct(repo=\"crates__xutf-1.4.0\", is_dev_dep = False),\n struct(repo=\"crates__xxhash-rust-0.8.18\", is_dev_dep = False),\n struct(repo=\"crates__yansi-1.0.1\", is_dev_dep = False),\n struct(repo=\"crates__zstd-0.13.3\", is_dev_dep = False),\n struct(repo=\"crates__zune-jpeg-0.5.15\", is_dev_dep = False),\n struct(repo = \"crates__fancy-regex-0.16.2\", is_dev_dep = True),\n struct(repo = \"crates__pretty_assertions-1.4.1\", is_dev_dep = True),\n struct(repo = \"crates__tiktoken-rs-0.11.0\", is_dev_dep = True),\n ]\n", + "crates.bzl": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\"\"\"\n# `crates_repository` API\n\n- [aliases](#aliases)\n- [crate_edition](#crate_edition)\n- [crate_deps](#crate_deps)\n- [all_crate_deps](#all_crate_deps)\n- [crate_repositories](#crate_repositories)\n\n\"\"\"\n\nload(\"@bazel_tools//tools/build_defs/repo:git.bzl\", \"git_repository\")\nload(\"@bazel_tools//tools/build_defs/repo:http.bzl\", \"http_archive\")\nload(\"@bazel_tools//tools/build_defs/repo:utils.bzl\", \"maybe\")\nload(\"@bazel_skylib//lib:selects.bzl\", \"selects\")\nload(\"@rules_rust//crate_universe:defs.bzl\", \"crates_vendor_remote_repository\", \"local_crate_mirror\")\n\n###############################################################################\n# MACROS API\n###############################################################################\n\n# An identifier that represent common dependencies (unconditional).\n_COMMON_CONDITION = \"\"\n\ndef _flatten_dependency_maps(all_dependency_maps):\n \"\"\"Flatten a list of dependency maps into one dictionary.\n\n Dependency maps have the following structure:\n\n ```python\n DEPENDENCIES_MAP = {\n # The first key in the map is a Bazel package\n # name of the workspace this file is defined in.\n \"workspace_member_package\": {\n\n # Not all dependencies are supported for all platforms.\n # the condition key is the condition required to be true\n # on the host platform.\n \"condition\": {\n\n # An alias to a crate target. # The label of the crate target the\n # Aliases are only crate names. # package name refers to.\n \"package_name\": \"@full//:label\",\n }\n }\n }\n ```\n\n Args:\n all_dependency_maps (list): A list of dicts as described above\n\n Returns:\n dict: A dictionary as described above\n \"\"\"\n dependencies = {}\n\n for workspace_deps_map in all_dependency_maps:\n for pkg_name, conditional_deps_map in workspace_deps_map.items():\n if pkg_name not in dependencies:\n non_frozen_map = dict()\n for key, values in conditional_deps_map.items():\n non_frozen_map.update({key: dict(values.items())})\n dependencies.setdefault(pkg_name, non_frozen_map)\n continue\n\n for condition, deps_map in conditional_deps_map.items():\n # If the condition has not been recorded, do so and continue\n if condition not in dependencies[pkg_name]:\n dependencies[pkg_name].setdefault(condition, dict(deps_map.items()))\n continue\n\n # Alert on any miss-matched dependencies\n inconsistent_entries = []\n for crate_name, crate_label in deps_map.items():\n existing = dependencies[pkg_name][condition].get(crate_name)\n if existing and existing != crate_label:\n inconsistent_entries.append((crate_name, existing, crate_label))\n dependencies[pkg_name][condition].update({crate_name: crate_label})\n\n return dependencies\n\ndef crate_deps(deps, package_name = None):\n \"\"\"Finds the fully qualified label of the requested crates for the package where this macro is called.\n\n Args:\n deps (list): The desired list of crate targets.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()`.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if not deps:\n return []\n\n if package_name == None:\n package_name = native.package_name()\n\n # Join both sets of dependencies\n dependencies = _flatten_dependency_maps([\n _NORMAL_DEPENDENCIES,\n _NORMAL_DEV_DEPENDENCIES,\n _PROC_MACRO_DEPENDENCIES,\n _PROC_MACRO_DEV_DEPENDENCIES,\n _BUILD_DEPENDENCIES,\n _BUILD_PROC_MACRO_DEPENDENCIES,\n ]).pop(package_name, {})\n\n # Combine all conditional packages so we can easily index over a flat list\n # TODO: Perhaps this should actually return select statements and maintain\n # the conditionals of the dependencies\n flat_deps = {}\n for deps_set in dependencies.values():\n for crate_name, crate_label in deps_set.items():\n flat_deps.update({crate_name: crate_label})\n\n missing_crates = []\n crate_targets = []\n for crate_target in deps:\n if crate_target not in flat_deps:\n missing_crates.append(crate_target)\n else:\n crate_targets.append(flat_deps[crate_target])\n\n if missing_crates:\n fail(\"Could not find crates `{}` among dependencies of `{}`. Available dependencies were `{}`\".format(\n missing_crates,\n package_name,\n dependencies,\n ))\n\n return crate_targets\n\ndef crate_edition(package_name = None):\n \"\"\"Finds the Rust edition for the package where this macro is called.\n\n Args:\n package_name (str, optional): The package name whose edition should be\n looked up. Defaults to `native.package_name()` when unset.\n\n Returns:\n str: The Rust edition declared by the package's Cargo.toml file.\n \"\"\"\n if package_name == None:\n package_name = native.package_name()\n\n if package_name not in _CRATE_EDITIONS:\n fail(\"Tried to get crate_edition for package \" + package_name + \" but that package had no Cargo.toml file\")\n\n return _CRATE_EDITIONS[package_name]\n\ndef all_crate_deps(\n normal = False, \n normal_dev = False, \n proc_macro = False, \n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Finds the fully qualified label of all requested direct crate dependencies \\\n for the package where this macro is called.\n\n If no parameters are set, all normal dependencies are returned. Setting any one flag will\n otherwise impact the contents of the returned list.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list.\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n list: A list of labels to generated rust targets (str)\n \"\"\"\n\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_dependency_maps = []\n if normal:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n if normal_dev:\n all_dependency_maps.append(_NORMAL_DEV_DEPENDENCIES)\n if proc_macro:\n all_dependency_maps.append(_PROC_MACRO_DEPENDENCIES)\n if proc_macro_dev:\n all_dependency_maps.append(_PROC_MACRO_DEV_DEPENDENCIES)\n if build:\n all_dependency_maps.append(_BUILD_DEPENDENCIES)\n if build_proc_macro:\n all_dependency_maps.append(_BUILD_PROC_MACRO_DEPENDENCIES)\n\n # Default to always using normal dependencies\n if not all_dependency_maps:\n all_dependency_maps.append(_NORMAL_DEPENDENCIES)\n\n dependencies = _flatten_dependency_maps(all_dependency_maps).pop(package_name, None)\n\n if not dependencies:\n if dependencies == None:\n fail(\"Tried to get all_crate_deps for package \" + package_name + \" but that package had no Cargo.toml file\")\n else:\n return []\n\n crate_deps = list(dependencies.pop(_COMMON_CONDITION, {}).values())\n for condition, deps in dependencies.items():\n crate_deps += selects.with_or({\n tuple(_CONDITIONS[condition]): deps.values(),\n \"//conditions:default\": [],\n })\n\n return crate_deps\n\ndef aliases(\n normal = False,\n normal_dev = False,\n proc_macro = False,\n proc_macro_dev = False,\n build = False,\n build_proc_macro = False,\n package_name = None):\n \"\"\"Produces a map of Crate alias names to their original label\n\n If no dependency kinds are specified, `normal` and `proc_macro` are used by default.\n Setting any one flag will otherwise determine the contents of the returned dict.\n\n Args:\n normal (bool, optional): If True, normal dependencies are included in the\n output list.\n normal_dev (bool, optional): If True, normal dev dependencies will be\n included in the output list..\n proc_macro (bool, optional): If True, proc_macro dependencies are included\n in the output list.\n proc_macro_dev (bool, optional): If True, dev proc_macro dependencies are\n included in the output list.\n build (bool, optional): If True, build dependencies are included\n in the output list.\n build_proc_macro (bool, optional): If True, build proc_macro dependencies are\n included in the output list.\n package_name (str, optional): The package name of the set of dependencies to look up.\n Defaults to `native.package_name()` when unset.\n\n Returns:\n dict: The aliases of all associated packages\n \"\"\"\n if package_name == None:\n package_name = native.package_name()\n\n # Determine the relevant maps to use\n all_aliases_maps = []\n if normal:\n all_aliases_maps.append(_NORMAL_ALIASES)\n if normal_dev:\n all_aliases_maps.append(_NORMAL_DEV_ALIASES)\n if proc_macro:\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n if proc_macro_dev:\n all_aliases_maps.append(_PROC_MACRO_DEV_ALIASES)\n if build:\n all_aliases_maps.append(_BUILD_ALIASES)\n if build_proc_macro:\n all_aliases_maps.append(_BUILD_PROC_MACRO_ALIASES)\n\n # Default to always using normal aliases\n if not all_aliases_maps:\n all_aliases_maps.append(_NORMAL_ALIASES)\n all_aliases_maps.append(_PROC_MACRO_ALIASES)\n\n aliases = _flatten_dependency_maps(all_aliases_maps).pop(package_name, None)\n\n if not aliases:\n return dict()\n\n common_items = aliases.pop(_COMMON_CONDITION, {}).items()\n\n # If there are only common items in the dictionary, immediately return them\n if not len(aliases.keys()) == 1:\n return dict(common_items)\n\n # Build a single select statement where each conditional has accounted for the\n # common set of aliases.\n crate_aliases = {\"//conditions:default\": dict(common_items)}\n for condition, deps in aliases.items():\n condition_triples = _CONDITIONS[condition]\n for triple in condition_triples:\n if triple in crate_aliases:\n crate_aliases[triple].update(deps)\n else:\n crate_aliases.update({triple: dict(deps.items() + common_items)})\n\n return select(crate_aliases)\n\n###############################################################################\n# WORKSPACE MEMBER DEPS, ALIASES, AND EDITIONS\n###############################################################################\n\n_CRATE_EDITIONS = {\n \"crates/vendor/brush-core\": \"2024\",\n \"crates/pi-ast\": \"2024\",\n \"crates/pi-builtins\": \"2024\",\n \"crates/pi-iso\": \"2024\",\n \"crates/pi-natives\": \"2024\",\n \"crates/pi-shell\": \"2024\",\n \"crates/pi-vcs\": \"2024\",\n \"crates/pi-voice\": \"2024\",\n \"crates/pi-walker\": \"2024\",\n}\n\n_NORMAL_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n \"bon\": Label(\"//bon-3.10.0\"),\n \"brush-parser\": Label(\"//brush-parser-0.4.0\"),\n \"cached\": Label(\"//cached-0.59.0\"),\n \"cfg-if\": Label(\"//cfg-if-1.0.4\"),\n \"chrono\": Label(\"//chrono-0.4.45\"),\n \"clap\": Label(\"//clap-4.6.6\"),\n \"color-print\": Label(\"//color-print-0.3.7\"),\n \"fancy-regex\": Label(\"//fancy-regex-0.17.0\"),\n \"futures\": Label(\"//futures-0.3.34\"),\n \"itertools\": Label(\"//itertools-0.14.0\"),\n \"normalize-path\": Label(\"//normalize-path-0.2.1\"),\n \"rand\": Label(\"//rand-0.10.2\"),\n \"rpds\": Label(\"//rpds-1.2.1\"),\n \"strum\": Label(\"//strum-0.28.0\"),\n \"thiserror\": Label(\"//thiserror-2.0.20\"),\n \"tokio-util\": Label(\"//tokio-util-0.7.19\"),\n \"tracing\": Label(\"//tracing-0.1.44\"),\n },\n \"cfg(any(unix, windows))\": {\n \"hostname\": Label(\"//hostname-0.4.2\"),\n \"tokio\": Label(\"//tokio-1.53.1\"),\n },\n \"cfg(target_family = \\\"wasm\\\")\": {\n \"tokio\": Label(\"//tokio-1.53.1\"),\n },\n \"cfg(unix)\": {\n \"command-fds\": Label(\"//command-fds-0.3.3\"),\n \"libc\": Label(\"//libc-0.2.189\"),\n \"nix\": Label(\"//nix-0.31.3\"),\n \"terminfo\": Label(\"//terminfo-0.9.0\"),\n \"uzers\": Label(\"//uzers-0.12.2\"),\n },\n \"cfg(windows)\": {\n \"check_elevation\": Label(\"//check_elevation-0.2.7\"),\n \"whoami\": Label(\"//whoami-2.1.3\"),\n \"windows-sys\": Label(\"//windows-sys-0.59.0\"),\n },\n \"wasm32-unknown-unknown\": {\n \"getrandom\": Label(\"//getrandom-0.4.3\"),\n \"uuid\": Label(\"//uuid-1.26.0\"),\n },\n },\n \"crates/pi-ast\": {\n _COMMON_CONDITION: {\n \"anyhow\": Label(\"//anyhow-1.0.104\"),\n \"ast-grep-core\": Label(\"//ast-grep-core-0.39.9\"),\n \"globset\": Label(\"//globset-0.4.20\"),\n \"ignore\": Label(\"//ignore-0.4.33\"),\n \"phf\": Label(\"//phf-0.13.1\"),\n \"serde\": Label(\"//serde-1.0.229\"),\n \"tree-sitter\": Label(\"//tree-sitter-0.25.10\"),\n \"tree_sitter_astro\": Label(\"//tree-sitter-astro-next-0.1.1\"),\n \"tree-sitter-bash\": Label(\"//tree-sitter-bash-0.25.1\"),\n \"tree-sitter-c\": Label(\"//tree-sitter-c-0.24.2\"),\n \"tree-sitter-c-sharp\": Label(\"//tree-sitter-c-sharp-0.23.5\"),\n \"tree-sitter-clojure\": Label(\"//tree-sitter-clojure-0.1.0\"),\n \"tree-sitter-cmake\": Label(\"//tree-sitter-cmake-0.7.4\"),\n \"tree-sitter-cpp\": Label(\"//tree-sitter-cpp-0.23.4\"),\n \"tree-sitter-css\": Label(\"//tree-sitter-css-0.25.0\"),\n \"tree-sitter-dart\": Label(\"//tree-sitter-dart-0.2.0\"),\n \"tree-sitter-diff\": Label(\"//tree-sitter-diff-0.1.0\"),\n \"tree_sitter_dockerfile\": Label(\"//tree-sitter-dockerfile-updated-0.2.0\"),\n \"tree-sitter-elisp\": Label(\"//tree-sitter-elisp-1.7.2\"),\n \"tree-sitter-elixir\": Label(\"//tree-sitter-elixir-0.3.5\"),\n \"tree-sitter-erlang\": Label(\"//tree-sitter-erlang-0.16.0\"),\n \"tree-sitter-fortran\": Label(\"//tree-sitter-fortran-0.6.0\"),\n \"tree-sitter-go\": Label(\"//tree-sitter-go-0.25.0\"),\n \"tree-sitter-graphql\": Label(\"//tree-sitter-graphql-0.1.0\"),\n \"tree-sitter-haskell\": Label(\"//tree-sitter-haskell-0.23.1\"),\n \"tree-sitter-hcl\": Label(\"//tree-sitter-hcl-1.1.0\"),\n \"tree-sitter-html\": Label(\"//tree-sitter-html-0.23.2\"),\n \"tree-sitter-ini\": Label(\"//tree-sitter-ini-1.4.0\"),\n \"tree-sitter-java\": Label(\"//tree-sitter-java-0.23.5\"),\n \"tree-sitter-javascript\": Label(\"//tree-sitter-javascript-0.25.0\"),\n \"tree-sitter-json\": Label(\"//tree-sitter-json-0.24.8\"),\n \"tree-sitter-julia\": Label(\"//tree-sitter-julia-0.23.1\"),\n \"tree-sitter-just\": Label(\"//tree-sitter-just-0.2.0\"),\n \"tree_sitter_kotlin\": Label(\"//tree-sitter-kotlin-sg-0.4.1\"),\n \"tree-sitter-lua\": Label(\"//tree-sitter-lua-0.5.0\"),\n \"tree-sitter-make\": Label(\"//tree-sitter-make-1.1.1\"),\n \"tree-sitter-md\": Label(\"//tree-sitter-md-0.5.3\"),\n \"tree-sitter-nix\": Label(\"//tree-sitter-nix-0.3.0\"),\n \"tree-sitter-objc\": Label(\"//tree-sitter-objc-3.0.2\"),\n \"tree-sitter-ocaml\": Label(\"//tree-sitter-ocaml-0.24.2\"),\n \"tree-sitter-odin\": Label(\"//tree-sitter-odin-1.3.0\"),\n \"tree-sitter-php\": Label(\"//tree-sitter-php-0.24.2\"),\n \"tree-sitter-powershell\": Label(\"//tree-sitter-powershell-0.26.4\"),\n \"tree-sitter-proto\": Label(\"//tree-sitter-proto-0.4.0\"),\n \"tree-sitter-python\": Label(\"//tree-sitter-python-0.25.0\"),\n \"tree-sitter-r\": Label(\"//tree-sitter-r-1.3.0\"),\n \"tree-sitter-regex\": Label(\"//tree-sitter-regex-0.25.0\"),\n \"tree-sitter-ruby\": Label(\"//tree-sitter-ruby-0.23.1\"),\n \"tree-sitter-rust\": Label(\"//tree-sitter-rust-0.24.2\"),\n \"tree-sitter-scala\": Label(\"//tree-sitter-scala-0.26.2\"),\n \"tree_sitter_sql\": Label(\"//tree-sitter-sequel-0.3.11\"),\n \"tree-sitter-solidity\": Label(\"//tree-sitter-solidity-1.2.13\"),\n \"tree-sitter-starlark\": Label(\"//tree-sitter-starlark-1.3.0\"),\n \"tree_sitter_svelte\": Label(\"//tree-sitter-svelte-next-0.1.1\"),\n \"tree-sitter-swift\": Label(\"//tree-sitter-swift-0.7.3\"),\n \"tree-sitter-tlaplus\": Label(\"//tree-sitter-tlaplus-1.5.0\"),\n \"tree-sitter-toml-ng\": Label(\"//tree-sitter-toml-ng-0.7.0\"),\n \"tree-sitter-typescript\": Label(\"//tree-sitter-typescript-0.23.2\"),\n \"tree-sitter-verilog\": Label(\"//tree-sitter-verilog-1.0.3\"),\n \"tree_sitter_vue\": Label(\"//tree-sitter-vue-next-0.1.0\"),\n \"tree-sitter-xml\": Label(\"//tree-sitter-xml-0.7.0\"),\n \"tree-sitter-yaml\": Label(\"//tree-sitter-yaml-0.7.2\"),\n \"tree-sitter-zig\": Label(\"//tree-sitter-zig-1.1.2\"),\n \"xxhash-rust\": Label(\"//xxhash-rust-0.8.18\"),\n },\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n \"ansi-width\": Label(\"//ansi-width-0.1.0\"),\n \"argmax\": Label(\"//argmax-0.3.1\"),\n \"bigdecimal\": Label(\"//bigdecimal-0.4.10\"),\n \"binary-heap-plus\": Label(\"//binary-heap-plus-0.5.0\"),\n \"brush-parser\": Label(\"//brush-parser-0.4.0\"),\n \"bstr\": Label(\"//bstr-1.13.1\"),\n \"bytecount\": Label(\"//bytecount-0.6.9\"),\n \"cfg-if\": Label(\"//cfg-if-1.0.4\"),\n \"chrono\": Label(\"//chrono-0.4.45\"),\n \"clap\": Label(\"//clap-4.6.6\"),\n \"codesnake\": Label(\"//codesnake-0.2.1\"),\n \"compare\": Label(\"//compare-0.1.0\"),\n \"faccess\": Label(\"//faccess-0.2.4\"),\n \"fancy-regex\": Label(\"//fancy-regex-0.17.0\"),\n \"filetime\": Label(\"//filetime-0.2.29\"),\n \"flume\": Label(\"//flume-0.11.1\"),\n \"foldhash\": Label(\"//foldhash-0.2.0\"),\n \"fs_extra\": Label(\"//fs_extra-1.3.0\"),\n \"futures\": Label(\"//futures-0.3.34\"),\n \"glob\": Label(\"//glob-0.3.4\"),\n \"globset\": Label(\"//globset-0.4.20\"),\n \"grep-cli\": Label(\"//grep-cli-0.1.12\"),\n \"grep-matcher\": Label(\"//grep-matcher-0.1.9\"),\n \"grep-pcre2\": Label(\"//grep-pcre2-0.1.10\"),\n \"grep-printer\": Label(\"//grep-printer-0.3.1\"),\n \"grep-regex\": Label(\"//grep-regex-0.1.14\"),\n \"grep-searcher\": Label(\"//grep-searcher-0.1.17\"),\n \"hex\": Label(\"//hex-0.4.3\"),\n \"hifijson\": Label(\"//hifijson-0.2.3\"),\n \"hostname\": Label(\"//hostname-0.4.2\"),\n \"ignore\": Label(\"//ignore-0.4.33\"),\n \"indicatif\": Label(\"//indicatif-0.18.6\"),\n \"itertools\": Label(\"//itertools-0.14.0\"),\n \"jaq-core\": Label(\"//jaq-core-2.2.1\"),\n \"jaq-json\": Label(\"//jaq-json-1.1.3\"),\n \"jaq-std\": Label(\"//jaq-std-2.1.2\"),\n \"jiff\": Label(\"//jiff-0.2.35\"),\n \"libc\": Label(\"//libc-0.2.189\"),\n \"lscolors\": Label(\"//lscolors-0.21.0\"),\n \"memchr\": Label(\"//memchr-2.8.3\"),\n \"memmap2\": Label(\"//memmap2-0.9.11\"),\n \"nom\": Label(\"//nom-8.0.0\"),\n \"num-bigint\": Label(\"//num-bigint-0.4.8\"),\n \"num-traits\": Label(\"//num-traits-0.2.19\"),\n \"onig\": Label(\"//onig-6.5.3\"),\n \"os_display\": Label(\"//os_display-0.1.4\"),\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"parse_datetime\": Label(\"//parse_datetime-0.14.0\"),\n \"platform-info\": Label(\"//platform-info-2.1.0\"),\n \"rand\": Label(\"//rand-0.10.2\"),\n \"rayon\": Label(\"//rayon-1.12.0\"),\n \"regex\": Label(\"//regex-1.13.1\"),\n \"rustc-hash\": Label(\"//rustc-hash-2.1.3\"),\n \"self_cell\": Label(\"//self_cell-1.3.0\"),\n \"serde_json\": Label(\"//serde_json-1.0.151\"),\n \"similar\": Label(\"//similar-3.2.0\"),\n \"smallvec\": Label(\"//smallvec-1.15.2\"),\n \"strum\": Label(\"//strum-0.28.0\"),\n \"tempfile\": Label(\"//tempfile-3.27.0\"),\n \"thiserror\": Label(\"//thiserror-2.0.20\"),\n \"tokio-util\": Label(\"//tokio-util-0.7.19\"),\n \"tracing\": Label(\"//tracing-0.1.44\"),\n \"uucore\": Label(\"//uucore-0.8.0\"),\n \"uutils_term_grid\": Label(\"//uutils_term_grid-0.8.0\"),\n \"xutf\": Label(\"//xutf-1.4.0\"),\n \"yansi\": Label(\"//yansi-1.0.1\"),\n },\n \"cfg(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"))\": {\n \"procfs\": Label(\"//procfs-0.18.0\"),\n },\n \"cfg(any(unix, windows))\": {\n \"tokio\": Label(\"//tokio-1.53.1\"),\n },\n \"cfg(target_arch = \\\"aarch64\\\")\": {\n \"sha2\": Label(\"//sha2-0.10.9\"),\n \"sha3\": Label(\"//sha3-0.10.9\"),\n },\n \"cfg(target_family = \\\"wasm\\\")\": {\n \"tokio\": Label(\"//tokio-1.53.1\"),\n },\n \"cfg(unix)\": {\n \"dns-lookup\": Label(\"//dns-lookup-3.0.1\"),\n \"nix\": Label(\"//nix-0.31.3\"),\n \"notify\": Label(\"//notify-8.2.0\"),\n \"rlimit\": Label(\"//rlimit-0.11.0\"),\n \"rustix\": Label(\"//rustix-1.1.4\"),\n },\n \"cfg(windows)\": {\n \"notify\": Label(\"//notify-8.2.0\"),\n \"rustix\": Label(\"//rustix-1.1.4\"),\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n },\n },\n \"crates/pi-iso\": {\n _COMMON_CONDITION: {\n \"similar\": Label(\"//similar-3.2.0\"),\n \"tokio\": Label(\"//tokio-1.53.1\"),\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n },\n \"cfg(unix)\": {\n \"libc\": Label(\"//libc-0.2.189\"),\n },\n \"cfg(windows)\": {\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n },\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n \"anyhow\": Label(\"//anyhow-1.0.104\"),\n \"arboard\": Label(\"//arboard-3.6.1\"),\n \"ast-grep-core\": Label(\"//ast-grep-core-0.39.9\"),\n \"base64\": Label(\"//base64-0.22.1\"),\n \"clap\": Label(\"//clap-4.6.6\"),\n \"flume\": Label(\"//flume-0.11.1\"),\n \"fontdue\": Label(\"//fontdue-0.9.4\"),\n \"futures\": Label(\"//futures-0.3.34\"),\n \"globset\": Label(\"//globset-0.4.20\"),\n \"grep-matcher\": Label(\"//grep-matcher-0.1.9\"),\n \"grep-pcre2\": Label(\"//grep-pcre2-0.1.10\"),\n \"grep-regex\": Label(\"//grep-regex-0.1.14\"),\n \"grep-searcher\": Label(\"//grep-searcher-0.1.17\"),\n \"heapless\": Label(\"//heapless-0.9.3\"),\n \"html-to-markdown-rs\": Label(\"//html-to-markdown-rs-3.11.4\"),\n \"icy_sixel\": Label(\"//icy_sixel-0.5.1\"),\n \"ignore\": Label(\"//ignore-0.4.33\"),\n \"image\": Label(\"//image-0.25.10\"),\n \"inferno\": Label(\"//inferno-0.12.8\"),\n \"napi\": Label(\"//napi-3.12.2\"),\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"pdf-inspector\": Label(\"//pdf-inspector-1.17.0\"),\n \"phf\": Label(\"//phf-0.13.1\"),\n \"png\": Label(\"//png-0.18.1\"),\n \"portable-pty\": Label(\"//portable-pty-0.9.0\"),\n \"rayon\": Label(\"//rayon-1.12.0\"),\n \"regex\": Label(\"//regex-1.13.1\"),\n \"resvg\": Label(\"//resvg-0.48.1\"),\n \"serde\": Label(\"//serde-1.0.229\"),\n \"serde_json\": Label(\"//serde_json-1.0.151\"),\n \"smallvec\": Label(\"//smallvec-1.15.2\"),\n \"syntect\": Label(\"//syntect-5.3.0\"),\n \"tokio\": Label(\"//tokio-1.53.1\"),\n \"tokio-util\": Label(\"//tokio-util-0.7.19\"),\n \"toml\": Label(\"//toml-1.1.4+spec-1.1.0\"),\n \"xutf\": Label(\"//xutf-1.4.0\"),\n \"xxhash-rust\": Label(\"//xxhash-rust-0.8.18\"),\n \"zstd\": Label(\"//zstd-0.13.3\"),\n \"zune-jpeg\": Label(\"//zune-jpeg-0.5.15\"),\n },\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"windows\\\"))\": {\n \"enigo\": Label(\"//enigo-0.6.1\"),\n \"xcap\": Label(\"//xcap-0.9.6\"),\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n \"ashpd\": Label(\"//ashpd-0.11.1\"),\n \"atspi\": Label(\"//atspi-0.30.0\"),\n \"reis\": Label(\"//reis-0.5.0\"),\n \"x11rb\": Label(\"//x11rb-0.13.2\"),\n \"xkeysym\": Label(\"//xkeysym-0.2.1\"),\n },\n \"cfg(target_os = \\\"macos\\\")\": {\n \"core-graphics\": Label(\"//core-graphics-0.25.0\"),\n \"foreign-types\": Label(\"//foreign-types-0.5.0\"),\n \"objc2\": Label(\"//objc2-0.6.4\"),\n \"objc2-app-kit\": Label(\"//objc2-app-kit-0.3.2\"),\n \"objc2-application-services\": Label(\"//objc2-application-services-0.3.2\"),\n \"objc2-core-foundation\": Label(\"//objc2-core-foundation-0.3.2\"),\n \"objc2-core-graphics\": Label(\"//objc2-core-graphics-0.3.2\"),\n \"objc2-foundation\": Label(\"//objc2-foundation-0.3.2\"),\n \"tempfile\": Label(\"//tempfile-3.27.0\"),\n },\n \"cfg(unix)\": {\n \"libc\": Label(\"//libc-0.2.189\"),\n },\n \"cfg(windows)\": {\n \"clipboard-win\": Label(\"//clipboard-win-5.4.1\"),\n \"uiautomation\": Label(\"//uiautomation-0.25.0\"),\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n \"winreg\": Label(\"//winreg-0.56.0\"),\n },\n },\n \"crates/pi-shell\": {\n _COMMON_CONDITION: {\n \"anyhow\": Label(\"//anyhow-1.0.104\"),\n \"brush-parser\": Label(\"//brush-parser-0.3.0\"),\n \"bytes\": Label(\"//bytes-1.12.1\"),\n \"clap\": Label(\"//clap-4.6.6\"),\n \"flume\": Label(\"//flume-0.11.1\"),\n \"jiff\": Label(\"//jiff-0.2.35\"),\n \"os_pipe\": Label(\"//os_pipe-1.2.3\"),\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"regex\": Label(\"//regex-1.13.1\"),\n \"serde\": Label(\"//serde-1.0.229\"),\n \"serde_json\": Label(\"//serde_json-1.0.151\"),\n \"tokio\": Label(\"//tokio-1.53.1\"),\n \"tokio-util\": Label(\"//tokio-util-0.7.19\"),\n \"toml\": Label(\"//toml-1.1.4+spec-1.1.0\"),\n \"xxhash-rust\": Label(\"//xxhash-rust-0.8.18\"),\n },\n \"cfg(unix)\": {\n \"libc\": Label(\"//libc-0.2.189\"),\n },\n \"cfg(windows)\": {\n \"smallvec\": Label(\"//smallvec-1.15.2\"),\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n \"winreg\": Label(\"//winreg-0.56.0\"),\n },\n },\n \"crates/pi-vcs\": {\n _COMMON_CONDITION: {\n \"gix\": Label(\"//gix-0.85.0\"),\n \"jj-lib\": Label(\"//jj-lib-0.44.0\"),\n \"thiserror\": Label(\"//thiserror-2.0.20\"),\n \"tokio\": Label(\"//tokio-1.53.1\"),\n \"tokio-util\": Label(\"//tokio-util-0.7.19\"),\n },\n \"cfg(unix)\": {\n \"libc\": Label(\"//libc-0.2.189\"),\n },\n },\n \"crates/pi-voice\": {\n _COMMON_CONDITION: {\n \"audiopus_sys\": Label(\"//audiopus_sys-0.2.2\"),\n \"bytes\": Label(\"//bytes-1.12.1\"),\n \"flume\": Label(\"//flume-0.11.1\"),\n \"opus\": Label(\"//opus-0.3.1\"),\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"tokio\": Label(\"//tokio-1.53.1\"),\n \"webrtc\": Label(\"//webrtc-0.17.2\"),\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n \"libc\": Label(\"//libc-0.2.189\"),\n },\n \"cfg(target_os = \\\"windows\\\")\": {\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n },\n },\n \"crates/pi-walker\": {\n _COMMON_CONDITION: {\n \"dashmap\": Label(\"//dashmap-6.2.1\"),\n \"globset\": Label(\"//globset-0.4.20\"),\n \"ignore\": Label(\"//ignore-0.4.33\"),\n \"parking_lot\": Label(\"//parking_lot-0.12.5\"),\n \"rayon\": Label(\"//rayon-1.12.0\"),\n },\n \"cfg(unix)\": {\n \"libc\": Label(\"//libc-0.2.189\"),\n },\n \"cfg(windows)\": {\n \"windows-sys\": Label(\"//windows-sys-0.61.2\"),\n },\n },\n}\n\n\n_NORMAL_ALIASES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n },\n \"cfg(any(unix, windows))\": {\n },\n \"cfg(target_family = \\\"wasm\\\")\": {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n \"wasm32-unknown-unknown\": {\n },\n },\n \"crates/pi-ast\": {\n _COMMON_CONDITION: {\n Label(\"//tree-sitter-astro-next-0.1.1\"): \"tree_sitter_astro\",\n Label(\"//tree-sitter-dockerfile-updated-0.2.0\"): \"tree_sitter_dockerfile\",\n Label(\"//tree-sitter-kotlin-sg-0.4.1\"): \"tree_sitter_kotlin\",\n Label(\"//tree-sitter-sequel-0.3.11\"): \"tree_sitter_sql\",\n Label(\"//tree-sitter-svelte-next-0.1.1\"): \"tree_sitter_svelte\",\n Label(\"//tree-sitter-vue-next-0.1.0\"): \"tree_sitter_vue\",\n },\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n },\n \"cfg(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"))\": {\n },\n \"cfg(any(unix, windows))\": {\n },\n \"cfg(target_arch = \\\"aarch64\\\")\": {\n },\n \"cfg(target_family = \\\"wasm\\\")\": {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n },\n \"crates/pi-iso\": {\n _COMMON_CONDITION: {\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n },\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"windows\\\"))\": {\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n },\n \"cfg(target_os = \\\"macos\\\")\": {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n },\n \"crates/pi-shell\": {\n _COMMON_CONDITION: {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n },\n \"crates/pi-vcs\": {\n _COMMON_CONDITION: {\n },\n \"cfg(unix)\": {\n },\n },\n \"crates/pi-voice\": {\n _COMMON_CONDITION: {\n },\n \"cfg(target_os = \\\"linux\\\")\": {\n },\n \"cfg(target_os = \\\"windows\\\")\": {\n },\n },\n \"crates/pi-walker\": {\n _COMMON_CONDITION: {\n },\n \"cfg(unix)\": {\n },\n \"cfg(windows)\": {\n },\n },\n}\n\n\n_NORMAL_DEV_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n \"anyhow\": Label(\"//anyhow-1.0.104\"),\n \"pretty_assertions\": Label(\"//pretty_assertions-1.4.1\"),\n \"tempfile\": Label(\"//tempfile-3.27.0\"),\n },\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n \"anyhow\": Label(\"//anyhow-1.0.104\"),\n \"pretty_assertions\": Label(\"//pretty_assertions-1.4.1\"),\n },\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n \"fancy-regex\": Label(\"//fancy-regex-0.16.2\"),\n \"tiktoken-rs\": Label(\"//tiktoken-rs-0.11.0\"),\n },\n },\n \"crates/pi-shell\": {\n _COMMON_CONDITION: {\n \"tempfile\": Label(\"//tempfile-3.27.0\"),\n },\n },\n \"crates/pi-vcs\": {\n _COMMON_CONDITION: {\n \"tempfile\": Label(\"//tempfile-3.27.0\"),\n },\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_NORMAL_DEV_ALIASES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-shell\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-vcs\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_PROC_MACRO_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n \"async-recursion\": Label(\"//async-recursion-1.1.1\"),\n \"async-trait\": Label(\"//async-trait-0.1.92\"),\n \"inherent\": Label(\"//inherent-1.0.14\"),\n \"strum_macros\": Label(\"//strum_macros-0.28.0\"),\n },\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n \"strum_macros\": Label(\"//strum_macros-0.28.0\"),\n },\n },\n \"crates/pi-iso\": {\n _COMMON_CONDITION: {\n \"async-trait\": Label(\"//async-trait-0.1.92\"),\n },\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n \"napi-derive\": Label(\"//napi-derive-3.6.3\"),\n },\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-vcs\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_PROC_MACRO_ALIASES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-vcs\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_PROC_MACRO_DEV_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-vcs\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_PROC_MACRO_DEV_ALIASES = {\n \"crates/vendor/brush-core\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-shell\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-vcs\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_BUILD_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n \"napi-build\": Label(\"//napi-build-2.4.1\"),\n \"serde\": Label(\"//serde-1.0.229\"),\n \"serde_json\": Label(\"//serde_json-1.0.151\"),\n },\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-vcs\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_BUILD_ALIASES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n _COMMON_CONDITION: {\n },\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-vcs\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_DEPENDENCIES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-vcs\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_BUILD_PROC_MACRO_ALIASES = {\n \"crates/vendor/brush-core\": {\n },\n \"crates/pi-ast\": {\n },\n \"crates/pi-builtins\": {\n },\n \"crates/pi-iso\": {\n },\n \"crates/pi-natives\": {\n },\n \"crates/pi-shell\": {\n },\n \"crates/pi-vcs\": {\n },\n \"crates/pi-voice\": {\n },\n \"crates/pi-walker\": {\n },\n}\n\n\n_CONDITIONS = {\n \"aarch64-apple-darwin\": [\"@@//bazel/triples:aarch64-apple-darwin\"],\n \"aarch64-linux-android\": [],\n \"aarch64-pc-windows-gnullvm\": [],\n \"aarch64-unknown-linux-gnu\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\"],\n \"aarch64-unknown-linux-musl\": [\"@@//bazel/triples:aarch64-unknown-linux-musl\"],\n \"cfg(all(all(target_arch = \\\"aarch64\\\", target_endian = \\\"little\\\"), target_os = \\\"windows\\\"))\": [],\n \"cfg(all(all(target_arch = \\\"aarch64\\\", target_endian = \\\"little\\\"), target_vendor = \\\"apple\\\", any(target_os = \\\"ios\\\", target_os = \\\"macos\\\", target_os = \\\"tvos\\\", target_os = \\\"visionos\\\", target_os = \\\"watchos\\\")))\": [\"@@//bazel/triples:aarch64-apple-darwin\"],\n \"cfg(all(any(all(target_arch = \\\"aarch64\\\", target_endian = \\\"little\\\"), all(target_arch = \\\"arm\\\", target_endian = \\\"little\\\")), any(target_os = \\\"android\\\", target_os = \\\"linux\\\")))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\"],\n \"cfg(all(any(target_arch = \\\"x86_64\\\", target_arch = \\\"arm64ec\\\"), target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(all(any(target_os = \\\"android\\\", target_os = \\\"linux\\\"), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", target_arch = \\\"s390x\\\"), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [],\n \"cfg(all(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"), not(any(all(target_os = \\\"linux\\\", target_env = \\\"\\\"), getrandom_backend = \\\"custom\\\", getrandom_backend = \\\"linux_raw\\\", getrandom_backend = \\\"rdrand\\\", getrandom_backend = \\\"rndr\\\"))))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(not(curve25519_dalek_backend = \\\"fiat\\\"), not(curve25519_dalek_backend = \\\"serial\\\"), target_arch = \\\"x86_64\\\"))\": [\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(not(rustix_use_libc), not(miri), target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\"))))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(not(rustix_use_libc), not(miri), target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", target_arch = \\\"s390x\\\"), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\"))))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(not(windows), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", any(target_arch = \\\"s390x\\\", target_arch = \\\"powerpc\\\")), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc\\\"), all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"cfg(all(not(windows), any(rustix_use_libc, miri, not(all(target_os = \\\"linux\\\", any(target_endian = \\\"little\\\", target_arch = \\\"s390x\\\"), any(target_arch = \\\"arm\\\", all(target_arch = \\\"aarch64\\\", target_pointer_width = \\\"64\\\"), target_arch = \\\"riscv64\\\", all(rustix_use_experimental_asm, target_arch = \\\"powerpc64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"s390x\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips32r6\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64\\\"), all(rustix_use_experimental_asm, target_arch = \\\"mips64r6\\\"), target_arch = \\\"x86\\\", all(target_arch = \\\"x86_64\\\", target_pointer_width = \\\"64\\\")))))))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_os = \\\"android\\\"))\": [],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_os = \\\"linux\\\"))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\"],\n \"cfg(all(target_arch = \\\"aarch64\\\", target_vendor = \\\"apple\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\"],\n \"cfg(all(target_arch = \\\"loongarch64\\\", target_os = \\\"linux\\\"))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"unknown\\\"))\": [],\n \"cfg(all(target_arch = \\\"wasm32\\\", target_os = \\\"wasi\\\", target_env = \\\"p2\\\"))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"gnu\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [],\n \"cfg(all(target_arch = \\\"x86_64\\\", target_env = \\\"gnu\\\", not(target_abi = \\\"llvm\\\"), not(windows_raw_dylib)))\": [\"@@//bazel/triples:x86_64-unknown-linux-gnu\"],\n \"cfg(all(target_arch = \\\"x86_64\\\", target_env = \\\"msvc\\\", not(windows_raw_dylib)))\": [\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(all(target_family = \\\"wasm\\\", target_os = \\\"unknown\\\"))\": [],\n \"cfg(all(target_os = \\\"linux\\\", not(target_env = \\\"ohos\\\")))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(target_os = \\\"uefi\\\", getrandom_backend = \\\"efi_rng\\\"))\": [],\n \"cfg(all(unix, not(any(target_os = \\\"macos\\\", target_os = \\\"android\\\", target_os = \\\"emscripten\\\"))))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(all(unix, not(target_os = \\\"macos\\\")))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any())\": [],\n \"cfg(any(target_arch = \\\"aarch64\\\", target_arch = \\\"x86\\\", target_arch = \\\"x86_64\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_arch = \\\"aarch64\\\", target_arch = \\\"x86_64\\\", target_arch = \\\"x86\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_arch = \\\"arm\\\", target_pointer_width = \\\"32\\\", target_pointer_width = \\\"64\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_arch = \\\"x86\\\", target_arch = \\\"x86_64\\\"))\": [\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_arch = \\\"x86_64\\\", target_arch = \\\"x86\\\"))\": [\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_os = \\\"android\\\", target_os = \\\"linux\\\"))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_os = \\\"android\\\", target_os = \\\"linux\\\", target_os = \\\"macos\\\", target_os = \\\"hurd\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_os = \\\"dragonfly\\\", target_os = \\\"freebsd\\\", target_os = \\\"hurd\\\", target_os = \\\"illumos\\\", target_os = \\\"cygwin\\\", all(target_os = \\\"horizon\\\", target_arch = \\\"arm\\\")))\": [],\n \"cfg(any(target_os = \\\"freebsd\\\", target_os = \\\"dragonfly\\\"))\": [],\n \"cfg(any(target_os = \\\"freebsd\\\", target_os = \\\"netbsd\\\"))\": [],\n \"cfg(any(target_os = \\\"freebsd\\\", target_os = \\\"openbsd\\\", target_os = \\\"netbsd\\\", target_os = \\\"dragonflybsd\\\", target_os = \\\"ios\\\"))\": [],\n \"cfg(any(target_os = \\\"haiku\\\", target_os = \\\"redox\\\", target_os = \\\"nto\\\", target_os = \\\"aix\\\"))\": [],\n \"cfg(any(target_os = \\\"ios\\\", target_os = \\\"visionos\\\", target_os = \\\"watchos\\\", target_os = \\\"tvos\\\"))\": [],\n \"cfg(any(target_os = \\\"linux\\\", target_os = \\\"android\\\"))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"openbsd\\\", target_os = \\\"vita\\\", target_os = \\\"emscripten\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"cfg(any(target_os = \\\"macos\\\", target_os = \\\"windows\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(any(unix, target_os = \\\"fuchsia\\\", target_os = \\\"vxworks\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(unix, target_os = \\\"hermit\\\", target_os = \\\"wasi\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(unix, target_os = \\\"redox\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(unix, target_os = \\\"wasi\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(unix, windows))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(any(windows, target_os = \\\"linux\\\"))\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(curve25519_dalek_backend = \\\"fiat\\\")\": [],\n \"cfg(not(all(target_arch = \\\"arm\\\", target_os = \\\"none\\\")))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(not(all(target_arch = \\\"wasm32\\\", target_os = \\\"unknown\\\")))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(not(any(target_os = \\\"android\\\", target_os = \\\"linux\\\")))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(not(feature = \\\"alloc\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(not(target_arch = \\\"wasm32\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(not(target_has_atomic = \\\"64\\\"))\": [],\n \"cfg(not(target_has_atomic = \\\"ptr\\\"))\": [],\n \"cfg(not(target_os = \\\"windows\\\"))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(not(windows))\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(target_arch = \\\"aarch64\\\")\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\"],\n \"cfg(target_arch = \\\"spirv\\\")\": [],\n \"cfg(target_arch = \\\"wasm32\\\")\": [],\n \"cfg(target_arch = \\\"x86\\\")\": [],\n \"cfg(target_arch = \\\"x86_64\\\")\": [\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-pc-windows-msvc\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(target_family = \\\"wasm\\\")\": [],\n \"cfg(target_os = \\\"android\\\")\": [],\n \"cfg(target_os = \\\"freebsd\\\")\": [],\n \"cfg(target_os = \\\"haiku\\\")\": [],\n \"cfg(target_os = \\\"hermit\\\")\": [],\n \"cfg(target_os = \\\"linux\\\")\": [\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(target_os = \\\"macos\\\")\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"cfg(target_os = \\\"netbsd\\\")\": [],\n \"cfg(target_os = \\\"redox\\\")\": [],\n \"cfg(target_os = \\\"solaris\\\")\": [],\n \"cfg(target_os = \\\"vxworks\\\")\": [],\n \"cfg(target_os = \\\"wasi\\\")\": [],\n \"cfg(target_os = \\\"windows\\\")\": [\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(target_vendor = \\\"apple\\\")\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"cfg(unix)\": [\"@@//bazel/triples:aarch64-apple-darwin\",\"@@//bazel/triples:aarch64-unknown-linux-gnu\",\"@@//bazel/triples:aarch64-unknown-linux-musl\",\"@@//bazel/triples:x86_64-apple-darwin\",\"@@//bazel/triples:x86_64-unknown-linux-gnu\",\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n \"cfg(windows)\": [\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"cfg(windows_raw_dylib)\": [],\n \"i686-pc-windows-gnu\": [],\n \"i686-pc-windows-gnullvm\": [],\n \"wasm32-unknown-unknown\": [],\n \"x86_64-apple-darwin\": [\"@@//bazel/triples:x86_64-apple-darwin\"],\n \"x86_64-pc-windows-gnu\": [],\n \"x86_64-pc-windows-gnullvm\": [],\n \"x86_64-pc-windows-msvc\": [\"@@//bazel/triples:x86_64-pc-windows-msvc\"],\n \"x86_64-unknown-linux-gnu\": [\"@@//bazel/triples:x86_64-unknown-linux-gnu\"],\n \"x86_64-unknown-linux-musl\": [\"@@//bazel/triples:x86_64-unknown-linux-musl\"],\n}\n\n###############################################################################\n\ndef crate_repositories():\n \"\"\"A macro for defining repositories for all generated crates.\n\n Returns:\n A list of repos visible to the module through the module extension.\n \"\"\"\n maybe(\n crates_vendor_remote_repository,\n name = \"crates\",\n # Lean interface: just point at `crates.bzl`; the repo rule\n # derives the sibling `BUILD.bazel` and `defs.bzl`.\n crates_module = Label(\"@crates//crates:crates.bzl\"),\n )\n maybe(\n http_archive,\n name = \"crates__adler2-2.0.1\",\n sha256 = \"320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/adler2/2.0.1/download\"],\n strip_prefix = \"adler2-2.0.1\",\n build_file = Label(\"@crates//crates:BUILD.adler2-2.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__aead-0.5.2\",\n sha256 = \"d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aead/0.5.2/download\"],\n strip_prefix = \"aead-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.aead-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__aes-0.8.4\",\n sha256 = \"b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aes/0.8.4/download\"],\n strip_prefix = \"aes-0.8.4\",\n build_file = Label(\"@crates//crates:BUILD.aes-0.8.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__aes-gcm-0.10.3\",\n sha256 = \"831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aes-gcm/0.10.3/download\"],\n strip_prefix = \"aes-gcm-0.10.3\",\n build_file = Label(\"@crates//crates:BUILD.aes-gcm-0.10.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ahash-0.8.12\",\n sha256 = \"5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ahash/0.8.12/download\"],\n strip_prefix = \"ahash-0.8.12\",\n build_file = Label(\"@crates//crates:BUILD.ahash-0.8.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__aho-corasick-1.1.5\",\n sha256 = \"c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/aho-corasick/1.1.5/download\"],\n strip_prefix = \"aho-corasick-1.1.5\",\n build_file = Label(\"@crates//crates:BUILD.aho-corasick-1.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__allocator-api2-0.2.21\",\n sha256 = \"683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/allocator-api2/0.2.21/download\"],\n strip_prefix = \"allocator-api2-0.2.21\",\n build_file = Label(\"@crates//crates:BUILD.allocator-api2-0.2.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__android_system_properties-0.1.6\",\n sha256 = \"ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/android_system_properties/0.1.6/download\"],\n strip_prefix = \"android_system_properties-0.1.6\",\n build_file = Label(\"@crates//crates:BUILD.android_system_properties-0.1.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__annotate-snippets-0.11.5\",\n sha256 = \"710e8eae58854cdc1790fcb56cca04d712a17be849eeb81da2a724bf4bae2bc4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/annotate-snippets/0.11.5/download\"],\n strip_prefix = \"annotate-snippets-0.11.5\",\n build_file = Label(\"@crates//crates:BUILD.annotate-snippets-0.11.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ansi-width-0.1.0\",\n sha256 = \"219e3ce6f2611d83b51ec2098a12702112c29e57203a6b0a0929b2cddb486608\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ansi-width/0.1.0/download\"],\n strip_prefix = \"ansi-width-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.ansi-width-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstream-1.0.0\",\n sha256 = \"824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstream/1.0.0/download\"],\n strip_prefix = \"anstream-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstream-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-1.0.14\",\n sha256 = \"940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle/1.0.14/download\"],\n strip_prefix = \"anstyle-1.0.14\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-1.0.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-parse-1.0.0\",\n sha256 = \"52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-parse/1.0.0/download\"],\n strip_prefix = \"anstyle-parse-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-parse-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-query-1.1.5\",\n sha256 = \"40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-query/1.1.5/download\"],\n strip_prefix = \"anstyle-query-1.1.5\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-query-1.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anstyle-wincon-3.0.11\",\n sha256 = \"291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anstyle-wincon/3.0.11/download\"],\n strip_prefix = \"anstyle-wincon-3.0.11\",\n build_file = Label(\"@crates//crates:BUILD.anstyle-wincon-3.0.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__anyhow-1.0.104\",\n sha256 = \"330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/anyhow/1.0.104/download\"],\n strip_prefix = \"anyhow-1.0.104\",\n build_file = Label(\"@crates//crates:BUILD.anyhow-1.0.104.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__arboard-3.6.1\",\n sha256 = \"0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/arboard/3.6.1/download\"],\n strip_prefix = \"arboard-3.6.1\",\n build_file = Label(\"@crates//crates:BUILD.arboard-3.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__arc-swap-1.9.2\",\n sha256 = \"c049c0be4daef0b145cb3555416b3b8ef5b7888a38aea1a3a155801fe7b0810b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/arc-swap/1.9.2/download\"],\n strip_prefix = \"arc-swap-1.9.2\",\n build_file = Label(\"@crates//crates:BUILD.arc-swap-1.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__archery-1.2.3\",\n sha256 = \"33ca55ee147b1926dbea904f50fe4902494e97bc742205abbbf10c709e43815f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/archery/1.2.3/download\"],\n strip_prefix = \"archery-1.2.3\",\n build_file = Label(\"@crates//crates:BUILD.archery-1.2.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__argmax-0.3.1\",\n sha256 = \"5b7e3ef5e3a7f2c5e5a49d90ad087c03d38258e75155daac64deb62c50972c66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/argmax/0.3.1/download\"],\n strip_prefix = \"argmax-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.argmax-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__arrayref-0.3.9\",\n sha256 = \"76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/arrayref/0.3.9/download\"],\n strip_prefix = \"arrayref-0.3.9\",\n build_file = Label(\"@crates//crates:BUILD.arrayref-0.3.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__arrayvec-0.7.8\",\n sha256 = \"d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/arrayvec/0.7.8/download\"],\n strip_prefix = \"arrayvec-0.7.8\",\n build_file = Label(\"@crates//crates:BUILD.arrayvec-0.7.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ashpd-0.11.1\",\n sha256 = \"d2f3f79755c74fd155000314eb349864caa787c6592eace6c6882dad873d9c39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ashpd/0.11.1/download\"],\n strip_prefix = \"ashpd-0.11.1\",\n build_file = Label(\"@crates//crates:BUILD.ashpd-0.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__asn1-rs-0.6.2\",\n sha256 = \"5493c3bedbacf7fd7382c6346bbd66687d12bbaad3a89a2d2c303ee6cf20b048\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/asn1-rs/0.6.2/download\"],\n strip_prefix = \"asn1-rs-0.6.2\",\n build_file = Label(\"@crates//crates:BUILD.asn1-rs-0.6.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__asn1-rs-derive-0.5.1\",\n sha256 = \"965c2d33e53cb6b267e148a4cb0760bc01f4904c1cd4bb4002a085bb016d1490\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/asn1-rs-derive/0.5.1/download\"],\n strip_prefix = \"asn1-rs-derive-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.asn1-rs-derive-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__asn1-rs-impl-0.2.0\",\n sha256 = \"7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/asn1-rs-impl/0.2.0/download\"],\n strip_prefix = \"asn1-rs-impl-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.asn1-rs-impl-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ast-grep-core-0.39.9\",\n sha256 = \"057ae90e7256ebf85f840b1638268df0142c9d19467d500b790631fd301acc27\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ast-grep-core/0.39.9/download\"],\n strip_prefix = \"ast-grep-core-0.39.9\",\n build_file = Label(\"@crates//crates:BUILD.ast-grep-core-0.39.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__astral-tl-0.7.11\",\n sha256 = \"d90933ffb0f97e2fc2e0de21da9d3f20597b804012d199843a6fe7c2810d28f3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/astral-tl/0.7.11/download\"],\n strip_prefix = \"astral-tl-0.7.11\",\n build_file = Label(\"@crates//crates:BUILD.astral-tl-0.7.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-broadcast-0.7.2\",\n sha256 = \"435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-broadcast/0.7.2/download\"],\n strip_prefix = \"async-broadcast-0.7.2\",\n build_file = Label(\"@crates//crates:BUILD.async-broadcast-0.7.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-channel-2.5.0\",\n sha256 = \"924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-channel/2.5.0/download\"],\n strip_prefix = \"async-channel-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.async-channel-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-executor-1.14.0\",\n sha256 = \"c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-executor/1.14.0/download\"],\n strip_prefix = \"async-executor-1.14.0\",\n build_file = Label(\"@crates//crates:BUILD.async-executor-1.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-io-2.6.0\",\n sha256 = \"456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-io/2.6.0/download\"],\n strip_prefix = \"async-io-2.6.0\",\n build_file = Label(\"@crates//crates:BUILD.async-io-2.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-lock-3.4.2\",\n sha256 = \"290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-lock/3.4.2/download\"],\n strip_prefix = \"async-lock-3.4.2\",\n build_file = Label(\"@crates//crates:BUILD.async-lock-3.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-process-2.5.0\",\n sha256 = \"fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-process/2.5.0/download\"],\n strip_prefix = \"async-process-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.async-process-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-recursion-1.1.1\",\n sha256 = \"3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-recursion/1.1.1/download\"],\n strip_prefix = \"async-recursion-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.async-recursion-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-signal-0.2.14\",\n sha256 = \"52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-signal/0.2.14/download\"],\n strip_prefix = \"async-signal-0.2.14\",\n build_file = Label(\"@crates//crates:BUILD.async-signal-0.2.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-task-4.7.1\",\n sha256 = \"8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-task/4.7.1/download\"],\n strip_prefix = \"async-task-4.7.1\",\n build_file = Label(\"@crates//crates:BUILD.async-task-4.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__async-trait-0.1.92\",\n sha256 = \"82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/async-trait/0.1.92/download\"],\n strip_prefix = \"async-trait-0.1.92\",\n build_file = Label(\"@crates//crates:BUILD.async-trait-0.1.92.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__atomic-waker-1.1.2\",\n sha256 = \"1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/atomic-waker/1.1.2/download\"],\n strip_prefix = \"atomic-waker-1.1.2\",\n build_file = Label(\"@crates//crates:BUILD.atomic-waker-1.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__atspi-0.30.0\",\n sha256 = \"6bf601cccedfffec598ec2db1f9d6745885458bccc0e8916d7023f017c94b3d0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/atspi/0.30.0/download\"],\n strip_prefix = \"atspi-0.30.0\",\n build_file = Label(\"@crates//crates:BUILD.atspi-0.30.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__atspi-common-0.14.0\",\n sha256 = \"f8a79bed3f5b408ce3152f36e07327a845e6ed5d7e2821a89264037dbcc11daf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/atspi-common/0.14.0/download\"],\n strip_prefix = \"atspi-common-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.atspi-common-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__atspi-connection-0.14.0\",\n sha256 = \"8fab8e4f574f5a7d3af280b38eff25fb6f47a537dac9ae39ce152f52b19fb10b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/atspi-connection/0.14.0/download\"],\n strip_prefix = \"atspi-connection-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.atspi-connection-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__atspi-proxies-0.14.0\",\n sha256 = \"53403acd3ab2fdb5914f6558da22e540fc07656fce5510f8c02be0e6ef68413e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/atspi-proxies/0.14.0/download\"],\n strip_prefix = \"atspi-proxies-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.atspi-proxies-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__audiopus_sys-0.2.2\",\n patch_args = [\n \"-p1\",\n ],\n patches = [\n \"@@//bazel/patches:audiopus-sys-libdir.patch\",\n ],\n sha256 = \"62314a1546a2064e033665d658e88c620a62904be945f8147e6b16c3db9f8651\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/audiopus_sys/0.2.2/download\"],\n strip_prefix = \"audiopus_sys-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.audiopus_sys-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__autocfg-1.5.1\",\n sha256 = \"f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/autocfg/1.5.1/download\"],\n strip_prefix = \"autocfg-1.5.1\",\n build_file = Label(\"@crates//crates:BUILD.autocfg-1.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base16ct-0.2.0\",\n sha256 = \"4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base16ct/0.2.0/download\"],\n strip_prefix = \"base16ct-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.base16ct-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64-0.22.1\",\n sha256 = \"72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64/0.22.1/download\"],\n strip_prefix = \"base64-0.22.1\",\n build_file = Label(\"@crates//crates:BUILD.base64-0.22.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64-0.23.1\",\n sha256 = \"ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64/0.23.1/download\"],\n strip_prefix = \"base64-0.23.1\",\n build_file = Label(\"@crates//crates:BUILD.base64-0.23.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64-simd-0.8.0\",\n sha256 = \"339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64-simd/0.8.0/download\"],\n strip_prefix = \"base64-simd-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.base64-simd-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__base64ct-1.8.3\",\n sha256 = \"2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/base64ct/1.8.3/download\"],\n strip_prefix = \"base64ct-1.8.3\",\n build_file = Label(\"@crates//crates:BUILD.base64ct-1.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__beef-0.5.2\",\n sha256 = \"3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/beef/0.5.2/download\"],\n strip_prefix = \"beef-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.beef-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bigdecimal-0.4.10\",\n sha256 = \"4d6867f1565b3aad85681f1015055b087fcfd840d6aeee6eee7f2da317603695\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bigdecimal/0.4.10/download\"],\n strip_prefix = \"bigdecimal-0.4.10\",\n build_file = Label(\"@crates//crates:BUILD.bigdecimal-0.4.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__binary-heap-plus-0.5.0\",\n sha256 = \"e4551d8382e911ecc0d0f0ffb602777988669be09447d536ff4388d1def11296\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/binary-heap-plus/0.5.0/download\"],\n strip_prefix = \"binary-heap-plus-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.binary-heap-plus-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bincode-1.3.3\",\n sha256 = \"b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bincode/1.3.3/download\"],\n strip_prefix = \"bincode-1.3.3\",\n build_file = Label(\"@crates//crates:BUILD.bincode-1.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bindgen-0.72.1\",\n sha256 = \"993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bindgen/0.72.1/download\"],\n strip_prefix = \"bindgen-0.72.1\",\n build_file = Label(\"@crates//crates:BUILD.bindgen-0.72.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-set-0.8.0\",\n sha256 = \"08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-set/0.8.0/download\"],\n strip_prefix = \"bit-set-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-set-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bit-vec-0.8.0\",\n sha256 = \"5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bit-vec/0.8.0/download\"],\n strip_prefix = \"bit-vec-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.bit-vec-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-1.3.2\",\n sha256 = \"bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/1.3.2/download\"],\n strip_prefix = \"bitflags-1.3.2\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-1.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitflags-2.13.1\",\n sha256 = \"b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitflags/2.13.1/download\"],\n strip_prefix = \"bitflags-2.13.1\",\n build_file = Label(\"@crates//crates:BUILD.bitflags-2.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bitvec-1.1.1\",\n sha256 = \"ddcec3d12c579d40898fe0a9a358a803c23e9c52ca3c425707f81c9436211837\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bitvec/1.1.1/download\"],\n strip_prefix = \"bitvec-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.bitvec-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__blake2-0.10.6\",\n sha256 = \"46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/blake2/0.10.6/download\"],\n strip_prefix = \"blake2-0.10.6\",\n build_file = Label(\"@crates//crates:BUILD.blake2-0.10.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__blake2b_simd-1.0.5\",\n sha256 = \"3560a7b1951efe814fcd721938313adc56753ca39f4b23847d7e9a2402f5dbff\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/blake2b_simd/1.0.5/download\"],\n strip_prefix = \"blake2b_simd-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.blake2b_simd-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__blake3-1.8.7\",\n sha256 = \"6d9e454fc11f76977dc803893aff6304ed33d6a26efae8696573bea74baa27ae\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/blake3/1.8.7/download\"],\n strip_prefix = \"blake3-1.8.7\",\n build_file = Label(\"@crates//crates:BUILD.blake3-1.8.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__block-buffer-0.10.4\",\n sha256 = \"3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/block-buffer/0.10.4/download\"],\n strip_prefix = \"block-buffer-0.10.4\",\n build_file = Label(\"@crates//crates:BUILD.block-buffer-0.10.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__block-buffer-0.12.1\",\n sha256 = \"d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/block-buffer/0.12.1/download\"],\n strip_prefix = \"block-buffer-0.12.1\",\n build_file = Label(\"@crates//crates:BUILD.block-buffer-0.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__block-padding-0.3.3\",\n sha256 = \"a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/block-padding/0.3.3/download\"],\n strip_prefix = \"block-padding-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.block-padding-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__block2-0.6.2\",\n sha256 = \"cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/block2/0.6.2/download\"],\n strip_prefix = \"block2-0.6.2\",\n build_file = Label(\"@crates//crates:BUILD.block2-0.6.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__blocking-1.7.0\",\n sha256 = \"a70e4329df6cb94385eed412ec92375c3cdd8a6e502493d1229b6414e4036dfa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/blocking/1.7.0/download\"],\n strip_prefix = \"blocking-1.7.0\",\n build_file = Label(\"@crates//crates:BUILD.blocking-1.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bon-3.10.0\",\n sha256 = \"9e3fac94a66da67200398458a25412bcc3f9b6443b5119a6cad9cf3ccfcd8cc6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bon/3.10.0/download\"],\n strip_prefix = \"bon-3.10.0\",\n build_file = Label(\"@crates//crates:BUILD.bon-3.10.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bon-macros-3.10.0\",\n sha256 = \"d4654961ad0494e4774c5c60b4cb4cd0ae9b9d92d039d901638b1dba97ebebf5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bon-macros/3.10.0/download\"],\n strip_prefix = \"bon-macros-3.10.0\",\n build_file = Label(\"@crates//crates:BUILD.bon-macros-3.10.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__brush-parser-0.3.0\",\n sha256 = \"f7367124d4f38fdcd65f4b815bda7caeb3de377b9cd95ffa1b23627989c93718\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/brush-parser/0.3.0/download\"],\n strip_prefix = \"brush-parser-0.3.0\",\n build_file = Label(\"@crates//crates:BUILD.brush-parser-0.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__brush-parser-0.4.0\",\n sha256 = \"9f64b19efc02f0dd6cac1d462e20a1098f425f09cb13624efbb1b7d63f061735\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/brush-parser/0.4.0/download\"],\n strip_prefix = \"brush-parser-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.brush-parser-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bstr-1.13.1\",\n sha256 = \"6bb31b46c14244e20ee9984b11bf5c992b91fb6939fea616e3512c8baecdbe5f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bstr/1.13.1/download\"],\n strip_prefix = \"bstr-1.13.1\",\n build_file = Label(\"@crates//crates:BUILD.bstr-1.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bumpalo-3.20.3\",\n sha256 = \"72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bumpalo/3.20.3/download\"],\n strip_prefix = \"bumpalo-3.20.3\",\n build_file = Label(\"@crates//crates:BUILD.bumpalo-3.20.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__by_address-1.2.1\",\n sha256 = \"64fa3c856b712db6612c019f14756e64e4bcea13337a6b33b696333a9eaa2d06\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/by_address/1.2.1/download\"],\n strip_prefix = \"by_address-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.by_address-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytecheck-0.8.3\",\n sha256 = \"26333eeac754f0ad8a6bcd0eb0ac012156302e4e16b852b72ee399aea4f12c29\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytecheck/0.8.3/download\"],\n strip_prefix = \"bytecheck-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.bytecheck-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytecheck_derive-0.8.3\",\n sha256 = \"46d07918caa9eeaaf06b7873925c53a61daac173539b4f7715090745e44e4e69\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytecheck_derive/0.8.3/download\"],\n strip_prefix = \"bytecheck_derive-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.bytecheck_derive-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytecount-0.6.9\",\n sha256 = \"175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytecount/0.6.9/download\"],\n strip_prefix = \"bytecount-0.6.9\",\n build_file = Label(\"@crates//crates:BUILD.bytecount-0.6.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytemuck-1.25.2\",\n sha256 = \"95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytemuck/1.25.2/download\"],\n strip_prefix = \"bytemuck-1.25.2\",\n build_file = Label(\"@crates//crates:BUILD.bytemuck-1.25.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytemuck_derive-1.12.0\",\n sha256 = \"fc0e56a716f1e132ff6bf4bdac1c944a3fcdc1cae65f70a4a2a1ac3b401d2d1f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytemuck_derive/1.12.0/download\"],\n strip_prefix = \"bytemuck_derive-1.12.0\",\n build_file = Label(\"@crates//crates:BUILD.bytemuck_derive-1.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__byteorder-1.5.0\",\n sha256 = \"1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/byteorder/1.5.0/download\"],\n strip_prefix = \"byteorder-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.byteorder-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__byteorder-lite-0.1.0\",\n sha256 = \"8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/byteorder-lite/0.1.0/download\"],\n strip_prefix = \"byteorder-lite-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.byteorder-lite-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__bytes-1.12.1\",\n sha256 = \"fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/bytes/1.12.1/download\"],\n strip_prefix = \"bytes-1.12.1\",\n build_file = Label(\"@crates//crates:BUILD.bytes-1.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cached-0.56.0\",\n sha256 = \"801927ee168e17809ab8901d9f01f700cd7d8d6a6527997fee44e4b0327a253c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cached/0.56.0/download\"],\n strip_prefix = \"cached-0.56.0\",\n build_file = Label(\"@crates//crates:BUILD.cached-0.56.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cached-0.59.0\",\n sha256 = \"53b6f5d101f0f6322c8646a45b7c581a673e476329040d97565815c2461dd0c4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cached/0.59.0/download\"],\n strip_prefix = \"cached-0.59.0\",\n build_file = Label(\"@crates//crates:BUILD.cached-0.59.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cached_proc_macro-0.25.0\",\n sha256 = \"9225bdcf4e4a9a4c08bf16607908eb2fbf746828d5e0b5e019726dbf6571f201\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cached_proc_macro/0.25.0/download\"],\n strip_prefix = \"cached_proc_macro-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.cached_proc_macro-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cached_proc_macro-0.27.0\",\n sha256 = \"8ebcf9c75f17a17d55d11afc98e46167d4790a263f428891b8705ab2f793eca3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cached_proc_macro/0.27.0/download\"],\n strip_prefix = \"cached_proc_macro-0.27.0\",\n build_file = Label(\"@crates//crates:BUILD.cached_proc_macro-0.27.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cached_proc_macro_types-0.1.1\",\n sha256 = \"ade8366b8bd5ba243f0a58f036cc0ca8a2f069cff1a2351ef1cac6b083e16fc0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cached_proc_macro_types/0.1.1/download\"],\n strip_prefix = \"cached_proc_macro_types-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.cached_proc_macro_types-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__calendrical_calculations-0.2.4\",\n sha256 = \"5abbd6eeda6885048d357edc66748eea6e0268e3dd11f326fff5bd248d779c26\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/calendrical_calculations/0.2.4/download\"],\n strip_prefix = \"calendrical_calculations-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.calendrical_calculations-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cbc-0.1.2\",\n sha256 = \"26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cbc/0.1.2/download\"],\n strip_prefix = \"cbc-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.cbc-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cc-1.2.67\",\n sha256 = \"e17dd265a7d0f31ef544e1b20e03add05d3b45b491b633b10d67145d2acc1a38\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cc/1.2.67/download\"],\n strip_prefix = \"cc-1.2.67\",\n build_file = Label(\"@crates//crates:BUILD.cc-1.2.67.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ccm-0.5.0\",\n sha256 = \"9ae3c82e4355234767756212c570e29833699ab63e6ffd161887314cc5b43847\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ccm/0.5.0/download\"],\n strip_prefix = \"ccm-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.ccm-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cexpr-0.6.0\",\n sha256 = \"6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cexpr/0.6.0/download\"],\n strip_prefix = \"cexpr-0.6.0\",\n build_file = Label(\"@crates//crates:BUILD.cexpr-0.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg-expr-0.20.9\",\n sha256 = \"fe4ece8474b5f766c63426647e7b4b316b67431ade1036a8313cee24a03ae917\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg-expr/0.20.9/download\"],\n strip_prefix = \"cfg-expr-0.20.9\",\n build_file = Label(\"@crates//crates:BUILD.cfg-expr-0.20.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg-if-1.0.4\",\n sha256 = \"9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg-if/1.0.4/download\"],\n strip_prefix = \"cfg-if-1.0.4\",\n build_file = Label(\"@crates//crates:BUILD.cfg-if-1.0.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg_aliases-0.1.1\",\n sha256 = \"fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg_aliases/0.1.1/download\"],\n strip_prefix = \"cfg_aliases-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.cfg_aliases-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cfg_aliases-0.2.2\",\n sha256 = \"f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cfg_aliases/0.2.2/download\"],\n strip_prefix = \"cfg_aliases-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.cfg_aliases-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chacha20-0.10.2\",\n sha256 = \"65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chacha20/0.10.2/download\"],\n strip_prefix = \"chacha20-0.10.2\",\n build_file = Label(\"@crates//crates:BUILD.chacha20-0.10.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chacha20-0.9.1\",\n sha256 = \"c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chacha20/0.9.1/download\"],\n strip_prefix = \"chacha20-0.9.1\",\n build_file = Label(\"@crates//crates:BUILD.chacha20-0.9.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chacha20poly1305-0.10.1\",\n sha256 = \"10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chacha20poly1305/0.10.1/download\"],\n strip_prefix = \"chacha20poly1305-0.10.1\",\n build_file = Label(\"@crates//crates:BUILD.chacha20poly1305-0.10.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__check_elevation-0.2.7\",\n sha256 = \"a7fe1fbbd8bd3174109071530f12932ff471eeff30d83e9c485d6ff424ac534b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/check_elevation/0.2.7/download\"],\n strip_prefix = \"check_elevation-0.2.7\",\n build_file = Label(\"@crates//crates:BUILD.check_elevation-0.2.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__chrono-0.4.45\",\n sha256 = \"1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/chrono/0.4.45/download\"],\n strip_prefix = \"chrono-0.4.45\",\n build_file = Label(\"@crates//crates:BUILD.chrono-0.4.45.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cipher-0.4.4\",\n sha256 = \"773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cipher/0.4.4/download\"],\n strip_prefix = \"cipher-0.4.4\",\n build_file = Label(\"@crates//crates:BUILD.cipher-0.4.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clang-sys-1.9.1\",\n sha256 = \"157a8ba7b480713b56f4c09fd13fc3e0a22a5dfab8097ba61cbc5feef950788a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clang-sys/1.9.1/download\"],\n strip_prefix = \"clang-sys-1.9.1\",\n build_file = Label(\"@crates//crates:BUILD.clang-sys-1.9.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap-4.6.6\",\n sha256 = \"473c7e07f409a8d772161724aa8db6a765a2532a70f9667eeb7b49d3d02fbdca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap/4.6.6/download\"],\n strip_prefix = \"clap-4.6.6\",\n build_file = Label(\"@crates//crates:BUILD.clap-4.6.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_builder-4.6.6\",\n sha256 = \"7b48fea5a88e9ae728a2dcbedbfc0e730f7d60da42e1cb049a83c9fb8b789889\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_builder/4.6.6/download\"],\n strip_prefix = \"clap_builder-4.6.6\",\n build_file = Label(\"@crates//crates:BUILD.clap_builder-4.6.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_derive-4.6.4\",\n sha256 = \"d012d2b9d65aca7f18f4d9878a045bc17899bba951561ba5ec3c2ba1eed9a061\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_derive/4.6.4/download\"],\n strip_prefix = \"clap_derive-4.6.4\",\n build_file = Label(\"@crates//crates:BUILD.clap_derive-4.6.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clap_lex-1.1.0\",\n sha256 = \"c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clap_lex/1.1.0/download\"],\n strip_prefix = \"clap_lex-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.clap_lex-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clipboard-win-5.4.1\",\n sha256 = \"bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clipboard-win/5.4.1/download\"],\n strip_prefix = \"clipboard-win-5.4.1\",\n build_file = Label(\"@crates//crates:BUILD.clipboard-win-5.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__clru-0.6.3\",\n sha256 = \"197fd99cb113a8d5d9b6376f3aa817f32c1078f2343b714fff7d2ca44fdf67d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/clru/0.6.3/download\"],\n strip_prefix = \"clru-0.6.3\",\n build_file = Label(\"@crates//crates:BUILD.clru-0.6.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cmake-0.1.58\",\n sha256 = \"c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cmake/0.1.58/download\"],\n strip_prefix = \"cmake-0.1.58\",\n build_file = Label(\"@crates//crates:BUILD.cmake-0.1.58.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__codesnake-0.2.1\",\n sha256 = \"2205f7f6d3de68ecf4c291c789b3edf07b6569268abd0188819086f71ae42225\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/codesnake/0.2.1/download\"],\n strip_prefix = \"codesnake-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.codesnake-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__color-print-0.3.7\",\n sha256 = \"3aa954171903797d5623e047d9ab69d91b493657917bdfb8c2c80ecaf9cdb6f4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/color-print/0.3.7/download\"],\n strip_prefix = \"color-print-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.color-print-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__color-print-proc-macro-0.3.7\",\n sha256 = \"692186b5ebe54007e45a59aea47ece9eb4108e141326c304cdc91699a7118a22\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/color-print-proc-macro/0.3.7/download\"],\n strip_prefix = \"color-print-proc-macro-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.color-print-proc-macro-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__color_quant-1.1.0\",\n sha256 = \"3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/color_quant/1.1.0/download\"],\n strip_prefix = \"color_quant-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.color_quant-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__colorchoice-1.0.5\",\n sha256 = \"1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/colorchoice/1.0.5/download\"],\n strip_prefix = \"colorchoice-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.colorchoice-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__command-fds-0.3.3\",\n sha256 = \"1b60b5124979fccd9addd89d8b97a1d6eebb4950694520c75ddd722535ea443f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/command-fds/0.3.3/download\"],\n strip_prefix = \"command-fds-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.command-fds-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__compare-0.1.0\",\n sha256 = \"120133d4db2ec47efe2e26502ee984747630c67f51974fca0b6c1340cf2368d3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/compare/0.1.0/download\"],\n strip_prefix = \"compare-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.compare-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__concurrent-queue-2.5.0\",\n sha256 = \"4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/concurrent-queue/2.5.0/download\"],\n strip_prefix = \"concurrent-queue-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.concurrent-queue-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__console-0.16.4\",\n sha256 = \"4fe5f465a4f6fee88fad41b85d990f84c835335e85b5d9e6e63e0d06d28cba7c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/console/0.16.4/download\"],\n strip_prefix = \"console-0.16.4\",\n build_file = Label(\"@crates//crates:BUILD.console-0.16.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__const-oid-0.10.2\",\n sha256 = \"a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/const-oid/0.10.2/download\"],\n strip_prefix = \"const-oid-0.10.2\",\n build_file = Label(\"@crates//crates:BUILD.const-oid-0.10.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__const-oid-0.9.6\",\n sha256 = \"c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/const-oid/0.9.6/download\"],\n strip_prefix = \"const-oid-0.9.6\",\n build_file = Label(\"@crates//crates:BUILD.const-oid-0.9.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__const-random-0.1.18\",\n sha256 = \"87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/const-random/0.1.18/download\"],\n strip_prefix = \"const-random-0.1.18\",\n build_file = Label(\"@crates//crates:BUILD.const-random-0.1.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__const-random-macro-0.1.16\",\n sha256 = \"f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/const-random-macro/0.1.16/download\"],\n strip_prefix = \"const-random-macro-0.1.16\",\n build_file = Label(\"@crates//crates:BUILD.const-random-macro-0.1.16.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__constant_time_eq-0.4.2\",\n sha256 = \"3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/constant_time_eq/0.4.2/download\"],\n strip_prefix = \"constant_time_eq-0.4.2\",\n build_file = Label(\"@crates//crates:BUILD.constant_time_eq-0.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__convert_case-0.11.0\",\n sha256 = \"affbf0190ed2caf063e3def54ff444b449371d55c58e513a95ab98eca50adb49\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/convert_case/0.11.0/download\"],\n strip_prefix = \"convert_case-0.11.0\",\n build_file = Label(\"@crates//crates:BUILD.convert_case-0.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__convert_case-0.8.0\",\n sha256 = \"baaaa0ecca5b51987b9423ccdc971514dd8b0bb7b4060b983d3664dad3f1f89f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/convert_case/0.8.0/download\"],\n strip_prefix = \"convert_case-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.convert_case-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cookie-factory-0.3.3\",\n sha256 = \"9885fa71e26b8ab7855e2ec7cae6e9b380edff76cd052e07c683a0319d51b3a2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cookie-factory/0.3.3/download\"],\n strip_prefix = \"cookie-factory-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.cookie-factory-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__core-foundation-0.10.1\",\n sha256 = \"b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/core-foundation/0.10.1/download\"],\n strip_prefix = \"core-foundation-0.10.1\",\n build_file = Label(\"@crates//crates:BUILD.core-foundation-0.10.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__core-foundation-sys-0.8.7\",\n sha256 = \"773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/core-foundation-sys/0.8.7/download\"],\n strip_prefix = \"core-foundation-sys-0.8.7\",\n build_file = Label(\"@crates//crates:BUILD.core-foundation-sys-0.8.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__core-graphics-0.25.0\",\n sha256 = \"064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/core-graphics/0.25.0/download\"],\n strip_prefix = \"core-graphics-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.core-graphics-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__core-graphics-types-0.2.0\",\n sha256 = \"3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/core-graphics-types/0.2.0/download\"],\n strip_prefix = \"core-graphics-types-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.core-graphics-types-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__core_maths-0.1.1\",\n sha256 = \"77745e017f5edba1a9c1d854f6f3a52dac8a12dd5af5d2f54aecf61e43d80d30\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/core_maths/0.1.1/download\"],\n strip_prefix = \"core_maths-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.core_maths-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cpufeatures-0.2.17\",\n sha256 = \"59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cpufeatures/0.2.17/download\"],\n strip_prefix = \"cpufeatures-0.2.17\",\n build_file = Label(\"@crates//crates:BUILD.cpufeatures-0.2.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__cpufeatures-0.3.1\",\n sha256 = \"5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/cpufeatures/0.3.1/download\"],\n strip_prefix = \"cpufeatures-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.cpufeatures-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crc-3.4.0\",\n sha256 = \"5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crc/3.4.0/download\"],\n strip_prefix = \"crc-3.4.0\",\n build_file = Label(\"@crates//crates:BUILD.crc-3.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crc-catalog-2.5.0\",\n sha256 = \"217698eaf96b4a3f0bc4f3662aaa55bdf913cd54d7204591faa790070c6d0853\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crc-catalog/2.5.0/download\"],\n strip_prefix = \"crc-catalog-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.crc-catalog-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crc-fast-1.8.2\",\n sha256 = \"85d9be5297a59f1b7651fd2711a1f4461929f53b182b394df0df15b3a387ef51\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crc-fast/1.8.2/download\"],\n strip_prefix = \"crc-fast-1.8.2\",\n build_file = Label(\"@crates//crates:BUILD.crc-fast-1.8.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crc32fast-1.5.1\",\n sha256 = \"8498c871161e1742aaa9d52551b2d6ebdd4c3d45a3be423e3728f33b955be550\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crc32fast/1.5.1/download\"],\n strip_prefix = \"crc32fast-1.5.1\",\n build_file = Label(\"@crates//crates:BUILD.crc32fast-1.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-channel-0.5.16\",\n sha256 = \"d85363c37faeca707aef026efa9f3b34d077bce547e48f770770625c6013679e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-channel/0.5.16/download\"],\n strip_prefix = \"crossbeam-channel-0.5.16\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-channel-0.5.16.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-deque-0.8.7\",\n sha256 = \"5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-deque/0.8.7/download\"],\n strip_prefix = \"crossbeam-deque-0.8.7\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-deque-0.8.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-epoch-0.9.20\",\n sha256 = \"2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-epoch/0.9.20/download\"],\n strip_prefix = \"crossbeam-epoch-0.9.20\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-epoch-0.9.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crossbeam-utils-0.8.22\",\n sha256 = \"61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crossbeam-utils/0.8.22/download\"],\n strip_prefix = \"crossbeam-utils-0.8.22\",\n build_file = Label(\"@crates//crates:BUILD.crossbeam-utils-0.8.22.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crunchy-0.2.4\",\n sha256 = \"460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crunchy/0.2.4/download\"],\n strip_prefix = \"crunchy-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.crunchy-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crypto-bigint-0.5.5\",\n sha256 = \"0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crypto-bigint/0.5.5/download\"],\n strip_prefix = \"crypto-bigint-0.5.5\",\n build_file = Label(\"@crates//crates:BUILD.crypto-bigint-0.5.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crypto-common-0.1.7\",\n sha256 = \"78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crypto-common/0.1.7/download\"],\n strip_prefix = \"crypto-common-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.crypto-common-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__crypto-common-0.2.2\",\n sha256 = \"ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/crypto-common/0.2.2/download\"],\n strip_prefix = \"crypto-common-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.crypto-common-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ctor-1.0.13\",\n sha256 = \"914a755b7c2d4af2bdcff7ce1739e2db9a1b81a9b07123d8015786ae03c0980d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ctor/1.0.13/download\"],\n strip_prefix = \"ctor-1.0.13\",\n build_file = Label(\"@crates//crates:BUILD.ctor-1.0.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ctr-0.9.2\",\n sha256 = \"0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ctr/0.9.2/download\"],\n strip_prefix = \"ctr-0.9.2\",\n build_file = Label(\"@crates//crates:BUILD.ctr-0.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__curve25519-dalek-4.1.3\",\n sha256 = \"97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/curve25519-dalek/4.1.3/download\"],\n strip_prefix = \"curve25519-dalek-4.1.3\",\n build_file = Label(\"@crates//crates:BUILD.curve25519-dalek-4.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__curve25519-dalek-derive-0.1.1\",\n sha256 = \"f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/curve25519-dalek-derive/0.1.1/download\"],\n strip_prefix = \"curve25519-dalek-derive-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.curve25519-dalek-derive-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling-0.20.11\",\n sha256 = \"fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling/0.20.11/download\"],\n strip_prefix = \"darling-0.20.11\",\n build_file = Label(\"@crates//crates:BUILD.darling-0.20.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling-0.24.1\",\n sha256 = \"ed17f5901b6630b993ca003def43f2f8ef4014fc13b047b57aad617ff32bc2ec\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling/0.24.1/download\"],\n strip_prefix = \"darling-0.24.1\",\n build_file = Label(\"@crates//crates:BUILD.darling-0.24.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_core-0.20.11\",\n sha256 = \"0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_core/0.20.11/download\"],\n strip_prefix = \"darling_core-0.20.11\",\n build_file = Label(\"@crates//crates:BUILD.darling_core-0.20.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_core-0.24.1\",\n sha256 = \"6837e2cf7485aaae18f86181d2f0e9a7ed297a025e220aeabf63fdebd3a2ddff\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_core/0.24.1/download\"],\n strip_prefix = \"darling_core-0.24.1\",\n build_file = Label(\"@crates//crates:BUILD.darling_core-0.24.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_macro-0.20.11\",\n sha256 = \"fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_macro/0.20.11/download\"],\n strip_prefix = \"darling_macro-0.20.11\",\n build_file = Label(\"@crates//crates:BUILD.darling_macro-0.20.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__darling_macro-0.24.1\",\n sha256 = \"2ac7135c3ef02b2f7833bbeb1be5ba7f966dcde8a87c6b87f65a778d71a02785\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/darling_macro/0.24.1/download\"],\n strip_prefix = \"darling_macro-0.24.1\",\n build_file = Label(\"@crates//crates:BUILD.darling_macro-0.24.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dashmap-6.2.1\",\n sha256 = \"e6361d5c062261c78a176addb82d4c821ae42bed6089de0e12603cd25de2059c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dashmap/6.2.1/download\"],\n strip_prefix = \"dashmap-6.2.1\",\n build_file = Label(\"@crates//crates:BUILD.dashmap-6.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__data-encoding-2.11.1\",\n sha256 = \"4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/data-encoding/2.11.1/download\"],\n strip_prefix = \"data-encoding-2.11.1\",\n build_file = Label(\"@crates//crates:BUILD.data-encoding-2.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__data-encoding-macro-0.1.21\",\n sha256 = \"c6a127ecbb3c4632e1525380e04c0c3fcf8dcb44d32a79ea290d8a36906edcd8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/data-encoding-macro/0.1.21/download\"],\n strip_prefix = \"data-encoding-macro-0.1.21\",\n build_file = Label(\"@crates//crates:BUILD.data-encoding-macro-0.1.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__data-encoding-macro-internal-0.1.19\",\n sha256 = \"c54e03a951783e8b327515db3f2a2fd0e3bed362a96b066f341ce66ed49b4ead\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/data-encoding-macro-internal/0.1.19/download\"],\n strip_prefix = \"data-encoding-macro-internal-0.1.19\",\n build_file = Label(\"@crates//crates:BUILD.data-encoding-macro-internal-0.1.19.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__data-url-0.3.2\",\n sha256 = \"be1e0bca6c3637f992fc1cc7cbc52a78c1ef6db076dbf1059c4323d6a2048376\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/data-url/0.3.2/download\"],\n strip_prefix = \"data-url-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.data-url-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__defmt-1.1.1\",\n sha256 = \"e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/defmt/1.1.1/download\"],\n strip_prefix = \"defmt-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.defmt-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__defmt-macros-1.1.1\",\n sha256 = \"bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/defmt-macros/1.1.1/download\"],\n strip_prefix = \"defmt-macros-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.defmt-macros-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__defmt-parser-1.0.0\",\n sha256 = \"10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/defmt-parser/1.0.0/download\"],\n strip_prefix = \"defmt-parser-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.defmt-parser-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__der-0.7.10\",\n sha256 = \"e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/der/0.7.10/download\"],\n strip_prefix = \"der-0.7.10\",\n build_file = Label(\"@crates//crates:BUILD.der-0.7.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__der-parser-9.0.0\",\n sha256 = \"5cd0a5c643689626bec213c4d8bd4d96acc8ffdb4ad4bb6bc16abf27d5f4b553\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/der-parser/9.0.0/download\"],\n strip_prefix = \"der-parser-9.0.0\",\n build_file = Label(\"@crates//crates:BUILD.der-parser-9.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__deranged-0.5.8\",\n sha256 = \"7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/deranged/0.5.8/download\"],\n strip_prefix = \"deranged-0.5.8\",\n build_file = Label(\"@crates//crates:BUILD.deranged-0.5.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__diff-0.1.13\",\n sha256 = \"56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/diff/0.1.13/download\"],\n strip_prefix = \"diff-0.1.13\",\n build_file = Label(\"@crates//crates:BUILD.diff-0.1.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__digest-0.10.7\",\n sha256 = \"9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/digest/0.10.7/download\"],\n strip_prefix = \"digest-0.10.7\",\n build_file = Label(\"@crates//crates:BUILD.digest-0.10.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__digest-0.11.3\",\n sha256 = \"f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/digest/0.11.3/download\"],\n strip_prefix = \"digest-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.digest-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dispatch2-0.3.1\",\n sha256 = \"1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dispatch2/0.3.1/download\"],\n strip_prefix = \"dispatch2-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.dispatch2-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__displaydoc-0.2.7\",\n sha256 = \"c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/displaydoc/0.2.7/download\"],\n strip_prefix = \"displaydoc-0.2.7\",\n build_file = Label(\"@crates//crates:BUILD.displaydoc-0.2.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dlib-0.5.3\",\n sha256 = \"ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dlib/0.5.3/download\"],\n strip_prefix = \"dlib-0.5.3\",\n build_file = Label(\"@crates//crates:BUILD.dlib-0.5.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dns-lookup-3.0.1\",\n sha256 = \"6e39034cee21a2f5bbb66ba0e3689819c4bb5d00382a282006e802a7ffa6c41d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dns-lookup/3.0.1/download\"],\n strip_prefix = \"dns-lookup-3.0.1\",\n build_file = Label(\"@crates//crates:BUILD.dns-lookup-3.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__downcast-rs-1.2.1\",\n sha256 = \"75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/downcast-rs/1.2.1/download\"],\n strip_prefix = \"downcast-rs-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.downcast-rs-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__drm-0.14.1\",\n sha256 = \"80bc8c5c6c2941f70a55c15f8d9f00f9710ebda3ffda98075f996a0e6c92756f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/drm/0.14.1/download\"],\n strip_prefix = \"drm-0.14.1\",\n build_file = Label(\"@crates//crates:BUILD.drm-0.14.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__drm-0.15.0\",\n sha256 = \"7a41816e58f47f49acfd956651055ddcf137c4882c2098c30c448817af21183a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/drm/0.15.0/download\"],\n strip_prefix = \"drm-0.15.0\",\n build_file = Label(\"@crates//crates:BUILD.drm-0.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__drm-ffi-0.9.1\",\n sha256 = \"51a91c9b32ac4e8105dec255e849e0d66e27d7c34d184364fb93e469db08f690\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/drm-ffi/0.9.1/download\"],\n strip_prefix = \"drm-ffi-0.9.1\",\n build_file = Label(\"@crates//crates:BUILD.drm-ffi-0.9.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__drm-fourcc-2.2.0\",\n sha256 = \"0aafbcdb8afc29c1a7ee5fbe53b5d62f4565b35a042a662ca9fecd0b54dae6f4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/drm-fourcc/2.2.0/download\"],\n strip_prefix = \"drm-fourcc-2.2.0\",\n build_file = Label(\"@crates//crates:BUILD.drm-fourcc-2.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__drm-sys-0.8.1\",\n sha256 = \"ecc8e1361066d91f5ffccff060a3c3be9c3ecde15be2959c1937595f7a82a9f8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/drm-sys/0.8.1/download\"],\n strip_prefix = \"drm-sys-0.8.1\",\n build_file = Label(\"@crates//crates:BUILD.drm-sys-0.8.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dtls-0.17.2\",\n sha256 = \"01a431e87fc386bd5e02deb554a013f97bc406e47a7d8e97efb7c6366b980e9c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dtls/0.17.2/download\"],\n strip_prefix = \"dtls-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.dtls-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dunce-1.0.5\",\n sha256 = \"92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dunce/1.0.5/download\"],\n strip_prefix = \"dunce-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.dunce-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__dyn-clone-1.0.20\",\n sha256 = \"d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/dyn-clone/1.0.20/download\"],\n strip_prefix = \"dyn-clone-1.0.20\",\n build_file = Label(\"@crates//crates:BUILD.dyn-clone-1.0.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ecb-0.1.2\",\n sha256 = \"1a8bfa975b1aec2145850fcaa1c6fe269a16578c44705a532ae3edc92b8881c7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ecb/0.1.2/download\"],\n strip_prefix = \"ecb-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.ecb-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ecdsa-0.16.9\",\n sha256 = \"ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ecdsa/0.16.9/download\"],\n strip_prefix = \"ecdsa-0.16.9\",\n build_file = Label(\"@crates//crates:BUILD.ecdsa-0.16.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__either-1.18.0\",\n sha256 = \"252afb9ae5eaa683babdc6a068b3f5726eb19e05070c731f9b2a23a7c3e8ed34\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/either/1.18.0/download\"],\n strip_prefix = \"either-1.18.0\",\n build_file = Label(\"@crates//crates:BUILD.either-1.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__elliptic-curve-0.13.8\",\n sha256 = \"b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/elliptic-curve/0.13.8/download\"],\n strip_prefix = \"elliptic-curve-0.13.8\",\n build_file = Label(\"@crates//crates:BUILD.elliptic-curve-0.13.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__encode_unicode-1.0.0\",\n sha256 = \"34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/encode_unicode/1.0.0/download\"],\n strip_prefix = \"encode_unicode-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.encode_unicode-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__encoding_rs-0.8.35\",\n sha256 = \"75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/encoding_rs/0.8.35/download\"],\n strip_prefix = \"encoding_rs-0.8.35\",\n build_file = Label(\"@crates//crates:BUILD.encoding_rs-0.8.35.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__encoding_rs_io-0.1.8\",\n sha256 = \"fba3fe847045ecff794b9c138293a80db914678c453ad63fbf0c6a9eb6e00b22\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/encoding_rs_io/0.1.8/download\"],\n strip_prefix = \"encoding_rs_io-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.encoding_rs_io-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__endi-1.1.1\",\n sha256 = \"66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/endi/1.1.1/download\"],\n strip_prefix = \"endi-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.endi-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__enigo-0.6.1\",\n sha256 = \"71c6c56e50f7acae2906a0dcbb34529ca647e40421119ad5d12e7f8ba6e50010\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/enigo/0.6.1/download\"],\n strip_prefix = \"enigo-0.6.1\",\n build_file = Label(\"@crates//crates:BUILD.enigo-0.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__enumflags2-0.7.12\",\n sha256 = \"1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/enumflags2/0.7.12/download\"],\n strip_prefix = \"enumflags2-0.7.12\",\n build_file = Label(\"@crates//crates:BUILD.enumflags2-0.7.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__enumflags2_derive-0.7.12\",\n sha256 = \"67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/enumflags2_derive/0.7.12/download\"],\n strip_prefix = \"enumflags2_derive-0.7.12\",\n build_file = Label(\"@crates//crates:BUILD.enumflags2_derive-0.7.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__env_filter-2.0.0\",\n sha256 = \"900d271a03799a1ee8d1ca9b19893b48ca674a9284fefcfb85f05e74ed314217\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/env_filter/2.0.0/download\"],\n strip_prefix = \"env_filter-2.0.0\",\n build_file = Label(\"@crates//crates:BUILD.env_filter-2.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__env_logger-0.11.11\",\n sha256 = \"de671bd27a75a797dc9ae289ba1e77276e75e2026408aab65185384e2d5cd3f6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/env_logger/0.11.11/download\"],\n strip_prefix = \"env_logger-0.11.11\",\n build_file = Label(\"@crates//crates:BUILD.env_logger-0.11.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__equivalent-1.0.2\",\n sha256 = \"877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/equivalent/1.0.2/download\"],\n strip_prefix = \"equivalent-1.0.2\",\n build_file = Label(\"@crates//crates:BUILD.equivalent-1.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__errno-0.3.14\",\n sha256 = \"39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/errno/0.3.14/download\"],\n strip_prefix = \"errno-0.3.14\",\n build_file = Label(\"@crates//crates:BUILD.errno-0.3.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__error-code-3.4.0\",\n sha256 = \"0b5343afd4a8365a643ac588dab4cf234a190c7f6c88c9f6dd6ffe00837661b7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/error-code/3.4.0/download\"],\n strip_prefix = \"error-code-3.4.0\",\n build_file = Label(\"@crates//crates:BUILD.error-code-3.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__etcetera-0.11.0\",\n sha256 = \"de48cc4d1c1d97a20fd819def54b890cadde72ed3ad0c614822a0a433361be96\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/etcetera/0.11.0/download\"],\n strip_prefix = \"etcetera-0.11.0\",\n build_file = Label(\"@crates//crates:BUILD.etcetera-0.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__euclid-0.22.14\",\n sha256 = \"f1a05365e3b1c6d1650318537c7460c6923f1abdd272ad6842baa2b509957a06\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/euclid/0.22.14/download\"],\n strip_prefix = \"euclid-0.22.14\",\n build_file = Label(\"@crates//crates:BUILD.euclid-0.22.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__event-listener-5.4.2\",\n sha256 = \"5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/event-listener/5.4.2/download\"],\n strip_prefix = \"event-listener-5.4.2\",\n build_file = Label(\"@crates//crates:BUILD.event-listener-5.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__event-listener-strategy-0.5.4\",\n sha256 = \"8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/event-listener-strategy/0.5.4/download\"],\n strip_prefix = \"event-listener-strategy-0.5.4\",\n build_file = Label(\"@crates//crates:BUILD.event-listener-strategy-0.5.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__faccess-0.2.4\",\n sha256 = \"59ae66425802d6a903e268ae1a08b8c38ba143520f227a205edf4e9c7e3e26d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/faccess/0.2.4/download\"],\n strip_prefix = \"faccess-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.faccess-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fancy-regex-0.16.2\",\n sha256 = \"998b056554fbe42e03ae0e152895cd1a7e1002aec800fdc6635d20270260c46f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fancy-regex/0.16.2/download\"],\n strip_prefix = \"fancy-regex-0.16.2\",\n build_file = Label(\"@crates//crates:BUILD.fancy-regex-0.16.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fancy-regex-0.17.0\",\n sha256 = \"72cf461f865c862bb7dc573f643dd6a2b6842f7c30b07882b56bd148cc2761b8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fancy-regex/0.17.0/download\"],\n strip_prefix = \"fancy-regex-0.17.0\",\n build_file = Label(\"@crates//crates:BUILD.fancy-regex-0.17.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__faster-hex-0.10.0\",\n sha256 = \"7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/faster-hex/0.10.0/download\"],\n strip_prefix = \"faster-hex-0.10.0\",\n build_file = Label(\"@crates//crates:BUILD.faster-hex-0.10.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fastrand-2.5.0\",\n sha256 = \"da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fastrand/2.5.0/download\"],\n strip_prefix = \"fastrand-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.fastrand-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fax-0.2.7\",\n sha256 = \"caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fax/0.2.7/download\"],\n strip_prefix = \"fax-0.2.7\",\n build_file = Label(\"@crates//crates:BUILD.fax-0.2.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fdeflate-0.3.7\",\n sha256 = \"1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fdeflate/0.3.7/download\"],\n strip_prefix = \"fdeflate-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.fdeflate-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ff-0.13.1\",\n sha256 = \"c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ff/0.13.1/download\"],\n strip_prefix = \"ff-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.ff-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fiat-crypto-0.2.9\",\n sha256 = \"28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fiat-crypto/0.2.9/download\"],\n strip_prefix = \"fiat-crypto-0.2.9\",\n build_file = Label(\"@crates//crates:BUILD.fiat-crypto-0.2.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__filedescriptor-0.8.3\",\n sha256 = \"e40758ed24c9b2eeb76c35fb0aebc66c626084edd827e07e1552279814c6682d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/filedescriptor/0.8.3/download\"],\n strip_prefix = \"filedescriptor-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.filedescriptor-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__filetime-0.2.29\",\n sha256 = \"5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/filetime/0.2.29/download\"],\n strip_prefix = \"filetime-0.2.29\",\n build_file = Label(\"@crates//crates:BUILD.filetime-0.2.29.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__find-msvc-tools-0.1.11\",\n sha256 = \"d45db016d36b838f563236e9193d0ee6ce38f3f68b6c94e914b4929c96bbb890\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/find-msvc-tools/0.1.11/download\"],\n strip_prefix = \"find-msvc-tools-0.1.11\",\n build_file = Label(\"@crates//crates:BUILD.find-msvc-tools-0.1.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fixed_decimal-0.7.2\",\n sha256 = \"79c3c892f121fff406e5dd6b28c1b30096b95111c30701a899d4f2b18da6d1bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fixed_decimal/0.7.2/download\"],\n strip_prefix = \"fixed_decimal-0.7.2\",\n build_file = Label(\"@crates//crates:BUILD.fixed_decimal-0.7.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fixedbitset-0.5.7\",\n sha256 = \"1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fixedbitset/0.5.7/download\"],\n strip_prefix = \"fixedbitset-0.5.7\",\n build_file = Label(\"@crates//crates:BUILD.fixedbitset-0.5.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__flate2-1.1.9\",\n sha256 = \"843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/flate2/1.1.9/download\"],\n strip_prefix = \"flate2-1.1.9\",\n build_file = Label(\"@crates//crates:BUILD.flate2-1.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__float-cmp-0.9.0\",\n sha256 = \"98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/float-cmp/0.9.0/download\"],\n strip_prefix = \"float-cmp-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.float-cmp-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-0.17.0\",\n sha256 = \"8137a6d5a2c50d6b0ebfcb9aaa91a28154e0a70605f112d30cb0cd4a78670477\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent/0.17.0/download\"],\n strip_prefix = \"fluent-0.17.0\",\n build_file = Label(\"@crates//crates:BUILD.fluent-0.17.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-bundle-0.16.0\",\n sha256 = \"01203cb8918f5711e73891b347816d932046f95f54207710bda99beaeb423bf4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent-bundle/0.16.0/download\"],\n strip_prefix = \"fluent-bundle-0.16.0\",\n build_file = Label(\"@crates//crates:BUILD.fluent-bundle-0.16.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-langneg-0.13.1\",\n sha256 = \"7eebbe59450baee8282d71676f3bfed5689aeab00b27545e83e5f14b1195e8b0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent-langneg/0.13.1/download\"],\n strip_prefix = \"fluent-langneg-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.fluent-langneg-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fluent-syntax-0.12.0\",\n sha256 = \"54f0d287c53ffd184d04d8677f590f4ac5379785529e5e08b1c8083acdd5c198\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fluent-syntax/0.12.0/download\"],\n strip_prefix = \"fluent-syntax-0.12.0\",\n build_file = Label(\"@crates//crates:BUILD.fluent-syntax-0.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__flume-0.11.1\",\n sha256 = \"da0e4dd2a88388a1f4ccc7c9ce104604dab68d9f408dc34cd45823d5a9069095\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/flume/0.11.1/download\"],\n strip_prefix = \"flume-0.11.1\",\n build_file = Label(\"@crates//crates:BUILD.flume-0.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fnv-1.0.7\",\n sha256 = \"3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fnv/1.0.7/download\"],\n strip_prefix = \"fnv-1.0.7\",\n build_file = Label(\"@crates//crates:BUILD.fnv-1.0.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.1.5\",\n sha256 = \"d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.1.5/download\"],\n strip_prefix = \"foldhash-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foldhash-0.2.0\",\n sha256 = \"77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foldhash/0.2.0/download\"],\n strip_prefix = \"foldhash-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.foldhash-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__font-types-0.12.4\",\n sha256 = \"e64eb721ca85a34323425f4041adc5d82704d3782d5f8f03793bc012419dce23\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/font-types/0.12.4/download\"],\n strip_prefix = \"font-types-0.12.4\",\n build_file = Label(\"@crates//crates:BUILD.font-types-0.12.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fontconfig-parser-0.5.8\",\n sha256 = \"bbc773e24e02d4ddd8395fd30dc147524273a83e54e0f312d986ea30de5f5646\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fontconfig-parser/0.5.8/download\"],\n strip_prefix = \"fontconfig-parser-0.5.8\",\n build_file = Label(\"@crates//crates:BUILD.fontconfig-parser-0.5.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fontdb-0.24.0\",\n sha256 = \"2660c5e9157bf76d2db1294e4a9feba604ef610819a3b591088d0d8392a3290f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fontdb/0.24.0/download\"],\n strip_prefix = \"fontdb-0.24.0\",\n build_file = Label(\"@crates//crates:BUILD.fontdb-0.24.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fontdue-0.9.4\",\n sha256 = \"7894823fa221401399e2598f8b63f81ac77ff5c63248b7656779bff1632d7d3d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fontdue/0.9.4/download\"],\n strip_prefix = \"fontdue-0.9.4\",\n build_file = Label(\"@crates//crates:BUILD.fontdue-0.9.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foreign-types-0.5.0\",\n sha256 = \"d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foreign-types/0.5.0/download\"],\n strip_prefix = \"foreign-types-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.foreign-types-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foreign-types-macros-0.2.4\",\n sha256 = \"ea5190182e6915eb873ddbc16e23b711b6eb1f9c00a0d0a3a91b5f6228475225\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foreign-types-macros/0.2.4/download\"],\n strip_prefix = \"foreign-types-macros-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.foreign-types-macros-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__foreign-types-shared-0.3.1\",\n sha256 = \"aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/foreign-types-shared/0.3.1/download\"],\n strip_prefix = \"foreign-types-shared-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.foreign-types-shared-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__form_urlencoded-1.2.2\",\n sha256 = \"cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/form_urlencoded/1.2.2/download\"],\n strip_prefix = \"form_urlencoded-1.2.2\",\n build_file = Label(\"@crates//crates:BUILD.form_urlencoded-1.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fs_extra-1.3.0\",\n sha256 = \"42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fs_extra/1.3.0/download\"],\n strip_prefix = \"fs_extra-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.fs_extra-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__fsevent-sys-4.1.0\",\n sha256 = \"76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/fsevent-sys/4.1.0/download\"],\n strip_prefix = \"fsevent-sys-4.1.0\",\n build_file = Label(\"@crates//crates:BUILD.fsevent-sys-4.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__funty-2.0.0\",\n sha256 = \"e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/funty/2.0.0/download\"],\n strip_prefix = \"funty-2.0.0\",\n build_file = Label(\"@crates//crates:BUILD.funty-2.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-0.3.34\",\n sha256 = \"9a31d2a3fbaaeb2af2368bbdd904aa8e812d3c04a1ee10d3171f52d556e5d0a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures/0.3.34/download\"],\n strip_prefix = \"futures-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-channel-0.3.34\",\n sha256 = \"b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-channel/0.3.34/download\"],\n strip_prefix = \"futures-channel-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-channel-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-core-0.3.34\",\n sha256 = \"92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-core/0.3.34/download\"],\n strip_prefix = \"futures-core-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-core-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-executor-0.3.34\",\n sha256 = \"031b47cf1a3c6cc8bc2fc76cd437f521619387907d469316e7c0bc278f1f5432\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-executor/0.3.34/download\"],\n strip_prefix = \"futures-executor-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-executor-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-io-0.3.34\",\n sha256 = \"53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-io/0.3.34/download\"],\n strip_prefix = \"futures-io-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-io-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-lite-2.6.1\",\n sha256 = \"f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-lite/2.6.1/download\"],\n strip_prefix = \"futures-lite-2.6.1\",\n build_file = Label(\"@crates//crates:BUILD.futures-lite-2.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-macro-0.3.34\",\n sha256 = \"9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-macro/0.3.34/download\"],\n strip_prefix = \"futures-macro-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-macro-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-sink-0.3.34\",\n sha256 = \"1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-sink/0.3.34/download\"],\n strip_prefix = \"futures-sink-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-sink-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-task-0.3.34\",\n sha256 = \"cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-task/0.3.34/download\"],\n strip_prefix = \"futures-task-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-task-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__futures-util-0.3.34\",\n sha256 = \"0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/futures-util/0.3.34/download\"],\n strip_prefix = \"futures-util-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.futures-util-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gbm-0.18.0\",\n sha256 = \"ce852e998d3ca5e4a97014fb31c940dc5ef344ec7d364984525fd11e8a547e6a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gbm/0.18.0/download\"],\n strip_prefix = \"gbm-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.gbm-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gbm-sys-0.4.0\",\n sha256 = \"c13a5f2acc785d8fb6bf6b7ab6bfb0ef5dad4f4d97e8e70bb8e470722312f76f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gbm-sys/0.4.0/download\"],\n strip_prefix = \"gbm-sys-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.gbm-sys-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__generic-array-0.14.7\",\n sha256 = \"85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/generic-array/0.14.7/download\"],\n strip_prefix = \"generic-array-0.14.7\",\n build_file = Label(\"@crates//crates:BUILD.generic-array-0.14.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gethostname-1.1.0\",\n sha256 = \"1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gethostname/1.1.0/download\"],\n strip_prefix = \"gethostname-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.gethostname-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.2.17\",\n sha256 = \"ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.2.17/download\"],\n strip_prefix = \"getrandom-0.2.17\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.2.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.3.4\",\n sha256 = \"899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.3.4/download\"],\n strip_prefix = \"getrandom-0.3.4\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.3.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__getrandom-0.4.3\",\n sha256 = \"300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/getrandom/0.4.3/download\"],\n strip_prefix = \"getrandom-0.4.3\",\n build_file = Label(\"@crates//crates:BUILD.getrandom-0.4.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ghash-0.5.1\",\n sha256 = \"f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ghash/0.5.1/download\"],\n strip_prefix = \"ghash-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.ghash-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gif-0.14.2\",\n sha256 = \"ee8cfcc411d9adbbaba82fb72661cc1bcca13e8bba98b364e62b2dba8f960159\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gif/0.14.2/download\"],\n strip_prefix = \"gif-0.14.2\",\n build_file = Label(\"@crates//crates:BUILD.gif-0.14.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-0.85.0\",\n sha256 = \"fa8b2e38ebfc4484dfef8580ddcaf8abb7285e6f3eb6413ff6775d104ae96ca6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix/0.85.0/download\"],\n strip_prefix = \"gix-0.85.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-0.85.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-actor-0.41.2\",\n sha256 = \"33f9308ad6fd35b2a865cbe4117ac61b2be59e4a9ef1621c7a9794f7c8e52c5b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-actor/0.41.2/download\"],\n strip_prefix = \"gix-actor-0.41.2\",\n build_file = Label(\"@crates//crates:BUILD.gix-actor-0.41.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-attributes-0.33.2\",\n sha256 = \"39b40888d0ed415c0744a6cdc61eebf0304c9d26ab726725b718443c322e5ba4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-attributes/0.33.2/download\"],\n strip_prefix = \"gix-attributes-0.33.2\",\n build_file = Label(\"@crates//crates:BUILD.gix-attributes-0.33.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-bitmap-0.3.3\",\n sha256 = \"7cd1d118d0f5d88b96e6f6e13b566475fef4797ead4a02c26fed36c1375066f7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-bitmap/0.3.3/download\"],\n strip_prefix = \"gix-bitmap-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.gix-bitmap-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-chunk-0.7.3\",\n sha256 = \"b2a871e5cab12ba568845714473505deefffb3c04eb47f4708ce344cd459c1cc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-chunk/0.7.3/download\"],\n strip_prefix = \"gix-chunk-0.7.3\",\n build_file = Label(\"@crates//crates:BUILD.gix-chunk-0.7.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-command-0.9.2\",\n sha256 = \"cf4363accdf6ef7ba861871d2d521ab7418a04aaaed919fadb022af71d379b12\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-command/0.9.2/download\"],\n strip_prefix = \"gix-command-0.9.2\",\n build_file = Label(\"@crates//crates:BUILD.gix-command-0.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-commitgraph-0.37.1\",\n sha256 = \"7f675d0df484a7f6a47e64bd6f311af489d947c0323b0564f36d14f3d7762abb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-commitgraph/0.37.1/download\"],\n strip_prefix = \"gix-commitgraph-0.37.1\",\n build_file = Label(\"@crates//crates:BUILD.gix-commitgraph-0.37.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-config-0.58.0\",\n sha256 = \"a29bf266c4cdaf759e535c24ad4ce655b987aeb6911075643403cc7cc5ade583\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-config/0.58.0/download\"],\n strip_prefix = \"gix-config-0.58.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-config-0.58.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-config-value-0.18.1\",\n sha256 = \"ed42168329552f6c2e5df09665c104199d45d84bedb53683738a49b57fe1baab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-config-value/0.18.1/download\"],\n strip_prefix = \"gix-config-value-0.18.1\",\n build_file = Label(\"@crates//crates:BUILD.gix-config-value-0.18.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-date-0.15.6\",\n sha256 = \"7e47b9e8cdc688296609b706428de570f88b1e0eed7156dde7b4a89d26fa4567\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-date/0.15.6/download\"],\n strip_prefix = \"gix-date-0.15.6\",\n build_file = Label(\"@crates//crates:BUILD.gix-date-0.15.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-diff-0.65.0\",\n sha256 = \"92c6d56c94edf92d78203a1cd416f770e35e10b6955ede6b9d7d0c22ff88a5f3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-diff/0.65.0/download\"],\n strip_prefix = \"gix-diff-0.65.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-diff-0.65.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-dir-0.27.0\",\n sha256 = \"20098fba2b9c6e29361ccb4c0379d42dfb81fc7f86f7ab11f2dff4528c0bf01f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-dir/0.27.0/download\"],\n strip_prefix = \"gix-dir-0.27.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-dir-0.27.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-discover-0.53.0\",\n sha256 = \"d624d5b23b10c1d85337645227abe353ac95ab8ff66a7bdd5ce689b2db33a722\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-discover/0.53.0/download\"],\n strip_prefix = \"gix-discover-0.53.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-discover-0.53.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-error-0.2.5\",\n sha256 = \"4a9292309fd944e71b2a3c96d3c03a6feb8852db646febdde7cbb9f79cb5f329\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-error/0.2.5/download\"],\n strip_prefix = \"gix-error-0.2.5\",\n build_file = Label(\"@crates//crates:BUILD.gix-error-0.2.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-features-0.48.1\",\n sha256 = \"1849ae154d38bc403185be14fa871e38e3c93ee606875d94e207fdb9fba52dbc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-features/0.48.1/download\"],\n strip_prefix = \"gix-features-0.48.1\",\n build_file = Label(\"@crates//crates:BUILD.gix-features-0.48.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-filter-0.32.0\",\n sha256 = \"6644fb2ef97928c278675b239f366b457103d7e436f811d27331a8daf212759c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-filter/0.32.0/download\"],\n strip_prefix = \"gix-filter-0.32.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-filter-0.32.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-fs-0.21.2\",\n sha256 = \"6cdff46db8798e47e2f727d84b9379aac5add3dd3d9d0b07bb4d7d5d640771fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-fs/0.21.2/download\"],\n strip_prefix = \"gix-fs-0.21.2\",\n build_file = Label(\"@crates//crates:BUILD.gix-fs-0.21.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-glob-0.26.1\",\n sha256 = \"d1fcb8ef5b16bcf874abe9b68d8abb3c0493c876d367ab824151f30a0f3f3756\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-glob/0.26.1/download\"],\n strip_prefix = \"gix-glob-0.26.1\",\n build_file = Label(\"@crates//crates:BUILD.gix-glob-0.26.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-hash-0.25.1\",\n sha256 = \"cb0926d3819c837750b4e03c7754901e73f68b8c9b690753a6372a1bed4eedce\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-hash/0.25.1/download\"],\n strip_prefix = \"gix-hash-0.25.1\",\n build_file = Label(\"@crates//crates:BUILD.gix-hash-0.25.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-hashtable-0.15.2\",\n sha256 = \"7e261d54091f0d1c729bc83f54548c071bdec60a697de1e58e88bdfd7a99d24e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-hashtable/0.15.2/download\"],\n strip_prefix = \"gix-hashtable-0.15.2\",\n build_file = Label(\"@crates//crates:BUILD.gix-hashtable-0.15.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-ignore-0.21.1\",\n sha256 = \"d491bab9bf2c9f341dc754f425c31d5d3f63aca615312167b82e1deeaca97d8d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-ignore/0.21.1/download\"],\n strip_prefix = \"gix-ignore-0.21.1\",\n build_file = Label(\"@crates//crates:BUILD.gix-ignore-0.21.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-imara-diff-0.2.5\",\n sha256 = \"1c91d8cffac8849493a82233811bd02b2b183b8cf39bf704de0fa0841b737595\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-imara-diff/0.2.5/download\"],\n strip_prefix = \"gix-imara-diff-0.2.5\",\n build_file = Label(\"@crates//crates:BUILD.gix-imara-diff-0.2.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-index-0.53.0\",\n sha256 = \"36d45f82ec5a4d7542ea595e9ad16e03e26c8cb4f221e5bc9fcdcf469f63a681\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-index/0.53.0/download\"],\n strip_prefix = \"gix-index-0.53.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-index-0.53.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-lock-23.0.1\",\n sha256 = \"65c9dedd9e90b0d47624d2ed241d394e09294118364e87b9b7e5f1fe755f3c2c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-lock/23.0.1/download\"],\n strip_prefix = \"gix-lock-23.0.1\",\n build_file = Label(\"@crates//crates:BUILD.gix-lock-23.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-merge-0.18.0\",\n sha256 = \"4b529a5dc509175fe277643a1c50b38de69f24b5a50f9c4e7f854c7fc7d1acc7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-merge/0.18.0/download\"],\n strip_prefix = \"gix-merge-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-merge-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-object-0.62.0\",\n sha256 = \"019b38afc3eac1e41f9fe09a327664b313ba4a120fa5f40e3678795d0e42783e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-object/0.62.0/download\"],\n strip_prefix = \"gix-object-0.62.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-object-0.62.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-odb-0.82.0\",\n sha256 = \"7fadc59f6fa0f9dd445eceee61060a2b59ca557f48da9fc677f567db535b782a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-odb/0.82.0/download\"],\n strip_prefix = \"gix-odb-0.82.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-odb-0.82.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-pack-0.72.0\",\n sha256 = \"ca3e7f1726cd2c0cd1cf1fc20be8a8e623f0b163f1f8d6fc836cfb9bc8cd758b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-pack/0.72.0/download\"],\n strip_prefix = \"gix-pack-0.72.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-pack-0.72.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-packetline-0.21.5\",\n sha256 = \"b217dd0ee0c4021ecf169a4a519b1b4f80d15e3f3765f3dc466223dc0ac891d7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-packetline/0.21.5/download\"],\n strip_prefix = \"gix-packetline-0.21.5\",\n build_file = Label(\"@crates//crates:BUILD.gix-packetline-0.21.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-path-0.12.5\",\n sha256 = \"2b075e730586bba7341304d6fc1b4efc1d10cf64532622521c0e07f30e661046\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-path/0.12.5/download\"],\n strip_prefix = \"gix-path-0.12.5\",\n build_file = Label(\"@crates//crates:BUILD.gix-path-0.12.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-pathspec-0.18.1\",\n sha256 = \"3050783b41ee11511e1e8fb35623df81806194f4030395f14f48ea37c2798c9f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-pathspec/0.18.1/download\"],\n strip_prefix = \"gix-pathspec-0.18.1\",\n build_file = Label(\"@crates//crates:BUILD.gix-pathspec-0.18.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-protocol-0.63.0\",\n sha256 = \"978468bae4ea2df20c72db3b20d0bdb548a0c1090b85a83643b553e6e0e041f2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-protocol/0.63.0/download\"],\n strip_prefix = \"gix-protocol-0.63.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-protocol-0.63.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-quote-0.7.2\",\n sha256 = \"a6e541fc33cc2b783b7979040d445a0c86a2eca747c8faea4ca84230d06ae6ef\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-quote/0.7.2/download\"],\n strip_prefix = \"gix-quote-0.7.2\",\n build_file = Label(\"@crates//crates:BUILD.gix-quote-0.7.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-ref-0.65.0\",\n sha256 = \"9bbfbce1dfd7d7f8469ddef6d3518376aff664348f153cbe0fc3e58ef993d24e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-ref/0.65.0/download\"],\n strip_prefix = \"gix-ref-0.65.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-ref-0.65.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-refspec-0.43.0\",\n sha256 = \"7bc36a4fb1a1540b59cf2da498783080743fa274b02a3f19ca444fc4015a9d4f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-refspec/0.43.0/download\"],\n strip_prefix = \"gix-refspec-0.43.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-refspec-0.43.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-revision-0.47.0\",\n sha256 = \"885075c3c21eb9c06e0be3b3728ba5932c04e1c1011dcee7c81801980e3e986f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-revision/0.47.0/download\"],\n strip_prefix = \"gix-revision-0.47.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-revision-0.47.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-revwalk-0.33.0\",\n sha256 = \"8f11fe7ca2585193d3d70bbe0be175a2008d883a704cc7a55e454e113e689455\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-revwalk/0.33.0/download\"],\n strip_prefix = \"gix-revwalk-0.33.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-revwalk-0.33.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-sec-0.14.2\",\n sha256 = \"af4fe6c152c1d50aea36f299825702cd37e303307832fec1d0fdd5844e47ce2f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-sec/0.14.2/download\"],\n strip_prefix = \"gix-sec-0.14.2\",\n build_file = Label(\"@crates//crates:BUILD.gix-sec-0.14.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-shallow-0.12.1\",\n sha256 = \"a292fc2fe548c5dfa575479d16b445b0ddf1dd2f56f1fec6aed386f82553cd97\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-shallow/0.12.1/download\"],\n strip_prefix = \"gix-shallow-0.12.1\",\n build_file = Label(\"@crates//crates:BUILD.gix-shallow-0.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-status-0.32.0\",\n sha256 = \"aec3293f75db1212f99217832cbc70c30faeb95cefc97c7f1a17fd3bcf13a72e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-status/0.32.0/download\"],\n strip_prefix = \"gix-status-0.32.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-status-0.32.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-submodule-0.32.0\",\n sha256 = \"a7f9f594f7cbda0b38ba6b633b3e9a7b7901acdc5d27bc186a16633800cd1ac8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-submodule/0.32.0/download\"],\n strip_prefix = \"gix-submodule-0.32.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-submodule-0.32.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-tempfile-23.0.2\",\n sha256 = \"6ef60812443484e67bf84e444cc71b4c78ae62deb822221774a4fa0c57fdb17f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-tempfile/23.0.2/download\"],\n strip_prefix = \"gix-tempfile-23.0.2\",\n build_file = Label(\"@crates//crates:BUILD.gix-tempfile-23.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-trace-0.1.21\",\n sha256 = \"be3eb81d9dc914335923e50d52829c551feefd6a72d176c4130c546b67a60814\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-trace/0.1.21/download\"],\n strip_prefix = \"gix-trace-0.1.21\",\n build_file = Label(\"@crates//crates:BUILD.gix-trace-0.1.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-transport-0.57.2\",\n sha256 = \"186874f7ad1fb2f9a2f2aa9c2dabc7f9dd087bef74c1a0eee2b4a9cf0248fcb3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-transport/0.57.2/download\"],\n strip_prefix = \"gix-transport-0.57.2\",\n build_file = Label(\"@crates//crates:BUILD.gix-transport-0.57.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-traverse-0.59.0\",\n sha256 = \"5062cca8f2977565bbaf666ec31dbdb9bc9d9293beb65f9bec52e6c1121b62a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-traverse/0.59.0/download\"],\n strip_prefix = \"gix-traverse-0.59.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-traverse-0.59.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-url-0.36.2\",\n sha256 = \"57d68e70e96da0e5f9c871f1566349e0fd0e1a20bb483c7f54af1dd0b85b4b29\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-url/0.36.2/download\"],\n strip_prefix = \"gix-url-0.36.2\",\n build_file = Label(\"@crates//crates:BUILD.gix-url-0.36.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-utils-0.3.6\",\n sha256 = \"0da1c46491b49458a446cc76f0085860f8164c2290742e0aa8c653ce67240a97\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-utils/0.3.6/download\"],\n strip_prefix = \"gix-utils-0.3.6\",\n build_file = Label(\"@crates//crates:BUILD.gix-utils-0.3.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-validate-0.11.4\",\n sha256 = \"4dae8780f63ed8a803b8bdabbd7aa5f5c5d74592c8b50eed875c1bb4f6545a6a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-validate/0.11.4/download\"],\n strip_prefix = \"gix-validate-0.11.4\",\n build_file = Label(\"@crates//crates:BUILD.gix-validate-0.11.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-worktree-0.54.0\",\n sha256 = \"92399ed66f259592050c6ed9dc80105e095a2f8e87e6b83d98aa2e21d8e27036\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-worktree/0.54.0/download\"],\n strip_prefix = \"gix-worktree-0.54.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-worktree-0.54.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-worktree-state-0.32.0\",\n sha256 = \"c0f926b6a249bdb0086b307c704b7abd9d643e08f98040efe6467f00bb6d2ef5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-worktree-state/0.32.0/download\"],\n strip_prefix = \"gix-worktree-state-0.32.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-worktree-state-0.32.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gix-worktree-stream-0.34.0\",\n sha256 = \"55f3a878c89a05470ad98c644b0015777c530da24854dd29e41fe4f41176840f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gix-worktree-stream/0.34.0/download\"],\n strip_prefix = \"gix-worktree-stream-0.34.0\",\n build_file = Label(\"@crates//crates:BUILD.gix-worktree-stream-0.34.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gl-0.14.0\",\n sha256 = \"a94edab108827d67608095e269cf862e60d920f144a5026d3dbcfd8b877fb404\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gl/0.14.0/download\"],\n strip_prefix = \"gl-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.gl-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__gl_generator-0.14.0\",\n sha256 = \"1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/gl_generator/0.14.0/download\"],\n strip_prefix = \"gl_generator-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.gl_generator-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__glob-0.3.4\",\n sha256 = \"e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/glob/0.3.4/download\"],\n strip_prefix = \"glob-0.3.4\",\n build_file = Label(\"@crates//crates:BUILD.glob-0.3.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__globset-0.4.20\",\n sha256 = \"07c34a9410465b45bd9787443bc7370f37735bad04b0f0cd57ff1a3186c98988\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/globset/0.4.20/download\"],\n strip_prefix = \"globset-0.4.20\",\n build_file = Label(\"@crates//crates:BUILD.globset-0.4.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-cli-0.1.12\",\n sha256 = \"cf32d263c5d5cc2a23ce587097f5ddafdb188492ba2e6fb638eaccdc22453631\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-cli/0.1.12/download\"],\n strip_prefix = \"grep-cli-0.1.12\",\n build_file = Label(\"@crates//crates:BUILD.grep-cli-0.1.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-matcher-0.1.9\",\n sha256 = \"f9417543f4870fc8f1c8e1af870afae2431007626d9e703fce6471c468d33847\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-matcher/0.1.9/download\"],\n strip_prefix = \"grep-matcher-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.grep-matcher-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-pcre2-0.1.10\",\n sha256 = \"b752bb6f57dd3716e55b63a33ca05b5825c3d66cd427468874a5564af6ca365c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-pcre2/0.1.10/download\"],\n strip_prefix = \"grep-pcre2-0.1.10\",\n build_file = Label(\"@crates//crates:BUILD.grep-pcre2-0.1.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-printer-0.3.1\",\n sha256 = \"fd76035e87871f51c1ee5b793e32122b3ccf9c692662d9622ef1686ff5321acb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-printer/0.3.1/download\"],\n strip_prefix = \"grep-printer-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.grep-printer-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-regex-0.1.14\",\n sha256 = \"0ce0c256c3ad82bcc07b812c15a45ec1d398122e8e15124f96695234db7112ef\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-regex/0.1.14/download\"],\n strip_prefix = \"grep-regex-0.1.14\",\n build_file = Label(\"@crates//crates:BUILD.grep-regex-0.1.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__grep-searcher-0.1.17\",\n sha256 = \"72348823a0eafc4bc2e9051064f28b5b42cc100b571b3a35d67918d711efcbc6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/grep-searcher/0.1.17/download\"],\n strip_prefix = \"grep-searcher-0.1.17\",\n build_file = Label(\"@crates//crates:BUILD.grep-searcher-0.1.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__group-0.13.0\",\n sha256 = \"f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/group/0.13.0/download\"],\n strip_prefix = \"group-0.13.0\",\n build_file = Label(\"@crates//crates:BUILD.group-0.13.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__half-2.7.1\",\n sha256 = \"6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/half/2.7.1/download\"],\n strip_prefix = \"half-2.7.1\",\n build_file = Label(\"@crates//crates:BUILD.half-2.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__harfrust-0.12.0\",\n sha256 = \"c03d949a14aa089bbb282f7dd76a498a7f684428e4257202efc119ec010376f9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/harfrust/0.12.0/download\"],\n strip_prefix = \"harfrust-0.12.0\",\n build_file = Label(\"@crates//crates:BUILD.harfrust-0.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hash32-0.3.1\",\n sha256 = \"47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hash32/0.3.1/download\"],\n strip_prefix = \"hash32-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.hash32-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.14.5\",\n sha256 = \"e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.14.5/download\"],\n strip_prefix = \"hashbrown-0.14.5\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.14.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.15.5\",\n sha256 = \"9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.15.5/download\"],\n strip_prefix = \"hashbrown-0.15.5\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.15.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.16.1\",\n sha256 = \"841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.16.1/download\"],\n strip_prefix = \"hashbrown-0.16.1\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.16.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hashbrown-0.17.1\",\n sha256 = \"ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hashbrown/0.17.1/download\"],\n strip_prefix = \"hashbrown-0.17.1\",\n build_file = Label(\"@crates//crates:BUILD.hashbrown-0.17.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__heapless-0.8.0\",\n sha256 = \"0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/heapless/0.8.0/download\"],\n strip_prefix = \"heapless-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.heapless-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__heapless-0.9.3\",\n sha256 = \"25ba4bd83f9415b58b4ed8dc5714c76e626a105be4646c02630ad730ad3b5aa4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/heapless/0.9.3/download\"],\n strip_prefix = \"heapless-0.9.3\",\n build_file = Label(\"@crates//crates:BUILD.heapless-0.9.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__heck-0.5.0\",\n sha256 = \"2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/heck/0.5.0/download\"],\n strip_prefix = \"heck-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.heck-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hermit-abi-0.5.2\",\n sha256 = \"fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hermit-abi/0.5.2/download\"],\n strip_prefix = \"hermit-abi-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.hermit-abi-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hex-0.4.3\",\n sha256 = \"7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hex/0.4.3/download\"],\n strip_prefix = \"hex-0.4.3\",\n build_file = Label(\"@crates//crates:BUILD.hex-0.4.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hifijson-0.2.3\",\n sha256 = \"0a7763b98ba8a24f59e698bf9ab197e7676c640d6455d1580b4ce7dc560f0f0d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hifijson/0.2.3/download\"],\n strip_prefix = \"hifijson-0.2.3\",\n build_file = Label(\"@crates//crates:BUILD.hifijson-0.2.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hkdf-0.12.4\",\n sha256 = \"7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hkdf/0.12.4/download\"],\n strip_prefix = \"hkdf-0.12.4\",\n build_file = Label(\"@crates//crates:BUILD.hkdf-0.12.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hmac-0.12.1\",\n sha256 = \"6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hmac/0.12.1/download\"],\n strip_prefix = \"hmac-0.12.1\",\n build_file = Label(\"@crates//crates:BUILD.hmac-0.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hostname-0.4.2\",\n sha256 = \"617aaa3557aef3810a6369d0a99fac8a080891b68bd9f9812a1eeda0c0730cbd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hostname/0.4.2/download\"],\n strip_prefix = \"hostname-0.4.2\",\n build_file = Label(\"@crates//crates:BUILD.hostname-0.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__html-escape-0.2.15\",\n sha256 = \"c9356095b4b41197bba32173600e1582792cda618f65d12f68e2e77d273413c5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/html-escape/0.2.15/download\"],\n strip_prefix = \"html-escape-0.2.15\",\n build_file = Label(\"@crates//crates:BUILD.html-escape-0.2.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__html-to-markdown-rs-3.11.4\",\n sha256 = \"6331a4c21bc99309e5863092660c08505c426eb1158e0472013487ecff85412b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/html-to-markdown-rs/3.11.4/download\"],\n strip_prefix = \"html-to-markdown-rs-3.11.4\",\n build_file = Label(\"@crates//crates:BUILD.html-to-markdown-rs-3.11.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__html5ever-0.39.0\",\n sha256 = \"46a1761807faccc9a19e86944bbf40610014066306f96edcdedc2fb714bcb7b8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/html5ever/0.39.0/download\"],\n strip_prefix = \"html5ever-0.39.0\",\n build_file = Label(\"@crates//crates:BUILD.html5ever-0.39.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__hybrid-array-0.4.14\",\n sha256 = \"707114b52a152fa7bdb290cd7cd5912d9467273b6d74e21b8d81aca1f8533f6b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/hybrid-array/0.4.14/download\"],\n strip_prefix = \"hybrid-array-0.4.14\",\n build_file = Label(\"@crates//crates:BUILD.hybrid-array-0.4.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__iana-time-zone-0.1.65\",\n sha256 = \"e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/iana-time-zone/0.1.65/download\"],\n strip_prefix = \"iana-time-zone-0.1.65\",\n build_file = Label(\"@crates//crates:BUILD.iana-time-zone-0.1.65.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__iana-time-zone-haiku-0.1.2\",\n sha256 = \"f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/iana-time-zone-haiku/0.1.2/download\"],\n strip_prefix = \"iana-time-zone-haiku-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.iana-time-zone-haiku-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_calendar-2.3.0\",\n sha256 = \"58655df2f728e46e4eee80bddebefacf52ec3e77cdb925014b47c5a5905eb55c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_calendar/2.3.0/download\"],\n strip_prefix = \"icu_calendar-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_calendar-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_calendar_data-2.3.0\",\n sha256 = \"dc00caaa3fb3201ff7a18aa458e8c3ab042b9da154cfdf948bdde3936c31c36e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_calendar_data/2.3.0/download\"],\n strip_prefix = \"icu_calendar_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_calendar_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_collator-2.3.1\",\n sha256 = \"08984ed58ac439ebf3e13d2cf26b0c46a60afcd21721c1d14087c0b240344dda\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_collator/2.3.1/download\"],\n strip_prefix = \"icu_collator-2.3.1\",\n build_file = Label(\"@crates//crates:BUILD.icu_collator-2.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_collator_data-2.3.0\",\n sha256 = \"f7d7e54efdddeb1208c08dd5d32b53a879ac00d2d3d051b2255fd26821d16368\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_collator_data/2.3.0/download\"],\n strip_prefix = \"icu_collator_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_collator_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_collections-2.3.0\",\n sha256 = \"fa68d21081c4a05d5a901a1c62add574c77048b6a1c67be3b50ce0b60d4ca513\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_collections/2.3.0/download\"],\n strip_prefix = \"icu_collections-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_collections-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_datetime-2.3.0\",\n sha256 = \"c44df99c4c5297b05653d1a1629f13bdc9fd4044acfbbaf30b15194a1eed4cd6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_datetime/2.3.0/download\"],\n strip_prefix = \"icu_datetime-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_datetime-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_datetime_data-2.3.0\",\n sha256 = \"8bb5555f6e4b42233f58564351ce16d73e9e6ebfce6bdcf29875d0cfc554d6a8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_datetime_data/2.3.0/download\"],\n strip_prefix = \"icu_datetime_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_datetime_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_decimal-2.3.0\",\n sha256 = \"9eb8f655bba2d0c0459e43a5b0e6cd3cd388109898fb3d85d048165e8b0abd08\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_decimal/2.3.0/download\"],\n strip_prefix = \"icu_decimal-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_decimal-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_decimal_data-2.3.0\",\n sha256 = \"e4c887fc7d4c297cf3f9436864af9e3dba7f8be9415a6c2a7f392f3b1636298c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_decimal_data/2.3.0/download\"],\n strip_prefix = \"icu_decimal_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_decimal_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_locale-2.3.1\",\n sha256 = \"785f595c61ef57169a467eeed7b4b6936a66f6cacbb116a96ee86da983251bf4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_locale/2.3.1/download\"],\n strip_prefix = \"icu_locale-2.3.1\",\n build_file = Label(\"@crates//crates:BUILD.icu_locale-2.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_locale_core-2.3.0\",\n sha256 = \"d56e28588da92eee5c3201a6eff33fabdd49b62269c8938d4ff050ce4d900deb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_locale_core/2.3.0/download\"],\n strip_prefix = \"icu_locale_core-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_locale_core-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_locale_data-2.3.0\",\n sha256 = \"d37d91460e362a5cf58907cd7ce871411775ee6294e49a5cc8e6cec16dfa75ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_locale_data/2.3.0/download\"],\n strip_prefix = \"icu_locale_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_locale_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_locale_fallback-2.3.0\",\n sha256 = \"251af8e57c9400e3eb58242fe5b8b1152b2a64fdf4cf632f923c38ccee6f2fa9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_locale_fallback/2.3.0/download\"],\n strip_prefix = \"icu_locale_fallback-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_locale_fallback-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_locale_fallback_data-2.3.0\",\n sha256 = \"decf2a22ec8fa68f1a0c1129a3f8583f8f8bc24e8b9ccbe98ead99f62a4dc3a8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_locale_fallback_data/2.3.0/download\"],\n strip_prefix = \"icu_locale_fallback_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_locale_fallback_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_normalizer-2.3.0\",\n sha256 = \"12f9cf5f235641ed274641dd81c3f28d870e276763d0797aeeab72317b1c646f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_normalizer/2.3.0/download\"],\n strip_prefix = \"icu_normalizer-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_normalizer-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_normalizer_data-2.3.0\",\n sha256 = \"1563da1ed3e0b3bf3d74c9b85917ac9c56464d2f57242270c09c9e752f8021a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_normalizer_data/2.3.0/download\"],\n strip_prefix = \"icu_normalizer_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_normalizer_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_pattern-0.5.0\",\n sha256 = \"2b3db611446bd92c246b03e4aa0bafa71ddb194af431ddbb42b9d70e4bfce1a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_pattern/0.5.0/download\"],\n strip_prefix = \"icu_pattern-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_pattern-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_plurals-2.3.0\",\n sha256 = \"e475e6766ef87b1d3c1f97be6363995b0bfaeddbc789671615df598a97ff0593\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_plurals/2.3.0/download\"],\n strip_prefix = \"icu_plurals-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_plurals-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_plurals_data-2.3.0\",\n sha256 = \"1251aa39a95e1333888e499b1263e1c196447a28948acf5bdabd82c046f153bf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_plurals_data/2.3.0/download\"],\n strip_prefix = \"icu_plurals_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_plurals_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_properties-2.3.0\",\n sha256 = \"7e7ca276ad3145661a65914e6daf131ca5120cd3dcee8f8f3214b8875184a148\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_properties/2.3.0/download\"],\n strip_prefix = \"icu_properties-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_properties-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_properties_data-2.3.0\",\n sha256 = \"e590f038c1464a96894fd6d10127e90a8be4509f56ff7ecef851b15cee0b7caa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_properties_data/2.3.0/download\"],\n strip_prefix = \"icu_properties_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_properties_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_provider-2.3.1\",\n sha256 = \"d27bbb9d3abbefac45d55f647c9de1d44aafcd1186eb91879afef17c396c3e73\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_provider/2.3.1/download\"],\n strip_prefix = \"icu_provider-2.3.1\",\n build_file = Label(\"@crates//crates:BUILD.icu_provider-2.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_time-2.3.0\",\n sha256 = \"af37e1c3b9f3ab564b619fdf4b22de169f6381eb0f7048e3ca454290c438126b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_time/2.3.0/download\"],\n strip_prefix = \"icu_time-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_time-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icu_time_data-2.3.0\",\n sha256 = \"005ff86fa5851a77fc0a977b72d717f777bd9230415a247219d7898aefb1517a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icu_time_data/2.3.0/download\"],\n strip_prefix = \"icu_time_data-2.3.0\",\n build_file = Label(\"@crates//crates:BUILD.icu_time_data-2.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__icy_sixel-0.5.1\",\n sha256 = \"4bfb5a63225620b59df34a235d1fb56ff7b766909c3212a8ff927511a22b181d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/icy_sixel/0.5.1/download\"],\n strip_prefix = \"icy_sixel-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.icy_sixel-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ident_case-1.0.1\",\n sha256 = \"b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ident_case/1.0.1/download\"],\n strip_prefix = \"ident_case-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.ident_case-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__idna-1.1.0\",\n sha256 = \"3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/idna/1.1.0/download\"],\n strip_prefix = \"idna-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.idna-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__idna_adapter-1.2.2\",\n sha256 = \"cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/idna_adapter/1.2.2/download\"],\n strip_prefix = \"idna_adapter-1.2.2\",\n build_file = Label(\"@crates//crates:BUILD.idna_adapter-1.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ignore-0.4.33\",\n sha256 = \"00b69833ed729dc5aa7d19541d96d6cf8e9137194207a04916d658e43168402f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ignore/0.4.33/download\"],\n strip_prefix = \"ignore-0.4.33\",\n build_file = Label(\"@crates//crates:BUILD.ignore-0.4.33.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__image-0.25.10\",\n sha256 = \"85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/image/0.25.10/download\"],\n strip_prefix = \"image-0.25.10\",\n build_file = Label(\"@crates//crates:BUILD.image-0.25.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__image-webp-0.2.4\",\n sha256 = \"525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/image-webp/0.2.4/download\"],\n strip_prefix = \"image-webp-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.image-webp-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__imagesize-0.15.0\",\n sha256 = \"65b27460c2c92b037f3f94c538ed9a3342f3fdf923606781629ccb35f82d042a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/imagesize/0.15.0/download\"],\n strip_prefix = \"imagesize-0.15.0\",\n build_file = Label(\"@crates//crates:BUILD.imagesize-0.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__include_dir-0.7.4\",\n sha256 = \"923d117408f1e49d914f1a379a309cffe4f18c05cf4e3d12e613a15fc81bd0dd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/include_dir/0.7.4/download\"],\n strip_prefix = \"include_dir-0.7.4\",\n build_file = Label(\"@crates//crates:BUILD.include_dir-0.7.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__include_dir_macros-0.7.4\",\n sha256 = \"7cab85a7ed0bd5f0e76d93846e0147172bed2e2d3f859bcc33a8d9699cad1a75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/include_dir_macros/0.7.4/download\"],\n strip_prefix = \"include_dir_macros-0.7.4\",\n build_file = Label(\"@crates//crates:BUILD.include_dir_macros-0.7.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__indenter-0.3.4\",\n sha256 = \"964de6e86d545b246d84badc0fef527924ace5134f30641c203ef52ba83f58d5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/indenter/0.3.4/download\"],\n strip_prefix = \"indenter-0.3.4\",\n build_file = Label(\"@crates//crates:BUILD.indenter-0.3.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__indexmap-2.14.0\",\n sha256 = \"d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/indexmap/2.14.0/download\"],\n strip_prefix = \"indexmap-2.14.0\",\n build_file = Label(\"@crates//crates:BUILD.indexmap-2.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__indicatif-0.18.6\",\n sha256 = \"9433806cd6b4ec1aba79c021c7e4c58fb4c3b9977c085062e611ac929998fb0c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/indicatif/0.18.6/download\"],\n strip_prefix = \"indicatif-0.18.6\",\n build_file = Label(\"@crates//crates:BUILD.indicatif-0.18.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__inferno-0.12.8\",\n sha256 = \"0c460d4fa06223667240720ab69a8045133755ae6dfbe100cf481b95e3a014f1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/inferno/0.12.8/download\"],\n strip_prefix = \"inferno-0.12.8\",\n build_file = Label(\"@crates//crates:BUILD.inferno-0.12.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__inherent-1.0.14\",\n sha256 = \"bee2c455ca60511a054699102d40ce7153621cb2429558f9eaa600e4499b5984\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/inherent/1.0.14/download\"],\n strip_prefix = \"inherent-1.0.14\",\n build_file = Label(\"@crates//crates:BUILD.inherent-1.0.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__inotify-0.11.5\",\n sha256 = \"4cc00ea907cab49550b7da656f80ebb97be1b997d931fbcd28d39734e17ce592\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/inotify/0.11.5/download\"],\n strip_prefix = \"inotify-0.11.5\",\n build_file = Label(\"@crates//crates:BUILD.inotify-0.11.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__inotify-sys-0.1.8\",\n sha256 = \"c033f80b2c113cdf91ab7a33faa9cbc014726dcad99880c8609af2a370edf37d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/inotify-sys/0.1.8/download\"],\n strip_prefix = \"inotify-sys-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.inotify-sys-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__inout-0.1.4\",\n sha256 = \"879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/inout/0.1.4/download\"],\n strip_prefix = \"inout-0.1.4\",\n build_file = Label(\"@crates//crates:BUILD.inout-0.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__insta-1.48.0\",\n sha256 = \"86f0f8fee8c926415c58d6ae43a08523a26faccb2323f5e6b644fe7dd4ef6b82\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/insta/1.48.0/download\"],\n strip_prefix = \"insta-1.48.0\",\n build_file = Label(\"@crates//crates:BUILD.insta-1.48.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__interceptor-0.17.2\",\n sha256 = \"88c11a956a48159f7fe539b8198f12b4db9b709ae5f94385b840db38f97fed74\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/interceptor/0.17.2/download\"],\n strip_prefix = \"interceptor-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.interceptor-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__interim-0.2.1\",\n sha256 = \"a9ce9099a85f468663d3225bf87e85d0548968441e1db12248b996b24f0f5b5a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/interim/0.2.1/download\"],\n strip_prefix = \"interim-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.interim-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__intl-memoizer-0.5.3\",\n sha256 = \"310da2e345f5eb861e7a07ee182262e94975051db9e4223e909ba90f392f163f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/intl-memoizer/0.5.3/download\"],\n strip_prefix = \"intl-memoizer-0.5.3\",\n build_file = Label(\"@crates//crates:BUILD.intl-memoizer-0.5.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__intl_pluralrules-7.0.2\",\n sha256 = \"078ea7b7c29a2b4df841a7f6ac8775ff6074020c6776d48491ce2268e068f972\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/intl_pluralrules/7.0.2/download\"],\n strip_prefix = \"intl_pluralrules-7.0.2\",\n build_file = Label(\"@crates//crates:BUILD.intl_pluralrules-7.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__io-close-0.3.7\",\n sha256 = \"9cadcf447f06744f8ce713d2d6239bb5bde2c357a452397a9ed90c625da390bc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/io-close/0.3.7/download\"],\n strip_prefix = \"io-close-0.3.7\",\n build_file = Label(\"@crates//crates:BUILD.io-close-0.3.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ipnet-2.12.1\",\n sha256 = \"6a756c3fac73139e83f14c2d742155dd2b78d3ee56597b419a0579b7bdd6dd78\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ipnet/2.12.1/download\"],\n strip_prefix = \"ipnet-2.12.1\",\n build_file = Label(\"@crates//crates:BUILD.ipnet-2.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__is_terminal_polyfill-1.70.2\",\n sha256 = \"a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/is_terminal_polyfill/1.70.2/download\"],\n strip_prefix = \"is_terminal_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.is_terminal_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.13.0\",\n sha256 = \"413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.13.0/download\"],\n strip_prefix = \"itertools-0.13.0\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.13.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.14.0\",\n sha256 = \"2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.14.0/download\"],\n strip_prefix = \"itertools-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itertools-0.15.0\",\n sha256 = \"8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itertools/0.15.0/download\"],\n strip_prefix = \"itertools-0.15.0\",\n build_file = Label(\"@crates//crates:BUILD.itertools-0.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__itoa-1.0.18\",\n sha256 = \"8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/itoa/1.0.18/download\"],\n strip_prefix = \"itoa-1.0.18\",\n build_file = Label(\"@crates//crates:BUILD.itoa-1.0.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jaq-core-2.2.1\",\n sha256 = \"77526a72eb79412c29fd141767a6549bbfcb1cb40e00556fe16532d5e878e098\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jaq-core/2.2.1/download\"],\n strip_prefix = \"jaq-core-2.2.1\",\n build_file = Label(\"@crates//crates:BUILD.jaq-core-2.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jaq-json-1.1.3\",\n sha256 = \"01dbdbd07b076e8403abac68ce7744d93e2ecd953bbc44bf77bf00e1e81172bc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jaq-json/1.1.3/download\"],\n strip_prefix = \"jaq-json-1.1.3\",\n build_file = Label(\"@crates//crates:BUILD.jaq-json-1.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jaq-std-2.1.2\",\n sha256 = \"2c264fe397c981705976c71f1bfe020382b9eda52ae950e57fe885e147bdd67d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jaq-std/2.1.2/download\"],\n strip_prefix = \"jaq-std-2.1.2\",\n build_file = Label(\"@crates//crates:BUILD.jaq-std-2.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-0.2.35\",\n sha256 = \"668b7183bd07af9a4885f5c35b0cc5c83c4607a913c16b7e17291832910d2dcc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff/0.2.35/download\"],\n strip_prefix = \"jiff-0.2.35\",\n build_file = Label(\"@crates//crates:BUILD.jiff-0.2.35.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-core-0.1.0\",\n sha256 = \"7feca88439efe53da3754500c1851dedf3cb36c524dd5cf8225cc0794de95d09\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff-core/0.1.0/download\"],\n strip_prefix = \"jiff-core-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.jiff-core-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-icu-0.2.2\",\n sha256 = \"0e67c2beaae8b10a82d849b9aabb698a43a682f32b17bcdc035d5ecadb44d646\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff-icu/0.2.2/download\"],\n strip_prefix = \"jiff-icu-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.jiff-icu-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-static-0.2.35\",\n sha256 = \"3a69dcb3a21cfb32ce1cd056169337ca284af0766dd766e7878819b251a49204\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff-static/0.2.35/download\"],\n strip_prefix = \"jiff-static-0.2.35\",\n build_file = Label(\"@crates//crates:BUILD.jiff-static-0.2.35.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-tzdb-0.1.8\",\n sha256 = \"142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff-tzdb/0.1.8/download\"],\n strip_prefix = \"jiff-tzdb-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.jiff-tzdb-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jiff-tzdb-platform-0.1.3\",\n sha256 = \"875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jiff-tzdb-platform/0.1.3/download\"],\n strip_prefix = \"jiff-tzdb-platform-0.1.3\",\n build_file = Label(\"@crates//crates:BUILD.jiff-tzdb-platform-0.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jj-lib-0.44.0\",\n sha256 = \"0d58fe15e3acbc89de606b7a10b284498ed908d09f3b7bdf560ca6f92e3a8d63\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jj-lib/0.44.0/download\"],\n strip_prefix = \"jj-lib-0.44.0\",\n build_file = Label(\"@crates//crates:BUILD.jj-lib-0.44.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jj-lib-proc-macros-0.44.0\",\n sha256 = \"d68a9ec87af36ba808fa818f5f1f041cce01df9eb0e21690e854fe612640060e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jj-lib-proc-macros/0.44.0/download\"],\n strip_prefix = \"jj-lib-proc-macros-0.44.0\",\n build_file = Label(\"@crates//crates:BUILD.jj-lib-proc-macros-0.44.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__jobserver-0.1.35\",\n sha256 = \"1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/jobserver/0.1.35/download\"],\n strip_prefix = \"jobserver-0.1.35\",\n build_file = Label(\"@crates//crates:BUILD.jobserver-0.1.35.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__js-sys-0.3.104\",\n sha256 = \"0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/js-sys/0.3.104/download\"],\n strip_prefix = \"js-sys-0.3.104\",\n build_file = Label(\"@crates//crates:BUILD.js-sys-0.3.104.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__keccak-0.1.6\",\n sha256 = \"cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/keccak/0.1.6/download\"],\n strip_prefix = \"keccak-0.1.6\",\n build_file = Label(\"@crates//crates:BUILD.keccak-0.1.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__khronos-egl-6.0.0\",\n sha256 = \"6aae1df220ece3c0ada96b8153459b67eebe9ae9212258bb0134ae60416fdf76\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/khronos-egl/6.0.0/download\"],\n strip_prefix = \"khronos-egl-6.0.0\",\n build_file = Label(\"@crates//crates:BUILD.khronos-egl-6.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__khronos_api-3.1.0\",\n sha256 = \"e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/khronos_api/3.1.0/download\"],\n strip_prefix = \"khronos_api-3.1.0\",\n build_file = Label(\"@crates//crates:BUILD.khronos_api-3.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__kqueue-1.2.1\",\n sha256 = \"8d763e5b24120b4ddf50de6c92308156765aabfbbccebf401da7cff2d70a41ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/kqueue/1.2.1/download\"],\n strip_prefix = \"kqueue-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.kqueue-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__kqueue-sys-1.1.2\",\n sha256 = \"07293a4e297ac234359b510362495713f75ea345d5307140414f20c69ffeb087\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/kqueue-sys/1.1.2/download\"],\n strip_prefix = \"kqueue-sys-1.1.2\",\n build_file = Label(\"@crates//crates:BUILD.kqueue-sys-1.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__kstring-2.0.2\",\n sha256 = \"558bf9508a558512042d3095138b1f7b8fe90c5467d94f9f1da28b3731c5dbd1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/kstring/2.0.2/download\"],\n strip_prefix = \"kstring-2.0.2\",\n build_file = Label(\"@crates//crates:BUILD.kstring-2.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__kurbo-0.13.1\",\n sha256 = \"4b60dfc32f652b926df6192e55525b16d186c69d47876c3ead4da5cc9f8450e2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/kurbo/0.13.1/download\"],\n strip_prefix = \"kurbo-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.kurbo-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lazy_static-1.5.0\",\n sha256 = \"bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lazy_static/1.5.0/download\"],\n strip_prefix = \"lazy_static-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.lazy_static-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libc-0.2.189\",\n sha256 = \"3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libc/0.2.189/download\"],\n strip_prefix = \"libc-0.2.189\",\n build_file = Label(\"@crates//crates:BUILD.libc-0.2.189.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libloading-0.8.9\",\n sha256 = \"d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libloading/0.8.9/download\"],\n strip_prefix = \"libloading-0.8.9\",\n build_file = Label(\"@crates//crates:BUILD.libloading-0.8.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libloading-0.9.0\",\n sha256 = \"754ca22de805bb5744484a5b151a9e1a8e837d5dc232c2d7d8c2e3492edc8b60\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libloading/0.9.0/download\"],\n strip_prefix = \"libloading-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.libloading-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libm-0.2.16\",\n sha256 = \"b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libm/0.2.16/download\"],\n strip_prefix = \"libm-0.2.16\",\n build_file = Label(\"@crates//crates:BUILD.libm-0.2.16.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libredox-0.1.21\",\n sha256 = \"d7955dfc218a8afb29dfeffd540e3a6e96baeb94fe7138228dd7cc6937fbbf96\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libredox/0.1.21/download\"],\n strip_prefix = \"libredox-0.1.21\",\n build_file = Label(\"@crates//crates:BUILD.libredox-0.1.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libspa-0.9.2\",\n sha256 = \"b6b8cfa2a7656627b4c92c6b9ef929433acd673d5ab3708cda1b18478ac00df4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libspa/0.9.2/download\"],\n strip_prefix = \"libspa-0.9.2\",\n build_file = Label(\"@crates//crates:BUILD.libspa-0.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libspa-sys-0.9.2\",\n sha256 = \"901049455d2eb6decf9058235d745237952f4804bc584c5fcb41412e6adcc6e0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libspa-sys/0.9.2/download\"],\n strip_prefix = \"libspa-sys-0.9.2\",\n build_file = Label(\"@crates//crates:BUILD.libspa-sys-0.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__libwayshot-xcap-0.3.3\",\n sha256 = \"ea8a46e4d016ef464e386e4970f5415fe0939c2d63abe0c2f539c05ef88c5fe5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/libwayshot-xcap/0.3.3/download\"],\n strip_prefix = \"libwayshot-xcap-0.3.3\",\n build_file = Label(\"@crates//crates:BUILD.libwayshot-xcap-0.3.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linked-hash-map-0.5.6\",\n sha256 = \"0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linked-hash-map/0.5.6/download\"],\n strip_prefix = \"linked-hash-map-0.5.6\",\n build_file = Label(\"@crates//crates:BUILD.linked-hash-map-0.5.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linux-raw-sys-0.12.1\",\n sha256 = \"32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linux-raw-sys/0.12.1/download\"],\n strip_prefix = \"linux-raw-sys-0.12.1\",\n build_file = Label(\"@crates//crates:BUILD.linux-raw-sys-0.12.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linux-raw-sys-0.4.15\",\n sha256 = \"d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linux-raw-sys/0.4.15/download\"],\n strip_prefix = \"linux-raw-sys-0.4.15\",\n build_file = Label(\"@crates//crates:BUILD.linux-raw-sys-0.4.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__linux-raw-sys-0.9.4\",\n sha256 = \"cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/linux-raw-sys/0.9.4/download\"],\n strip_prefix = \"linux-raw-sys-0.9.4\",\n build_file = Label(\"@crates//crates:BUILD.linux-raw-sys-0.9.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__litemap-0.8.3\",\n sha256 = \"47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/litemap/0.8.3/download\"],\n strip_prefix = \"litemap-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.litemap-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lock_api-0.4.14\",\n sha256 = \"224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lock_api/0.4.14/download\"],\n strip_prefix = \"lock_api-0.4.14\",\n build_file = Label(\"@crates//crates:BUILD.lock_api-0.4.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__log-0.4.34\",\n sha256 = \"f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/log/0.4.34/download\"],\n strip_prefix = \"log-0.4.34\",\n build_file = Label(\"@crates//crates:BUILD.log-0.4.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__logos-0.15.1\",\n sha256 = \"ff472f899b4ec2d99161c51f60ff7075eeb3097069a36050d8037a6325eb8154\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/logos/0.15.1/download\"],\n strip_prefix = \"logos-0.15.1\",\n build_file = Label(\"@crates//crates:BUILD.logos-0.15.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__logos-codegen-0.15.1\",\n sha256 = \"192a3a2b90b0c05b27a0b2c43eecdb7c415e29243acc3f89cc8247a5b693045c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/logos-codegen/0.15.1/download\"],\n strip_prefix = \"logos-codegen-0.15.1\",\n build_file = Label(\"@crates//crates:BUILD.logos-codegen-0.15.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__logos-derive-0.15.1\",\n sha256 = \"605d9697bcd5ef3a42d38efc51541aa3d6a4a25f7ab6d1ed0da5ac632a26b470\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/logos-derive/0.15.1/download\"],\n strip_prefix = \"logos-derive-0.15.1\",\n build_file = Label(\"@crates//crates:BUILD.logos-derive-0.15.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lopdf-0.42.0\",\n sha256 = \"25aab26d99567469098e64a02f42679f8965c6401263eefa31d8f2dcc37a221c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lopdf/0.42.0/download\"],\n strip_prefix = \"lopdf-0.42.0\",\n build_file = Label(\"@crates//crates:BUILD.lopdf-0.42.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__lscolors-0.21.0\",\n sha256 = \"d60e266dfb1426eb2d24792602e041131fdc0236bb7007abc0e589acafd60929\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/lscolors/0.21.0/download\"],\n strip_prefix = \"lscolors-0.21.0\",\n build_file = Label(\"@crates//crates:BUILD.lscolors-0.21.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__maplit-1.0.2\",\n sha256 = \"3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/maplit/1.0.2/download\"],\n strip_prefix = \"maplit-1.0.2\",\n build_file = Label(\"@crates//crates:BUILD.maplit-1.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__markup5ever-0.39.0\",\n sha256 = \"7122d987ec5f704ee56f6e5b41a7d93722e9aae27ae07cafa4036c4d3f9757de\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/markup5ever/0.39.0/download\"],\n strip_prefix = \"markup5ever-0.39.0\",\n build_file = Label(\"@crates//crates:BUILD.markup5ever-0.39.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__maybe-async-0.2.11\",\n sha256 = \"746873a384ad60adc5db74471dfaba74bd278afbdcfd81db93fafcdfc8b5ca0c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/maybe-async/0.2.11/download\"],\n strip_prefix = \"maybe-async-0.2.11\",\n build_file = Label(\"@crates//crates:BUILD.maybe-async-0.2.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__md-5-0.10.6\",\n sha256 = \"d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/md-5/0.10.6/download\"],\n strip_prefix = \"md-5-0.10.6\",\n build_file = Label(\"@crates//crates:BUILD.md-5-0.10.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memchr-2.8.3\",\n sha256 = \"cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memchr/2.8.3/download\"],\n strip_prefix = \"memchr-2.8.3\",\n build_file = Label(\"@crates//crates:BUILD.memchr-2.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memmap2-0.9.11\",\n sha256 = \"d1219ed1b7f229ee7104d281dd01d6802fe28bb6e95d292942c4daacdeb798c0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memmap2/0.9.11/download\"],\n strip_prefix = \"memmap2-0.9.11\",\n build_file = Label(\"@crates//crates:BUILD.memmap2-0.9.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memoffset-0.7.1\",\n sha256 = \"5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memoffset/0.7.1/download\"],\n strip_prefix = \"memoffset-0.7.1\",\n build_file = Label(\"@crates//crates:BUILD.memoffset-0.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__memoffset-0.9.1\",\n sha256 = \"488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/memoffset/0.9.1/download\"],\n strip_prefix = \"memoffset-0.9.1\",\n build_file = Label(\"@crates//crates:BUILD.memoffset-0.9.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__minimal-lexical-0.2.1\",\n sha256 = \"68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/minimal-lexical/0.2.1/download\"],\n strip_prefix = \"minimal-lexical-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.minimal-lexical-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__miniz_oxide-0.8.9\",\n sha256 = \"1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/miniz_oxide/0.8.9/download\"],\n strip_prefix = \"miniz_oxide-0.8.9\",\n build_file = Label(\"@crates//crates:BUILD.miniz_oxide-0.8.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__mio-1.2.2\",\n sha256 = \"30d65c71f1ce40ab09135ce117d742b9f8a19ff91a41a8b57ed50bc2de59c427\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/mio/1.2.2/download\"],\n strip_prefix = \"mio-1.2.2\",\n build_file = Label(\"@crates//crates:BUILD.mio-1.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__moxcms-0.8.1\",\n sha256 = \"bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/moxcms/0.8.1/download\"],\n strip_prefix = \"moxcms-0.8.1\",\n build_file = Label(\"@crates//crates:BUILD.moxcms-0.8.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__munge-0.4.7\",\n sha256 = \"5e17401f259eba956ca16491461b6e8f72913a0a114e39736ce404410f915a0c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/munge/0.4.7/download\"],\n strip_prefix = \"munge-0.4.7\",\n build_file = Label(\"@crates//crates:BUILD.munge-0.4.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__munge_macro-0.4.7\",\n sha256 = \"4568f25ccbd45ab5d5603dc34318c1ec56b117531781260002151b8530a9f931\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/munge_macro/0.4.7/download\"],\n strip_prefix = \"munge_macro-0.4.7\",\n build_file = Label(\"@crates//crates:BUILD.munge_macro-0.4.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nanorand-0.7.0\",\n sha256 = \"6a51313c5820b0b02bd422f4b44776fbf47961755c74ce64afc73bfad10226c3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nanorand/0.7.0/download\"],\n strip_prefix = \"nanorand-0.7.0\",\n build_file = Label(\"@crates//crates:BUILD.nanorand-0.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__napi-3.12.2\",\n sha256 = \"58c5f4d5375213fdb7be2655e152386e82f026f9a5ba36a75556e11359aafe09\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/napi/3.12.2/download\"],\n strip_prefix = \"napi-3.12.2\",\n build_file = Label(\"@crates//crates:BUILD.napi-3.12.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__napi-build-2.4.1\",\n sha256 = \"60fdf9b392c50e7c4170fa633bd909490ed7835cea4c046776d1a4dd8d2ae0ab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/napi-build/2.4.1/download\"],\n strip_prefix = \"napi-build-2.4.1\",\n build_file = Label(\"@crates//crates:BUILD.napi-build-2.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__napi-derive-3.6.3\",\n sha256 = \"0fa55ea69990c90b888e9e77044410e304ce7f35de599dc6d0b5c1923d2e59af\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/napi-derive/3.6.3/download\"],\n strip_prefix = \"napi-derive-3.6.3\",\n build_file = Label(\"@crates//crates:BUILD.napi-derive-3.6.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__napi-derive-backend-6.1.2\",\n sha256 = \"df4056ac7c18e4438ccf0edaed4340ca0d269278c8ec19284f7b23cb039fd0ae\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/napi-derive-backend/6.1.2/download\"],\n strip_prefix = \"napi-derive-backend-6.1.2\",\n build_file = Label(\"@crates//crates:BUILD.napi-derive-backend-6.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__napi-sys-3.3.0\",\n sha256 = \"85fbf1fa9f1babfe396d74bbbf52b3643770243e8f5b0b46715d4caf7f0dfc9a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/napi-sys/3.3.0/download\"],\n strip_prefix = \"napi-sys-3.3.0\",\n build_file = Label(\"@crates//crates:BUILD.napi-sys-3.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__new_debug_unreachable-1.0.6\",\n sha256 = \"650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/new_debug_unreachable/1.0.6/download\"],\n strip_prefix = \"new_debug_unreachable-1.0.6\",\n build_file = Label(\"@crates//crates:BUILD.new_debug_unreachable-1.0.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.24.3\",\n sha256 = \"fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.24.3/download\"],\n strip_prefix = \"nix-0.24.3\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.24.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.26.4\",\n sha256 = \"598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.26.4/download\"],\n strip_prefix = \"nix-0.26.4\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.26.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.28.0\",\n sha256 = \"ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.28.0/download\"],\n strip_prefix = \"nix-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.30.1\",\n sha256 = \"74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.30.1/download\"],\n strip_prefix = \"nix-0.30.1\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.30.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nix-0.31.3\",\n sha256 = \"cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nix/0.31.3/download\"],\n strip_prefix = \"nix-0.31.3\",\n build_file = Label(\"@crates//crates:BUILD.nix-0.31.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nohash-hasher-0.2.0\",\n sha256 = \"2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nohash-hasher/0.2.0/download\"],\n strip_prefix = \"nohash-hasher-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.nohash-hasher-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nom-7.1.3\",\n sha256 = \"d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nom/7.1.3/download\"],\n strip_prefix = \"nom-7.1.3\",\n build_file = Label(\"@crates//crates:BUILD.nom-7.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nom-8.0.0\",\n sha256 = \"df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nom/8.0.0/download\"],\n strip_prefix = \"nom-8.0.0\",\n build_file = Label(\"@crates//crates:BUILD.nom-8.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nonempty-0.12.0\",\n sha256 = \"9737e026353e5cd0736f98eddae28665118eb6f6600902a7f50db585621fecb6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nonempty/0.12.0/download\"],\n strip_prefix = \"nonempty-0.12.0\",\n build_file = Label(\"@crates//crates:BUILD.nonempty-0.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__normalize-path-0.2.1\",\n sha256 = \"f5438dd2b2ff4c6df6e1ce22d825ed2fa93ee2922235cc45186991717f0a892d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/normalize-path/0.2.1/download\"],\n strip_prefix = \"normalize-path-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.normalize-path-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__notify-8.2.0\",\n sha256 = \"4d3d07927151ff8575b7087f245456e549fea62edf0ec4e565a5ee50c8402bc3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/notify/8.2.0/download\"],\n strip_prefix = \"notify-8.2.0\",\n build_file = Label(\"@crates//crates:BUILD.notify-8.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__notify-types-2.1.0\",\n sha256 = \"42b8cfee0e339a0337359f3c88165702ac6e600dc01c0cc9579a92d62b08477a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/notify-types/2.1.0/download\"],\n strip_prefix = \"notify-types-2.1.0\",\n build_file = Label(\"@crates//crates:BUILD.notify-types-2.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__nu-ansi-term-0.50.3\",\n sha256 = \"7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/nu-ansi-term/0.50.3/download\"],\n strip_prefix = \"nu-ansi-term-0.50.3\",\n build_file = Label(\"@crates//crates:BUILD.nu-ansi-term-0.50.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-bigint-0.4.8\",\n sha256 = \"c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-bigint/0.4.8/download\"],\n strip_prefix = \"num-bigint-0.4.8\",\n build_file = Label(\"@crates//crates:BUILD.num-bigint-0.4.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-conv-0.2.2\",\n sha256 = \"521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-conv/0.2.2/download\"],\n strip_prefix = \"num-conv-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.num-conv-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-format-0.4.4\",\n sha256 = \"a652d9771a63711fd3c3deb670acfbe5c30a4072e664d7a3bf5a9e1056ac72c3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-format/0.4.4/download\"],\n strip_prefix = \"num-format-0.4.4\",\n build_file = Label(\"@crates//crates:BUILD.num-format-0.4.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-integer-0.1.47\",\n sha256 = \"7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-integer/0.1.47/download\"],\n strip_prefix = \"num-integer-0.1.47\",\n build_file = Label(\"@crates//crates:BUILD.num-integer-0.1.47.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__num-traits-0.2.19\",\n sha256 = \"071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/num-traits/0.2.19/download\"],\n strip_prefix = \"num-traits-0.2.19\",\n build_file = Label(\"@crates//crates:BUILD.num-traits-0.2.19.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-0.6.4\",\n sha256 = \"3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2/0.6.4/download\"],\n strip_prefix = \"objc2-0.6.4\",\n build_file = Label(\"@crates//crates:BUILD.objc2-0.6.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-app-kit-0.3.2\",\n sha256 = \"d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-app-kit/0.3.2/download\"],\n strip_prefix = \"objc2-app-kit-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-app-kit-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-application-services-0.3.2\",\n sha256 = \"69282c2b5bc58fba07cb9de2113619532eb551e98efe3d8d695509ef45fbd53b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-application-services/0.3.2/download\"],\n strip_prefix = \"objc2-application-services-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-application-services-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-av-foundation-0.3.2\",\n sha256 = \"478ae33fcac9df0a18db8302387c666b8ef08a3e2d62b510ca4fc278a384b6c0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-av-foundation/0.3.2/download\"],\n strip_prefix = \"objc2-av-foundation-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-av-foundation-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-avf-audio-0.3.2\",\n sha256 = \"13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-avf-audio/0.3.2/download\"],\n strip_prefix = \"objc2-avf-audio-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-avf-audio-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-cloud-kit-0.3.2\",\n sha256 = \"73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-cloud-kit/0.3.2/download\"],\n strip_prefix = \"objc2-cloud-kit-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-cloud-kit-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-audio-0.3.2\",\n sha256 = \"e1eebcea8b0dbff5f7c8504f3107c68fc061a3eb44932051c8cf8a68d969c3b2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-audio/0.3.2/download\"],\n strip_prefix = \"objc2-core-audio-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-audio-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-audio-types-0.3.2\",\n sha256 = \"5a89f2ec274a0cf4a32642b2991e8b351a404d290da87bb6a9a9d8632490bd1c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-audio-types/0.3.2/download\"],\n strip_prefix = \"objc2-core-audio-types-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-audio-types-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-data-0.3.2\",\n sha256 = \"0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-data/0.3.2/download\"],\n strip_prefix = \"objc2-core-data-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-data-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-foundation-0.3.2\",\n sha256 = \"2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-foundation/0.3.2/download\"],\n strip_prefix = \"objc2-core-foundation-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-foundation-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-graphics-0.3.2\",\n sha256 = \"e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-graphics/0.3.2/download\"],\n strip_prefix = \"objc2-core-graphics-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-graphics-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-image-0.3.2\",\n sha256 = \"e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-image/0.3.2/download\"],\n strip_prefix = \"objc2-core-image-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-image-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-media-0.3.2\",\n sha256 = \"05ec576860167a15dd9fce7fbee7512beb4e31f532159d3482d1f9c6caedf31d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-media/0.3.2/download\"],\n strip_prefix = \"objc2-core-media-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-media-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-services-0.3.2\",\n sha256 = \"583300ad934cba24ff5292aee751ecc070f7ca6b39a574cc21b7b5e588e06a0b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-services/0.3.2/download\"],\n strip_prefix = \"objc2-core-services-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-services-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-text-0.3.2\",\n sha256 = \"0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-text/0.3.2/download\"],\n strip_prefix = \"objc2-core-text-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-text-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-core-video-0.3.2\",\n sha256 = \"d425caf1df73233f29fd8a5c3e5edbc30d2d4307870f802d18f00d83dc5141a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-core-video/0.3.2/download\"],\n strip_prefix = \"objc2-core-video-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-core-video-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-encode-4.1.0\",\n sha256 = \"ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-encode/4.1.0/download\"],\n strip_prefix = \"objc2-encode-4.1.0\",\n build_file = Label(\"@crates//crates:BUILD.objc2-encode-4.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-foundation-0.3.2\",\n sha256 = \"e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-foundation/0.3.2/download\"],\n strip_prefix = \"objc2-foundation-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-foundation-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-image-io-0.3.2\",\n sha256 = \"32b0446e98cf4a784cc7a0177715ff317eeaa8463841c616cfc78aa4f953c4ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-image-io/0.3.2/download\"],\n strip_prefix = \"objc2-image-io-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-image-io-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-io-surface-0.3.2\",\n sha256 = \"180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-io-surface/0.3.2/download\"],\n strip_prefix = \"objc2-io-surface-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-io-surface-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-media-toolbox-0.3.2\",\n sha256 = \"edd9fdde720df3da7046bb9097811000c1e7ab5cd579fa89d96b27d56781fb30\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-media-toolbox/0.3.2/download\"],\n strip_prefix = \"objc2-media-toolbox-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-media-toolbox-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-metal-0.3.2\",\n sha256 = \"a0125f776a10d00af4152d74616409f0d4a2053a6f57fa5b7d6aa2854ac04794\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-metal/0.3.2/download\"],\n strip_prefix = \"objc2-metal-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-metal-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-quartz-core-0.3.2\",\n sha256 = \"96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-quartz-core/0.3.2/download\"],\n strip_prefix = \"objc2-quartz-core-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-quartz-core-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-security-0.3.2\",\n sha256 = \"709fe137109bd1e8b5a99390f77a7d8b2961dafc1a1c5db8f2e60329ad6d895a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-security/0.3.2/download\"],\n strip_prefix = \"objc2-security-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-security-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__objc2-system-configuration-0.3.2\",\n sha256 = \"7216bd11cbda54ccabcab84d523dc93b858ec75ecfb3a7d89513fa22464da396\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/objc2-system-configuration/0.3.2/download\"],\n strip_prefix = \"objc2-system-configuration-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.objc2-system-configuration-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__oid-registry-0.7.1\",\n sha256 = \"a8d8034d9489cdaf79228eb9f6a3b8d7bb32ba00d6645ebd48eef4077ceb5bd9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/oid-registry/0.7.1/download\"],\n strip_prefix = \"oid-registry-0.7.1\",\n build_file = Label(\"@crates//crates:BUILD.oid-registry-0.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell-1.21.4\",\n sha256 = \"9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell/1.21.4/download\"],\n strip_prefix = \"once_cell-1.21.4\",\n build_file = Label(\"@crates//crates:BUILD.once_cell-1.21.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__once_cell_polyfill-1.70.2\",\n sha256 = \"384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/once_cell_polyfill/1.70.2/download\"],\n strip_prefix = \"once_cell_polyfill-1.70.2\",\n build_file = Label(\"@crates//crates:BUILD.once_cell_polyfill-1.70.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__onig-6.5.3\",\n sha256 = \"0cc3cbf698f9438986c11a880c90a6d04b9de27575afd28bbf45b154b6c709e2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/onig/6.5.3/download\"],\n strip_prefix = \"onig-6.5.3\",\n build_file = Label(\"@crates//crates:BUILD.onig-6.5.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__onig_sys-69.9.3\",\n sha256 = \"1e68317604e77e53b85896388e1a803c1d21b74c899ec9e5e1112db90735edd7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/onig_sys/69.9.3/download\"],\n strip_prefix = \"onig_sys-69.9.3\",\n build_file = Label(\"@crates//crates:BUILD.onig_sys-69.9.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__opaque-debug-0.3.1\",\n sha256 = \"c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/opaque-debug/0.3.1/download\"],\n strip_prefix = \"opaque-debug-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.opaque-debug-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__opus-0.3.1\",\n sha256 = \"4d3809943dff6fbad5f0484449ea26bdb9cb7d8efdf26ed50d3c7f227f69eb5c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/opus/0.3.1/download\"],\n strip_prefix = \"opus-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.opus-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ordered-float-5.4.0\",\n sha256 = \"c860fd3227ca4ac3cc032e2cd20cba3f02ccdf4b610538f8ee6584d56bb62e96\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ordered-float/5.4.0/download\"],\n strip_prefix = \"ordered-float-5.4.0\",\n build_file = Label(\"@crates//crates:BUILD.ordered-float-5.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ordered-stream-0.2.0\",\n sha256 = \"9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ordered-stream/0.2.0/download\"],\n strip_prefix = \"ordered-stream-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.ordered-stream-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__os_display-0.1.4\",\n sha256 = \"ad5fd71b79026fb918650dde6d125000a233764f1c2f1659a1c71118e33ea08f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/os_display/0.1.4/download\"],\n strip_prefix = \"os_display-0.1.4\",\n build_file = Label(\"@crates//crates:BUILD.os_display-0.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__os_pipe-1.2.3\",\n sha256 = \"7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/os_pipe/1.2.3/download\"],\n strip_prefix = \"os_pipe-1.2.3\",\n build_file = Label(\"@crates//crates:BUILD.os_pipe-1.2.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__outref-0.5.2\",\n sha256 = \"1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/outref/0.5.2/download\"],\n strip_prefix = \"outref-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.outref-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__p256-0.13.2\",\n sha256 = \"c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/p256/0.13.2/download\"],\n strip_prefix = \"p256-0.13.2\",\n build_file = Label(\"@crates//crates:BUILD.p256-0.13.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__p384-0.13.1\",\n sha256 = \"fe42f1670a52a47d448f14b6a5c61dd78fce51856e68edaa38f7ae3a46b8d6b6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/p384/0.13.1/download\"],\n strip_prefix = \"p384-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.p384-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__palette-0.7.7\",\n sha256 = \"ddeed8580d347d2abf3dcf06a5f0b3dc020258338526b277847cd4248a70fc64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/palette/0.7.7/download\"],\n strip_prefix = \"palette-0.7.7\",\n build_file = Label(\"@crates//crates:BUILD.palette-0.7.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__palette_derive-0.7.7\",\n sha256 = \"88537020289b719d81be994ccf1bbf4990f477e2f69ee52fe3e45f43a02e56be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/palette_derive/0.7.7/download\"],\n strip_prefix = \"palette_derive-0.7.7\",\n build_file = Label(\"@crates//crates:BUILD.palette_derive-0.7.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__palette_math-0.7.7\",\n sha256 = \"6e6eb142958d64335fb0e345c5b9ead2ecd6fc438c307e9d7d3c4fd428dbaf12\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/palette_math/0.7.7/download\"],\n strip_prefix = \"palette_math-0.7.7\",\n build_file = Label(\"@crates//crates:BUILD.palette_math-0.7.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__parking-2.2.1\",\n sha256 = \"f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/parking/2.2.1/download\"],\n strip_prefix = \"parking-2.2.1\",\n build_file = Label(\"@crates//crates:BUILD.parking-2.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__parking_lot-0.12.5\",\n sha256 = \"93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/parking_lot/0.12.5/download\"],\n strip_prefix = \"parking_lot-0.12.5\",\n build_file = Label(\"@crates//crates:BUILD.parking_lot-0.12.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__parking_lot_core-0.9.12\",\n sha256 = \"2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/parking_lot_core/0.9.12/download\"],\n strip_prefix = \"parking_lot_core-0.9.12\",\n build_file = Label(\"@crates//crates:BUILD.parking_lot_core-0.9.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__parse_datetime-0.14.0\",\n sha256 = \"413775a7eac2261d2211a79d10ef275e5b6f7b527eec42ad09adce2ffa92b6e5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/parse_datetime/0.14.0/download\"],\n strip_prefix = \"parse_datetime-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.parse_datetime-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pcre2-0.2.11\",\n sha256 = \"9e970b0fcce0c7ee6ef662744ff711f21ccd6f11b7cf03cd187a80e89797fc67\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pcre2/0.2.11/download\"],\n strip_prefix = \"pcre2-0.2.11\",\n build_file = Label(\"@crates//crates:BUILD.pcre2-0.2.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pcre2-sys-0.2.10\",\n sha256 = \"18b9073c1a2549bd409bf4a32c94d903bb1a09bf845bc306ae148897fa0760a4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pcre2-sys/0.2.10/download\"],\n strip_prefix = \"pcre2-sys-0.2.10\",\n build_file = Label(\"@crates//crates:BUILD.pcre2-sys-0.2.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pdf-inspector-1.17.0\",\n sha256 = \"6cdfc6057e1b38a2ae84490c5e64abc5c81738d4d5ac1ccc55cf1a2c9b87334e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pdf-inspector/1.17.0/download\"],\n strip_prefix = \"pdf-inspector-1.17.0\",\n build_file = Label(\"@crates//crates:BUILD.pdf-inspector-1.17.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__peg-0.8.6\",\n sha256 = \"0aad070be5b63aa72103f2fcdd70a83adbd5e90112ce5b574171ff1c65501773\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/peg/0.8.6/download\"],\n strip_prefix = \"peg-0.8.6\",\n build_file = Label(\"@crates//crates:BUILD.peg-0.8.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__peg-macros-0.8.6\",\n sha256 = \"ddd8ef6825cae95355031ae26a99b616a2a21f22ba2de0197c43dfb05acbe7ee\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/peg-macros/0.8.6/download\"],\n strip_prefix = \"peg-macros-0.8.6\",\n build_file = Label(\"@crates//crates:BUILD.peg-macros-0.8.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__peg-runtime-0.8.6\",\n sha256 = \"7011d97b484a5ebdc4b1fdb3b12d5e4bbbea56e9d22b688f2e79e04b65a7d8a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/peg-runtime/0.8.6/download\"],\n strip_prefix = \"peg-runtime-0.8.6\",\n build_file = Label(\"@crates//crates:BUILD.peg-runtime-0.8.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pem-3.0.6\",\n sha256 = \"1d30c53c26bc5b31a98cd02d20f25a7c8567146caf63ed593a9d87b2775291be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pem/3.0.6/download\"],\n strip_prefix = \"pem-3.0.6\",\n build_file = Label(\"@crates//crates:BUILD.pem-3.0.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pem-rfc7468-0.7.0\",\n sha256 = \"88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pem-rfc7468/0.7.0/download\"],\n strip_prefix = \"pem-rfc7468-0.7.0\",\n build_file = Label(\"@crates//crates:BUILD.pem-rfc7468-0.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__percent-encoding-2.3.2\",\n sha256 = \"9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/percent-encoding/2.3.2/download\"],\n strip_prefix = \"percent-encoding-2.3.2\",\n build_file = Label(\"@crates//crates:BUILD.percent-encoding-2.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pest-2.9.0\",\n sha256 = \"5a07a60cc7a4d00c91f95c685609d1d2f79050e6804b70ebedd7650f0b839bcf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pest/2.9.0/download\"],\n strip_prefix = \"pest-2.9.0\",\n build_file = Label(\"@crates//crates:BUILD.pest-2.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pest_derive-2.9.0\",\n sha256 = \"b3a83744a5c8455b8b3e0dc5031362780a347c878bdd11584d1a8984228cc88d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pest_derive/2.9.0/download\"],\n strip_prefix = \"pest_derive-2.9.0\",\n build_file = Label(\"@crates//crates:BUILD.pest_derive-2.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pest_generator-2.9.0\",\n sha256 = \"e0cd3451aa3de60d4b9a1e736885e4dea6b31617598026f12256ad566d63304a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pest_generator/2.9.0/download\"],\n strip_prefix = \"pest_generator-2.9.0\",\n build_file = Label(\"@crates//crates:BUILD.pest_generator-2.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pest_meta-2.9.0\",\n sha256 = \"e04d3a0849e241d7dfce834c83b1c5edc8622009e8dd51a12ba1927c32f05496\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pest_meta/2.9.0/download\"],\n strip_prefix = \"pest_meta-2.9.0\",\n build_file = Label(\"@crates//crates:BUILD.pest_meta-2.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__petgraph-0.8.3\",\n sha256 = \"8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/petgraph/0.8.3/download\"],\n strip_prefix = \"petgraph-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.petgraph-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf-0.11.3\",\n sha256 = \"1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf/0.11.3/download\"],\n strip_prefix = \"phf-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.phf-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf-0.13.1\",\n sha256 = \"c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf/0.13.1/download\"],\n strip_prefix = \"phf-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.phf-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf-0.14.0\",\n sha256 = \"010378780309880b08997fae13be7834dba947d36393bd372f2b1556deb2a2f6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf/0.14.0/download\"],\n strip_prefix = \"phf-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.phf-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_codegen-0.11.3\",\n sha256 = \"aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_codegen/0.11.3/download\"],\n strip_prefix = \"phf_codegen-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.phf_codegen-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_codegen-0.13.1\",\n sha256 = \"49aa7f9d80421bca176ca8dbfebe668cc7a2684708594ec9f3c0db0805d5d6e1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_codegen/0.13.1/download\"],\n strip_prefix = \"phf_codegen-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.phf_codegen-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_generator-0.11.3\",\n sha256 = \"3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_generator/0.11.3/download\"],\n strip_prefix = \"phf_generator-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.phf_generator-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_generator-0.13.1\",\n sha256 = \"135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_generator/0.13.1/download\"],\n strip_prefix = \"phf_generator-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.phf_generator-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_generator-0.14.0\",\n sha256 = \"aeb62e0959d5a1bebc965f4d15d9e2b7cea002b6b0f5ba8cde6cc26738467100\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_generator/0.14.0/download\"],\n strip_prefix = \"phf_generator-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.phf_generator-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_macros-0.13.1\",\n sha256 = \"812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_macros/0.13.1/download\"],\n strip_prefix = \"phf_macros-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.phf_macros-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_macros-0.14.0\",\n sha256 = \"5fa8d0ca26d424d27630da600c6624696e7dec8bf7b3b492b383c5dc49e5e085\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_macros/0.14.0/download\"],\n strip_prefix = \"phf_macros-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.phf_macros-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_shared-0.11.3\",\n sha256 = \"67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_shared/0.11.3/download\"],\n strip_prefix = \"phf_shared-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.phf_shared-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_shared-0.13.1\",\n sha256 = \"e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_shared/0.13.1/download\"],\n strip_prefix = \"phf_shared-0.13.1\",\n build_file = Label(\"@crates//crates:BUILD.phf_shared-0.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__phf_shared-0.14.0\",\n sha256 = \"c6fd9027e2d9319be6349febd1db4e8d02aa544921200c9b777720ac34a3aa89\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/phf_shared/0.14.0/download\"],\n strip_prefix = \"phf_shared-0.14.0\",\n build_file = Label(\"@crates//crates:BUILD.phf_shared-0.14.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pico-args-0.5.0\",\n sha256 = \"5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pico-args/0.5.0/download\"],\n strip_prefix = \"pico-args-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.pico-args-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pin-project-lite-0.2.17\",\n sha256 = \"a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pin-project-lite/0.2.17/download\"],\n strip_prefix = \"pin-project-lite-0.2.17\",\n build_file = Label(\"@crates//crates:BUILD.pin-project-lite-0.2.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pin-utils-0.1.0\",\n sha256 = \"8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pin-utils/0.1.0/download\"],\n strip_prefix = \"pin-utils-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.pin-utils-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__piper-0.2.5\",\n sha256 = \"c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/piper/0.2.5/download\"],\n strip_prefix = \"piper-0.2.5\",\n build_file = Label(\"@crates//crates:BUILD.piper-0.2.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pipewire-0.9.2\",\n sha256 = \"9688b89abf11d756499f7c6190711d6dbe5a3acdb30c8fbf001d6596d06a8d44\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pipewire/0.9.2/download\"],\n strip_prefix = \"pipewire-0.9.2\",\n build_file = Label(\"@crates//crates:BUILD.pipewire-0.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pipewire-sys-0.9.2\",\n sha256 = \"cb028afee0d6ca17020b090e3b8fa2d7de23305aef975c7e5192a5050246ea36\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pipewire-sys/0.9.2/download\"],\n strip_prefix = \"pipewire-sys-0.9.2\",\n build_file = Label(\"@crates//crates:BUILD.pipewire-sys-0.9.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pkcs8-0.10.2\",\n sha256 = \"f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pkcs8/0.10.2/download\"],\n strip_prefix = \"pkcs8-0.10.2\",\n build_file = Label(\"@crates//crates:BUILD.pkcs8-0.10.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pkg-config-0.3.34\",\n sha256 = \"f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pkg-config/0.3.34/download\"],\n strip_prefix = \"pkg-config-0.3.34\",\n build_file = Label(\"@crates//crates:BUILD.pkg-config-0.3.34.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__platform-info-2.1.0\",\n sha256 = \"9368d62437c8cbb7c31ee37fd8c08a7d390e09a3ff75698a674953f46705ffcb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/platform-info/2.1.0/download\"],\n strip_prefix = \"platform-info-2.1.0\",\n build_file = Label(\"@crates//crates:BUILD.platform-info-2.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__png-0.18.1\",\n sha256 = \"60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/png/0.18.1/download\"],\n strip_prefix = \"png-0.18.1\",\n build_file = Label(\"@crates//crates:BUILD.png-0.18.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__polling-3.11.0\",\n sha256 = \"5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/polling/3.11.0/download\"],\n strip_prefix = \"polling-3.11.0\",\n build_file = Label(\"@crates//crates:BUILD.polling-3.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pollster-1.0.1\",\n sha256 = \"bc6355899e1c9462875b6757c79f3caa011a1fdae12bbb1a2e72dd1f234f8336\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pollster/1.0.1/download\"],\n strip_prefix = \"pollster-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.pollster-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__poly1305-0.8.0\",\n sha256 = \"8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/poly1305/0.8.0/download\"],\n strip_prefix = \"poly1305-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.poly1305-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__polycool-0.4.0\",\n sha256 = \"50596ddc09eb5ad5f75cacd40209568e66df71baf86e1499a0e99c4cff12a5a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/polycool/0.4.0/download\"],\n strip_prefix = \"polycool-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.polycool-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__polyval-0.6.2\",\n sha256 = \"9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/polyval/0.6.2/download\"],\n strip_prefix = \"polyval-0.6.2\",\n build_file = Label(\"@crates//crates:BUILD.polyval-0.6.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__portable-atomic-1.15.0\",\n sha256 = \"05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/portable-atomic/1.15.0/download\"],\n strip_prefix = \"portable-atomic-1.15.0\",\n build_file = Label(\"@crates//crates:BUILD.portable-atomic-1.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__portable-atomic-util-0.2.7\",\n sha256 = \"c2a106d1259c23fac8e543272398ae0e3c0b8d33c88ed73d0cc71b0f1d902618\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/portable-atomic-util/0.2.7/download\"],\n strip_prefix = \"portable-atomic-util-0.2.7\",\n build_file = Label(\"@crates//crates:BUILD.portable-atomic-util-0.2.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__portable-pty-0.9.0\",\n sha256 = \"b4a596a2b3d2752d94f51fac2d4a96737b8705dddd311a32b9af47211f08671e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/portable-pty/0.9.0/download\"],\n strip_prefix = \"portable-pty-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.portable-pty-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__potential_utf-0.1.6\",\n sha256 = \"d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/potential_utf/0.1.6/download\"],\n strip_prefix = \"potential_utf-0.1.6\",\n build_file = Label(\"@crates//crates:BUILD.potential_utf-0.1.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__powerfmt-0.2.0\",\n sha256 = \"439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/powerfmt/0.2.0/download\"],\n strip_prefix = \"powerfmt-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.powerfmt-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ppv-lite86-0.2.21\",\n sha256 = \"85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ppv-lite86/0.2.21/download\"],\n strip_prefix = \"ppv-lite86-0.2.21\",\n build_file = Label(\"@crates//crates:BUILD.ppv-lite86-0.2.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__precomputed-hash-0.1.1\",\n sha256 = \"925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/precomputed-hash/0.1.1/download\"],\n strip_prefix = \"precomputed-hash-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.precomputed-hash-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pretty_assertions-1.4.1\",\n sha256 = \"3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pretty_assertions/1.4.1/download\"],\n strip_prefix = \"pretty_assertions-1.4.1\",\n build_file = Label(\"@crates//crates:BUILD.pretty_assertions-1.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__prettyplease-0.3.0\",\n sha256 = \"2bfe0f4c752e450fc2faf62654f1c134747922825d5b04ca717b8874f41a40c0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/prettyplease/0.3.0/download\"],\n strip_prefix = \"prettyplease-0.3.0\",\n build_file = Label(\"@crates//crates:BUILD.prettyplease-0.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__primeorder-0.13.6\",\n sha256 = \"353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/primeorder/0.13.6/download\"],\n strip_prefix = \"primeorder-0.13.6\",\n build_file = Label(\"@crates//crates:BUILD.primeorder-0.13.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__proc-macro-crate-3.5.0\",\n sha256 = \"e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/proc-macro-crate/3.5.0/download\"],\n strip_prefix = \"proc-macro-crate-3.5.0\",\n build_file = Label(\"@crates//crates:BUILD.proc-macro-crate-3.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__proc-macro2-1.0.107\",\n sha256 = \"985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/proc-macro2/1.0.107/download\"],\n strip_prefix = \"proc-macro2-1.0.107\",\n build_file = Label(\"@crates//crates:BUILD.proc-macro2-1.0.107.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__procfs-0.18.0\",\n sha256 = \"25485360a54d6861439d60facef26de713b1e126bf015ec8f98239467a2b82f7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/procfs/0.18.0/download\"],\n strip_prefix = \"procfs-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.procfs-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__procfs-core-0.18.0\",\n sha256 = \"e6401bf7b6af22f78b563665d15a22e9aef27775b79b149a66ca022468a4e405\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/procfs-core/0.18.0/download\"],\n strip_prefix = \"procfs-core-0.18.0\",\n build_file = Label(\"@crates//crates:BUILD.procfs-core-0.18.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__prodash-31.0.0\",\n sha256 = \"962200e2d7d551451297d9fdce85138374019ada198e30ea9ede38034e27604c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/prodash/31.0.0/download\"],\n strip_prefix = \"prodash-31.0.0\",\n build_file = Label(\"@crates//crates:BUILD.prodash-31.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__prost-0.14.4\",\n sha256 = \"528ac67416ff8646872a3c02cad9cc4ee5dc9f9540c9b10771855c95cb2e5ae1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/prost/0.14.4/download\"],\n strip_prefix = \"prost-0.14.4\",\n build_file = Label(\"@crates//crates:BUILD.prost-0.14.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__prost-derive-0.14.4\",\n sha256 = \"b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/prost-derive/0.14.4/download\"],\n strip_prefix = \"prost-derive-0.14.4\",\n build_file = Label(\"@crates//crates:BUILD.prost-derive-0.14.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ptr_meta-0.3.2\",\n sha256 = \"743da816b98c921cdbe8628ef7381b76f25ecf4da599fc80aca90eae7ef70cc0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ptr_meta/0.3.2/download\"],\n strip_prefix = \"ptr_meta-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.ptr_meta-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ptr_meta_derive-0.3.2\",\n sha256 = \"1c8d9ca532f185d5d4db7a7c9d51420b452168ea1c2b913953281bd6fe1fcbd0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ptr_meta_derive/0.3.2/download\"],\n strip_prefix = \"ptr_meta_derive-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.ptr_meta_derive-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__pxfm-0.1.30\",\n sha256 = \"d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/pxfm/0.1.30/download\"],\n strip_prefix = \"pxfm-0.1.30\",\n build_file = Label(\"@crates//crates:BUILD.pxfm-0.1.30.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quantette-0.6.0\",\n sha256 = \"ba5d37e94c17b8870a5b936001d2845a6782a22ebdb1706c84294eca777f6729\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quantette/0.6.0/download\"],\n strip_prefix = \"quantette-0.6.0\",\n build_file = Label(\"@crates//crates:BUILD.quantette-0.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quick-error-2.0.1\",\n sha256 = \"a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quick-error/2.0.1/download\"],\n strip_prefix = \"quick-error-2.0.1\",\n build_file = Label(\"@crates//crates:BUILD.quick-error-2.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quick-xml-0.41.0\",\n sha256 = \"e660451e55124f798a69a5af3f49ccfbefbd41910eefd25caf2393e1f3473ec1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quick-xml/0.41.0/download\"],\n strip_prefix = \"quick-xml-0.41.0\",\n build_file = Label(\"@crates//crates:BUILD.quick-xml-0.41.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__quote-1.0.47\",\n sha256 = \"1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/quote/1.0.47/download\"],\n strip_prefix = \"quote-1.0.47\",\n build_file = Label(\"@crates//crates:BUILD.quote-1.0.47.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__r-efi-5.3.0\",\n sha256 = \"69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/r-efi/5.3.0/download\"],\n strip_prefix = \"r-efi-5.3.0\",\n build_file = Label(\"@crates//crates:BUILD.r-efi-5.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__r-efi-6.0.0\",\n sha256 = \"f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/r-efi/6.0.0/download\"],\n strip_prefix = \"r-efi-6.0.0\",\n build_file = Label(\"@crates//crates:BUILD.r-efi-6.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__radium-0.7.0\",\n sha256 = \"dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/radium/0.7.0/download\"],\n strip_prefix = \"radium-0.7.0\",\n build_file = Label(\"@crates//crates:BUILD.radium-0.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rancor-0.1.3\",\n sha256 = \"9b534442d0fcdb55d66f373d9cac6d33b6293a2335bc2136dbd06ce0e87d2572\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rancor/0.1.3/download\"],\n strip_prefix = \"rancor-0.1.3\",\n build_file = Label(\"@crates//crates:BUILD.rancor-0.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand-0.10.2\",\n sha256 = \"c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand/0.10.2/download\"],\n strip_prefix = \"rand-0.10.2\",\n build_file = Label(\"@crates//crates:BUILD.rand-0.10.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand-0.8.8\",\n sha256 = \"e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand/0.8.8/download\"],\n strip_prefix = \"rand-0.8.8\",\n build_file = Label(\"@crates//crates:BUILD.rand-0.8.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand-0.9.5\",\n sha256 = \"b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand/0.9.5/download\"],\n strip_prefix = \"rand-0.9.5\",\n build_file = Label(\"@crates//crates:BUILD.rand-0.9.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand_chacha-0.10.0\",\n sha256 = \"3e6af7f3e25ded52c41df4e0b1af2d047e45896c2f3281792ed68a1c243daedb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand_chacha/0.10.0/download\"],\n strip_prefix = \"rand_chacha-0.10.0\",\n build_file = Label(\"@crates//crates:BUILD.rand_chacha-0.10.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand_chacha-0.9.0\",\n sha256 = \"d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand_chacha/0.9.0/download\"],\n strip_prefix = \"rand_chacha-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.rand_chacha-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand_core-0.10.1\",\n sha256 = \"63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand_core/0.10.1/download\"],\n strip_prefix = \"rand_core-0.10.1\",\n build_file = Label(\"@crates//crates:BUILD.rand_core-0.10.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand_core-0.6.4\",\n sha256 = \"ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand_core/0.6.4/download\"],\n strip_prefix = \"rand_core-0.6.4\",\n build_file = Label(\"@crates//crates:BUILD.rand_core-0.6.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand_core-0.9.5\",\n sha256 = \"76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand_core/0.9.5/download\"],\n strip_prefix = \"rand_core-0.9.5\",\n build_file = Label(\"@crates//crates:BUILD.rand_core-0.9.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rand_xoshiro-0.8.1\",\n sha256 = \"662effc7698e08ea324d3acccf8d9d7f7bf79b9785e270a174ea36e56900c91d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rand_xoshiro/0.8.1/download\"],\n strip_prefix = \"rand_xoshiro-0.8.1\",\n build_file = Label(\"@crates//crates:BUILD.rand_xoshiro-0.8.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rangemap-1.8.0\",\n sha256 = \"a611d15b50743feb4c76b7d03edcb0e64f399c26961e4efe6975bc398be6aa3d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rangemap/1.8.0/download\"],\n strip_prefix = \"rangemap-1.8.0\",\n build_file = Label(\"@crates//crates:BUILD.rangemap-1.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-1.12.0\",\n sha256 = \"fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon/1.12.0/download\"],\n strip_prefix = \"rayon-1.12.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-1.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rayon-core-1.13.0\",\n sha256 = \"22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rayon-core/1.13.0/download\"],\n strip_prefix = \"rayon-core-1.13.0\",\n build_file = Label(\"@crates//crates:BUILD.rayon-core-1.13.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rcgen-0.13.2\",\n sha256 = \"75e669e5202259b5314d1ea5397316ad400819437857b90861765f24c4cf80a2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rcgen/0.13.2/download\"],\n strip_prefix = \"rcgen-0.13.2\",\n build_file = Label(\"@crates//crates:BUILD.rcgen-0.13.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__read-fonts-0.41.0\",\n sha256 = \"046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/read-fonts/0.41.0/download\"],\n strip_prefix = \"read-fonts-0.41.0\",\n build_file = Label(\"@crates//crates:BUILD.read-fonts-0.41.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__redox_syscall-0.5.18\",\n sha256 = \"ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/redox_syscall/0.5.18/download\"],\n strip_prefix = \"redox_syscall-0.5.18\",\n build_file = Label(\"@crates//crates:BUILD.redox_syscall-0.5.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ref-cast-1.0.27\",\n sha256 = \"7e440fb4e4b4147295338efb76001ab9e4efc0e5839df2c47fc5ac2381d365c3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ref-cast/1.0.27/download\"],\n strip_prefix = \"ref-cast-1.0.27\",\n build_file = Label(\"@crates//crates:BUILD.ref-cast-1.0.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ref-cast-impl-1.0.27\",\n sha256 = \"92ecd8964f8453721699a1ed72037b0db49ce2f5a5138486ee89bed6f67cdf3a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ref-cast-impl/1.0.27/download\"],\n strip_prefix = \"ref-cast-impl-1.0.27\",\n build_file = Label(\"@crates//crates:BUILD.ref-cast-impl-1.0.27.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-1.13.1\",\n sha256 = \"f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex/1.13.1/download\"],\n strip_prefix = \"regex-1.13.1\",\n build_file = Label(\"@crates//crates:BUILD.regex-1.13.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-automata-0.4.18\",\n sha256 = \"ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-automata/0.4.18/download\"],\n strip_prefix = \"regex-automata-0.4.18\",\n build_file = Label(\"@crates//crates:BUILD.regex-automata-0.4.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-lite-0.1.9\",\n sha256 = \"cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-lite/0.1.9/download\"],\n strip_prefix = \"regex-lite-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.regex-lite-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__regex-syntax-0.8.11\",\n sha256 = \"d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/regex-syntax/0.8.11/download\"],\n strip_prefix = \"regex-syntax-0.8.11\",\n build_file = Label(\"@crates//crates:BUILD.regex-syntax-0.8.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__reis-0.5.0\",\n sha256 = \"00939c5c526a1b4054ef8d9d96b3f92227f08ca355965e986741b556eda6d289\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/reis/0.5.0/download\"],\n strip_prefix = \"reis-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.reis-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rend-0.5.4\",\n sha256 = \"663ba70707f96e871406fe10d68128412e619b06d1d47cb91c3a4c6501176240\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rend/0.5.4/download\"],\n strip_prefix = \"rend-0.5.4\",\n build_file = Label(\"@crates//crates:BUILD.rend-0.5.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__resvg-0.48.1\",\n sha256 = \"67e3803f97b999e80cbf7c6ecdd07a8102204d92e1633cf48783720c521196bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/resvg/0.48.1/download\"],\n strip_prefix = \"resvg-0.48.1\",\n build_file = Label(\"@crates//crates:BUILD.resvg-0.48.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rfc6979-0.4.0\",\n sha256 = \"f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rfc6979/0.4.0/download\"],\n strip_prefix = \"rfc6979-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.rfc6979-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rgb-0.8.53\",\n sha256 = \"47b34b781b31e5d73e9fbc8689c70551fd1ade9a19e3e28cfec8580a79290cc4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rgb/0.8.53/download\"],\n strip_prefix = \"rgb-0.8.53\",\n build_file = Label(\"@crates//crates:BUILD.rgb-0.8.53.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ring-0.17.14\",\n sha256 = \"a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ring/0.17.14/download\"],\n strip_prefix = \"ring-0.17.14\",\n build_file = Label(\"@crates//crates:BUILD.ring-0.17.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rkyv-0.8.18\",\n sha256 = \"d9776093b7ca170454ab1406954f7b7d97a57c51dc6c0642957fb2ef25c2d399\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rkyv/0.8.18/download\"],\n strip_prefix = \"rkyv-0.8.18\",\n build_file = Label(\"@crates//crates:BUILD.rkyv-0.8.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rkyv_derive-0.8.18\",\n sha256 = \"1c25ef604ac7dd839d44d64648952ea23c97866f124ff671b0ed2cf3ad9bb06e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rkyv_derive/0.8.18/download\"],\n strip_prefix = \"rkyv_derive-0.8.18\",\n build_file = Label(\"@crates//crates:BUILD.rkyv_derive-0.8.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rlimit-0.11.0\",\n sha256 = \"f35ee2729c56bb610f6dba436bf78135f728b7373bdffae2ec815b2d3eb98cc3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rlimit/0.11.0/download\"],\n strip_prefix = \"rlimit-0.11.0\",\n build_file = Label(\"@crates//crates:BUILD.rlimit-0.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__roxmltree-0.20.0\",\n sha256 = \"6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/roxmltree/0.20.0/download\"],\n strip_prefix = \"roxmltree-0.20.0\",\n build_file = Label(\"@crates//crates:BUILD.roxmltree-0.20.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__roxmltree-0.21.1\",\n sha256 = \"f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/roxmltree/0.21.1/download\"],\n strip_prefix = \"roxmltree-0.21.1\",\n build_file = Label(\"@crates//crates:BUILD.roxmltree-0.21.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rpds-1.2.1\",\n sha256 = \"e025feb26210bc196b908e72deb063b1b4000754304341cbc168a1e72c857ebc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rpds/1.2.1/download\"],\n strip_prefix = \"rpds-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.rpds-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rtcp-0.17.2\",\n sha256 = \"adad7f6a501162881032fc84b4bc78ae11f1b30748180b9f5cbe8810bf613aab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rtcp/0.17.2/download\"],\n strip_prefix = \"rtcp-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.rtcp-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rtp-0.17.2\",\n sha256 = \"149329e78ada26b5e174a4c281a7a7e5c8bda6008adc90daddd6f98fce56db29\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rtp/0.17.2/download\"],\n strip_prefix = \"rtp-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.rtp-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustc-hash-1.1.0\",\n sha256 = \"08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustc-hash/1.1.0/download\"],\n strip_prefix = \"rustc-hash-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.rustc-hash-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustc-hash-2.1.3\",\n sha256 = \"6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustc-hash/2.1.3/download\"],\n strip_prefix = \"rustc-hash-2.1.3\",\n build_file = Label(\"@crates//crates:BUILD.rustc-hash-2.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustc_version-0.4.1\",\n sha256 = \"cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustc_version/0.4.1/download\"],\n strip_prefix = \"rustc_version-0.4.1\",\n build_file = Label(\"@crates//crates:BUILD.rustc_version-0.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rusticata-macros-4.1.0\",\n sha256 = \"faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rusticata-macros/4.1.0/download\"],\n strip_prefix = \"rusticata-macros-4.1.0\",\n build_file = Label(\"@crates//crates:BUILD.rusticata-macros-4.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustix-0.38.44\",\n sha256 = \"fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustix/0.38.44/download\"],\n strip_prefix = \"rustix-0.38.44\",\n build_file = Label(\"@crates//crates:BUILD.rustix-0.38.44.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustix-1.1.4\",\n sha256 = \"b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustix/1.1.4/download\"],\n strip_prefix = \"rustix-1.1.4\",\n build_file = Label(\"@crates//crates:BUILD.rustix-1.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustls-0.23.43\",\n sha256 = \"0283386ce02abc0151e1761d08802dfe86c173b0b494af5cbc086574e453da06\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustls/0.23.43/download\"],\n strip_prefix = \"rustls-0.23.43\",\n build_file = Label(\"@crates//crates:BUILD.rustls-0.23.43.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustls-pki-types-1.15.1\",\n sha256 = \"2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustls-pki-types/1.15.1/download\"],\n strip_prefix = \"rustls-pki-types-1.15.1\",\n build_file = Label(\"@crates//crates:BUILD.rustls-pki-types-1.15.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustls-webpki-0.103.15\",\n sha256 = \"f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustls-webpki/0.103.15/download\"],\n strip_prefix = \"rustls-webpki-0.103.15\",\n build_file = Label(\"@crates//crates:BUILD.rustls-webpki-0.103.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__rustversion-1.0.23\",\n sha256 = \"cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/rustversion/1.0.23/download\"],\n strip_prefix = \"rustversion-1.0.23\",\n build_file = Label(\"@crates//crates:BUILD.rustversion-1.0.23.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__safe_arch-1.2.0\",\n sha256 = \"42c6efa15875e6ecb39ca61fb0b0c1a40b84fac5a5ffe71eef7d1000c8eb3f5f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/safe_arch/1.2.0/download\"],\n strip_prefix = \"safe_arch-1.2.0\",\n build_file = Label(\"@crates//crates:BUILD.safe_arch-1.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__same-file-1.0.6\",\n sha256 = \"93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/same-file/1.0.6/download\"],\n strip_prefix = \"same-file-1.0.6\",\n build_file = Label(\"@crates//crates:BUILD.same-file-1.0.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__scoped-tls-1.0.1\",\n sha256 = \"e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/scoped-tls/1.0.1/download\"],\n strip_prefix = \"scoped-tls-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.scoped-tls-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__scopeguard-1.2.0\",\n sha256 = \"94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/scopeguard/1.2.0/download\"],\n strip_prefix = \"scopeguard-1.2.0\",\n build_file = Label(\"@crates//crates:BUILD.scopeguard-1.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sdp-0.17.2\",\n sha256 = \"66b6eecfa5151edef84d544ff3885dff98e5b5fe97586757a4b5118bde51c958\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sdp/0.17.2/download\"],\n strip_prefix = \"sdp-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.sdp-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sec1-0.7.3\",\n sha256 = \"d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sec1/0.7.3/download\"],\n strip_prefix = \"sec1-0.7.3\",\n build_file = Label(\"@crates//crates:BUILD.sec1-0.7.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__self_cell-1.3.0\",\n sha256 = \"2ab42ca02749e120097e328d91d415325bdf43b1c72c4c8badf37375fe40a813\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/self_cell/1.3.0/download\"],\n strip_prefix = \"self_cell-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.self_cell-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__semver-1.0.28\",\n sha256 = \"8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/semver/1.0.28/download\"],\n strip_prefix = \"semver-1.0.28\",\n build_file = Label(\"@crates//crates:BUILD.semver-1.0.28.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde-1.0.229\",\n sha256 = \"4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde/1.0.229/download\"],\n strip_prefix = \"serde-1.0.229\",\n build_file = Label(\"@crates//crates:BUILD.serde-1.0.229.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_core-1.0.229\",\n sha256 = \"67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_core/1.0.229/download\"],\n strip_prefix = \"serde_core-1.0.229\",\n build_file = Label(\"@crates//crates:BUILD.serde_core-1.0.229.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_derive-1.0.229\",\n sha256 = \"e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_derive/1.0.229/download\"],\n strip_prefix = \"serde_derive-1.0.229\",\n build_file = Label(\"@crates//crates:BUILD.serde_derive-1.0.229.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_json-1.0.151\",\n sha256 = \"c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_json/1.0.151/download\"],\n strip_prefix = \"serde_json-1.0.151\",\n build_file = Label(\"@crates//crates:BUILD.serde_json-1.0.151.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_repr-0.1.21\",\n sha256 = \"8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_repr/0.1.21/download\"],\n strip_prefix = \"serde_repr-0.1.21\",\n build_file = Label(\"@crates//crates:BUILD.serde_repr-0.1.21.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serde_spanned-1.1.1\",\n sha256 = \"6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serde_spanned/1.1.1/download\"],\n strip_prefix = \"serde_spanned-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.serde_spanned-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__serial2-0.2.38\",\n sha256 = \"b16809bc35793b19ce4e0c53924bc0dce3937f15487997cfdaed936004180730\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/serial2/0.2.38/download\"],\n strip_prefix = \"serial2-0.2.38\",\n build_file = Label(\"@crates//crates:BUILD.serial2-0.2.38.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sha1-0.10.7\",\n sha256 = \"a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sha1/0.10.7/download\"],\n strip_prefix = \"sha1-0.10.7\",\n build_file = Label(\"@crates//crates:BUILD.sha1-0.10.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sha1-checked-0.10.0\",\n sha256 = \"89f599ac0c323ebb1c6082821a54962b839832b03984598375bff3975b804423\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sha1-checked/0.10.0/download\"],\n strip_prefix = \"sha1-checked-0.10.0\",\n build_file = Label(\"@crates//crates:BUILD.sha1-checked-0.10.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sha2-0.10.9\",\n sha256 = \"a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sha2/0.10.9/download\"],\n strip_prefix = \"sha2-0.10.9\",\n build_file = Label(\"@crates//crates:BUILD.sha2-0.10.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sha2-0.11.0\",\n sha256 = \"446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sha2/0.11.0/download\"],\n strip_prefix = \"sha2-0.11.0\",\n build_file = Label(\"@crates//crates:BUILD.sha2-0.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sha2-asm-0.6.4\",\n sha256 = \"b845214d6175804686b2bd482bcffe96651bb2d1200742b712003504a2dac1ab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sha2-asm/0.6.4/download\"],\n strip_prefix = \"sha2-asm-0.6.4\",\n build_file = Label(\"@crates//crates:BUILD.sha2-asm-0.6.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sha3-0.10.9\",\n sha256 = \"77fd7028345d415a4034cf8777cd4f8ab1851274233b45f84e3d955502d93874\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sha3/0.10.9/download\"],\n strip_prefix = \"sha3-0.10.9\",\n build_file = Label(\"@crates//crates:BUILD.sha3-0.10.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shared_library-0.1.9\",\n sha256 = \"5a9e7e0f2bfae24d8a5b5a66c5b257a83c7412304311512a0c054cd5e619da11\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shared_library/0.1.9/download\"],\n strip_prefix = \"shared_library-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.shared_library-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shell-words-1.1.1\",\n sha256 = \"dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shell-words/1.1.1/download\"],\n strip_prefix = \"shell-words-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.shell-words-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shlex-1.3.0\",\n sha256 = \"0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shlex/1.3.0/download\"],\n strip_prefix = \"shlex-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.shlex-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__shlex-2.0.1\",\n sha256 = \"f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/shlex/2.0.1/download\"],\n strip_prefix = \"shlex-2.0.1\",\n build_file = Label(\"@crates//crates:BUILD.shlex-2.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__signal-hook-registry-1.4.8\",\n sha256 = \"c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/signal-hook-registry/1.4.8/download\"],\n strip_prefix = \"signal-hook-registry-1.4.8\",\n build_file = Label(\"@crates//crates:BUILD.signal-hook-registry-1.4.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__signature-2.2.0\",\n sha256 = \"77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/signature/2.2.0/download\"],\n strip_prefix = \"signature-2.2.0\",\n build_file = Label(\"@crates//crates:BUILD.signature-2.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__simd-adler32-0.3.10\",\n sha256 = \"3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/simd-adler32/0.3.10/download\"],\n strip_prefix = \"simd-adler32-0.3.10\",\n build_file = Label(\"@crates//crates:BUILD.simd-adler32-0.3.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__simdutf8-0.1.5\",\n sha256 = \"e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/simdutf8/0.1.5/download\"],\n strip_prefix = \"simdutf8-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.simdutf8-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__similar-2.7.0\",\n sha256 = \"bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/similar/2.7.0/download\"],\n strip_prefix = \"similar-2.7.0\",\n build_file = Label(\"@crates//crates:BUILD.similar-2.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__similar-3.2.0\",\n sha256 = \"4f66ca1f7aca2474dc10c942eb22feffc897735f54cd1db90138c2fddb490987\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/similar/3.2.0/download\"],\n strip_prefix = \"similar-3.2.0\",\n build_file = Label(\"@crates//crates:BUILD.similar-3.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__simplecss-0.2.2\",\n sha256 = \"7a9c6883ca9c3c7c90e888de77b7a5c849c779d25d74a1269b0218b14e8b136c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/simplecss/0.2.2/download\"],\n strip_prefix = \"simplecss-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.simplecss-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__siphasher-1.0.3\",\n sha256 = \"8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/siphasher/1.0.3/download\"],\n strip_prefix = \"siphasher-1.0.3\",\n build_file = Label(\"@crates//crates:BUILD.siphasher-1.0.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__skrifa-0.44.0\",\n sha256 = \"819ab7d62b1d3e72d9d9dea5650bac30424f9111364bb94928dbf5ecad1baa68\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/skrifa/0.44.0/download\"],\n strip_prefix = \"skrifa-0.44.0\",\n build_file = Label(\"@crates//crates:BUILD.skrifa-0.44.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__slab-0.4.12\",\n sha256 = \"0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/slab/0.4.12/download\"],\n strip_prefix = \"slab-0.4.12\",\n build_file = Label(\"@crates//crates:BUILD.slab-0.4.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__slotmap-1.1.1\",\n sha256 = \"bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/slotmap/1.1.1/download\"],\n strip_prefix = \"slotmap-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.slotmap-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__sm3-0.5.0\",\n sha256 = \"da6a89ba31723d185fd7413b98c576a575f356d9b84729d8ecb6ead60000a5b6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/sm3/0.5.0/download\"],\n strip_prefix = \"sm3-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.sm3-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__smallvec-1.15.2\",\n sha256 = \"8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/smallvec/1.15.2/download\"],\n strip_prefix = \"smallvec-1.15.2\",\n build_file = Label(\"@crates//crates:BUILD.smallvec-1.15.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__smol_str-0.2.2\",\n sha256 = \"dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/smol_str/0.2.2/download\"],\n strip_prefix = \"smol_str-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.smol_str-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__socket2-0.5.10\",\n sha256 = \"e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/socket2/0.5.10/download\"],\n strip_prefix = \"socket2-0.5.10\",\n build_file = Label(\"@crates//crates:BUILD.socket2-0.5.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__socket2-0.6.5\",\n sha256 = \"c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/socket2/0.6.5/download\"],\n strip_prefix = \"socket2-0.6.5\",\n build_file = Label(\"@crates//crates:BUILD.socket2-0.6.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__spin-0.10.1\",\n sha256 = \"023a211cb3138dbc438680b32560ad89f699977624c9f8dbb95a47d5b4c07dd3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/spin/0.10.1/download\"],\n strip_prefix = \"spin-0.10.1\",\n build_file = Label(\"@crates//crates:BUILD.spin-0.10.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__spin-0.9.9\",\n sha256 = \"3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/spin/0.9.9/download\"],\n strip_prefix = \"spin-0.9.9\",\n build_file = Label(\"@crates//crates:BUILD.spin-0.9.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__spki-0.7.3\",\n sha256 = \"d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/spki/0.7.3/download\"],\n strip_prefix = \"spki-0.7.3\",\n build_file = Label(\"@crates//crates:BUILD.spki-0.7.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__stable_deref_trait-1.2.1\",\n sha256 = \"6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/stable_deref_trait/1.2.1/download\"],\n strip_prefix = \"stable_deref_trait-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.stable_deref_trait-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__static_assertions-1.1.0\",\n sha256 = \"a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/static_assertions/1.1.0/download\"],\n strip_prefix = \"static_assertions-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.static_assertions-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__str_stack-0.1.1\",\n sha256 = \"7f446288b699d66d0fd2e30d1cfe7869194312524b3b9252594868ed26ef056a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/str_stack/0.1.1/download\"],\n strip_prefix = \"str_stack-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.str_stack-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__streaming-iterator-0.1.9\",\n sha256 = \"2b2231b7c3057d5e4ad0156fb3dc807d900806020c5ffa3ee6ff2c8c76fb8520\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/streaming-iterator/0.1.9/download\"],\n strip_prefix = \"streaming-iterator-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.streaming-iterator-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strict-num-0.1.1\",\n sha256 = \"6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strict-num/0.1.1/download\"],\n strip_prefix = \"strict-num-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.strict-num-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__string_cache-0.9.0\",\n sha256 = \"a18596f8c785a729f2819c0f6a7eae6ebeebdfffbfe4214ae6b087f690e31901\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/string_cache/0.9.0/download\"],\n strip_prefix = \"string_cache-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.string_cache-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__string_cache_codegen-0.6.1\",\n sha256 = \"585635e46db231059f76c5849798146164652513eb9e8ab2685939dd90f29b69\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/string_cache_codegen/0.6.1/download\"],\n strip_prefix = \"string_cache_codegen-0.6.1\",\n build_file = Label(\"@crates//crates:BUILD.string_cache_codegen-0.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__stringprep-0.1.5\",\n sha256 = \"7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/stringprep/0.1.5/download\"],\n strip_prefix = \"stringprep-0.1.5\",\n build_file = Label(\"@crates//crates:BUILD.stringprep-0.1.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strsim-0.11.1\",\n sha256 = \"7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strsim/0.11.1/download\"],\n strip_prefix = \"strsim-0.11.1\",\n build_file = Label(\"@crates//crates:BUILD.strsim-0.11.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum-0.28.0\",\n sha256 = \"9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum/0.28.0/download\"],\n strip_prefix = \"strum-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__strum_macros-0.28.0\",\n sha256 = \"ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/strum_macros/0.28.0/download\"],\n strip_prefix = \"strum_macros-0.28.0\",\n build_file = Label(\"@crates//crates:BUILD.strum_macros-0.28.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__stun-0.17.2\",\n sha256 = \"2e3b8d5ad1dd4c8cd0595440f26521a71dd593cb5873ee8e06b91510b7d97269\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/stun/0.17.2/download\"],\n strip_prefix = \"stun-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.stun-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__substring-1.4.5\",\n sha256 = \"42ee6433ecef213b2e72f587ef64a2f5943e7cd16fbd82dbe8bc07486c534c86\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/substring/1.4.5/download\"],\n strip_prefix = \"substring-1.4.5\",\n build_file = Label(\"@crates//crates:BUILD.substring-1.4.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__subtle-2.6.1\",\n sha256 = \"13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/subtle/2.6.1/download\"],\n strip_prefix = \"subtle-2.6.1\",\n build_file = Label(\"@crates//crates:BUILD.subtle-2.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__svgtypes-0.16.1\",\n sha256 = \"695b5790b3131dafa99b3bbfd25a216edb3d216dad9ca208d4657bfb8f2abc3d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/svgtypes/0.16.1/download\"],\n strip_prefix = \"svgtypes-0.16.1\",\n build_file = Label(\"@crates//crates:BUILD.svgtypes-0.16.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__syn-2.0.119\",\n sha256 = \"872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/syn/2.0.119/download\"],\n strip_prefix = \"syn-2.0.119\",\n build_file = Label(\"@crates//crates:BUILD.syn-2.0.119.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__syn-3.0.4\",\n sha256 = \"e6275cddf4610d1775e6d1fe9469b2e77d0f39fd98fb7450901b821e0c53649f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/syn/3.0.4/download\"],\n strip_prefix = \"syn-3.0.4\",\n build_file = Label(\"@crates//crates:BUILD.syn-3.0.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__synstructure-0.13.2\",\n sha256 = \"728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/synstructure/0.13.2/download\"],\n strip_prefix = \"synstructure-0.13.2\",\n build_file = Label(\"@crates//crates:BUILD.synstructure-0.13.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__syntect-5.3.0\",\n sha256 = \"656b45c05d95a5704399aeef6bd0ddec7b2b3531b7c9e900abbf7c4d2190c925\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/syntect/5.3.0/download\"],\n strip_prefix = \"syntect-5.3.0\",\n build_file = Label(\"@crates//crates:BUILD.syntect-5.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__system-deps-7.0.8\",\n sha256 = \"396a35feb67335377e0251fcbc1092fc85c484bd4e3a7a54319399da127796e7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/system-deps/7.0.8/download\"],\n strip_prefix = \"system-deps-7.0.8\",\n build_file = Label(\"@crates//crates:BUILD.system-deps-7.0.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tap-1.0.1\",\n sha256 = \"55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tap/1.0.1/download\"],\n strip_prefix = \"tap-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.tap-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__target-lexicon-0.13.5\",\n sha256 = \"adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/target-lexicon/0.13.5/download\"],\n strip_prefix = \"target-lexicon-0.13.5\",\n build_file = Label(\"@crates//crates:BUILD.target-lexicon-0.13.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tempfile-3.27.0\",\n sha256 = \"32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tempfile/3.27.0/download\"],\n strip_prefix = \"tempfile-3.27.0\",\n build_file = Label(\"@crates//crates:BUILD.tempfile-3.27.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tendril-0.5.1\",\n sha256 = \"5fed54709c5b3a53d09bb1c113ea4f5ceafd1e772ddcb0030a82e1d56c087b08\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tendril/0.5.1/download\"],\n strip_prefix = \"tendril-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.tendril-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__termcolor-1.4.1\",\n sha256 = \"06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/termcolor/1.4.1/download\"],\n strip_prefix = \"termcolor-1.4.1\",\n build_file = Label(\"@crates//crates:BUILD.termcolor-1.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__terminal_size-0.4.4\",\n sha256 = \"230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/terminal_size/0.4.4/download\"],\n strip_prefix = \"terminal_size-0.4.4\",\n build_file = Label(\"@crates//crates:BUILD.terminal_size-0.4.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__terminfo-0.9.0\",\n sha256 = \"d4ea810f0692f9f51b382fff5893887bb4580f5fa246fde546e0b13e7fcee662\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/terminfo/0.9.0/download\"],\n strip_prefix = \"terminfo-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.terminfo-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-1.0.69\",\n sha256 = \"b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror/1.0.69/download\"],\n strip_prefix = \"thiserror-1.0.69\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-1.0.69.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-2.0.20\",\n sha256 = \"ec86235f5fcc2a73650310756d2ac5b138a5780bbbdfae3eeccec992c435ba4f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror/2.0.20/download\"],\n strip_prefix = \"thiserror-2.0.20\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-2.0.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-impl-1.0.69\",\n sha256 = \"4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror-impl/1.0.69/download\"],\n strip_prefix = \"thiserror-impl-1.0.69\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-impl-1.0.69.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__thiserror-impl-2.0.20\",\n sha256 = \"bc04cd3e1236dd4a98afca4569f2deb3f120e5422a4023be2cb683f8486292af\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/thiserror-impl/2.0.20/download\"],\n strip_prefix = \"thiserror-impl-2.0.20\",\n build_file = Label(\"@crates//crates:BUILD.thiserror-impl-2.0.20.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tiff-0.11.3\",\n sha256 = \"b63feaf3343d35b6ca4d50483f94843803b0f51634937cc2ec519fc32232bc52\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tiff/0.11.3/download\"],\n strip_prefix = \"tiff-0.11.3\",\n build_file = Label(\"@crates//crates:BUILD.tiff-0.11.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tiktoken-rs-0.11.0\",\n sha256 = \"fac4a168cfc1d8ed65bf17a6ee0843ad9a68f863c63c0fb2fa7eab67838782ee\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tiktoken-rs/0.11.0/download\"],\n strip_prefix = \"tiktoken-rs-0.11.0\",\n build_file = Label(\"@crates//crates:BUILD.tiktoken-rs-0.11.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-0.3.55\",\n sha256 = \"cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time/0.3.55/download\"],\n strip_prefix = \"time-0.3.55\",\n build_file = Label(\"@crates//crates:BUILD.time-0.3.55.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-core-0.1.9\",\n sha256 = \"9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time-core/0.1.9/download\"],\n strip_prefix = \"time-core-0.1.9\",\n build_file = Label(\"@crates//crates:BUILD.time-core-0.1.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__time-macros-0.2.32\",\n sha256 = \"7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/time-macros/0.2.32/download\"],\n strip_prefix = \"time-macros-0.2.32\",\n build_file = Label(\"@crates//crates:BUILD.time-macros-0.2.32.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tiny-keccak-2.0.2\",\n sha256 = \"2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tiny-keccak/2.0.2/download\"],\n strip_prefix = \"tiny-keccak-2.0.2\",\n build_file = Label(\"@crates//crates:BUILD.tiny-keccak-2.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tiny-skia-0.12.0\",\n sha256 = \"47ffee5eaaf5527f630fb0e356b90ebdec84d5d18d937c5e440350f88c5a91ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tiny-skia/0.12.0/download\"],\n strip_prefix = \"tiny-skia-0.12.0\",\n build_file = Label(\"@crates//crates:BUILD.tiny-skia-0.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tiny-skia-path-0.12.0\",\n sha256 = \"edca365c3faccca67d06593c5980fa6c57687de727a03131735bb85f01fdeeb9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tiny-skia-path/0.12.0/download\"],\n strip_prefix = \"tiny-skia-path-0.12.0\",\n build_file = Label(\"@crates//crates:BUILD.tiny-skia-path-0.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinystr-0.8.4\",\n sha256 = \"b1e27c91459209c2986af3dcf603a5a74a4368754ce37414f59acc971167f643\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinystr/0.8.4/download\"],\n strip_prefix = \"tinystr-0.8.4\",\n build_file = Label(\"@crates//crates:BUILD.tinystr-0.8.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec-1.12.0\",\n sha256 = \"bb4ebadaa0af04fab11ae01eb5f9fdb5f9c5b875506e210e71c07873528baa7f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec/1.12.0/download\"],\n strip_prefix = \"tinyvec-1.12.0\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec-1.12.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tinyvec_macros-0.1.1\",\n sha256 = \"1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tinyvec_macros/0.1.1/download\"],\n strip_prefix = \"tinyvec_macros-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tinyvec_macros-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tokio-1.53.1\",\n sha256 = \"202caea871b69668250d242070849eb495be178ed697a3e98aebce5bc81a0bed\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tokio/1.53.1/download\"],\n strip_prefix = \"tokio-1.53.1\",\n build_file = Label(\"@crates//crates:BUILD.tokio-1.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tokio-macros-2.7.2\",\n sha256 = \"78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tokio-macros/2.7.2/download\"],\n strip_prefix = \"tokio-macros-2.7.2\",\n build_file = Label(\"@crates//crates:BUILD.tokio-macros-2.7.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tokio-util-0.7.19\",\n sha256 = \"494815d09bf52b5548659851081238f0ca39ff638363907596da739561c62c52\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tokio-util/0.7.19/download\"],\n strip_prefix = \"tokio-util-0.7.19\",\n build_file = Label(\"@crates//crates:BUILD.tokio-util-0.7.19.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml-1.1.4-spec-1.1.0\",\n sha256 = \"3aace63f4bbcdfc2c965b059de67119c89c4017a70d633be6c104910f67056f5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml/1.1.4+spec-1.1.0/download\"],\n strip_prefix = \"toml-1.1.4+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml-1.1.4+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_datetime-1.1.1-spec-1.1.0\",\n sha256 = \"3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_datetime/1.1.1+spec-1.1.0/download\"],\n strip_prefix = \"toml_datetime-1.1.1+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_datetime-1.1.1+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_edit-0.25.13-spec-1.1.0\",\n sha256 = \"6975367e4d2ef766d86af01ffad14b622fecc8d4357a998fbc4deb6e9bacaf9b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_edit/0.25.13+spec-1.1.0/download\"],\n strip_prefix = \"toml_edit-0.25.13+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_edit-0.25.13+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_parser-1.1.3-spec-1.1.0\",\n sha256 = \"1d38ac1cf9b95face32296c0a3ede1fdc270627c9d9c02a7274dd6d960dc4d56\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_parser/1.1.3+spec-1.1.0/download\"],\n strip_prefix = \"toml_parser-1.1.3+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_parser-1.1.3+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__toml_writer-1.1.2-spec-1.1.0\",\n sha256 = \"7d56353a2a665ad0f41a421187180aab746c8c325620617ad883a99a1cbe66d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/toml_writer/1.1.2+spec-1.1.0/download\"],\n strip_prefix = \"toml_writer-1.1.2+spec-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.toml_writer-1.1.2+spec-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tracing-0.1.44\",\n sha256 = \"63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tracing/0.1.44/download\"],\n strip_prefix = \"tracing-0.1.44\",\n build_file = Label(\"@crates//crates:BUILD.tracing-0.1.44.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tracing-attributes-0.1.31\",\n sha256 = \"7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tracing-attributes/0.1.31/download\"],\n strip_prefix = \"tracing-attributes-0.1.31\",\n build_file = Label(\"@crates//crates:BUILD.tracing-attributes-0.1.31.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tracing-core-0.1.36\",\n sha256 = \"db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tracing-core/0.1.36/download\"],\n strip_prefix = \"tracing-core-0.1.36\",\n build_file = Label(\"@crates//crates:BUILD.tracing-core-0.1.36.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-0.25.10\",\n sha256 = \"78f873475d258561b06f1c595d93308a7ed124d9977cb26b148c2084a4a3cc87\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter/0.25.10/download\"],\n strip_prefix = \"tree-sitter-0.25.10\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-0.25.10.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-astro-next-0.1.1\",\n sha256 = \"794a4a59fc2d88e49b4bc41fef9522d77184a36f4e68bbaf545cd1eb2364c46e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-astro-next/0.1.1/download\"],\n strip_prefix = \"tree-sitter-astro-next-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-astro-next-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-bash-0.25.1\",\n sha256 = \"9e5ec769279cc91b561d3df0d8a5deb26b0ad40d183127f409494d6d8fc53062\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-bash/0.25.1/download\"],\n strip_prefix = \"tree-sitter-bash-0.25.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-bash-0.25.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-c-0.24.2\",\n sha256 = \"a9b2eb57a55fed6b00812912e730b7a275cf4fe98bfd6a5d76263d4438371728\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-c/0.24.2/download\"],\n strip_prefix = \"tree-sitter-c-0.24.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-c-0.24.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-c-sharp-0.23.5\",\n sha256 = \"c1aac67f1ad71de1d6d39708d34811081c26dfa495658de6c14c34200849357c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-c-sharp/0.23.5/download\"],\n strip_prefix = \"tree-sitter-c-sharp-0.23.5\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-c-sharp-0.23.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-clojure-0.1.0\",\n sha256 = \"4004884cc509449a1d78fa3e1f02b4e953d0a8065984445304795e72e885338c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-clojure/0.1.0/download\"],\n strip_prefix = \"tree-sitter-clojure-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-clojure-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-cmake-0.7.4\",\n sha256 = \"164e0c4f4236ec5ceff14824a5528615cf462e100467e49826442ff57d327061\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-cmake/0.7.4/download\"],\n strip_prefix = \"tree-sitter-cmake-0.7.4\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-cmake-0.7.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-cpp-0.23.4\",\n sha256 = \"df2196ea9d47b4ab4a31b9297eaa5a5d19a0b121dceb9f118f6790ad0ab94743\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-cpp/0.23.4/download\"],\n strip_prefix = \"tree-sitter-cpp-0.23.4\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-cpp-0.23.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-css-0.25.0\",\n sha256 = \"a5cbc5e18f29a2c6d6435891f42569525cf95435a3e01c2f1947abcde178686f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-css/0.25.0/download\"],\n strip_prefix = \"tree-sitter-css-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-css-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-dart-0.2.0\",\n sha256 = \"325dd1e24ee9ee21111e9c43680ae7d6010aaa9f282b048a99b9c7163c1cf553\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-dart/0.2.0/download\"],\n strip_prefix = \"tree-sitter-dart-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-dart-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-diff-0.1.0\",\n sha256 = \"dfe1e5ca280a65dfe5ba4205c1bcc84edf486464fed315db53dee6da9a335889\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-diff/0.1.0/download\"],\n strip_prefix = \"tree-sitter-diff-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-diff-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-dockerfile-updated-0.2.0\",\n sha256 = \"5e61eb704364be179ab9be89e2891c8e77c0041eca5891a5c04164a21f6df7a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-dockerfile-updated/0.2.0/download\"],\n strip_prefix = \"tree-sitter-dockerfile-updated-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-dockerfile-updated-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-elisp-1.7.2\",\n sha256 = \"6b8b82ab7474028f20d2119285566f219209ebdbeec767fa28025b70f94f8cf3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-elisp/1.7.2/download\"],\n strip_prefix = \"tree-sitter-elisp-1.7.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-elisp-1.7.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-elixir-0.3.5\",\n sha256 = \"66dd064a762ed95bfc29857fa3cb7403bb1e5cb88112de0f6341b7e47284ba40\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-elixir/0.3.5/download\"],\n strip_prefix = \"tree-sitter-elixir-0.3.5\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-elixir-0.3.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-erlang-0.16.0\",\n sha256 = \"ceb442e728225d601db0661f60d64e166bd9b9a55c587f71d4e4f27378717cce\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-erlang/0.16.0/download\"],\n strip_prefix = \"tree-sitter-erlang-0.16.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-erlang-0.16.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-fortran-0.6.0\",\n sha256 = \"ea5fea41363a9b59666001dc26c4b356d4e164da27c6ce31145e00aba6bf9b16\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-fortran/0.6.0/download\"],\n strip_prefix = \"tree-sitter-fortran-0.6.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-fortran-0.6.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-go-0.25.0\",\n sha256 = \"c8560a4d2f835cc0d4d2c2e03cbd0dde2f6114b43bc491164238d333e28b16ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-go/0.25.0/download\"],\n strip_prefix = \"tree-sitter-go-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-go-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-graphql-0.1.0\",\n sha256 = \"efedc4cac157161cc23a0adc4553a2cedc908e1cd754b6cd033a919bb81ce5d6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-graphql/0.1.0/download\"],\n strip_prefix = \"tree-sitter-graphql-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-graphql-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-haskell-0.23.1\",\n sha256 = \"977c51e504548cba13fc27cb5a2edab2124cf6716a1934915d07ab99523b05a4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-haskell/0.23.1/download\"],\n strip_prefix = \"tree-sitter-haskell-0.23.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-haskell-0.23.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-hcl-1.1.0\",\n sha256 = \"5a7b2cc3d7121553b84309fab9d11b3ff3d420403eef9ae50f9fd1cd9d9cf012\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-hcl/1.1.0/download\"],\n strip_prefix = \"tree-sitter-hcl-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-hcl-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-html-0.23.2\",\n sha256 = \"261b708e5d92061ede329babaaa427b819329a9d427a1d710abb0f67bbef63ee\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-html/0.23.2/download\"],\n strip_prefix = \"tree-sitter-html-0.23.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-html-0.23.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-ini-1.4.0\",\n sha256 = \"387f79682cd53b7c0a5777c96e601a02b9965a787984ef86dbb8952bdab2d62f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-ini/1.4.0/download\"],\n strip_prefix = \"tree-sitter-ini-1.4.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-ini-1.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-java-0.23.5\",\n sha256 = \"0aa6cbcdc8c679b214e616fd3300da67da0e492e066df01bcf5a5921a71e90d6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-java/0.23.5/download\"],\n strip_prefix = \"tree-sitter-java-0.23.5\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-java-0.23.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-javascript-0.25.0\",\n sha256 = \"68204f2abc0627a90bdf06e605f5c470aa26fdcb2081ea553a04bdad756693f5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-javascript/0.25.0/download\"],\n strip_prefix = \"tree-sitter-javascript-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-javascript-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-json-0.24.8\",\n sha256 = \"4d727acca406c0020cffc6cf35516764f36c8e3dc4408e5ebe2cb35a947ec471\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-json/0.24.8/download\"],\n strip_prefix = \"tree-sitter-json-0.24.8\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-json-0.24.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-julia-0.23.1\",\n sha256 = \"4144731a178812ee867619b1e98b3b91e54c1652304b26e5ebe3175b701de323\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-julia/0.23.1/download\"],\n strip_prefix = \"tree-sitter-julia-0.23.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-julia-0.23.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-just-0.2.0\",\n sha256 = \"bd46794f2c270f43d73b2f2c8c256992471f3493c903604da0886df984771920\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-just/0.2.0/download\"],\n strip_prefix = \"tree-sitter-just-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-just-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-kotlin-sg-0.4.1\",\n sha256 = \"c06ec43ae3c12165d4ac08afe4e1f5fc6757ffe274fa7bd5af9007ef11ba4319\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-kotlin-sg/0.4.1/download\"],\n strip_prefix = \"tree-sitter-kotlin-sg-0.4.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-kotlin-sg-0.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-language-0.1.7\",\n sha256 = \"009994f150cc0cd50ff54917d5bc8bffe8cad10ca10d81c34da2ec421ae61782\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-language/0.1.7/download\"],\n strip_prefix = \"tree-sitter-language-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-language-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-lua-0.5.0\",\n sha256 = \"8daaf5f4235188a58603c39760d5fa5d4b920d36a299c934adddae757f32a10c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-lua/0.5.0/download\"],\n strip_prefix = \"tree-sitter-lua-0.5.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-lua-0.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-make-1.1.1\",\n sha256 = \"c5998dc7cbcbdab19fae8aefef982bf2d6544513d8d2e69cc44aec4c63810104\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-make/1.1.1/download\"],\n strip_prefix = \"tree-sitter-make-1.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-make-1.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-md-0.5.3\",\n sha256 = \"2efd398be546456c814598ee56c0f51769a77241511b4a58077815d120afa882\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-md/0.5.3/download\"],\n strip_prefix = \"tree-sitter-md-0.5.3\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-md-0.5.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-nix-0.3.0\",\n sha256 = \"4952a9733f3a98f6683a0ccd1035d84ab7a52f7e84eeed58548d86765ad92de3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-nix/0.3.0/download\"],\n strip_prefix = \"tree-sitter-nix-0.3.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-nix-0.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-objc-3.0.2\",\n sha256 = \"9ca8bb556423fc176f0535e79d525f783a6684d3c9da81bf9d905303c129e1d2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-objc/3.0.2/download\"],\n strip_prefix = \"tree-sitter-objc-3.0.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-objc-3.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-ocaml-0.24.2\",\n sha256 = \"7d19db582b3855f56b5f9ec484170fbfb9ee60b938ec7720d76d2ee788e8b640\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-ocaml/0.24.2/download\"],\n strip_prefix = \"tree-sitter-ocaml-0.24.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-ocaml-0.24.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-odin-1.3.0\",\n sha256 = \"24db210fe9ba2237c71c5030d7b146c7025420ba72dd8013d13cd822c3a8d77a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-odin/1.3.0/download\"],\n strip_prefix = \"tree-sitter-odin-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-odin-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-php-0.24.2\",\n sha256 = \"0d8c17c3ab69052c5eeaa7ff5cd972dd1bc25d1b97ee779fec391ad3b5df5592\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-php/0.24.2/download\"],\n strip_prefix = \"tree-sitter-php-0.24.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-php-0.24.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-powershell-0.26.4\",\n sha256 = \"3faf304d44b9ddd4a7d97804bb8de7daf564336dd5a526dc6de5b39238243022\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-powershell/0.26.4/download\"],\n strip_prefix = \"tree-sitter-powershell-0.26.4\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-powershell-0.26.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-proto-0.4.0\",\n sha256 = \"2e410ccb5fa3cbd6bf7b8e512ecf7ad9d5254395b822bfe9f751b50fa978f31c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-proto/0.4.0/download\"],\n strip_prefix = \"tree-sitter-proto-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-proto-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-python-0.25.0\",\n sha256 = \"6bf85fd39652e740bf60f46f4cda9492c3a9ad75880575bf14960f775cb74a1c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-python/0.25.0/download\"],\n strip_prefix = \"tree-sitter-python-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-python-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-r-1.3.0\",\n sha256 = \"ffc9954ec870dcad6cffdd302b405306c68cf031ed79a78cd9746f6740d9fe20\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-r/1.3.0/download\"],\n strip_prefix = \"tree-sitter-r-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-r-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-regex-0.25.0\",\n sha256 = \"bd8a59be9f0ac131fd8f062eaaba14882b2fa5a6a7882a20134cb1d60df2e625\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-regex/0.25.0/download\"],\n strip_prefix = \"tree-sitter-regex-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-regex-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-ruby-0.23.1\",\n sha256 = \"be0484ea4ef6bb9c575b4fdabde7e31340a8d2dbc7d52b321ac83da703249f95\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-ruby/0.23.1/download\"],\n strip_prefix = \"tree-sitter-ruby-0.23.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-ruby-0.23.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-rust-0.24.2\",\n sha256 = \"439e577dbe07423ec2582ac62c7531120dbfccfa6e5f92406f93dd271a120e45\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-rust/0.24.2/download\"],\n strip_prefix = \"tree-sitter-rust-0.24.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-rust-0.24.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-scala-0.26.2\",\n sha256 = \"24e0ab4505990bfe30051761d40a7bf4033ce5a81c9eda9e20e987a5cdc84826\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-scala/0.26.2/download\"],\n strip_prefix = \"tree-sitter-scala-0.26.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-scala-0.26.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-sequel-0.3.11\",\n sha256 = \"9d198ad3c319c02e43c21efa1ec796b837afcb96ffaef1a40c1978fbdcec7d17\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-sequel/0.3.11/download\"],\n strip_prefix = \"tree-sitter-sequel-0.3.11\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-sequel-0.3.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-solidity-1.2.13\",\n sha256 = \"4eacf8875b70879f0cb670c60b233ad0b68752d9e1474e6c3ef168eea8a90b25\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-solidity/1.2.13/download\"],\n strip_prefix = \"tree-sitter-solidity-1.2.13\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-solidity-1.2.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-starlark-1.3.0\",\n sha256 = \"8934f282d085cc4b9ee28aa688aa3fbe8aa3766201c2a6252f411d45b4c3a721\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-starlark/1.3.0/download\"],\n strip_prefix = \"tree-sitter-starlark-1.3.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-starlark-1.3.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-svelte-next-0.1.1\",\n sha256 = \"56f88190d0743e897c3e148a7e241aba0a8844b8afe816943851426e3f7b9753\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-svelte-next/0.1.1/download\"],\n strip_prefix = \"tree-sitter-svelte-next-0.1.1\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-svelte-next-0.1.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-swift-0.7.3\",\n sha256 = \"fe36052155b9dd69ca82b3b8f1b4ccfb2d867125ac1a4db1dd7331829242668c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-swift/0.7.3/download\"],\n strip_prefix = \"tree-sitter-swift-0.7.3\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-swift-0.7.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-tlaplus-1.5.0\",\n sha256 = \"ddaacc0337bfee38f233a91a704dc36b887a0c385348163f65344d64b73f79e1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-tlaplus/1.5.0/download\"],\n strip_prefix = \"tree-sitter-tlaplus-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-tlaplus-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-toml-ng-0.7.0\",\n sha256 = \"e9adc2c898ae49730e857d75be403da3f92bb81d8e37a2f918a08dd10de5ebb1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-toml-ng/0.7.0/download\"],\n strip_prefix = \"tree-sitter-toml-ng-0.7.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-toml-ng-0.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-typescript-0.23.2\",\n sha256 = \"6c5f76ed8d947a75cc446d5fccd8b602ebf0cde64ccf2ffa434d873d7a575eff\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-typescript/0.23.2/download\"],\n strip_prefix = \"tree-sitter-typescript-0.23.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-typescript-0.23.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-verilog-1.0.3\",\n sha256 = \"d4e7e0360395852f1f6ff5b7b82c72dc6557d181073188df1d60ec469ea69c66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-verilog/1.0.3/download\"],\n strip_prefix = \"tree-sitter-verilog-1.0.3\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-verilog-1.0.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-vue-next-0.1.0\",\n sha256 = \"e9ac89acaa8165aaabfa8ae9683aa423b0d2bf42c815dae5ca031a36a75525f1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-vue-next/0.1.0/download\"],\n strip_prefix = \"tree-sitter-vue-next-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-vue-next-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-xml-0.7.0\",\n sha256 = \"e670041f591d994f54d597ddcd8f4ebc930e282c4c76a42268743b71f0c8b6b3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-xml/0.7.0/download\"],\n strip_prefix = \"tree-sitter-xml-0.7.0\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-xml-0.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-yaml-0.7.2\",\n sha256 = \"53c223db85f05e34794f065454843b0668ebc15d240ada63e2b5939f43ce7c97\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-yaml/0.7.2/download\"],\n strip_prefix = \"tree-sitter-yaml-0.7.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-yaml-0.7.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree-sitter-zig-1.1.2\",\n sha256 = \"ab11fc124851b0db4dd5e55983bbd9631192e93238389dcd44521715e5d53e28\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree-sitter-zig/1.1.2/download\"],\n strip_prefix = \"tree-sitter-zig-1.1.2\",\n build_file = Label(\"@crates//crates:BUILD.tree-sitter-zig-1.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__tree_magic_mini-3.2.2\",\n sha256 = \"b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/tree_magic_mini/3.2.2/download\"],\n strip_prefix = \"tree_magic_mini-3.2.2\",\n build_file = Label(\"@crates//crates:BUILD.tree_magic_mini-3.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__triomphe-0.1.16\",\n sha256 = \"b40688ea6389c8171614b25491f71d4a27946e0c7ce2da1c6de27e25abf1a0ae\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/triomphe/0.1.16/download\"],\n strip_prefix = \"triomphe-0.1.16\",\n build_file = Label(\"@crates//crates:BUILD.triomphe-0.1.16.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ttf-parser-0.25.1\",\n sha256 = \"d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ttf-parser/0.25.1/download\"],\n strip_prefix = \"ttf-parser-0.25.1\",\n build_file = Label(\"@crates//crates:BUILD.ttf-parser-0.25.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__turn-0.17.2\",\n sha256 = \"d99249a493335eb44c4d7943a8751b22561a82c9903d8eb2d29780b3927880a7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/turn/0.17.2/download\"],\n strip_prefix = \"turn-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.turn-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__type-map-0.5.1\",\n sha256 = \"cb30dbbd9036155e74adad6812e9898d03ec374946234fbcebd5dfc7b9187b90\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/type-map/0.5.1/download\"],\n strip_prefix = \"type-map-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.type-map-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__typed-arena-2.0.2\",\n sha256 = \"6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/typed-arena/2.0.2/download\"],\n strip_prefix = \"typed-arena-2.0.2\",\n build_file = Label(\"@crates//crates:BUILD.typed-arena-2.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__typenum-1.20.1\",\n sha256 = \"b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/typenum/1.20.1/download\"],\n strip_prefix = \"typenum-1.20.1\",\n build_file = Label(\"@crates//crates:BUILD.typenum-1.20.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__ucd-trie-0.1.7\",\n sha256 = \"2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/ucd-trie/0.1.7/download\"],\n strip_prefix = \"ucd-trie-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.ucd-trie-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uds_windows-1.2.1\",\n sha256 = \"f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uds_windows/1.2.1/download\"],\n strip_prefix = \"uds_windows-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.uds_windows-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uiautomation-0.25.0\",\n sha256 = \"c68495a701b9f2f21f29353ac446f0d27dd0d7ce97aa9ccf9061bca0446cd744\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uiautomation/0.25.0/download\"],\n strip_prefix = \"uiautomation-0.25.0\",\n build_file = Label(\"@crates//crates:BUILD.uiautomation-0.25.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uiautomation_derive-0.7.8\",\n sha256 = \"ffcc4d404aa1c03a848f95cf5feadc3e63946d7f095bf388770b85550093d388\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uiautomation_derive/0.7.8/download\"],\n strip_prefix = \"uiautomation_derive-0.7.8\",\n build_file = Label(\"@crates//crates:BUILD.uiautomation_derive-0.7.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uluru-3.1.0\",\n sha256 = \"7c8a2469e56e6e5095c82ccd3afb98dad95f7af7929aab6d8ba8d6e0f73657da\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uluru/3.1.0/download\"],\n strip_prefix = \"uluru-3.1.0\",\n build_file = Label(\"@crates//crates:BUILD.uluru-3.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unic-langid-0.9.6\",\n sha256 = \"a28ba52c9b05311f4f6e62d5d9d46f094bd6e84cb8df7b3ef952748d752a7d05\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unic-langid/0.9.6/download\"],\n strip_prefix = \"unic-langid-0.9.6\",\n build_file = Label(\"@crates//crates:BUILD.unic-langid-0.9.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unic-langid-impl-0.9.6\",\n sha256 = \"dce1bf08044d4b7a94028c93786f8566047edc11110595914de93362559bc658\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unic-langid-impl/0.9.6/download\"],\n strip_prefix = \"unic-langid-impl-0.9.6\",\n build_file = Label(\"@crates//crates:BUILD.unic-langid-impl-0.9.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicase-2.9.0\",\n sha256 = \"dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicase/2.9.0/download\"],\n strip_prefix = \"unicase-2.9.0\",\n build_file = Label(\"@crates//crates:BUILD.unicase-2.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-bidi-0.3.18\",\n sha256 = \"5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-bidi/0.3.18/download\"],\n strip_prefix = \"unicode-bidi-0.3.18\",\n build_file = Label(\"@crates//crates:BUILD.unicode-bidi-0.3.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-bom-2.0.3\",\n sha256 = \"7eec5d1121208364f6793f7d2e222bf75a915c19557537745b195b253dd64217\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-bom/2.0.3/download\"],\n strip_prefix = \"unicode-bom-2.0.3\",\n build_file = Label(\"@crates//crates:BUILD.unicode-bom-2.0.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-ident-1.0.24\",\n sha256 = \"e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-ident/1.0.24/download\"],\n strip_prefix = \"unicode-ident-1.0.24\",\n build_file = Label(\"@crates//crates:BUILD.unicode-ident-1.0.24.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-normalization-0.1.25\",\n sha256 = \"5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-normalization/0.1.25/download\"],\n strip_prefix = \"unicode-normalization-0.1.25\",\n build_file = Label(\"@crates//crates:BUILD.unicode-normalization-0.1.25.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-properties-0.1.4\",\n sha256 = \"7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-properties/0.1.4/download\"],\n strip_prefix = \"unicode-properties-0.1.4\",\n build_file = Label(\"@crates//crates:BUILD.unicode-properties-0.1.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-script-0.5.8\",\n sha256 = \"383ad40bb927465ec0ce7720e033cb4ca06912855fc35db31b5755d0de75b1ee\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-script/0.5.8/download\"],\n strip_prefix = \"unicode-script-0.5.8\",\n build_file = Label(\"@crates//crates:BUILD.unicode-script-0.5.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-segmentation-1.13.3\",\n sha256 = \"c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-segmentation/1.13.3/download\"],\n strip_prefix = \"unicode-segmentation-1.13.3\",\n build_file = Label(\"@crates//crates:BUILD.unicode-segmentation-1.13.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-vo-0.1.0\",\n sha256 = \"b1d386ff53b415b7fe27b50bb44679e2cc4660272694b7b6f3326d8480823a94\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-vo/0.1.0/download\"],\n strip_prefix = \"unicode-vo-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.unicode-vo-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-width-0.1.14\",\n sha256 = \"7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-width/0.1.14/download\"],\n strip_prefix = \"unicode-width-0.1.14\",\n build_file = Label(\"@crates//crates:BUILD.unicode-width-0.1.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unicode-width-0.2.2\",\n sha256 = \"b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unicode-width/0.2.2/download\"],\n strip_prefix = \"unicode-width-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.unicode-width-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__unit-prefix-0.5.2\",\n sha256 = \"81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/unit-prefix/0.5.2/download\"],\n strip_prefix = \"unit-prefix-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.unit-prefix-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__universal-hash-0.5.1\",\n sha256 = \"fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/universal-hash/0.5.1/download\"],\n strip_prefix = \"universal-hash-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.universal-hash-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__untrusted-0.9.0\",\n sha256 = \"8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/untrusted/0.9.0/download\"],\n strip_prefix = \"untrusted-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.untrusted-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__url-2.5.8\",\n sha256 = \"ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/url/2.5.8/download\"],\n strip_prefix = \"url-2.5.8\",\n build_file = Label(\"@crates//crates:BUILD.url-2.5.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__urlencoding-2.1.3\",\n sha256 = \"daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/urlencoding/2.1.3/download\"],\n strip_prefix = \"urlencoding-2.1.3\",\n build_file = Label(\"@crates//crates:BUILD.urlencoding-2.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__usvg-0.48.1\",\n sha256 = \"977d0a4abdef933f424a99fe09f95576e089b90aebc6f016a3bc813762493e91\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/usvg/0.48.1/download\"],\n strip_prefix = \"usvg-0.48.1\",\n build_file = Label(\"@crates//crates:BUILD.usvg-0.48.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf16_iter-1.0.5\",\n sha256 = \"c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf16_iter/1.0.5/download\"],\n strip_prefix = \"utf16_iter-1.0.5\",\n build_file = Label(\"@crates//crates:BUILD.utf16_iter-1.0.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf8-chars-3.0.7\",\n sha256 = \"92498c67ea3511b37eccff13b573ed871faf0ce9c4056ab032bd01a681f445a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf8-chars/3.0.7/download\"],\n strip_prefix = \"utf8-chars-3.0.7\",\n build_file = Label(\"@crates//crates:BUILD.utf8-chars-3.0.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf8_iter-1.0.4\",\n sha256 = \"b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf8_iter/1.0.4/download\"],\n strip_prefix = \"utf8_iter-1.0.4\",\n build_file = Label(\"@crates//crates:BUILD.utf8_iter-1.0.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__utf8parse-0.2.2\",\n sha256 = \"06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/utf8parse/0.2.2/download\"],\n strip_prefix = \"utf8parse-0.2.2\",\n build_file = Label(\"@crates//crates:BUILD.utf8parse-0.2.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uucore-0.8.0\",\n sha256 = \"07d779636d827cde4100f0e65ff3fd23b0b1f1195055475c6e6813d425f30c8e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uucore/0.8.0/download\"],\n strip_prefix = \"uucore-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.uucore-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uucore_procs-0.8.0\",\n sha256 = \"da865e8a648b260dbd89fca76d0801995877ab27a4e259b6dec30ba9743b86ab\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uucore_procs/0.8.0/download\"],\n strip_prefix = \"uucore_procs-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.uucore_procs-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uuid-1.26.0\",\n sha256 = \"b5772d71c9be8a8a6ac2117d949c5b224c1b72241bb611d9a3012edcf8af7812\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uuid/1.26.0/download\"],\n strip_prefix = \"uuid-1.26.0\",\n build_file = Label(\"@crates//crates:BUILD.uuid-1.26.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uutils_term_grid-0.8.0\",\n sha256 = \"382d49b39de4a115f203305057741126b09a615892d773a2d419a2b816e30e39\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uutils_term_grid/0.8.0/download\"],\n strip_prefix = \"uutils_term_grid-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.uutils_term_grid-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__uzers-0.12.2\",\n sha256 = \"0b8275fb1afee25b4111d2dc8b5c505dbbc4afd0b990cb96deb2d88bff8be18d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/uzers/0.12.2/download\"],\n strip_prefix = \"uzers-0.12.2\",\n build_file = Label(\"@crates//crates:BUILD.uzers-0.12.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__version-compare-0.2.1\",\n sha256 = \"03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/version-compare/0.2.1/download\"],\n strip_prefix = \"version-compare-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.version-compare-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__version_check-0.9.5\",\n sha256 = \"0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/version_check/0.9.5/download\"],\n strip_prefix = \"version_check-0.9.5\",\n build_file = Label(\"@crates//crates:BUILD.version_check-0.9.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__vsimd-0.8.0\",\n sha256 = \"5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/vsimd/0.8.0/download\"],\n strip_prefix = \"vsimd-0.8.0\",\n build_file = Label(\"@crates//crates:BUILD.vsimd-0.8.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__waitgroup-0.1.2\",\n sha256 = \"d1f50000a783467e6c0200f9d10642f4bc424e39efc1b770203e88b488f79292\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/waitgroup/0.1.2/download\"],\n strip_prefix = \"waitgroup-0.1.2\",\n build_file = Label(\"@crates//crates:BUILD.waitgroup-0.1.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__walkdir-2.5.0\",\n sha256 = \"29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/walkdir/2.5.0/download\"],\n strip_prefix = \"walkdir-2.5.0\",\n build_file = Label(\"@crates//crates:BUILD.walkdir-2.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasi-0.11.1-wasi-snapshot-preview1\",\n sha256 = \"ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasi/0.11.1+wasi-snapshot-preview1/download\"],\n strip_prefix = \"wasi-0.11.1+wasi-snapshot-preview1\",\n build_file = Label(\"@crates//crates:BUILD.wasi-0.11.1+wasi-snapshot-preview1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasi-0.14.7-wasi-0.2.4\",\n sha256 = \"883478de20367e224c0090af9cf5f9fa85bed63a95c1abf3afc5c083ebc06e8c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasi/0.14.7+wasi-0.2.4/download\"],\n strip_prefix = \"wasi-0.14.7+wasi-0.2.4\",\n build_file = Label(\"@crates//crates:BUILD.wasi-0.14.7+wasi-0.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasip2-1.0.4-wasi-0.2.12\",\n sha256 = \"b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasip2/1.0.4+wasi-0.2.12/download\"],\n strip_prefix = \"wasip2-1.0.4+wasi-0.2.12\",\n build_file = Label(\"@crates//crates:BUILD.wasip2-1.0.4+wasi-0.2.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasite-1.0.2\",\n sha256 = \"66fe902b4a6b8028a753d5424909b764ccf79b7a209eac9bf97e59cda9f71a42\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasite/1.0.2/download\"],\n strip_prefix = \"wasite-1.0.2\",\n build_file = Label(\"@crates//crates:BUILD.wasite-1.0.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-0.2.127\",\n sha256 = \"1b70935747edd64d89de3efa29d73789b806c15798f8e7dca4d8ac356b50ce70\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen/0.2.127/download\"],\n strip_prefix = \"wasm-bindgen-0.2.127\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-0.2.127.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-0.2.127\",\n sha256 = \"77775f8f3f7217702089053b94958f8f54061a3f663417df76e19cbdcca29bc1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro/0.2.127/download\"],\n strip_prefix = \"wasm-bindgen-macro-0.2.127\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-0.2.127.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-macro-support-0.2.127\",\n sha256 = \"e11d33f857dc2fb11b8bc75aee111aa9cbeb12cd9f25efd3d4c2a3dd4e235284\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-macro-support/0.2.127/download\"],\n strip_prefix = \"wasm-bindgen-macro-support-0.2.127\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-macro-support-0.2.127.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wasm-bindgen-shared-0.2.127\",\n sha256 = \"7ef64dbcc55df09c7e5a46182d181c2cfa3e925f3da937ea764728b4bbb9dcbf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wasm-bindgen-shared/0.2.127/download\"],\n strip_prefix = \"wasm-bindgen-shared-0.2.127\",\n build_file = Label(\"@crates//crates:BUILD.wasm-bindgen-shared-0.2.127.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-backend-0.3.17\",\n sha256 = \"38a91b4eaddff87b1cd1074985e3713da4af2c49742d1b356b2c01670a67a078\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-backend/0.3.17/download\"],\n strip_prefix = \"wayland-backend-0.3.17\",\n build_file = Label(\"@crates//crates:BUILD.wayland-backend-0.3.17.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-client-0.31.15\",\n sha256 = \"e3c36a0f861ad76d0901f2800b46321410d9f73f2ea88aac0650d86c32688073\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-client/0.31.15/download\"],\n strip_prefix = \"wayland-client-0.31.15\",\n build_file = Label(\"@crates//crates:BUILD.wayland-client-0.31.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-protocols-0.32.13\",\n sha256 = \"23d0c813de3daa2ed6520af85a3bd49b0e722a3078506899aa9686fea58dc4b6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-protocols/0.32.13/download\"],\n strip_prefix = \"wayland-protocols-0.32.13\",\n build_file = Label(\"@crates//crates:BUILD.wayland-protocols-0.32.13.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-protocols-wlr-0.3.12\",\n sha256 = \"eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-protocols-wlr/0.3.12/download\"],\n strip_prefix = \"wayland-protocols-wlr-0.3.12\",\n build_file = Label(\"@crates//crates:BUILD.wayland-protocols-wlr-0.3.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-scanner-0.31.11\",\n sha256 = \"338e30461b3a2b67d70eb30a6d89f8e0c93a833e07d2ae89085cd070c4a00ac0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-scanner/0.31.11/download\"],\n strip_prefix = \"wayland-scanner-0.31.11\",\n build_file = Label(\"@crates//crates:BUILD.wayland-scanner-0.31.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-server-0.31.14\",\n sha256 = \"0dde9c29be0f723a573977de51ee455bf3dfa03652730a74f9dd3b337e374d75\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-server/0.31.14/download\"],\n strip_prefix = \"wayland-server-0.31.14\",\n build_file = Label(\"@crates//crates:BUILD.wayland-server-0.31.14.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wayland-sys-0.31.11\",\n sha256 = \"d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wayland-sys/0.31.11/download\"],\n strip_prefix = \"wayland-sys-0.31.11\",\n build_file = Label(\"@crates//crates:BUILD.wayland-sys-0.31.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__web-sys-0.3.104\",\n sha256 = \"c435338968042f4f59a557f690a253676d47ce13ceb55d70100e7facf6620a30\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/web-sys/0.3.104/download\"],\n strip_prefix = \"web-sys-0.3.104\",\n build_file = Label(\"@crates//crates:BUILD.web-sys-0.3.104.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__web-time-1.1.0\",\n sha256 = \"5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/web-time/1.1.0/download\"],\n strip_prefix = \"web-time-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.web-time-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__web_atoms-0.2.6\",\n sha256 = \"ba8b815c1b593dc0baf78dd0f4fc8fdb2de53198fb1163738093e9a311c33fb3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/web_atoms/0.2.6/download\"],\n strip_prefix = \"web_atoms-0.2.6\",\n build_file = Label(\"@crates//crates:BUILD.web_atoms-0.2.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-0.17.2\",\n sha256 = \"baaacdf9d96224d7b6e2872ba065578f38775f7634367e3ac2cc87c7271da433\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc/0.17.2/download\"],\n strip_prefix = \"webrtc-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-data-0.17.2\",\n sha256 = \"bd470286275809f2fcfcdb1e73ef5f1500be82eff7fe98150ce81b20aad5a2a4\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-data/0.17.2/download\"],\n strip_prefix = \"webrtc-data-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-data-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-ice-0.17.2\",\n sha256 = \"5b7fd30f52e6fda8664779b84b7904b2553b76fee24d9ca665e774ae32b13f53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-ice/0.17.2/download\"],\n strip_prefix = \"webrtc-ice-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-ice-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-mdns-0.17.2\",\n sha256 = \"91ffa0ea00c0fae979aafa5db285fec5eeb360e1ea246ebec529ba4e09f8e03e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-mdns/0.17.2/download\"],\n strip_prefix = \"webrtc-mdns-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-mdns-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-media-0.17.2\",\n sha256 = \"26a6c7335bdd03dc023cb9a3bd7966866d969c92c86987b73aa16dfa39c7ca29\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-media/0.17.2/download\"],\n strip_prefix = \"webrtc-media-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-media-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-sctp-0.17.2\",\n sha256 = \"1c4b637f0d8eb96d900ac0f79b3060ddd21ca88dfefa467e96e67ab0016f2574\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-sctp/0.17.2/download\"],\n strip_prefix = \"webrtc-sctp-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-sctp-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-srtp-0.17.2\",\n sha256 = \"45d2b667a0b5d04eebcb7cb22fd51b2af3721f418097b496e72de16386c8d0c3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-srtp/0.17.2/download\"],\n strip_prefix = \"webrtc-srtp-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-srtp-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__webrtc-util-0.17.2\",\n sha256 = \"1beae0b4f24969741c26ca282a257dc5823bd9cbe608f7e3ca3775102d323ad9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/webrtc-util/0.17.2/download\"],\n strip_prefix = \"webrtc-util-0.17.2\",\n build_file = Label(\"@crates//crates:BUILD.webrtc-util-0.17.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__weezl-0.1.12\",\n sha256 = \"a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/weezl/0.1.12/download\"],\n strip_prefix = \"weezl-0.1.12\",\n build_file = Label(\"@crates//crates:BUILD.weezl-0.1.12.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__whoami-2.1.3\",\n sha256 = \"626c4bac6755d76ffc12cb01b2eac751db1996b9e0041de9aa02c8c211ddc82c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/whoami/2.1.3/download\"],\n strip_prefix = \"whoami-2.1.3\",\n build_file = Label(\"@crates//crates:BUILD.whoami-2.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wide-1.7.0\",\n sha256 = \"8cf05ca94c9fba0c51316899caa1d1e74a064fc310a5efa7375e614343d415be\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wide/1.7.0/download\"],\n strip_prefix = \"wide-1.7.0\",\n build_file = Label(\"@crates//crates:BUILD.wide-1.7.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__widestring-1.2.1\",\n sha256 = \"72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/widestring/1.2.1/download\"],\n strip_prefix = \"widestring-1.2.1\",\n build_file = Label(\"@crates//crates:BUILD.widestring-1.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wild-2.2.1\",\n sha256 = \"a3131afc8c575281e1e80f36ed6a092aa502c08b18ed7524e86fbbb12bb410e1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wild/2.2.1/download\"],\n strip_prefix = \"wild-2.2.1\",\n build_file = Label(\"@crates//crates:BUILD.wild-2.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-0.3.9\",\n sha256 = \"5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi/0.3.9/download\"],\n strip_prefix = \"winapi-0.3.9\",\n build_file = Label(\"@crates//crates:BUILD.winapi-0.3.9.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-i686-pc-windows-gnu-0.4.0\",\n sha256 = \"ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi-i686-pc-windows-gnu/0.4.0/download\"],\n strip_prefix = \"winapi-i686-pc-windows-gnu-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.winapi-i686-pc-windows-gnu-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-util-0.1.11\",\n sha256 = \"c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi-util/0.1.11/download\"],\n strip_prefix = \"winapi-util-0.1.11\",\n build_file = Label(\"@crates//crates:BUILD.winapi-util-0.1.11.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winapi-x86_64-pc-windows-gnu-0.4.0\",\n sha256 = \"712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winapi-x86_64-pc-windows-gnu/0.4.0/download\"],\n strip_prefix = \"winapi-x86_64-pc-windows-gnu-0.4.0\",\n build_file = Label(\"@crates//crates:BUILD.winapi-x86_64-pc-windows-gnu-0.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-0.51.1\",\n sha256 = \"ca229916c5ee38c2f2bc1e9d8f04df975b4bd93f9955dc69fabb5d91270045c9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows/0.51.1/download\"],\n strip_prefix = \"windows-0.51.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-0.51.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-0.61.3\",\n sha256 = \"9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows/0.61.3/download\"],\n strip_prefix = \"windows-0.61.3\",\n build_file = Label(\"@crates//crates:BUILD.windows-0.61.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-0.62.2\",\n sha256 = \"527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows/0.62.2/download\"],\n strip_prefix = \"windows-0.62.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-0.62.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-collections-0.2.0\",\n sha256 = \"3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-collections/0.2.0/download\"],\n strip_prefix = \"windows-collections-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-collections-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-collections-0.3.2\",\n sha256 = \"23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-collections/0.3.2/download\"],\n strip_prefix = \"windows-collections-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-collections-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-core-0.51.1\",\n sha256 = \"f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-core/0.51.1/download\"],\n strip_prefix = \"windows-core-0.51.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-core-0.51.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-core-0.61.2\",\n sha256 = \"c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-core/0.61.2/download\"],\n strip_prefix = \"windows-core-0.61.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-core-0.61.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-core-0.62.2\",\n sha256 = \"b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-core/0.62.2/download\"],\n strip_prefix = \"windows-core-0.62.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-core-0.62.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-future-0.2.1\",\n sha256 = \"fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-future/0.2.1/download\"],\n strip_prefix = \"windows-future-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-future-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-future-0.3.2\",\n sha256 = \"e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-future/0.3.2/download\"],\n strip_prefix = \"windows-future-0.3.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-future-0.3.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-implement-0.60.2\",\n sha256 = \"053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-implement/0.60.2/download\"],\n strip_prefix = \"windows-implement-0.60.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-implement-0.60.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-interface-0.59.3\",\n sha256 = \"3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-interface/0.59.3/download\"],\n strip_prefix = \"windows-interface-0.59.3\",\n build_file = Label(\"@crates//crates:BUILD.windows-interface-0.59.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-link-0.1.3\",\n sha256 = \"5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-link/0.1.3/download\"],\n strip_prefix = \"windows-link-0.1.3\",\n build_file = Label(\"@crates//crates:BUILD.windows-link-0.1.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-link-0.2.1\",\n sha256 = \"f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-link/0.2.1/download\"],\n strip_prefix = \"windows-link-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-link-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-numerics-0.2.0\",\n sha256 = \"9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-numerics/0.2.0/download\"],\n strip_prefix = \"windows-numerics-0.2.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-numerics-0.2.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-numerics-0.3.1\",\n sha256 = \"6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-numerics/0.3.1/download\"],\n strip_prefix = \"windows-numerics-0.3.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-numerics-0.3.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-result-0.3.4\",\n sha256 = \"56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-result/0.3.4/download\"],\n strip_prefix = \"windows-result-0.3.4\",\n build_file = Label(\"@crates//crates:BUILD.windows-result-0.3.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-result-0.4.1\",\n sha256 = \"7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-result/0.4.1/download\"],\n strip_prefix = \"windows-result-0.4.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-result-0.4.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-strings-0.4.2\",\n sha256 = \"56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-strings/0.4.2/download\"],\n strip_prefix = \"windows-strings-0.4.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-strings-0.4.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-strings-0.5.1\",\n sha256 = \"7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-strings/0.5.1/download\"],\n strip_prefix = \"windows-strings-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-strings-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.52.0\",\n sha256 = \"282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.52.0/download\"],\n strip_prefix = \"windows-sys-0.52.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.52.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.59.0\",\n sha256 = \"1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.59.0/download\"],\n strip_prefix = \"windows-sys-0.59.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.59.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.60.2\",\n sha256 = \"f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.60.2/download\"],\n strip_prefix = \"windows-sys-0.60.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.60.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-sys-0.61.2\",\n sha256 = \"ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-sys/0.61.2/download\"],\n strip_prefix = \"windows-sys-0.61.2\",\n build_file = Label(\"@crates//crates:BUILD.windows-sys-0.61.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-targets-0.48.5\",\n sha256 = \"9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-targets/0.48.5/download\"],\n strip_prefix = \"windows-targets-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows-targets-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-targets-0.52.6\",\n sha256 = \"9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-targets/0.52.6/download\"],\n strip_prefix = \"windows-targets-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows-targets-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-targets-0.53.5\",\n sha256 = \"4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-targets/0.53.5/download\"],\n strip_prefix = \"windows-targets-0.53.5\",\n build_file = Label(\"@crates//crates:BUILD.windows-targets-0.53.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-threading-0.1.0\",\n sha256 = \"b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-threading/0.1.0/download\"],\n strip_prefix = \"windows-threading-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.windows-threading-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows-threading-0.2.1\",\n sha256 = \"3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows-threading/0.2.1/download\"],\n strip_prefix = \"windows-threading-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.windows-threading-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_gnullvm-0.48.5\",\n sha256 = \"2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_gnullvm/0.48.5/download\"],\n strip_prefix = \"windows_aarch64_gnullvm-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_gnullvm-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_gnullvm-0.52.6\",\n sha256 = \"32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_gnullvm-0.53.1\",\n sha256 = \"a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_gnullvm/0.53.1/download\"],\n strip_prefix = \"windows_aarch64_gnullvm-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_gnullvm-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_msvc-0.48.5\",\n sha256 = \"dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_msvc/0.48.5/download\"],\n strip_prefix = \"windows_aarch64_msvc-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_msvc-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_msvc-0.52.6\",\n sha256 = \"09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_aarch64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_aarch64_msvc-0.53.1\",\n sha256 = \"b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_aarch64_msvc/0.53.1/download\"],\n strip_prefix = \"windows_aarch64_msvc-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_aarch64_msvc-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnu-0.48.5\",\n sha256 = \"a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnu/0.48.5/download\"],\n strip_prefix = \"windows_i686_gnu-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnu-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnu-0.52.6\",\n sha256 = \"8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnu/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnu-0.53.1\",\n sha256 = \"960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnu/0.53.1/download\"],\n strip_prefix = \"windows_i686_gnu-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnu-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnullvm-0.52.6\",\n sha256 = \"0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_i686_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_gnullvm-0.53.1\",\n sha256 = \"fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_gnullvm/0.53.1/download\"],\n strip_prefix = \"windows_i686_gnullvm-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_gnullvm-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_msvc-0.48.5\",\n sha256 = \"8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_msvc/0.48.5/download\"],\n strip_prefix = \"windows_i686_msvc-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_msvc-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_msvc-0.52.6\",\n sha256 = \"240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_msvc/0.52.6/download\"],\n strip_prefix = \"windows_i686_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_i686_msvc-0.53.1\",\n sha256 = \"1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_i686_msvc/0.53.1/download\"],\n strip_prefix = \"windows_i686_msvc-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_i686_msvc-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnu-0.48.5\",\n sha256 = \"53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnu/0.48.5/download\"],\n strip_prefix = \"windows_x86_64_gnu-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnu-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnu-0.52.6\",\n sha256 = \"147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnu/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnu-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnu-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnu-0.53.1\",\n sha256 = \"9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnu/0.53.1/download\"],\n strip_prefix = \"windows_x86_64_gnu-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnu-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnullvm-0.48.5\",\n sha256 = \"0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnullvm/0.48.5/download\"],\n strip_prefix = \"windows_x86_64_gnullvm-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnullvm-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnullvm-0.52.6\",\n sha256 = \"24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnullvm/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_gnullvm-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnullvm-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_gnullvm-0.53.1\",\n sha256 = \"0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_gnullvm/0.53.1/download\"],\n strip_prefix = \"windows_x86_64_gnullvm-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_gnullvm-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_msvc-0.48.5\",\n sha256 = \"ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_msvc/0.48.5/download\"],\n strip_prefix = \"windows_x86_64_msvc-0.48.5\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_msvc-0.48.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_msvc-0.52.6\",\n sha256 = \"589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_msvc/0.52.6/download\"],\n strip_prefix = \"windows_x86_64_msvc-0.52.6\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_msvc-0.52.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__windows_x86_64_msvc-0.53.1\",\n sha256 = \"d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/windows_x86_64_msvc/0.53.1/download\"],\n strip_prefix = \"windows_x86_64_msvc-0.53.1\",\n build_file = Label(\"@crates//crates:BUILD.windows_x86_64_msvc-0.53.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-0.7.15\",\n sha256 = \"df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/0.7.15/download\"],\n strip_prefix = \"winnow-0.7.15\",\n build_file = Label(\"@crates//crates:BUILD.winnow-0.7.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winnow-1.0.4\",\n sha256 = \"23b97319f7b8343df12cc98938e5c3eb436064524c8d2b4e30a1d3a36eecdf81\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winnow/1.0.4/download\"],\n strip_prefix = \"winnow-1.0.4\",\n build_file = Label(\"@crates//crates:BUILD.winnow-1.0.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winreg-0.10.1\",\n sha256 = \"80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winreg/0.10.1/download\"],\n strip_prefix = \"winreg-0.10.1\",\n build_file = Label(\"@crates//crates:BUILD.winreg-0.10.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__winreg-0.56.0\",\n sha256 = \"7d6f32a0ff4a9f6f01231eb2059cc85479330739333e0e58cadf03b6af2cca10\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/winreg/0.56.0/download\"],\n strip_prefix = \"winreg-0.56.0\",\n build_file = Label(\"@crates//crates:BUILD.winreg-0.56.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wit-bindgen-0.57.1\",\n sha256 = \"1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wit-bindgen/0.57.1/download\"],\n strip_prefix = \"wit-bindgen-0.57.1\",\n build_file = Label(\"@crates//crates:BUILD.wit-bindgen-0.57.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wl-clipboard-rs-0.9.3\",\n sha256 = \"e9651471a32e87d96ef3a127715382b2d11cc7c8bb9822ded8a7cc94072eb0a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wl-clipboard-rs/0.9.3/download\"],\n strip_prefix = \"wl-clipboard-rs-0.9.3\",\n build_file = Label(\"@crates//crates:BUILD.wl-clipboard-rs-0.9.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__write16-1.0.0\",\n sha256 = \"d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/write16/1.0.0/download\"],\n strip_prefix = \"write16-1.0.0\",\n build_file = Label(\"@crates//crates:BUILD.write16-1.0.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__writeable-0.6.4\",\n sha256 = \"3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/writeable/0.6.4/download\"],\n strip_prefix = \"writeable-0.6.4\",\n build_file = Label(\"@crates//crates:BUILD.writeable-0.6.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__wyz-0.5.1\",\n sha256 = \"05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/wyz/0.5.1/download\"],\n strip_prefix = \"wyz-0.5.1\",\n build_file = Label(\"@crates//crates:BUILD.wyz-0.5.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__x11rb-0.13.2\",\n sha256 = \"9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/x11rb/0.13.2/download\"],\n strip_prefix = \"x11rb-0.13.2\",\n build_file = Label(\"@crates//crates:BUILD.x11rb-0.13.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__x11rb-protocol-0.13.2\",\n sha256 = \"ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/x11rb-protocol/0.13.2/download\"],\n strip_prefix = \"x11rb-protocol-0.13.2\",\n build_file = Label(\"@crates//crates:BUILD.x11rb-protocol-0.13.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__x25519-dalek-2.0.1\",\n sha256 = \"c7e468321c81fb07fa7f4c636c3972b9100f0346e5b6a9f2bd0603a52f7ed277\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/x25519-dalek/2.0.1/download\"],\n strip_prefix = \"x25519-dalek-2.0.1\",\n build_file = Label(\"@crates//crates:BUILD.x25519-dalek-2.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__x509-parser-0.16.0\",\n sha256 = \"fcbc162f30700d6f3f82a24bf7cc62ffe7caea42c0b2cba8bf7f3ae50cf51f69\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/x509-parser/0.16.0/download\"],\n strip_prefix = \"x509-parser-0.16.0\",\n build_file = Label(\"@crates//crates:BUILD.x509-parser-0.16.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xattr-1.6.1\",\n sha256 = \"32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xattr/1.6.1/download\"],\n strip_prefix = \"xattr-1.6.1\",\n build_file = Label(\"@crates//crates:BUILD.xattr-1.6.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xcap-0.9.6\",\n sha256 = \"b6ad471d5ba232bc276382d26a9d3b837d6853b7df389058b5bb1e94dcdd248c\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xcap/0.9.6/download\"],\n strip_prefix = \"xcap-0.9.6\",\n build_file = Label(\"@crates//crates:BUILD.xcap-0.9.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xcb-1.7.1\",\n sha256 = \"a6c2ad15e0e922856ee89afe862b8992334bbe7953adad56cd1199358cb30566\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xcb/1.7.1/download\"],\n strip_prefix = \"xcb-1.7.1\",\n build_file = Label(\"@crates//crates:BUILD.xcb-1.7.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xkbcommon-0.9.0\",\n sha256 = \"a7a974f48060a14e95705c01f24ad9c3345022f4d97441b8a36beb7ed5c4a02d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xkbcommon/0.9.0/download\"],\n strip_prefix = \"xkbcommon-0.9.0\",\n build_file = Label(\"@crates//crates:BUILD.xkbcommon-0.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xkeysym-0.2.1\",\n sha256 = \"b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xkeysym/0.2.1/download\"],\n strip_prefix = \"xkeysym-0.2.1\",\n build_file = Label(\"@crates//crates:BUILD.xkeysym-0.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xml-rs-0.8.29\",\n sha256 = \"e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xml-rs/0.8.29/download\"],\n strip_prefix = \"xml-rs-0.8.29\",\n build_file = Label(\"@crates//crates:BUILD.xml-rs-0.8.29.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xmlwriter-0.1.0\",\n sha256 = \"ec7a2a501ed189703dba8b08142f057e887dfc4b2cc4db2d343ac6376ba3e0b9\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xmlwriter/0.1.0/download\"],\n strip_prefix = \"xmlwriter-0.1.0\",\n build_file = Label(\"@crates//crates:BUILD.xmlwriter-0.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xutf-1.4.0\",\n sha256 = \"a14f3ca7038796715a5f5fd1c22aac21423b4f86fd9ef5585ef1744a5cfc573e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xutf/1.4.0/download\"],\n strip_prefix = \"xutf-1.4.0\",\n build_file = Label(\"@crates//crates:BUILD.xutf-1.4.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__xxhash-rust-0.8.18\",\n sha256 = \"aee1b19627c7c60102ab80d3a9cbe18de90bfe03bfa6c3715447681f0e8c8af6\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/xxhash-rust/0.8.18/download\"],\n strip_prefix = \"xxhash-rust-0.8.18\",\n build_file = Label(\"@crates//crates:BUILD.xxhash-rust-0.8.18.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yaml-rust-0.4.5\",\n sha256 = \"56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yaml-rust/0.4.5/download\"],\n strip_prefix = \"yaml-rust-0.4.5\",\n build_file = Label(\"@crates//crates:BUILD.yaml-rust-0.4.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yansi-1.0.1\",\n sha256 = \"cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yansi/1.0.1/download\"],\n strip_prefix = \"yansi-1.0.1\",\n build_file = Label(\"@crates//crates:BUILD.yansi-1.0.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yasna-0.5.2\",\n sha256 = \"e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yasna/0.5.2/download\"],\n strip_prefix = \"yasna-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.yasna-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yoke-0.8.3\",\n sha256 = \"709fe23a0424b6a435d82152b1bd3fdfb0833487d5fa90d05d42762a9891fef5\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yoke/0.8.3/download\"],\n strip_prefix = \"yoke-0.8.3\",\n build_file = Label(\"@crates//crates:BUILD.yoke-0.8.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__yoke-derive-0.8.2\",\n sha256 = \"de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/yoke-derive/0.8.2/download\"],\n strip_prefix = \"yoke-derive-0.8.2\",\n build_file = Label(\"@crates//crates:BUILD.yoke-derive-0.8.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__z85-3.0.7\",\n sha256 = \"c6e61e59a957b7ccee15d2049f86e8bfd6f66968fcd88f018950662d9b86e675\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/z85/3.0.7/download\"],\n strip_prefix = \"z85-3.0.7\",\n build_file = Label(\"@crates//crates:BUILD.z85-3.0.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus-5.19.0\",\n sha256 = \"5db4be7c075cb421e4b7ee645541604239bd243ba7c357511f4ff3a74b555907\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus/5.19.0/download\"],\n strip_prefix = \"zbus-5.19.0\",\n build_file = Label(\"@crates//crates:BUILD.zbus-5.19.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus-lockstep-0.5.2\",\n sha256 = \"6998de05217a084b7578728a9443d04ea4cd80f2a0839b8d78770b76ccd45863\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus-lockstep/0.5.2/download\"],\n strip_prefix = \"zbus-lockstep-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.zbus-lockstep-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus-lockstep-macros-0.5.2\",\n sha256 = \"10da05367f3a7b7553c8cdf8fa91aee6b64afebe32b51c95177957efc47ca3a0\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus-lockstep-macros/0.5.2/download\"],\n strip_prefix = \"zbus-lockstep-macros-0.5.2\",\n build_file = Label(\"@crates//crates:BUILD.zbus-lockstep-macros-0.5.2.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus_macros-5.19.0\",\n sha256 = \"2990635d09ade6df1868f72f8cac69a876a90981e8bd3c40b1be413f8dc88f40\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus_macros/5.19.0/download\"],\n strip_prefix = \"zbus_macros-5.19.0\",\n build_file = Label(\"@crates//crates:BUILD.zbus_macros-5.19.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus_names-4.3.4\",\n sha256 = \"d8bf88b4a3ff53e883001e0e0115b297a9d53c31b9c1edd2bfdd853e3428624e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus_names/4.3.4/download\"],\n strip_prefix = \"zbus_names-4.3.4\",\n build_file = Label(\"@crates//crates:BUILD.zbus_names-4.3.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zbus_xml-5.2.1\",\n sha256 = \"d1586c021a01ca0a9216dcd874e546382e156a5cbab5fab6cb5f10087e22682a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zbus_xml/5.2.1/download\"],\n strip_prefix = \"zbus_xml-5.2.1\",\n build_file = Label(\"@crates//crates:BUILD.zbus_xml-5.2.1.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zcheapstr-1.1.0\",\n sha256 = \"d1afec51604565183aeb5c54c20aeab286120d4e4460f7f76e3e8bb8c0d99473\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zcheapstr/1.1.0/download\"],\n strip_prefix = \"zcheapstr-1.1.0\",\n build_file = Label(\"@crates//crates:BUILD.zcheapstr-1.1.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-0.8.56\",\n sha256 = \"556764e583adb45a9f8d413c2a147fa7e8d821e48e12b14fd560b607998b75eb\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy/0.8.56/download\"],\n strip_prefix = \"zerocopy-0.8.56\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-0.8.56.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerocopy-derive-0.8.56\",\n sha256 = \"f2ab42fc20575779bd240faa45f94a74256f755c0fa9e89f0ede20d91d0cdfc1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerocopy-derive/0.8.56/download\"],\n strip_prefix = \"zerocopy-derive-0.8.56\",\n build_file = Label(\"@crates//crates:BUILD.zerocopy-derive-0.8.56.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerofrom-0.1.8\",\n sha256 = \"0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerofrom/0.1.8/download\"],\n strip_prefix = \"zerofrom-0.1.8\",\n build_file = Label(\"@crates//crates:BUILD.zerofrom-0.1.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerofrom-derive-0.1.7\",\n sha256 = \"11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerofrom-derive/0.1.7/download\"],\n strip_prefix = \"zerofrom-derive-0.1.7\",\n build_file = Label(\"@crates//crates:BUILD.zerofrom-derive-0.1.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zeroize-1.9.0\",\n sha256 = \"e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zeroize/1.9.0/download\"],\n strip_prefix = \"zeroize-1.9.0\",\n build_file = Label(\"@crates//crates:BUILD.zeroize-1.9.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zeroize_derive-1.5.0\",\n sha256 = \"3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zeroize_derive/1.5.0/download\"],\n strip_prefix = \"zeroize_derive-1.5.0\",\n build_file = Label(\"@crates//crates:BUILD.zeroize_derive-1.5.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerotrie-0.2.5\",\n sha256 = \"4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerotrie/0.2.5/download\"],\n strip_prefix = \"zerotrie-0.2.5\",\n build_file = Label(\"@crates//crates:BUILD.zerotrie-0.2.5.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerovec-0.11.8\",\n sha256 = \"bb0464e17806c1d976d5cba29399c7f08e516e279e2ba493f63123b5fca67dd8\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerovec/0.11.8/download\"],\n strip_prefix = \"zerovec-0.11.8\",\n build_file = Label(\"@crates//crates:BUILD.zerovec-0.11.8.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zerovec-derive-0.11.6\",\n sha256 = \"34df6fc39dbd26ddc9c10e6a2984476e13acce22e64e4487636ef494369225da\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zerovec-derive/0.11.6/download\"],\n strip_prefix = \"zerovec-derive-0.11.6\",\n build_file = Label(\"@crates//crates:BUILD.zerovec-derive-0.11.6.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zlib-rs-0.6.7\",\n sha256 = \"34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zlib-rs/0.6.7/download\"],\n strip_prefix = \"zlib-rs-0.6.7\",\n build_file = Label(\"@crates//crates:BUILD.zlib-rs-0.6.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zmij-1.0.23\",\n sha256 = \"29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zmij/1.0.23/download\"],\n strip_prefix = \"zmij-1.0.23\",\n build_file = Label(\"@crates//crates:BUILD.zmij-1.0.23.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zstd-0.13.3\",\n sha256 = \"e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zstd/0.13.3/download\"],\n strip_prefix = \"zstd-0.13.3\",\n build_file = Label(\"@crates//crates:BUILD.zstd-0.13.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zstd-safe-7.2.4\",\n sha256 = \"8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zstd-safe/7.2.4/download\"],\n strip_prefix = \"zstd-safe-7.2.4\",\n build_file = Label(\"@crates//crates:BUILD.zstd-safe-7.2.4.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zstd-sys-2.0.16-zstd.1.5.7\",\n sha256 = \"91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zstd-sys/2.0.16+zstd.1.5.7/download\"],\n strip_prefix = \"zstd-sys-2.0.16+zstd.1.5.7\",\n build_file = Label(\"@crates//crates:BUILD.zstd-sys-2.0.16+zstd.1.5.7.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zune-core-0.5.3\",\n sha256 = \"d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zune-core/0.5.3/download\"],\n strip_prefix = \"zune-core-0.5.3\",\n build_file = Label(\"@crates//crates:BUILD.zune-core-0.5.3.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zune-jpeg-0.5.15\",\n sha256 = \"27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zune-jpeg/0.5.15/download\"],\n strip_prefix = \"zune-jpeg-0.5.15\",\n build_file = Label(\"@crates//crates:BUILD.zune-jpeg-0.5.15.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zvariant-5.15.0\",\n sha256 = \"c1d34c27cc6cdd1f458427519dd6b8612f7b7e3f7b9a0b2355d041dda9869147\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zvariant/5.15.0/download\"],\n strip_prefix = \"zvariant-5.15.0\",\n build_file = Label(\"@crates//crates:BUILD.zvariant-5.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zvariant_derive-5.15.0\",\n sha256 = \"864155e69b4352db0c7f374917bf45d1e0c8d17659c8b3dbf9795f3673f8c497\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zvariant_derive/5.15.0/download\"],\n strip_prefix = \"zvariant_derive-5.15.0\",\n build_file = Label(\"@crates//crates:BUILD.zvariant_derive-5.15.0.bazel\"),\n )\n\n maybe(\n http_archive,\n name = \"crates__zvariant_utils-4.2.0\",\n sha256 = \"bad0294361a320b694a328460dc73add56c306150f5cb6bfafc44446120008a3\",\n type = \"tar.gz\",\n urls = [\"https://static.crates.io/crates/zvariant_utils/4.2.0/download\"],\n strip_prefix = \"zvariant_utils-4.2.0\",\n build_file = Label(\"@crates//crates:BUILD.zvariant_utils-4.2.0.bazel\"),\n )\n\n return [\n struct(repo = \"crates\", is_dev_dep = False),\n struct(repo=\"crates__ansi-width-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__anyhow-1.0.104\", is_dev_dep = False),\n struct(repo=\"crates__arboard-3.6.1\", is_dev_dep = False),\n struct(repo=\"crates__argmax-0.3.1\", is_dev_dep = False),\n struct(repo=\"crates__ashpd-0.11.1\", is_dev_dep = False),\n struct(repo=\"crates__ast-grep-core-0.39.9\", is_dev_dep = False),\n struct(repo=\"crates__async-recursion-1.1.1\", is_dev_dep = False),\n struct(repo=\"crates__async-trait-0.1.92\", is_dev_dep = False),\n struct(repo=\"crates__atspi-0.30.0\", is_dev_dep = False),\n struct(repo=\"crates__audiopus_sys-0.2.2\", is_dev_dep = False),\n struct(repo=\"crates__base64-0.22.1\", is_dev_dep = False),\n struct(repo=\"crates__bigdecimal-0.4.10\", is_dev_dep = False),\n struct(repo=\"crates__binary-heap-plus-0.5.0\", is_dev_dep = False),\n struct(repo=\"crates__bon-3.10.0\", is_dev_dep = False),\n struct(repo=\"crates__brush-parser-0.3.0\", is_dev_dep = False),\n struct(repo=\"crates__brush-parser-0.4.0\", is_dev_dep = False),\n struct(repo=\"crates__bstr-1.13.1\", is_dev_dep = False),\n struct(repo=\"crates__bytecount-0.6.9\", is_dev_dep = False),\n struct(repo=\"crates__bytes-1.12.1\", is_dev_dep = False),\n struct(repo=\"crates__cached-0.59.0\", is_dev_dep = False),\n struct(repo=\"crates__cfg-if-1.0.4\", is_dev_dep = False),\n struct(repo=\"crates__check_elevation-0.2.7\", is_dev_dep = False),\n struct(repo=\"crates__chrono-0.4.45\", is_dev_dep = False),\n struct(repo=\"crates__clap-4.6.6\", is_dev_dep = False),\n struct(repo=\"crates__clipboard-win-5.4.1\", is_dev_dep = False),\n struct(repo=\"crates__codesnake-0.2.1\", is_dev_dep = False),\n struct(repo=\"crates__color-print-0.3.7\", is_dev_dep = False),\n struct(repo=\"crates__command-fds-0.3.3\", is_dev_dep = False),\n struct(repo=\"crates__compare-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__core-graphics-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__dashmap-6.2.1\", is_dev_dep = False),\n struct(repo=\"crates__dns-lookup-3.0.1\", is_dev_dep = False),\n struct(repo=\"crates__enigo-0.6.1\", is_dev_dep = False),\n struct(repo=\"crates__faccess-0.2.4\", is_dev_dep = False),\n struct(repo=\"crates__fancy-regex-0.17.0\", is_dev_dep = False),\n struct(repo=\"crates__filetime-0.2.29\", is_dev_dep = False),\n struct(repo=\"crates__flume-0.11.1\", is_dev_dep = False),\n struct(repo=\"crates__foldhash-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__fontdue-0.9.4\", is_dev_dep = False),\n struct(repo=\"crates__foreign-types-0.5.0\", is_dev_dep = False),\n struct(repo=\"crates__fs_extra-1.3.0\", is_dev_dep = False),\n struct(repo=\"crates__futures-0.3.34\", is_dev_dep = False),\n struct(repo=\"crates__getrandom-0.4.3\", is_dev_dep = False),\n struct(repo=\"crates__gix-0.85.0\", is_dev_dep = False),\n struct(repo=\"crates__glob-0.3.4\", is_dev_dep = False),\n struct(repo=\"crates__globset-0.4.20\", is_dev_dep = False),\n struct(repo=\"crates__grep-cli-0.1.12\", is_dev_dep = False),\n struct(repo=\"crates__grep-matcher-0.1.9\", is_dev_dep = False),\n struct(repo=\"crates__grep-pcre2-0.1.10\", is_dev_dep = False),\n struct(repo=\"crates__grep-printer-0.3.1\", is_dev_dep = False),\n struct(repo=\"crates__grep-regex-0.1.14\", is_dev_dep = False),\n struct(repo=\"crates__grep-searcher-0.1.17\", is_dev_dep = False),\n struct(repo=\"crates__heapless-0.9.3\", is_dev_dep = False),\n struct(repo=\"crates__hex-0.4.3\", is_dev_dep = False),\n struct(repo=\"crates__hifijson-0.2.3\", is_dev_dep = False),\n struct(repo=\"crates__hostname-0.4.2\", is_dev_dep = False),\n struct(repo=\"crates__html-to-markdown-rs-3.11.4\", is_dev_dep = False),\n struct(repo=\"crates__icy_sixel-0.5.1\", is_dev_dep = False),\n struct(repo=\"crates__ignore-0.4.33\", is_dev_dep = False),\n struct(repo=\"crates__image-0.25.10\", is_dev_dep = False),\n struct(repo=\"crates__indicatif-0.18.6\", is_dev_dep = False),\n struct(repo=\"crates__inferno-0.12.8\", is_dev_dep = False),\n struct(repo=\"crates__inherent-1.0.14\", is_dev_dep = False),\n struct(repo=\"crates__itertools-0.14.0\", is_dev_dep = False),\n struct(repo=\"crates__jaq-core-2.2.1\", is_dev_dep = False),\n struct(repo=\"crates__jaq-json-1.1.3\", is_dev_dep = False),\n struct(repo=\"crates__jaq-std-2.1.2\", is_dev_dep = False),\n struct(repo=\"crates__jiff-0.2.35\", is_dev_dep = False),\n struct(repo=\"crates__jj-lib-0.44.0\", is_dev_dep = False),\n struct(repo=\"crates__libc-0.2.189\", is_dev_dep = False),\n struct(repo=\"crates__lscolors-0.21.0\", is_dev_dep = False),\n struct(repo=\"crates__memchr-2.8.3\", is_dev_dep = False),\n struct(repo=\"crates__memmap2-0.9.11\", is_dev_dep = False),\n struct(repo=\"crates__napi-3.12.2\", is_dev_dep = False),\n struct(repo=\"crates__napi-build-2.4.1\", is_dev_dep = False),\n struct(repo=\"crates__napi-derive-3.6.3\", is_dev_dep = False),\n struct(repo=\"crates__nix-0.31.3\", is_dev_dep = False),\n struct(repo=\"crates__nom-8.0.0\", is_dev_dep = False),\n struct(repo=\"crates__normalize-path-0.2.1\", is_dev_dep = False),\n struct(repo=\"crates__notify-8.2.0\", is_dev_dep = False),\n struct(repo=\"crates__num-bigint-0.4.8\", is_dev_dep = False),\n struct(repo=\"crates__num-traits-0.2.19\", is_dev_dep = False),\n struct(repo=\"crates__objc2-0.6.4\", is_dev_dep = False),\n struct(repo=\"crates__objc2-app-kit-0.3.2\", is_dev_dep = False),\n struct(repo=\"crates__objc2-application-services-0.3.2\", is_dev_dep = False),\n struct(repo=\"crates__objc2-core-foundation-0.3.2\", is_dev_dep = False),\n struct(repo=\"crates__objc2-core-graphics-0.3.2\", is_dev_dep = False),\n struct(repo=\"crates__objc2-foundation-0.3.2\", is_dev_dep = False),\n struct(repo=\"crates__onig-6.5.3\", is_dev_dep = False),\n struct(repo=\"crates__opus-0.3.1\", is_dev_dep = False),\n struct(repo=\"crates__os_display-0.1.4\", is_dev_dep = False),\n struct(repo=\"crates__os_pipe-1.2.3\", is_dev_dep = False),\n struct(repo=\"crates__parking_lot-0.12.5\", is_dev_dep = False),\n struct(repo=\"crates__parse_datetime-0.14.0\", is_dev_dep = False),\n struct(repo=\"crates__pdf-inspector-1.17.0\", is_dev_dep = False),\n struct(repo=\"crates__phf-0.13.1\", is_dev_dep = False),\n struct(repo=\"crates__platform-info-2.1.0\", is_dev_dep = False),\n struct(repo=\"crates__png-0.18.1\", is_dev_dep = False),\n struct(repo=\"crates__portable-pty-0.9.0\", is_dev_dep = False),\n struct(repo=\"crates__procfs-0.18.0\", is_dev_dep = False),\n struct(repo=\"crates__rand-0.10.2\", is_dev_dep = False),\n struct(repo=\"crates__rayon-1.12.0\", is_dev_dep = False),\n struct(repo=\"crates__regex-1.13.1\", is_dev_dep = False),\n struct(repo=\"crates__reis-0.5.0\", is_dev_dep = False),\n struct(repo=\"crates__resvg-0.48.1\", is_dev_dep = False),\n struct(repo=\"crates__rlimit-0.11.0\", is_dev_dep = False),\n struct(repo=\"crates__rpds-1.2.1\", is_dev_dep = False),\n struct(repo=\"crates__rustc-hash-2.1.3\", is_dev_dep = False),\n struct(repo=\"crates__rustix-1.1.4\", is_dev_dep = False),\n struct(repo=\"crates__self_cell-1.3.0\", is_dev_dep = False),\n struct(repo=\"crates__serde-1.0.229\", is_dev_dep = False),\n struct(repo=\"crates__serde_json-1.0.151\", is_dev_dep = False),\n struct(repo=\"crates__sha2-0.10.9\", is_dev_dep = False),\n struct(repo=\"crates__sha3-0.10.9\", is_dev_dep = False),\n struct(repo=\"crates__similar-3.2.0\", is_dev_dep = False),\n struct(repo=\"crates__smallvec-1.15.2\", is_dev_dep = False),\n struct(repo=\"crates__strum-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__strum_macros-0.28.0\", is_dev_dep = False),\n struct(repo=\"crates__syntect-5.3.0\", is_dev_dep = False),\n struct(repo=\"crates__tempfile-3.27.0\", is_dev_dep = False),\n struct(repo=\"crates__terminfo-0.9.0\", is_dev_dep = False),\n struct(repo=\"crates__thiserror-2.0.20\", is_dev_dep = False),\n struct(repo=\"crates__tokio-1.53.1\", is_dev_dep = False),\n struct(repo=\"crates__tokio-util-0.7.19\", is_dev_dep = False),\n struct(repo=\"crates__toml-1.1.4-spec-1.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tracing-0.1.44\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-0.25.10\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-astro-next-0.1.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-bash-0.25.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-c-0.24.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-c-sharp-0.23.5\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-clojure-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-cmake-0.7.4\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-cpp-0.23.4\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-css-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-dart-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-diff-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-dockerfile-updated-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-elisp-1.7.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-elixir-0.3.5\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-erlang-0.16.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-fortran-0.6.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-go-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-graphql-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-haskell-0.23.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-hcl-1.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-html-0.23.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-ini-1.4.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-java-0.23.5\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-javascript-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-json-0.24.8\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-julia-0.23.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-just-0.2.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-kotlin-sg-0.4.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-lua-0.5.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-make-1.1.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-md-0.5.3\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-nix-0.3.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-objc-3.0.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-ocaml-0.24.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-odin-1.3.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-php-0.24.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-powershell-0.26.4\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-proto-0.4.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-python-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-r-1.3.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-regex-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-ruby-0.23.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-rust-0.24.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-scala-0.26.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-sequel-0.3.11\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-solidity-1.2.13\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-starlark-1.3.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-svelte-next-0.1.1\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-swift-0.7.3\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-tlaplus-1.5.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-toml-ng-0.7.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-typescript-0.23.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-verilog-1.0.3\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-vue-next-0.1.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-xml-0.7.0\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-yaml-0.7.2\", is_dev_dep = False),\n struct(repo=\"crates__tree-sitter-zig-1.1.2\", is_dev_dep = False),\n struct(repo=\"crates__uiautomation-0.25.0\", is_dev_dep = False),\n struct(repo=\"crates__uucore-0.8.0\", is_dev_dep = False),\n struct(repo=\"crates__uuid-1.26.0\", is_dev_dep = False),\n struct(repo=\"crates__uutils_term_grid-0.8.0\", is_dev_dep = False),\n struct(repo=\"crates__uzers-0.12.2\", is_dev_dep = False),\n struct(repo=\"crates__webrtc-0.17.2\", is_dev_dep = False),\n struct(repo=\"crates__whoami-2.1.3\", is_dev_dep = False),\n struct(repo=\"crates__windows-sys-0.59.0\", is_dev_dep = False),\n struct(repo=\"crates__windows-sys-0.61.2\", is_dev_dep = False),\n struct(repo=\"crates__winreg-0.56.0\", is_dev_dep = False),\n struct(repo=\"crates__x11rb-0.13.2\", is_dev_dep = False),\n struct(repo=\"crates__xcap-0.9.6\", is_dev_dep = False),\n struct(repo=\"crates__xkeysym-0.2.1\", is_dev_dep = False),\n struct(repo=\"crates__xutf-1.4.0\", is_dev_dep = False),\n struct(repo=\"crates__xxhash-rust-0.8.18\", is_dev_dep = False),\n struct(repo=\"crates__yansi-1.0.1\", is_dev_dep = False),\n struct(repo=\"crates__zstd-0.13.3\", is_dev_dep = False),\n struct(repo=\"crates__zune-jpeg-0.5.15\", is_dev_dep = False),\n struct(repo = \"crates__fancy-regex-0.16.2\", is_dev_dep = True),\n struct(repo = \"crates__pretty_assertions-1.4.1\", is_dev_dep = True),\n struct(repo = \"crates__tiktoken-rs-0.11.0\", is_dev_dep = True),\n ]\n", "defs.bzl": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\"\"\"Deprecated: re-exports the crate_universe macros from `:crates.bzl`.\"\"\"\n\nload(\n \":crates.bzl\",\n _aliases = \"aliases\",\n _all_crate_deps = \"all_crate_deps\",\n _crate_deps = \"crate_deps\",\n _crate_edition = \"crate_edition\",\n _crate_repositories = \"crate_repositories\",\n)\n\naliases = _aliases\nall_crate_deps = _all_crate_deps\ncrate_deps = _crate_deps\ncrate_edition = _crate_edition\ncrate_repositories = _crate_repositories\n", "ansi-width-0.1.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"ansi-width-0.1.0\",\n actual = \"@crates__ansi-width-0.1.0//:ansi_width\",\n tags = [\"manual\"],\n)\n", "ansi-width/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"ansi-width\",\n actual = \"@crates__ansi-width-0.1.0//:ansi_width\",\n tags = [\"manual\"],\n)\n", @@ -548,8 +549,8 @@ "bigdecimal/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"bigdecimal\",\n actual = \"@crates__bigdecimal-0.4.10//:bigdecimal\",\n tags = [\"manual\"],\n)\n", "binary-heap-plus-0.5.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"binary-heap-plus-0.5.0\",\n actual = \"@crates__binary-heap-plus-0.5.0//:binary_heap_plus\",\n tags = [\"manual\"],\n)\n", "binary-heap-plus/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"binary-heap-plus\",\n actual = \"@crates__binary-heap-plus-0.5.0//:binary_heap_plus\",\n tags = [\"manual\"],\n)\n", - "bon-3.9.3/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"bon-3.9.3\",\n actual = \"@crates__bon-3.9.3//:bon\",\n tags = [\"manual\"],\n)\n", - "bon/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"bon\",\n actual = \"@crates__bon-3.9.3//:bon\",\n tags = [\"manual\"],\n)\n", + "bon-3.10.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"bon-3.10.0\",\n actual = \"@crates__bon-3.10.0//:bon\",\n tags = [\"manual\"],\n)\n", + "bon/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"bon\",\n actual = \"@crates__bon-3.10.0//:bon\",\n tags = [\"manual\"],\n)\n", "brush-parser-0.3.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"brush-parser-0.3.0\",\n actual = \"@crates__brush-parser-0.3.0//:brush_parser\",\n tags = [\"manual\"],\n)\n", "brush-parser-0.4.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"brush-parser-0.4.0\",\n actual = \"@crates__brush-parser-0.4.0//:brush_parser\",\n tags = [\"manual\"],\n)\n", "bstr-1.13.1/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"bstr-1.13.1\",\n actual = \"@crates__bstr-1.13.1//:bstr\",\n tags = [\"manual\"],\n)\n", @@ -606,6 +607,8 @@ "futures/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"futures\",\n actual = \"@crates__futures-0.3.34//:futures\",\n tags = [\"manual\"],\n)\n", "getrandom-0.4.3/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"getrandom-0.4.3\",\n actual = \"@crates__getrandom-0.4.3//:getrandom\",\n tags = [\"manual\"],\n)\n", "getrandom/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"getrandom\",\n actual = \"@crates__getrandom-0.4.3//:getrandom\",\n tags = [\"manual\"],\n)\n", + "gix-0.85.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"gix-0.85.0\",\n actual = \"@crates__gix-0.85.0//:gix\",\n tags = [\"manual\"],\n)\n", + "gix/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"gix\",\n actual = \"@crates__gix-0.85.0//:gix\",\n tags = [\"manual\"],\n)\n", "glob-0.3.4/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"glob-0.3.4\",\n actual = \"@crates__glob-0.3.4//:glob\",\n tags = [\"manual\"],\n)\n", "glob/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"glob\",\n actual = \"@crates__glob-0.3.4//:glob\",\n tags = [\"manual\"],\n)\n", "globset-0.4.20/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"globset-0.4.20\",\n actual = \"@crates__globset-0.4.20//:globset\",\n tags = [\"manual\"],\n)\n", @@ -630,8 +633,8 @@ "hifijson/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"hifijson\",\n actual = \"@crates__hifijson-0.2.3//:hifijson\",\n tags = [\"manual\"],\n)\n", "hostname-0.4.2/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"hostname-0.4.2\",\n actual = \"@crates__hostname-0.4.2//:hostname\",\n tags = [\"manual\"],\n)\n", "hostname/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"hostname\",\n actual = \"@crates__hostname-0.4.2//:hostname\",\n tags = [\"manual\"],\n)\n", - "html-to-markdown-rs-3.11.3/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"html-to-markdown-rs-3.11.3\",\n actual = \"@crates__html-to-markdown-rs-3.11.3//:html_to_markdown_rs\",\n tags = [\"manual\"],\n)\n", - "html-to-markdown-rs/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"html-to-markdown-rs\",\n actual = \"@crates__html-to-markdown-rs-3.11.3//:html_to_markdown_rs\",\n tags = [\"manual\"],\n)\n", + "html-to-markdown-rs-3.11.4/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"html-to-markdown-rs-3.11.4\",\n actual = \"@crates__html-to-markdown-rs-3.11.4//:html_to_markdown_rs\",\n tags = [\"manual\"],\n)\n", + "html-to-markdown-rs/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"html-to-markdown-rs\",\n actual = \"@crates__html-to-markdown-rs-3.11.4//:html_to_markdown_rs\",\n tags = [\"manual\"],\n)\n", "icy_sixel-0.5.1/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"icy_sixel-0.5.1\",\n actual = \"@crates__icy_sixel-0.5.1//:icy_sixel\",\n tags = [\"manual\"],\n)\n", "icy_sixel/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"icy_sixel\",\n actual = \"@crates__icy_sixel-0.5.1//:icy_sixel\",\n tags = [\"manual\"],\n)\n", "ignore-0.4.33/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"ignore-0.4.33\",\n actual = \"@crates__ignore-0.4.33//:ignore\",\n tags = [\"manual\"],\n)\n", @@ -654,6 +657,8 @@ "jaq-std/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"jaq-std\",\n actual = \"@crates__jaq-std-2.1.2//:jaq_std\",\n tags = [\"manual\"],\n)\n", "jiff-0.2.35/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"jiff-0.2.35\",\n actual = \"@crates__jiff-0.2.35//:jiff\",\n tags = [\"manual\"],\n)\n", "jiff/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"jiff\",\n actual = \"@crates__jiff-0.2.35//:jiff\",\n tags = [\"manual\"],\n)\n", + "jj-lib-0.44.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"jj-lib-0.44.0\",\n actual = \"@crates__jj-lib-0.44.0//:jj_lib\",\n tags = [\"manual\"],\n)\n", + "jj-lib/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"jj-lib\",\n actual = \"@crates__jj-lib-0.44.0//:jj_lib\",\n tags = [\"manual\"],\n)\n", "libc-0.2.189/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"libc-0.2.189\",\n actual = \"@crates__libc-0.2.189//:libc\",\n tags = [\"manual\"],\n)\n", "libc/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"libc\",\n actual = \"@crates__libc-0.2.189//:libc\",\n tags = [\"manual\"],\n)\n", "lscolors-0.21.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"lscolors-0.21.0\",\n actual = \"@crates__lscolors-0.21.0//:lscolors\",\n tags = [\"manual\"],\n)\n", @@ -708,8 +713,8 @@ "pdf-inspector/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"pdf-inspector\",\n actual = \"@crates__pdf-inspector-1.17.0//:pdf_inspector\",\n tags = [\"manual\"],\n)\n", "phf-0.13.1/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"phf-0.13.1\",\n actual = \"@crates__phf-0.13.1//:phf\",\n tags = [\"manual\"],\n)\n", "phf/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"phf\",\n actual = \"@crates__phf-0.13.1//:phf\",\n tags = [\"manual\"],\n)\n", - "pi-shell-18.0.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"pi-shell-18.0.0\",\n actual = \"@crates__pi-shell-18.0.0//:pi_shell\",\n tags = [\"manual\"],\n)\n", - "pi-shell/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"pi-shell\",\n actual = \"@crates__pi-shell-18.0.0//:pi_shell\",\n tags = [\"manual\"],\n)\n", + "pi-shell-18.0.9/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"pi-shell-18.0.9\",\n actual = \"@crates__pi-shell-18.0.9//:pi_shell\",\n tags = [\"manual\"],\n)\n", + "pi-shell/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"pi-shell\",\n actual = \"@crates__pi-shell-18.0.9//:pi_shell\",\n tags = [\"manual\"],\n)\n", "platform-info-2.1.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"platform-info-2.1.0\",\n actual = \"@crates__platform-info-2.1.0//:platform_info\",\n tags = [\"manual\"],\n)\n", "platform-info/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"platform-info\",\n actual = \"@crates__platform-info-2.1.0//:platform_info\",\n tags = [\"manual\"],\n)\n", "png-0.18.1/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"png-0.18.1\",\n actual = \"@crates__png-0.18.1//:png\",\n tags = [\"manual\"],\n)\n", @@ -728,6 +733,8 @@ "regex/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"regex\",\n actual = \"@crates__regex-1.13.1//:regex\",\n tags = [\"manual\"],\n)\n", "reis-0.5.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"reis-0.5.0\",\n actual = \"@crates__reis-0.5.0//:reis\",\n tags = [\"manual\"],\n)\n", "reis/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"reis\",\n actual = \"@crates__reis-0.5.0//:reis\",\n tags = [\"manual\"],\n)\n", + "resvg-0.48.1/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"resvg-0.48.1\",\n actual = \"@crates__resvg-0.48.1//:resvg\",\n tags = [\"manual\"],\n)\n", + "resvg/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"resvg\",\n actual = \"@crates__resvg-0.48.1//:resvg\",\n tags = [\"manual\"],\n)\n", "rlimit-0.11.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"rlimit-0.11.0\",\n actual = \"@crates__rlimit-0.11.0//:rlimit\",\n tags = [\"manual\"],\n)\n", "rlimit/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"rlimit\",\n actual = \"@crates__rlimit-0.11.0//:rlimit\",\n tags = [\"manual\"],\n)\n", "rpds-1.2.1/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"rpds-1.2.1\",\n actual = \"@crates__rpds-1.2.1//:rpds\",\n tags = [\"manual\"],\n)\n", @@ -742,6 +749,10 @@ "serde/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"serde\",\n actual = \"@crates__serde-1.0.229//:serde\",\n tags = [\"manual\"],\n)\n", "serde_json-1.0.151/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"serde_json-1.0.151\",\n actual = \"@crates__serde_json-1.0.151//:serde_json\",\n tags = [\"manual\"],\n)\n", "serde_json/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"serde_json\",\n actual = \"@crates__serde_json-1.0.151//:serde_json\",\n tags = [\"manual\"],\n)\n", + "sha2-0.10.9/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"sha2-0.10.9\",\n actual = \"@crates__sha2-0.10.9//:sha2\",\n tags = [\"manual\"],\n)\n", + "sha2/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"sha2\",\n actual = \"@crates__sha2-0.10.9//:sha2\",\n tags = [\"manual\"],\n)\n", + "sha3-0.10.9/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"sha3-0.10.9\",\n actual = \"@crates__sha3-0.10.9//:sha3\",\n tags = [\"manual\"],\n)\n", + "sha3/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"sha3\",\n actual = \"@crates__sha3-0.10.9//:sha3\",\n tags = [\"manual\"],\n)\n", "similar-3.2.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"similar-3.2.0\",\n actual = \"@crates__similar-3.2.0//:similar\",\n tags = [\"manual\"],\n)\n", "similar/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"similar\",\n actual = \"@crates__similar-3.2.0//:similar\",\n tags = [\"manual\"],\n)\n", "smallvec-1.15.2/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"smallvec-1.15.2\",\n actual = \"@crates__smallvec-1.15.2//:smallvec\",\n tags = [\"manual\"],\n)\n", @@ -892,8 +903,8 @@ "uiautomation/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"uiautomation\",\n actual = \"@crates__uiautomation-0.25.0//:uiautomation\",\n tags = [\"manual\"],\n)\n", "uucore-0.8.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"uucore-0.8.0\",\n actual = \"@crates__uucore-0.8.0//:uucore\",\n tags = [\"manual\"],\n)\n", "uucore/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"uucore\",\n actual = \"@crates__uucore-0.8.0//:uucore\",\n tags = [\"manual\"],\n)\n", - "uuid-1.24.1/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"uuid-1.24.1\",\n actual = \"@crates__uuid-1.24.1//:uuid\",\n tags = [\"manual\"],\n)\n", - "uuid/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"uuid\",\n actual = \"@crates__uuid-1.24.1//:uuid\",\n tags = [\"manual\"],\n)\n", + "uuid-1.26.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"uuid-1.26.0\",\n actual = \"@crates__uuid-1.26.0//:uuid\",\n tags = [\"manual\"],\n)\n", + "uuid/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"uuid\",\n actual = \"@crates__uuid-1.26.0//:uuid\",\n tags = [\"manual\"],\n)\n", "uutils_term_grid-0.8.0/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"uutils_term_grid-0.8.0\",\n actual = \"@crates__uutils_term_grid-0.8.0//:term_grid\",\n tags = [\"manual\"],\n)\n", "uutils_term_grid/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"uutils_term_grid\",\n actual = \"@crates__uutils_term_grid-0.8.0//:term_grid\",\n tags = [\"manual\"],\n)\n", "uzers-0.12.2/BUILD.bazel": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\npackage(default_visibility = [\"//visibility:public\"])\n\nalias(\n name = \"uzers-0.12.2\",\n actual = \"@crates__uzers-0.12.2//:uzers\",\n tags = [\"manual\"],\n)\n", @@ -1143,7 +1154,7 @@ "https://static.crates.io/crates/arboard/3.6.1/download" ], "strip_prefix": "arboard-3.6.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"arboard\",\n deps = [\n \"@crates__image-0.25.10//:image\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\", # aarch64-apple-darwin\n \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\", # aarch64-apple-darwin\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__log-0.4.33//:log\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__parking_lot-0.12.5//:parking_lot\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__wl-clipboard-rs-0.9.3//:wl_clipboard_rs\", # aarch64-unknown-linux-gnu\n \"@crates__x11rb-0.13.2//:x11rb\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__log-0.4.33//:log\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__parking_lot-0.12.5//:parking_lot\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__wl-clipboard-rs-0.9.3//:wl_clipboard_rs\", # aarch64-unknown-linux-musl\n \"@crates__x11rb-0.13.2//:x11rb\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\", # x86_64-apple-darwin\n \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\", # x86_64-apple-darwin\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__clipboard-win-5.4.1//:clipboard_win\", # cfg(windows)\n \"@crates__log-0.4.33//:log\", # cfg(windows)\n \"@crates__windows-sys-0.60.2//:windows_sys\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__log-0.4.33//:log\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__parking_lot-0.12.5//:parking_lot\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__wl-clipboard-rs-0.9.3//:wl_clipboard_rs\", # x86_64-unknown-linux-gnu\n \"@crates__x11rb-0.13.2//:x11rb\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__log-0.4.33//:log\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__parking_lot-0.12.5//:parking_lot\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__wl-clipboard-rs-0.9.3//:wl_clipboard_rs\", # x86_64-unknown-linux-musl\n \"@crates__x11rb-0.13.2//:x11rb\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"core-graphics\",\n \"default\",\n \"image\",\n \"image-data\",\n \"wayland-data-control\",\n \"windows-sys\",\n \"wl-clipboard-rs\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=arboard\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.6.1\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"arboard\",\n deps = [\n \"@crates__image-0.25.10//:image\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\", # aarch64-apple-darwin\n \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\", # aarch64-apple-darwin\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__log-0.4.34//:log\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__parking_lot-0.12.5//:parking_lot\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__wl-clipboard-rs-0.9.3//:wl_clipboard_rs\", # aarch64-unknown-linux-gnu\n \"@crates__x11rb-0.13.2//:x11rb\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__log-0.4.34//:log\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__parking_lot-0.12.5//:parking_lot\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__wl-clipboard-rs-0.9.3//:wl_clipboard_rs\", # aarch64-unknown-linux-musl\n \"@crates__x11rb-0.13.2//:x11rb\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\", # x86_64-apple-darwin\n \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\", # x86_64-apple-darwin\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__clipboard-win-5.4.1//:clipboard_win\", # cfg(windows)\n \"@crates__log-0.4.34//:log\", # cfg(windows)\n \"@crates__windows-sys-0.60.2//:windows_sys\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__log-0.4.34//:log\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__parking_lot-0.12.5//:parking_lot\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__wl-clipboard-rs-0.9.3//:wl_clipboard_rs\", # x86_64-unknown-linux-gnu\n \"@crates__x11rb-0.13.2//:x11rb\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__log-0.4.34//:log\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__parking_lot-0.12.5//:parking_lot\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n \"@crates__wl-clipboard-rs-0.9.3//:wl_clipboard_rs\", # x86_64-unknown-linux-musl\n \"@crates__x11rb-0.13.2//:x11rb\", # cfg(all(unix, not(any(target_os = \"macos\", target_os = \"android\", target_os = \"emscripten\"))))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"core-graphics\",\n \"default\",\n \"image\",\n \"image-data\",\n \"wayland-data-control\",\n \"windows-sys\",\n \"wl-clipboard-rs\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=arboard\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.6.1\",\n)\n" } }, "crates__arc-swap-1.9.2": { @@ -1185,6 +1196,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"argmax\",\n deps = [\n \"@crates__lazy_static-1.5.0//:lazy_static\",\n \"@crates__nix-0.24.3//:nix\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=argmax\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.1\",\n)\n" } }, + "crates__arrayref-0.3.9": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/arrayref/0.3.9/download" + ], + "strip_prefix": "arrayref-0.3.9", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"arrayref\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=arrayref\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.9\",\n)\n" + } + }, "crates__arrayvec-0.7.8": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -1351,7 +1375,7 @@ "https://static.crates.io/crates/async-process/2.5.0/download" ], "strip_prefix": "async-process-2.5.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"async_process\",\n deps = [\n \"@crates__async-io-2.6.0//:async_io\",\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__event-listener-5.4.2//:event_listener\",\n \"@crates__futures-lite-2.6.1//:futures_lite\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__async-channel-2.5.0//:async_channel\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__async-task-4.7.1//:async_task\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__async-channel-2.5.0//:async_channel\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__async-task-4.7.1//:async_task\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__async-channel-2.5.0//:async_channel\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__async-task-4.7.1//:async_task\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__blocking-1.6.2//:blocking\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__async-channel-2.5.0//:async_channel\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__async-task-4.7.1//:async_task\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__async-channel-2.5.0//:async_channel\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__async-task-4.7.1//:async_task\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=async-process\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.5.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"async_process\",\n deps = [\n \"@crates__async-io-2.6.0//:async_io\",\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__event-listener-5.4.2//:event_listener\",\n \"@crates__futures-lite-2.6.1//:futures_lite\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__async-channel-2.5.0//:async_channel\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__async-task-4.7.1//:async_task\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__async-channel-2.5.0//:async_channel\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__async-task-4.7.1//:async_task\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__async-channel-2.5.0//:async_channel\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__async-task-4.7.1//:async_task\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__blocking-1.7.0//:blocking\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__async-channel-2.5.0//:async_channel\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__async-task-4.7.1//:async_task\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__async-channel-2.5.0//:async_channel\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__async-lock-3.4.2//:async_lock\", # cfg(unix)\n \"@crates__async-signal-0.2.14//:async_signal\", # cfg(unix)\n \"@crates__async-task-4.7.1//:async_task\", # cfg(any(windows, target_os = \"linux\"))\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=async-process\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.5.0\",\n)\n" } }, "crates__async-recursion-1.1.1": { @@ -1403,7 +1427,7 @@ "https://static.crates.io/crates/async-trait/0.1.92/download" ], "strip_prefix": "async-trait-0.1.92", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"async_trait\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=async-trait\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.92\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"async_trait\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=async-trait\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.92\",\n)\n" } }, "crates__atomic-waker-1.1.2": { @@ -1487,7 +1511,7 @@ "https://static.crates.io/crates/audiopus_sys/0.2.2/download" ], "strip_prefix": "audiopus_sys-0.2.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"audiopus_sys\",\n deps = [\n \"@crates__audiopus_sys-0.2.2//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"static\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=audiopus_sys\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.2\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n build_script_env = {\n \"CFLAGS\": \"-fno-sanitize=undefined\",\n \"CMAKE_GENERATOR_x86_64_pc_windows_msvc\": \"Ninja\",\n \"CMAKE_POLICY_VERSION_MINIMUM\": \"3.5\",\n \"CMAKE_TOOLCHAIN_FILE_x86_64_pc_windows_msvc\": \"$${pwd}/external/+msvc_cc_repository+msvc_cc/toolchain.cmake\",\n \"OPUS_NO_PKG\": \"1\",\n \"PATH\": \"/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:/run/current-system/sw/bin\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"static\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n deps = [\n \"@crates__cmake-0.1.58//:cmake\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__pkg-config-0.3.34//:pkg_config\",\n ],\n emit_warnings = False,\n edition = \"2018\",\n pkg_name = \"audiopus_sys\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=audiopus_sys\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.2.2\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"audiopus_sys\",\n deps = [\n \"@crates__audiopus_sys-0.2.2//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"static\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=audiopus_sys\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.2\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n build_script_env = {\n \"CFLAGS\": \"-fno-sanitize=undefined\",\n \"CMAKE_GENERATOR_x86_64_pc_windows_msvc\": \"Ninja\",\n \"CMAKE_POLICY_VERSION_MINIMUM\": \"3.5\",\n \"CMAKE_TOOLCHAIN_FILE_x86_64_pc_windows_msvc\": \"$${pwd}/external/+msvc_cc_repository+msvc_cc/toolchain.cmake\",\n \"OPUS_NO_PKG\": \"1\",\n \"PATH\": \"/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:/run/current-system/sw/bin\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"static\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n deps = [\n \"@crates__cmake-0.1.58//:cmake\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__pkg-config-0.3.34//:pkg_config\",\n ],\n emit_warnings = False,\n edition = \"2018\",\n pkg_name = \"audiopus_sys\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=audiopus_sys\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.2.2\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, "crates__autocfg-1.5.1": { @@ -1568,6 +1592,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"base64ct\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=base64ct\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.8.3\",\n)\n" } }, + "crates__beef-0.5.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/beef/0.5.2/download" + ], + "strip_prefix": "beef-0.5.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"beef\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=beef\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.2\",\n)\n" + } + }, "crates__bigdecimal-0.4.10": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -1685,6 +1722,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"bitvec\",\n deps = [\n \"@crates__funty-2.0.0//:funty\",\n \"@crates__radium-0.7.0//:radium\",\n \"@crates__tap-1.0.1//:tap\",\n \"@crates__wyz-0.5.1//:wyz\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bitvec\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.1.1\",\n)\n" } }, + "crates__blake2-0.10.6": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/blake2/0.10.6/download" + ], + "strip_prefix": "blake2-0.10.6", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"blake2\",\n deps = [\n \"@crates__digest-0.10.7//:digest\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=blake2\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.6\",\n)\n" + } + }, "crates__blake2b_simd-1.0.5": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -1708,7 +1758,7 @@ "https://static.crates.io/crates/blake3/1.8.7/download" ], "strip_prefix": "blake3-1.8.7", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"blake3\",\n deps = [\n \"@crates__arrayvec-0.7.8//:arrayvec\",\n \"@crates__blake3-1.8.7//:build_script_build\",\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__constant_time_eq-0.4.2//:constant_time_eq\",\n ] + select({\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__cpufeatures-0.3.0//:cpufeatures\", # cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__cpufeatures-0.3.0//:cpufeatures\", # cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.3.0//:cpufeatures\", # cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.3.0//:cpufeatures\", # cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=blake3\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.8.7\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n build_script_env = {\n \"PATH\": \"$${pwd}/external/+msvc_cc_repository+msvc_cc/bin:/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n deps = [\n \"@crates__cc-1.2.67//:cc\",\n ],\n emit_warnings = False,\n edition = \"2024\",\n pkg_name = \"blake3\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=blake3\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"1.8.7\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"blake3\",\n deps = [\n \"@crates__arrayvec-0.7.8//:arrayvec\",\n \"@crates__blake3-1.8.7//:build_script_build\",\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__constant_time_eq-0.4.2//:constant_time_eq\",\n ] + select({\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=blake3\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.8.7\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n build_script_env = {\n \"PATH\": \"$${pwd}/external/+msvc_cc_repository+msvc_cc/bin:/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n deps = [\n \"@crates__cc-1.2.67//:cc\",\n ],\n emit_warnings = False,\n edition = \"2024\",\n pkg_name = \"blake3\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=blake3\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"1.8.7\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, "crates__block-buffer-0.10.4": { @@ -1763,43 +1813,43 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"block2\",\n deps = [\n \"@crates__objc2-0.6.4//:objc2\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=block2\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.6.2\",\n)\n" } }, - "crates__blocking-1.6.2": { + "crates__blocking-1.7.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21", + "sha256": "a70e4329df6cb94385eed412ec92375c3cdd8a6e502493d1229b6414e4036dfa", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/blocking/1.6.2/download" + "https://static.crates.io/crates/blocking/1.7.0/download" ], - "strip_prefix": "blocking-1.6.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"blocking\",\n deps = [\n \"@crates__async-channel-2.5.0//:async_channel\",\n \"@crates__async-task-4.7.1//:async_task\",\n \"@crates__futures-io-0.3.34//:futures_io\",\n \"@crates__futures-lite-2.6.1//:futures_lite\",\n \"@crates__piper-0.2.5//:piper\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=blocking\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.6.2\",\n)\n" + "strip_prefix": "blocking-1.7.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"blocking\",\n deps = [\n \"@crates__async-channel-2.5.0//:async_channel\",\n \"@crates__async-task-4.7.1//:async_task\",\n \"@crates__futures-io-0.3.34//:futures_io\",\n \"@crates__futures-lite-2.6.1//:futures_lite\",\n \"@crates__piper-0.2.5//:piper\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=blocking\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.7.0\",\n)\n" } }, - "crates__bon-3.9.3": { + "crates__bon-3.10.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "a602c73c7b0148ec6d12af6fd5cc7a46e2eacc8878271a999abac56eed12f561", + "sha256": "9e3fac94a66da67200398458a25412bcc3f9b6443b5119a6cad9cf3ccfcd8cc6", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/bon/3.9.3/download" + "https://static.crates.io/crates/bon/3.10.0/download" ], - "strip_prefix": "bon-3.9.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"bon\",\n proc_macro_deps = [\n \"@crates__bon-macros-3.9.3//:bon_macros\",\n \"@crates__rustversion-1.0.23//:rustversion\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bon\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.9.3\",\n)\n" + "strip_prefix": "bon-3.10.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"bon\",\n proc_macro_deps = [\n \"@crates__bon-macros-3.10.0//:bon_macros\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bon\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.10.0\",\n)\n" } }, - "crates__bon-macros-3.9.3": { + "crates__bon-macros-3.10.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "6dee98b0db6a962de883bf5d20362dee4d7ca0d12fe39a7c6c73c844e1cd7c1f", + "sha256": "d4654961ad0494e4774c5c60b4cb4cd0ae9b9d92d039d901638b1dba97ebebf5", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/bon-macros/3.9.3/download" + "https://static.crates.io/crates/bon-macros/3.10.0/download" ], - "strip_prefix": "bon-macros-3.9.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"bon_macros\",\n deps = [\n \"@crates__darling-0.23.0//:darling\",\n \"@crates__ident_case-1.0.1//:ident_case\",\n \"@crates__prettyplease-0.2.37//:prettyplease\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-2.0.119//:syn\",\n ],\n proc_macro_deps = [\n \"@crates__rustversion-1.0.23//:rustversion\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bon-macros\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.9.3\",\n)\n" + "strip_prefix": "bon-macros-3.10.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"bon_macros\",\n deps = [\n \"@crates__darling-0.24.1//:darling\",\n \"@crates__ident_case-1.0.1//:ident_case\",\n \"@crates__prettyplease-0.3.0//:prettyplease\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bon-macros\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.10.0\",\n)\n" } }, "crates__brush-parser-0.3.0": { @@ -1812,7 +1862,7 @@ "https://static.crates.io/crates/brush-parser/0.3.0/download" ], "strip_prefix": "brush-parser-0.3.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"brush_parser\",\n deps = [\n \"@crates__bon-3.9.3//:bon\",\n \"@crates__cached-0.56.0//:cached\",\n \"@crates__indenter-0.3.4//:indenter\",\n \"@crates__peg-0.8.6//:peg\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__tracing-0.1.44//:tracing\",\n \"@crates__utf8-chars-3.0.7//:utf8_chars\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=brush-parser\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"brush_parser\",\n deps = [\n \"@crates__bon-3.10.0//:bon\",\n \"@crates__cached-0.56.0//:cached\",\n \"@crates__indenter-0.3.4//:indenter\",\n \"@crates__peg-0.8.6//:peg\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__tracing-0.1.44//:tracing\",\n \"@crates__utf8-chars-3.0.7//:utf8_chars\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=brush-parser\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.0\",\n)\n" } }, "crates__brush-parser-0.4.0": { @@ -1825,7 +1875,7 @@ "https://static.crates.io/crates/brush-parser/0.4.0/download" ], "strip_prefix": "brush-parser-0.4.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"brush_parser\",\n deps = [\n \"@crates__bon-3.9.3//:bon\",\n \"@crates__cached-0.59.0//:cached\",\n \"@crates__indenter-0.3.4//:indenter\",\n \"@crates__insta-1.48.0//:insta\",\n \"@crates__peg-0.8.6//:peg\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__tracing-0.1.44//:tracing\",\n \"@crates__utf8-chars-3.0.7//:utf8_chars\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=brush-parser\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"brush_parser\",\n deps = [\n \"@crates__bon-3.10.0//:bon\",\n \"@crates__cached-0.59.0//:cached\",\n \"@crates__indenter-0.3.4//:indenter\",\n \"@crates__insta-1.48.0//:insta\",\n \"@crates__peg-0.8.6//:peg\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__tracing-0.1.44//:tracing\",\n \"@crates__utf8-chars-3.0.7//:utf8_chars\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=brush-parser\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.0\",\n)\n" } }, "crates__bstr-1.13.1": { @@ -1838,7 +1888,7 @@ "https://static.crates.io/crates/bstr/1.13.1/download" ], "strip_prefix": "bstr-1.13.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"bstr\",\n deps = [\n \"@crates__memchr-2.8.3//:memchr\",\n \"@crates__regex-automata-0.4.18//:regex_automata\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n \"unicode\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bstr\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.13.1\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"bstr\",\n deps = [\n \"@crates__memchr-2.8.3//:memchr\",\n \"@crates__regex-automata-0.4.18//:regex_automata\",\n \"@crates__serde_core-1.0.229//:serde_core\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"serde\",\n \"std\",\n \"unicode\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bstr\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.13.1\",\n)\n" } }, "crates__bumpalo-3.20.3": { @@ -1890,7 +1940,7 @@ "https://static.crates.io/crates/bytecheck_derive/0.8.3/download" ], "strip_prefix": "bytecheck_derive-0.8.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"bytecheck_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bytecheck_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.3\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"bytecheck_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bytecheck_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.3\",\n)\n" } }, "crates__bytecount-0.6.9": { @@ -1916,7 +1966,7 @@ "https://static.crates.io/crates/bytemuck/1.25.2/download" ], "strip_prefix": "bytemuck-1.25.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"bytemuck\",\n proc_macro_deps = [\n \"@crates__bytemuck_derive-1.12.0//:bytemuck_derive\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"bytemuck_derive\",\n \"derive\",\n \"extern_crate_alloc\",\n \"min_const_generics\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bytemuck\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.25.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"bytemuck\",\n proc_macro_deps = [\n \"@crates__bytemuck_derive-1.12.0//:bytemuck_derive\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"aarch64_simd\",\n \"bytemuck_derive\",\n \"derive\",\n \"extern_crate_alloc\",\n \"min_const_generics\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bytemuck\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.25.2\",\n)\n" } }, "crates__bytemuck_derive-1.12.0": { @@ -1929,7 +1979,7 @@ "https://static.crates.io/crates/bytemuck_derive/1.12.0/download" ], "strip_prefix": "bytemuck_derive-1.12.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"bytemuck_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bytemuck_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.12.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"bytemuck_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=bytemuck_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.12.0\",\n)\n" } }, "crates__byteorder-1.5.0": { @@ -2166,17 +2216,17 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"chacha20\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__cipher-0.4.4//:cipher\",\n ] + select({\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"zeroize\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=chacha20\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.1\",\n)\n" } }, - "crates__chacha20-0.10.1": { + "crates__chacha20-0.10.2": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "d524456ba66e72eb8b115ff89e01e497f8e6d11d78b70b1aa13c0fbd97540a81", + "sha256": "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/chacha20/0.10.1/download" + "https://static.crates.io/crates/chacha20/0.10.2/download" ], - "strip_prefix": "chacha20-0.10.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"chacha20\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__rand_core-0.10.1//:rand_core\",\n ] + select({\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__cpufeatures-0.3.0//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__cpufeatures-0.3.0//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.3.0//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.3.0//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"rng\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=chacha20\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.1\",\n)\n" + "strip_prefix": "chacha20-0.10.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"chacha20\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__rand_core-0.10.1//:rand_core\",\n ] + select({\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"rng\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=chacha20\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.2\",\n)\n" } }, "crates__chacha20poly1305-0.10.1": { @@ -2215,7 +2265,7 @@ "https://static.crates.io/crates/chrono/0.4.45/download" ], "strip_prefix": "chrono-0.4.45", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"chrono\",\n deps = [\n \"@crates__num-traits-0.2.19//:num_traits\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # x86_64-apple-darwin\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-link-0.2.1//:windows_link\", # x86_64-pc-windows-msvc\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"clock\",\n \"default\",\n \"iana-time-zone\",\n \"js-sys\",\n \"now\",\n \"oldtime\",\n \"std\",\n \"wasm-bindgen\",\n \"wasmbind\",\n \"winapi\",\n \"windows-link\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=chrono\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.45\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"chrono\",\n deps = [\n \"@crates__num-traits-0.2.19//:num_traits\",\n \"@crates__serde-1.0.229//:serde\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # x86_64-apple-darwin\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-link-0.2.1//:windows_link\", # x86_64-pc-windows-msvc\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__iana-time-zone-0.1.65//:iana_time_zone\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"clock\",\n \"default\",\n \"iana-time-zone\",\n \"js-sys\",\n \"now\",\n \"oldtime\",\n \"serde\",\n \"std\",\n \"wasm-bindgen\",\n \"wasmbind\",\n \"winapi\",\n \"windows-link\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=chrono\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.45\",\n)\n" } }, "crates__cipher-0.4.4": { @@ -2280,7 +2330,7 @@ "https://static.crates.io/crates/clap_derive/4.6.4/download" ], "strip_prefix": "clap_derive-4.6.4", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"clap_derive\",\n deps = [\n \"@crates__heck-0.5.0//:heck\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=clap_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"4.6.4\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"clap_derive\",\n deps = [\n \"@crates__heck-0.5.0//:heck\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=clap_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"4.6.4\",\n)\n" } }, "crates__clap_lex-1.1.0": { @@ -2309,6 +2359,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"clipboard_win\",\n deps = select({\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__error-code-3.4.0//:error_code\", # cfg(windows)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=clipboard-win\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"5.4.1\",\n)\n" } }, + "crates__clru-0.6.3": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "197fd99cb113a8d5d9b6376f3aa817f32c1078f2343b714fff7d2ca44fdf67d5", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/clru/0.6.3/download" + ], + "strip_prefix": "clru-0.6.3", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"clru\",\n deps = [\n \"@crates__hashbrown-0.16.1//:hashbrown\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=clru\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.6.3\",\n)\n" + } + }, "crates__cmake-0.1.58": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -2621,17 +2684,17 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"cpufeatures\",\n deps = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(target_arch = \"aarch64\", target_vendor = \"apple\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=cpufeatures\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.17\",\n)\n" } }, - "crates__cpufeatures-0.3.0": { + "crates__cpufeatures-0.3.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201", + "sha256": "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/cpufeatures/0.3.0/download" + "https://static.crates.io/crates/cpufeatures/0.3.1/download" ], - "strip_prefix": "cpufeatures-0.3.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"cpufeatures\",\n deps = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(target_arch = \"aarch64\", target_vendor = \"apple\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=cpufeatures\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.0\",\n)\n" + "strip_prefix": "cpufeatures-0.3.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"cpufeatures\",\n deps = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(target_arch = \"aarch64\", target_vendor = \"apple\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(target_arch = \"aarch64\", target_os = \"linux\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=cpufeatures\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.1\",\n)\n" } }, "crates__crc-3.4.0": { @@ -2673,17 +2736,30 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"crc_fast\",\n deps = [\n \"@crates__crc-3.4.0//:crc\",\n \"@crates__digest-0.10.7//:digest\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__spin-0.10.1//:spin\", # cfg(target_arch = \"aarch64\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__spin-0.10.1//:spin\", # cfg(target_arch = \"aarch64\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__spin-0.10.1//:spin\", # cfg(target_arch = \"aarch64\")\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__spin-0.10.1//:spin\", # cfg(target_arch = \"x86_64\")\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__spin-0.10.1//:spin\", # cfg(target_arch = \"x86_64\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__spin-0.10.1//:spin\", # cfg(target_arch = \"x86_64\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__spin-0.10.1//:spin\", # cfg(target_arch = \"x86_64\")\n ],\n \"//conditions:default\": [],\n }),\n proc_macro_deps = [\n \"@crates__rustversion-1.0.23//:rustversion\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"digest\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=crc-fast\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.8.2\",\n)\n" } }, - "crates__crc32fast-1.5.0": { + "crates__crc32fast-1.5.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511", + "sha256": "8498c871161e1742aaa9d52551b2d6ebdd4c3d45a3be423e3728f33b955be550", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/crc32fast/1.5.0/download" + "https://static.crates.io/crates/crc32fast/1.5.1/download" ], - "strip_prefix": "crc32fast-1.5.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"crc32fast\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__crc32fast-1.5.0//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=crc32fast\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.5.0\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"crc32fast\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=crc32fast\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"1.5.0\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "strip_prefix": "crc32fast-1.5.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"crc32fast\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__crc32fast-1.5.1//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=crc32fast\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.5.1\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"crc32fast\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=crc32fast\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"1.5.1\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + } + }, + "crates__crossbeam-channel-0.5.16": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "d85363c37faeca707aef026efa9f3b34d077bce547e48f770770625c6013679e", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/crossbeam-channel/0.5.16/download" + ], + "strip_prefix": "crossbeam-channel-0.5.16", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"crossbeam_channel\",\n deps = [\n \"@crates__crossbeam-utils-0.8.22//:crossbeam_utils\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=crossbeam-channel\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.16\",\n)\n" } }, "crates__crossbeam-deque-0.8.7": { @@ -2842,17 +2918,17 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"darling\",\n deps = [\n \"@crates__darling_core-0.20.11//:darling_core\",\n ],\n proc_macro_deps = [\n \"@crates__darling_macro-0.20.11//:darling_macro\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"suggestions\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=darling\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.20.11\",\n)\n" } }, - "crates__darling-0.23.0": { + "crates__darling-0.24.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d", + "sha256": "ed17f5901b6630b993ca003def43f2f8ef4014fc13b047b57aad617ff32bc2ec", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/darling/0.23.0/download" + "https://static.crates.io/crates/darling/0.24.1/download" ], - "strip_prefix": "darling-0.23.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"darling\",\n deps = [\n \"@crates__darling_core-0.23.0//:darling_core\",\n ],\n proc_macro_deps = [\n \"@crates__darling_macro-0.23.0//:darling_macro\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"suggestions\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=darling\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.23.0\",\n)\n" + "strip_prefix": "darling-0.24.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"darling\",\n deps = [\n \"@crates__darling_core-0.24.1//:darling_core\",\n ],\n proc_macro_deps = [\n \"@crates__darling_macro-0.24.1//:darling_macro\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"suggestions\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=darling\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.24.1\",\n)\n" } }, "crates__darling_core-0.20.11": { @@ -2868,17 +2944,17 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"darling_core\",\n deps = [\n \"@crates__fnv-1.0.7//:fnv\",\n \"@crates__ident_case-1.0.1//:ident_case\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__strsim-0.11.1//:strsim\",\n \"@crates__syn-2.0.119//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"strsim\",\n \"suggestions\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=darling_core\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.20.11\",\n)\n" } }, - "crates__darling_core-0.23.0": { + "crates__darling_core-0.24.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0", + "sha256": "6837e2cf7485aaae18f86181d2f0e9a7ed297a025e220aeabf63fdebd3a2ddff", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/darling_core/0.23.0/download" + "https://static.crates.io/crates/darling_core/0.24.1/download" ], - "strip_prefix": "darling_core-0.23.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"darling_core\",\n deps = [\n \"@crates__ident_case-1.0.1//:ident_case\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__strsim-0.11.1//:strsim\",\n \"@crates__syn-2.0.119//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"strsim\",\n \"suggestions\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=darling_core\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.23.0\",\n)\n" + "strip_prefix": "darling_core-0.24.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"darling_core\",\n deps = [\n \"@crates__ident_case-1.0.1//:ident_case\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__strsim-0.11.1//:strsim\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"strsim\",\n \"suggestions\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=darling_core\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.24.1\",\n)\n" } }, "crates__darling_macro-0.20.11": { @@ -2894,17 +2970,17 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"darling_macro\",\n deps = [\n \"@crates__darling_core-0.20.11//:darling_core\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-2.0.119//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=darling_macro\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.20.11\",\n)\n" } }, - "crates__darling_macro-0.23.0": { + "crates__darling_macro-0.24.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d", + "sha256": "2ac7135c3ef02b2f7833bbeb1be5ba7f966dcde8a87c6b87f65a778d71a02785", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/darling_macro/0.23.0/download" + "https://static.crates.io/crates/darling_macro/0.24.1/download" ], - "strip_prefix": "darling_macro-0.23.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"darling_macro\",\n deps = [\n \"@crates__darling_core-0.23.0//:darling_core\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-2.0.119//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=darling_macro\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.23.0\",\n)\n" + "strip_prefix": "darling_macro-0.24.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"darling_macro\",\n deps = [\n \"@crates__darling_core-0.24.1//:darling_core\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=darling_macro\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.24.1\",\n)\n" } }, "crates__dashmap-6.2.1": { @@ -2956,7 +3032,20 @@ "https://static.crates.io/crates/data-encoding-macro-internal/0.1.19/download" ], "strip_prefix": "data-encoding-macro-internal-0.1.19", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"data_encoding_macro_internal\",\n deps = [\n \"@crates__data-encoding-2.11.1//:data_encoding\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=data-encoding-macro-internal\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.19\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"data_encoding_macro_internal\",\n deps = [\n \"@crates__data-encoding-2.11.1//:data_encoding\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=data-encoding-macro-internal\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.19\",\n)\n" + } + }, + "crates__data-url-0.3.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "be1e0bca6c3637f992fc1cc7cbc52a78c1ef6db076dbf1059c4323d6a2048376", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/data-url/0.3.2/download" + ], + "strip_prefix": "data-url-0.3.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"data_url\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=data-url\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.2\",\n)\n" } }, "crates__defmt-1.1.1": { @@ -3099,7 +3188,7 @@ "https://static.crates.io/crates/displaydoc/0.2.7/download" ], "strip_prefix": "displaydoc-0.2.7", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"displaydoc\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=displaydoc\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.7\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"displaydoc\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=displaydoc\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.7\",\n)\n" } }, "crates__dlib-0.5.3": { @@ -3216,7 +3305,7 @@ "https://static.crates.io/crates/dtls/0.17.2/download" ], "strip_prefix": "dtls-0.17.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"dtls\",\n deps = [\n \"@crates__aes-0.8.4//:aes\",\n \"@crates__aes-gcm-0.10.3//:aes_gcm\",\n \"@crates__bytecheck-0.8.3//:bytecheck\",\n \"@crates__byteorder-1.5.0//:byteorder\",\n \"@crates__cbc-0.1.2//:cbc\",\n \"@crates__ccm-0.5.0//:ccm\",\n \"@crates__chacha20poly1305-0.10.1//:chacha20poly1305\",\n \"@crates__der-parser-9.0.0//:der_parser\",\n \"@crates__hmac-0.12.1//:hmac\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__p256-0.13.2//:p256\",\n \"@crates__p384-0.13.1//:p384\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__rand_core-0.6.4//:rand_core\",\n \"@crates__rcgen-0.13.2//:rcgen\",\n \"@crates__ring-0.17.14//:ring\",\n \"@crates__rkyv-0.8.18//:rkyv\",\n \"@crates__rustls-0.23.43//:rustls\",\n \"@crates__sec1-0.7.3//:sec1\",\n \"@crates__sha1-0.10.7//:sha1\",\n \"@crates__sha2-0.10.9//:sha2\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n \"@crates__x25519-dalek-2.0.1//:x25519_dalek\",\n \"@crates__x509-parser-0.16.0//:x509_parser\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=dtls\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"dtls\",\n deps = [\n \"@crates__aes-0.8.4//:aes\",\n \"@crates__aes-gcm-0.10.3//:aes_gcm\",\n \"@crates__bytecheck-0.8.3//:bytecheck\",\n \"@crates__byteorder-1.5.0//:byteorder\",\n \"@crates__cbc-0.1.2//:cbc\",\n \"@crates__ccm-0.5.0//:ccm\",\n \"@crates__chacha20poly1305-0.10.1//:chacha20poly1305\",\n \"@crates__der-parser-9.0.0//:der_parser\",\n \"@crates__hmac-0.12.1//:hmac\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__p256-0.13.2//:p256\",\n \"@crates__p384-0.13.1//:p384\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__rand_core-0.6.4//:rand_core\",\n \"@crates__rcgen-0.13.2//:rcgen\",\n \"@crates__ring-0.17.14//:ring\",\n \"@crates__rkyv-0.8.18//:rkyv\",\n \"@crates__rustls-0.23.43//:rustls\",\n \"@crates__sec1-0.7.3//:sec1\",\n \"@crates__sha1-0.10.7//:sha1\",\n \"@crates__sha2-0.10.9//:sha2\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n \"@crates__x25519-dalek-2.0.1//:x25519_dalek\",\n \"@crates__x509-parser-0.16.0//:x509_parser\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=dtls\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" } }, "crates__dunce-1.0.5": { @@ -3281,7 +3370,7 @@ "https://static.crates.io/crates/either/1.18.0/download" ], "strip_prefix": "either-1.18.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"either\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"std\",\n \"use_std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=either\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.18.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"either\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n \"use_std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=either\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.18.0\",\n)\n" } }, "crates__elliptic-curve-0.13.8": { @@ -3359,7 +3448,7 @@ "https://static.crates.io/crates/enigo/0.6.1/download" ], "strip_prefix": "enigo-0.6.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"enigo\",\n deps = [\n \"@crates__log-0.4.33//:log\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__core-foundation-0.10.1//:core_foundation\", # cfg(target_os = \"macos\")\n \"@crates__core-graphics-0.25.0//:core_graphics\", # cfg(target_os = \"macos\")\n \"@crates__foreign-types-shared-0.3.1//:foreign_types_shared\", # cfg(target_os = \"macos\")\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkbcommon-0.9.0//:xkbcommon\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkeysym-0.2.1//:xkeysym\", # cfg(all(unix, not(target_os = \"macos\")))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkbcommon-0.9.0//:xkbcommon\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkeysym-0.2.1//:xkeysym\", # cfg(all(unix, not(target_os = \"macos\")))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__core-foundation-0.10.1//:core_foundation\", # cfg(target_os = \"macos\")\n \"@crates__core-graphics-0.25.0//:core_graphics\", # cfg(target_os = \"macos\")\n \"@crates__foreign-types-shared-0.3.1//:foreign_types_shared\", # cfg(target_os = \"macos\")\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-0.61.3//:windows\", # cfg(target_os = \"windows\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkbcommon-0.9.0//:xkbcommon\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkeysym-0.2.1//:xkeysym\", # cfg(all(unix, not(target_os = \"macos\")))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkbcommon-0.9.0//:xkbcommon\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkeysym-0.2.1//:xkeysym\", # cfg(all(unix, not(target_os = \"macos\")))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=enigo\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.6.1\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"enigo\",\n deps = [\n \"@crates__log-0.4.34//:log\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__core-foundation-0.10.1//:core_foundation\", # cfg(target_os = \"macos\")\n \"@crates__core-graphics-0.25.0//:core_graphics\", # cfg(target_os = \"macos\")\n \"@crates__foreign-types-shared-0.3.1//:foreign_types_shared\", # cfg(target_os = \"macos\")\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkbcommon-0.9.0//:xkbcommon\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkeysym-0.2.1//:xkeysym\", # cfg(all(unix, not(target_os = \"macos\")))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkbcommon-0.9.0//:xkbcommon\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkeysym-0.2.1//:xkeysym\", # cfg(all(unix, not(target_os = \"macos\")))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__core-foundation-0.10.1//:core_foundation\", # cfg(target_os = \"macos\")\n \"@crates__core-graphics-0.25.0//:core_graphics\", # cfg(target_os = \"macos\")\n \"@crates__foreign-types-shared-0.3.1//:foreign_types_shared\", # cfg(target_os = \"macos\")\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-0.61.3//:windows\", # cfg(target_os = \"windows\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkbcommon-0.9.0//:xkbcommon\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkeysym-0.2.1//:xkeysym\", # cfg(all(unix, not(target_os = \"macos\")))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkbcommon-0.9.0//:xkbcommon\", # cfg(all(unix, not(target_os = \"macos\")))\n \"@crates__xkeysym-0.2.1//:xkeysym\", # cfg(all(unix, not(target_os = \"macos\")))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=enigo\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.6.1\",\n)\n" } }, "crates__enumflags2-0.7.12": { @@ -3398,7 +3487,7 @@ "https://static.crates.io/crates/env_filter/2.0.0/download" ], "strip_prefix": "env_filter-2.0.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"env_filter\",\n deps = [\n \"@crates__log-0.4.33//:log\",\n \"@crates__regex-1.13.1//:regex\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"regex\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=env_filter\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.0.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"env_filter\",\n deps = [\n \"@crates__log-0.4.34//:log\",\n \"@crates__regex-1.13.1//:regex\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"regex\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=env_filter\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.0.0\",\n)\n" } }, "crates__env_logger-0.11.11": { @@ -3411,7 +3500,7 @@ "https://static.crates.io/crates/env_logger/0.11.11/download" ], "strip_prefix": "env_logger-0.11.11", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"env_logger\",\n deps = [\n \"@crates__anstream-1.0.0//:anstream\",\n \"@crates__anstyle-1.0.14//:anstyle\",\n \"@crates__env_filter-2.0.0//:env_filter\",\n \"@crates__jiff-0.2.35//:jiff\",\n \"@crates__log-0.4.33//:log\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"auto-color\",\n \"color\",\n \"default\",\n \"humantime\",\n \"regex\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=env_logger\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.11.11\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"env_logger\",\n deps = [\n \"@crates__anstream-1.0.0//:anstream\",\n \"@crates__anstyle-1.0.14//:anstyle\",\n \"@crates__env_filter-2.0.0//:env_filter\",\n \"@crates__jiff-0.2.35//:jiff\",\n \"@crates__log-0.4.34//:log\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"auto-color\",\n \"color\",\n \"default\",\n \"humantime\",\n \"regex\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=env_logger\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.11.11\",\n)\n" } }, "crates__equivalent-1.0.2": { @@ -3453,6 +3542,32 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"error_code\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=error-code\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.4.0\",\n)\n" } }, + "crates__etcetera-0.11.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "de48cc4d1c1d97a20fd819def54b890cadde72ed3ad0c614822a0a433361be96", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/etcetera/0.11.0/download" + ], + "strip_prefix": "etcetera-0.11.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"etcetera\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n ] + select({\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-sys-0.61.2//:windows_sys\", # cfg(windows)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=etcetera\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.11.0\",\n)\n" + } + }, + "crates__euclid-0.22.14": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "f1a05365e3b1c6d1650318537c7460c6923f1abdd272ad6842baa2b509957a06", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/euclid/0.22.14/download" + ], + "strip_prefix": "euclid-0.22.14", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"euclid\",\n deps = [\n \"@crates__num-traits-0.2.19//:num_traits\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=euclid\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.22.14\",\n)\n" + } + }, "crates__event-listener-5.4.2": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -3518,6 +3633,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"fancy_regex\",\n deps = [\n \"@crates__bit-set-0.8.0//:bit_set\",\n \"@crates__regex-automata-0.4.18//:regex_automata\",\n \"@crates__regex-syntax-0.8.11//:regex_syntax\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"perf\",\n \"std\",\n \"unicode\",\n \"variable-lookbehinds\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=fancy-regex\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.0\",\n)\n" } }, + "crates__faster-hex-0.10.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "7223ae2d2f179b803433d9c830478527e92b8117eab39460edae7f1614d9fb73", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/faster-hex/0.10.0/download" + ], + "strip_prefix": "faster-hex-0.10.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"faster_hex\",\n deps = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__heapless-0.8.0//:heapless\", # cfg(not(feature = \"alloc\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__heapless-0.8.0//:heapless\", # cfg(not(feature = \"alloc\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__heapless-0.8.0//:heapless\", # cfg(not(feature = \"alloc\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__heapless-0.8.0//:heapless\", # cfg(not(feature = \"alloc\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__heapless-0.8.0//:heapless\", # cfg(not(feature = \"alloc\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__heapless-0.8.0//:heapless\", # cfg(not(feature = \"alloc\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__heapless-0.8.0//:heapless\", # cfg(not(feature = \"alloc\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=faster-hex\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.0\",\n)\n" + } + }, "crates__fastrand-2.5.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -3658,7 +3786,20 @@ "https://static.crates.io/crates/flate2/1.1.9/download" ], "strip_prefix": "flate2-1.1.9", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"flate2\",\n deps = [\n \"@crates__crc32fast-1.5.0//:crc32fast\",\n \"@crates__miniz_oxide-0.8.9//:miniz_oxide\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"any_impl\",\n \"default\",\n \"miniz_oxide\",\n \"rust_backend\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=flate2\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.1.9\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"flate2\",\n deps = [\n \"@crates__crc32fast-1.5.1//:crc32fast\",\n \"@crates__miniz_oxide-0.8.9//:miniz_oxide\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"any_impl\",\n \"default\",\n \"miniz_oxide\",\n \"rust_backend\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=flate2\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.1.9\",\n)\n" + } + }, + "crates__float-cmp-0.9.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/float-cmp/0.9.0/download" + ], + "strip_prefix": "float-cmp-0.9.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"float_cmp\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=float-cmp\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.0\",\n)\n" } }, "crates__fluent-0.17.0": { @@ -3765,6 +3906,45 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"foldhash\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=foldhash\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.0\",\n)\n" } }, + "crates__font-types-0.12.4": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "e64eb721ca85a34323425f4041adc5d82704d3782d5f8f03793bc012419dce23", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/font-types/0.12.4/download" + ], + "strip_prefix": "font-types-0.12.4", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"font_types\",\n deps = [\n \"@crates__bytemuck-1.25.2//:bytemuck\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"bytemuck\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=font-types\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.4\",\n)\n" + } + }, + "crates__fontconfig-parser-0.5.8": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "bbc773e24e02d4ddd8395fd30dc147524273a83e54e0f312d986ea30de5f5646", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/fontconfig-parser/0.5.8/download" + ], + "strip_prefix": "fontconfig-parser-0.5.8", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"fontconfig_parser\",\n deps = [\n \"@crates__roxmltree-0.20.0//:roxmltree\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=fontconfig-parser\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.8\",\n)\n" + } + }, + "crates__fontdb-0.24.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "2660c5e9157bf76d2db1294e4a9feba604ef610819a3b591088d0d8392a3290f", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/fontdb/0.24.0/download" + ], + "strip_prefix": "fontdb-0.24.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"fontdb\",\n deps = [\n \"@crates__log-0.4.34//:log\",\n \"@crates__memmap2-0.9.11//:memmap2\",\n \"@crates__slotmap-1.1.1//:slotmap\",\n \"@crates__tinyvec-1.12.0//:tinyvec\",\n ] + select({\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__fontconfig-parser-0.5.8//:fontconfig_parser\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__fontconfig-parser-0.5.8//:fontconfig_parser\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__fontconfig-parser-0.5.8//:fontconfig_parser\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__fontconfig-parser-0.5.8//:fontconfig_parser\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"fontconfig\",\n \"fontconfig-parser\",\n \"fs\",\n \"memmap\",\n \"memmap2\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=fontdb\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.24.0\",\n)\n" + } + }, "crates__fontdue-0.9.4": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -3801,7 +3981,7 @@ "https://static.crates.io/crates/foreign-types-macros/0.2.4/download" ], "strip_prefix": "foreign-types-macros-0.2.4", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"foreign_types_macros\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=foreign-types-macros\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.4\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"foreign_types_macros\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=foreign-types-macros\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.4\",\n)\n" } }, "crates__foreign-types-shared-0.3.1": { @@ -3957,7 +4137,7 @@ "https://static.crates.io/crates/futures-macro/0.3.34/download" ], "strip_prefix": "futures-macro-0.3.34", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"futures_macro\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=futures-macro\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.34\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"futures_macro\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=futures-macro\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.34\",\n)\n" } }, "crates__futures-sink-0.3.34": { @@ -4116,436 +4296,1125 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gif\",\n deps = [\n \"@crates__color_quant-1.1.0//:color_quant\",\n \"@crates__weezl-0.1.12//:weezl\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"color_quant\",\n \"default\",\n \"raii_no_panic\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gif\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.2\",\n)\n" } }, - "crates__gl-0.14.0": { + "crates__gix-0.85.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "a94edab108827d67608095e269cf862e60d920f144a5026d3dbcfd8b877fb404", + "sha256": "fa8b2e38ebfc4484dfef8580ddcaf8abb7285e6f3eb6413ff6775d104ae96ca6", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/gl/0.14.0/download" + "https://static.crates.io/crates/gix/0.85.0/download" ], - "strip_prefix": "gl-0.14.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gl\",\n deps = [\n \"@crates__gl-0.14.0//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gl\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.0\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n deps = [\n \"@crates__gl_generator-0.14.0//:gl_generator\",\n ],\n emit_warnings = False,\n edition = \"2015\",\n pkg_name = \"gl\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gl\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.14.0\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "strip_prefix": "gix-0.85.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix\",\n deps = [\n \"@crates__gix-actor-0.41.2//:gix_actor\",\n \"@crates__gix-attributes-0.33.2//:gix_attributes\",\n \"@crates__gix-command-0.9.2//:gix_command\",\n \"@crates__gix-commitgraph-0.37.1//:gix_commitgraph\",\n \"@crates__gix-config-0.58.0//:gix_config\",\n \"@crates__gix-date-0.15.6//:gix_date\",\n \"@crates__gix-diff-0.65.0//:gix_diff\",\n \"@crates__gix-dir-0.27.0//:gix_dir\",\n \"@crates__gix-discover-0.53.0//:gix_discover\",\n \"@crates__gix-error-0.2.5//:gix_error\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-filter-0.32.0//:gix_filter\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-glob-0.26.1//:gix_glob\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-hashtable-0.15.2//:gix_hashtable\",\n \"@crates__gix-ignore-0.21.1//:gix_ignore\",\n \"@crates__gix-index-0.53.0//:gix_index\",\n \"@crates__gix-lock-23.0.1//:gix_lock\",\n \"@crates__gix-merge-0.18.0//:gix_merge\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-odb-0.82.0//:gix_odb\",\n \"@crates__gix-pack-0.72.0//:gix_pack\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-pathspec-0.18.1//:gix_pathspec\",\n \"@crates__gix-protocol-0.63.0//:gix_protocol\",\n \"@crates__gix-ref-0.65.0//:gix_ref\",\n \"@crates__gix-refspec-0.43.0//:gix_refspec\",\n \"@crates__gix-revision-0.47.0//:gix_revision\",\n \"@crates__gix-revwalk-0.33.0//:gix_revwalk\",\n \"@crates__gix-sec-0.14.2//:gix_sec\",\n \"@crates__gix-shallow-0.12.1//:gix_shallow\",\n \"@crates__gix-status-0.32.0//:gix_status\",\n \"@crates__gix-submodule-0.32.0//:gix_submodule\",\n \"@crates__gix-tempfile-23.0.2//:gix_tempfile\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__gix-traverse-0.59.0//:gix_traverse\",\n \"@crates__gix-url-0.36.2//:gix_url\",\n \"@crates__gix-utils-0.3.6//:gix_utils\",\n \"@crates__gix-validate-0.11.4//:gix_validate\",\n \"@crates__gix-worktree-0.54.0//:gix_worktree\",\n \"@crates__gix-worktree-state-0.32.0//:gix_worktree_state\",\n \"@crates__nonempty-0.12.0//:nonempty\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"attributes\",\n \"blob-diff\",\n \"command\",\n \"dirwalk\",\n \"excludes\",\n \"gix-status\",\n \"index\",\n \"max-control\",\n \"max-performance-safe\",\n \"merge\",\n \"pack-cache-lru-dynamic\",\n \"pack-cache-lru-static\",\n \"parallel\",\n \"revision\",\n \"sha1\",\n \"sha256\",\n \"status\",\n \"tree-editor\",\n \"worktree-mutation\",\n \"zlib-rs\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.85.0\",\n)\n" } }, - "crates__gl_generator-0.14.0": { + "crates__gix-actor-0.41.2": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d", + "sha256": "33f9308ad6fd35b2a865cbe4117ac61b2be59e4a9ef1621c7a9794f7c8e52c5b", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/gl_generator/0.14.0/download" + "https://static.crates.io/crates/gix-actor/0.41.2/download" ], - "strip_prefix": "gl_generator-0.14.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gl_generator\",\n deps = [\n \"@crates__khronos_api-3.1.0//:khronos_api\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__xml-rs-0.8.29//:xml\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gl_generator\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.0\",\n)\n" + "strip_prefix": "gix-actor-0.41.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_actor\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-date-0.15.6//:gix_date\",\n \"@crates__gix-error-0.2.5//:gix_error\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-actor\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.41.2\",\n)\n" } }, - "crates__glob-0.3.4": { + "crates__gix-attributes-0.33.2": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b", + "sha256": "39b40888d0ed415c0744a6cdc61eebf0304c9d26ab726725b718443c322e5ba4", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/glob/0.3.4/download" + "https://static.crates.io/crates/gix-attributes/0.33.2/download" ], - "strip_prefix": "glob-0.3.4", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"glob\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=glob\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.4\",\n)\n" + "strip_prefix": "gix-attributes-0.33.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_attributes\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-glob-0.26.1//:gix_glob\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-quote-0.7.2//:gix_quote\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__kstring-2.0.2//:kstring\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__unicode-bom-2.0.3//:unicode_bom\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-attributes\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.33.2\",\n)\n" } }, - "crates__globset-0.4.20": { + "crates__gix-bitmap-0.3.3": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "07c34a9410465b45bd9787443bc7370f37735bad04b0f0cd57ff1a3186c98988", + "sha256": "7cd1d118d0f5d88b96e6f6e13b566475fef4797ead4a02c26fed36c1375066f7", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/globset/0.4.20/download" + "https://static.crates.io/crates/gix-bitmap/0.3.3/download" ], - "strip_prefix": "globset-0.4.20", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"globset\",\n deps = [\n \"@crates__aho-corasick-1.1.5//:aho_corasick\",\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__regex-automata-0.4.18//:regex_automata\",\n \"@crates__regex-syntax-0.8.11//:regex_syntax\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"log\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=globset\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.20\",\n)\n" + "strip_prefix": "gix-bitmap-0.3.3", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_bitmap\",\n deps = [\n \"@crates__gix-error-0.2.5//:gix_error\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-bitmap\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.3\",\n)\n" } }, - "crates__grep-cli-0.1.12": { + "crates__gix-chunk-0.7.3": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "cf32d263c5d5cc2a23ce587097f5ddafdb188492ba2e6fb638eaccdc22453631", + "sha256": "b2a871e5cab12ba568845714473505deefffb3c04eb47f4708ce344cd459c1cc", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/grep-cli/0.1.12/download" + "https://static.crates.io/crates/gix-chunk/0.7.3/download" ], - "strip_prefix": "grep-cli-0.1.12", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_cli\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__globset-0.4.20//:globset\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__termcolor-1.4.1//:termcolor\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__winapi-util-0.1.11//:winapi_util\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-cli\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.12\",\n)\n" + "strip_prefix": "gix-chunk-0.7.3", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_chunk\",\n deps = [\n \"@crates__gix-error-0.2.5//:gix_error\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-chunk\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.7.3\",\n)\n" } }, - "crates__grep-matcher-0.1.9": { + "crates__gix-command-0.9.2": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "f9417543f4870fc8f1c8e1af870afae2431007626d9e703fce6471c468d33847", + "sha256": "cf4363accdf6ef7ba861871d2d521ab7418a04aaaed919fadb022af71d379b12", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/grep-matcher/0.1.9/download" + "https://static.crates.io/crates/gix-command/0.9.2/download" ], - "strip_prefix": "grep-matcher-0.1.9", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_matcher\",\n deps = [\n \"@crates__memchr-2.8.3//:memchr\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-matcher\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.9\",\n)\n" + "strip_prefix": "gix-command-0.9.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_command\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-quote-0.7.2//:gix_quote\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__shell-words-1.1.1//:shell_words\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-command\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.2\",\n)\n" } }, - "crates__grep-pcre2-0.1.10": { + "crates__gix-commitgraph-0.37.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "b752bb6f57dd3716e55b63a33ca05b5825c3d66cd427468874a5564af6ca365c", + "sha256": "7f675d0df484a7f6a47e64bd6f311af489d947c0323b0564f36d14f3d7762abb", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/grep-pcre2/0.1.10/download" + "https://static.crates.io/crates/gix-commitgraph/0.37.1/download" ], - "strip_prefix": "grep-pcre2-0.1.10", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_pcre2\",\n deps = [\n \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__pcre2-0.2.11//:pcre2\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-pcre2\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.10\",\n)\n" + "strip_prefix": "gix-commitgraph-0.37.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_commitgraph\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-chunk-0.7.3//:gix_chunk\",\n \"@crates__gix-error-0.2.5//:gix_error\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__memmap2-0.9.11//:memmap2\",\n \"@crates__nonempty-0.12.0//:nonempty\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-commitgraph\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.37.1\",\n)\n" } }, - "crates__grep-printer-0.3.1": { + "crates__gix-config-0.58.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "fd76035e87871f51c1ee5b793e32122b3ccf9c692662d9622ef1686ff5321acb", + "sha256": "a29bf266c4cdaf759e535c24ad4ce655b987aeb6911075643403cc7cc5ade583", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/grep-printer/0.3.1/download" + "https://static.crates.io/crates/gix-config/0.58.0/download" ], - "strip_prefix": "grep-printer-0.3.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_printer\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n \"@crates__grep-searcher-0.1.17//:grep_searcher\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__serde-1.0.229//:serde\",\n \"@crates__serde_json-1.0.151//:serde_json\",\n \"@crates__termcolor-1.4.1//:termcolor\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"serde\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-printer\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.1\",\n)\n" + "strip_prefix": "gix-config-0.58.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_config\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-config-value-0.18.1//:gix_config_value\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-glob-0.26.1//:gix_glob\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-ref-0.65.0//:gix_ref\",\n \"@crates__gix-sec-0.14.2//:gix_sec\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__unicode-bom-2.0.3//:unicode_bom\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-config\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.58.0\",\n)\n" } }, - "crates__grep-regex-0.1.14": { + "crates__gix-config-value-0.18.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "0ce0c256c3ad82bcc07b812c15a45ec1d398122e8e15124f96695234db7112ef", + "sha256": "ed42168329552f6c2e5df09665c104199d45d84bedb53683738a49b57fe1baab", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/grep-regex/0.1.14/download" + "https://static.crates.io/crates/gix-config-value/0.18.1/download" ], - "strip_prefix": "grep-regex-0.1.14", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_regex\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__regex-automata-0.4.18//:regex_automata\",\n \"@crates__regex-syntax-0.8.11//:regex_syntax\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-regex\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.14\",\n)\n" + "strip_prefix": "gix-config-value-0.18.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_config_value\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-config-value\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.18.1\",\n)\n" } }, - "crates__grep-searcher-0.1.17": { + "crates__gix-date-0.15.6": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "72348823a0eafc4bc2e9051064f28b5b42cc100b571b3a35d67918d711efcbc6", + "sha256": "7e47b9e8cdc688296609b706428de570f88b1e0eed7156dde7b4a89d26fa4567", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/grep-searcher/0.1.17/download" + "https://static.crates.io/crates/gix-date/0.15.6/download" ], - "strip_prefix": "grep-searcher-0.1.17", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_searcher\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__encoding_rs-0.8.35//:encoding_rs\",\n \"@crates__encoding_rs_io-0.1.8//:encoding_rs_io\",\n \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__memchr-2.8.3//:memchr\",\n \"@crates__memmap2-0.9.11//:memmap2\",\n ],\n aliases = {\n \"@crates__memmap2-0.9.11//:memmap2\": \"memmap\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-searcher\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.17\",\n)\n" + "strip_prefix": "gix-date-0.15.6", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_date\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-error-0.2.5//:gix_error\",\n \"@crates__itoa-1.0.18//:itoa\",\n \"@crates__jiff-0.2.35//:jiff\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-date\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.15.6\",\n)\n" } }, - "crates__group-0.13.0": { + "crates__gix-diff-0.65.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63", + "sha256": "92c6d56c94edf92d78203a1cd416f770e35e10b6955ede6b9d7d0c22ff88a5f3", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/group/0.13.0/download" + "https://static.crates.io/crates/gix-diff/0.65.0/download" ], - "strip_prefix": "group-0.13.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"group\",\n deps = [\n \"@crates__ff-0.13.1//:ff\",\n \"@crates__rand_core-0.6.4//:rand_core\",\n \"@crates__subtle-2.6.1//:subtle\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=group\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.13.0\",\n)\n" + "strip_prefix": "gix-diff-0.65.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_diff\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-attributes-0.33.2//:gix_attributes\",\n \"@crates__gix-command-0.9.2//:gix_command\",\n \"@crates__gix-filter-0.32.0//:gix_filter\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-imara-diff-0.2.5//:gix_imara_diff\",\n \"@crates__gix-index-0.53.0//:gix_index\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-pathspec-0.18.1//:gix_pathspec\",\n \"@crates__gix-tempfile-23.0.2//:gix_tempfile\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__gix-traverse-0.59.0//:gix_traverse\",\n \"@crates__gix-worktree-0.54.0//:gix_worktree\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n aliases = {\n \"@crates__gix-imara-diff-0.2.5//:gix_imara_diff\": \"imara_diff\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"blob\",\n \"index\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-diff\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.65.0\",\n)\n" } }, - "crates__half-2.7.1": { + "crates__gix-dir-0.27.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b", + "sha256": "20098fba2b9c6e29361ccb4c0379d42dfb81fc7f86f7ab11f2dff4528c0bf01f", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/half/2.7.1/download" + "https://static.crates.io/crates/gix-dir/0.27.0/download" ], - "strip_prefix": "half-2.7.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"half\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__zerocopy-0.8.56//:zerocopy\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=half\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.7.1\",\n)\n" + "strip_prefix": "gix-dir-0.27.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_dir\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-discover-0.53.0//:gix_discover\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-ignore-0.21.1//:gix_ignore\",\n \"@crates__gix-index-0.53.0//:gix_index\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-pathspec-0.18.1//:gix_pathspec\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__gix-utils-0.3.6//:gix_utils\",\n \"@crates__gix-worktree-0.54.0//:gix_worktree\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-dir\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.27.0\",\n)\n" } }, - "crates__hash32-0.3.1": { + "crates__gix-discover-0.53.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606", + "sha256": "d624d5b23b10c1d85337645227abe353ac95ab8ff66a7bdd5ce689b2db33a722", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hash32/0.3.1/download" + "https://static.crates.io/crates/gix-discover/0.53.0/download" ], - "strip_prefix": "hash32-0.3.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hash32\",\n deps = [\n \"@crates__byteorder-1.5.0//:byteorder\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hash32\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.1\",\n)\n" + "strip_prefix": "gix-discover-0.53.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_discover\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-ref-0.65.0//:gix_ref\",\n \"@crates__gix-sec-0.14.2//:gix_sec\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ] + select({\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__dunce-1.0.5//:dunce\", # cfg(windows)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-discover\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.53.0\",\n)\n" } }, - "crates__hashbrown-0.14.5": { + "crates__gix-error-0.2.5": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1", + "sha256": "4a9292309fd944e71b2a3c96d3c03a6feb8852db646febdde7cbb9f79cb5f329", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hashbrown/0.14.5/download" + "https://static.crates.io/crates/gix-error/0.2.5/download" ], - "strip_prefix": "hashbrown-0.14.5", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hashbrown\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"raw\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hashbrown\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.5\",\n)\n" + "strip_prefix": "gix-error-0.2.5", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_error\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-error\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.5\",\n)\n" } }, - "crates__hashbrown-0.15.5": { + "crates__gix-features-0.48.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1", + "sha256": "1849ae154d38bc403185be14fa871e38e3c93ee606875d94e207fdb9fba52dbc", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hashbrown/0.15.5/download" + "https://static.crates.io/crates/gix-features/0.48.1/download" ], - "strip_prefix": "hashbrown-0.15.5", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hashbrown\",\n deps = [\n \"@crates__allocator-api2-0.2.21//:allocator_api2\",\n \"@crates__equivalent-1.0.2//:equivalent\",\n \"@crates__foldhash-0.1.5//:foldhash\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"allocator-api2\",\n \"default\",\n \"default-hasher\",\n \"equivalent\",\n \"inline-more\",\n \"raw-entry\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hashbrown\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.15.5\",\n)\n" + "strip_prefix": "gix-features-0.48.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_features\",\n deps = [\n \"@crates__crc32fast-1.5.1//:crc32fast\",\n \"@crates__crossbeam-channel-0.5.16//:crossbeam_channel\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__gix-utils-0.3.6//:gix_utils\",\n \"@crates__once_cell-1.21.4//:once_cell\",\n \"@crates__parking_lot-0.12.5//:parking_lot\",\n \"@crates__prodash-31.0.0//:prodash\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__walkdir-2.5.0//:walkdir\",\n \"@crates__zlib-rs-0.6.7//:zlib_rs\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"crc32\",\n \"default\",\n \"fs-read-dir\",\n \"once_cell\",\n \"parallel\",\n \"prodash\",\n \"progress\",\n \"walkdir\",\n \"zlib\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-features\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.48.1\",\n)\n" } }, - "crates__hashbrown-0.16.1": { + "crates__gix-filter-0.32.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100", + "sha256": "6644fb2ef97928c278675b239f366b457103d7e436f811d27331a8daf212759c", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hashbrown/0.16.1/download" + "https://static.crates.io/crates/gix-filter/0.32.0/download" ], - "strip_prefix": "hashbrown-0.16.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hashbrown\",\n deps = [\n \"@crates__allocator-api2-0.2.21//:allocator_api2\",\n \"@crates__equivalent-1.0.2//:equivalent\",\n \"@crates__foldhash-0.2.0//:foldhash\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"allocator-api2\",\n \"default\",\n \"default-hasher\",\n \"equivalent\",\n \"inline-more\",\n \"raw-entry\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hashbrown\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.16.1\",\n)\n" + "strip_prefix": "gix-filter-0.32.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_filter\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__encoding_rs-0.8.35//:encoding_rs\",\n \"@crates__gix-attributes-0.33.2//:gix_attributes\",\n \"@crates__gix-command-0.9.2//:gix_command\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-packetline-0.21.5//:gix_packetline\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-quote-0.7.2//:gix_quote\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__gix-utils-0.3.6//:gix_utils\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-filter\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.32.0\",\n)\n" } }, - "crates__hashbrown-0.17.1": { + "crates__gix-fs-0.21.2": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a", + "sha256": "6cdff46db8798e47e2f727d84b9379aac5add3dd3d9d0b07bb4d7d5d640771fe", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hashbrown/0.17.1/download" + "https://static.crates.io/crates/gix-fs/0.21.2/download" ], - "strip_prefix": "hashbrown-0.17.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hashbrown\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hashbrown\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.1\",\n)\n" + "strip_prefix": "gix-fs-0.21.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_fs\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__fastrand-2.5.0//:fastrand\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-utils-0.3.6//:gix_utils\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-fs\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.21.2\",\n)\n" } }, - "crates__heapless-0.9.3": { + "crates__gix-glob-0.26.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "25ba4bd83f9415b58b4ed8dc5714c76e626a105be4646c02630ad730ad3b5aa4", + "sha256": "d1fcb8ef5b16bcf874abe9b68d8abb3c0493c876d367ab824151f30a0f3f3756", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/heapless/0.9.3/download" + "https://static.crates.io/crates/gix-glob/0.26.1/download" ], - "strip_prefix": "heapless-0.9.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"heapless\",\n deps = [\n \"@crates__hash32-0.3.1//:hash32\",\n \"@crates__heapless-0.9.3//:build_script_build\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=heapless\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.3\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"heapless\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=heapless\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.9.3\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "strip_prefix": "gix-glob-0.26.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_glob\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-glob\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.26.1\",\n)\n" } }, - "crates__heck-0.5.0": { + "crates__gix-hash-0.25.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea", + "sha256": "cb0926d3819c837750b4e03c7754901e73f68b8c9b690753a6372a1bed4eedce", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/heck/0.5.0/download" + "https://static.crates.io/crates/gix-hash/0.25.1/download" ], - "strip_prefix": "heck-0.5.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"heck\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=heck\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.0\",\n)\n" + "strip_prefix": "gix-hash-0.25.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_hash\",\n deps = [\n \"@crates__faster-hex-0.10.0//:faster_hex\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__sha1-checked-0.10.0//:sha1_checked\",\n \"@crates__sha2-0.11.0//:sha2\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"sha1\",\n \"sha256\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-hash\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.25.1\",\n)\n" } }, - "crates__hermit-abi-0.5.2": { + "crates__gix-hashtable-0.15.2": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c", + "sha256": "7e261d54091f0d1c729bc83f54548c071bdec60a697de1e58e88bdfd7a99d24e", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hermit-abi/0.5.2/download" + "https://static.crates.io/crates/gix-hashtable/0.15.2/download" ], - "strip_prefix": "hermit-abi-0.5.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hermit_abi\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hermit-abi\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.2\",\n)\n" + "strip_prefix": "gix-hashtable-0.15.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_hashtable\",\n deps = [\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__hashbrown-0.17.1//:hashbrown\",\n \"@crates__parking_lot-0.12.5//:parking_lot\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-hashtable\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.15.2\",\n)\n" } }, - "crates__hex-0.4.3": { + "crates__gix-ignore-0.21.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70", + "sha256": "d491bab9bf2c9f341dc754f425c31d5d3f63aca615312167b82e1deeaca97d8d", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hex/0.4.3/download" + "https://static.crates.io/crates/gix-ignore/0.21.1/download" ], - "strip_prefix": "hex-0.4.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hex\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hex\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.3\",\n)\n" + "strip_prefix": "gix-ignore-0.21.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_ignore\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-glob-0.26.1//:gix_glob\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__unicode-bom-2.0.3//:unicode_bom\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-ignore\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.21.1\",\n)\n" } }, - "crates__hifijson-0.2.3": { + "crates__gix-imara-diff-0.2.5": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "0a7763b98ba8a24f59e698bf9ab197e7676c640d6455d1580b4ce7dc560f0f0d", + "sha256": "1c91d8cffac8849493a82233811bd02b2b183b8cf39bf704de0fa0841b737595", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hifijson/0.2.3/download" + "https://static.crates.io/crates/gix-imara-diff/0.2.5/download" ], - "strip_prefix": "hifijson-0.2.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hifijson\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hifijson\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.3\",\n)\n" + "strip_prefix": "gix-imara-diff-0.2.5", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_imara_diff\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__hashbrown-0.17.1//:hashbrown\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-imara-diff\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.5\",\n)\n" } }, - "crates__hkdf-0.12.4": { + "crates__gix-index-0.53.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7", + "sha256": "36d45f82ec5a4d7542ea595e9ad16e03e26c8cb4f221e5bc9fcdcf469f63a681", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hkdf/0.12.4/download" + "https://static.crates.io/crates/gix-index/0.53.0/download" ], - "strip_prefix": "hkdf-0.12.4", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hkdf\",\n deps = [\n \"@crates__hmac-0.12.1//:hmac\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hkdf\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.4\",\n)\n" + "strip_prefix": "gix-index-0.53.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_index\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__filetime-0.2.29//:filetime\",\n \"@crates__fnv-1.0.7//:fnv\",\n \"@crates__gix-bitmap-0.3.3//:gix_bitmap\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-lock-23.0.1//:gix_lock\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-traverse-0.59.0//:gix_traverse\",\n \"@crates__gix-utils-0.3.6//:gix_utils\",\n \"@crates__gix-validate-0.11.4//:gix_validate\",\n \"@crates__hashbrown-0.17.1//:hashbrown\",\n \"@crates__itoa-1.0.18//:itoa\",\n \"@crates__memmap2-0.9.11//:memmap2\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-index\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.53.0\",\n)\n" } }, - "crates__hmac-0.12.1": { + "crates__gix-lock-23.0.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e", + "sha256": "65c9dedd9e90b0d47624d2ed241d394e09294118364e87b9b7e5f1fe755f3c2c", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hmac/0.12.1/download" + "https://static.crates.io/crates/gix-lock/23.0.1/download" ], - "strip_prefix": "hmac-0.12.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hmac\",\n deps = [\n \"@crates__digest-0.10.7//:digest\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"reset\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hmac\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.1\",\n)\n" + "strip_prefix": "gix-lock-23.0.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_lock\",\n deps = [\n \"@crates__gix-tempfile-23.0.2//:gix_tempfile\",\n \"@crates__gix-utils-0.3.6//:gix_utils\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-lock\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"23.0.1\",\n)\n" } }, - "crates__hostname-0.4.2": { + "crates__gix-merge-0.18.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "617aaa3557aef3810a6369d0a99fac8a080891b68bd9f9812a1eeda0c0730cbd", + "sha256": "4b529a5dc509175fe277643a1c50b38de69f24b5a50f9c4e7f854c7fc7d1acc7", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hostname/0.4.2/download" + "https://static.crates.io/crates/gix-merge/0.18.0/download" ], - "strip_prefix": "hostname-0.4.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hostname\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-link-0.2.1//:windows_link\", # cfg(target_os = \"windows\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hostname\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.2\",\n)\n" + "strip_prefix": "gix-merge-0.18.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_merge\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-command-0.9.2//:gix_command\",\n \"@crates__gix-diff-0.65.0//:gix_diff\",\n \"@crates__gix-filter-0.32.0//:gix_filter\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-imara-diff-0.2.5//:gix_imara_diff\",\n \"@crates__gix-index-0.53.0//:gix_index\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-quote-0.7.2//:gix_quote\",\n \"@crates__gix-revision-0.47.0//:gix_revision\",\n \"@crates__gix-revwalk-0.33.0//:gix_revwalk\",\n \"@crates__gix-tempfile-23.0.2//:gix_tempfile\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__gix-worktree-0.54.0//:gix_worktree\",\n \"@crates__nonempty-0.12.0//:nonempty\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n aliases = {\n \"@crates__gix-imara-diff-0.2.5//:gix_imara_diff\": \"imara_diff\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-merge\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.18.0\",\n)\n" } }, - "crates__html-escape-0.2.15": { + "crates__gix-object-0.62.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "c9356095b4b41197bba32173600e1582792cda618f65d12f68e2e77d273413c5", + "sha256": "019b38afc3eac1e41f9fe09a327664b313ba4a120fa5f40e3678795d0e42783e", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/html-escape/0.2.15/download" + "https://static.crates.io/crates/gix-object/0.62.0/download" ], - "strip_prefix": "html-escape-0.2.15", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"html_escape\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=html-escape\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.15\",\n)\n" + "strip_prefix": "gix-object-0.62.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_object\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-actor-0.41.2//:gix_actor\",\n \"@crates__gix-date-0.15.6//:gix_date\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-hashtable-0.15.2//:gix_hashtable\",\n \"@crates__gix-utils-0.3.6//:gix_utils\",\n \"@crates__gix-validate-0.11.4//:gix_validate\",\n \"@crates__itoa-1.0.18//:itoa\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-object\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.62.0\",\n)\n" } }, - "crates__html-to-markdown-rs-3.11.3": { + "crates__gix-odb-0.82.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "187d8352a854d055faf1e6574bd14d8c3e429a1c1a73462793155ce63a845fb4", + "sha256": "7fadc59f6fa0f9dd445eceee61060a2b59ca557f48da9fc677f567db535b782a", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/html-to-markdown-rs/3.11.3/download" + "https://static.crates.io/crates/gix-odb/0.82.0/download" ], - "strip_prefix": "html-to-markdown-rs-3.11.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"html_to_markdown_rs\",\n deps = [\n \"@crates__ahash-0.8.12//:ahash\",\n \"@crates__astral-tl-0.7.11//:tl\",\n \"@crates__base64-0.23.1//:base64\",\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__html-escape-0.2.15//:html_escape\",\n \"@crates__html5ever-0.39.0//:html5ever\",\n \"@crates__memchr-2.8.3//:memchr\",\n \"@crates__once_cell-1.21.4//:once_cell\",\n \"@crates__phf-0.14.0//:phf\",\n \"@crates__regex-1.13.1//:regex\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__tracing-0.1.44//:tracing\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=html-to-markdown-rs\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.11.3\",\n)\n" + "strip_prefix": "gix-odb-0.82.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_odb\",\n deps = [\n \"@crates__arc-swap-1.9.2//:arc_swap\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-hashtable-0.15.2//:gix_hashtable\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-pack-0.72.0//:gix_pack\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-quote-0.7.2//:gix_quote\",\n \"@crates__memmap2-0.9.11//:memmap2\",\n \"@crates__parking_lot-0.12.5//:parking_lot\",\n \"@crates__tempfile-3.27.0//:tempfile\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-odb\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.82.0\",\n)\n" } }, - "crates__html5ever-0.39.0": { + "crates__gix-pack-0.72.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "46a1761807faccc9a19e86944bbf40610014066306f96edcdedc2fb714bcb7b8", + "sha256": "ca3e7f1726cd2c0cd1cf1fc20be8a8e623f0b163f1f8d6fc836cfb9bc8cd758b", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/html5ever/0.39.0/download" + "https://static.crates.io/crates/gix-pack/0.72.0/download" ], - "strip_prefix": "html5ever-0.39.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"html5ever\",\n deps = [\n \"@crates__log-0.4.33//:log\",\n \"@crates__markup5ever-0.39.0//:markup5ever\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=html5ever\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.39.0\",\n)\n" + "strip_prefix": "gix-pack-0.72.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_pack\",\n deps = [\n \"@crates__clru-0.6.3//:clru\",\n \"@crates__gix-chunk-0.7.3//:gix_chunk\",\n \"@crates__gix-error-0.2.5//:gix_error\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-hashtable-0.15.2//:gix_hashtable\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__memmap2-0.9.11//:memmap2\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__uluru-3.1.0//:uluru\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"object-cache-dynamic\",\n \"pack-cache-lru-dynamic\",\n \"pack-cache-lru-static\",\n \"sha1\",\n \"sha256\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-pack\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.72.0\",\n)\n" } }, - "crates__hybrid-array-0.4.14": { + "crates__gix-packetline-0.21.5": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "707114b52a152fa7bdb290cd7cd5912d9467273b6d74e21b8d81aca1f8533f6b", + "sha256": "b217dd0ee0c4021ecf169a4a519b1b4f80d15e3f3765f3dc466223dc0ac891d7", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/hybrid-array/0.4.14/download" + "https://static.crates.io/crates/gix-packetline/0.21.5/download" ], - "strip_prefix": "hybrid-array-0.4.14", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hybrid_array\",\n deps = [\n \"@crates__typenum-1.20.1//:typenum\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hybrid-array\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.14\",\n)\n" + "strip_prefix": "gix-packetline-0.21.5", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_packetline\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__faster-hex-0.10.0//:faster_hex\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"blocking-io\",\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-packetline\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.21.5\",\n)\n" } }, - "crates__iana-time-zone-0.1.65": { + "crates__gix-path-0.12.5": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470", + "sha256": "2b075e730586bba7341304d6fc1b4efc1d10cf64532622521c0e07f30e661046", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/iana-time-zone/0.1.65/download" + "https://static.crates.io/crates/gix-path/0.12.5/download" ], - "strip_prefix": "iana-time-zone-0.1.65", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"iana_time_zone\",\n deps = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__core-foundation-sys-0.8.7//:core_foundation_sys\", # cfg(target_vendor = \"apple\")\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__core-foundation-sys-0.8.7//:core_foundation_sys\", # cfg(target_vendor = \"apple\")\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-core-0.62.2//:windows_core\", # cfg(target_os = \"windows\")\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"fallback\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=iana-time-zone\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.65\",\n)\n" + "strip_prefix": "gix-path-0.12.5", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_path\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__gix-validate-0.11.4//:gix_validate\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-path\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.5\",\n)\n" } }, - "crates__iana-time-zone-haiku-0.1.2": { + "crates__gix-pathspec-0.18.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f", + "sha256": "3050783b41ee11511e1e8fb35623df81806194f4030395f14f48ea37c2798c9f", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/iana-time-zone-haiku/0.1.2/download" + "https://static.crates.io/crates/gix-pathspec/0.18.1/download" ], - "strip_prefix": "iana-time-zone-haiku-0.1.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"iana_time_zone_haiku\",\n deps = [\n \"@crates__iana-time-zone-haiku-0.1.2//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=iana-time-zone-haiku\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.2\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n deps = [\n \"@crates__cc-1.2.67//:cc\",\n ],\n emit_warnings = False,\n edition = \"2018\",\n pkg_name = \"iana-time-zone-haiku\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=iana-time-zone-haiku\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.1.2\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "strip_prefix": "gix-pathspec-0.18.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_pathspec\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-attributes-0.33.2//:gix_attributes\",\n \"@crates__gix-config-value-0.18.1//:gix_config_value\",\n \"@crates__gix-glob-0.26.1//:gix_glob\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-pathspec\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.18.1\",\n)\n" } }, - "crates__icu_calendar-2.3.0": { + "crates__gix-protocol-0.63.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "58655df2f728e46e4eee80bddebefacf52ec3e77cdb925014b47c5a5905eb55c", + "sha256": "978468bae4ea2df20c72db3b20d0bdb548a0c1090b85a83643b553e6e0e041f2", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/icu_calendar/2.3.0/download" + "https://static.crates.io/crates/gix-protocol/0.63.0/download" ], - "strip_prefix": "icu_calendar-2.3.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"icu_calendar\",\n deps = [\n \"@crates__calendrical_calculations-0.2.4//:calendrical_calculations\",\n \"@crates__icu_calendar_data-2.3.0//:icu_calendar_data\",\n \"@crates__icu_locale_core-2.3.0//:icu_locale_core\",\n \"@crates__icu_locale_fallback-2.3.0//:icu_locale_fallback\",\n \"@crates__icu_provider-2.3.1//:icu_provider\",\n \"@crates__tinystr-0.8.4//:tinystr\",\n \"@crates__zerovec-0.11.8//:zerovec\",\n ],\n proc_macro_deps = [\n \"@crates__displaydoc-0.2.7//:displaydoc\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"compiled_data\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=icu_calendar\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.3.0\",\n)\n" + "strip_prefix": "gix-protocol-0.63.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_protocol\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-date-0.15.6//:gix_date\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-ref-0.65.0//:gix_ref\",\n \"@crates__gix-shallow-0.12.1//:gix_shallow\",\n \"@crates__gix-transport-0.57.2//:gix_transport\",\n \"@crates__gix-utils-0.3.6//:gix_utils\",\n \"@crates__nonempty-0.12.0//:nonempty\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n proc_macro_deps = [\n \"@crates__maybe-async-0.2.11//:maybe_async\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-protocol\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.63.0\",\n)\n" } }, - "crates__icu_calendar_data-2.3.0": { + "crates__gix-quote-0.7.2": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "dc00caaa3fb3201ff7a18aa458e8c3ab042b9da154cfdf948bdde3936c31c36e", + "sha256": "a6e541fc33cc2b783b7979040d445a0c86a2eca747c8faea4ca84230d06ae6ef", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/icu_calendar_data/2.3.0/download" + "https://static.crates.io/crates/gix-quote/0.7.2/download" ], - "strip_prefix": "icu_calendar_data-2.3.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"icu_calendar_data\",\n deps = [\n \"@crates__icu_calendar_data-2.3.0//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=icu_calendar_data\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.3.0\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2024\",\n pkg_name = \"icu_calendar_data\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=icu_calendar_data\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"2.3.0\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "strip_prefix": "gix-quote-0.7.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_quote\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-error-0.2.5//:gix_error\",\n \"@crates__gix-utils-0.3.6//:gix_utils\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-quote\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.7.2\",\n)\n" } }, - "crates__icu_collator-2.3.1": { + "crates__gix-ref-0.65.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "9bbfbce1dfd7d7f8469ddef6d3518376aff664348f153cbe0fc3e58ef993d24e", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-ref/0.65.0/download" + ], + "strip_prefix": "gix-ref-0.65.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_ref\",\n deps = [\n \"@crates__gix-actor-0.41.2//:gix_actor\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-lock-23.0.1//:gix_lock\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-tempfile-23.0.2//:gix_tempfile\",\n \"@crates__gix-utils-0.3.6//:gix_utils\",\n \"@crates__gix-validate-0.11.4//:gix_validate\",\n \"@crates__memmap2-0.9.11//:memmap2\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-ref\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.65.0\",\n)\n" + } + }, + "crates__gix-refspec-0.43.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "7bc36a4fb1a1540b59cf2da498783080743fa274b02a3f19ca444fc4015a9d4f", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-refspec/0.43.0/download" + ], + "strip_prefix": "gix-refspec-0.43.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_refspec\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-error-0.2.5//:gix_error\",\n \"@crates__gix-glob-0.26.1//:gix_glob\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-revision-0.47.0//:gix_revision\",\n \"@crates__gix-validate-0.11.4//:gix_validate\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-refspec\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.43.0\",\n)\n" + } + }, + "crates__gix-revision-0.47.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "885075c3c21eb9c06e0be3b3728ba5932c04e1c1011dcee7c81801980e3e986f", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-revision/0.47.0/download" + ], + "strip_prefix": "gix-revision-0.47.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_revision\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-commitgraph-0.37.1//:gix_commitgraph\",\n \"@crates__gix-date-0.15.6//:gix_date\",\n \"@crates__gix-error-0.2.5//:gix_error\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-hashtable-0.15.2//:gix_hashtable\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-revwalk-0.33.0//:gix_revwalk\",\n \"@crates__gix-trace-0.1.21//:gix_trace\",\n \"@crates__nonempty-0.12.0//:nonempty\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"describe\",\n \"merge_base\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-revision\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.47.0\",\n)\n" + } + }, + "crates__gix-revwalk-0.33.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "8f11fe7ca2585193d3d70bbe0be175a2008d883a704cc7a55e454e113e689455", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-revwalk/0.33.0/download" + ], + "strip_prefix": "gix-revwalk-0.33.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_revwalk\",\n deps = [\n \"@crates__gix-commitgraph-0.37.1//:gix_commitgraph\",\n \"@crates__gix-date-0.15.6//:gix_date\",\n \"@crates__gix-error-0.2.5//:gix_error\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-hashtable-0.15.2//:gix_hashtable\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-revwalk\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.33.0\",\n)\n" + } + }, + "crates__gix-sec-0.14.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "af4fe6c152c1d50aea36f299825702cd37e303307832fec1d0fdd5844e47ce2f", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-sec/0.14.2/download" + ], + "strip_prefix": "gix-sec-0.14.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_sec\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__gix-path-0.12.5//:gix_path\", # cfg(windows)\n \"@crates__windows-sys-0.61.2//:windows_sys\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-sec\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.2\",\n)\n" + } + }, + "crates__gix-shallow-0.12.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "a292fc2fe548c5dfa575479d16b445b0ddf1dd2f56f1fec6aed386f82553cd97", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-shallow/0.12.1/download" + ], + "strip_prefix": "gix-shallow-0.12.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_shallow\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-lock-23.0.1//:gix_lock\",\n \"@crates__nonempty-0.12.0//:nonempty\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-shallow\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.1\",\n)\n" + } + }, + "crates__gix-status-0.32.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "aec3293f75db1212f99217832cbc70c30faeb95cefc97c7f1a17fd3bcf13a72e", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-status/0.32.0/download" + ], + "strip_prefix": "gix-status-0.32.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_status\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__filetime-0.2.29//:filetime\",\n \"@crates__gix-diff-0.65.0//:gix_diff\",\n \"@crates__gix-dir-0.27.0//:gix_dir\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-filter-0.32.0//:gix_filter\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-index-0.53.0//:gix_index\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-pathspec-0.18.1//:gix_pathspec\",\n \"@crates__gix-worktree-0.54.0//:gix_worktree\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"worktree-rewrites\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-status\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.32.0\",\n)\n" + } + }, + "crates__gix-submodule-0.32.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "a7f9f594f7cbda0b38ba6b633b3e9a7b7901acdc5d27bc186a16633800cd1ac8", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-submodule/0.32.0/download" + ], + "strip_prefix": "gix-submodule-0.32.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_submodule\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-config-0.58.0//:gix_config\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-pathspec-0.18.1//:gix_pathspec\",\n \"@crates__gix-refspec-0.43.0//:gix_refspec\",\n \"@crates__gix-url-0.36.2//:gix_url\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-submodule\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.32.0\",\n)\n" + } + }, + "crates__gix-tempfile-23.0.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "6ef60812443484e67bf84e444cc71b4c78ae62deb822221774a4fa0c57fdb17f", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-tempfile/23.0.2/download" + ], + "strip_prefix": "gix-tempfile-23.0.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_tempfile\",\n deps = [\n \"@crates__dashmap-6.2.1//:dashmap\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__parking_lot-0.12.5//:parking_lot\",\n \"@crates__tempfile-3.27.0//:tempfile\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(not(windows))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"hp-hashmap\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-tempfile\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"23.0.2\",\n)\n" + } + }, + "crates__gix-trace-0.1.21": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "be3eb81d9dc914335923e50d52829c551feefd6a72d176c4130c546b67a60814", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-trace/0.1.21/download" + ], + "strip_prefix": "gix-trace-0.1.21", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_trace\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-trace\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.21\",\n)\n" + } + }, + "crates__gix-transport-0.57.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "186874f7ad1fb2f9a2f2aa9c2dabc7f9dd087bef74c1a0eee2b4a9cf0248fcb3", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-transport/0.57.2/download" + ], + "strip_prefix": "gix-transport-0.57.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_transport\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-command-0.9.2//:gix_command\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-packetline-0.21.5//:gix_packetline\",\n \"@crates__gix-quote-0.7.2//:gix_quote\",\n \"@crates__gix-sec-0.14.2//:gix_sec\",\n \"@crates__gix-url-0.36.2//:gix_url\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-transport\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.57.2\",\n)\n" + } + }, + "crates__gix-traverse-0.59.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "5062cca8f2977565bbaf666ec31dbdb9bc9d9293beb65f9bec52e6c1121b62a1", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-traverse/0.59.0/download" + ], + "strip_prefix": "gix-traverse-0.59.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_traverse\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__gix-commitgraph-0.37.1//:gix_commitgraph\",\n \"@crates__gix-date-0.15.6//:gix_date\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-hashtable-0.15.2//:gix_hashtable\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-revwalk-0.33.0//:gix_revwalk\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-traverse\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.59.0\",\n)\n" + } + }, + "crates__gix-url-0.36.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "57d68e70e96da0e5f9c871f1566349e0fd0e1a20bb483c7f54af1dd0b85b4b29", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-url/0.36.2/download" + ], + "strip_prefix": "gix-url-0.36.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_url\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__percent-encoding-2.3.2//:percent_encoding\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-url\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.36.2\",\n)\n" + } + }, + "crates__gix-utils-0.3.6": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "0da1c46491b49458a446cc76f0085860f8164c2290742e0aa8c653ce67240a97", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-utils/0.3.6/download" + ], + "strip_prefix": "gix-utils-0.3.6", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_utils\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__fastrand-2.5.0//:fastrand\",\n \"@crates__unicode-normalization-0.1.25//:unicode_normalization\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__getrandom-0.4.3//:getrandom\", # cfg(not(all(target_arch = \"wasm32\", target_os = \"unknown\")))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__getrandom-0.4.3//:getrandom\", # cfg(not(all(target_arch = \"wasm32\", target_os = \"unknown\")))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__getrandom-0.4.3//:getrandom\", # cfg(not(all(target_arch = \"wasm32\", target_os = \"unknown\")))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__getrandom-0.4.3//:getrandom\", # cfg(not(all(target_arch = \"wasm32\", target_os = \"unknown\")))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__getrandom-0.4.3//:getrandom\", # cfg(not(all(target_arch = \"wasm32\", target_os = \"unknown\")))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__getrandom-0.4.3//:getrandom\", # cfg(not(all(target_arch = \"wasm32\", target_os = \"unknown\")))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__getrandom-0.4.3//:getrandom\", # cfg(not(all(target_arch = \"wasm32\", target_os = \"unknown\")))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"bstr\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-utils\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.6\",\n)\n" + } + }, + "crates__gix-validate-0.11.4": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "4dae8780f63ed8a803b8bdabbd7aa5f5c5d74592c8b50eed875c1bb4f6545a6a", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-validate/0.11.4/download" + ], + "strip_prefix": "gix-validate-0.11.4", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_validate\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-validate\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.11.4\",\n)\n" + } + }, + "crates__gix-worktree-0.54.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "92399ed66f259592050c6ed9dc80105e095a2f8e87e6b83d98aa2e21d8e27036", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-worktree/0.54.0/download" + ], + "strip_prefix": "gix-worktree-0.54.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_worktree\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-attributes-0.33.2//:gix_attributes\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-glob-0.26.1//:gix_glob\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-ignore-0.21.1//:gix_ignore\",\n \"@crates__gix-index-0.53.0//:gix_index\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-validate-0.11.4//:gix_validate\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"attributes\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-worktree\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.54.0\",\n)\n" + } + }, + "crates__gix-worktree-state-0.32.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "c0f926b6a249bdb0086b307c704b7abd9d643e08f98040efe6467f00bb6d2ef5", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-worktree-state/0.32.0/download" + ], + "strip_prefix": "gix-worktree-state-0.32.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_worktree_state\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-filter-0.32.0//:gix_filter\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-index-0.53.0//:gix_index\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-worktree-0.54.0//:gix_worktree\",\n \"@crates__io-close-0.3.7//:io_close\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-worktree-state\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.32.0\",\n)\n" + } + }, + "crates__gix-worktree-stream-0.34.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "55f3a878c89a05470ad98c644b0015777c530da24854dd29e41fe4f41176840f", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gix-worktree-stream/0.34.0/download" + ], + "strip_prefix": "gix-worktree-stream-0.34.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gix_worktree_stream\",\n deps = [\n \"@crates__gix-attributes-0.33.2//:gix_attributes\",\n \"@crates__gix-error-0.2.5//:gix_error\",\n \"@crates__gix-features-0.48.1//:gix_features\",\n \"@crates__gix-filter-0.32.0//:gix_filter\",\n \"@crates__gix-fs-0.21.2//:gix_fs\",\n \"@crates__gix-hash-0.25.1//:gix_hash\",\n \"@crates__gix-object-0.62.0//:gix_object\",\n \"@crates__gix-path-0.12.5//:gix_path\",\n \"@crates__gix-traverse-0.59.0//:gix_traverse\",\n \"@crates__parking_lot-0.12.5//:parking_lot\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gix-worktree-stream\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.34.0\",\n)\n" + } + }, + "crates__gl-0.14.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "a94edab108827d67608095e269cf862e60d920f144a5026d3dbcfd8b877fb404", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gl/0.14.0/download" + ], + "strip_prefix": "gl-0.14.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gl\",\n deps = [\n \"@crates__gl-0.14.0//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gl\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.0\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n deps = [\n \"@crates__gl_generator-0.14.0//:gl_generator\",\n ],\n emit_warnings = False,\n edition = \"2015\",\n pkg_name = \"gl\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gl\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.14.0\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + } + }, + "crates__gl_generator-0.14.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/gl_generator/0.14.0/download" + ], + "strip_prefix": "gl_generator-0.14.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"gl_generator\",\n deps = [\n \"@crates__khronos_api-3.1.0//:khronos_api\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__xml-rs-0.8.29//:xml\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=gl_generator\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.0\",\n)\n" + } + }, + "crates__glob-0.3.4": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/glob/0.3.4/download" + ], + "strip_prefix": "glob-0.3.4", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"glob\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=glob\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.4\",\n)\n" + } + }, + "crates__globset-0.4.20": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "07c34a9410465b45bd9787443bc7370f37735bad04b0f0cd57ff1a3186c98988", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/globset/0.4.20/download" + ], + "strip_prefix": "globset-0.4.20", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"globset\",\n deps = [\n \"@crates__aho-corasick-1.1.5//:aho_corasick\",\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__regex-automata-0.4.18//:regex_automata\",\n \"@crates__regex-syntax-0.8.11//:regex_syntax\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"log\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=globset\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.20\",\n)\n" + } + }, + "crates__grep-cli-0.1.12": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "cf32d263c5d5cc2a23ce587097f5ddafdb188492ba2e6fb638eaccdc22453631", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/grep-cli/0.1.12/download" + ], + "strip_prefix": "grep-cli-0.1.12", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_cli\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__globset-0.4.20//:globset\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__termcolor-1.4.1//:termcolor\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__winapi-util-0.1.11//:winapi_util\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-cli\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.12\",\n)\n" + } + }, + "crates__grep-matcher-0.1.9": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "f9417543f4870fc8f1c8e1af870afae2431007626d9e703fce6471c468d33847", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/grep-matcher/0.1.9/download" + ], + "strip_prefix": "grep-matcher-0.1.9", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_matcher\",\n deps = [\n \"@crates__memchr-2.8.3//:memchr\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-matcher\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.9\",\n)\n" + } + }, + "crates__grep-pcre2-0.1.10": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "b752bb6f57dd3716e55b63a33ca05b5825c3d66cd427468874a5564af6ca365c", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/grep-pcre2/0.1.10/download" + ], + "strip_prefix": "grep-pcre2-0.1.10", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_pcre2\",\n deps = [\n \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__pcre2-0.2.11//:pcre2\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-pcre2\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.10\",\n)\n" + } + }, + "crates__grep-printer-0.3.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "fd76035e87871f51c1ee5b793e32122b3ccf9c692662d9622ef1686ff5321acb", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/grep-printer/0.3.1/download" + ], + "strip_prefix": "grep-printer-0.3.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_printer\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n \"@crates__grep-searcher-0.1.17//:grep_searcher\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__serde-1.0.229//:serde\",\n \"@crates__serde_json-1.0.151//:serde_json\",\n \"@crates__termcolor-1.4.1//:termcolor\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"serde\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-printer\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.1\",\n)\n" + } + }, + "crates__grep-regex-0.1.14": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "0ce0c256c3ad82bcc07b812c15a45ec1d398122e8e15124f96695234db7112ef", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/grep-regex/0.1.14/download" + ], + "strip_prefix": "grep-regex-0.1.14", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_regex\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__regex-automata-0.4.18//:regex_automata\",\n \"@crates__regex-syntax-0.8.11//:regex_syntax\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-regex\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.14\",\n)\n" + } + }, + "crates__grep-searcher-0.1.17": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "72348823a0eafc4bc2e9051064f28b5b42cc100b571b3a35d67918d711efcbc6", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/grep-searcher/0.1.17/download" + ], + "strip_prefix": "grep-searcher-0.1.17", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"grep_searcher\",\n deps = [\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__encoding_rs-0.8.35//:encoding_rs\",\n \"@crates__encoding_rs_io-0.1.8//:encoding_rs_io\",\n \"@crates__grep-matcher-0.1.9//:grep_matcher\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__memchr-2.8.3//:memchr\",\n \"@crates__memmap2-0.9.11//:memmap2\",\n ],\n aliases = {\n \"@crates__memmap2-0.9.11//:memmap2\": \"memmap\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=grep-searcher\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.17\",\n)\n" + } + }, + "crates__group-0.13.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/group/0.13.0/download" + ], + "strip_prefix": "group-0.13.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"group\",\n deps = [\n \"@crates__ff-0.13.1//:ff\",\n \"@crates__rand_core-0.6.4//:rand_core\",\n \"@crates__subtle-2.6.1//:subtle\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=group\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.13.0\",\n)\n" + } + }, + "crates__half-2.7.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/half/2.7.1/download" + ], + "strip_prefix": "half-2.7.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"half\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__zerocopy-0.8.56//:zerocopy\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=half\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.7.1\",\n)\n" + } + }, + "crates__harfrust-0.12.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "c03d949a14aa089bbb282f7dd76a498a7f684428e4257202efc119ec010376f9", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/harfrust/0.12.0/download" + ], + "strip_prefix": "harfrust-0.12.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"harfrust\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__bytemuck-1.25.2//:bytemuck\",\n \"@crates__read-fonts-0.41.0//:read_fonts\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=harfrust\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.0\",\n)\n" + } + }, + "crates__hash32-0.3.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "47d60b12902ba28e2730cd37e95b8c9223af2808df9e902d4df49588d1470606", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hash32/0.3.1/download" + ], + "strip_prefix": "hash32-0.3.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hash32\",\n deps = [\n \"@crates__byteorder-1.5.0//:byteorder\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hash32\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.1\",\n)\n" + } + }, + "crates__hashbrown-0.14.5": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hashbrown/0.14.5/download" + ], + "strip_prefix": "hashbrown-0.14.5", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hashbrown\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"raw\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hashbrown\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.5\",\n)\n" + } + }, + "crates__hashbrown-0.15.5": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hashbrown/0.15.5/download" + ], + "strip_prefix": "hashbrown-0.15.5", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hashbrown\",\n deps = [\n \"@crates__allocator-api2-0.2.21//:allocator_api2\",\n \"@crates__equivalent-1.0.2//:equivalent\",\n \"@crates__foldhash-0.1.5//:foldhash\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"allocator-api2\",\n \"default\",\n \"default-hasher\",\n \"equivalent\",\n \"inline-more\",\n \"raw-entry\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hashbrown\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.15.5\",\n)\n" + } + }, + "crates__hashbrown-0.16.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hashbrown/0.16.1/download" + ], + "strip_prefix": "hashbrown-0.16.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hashbrown\",\n deps = [\n \"@crates__allocator-api2-0.2.21//:allocator_api2\",\n \"@crates__equivalent-1.0.2//:equivalent\",\n \"@crates__foldhash-0.2.0//:foldhash\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"allocator-api2\",\n \"default\",\n \"default-hasher\",\n \"equivalent\",\n \"inline-more\",\n \"raw-entry\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hashbrown\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.16.1\",\n)\n" + } + }, + "crates__hashbrown-0.17.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hashbrown/0.17.1/download" + ], + "strip_prefix": "hashbrown-0.17.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hashbrown\",\n deps = [\n \"@crates__allocator-api2-0.2.21//:allocator_api2\",\n \"@crates__equivalent-1.0.2//:equivalent\",\n \"@crates__foldhash-0.2.0//:foldhash\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"allocator-api2\",\n \"default\",\n \"default-hasher\",\n \"equivalent\",\n \"inline-more\",\n \"raw-entry\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hashbrown\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.1\",\n)\n" + } + }, + "crates__heapless-0.8.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "0bfb9eb618601c89945a70e254898da93b13be0388091d42117462b265bb3fad", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/heapless/0.8.0/download" + ], + "strip_prefix": "heapless-0.8.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"heapless\",\n deps = [\n \"@crates__hash32-0.3.1//:hash32\",\n \"@crates__heapless-0.8.0//:build_script_build\",\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=heapless\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.0\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"heapless\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=heapless\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.8.0\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + } + }, + "crates__heapless-0.9.3": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "25ba4bd83f9415b58b4ed8dc5714c76e626a105be4646c02630ad730ad3b5aa4", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/heapless/0.9.3/download" + ], + "strip_prefix": "heapless-0.9.3", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"heapless\",\n deps = [\n \"@crates__hash32-0.3.1//:hash32\",\n \"@crates__heapless-0.9.3//:build_script_build\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__stable_deref_trait-1.2.1//:stable_deref_trait\", # cfg(any(target_arch = \"arm\", target_pointer_width = \"32\", target_pointer_width = \"64\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=heapless\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.3\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"heapless\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=heapless\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.9.3\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + } + }, + "crates__heck-0.5.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/heck/0.5.0/download" + ], + "strip_prefix": "heck-0.5.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"heck\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=heck\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.0\",\n)\n" + } + }, + "crates__hermit-abi-0.5.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hermit-abi/0.5.2/download" + ], + "strip_prefix": "hermit-abi-0.5.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hermit_abi\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hermit-abi\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.2\",\n)\n" + } + }, + "crates__hex-0.4.3": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hex/0.4.3/download" + ], + "strip_prefix": "hex-0.4.3", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hex\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hex\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.3\",\n)\n" + } + }, + "crates__hifijson-0.2.3": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "0a7763b98ba8a24f59e698bf9ab197e7676c640d6455d1580b4ce7dc560f0f0d", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hifijson/0.2.3/download" + ], + "strip_prefix": "hifijson-0.2.3", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hifijson\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hifijson\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.3\",\n)\n" + } + }, + "crates__hkdf-0.12.4": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hkdf/0.12.4/download" + ], + "strip_prefix": "hkdf-0.12.4", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hkdf\",\n deps = [\n \"@crates__hmac-0.12.1//:hmac\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hkdf\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.4\",\n)\n" + } + }, + "crates__hmac-0.12.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hmac/0.12.1/download" + ], + "strip_prefix": "hmac-0.12.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hmac\",\n deps = [\n \"@crates__digest-0.10.7//:digest\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"reset\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hmac\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.1\",\n)\n" + } + }, + "crates__hostname-0.4.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "617aaa3557aef3810a6369d0a99fac8a080891b68bd9f9812a1eeda0c0730cbd", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hostname/0.4.2/download" + ], + "strip_prefix": "hostname-0.4.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hostname\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-link-0.2.1//:windows_link\", # cfg(target_os = \"windows\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"redox\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hostname\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.2\",\n)\n" + } + }, + "crates__html-escape-0.2.15": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "c9356095b4b41197bba32173600e1582792cda618f65d12f68e2e77d273413c5", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/html-escape/0.2.15/download" + ], + "strip_prefix": "html-escape-0.2.15", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"html_escape\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=html-escape\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.15\",\n)\n" + } + }, + "crates__html-to-markdown-rs-3.11.4": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "6331a4c21bc99309e5863092660c08505c426eb1158e0472013487ecff85412b", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/html-to-markdown-rs/3.11.4/download" + ], + "strip_prefix": "html-to-markdown-rs-3.11.4", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"html_to_markdown_rs\",\n deps = [\n \"@crates__ahash-0.8.12//:ahash\",\n \"@crates__astral-tl-0.7.11//:tl\",\n \"@crates__base64-0.23.1//:base64\",\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__html-escape-0.2.15//:html_escape\",\n \"@crates__html5ever-0.39.0//:html5ever\",\n \"@crates__memchr-2.8.3//:memchr\",\n \"@crates__once_cell-1.21.4//:once_cell\",\n \"@crates__phf-0.14.0//:phf\",\n \"@crates__regex-1.13.1//:regex\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__tracing-0.1.44//:tracing\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=html-to-markdown-rs\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.11.4\",\n)\n" + } + }, + "crates__html5ever-0.39.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "46a1761807faccc9a19e86944bbf40610014066306f96edcdedc2fb714bcb7b8", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/html5ever/0.39.0/download" + ], + "strip_prefix": "html5ever-0.39.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"html5ever\",\n deps = [\n \"@crates__log-0.4.34//:log\",\n \"@crates__markup5ever-0.39.0//:markup5ever\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=html5ever\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.39.0\",\n)\n" + } + }, + "crates__hybrid-array-0.4.14": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "707114b52a152fa7bdb290cd7cd5912d9467273b6d74e21b8d81aca1f8533f6b", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/hybrid-array/0.4.14/download" + ], + "strip_prefix": "hybrid-array-0.4.14", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"hybrid_array\",\n deps = [\n \"@crates__typenum-1.20.1//:typenum\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=hybrid-array\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.14\",\n)\n" + } + }, + "crates__iana-time-zone-0.1.65": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/iana-time-zone/0.1.65/download" + ], + "strip_prefix": "iana-time-zone-0.1.65", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"iana_time_zone\",\n deps = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__core-foundation-sys-0.8.7//:core_foundation_sys\", # cfg(target_vendor = \"apple\")\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__core-foundation-sys-0.8.7//:core_foundation_sys\", # cfg(target_vendor = \"apple\")\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-core-0.62.2//:windows_core\", # cfg(target_os = \"windows\")\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"fallback\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=iana-time-zone\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.65\",\n)\n" + } + }, + "crates__iana-time-zone-haiku-0.1.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/iana-time-zone-haiku/0.1.2/download" + ], + "strip_prefix": "iana-time-zone-haiku-0.1.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"iana_time_zone_haiku\",\n deps = [\n \"@crates__iana-time-zone-haiku-0.1.2//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=iana-time-zone-haiku\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.2\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n deps = [\n \"@crates__cc-1.2.67//:cc\",\n ],\n emit_warnings = False,\n edition = \"2018\",\n pkg_name = \"iana-time-zone-haiku\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=iana-time-zone-haiku\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.1.2\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + } + }, + "crates__icu_calendar-2.3.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "58655df2f728e46e4eee80bddebefacf52ec3e77cdb925014b47c5a5905eb55c", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/icu_calendar/2.3.0/download" + ], + "strip_prefix": "icu_calendar-2.3.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"icu_calendar\",\n deps = [\n \"@crates__calendrical_calculations-0.2.4//:calendrical_calculations\",\n \"@crates__icu_calendar_data-2.3.0//:icu_calendar_data\",\n \"@crates__icu_locale_core-2.3.0//:icu_locale_core\",\n \"@crates__icu_locale_fallback-2.3.0//:icu_locale_fallback\",\n \"@crates__icu_provider-2.3.1//:icu_provider\",\n \"@crates__tinystr-0.8.4//:tinystr\",\n \"@crates__zerovec-0.11.8//:zerovec\",\n ],\n proc_macro_deps = [\n \"@crates__displaydoc-0.2.7//:displaydoc\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"compiled_data\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=icu_calendar\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.3.0\",\n)\n" + } + }, + "crates__icu_calendar_data-2.3.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "dc00caaa3fb3201ff7a18aa458e8c3ab042b9da154cfdf948bdde3936c31c36e", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/icu_calendar_data/2.3.0/download" + ], + "strip_prefix": "icu_calendar_data-2.3.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"icu_calendar_data\",\n deps = [\n \"@crates__icu_calendar_data-2.3.0//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=icu_calendar_data\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.3.0\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2024\",\n pkg_name = \"icu_calendar_data\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=icu_calendar_data\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"2.3.0\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + } + }, + "crates__icu_collator-2.3.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, @@ -4893,7 +5762,7 @@ "https://static.crates.io/crates/ignore/0.4.33/download" ], "strip_prefix": "ignore-0.4.33", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"ignore\",\n deps = [\n \"@crates__crossbeam-deque-0.8.7//:crossbeam_deque\",\n \"@crates__globset-0.4.20//:globset\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__memchr-2.8.3//:memchr\",\n \"@crates__regex-automata-0.4.18//:regex_automata\",\n \"@crates__same-file-1.0.6//:same_file\",\n \"@crates__walkdir-2.5.0//:walkdir\",\n ] + select({\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__winapi-util-0.1.11//:winapi_util\", # cfg(windows)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=ignore\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.33\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"ignore\",\n deps = [\n \"@crates__crossbeam-deque-0.8.7//:crossbeam_deque\",\n \"@crates__globset-0.4.20//:globset\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__memchr-2.8.3//:memchr\",\n \"@crates__regex-automata-0.4.18//:regex_automata\",\n \"@crates__same-file-1.0.6//:same_file\",\n \"@crates__walkdir-2.5.0//:walkdir\",\n ] + select({\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__winapi-util-0.1.11//:winapi_util\", # cfg(windows)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=ignore\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.33\",\n)\n" } }, "crates__image-0.25.10": { @@ -4922,6 +5791,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"image_webp\",\n deps = [\n \"@crates__byteorder-lite-0.1.0//:byteorder_lite\",\n \"@crates__quick-error-2.0.1//:quick_error\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=image-webp\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.4\",\n)\n" } }, + "crates__imagesize-0.15.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "65b27460c2c92b037f3f94c538ed9a3342f3fdf923606781629ccb35f82d042a", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/imagesize/0.15.0/download" + ], + "strip_prefix": "imagesize-0.15.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"imagesize\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"aesprite\",\n \"astc\",\n \"atc\",\n \"bmp\",\n \"dds\",\n \"default\",\n \"eac\",\n \"etc2\",\n \"exr\",\n \"farbfeld\",\n \"gif\",\n \"hdr\",\n \"heif\",\n \"ico\",\n \"ilbm\",\n \"jpeg\",\n \"jxl\",\n \"ktx2\",\n \"mod\",\n \"png\",\n \"pnm\",\n \"psd\",\n \"pvrtc\",\n \"qoi\",\n \"tga\",\n \"tiff\",\n \"vtf\",\n \"webp\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=imagesize\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.15.0\",\n)\n" + } + }, "crates__include_dir-0.7.4": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -4971,7 +5853,7 @@ "https://static.crates.io/crates/indexmap/2.14.0/download" ], "strip_prefix": "indexmap-2.14.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"indexmap\",\n deps = [\n \"@crates__equivalent-1.0.2//:equivalent\",\n \"@crates__hashbrown-0.17.1//:hashbrown\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=indexmap\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.14.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"indexmap\",\n deps = [\n \"@crates__equivalent-1.0.2//:equivalent\",\n \"@crates__hashbrown-0.17.1//:hashbrown\",\n \"@crates__serde_core-1.0.229//:serde_core\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"serde\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=indexmap\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.14.0\",\n)\n" } }, "crates__indicatif-0.18.6": { @@ -4997,7 +5879,7 @@ "https://static.crates.io/crates/inferno/0.12.8/download" ], "strip_prefix": "inferno-0.12.8", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"inferno\",\n deps = [\n \"@crates__ahash-0.8.12//:ahash\",\n \"@crates__itoa-1.0.18//:itoa\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__num-format-0.4.4//:num_format\",\n \"@crates__once_cell-1.21.4//:once_cell\",\n \"@crates__quick-xml-0.41.0//:quick_xml\",\n \"@crates__rgb-0.8.53//:rgb\",\n \"@crates__str_stack-0.1.1//:str_stack\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=inferno\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.8\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"inferno\",\n deps = [\n \"@crates__ahash-0.8.12//:ahash\",\n \"@crates__itoa-1.0.18//:itoa\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__num-format-0.4.4//:num_format\",\n \"@crates__once_cell-1.21.4//:once_cell\",\n \"@crates__quick-xml-0.41.0//:quick_xml\",\n \"@crates__rgb-0.8.53//:rgb\",\n \"@crates__str_stack-0.1.1//:str_stack\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=inferno\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.8\",\n)\n" } }, "crates__inherent-1.0.14": { @@ -5010,7 +5892,7 @@ "https://static.crates.io/crates/inherent/1.0.14/download" ], "strip_prefix": "inherent-1.0.14", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"inherent\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=inherent\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.14\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"inherent\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=inherent\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.14\",\n)\n" } }, "crates__inotify-0.11.5": { @@ -5075,7 +5957,20 @@ "https://static.crates.io/crates/interceptor/0.17.2/download" ], "strip_prefix": "interceptor-0.17.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"interceptor\",\n deps = [\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__futures-0.3.34//:futures\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__rtcp-0.17.2//:rtcp\",\n \"@crates__rtp-0.17.2//:rtp\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__waitgroup-0.1.2//:waitgroup\",\n \"@crates__webrtc-srtp-0.17.2//:webrtc_srtp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-srtp-0.17.2//:webrtc_srtp\": \"srtp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=interceptor\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"interceptor\",\n deps = [\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__futures-0.3.34//:futures\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__rtcp-0.17.2//:rtcp\",\n \"@crates__rtp-0.17.2//:rtp\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__waitgroup-0.1.2//:waitgroup\",\n \"@crates__webrtc-srtp-0.17.2//:webrtc_srtp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-srtp-0.17.2//:webrtc_srtp\": \"srtp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=interceptor\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" + } + }, + "crates__interim-0.2.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "a9ce9099a85f468663d3225bf87e85d0548968441e1db12248b996b24f0f5b5a", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/interim/0.2.1/download" + ], + "strip_prefix": "interim-0.2.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"interim\",\n deps = [\n \"@crates__chrono-0.4.45//:chrono\",\n \"@crates__logos-0.15.1//:logos\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"chrono_0_4\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=interim\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.1\",\n)\n" } }, "crates__intl-memoizer-0.5.3": { @@ -5104,6 +5999,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"intl_pluralrules\",\n deps = [\n \"@crates__unic-langid-0.9.6//:unic_langid\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=intl_pluralrules\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"7.0.2\",\n)\n" } }, + "crates__io-close-0.3.7": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "9cadcf447f06744f8ce713d2d6239bb5bde2c357a452397a9ed90c625da390bc", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/io-close/0.3.7/download" + ], + "strip_prefix": "io-close-0.3.7", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"io_close\",\n deps = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__winapi-0.3.9//:winapi\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=io-close\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.7\",\n)\n" + } + }, "crates__ipnet-2.12.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -5156,6 +6064,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"itertools\",\n deps = [\n \"@crates__either-1.18.0//:either\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"use_alloc\",\n \"use_std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=itertools\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.0\",\n)\n" } }, + "crates__itertools-0.15.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/itertools/0.15.0/download" + ], + "strip_prefix": "itertools-0.15.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"itertools\",\n deps = [\n \"@crates__either-1.18.0//:either\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"use_alloc\",\n \"use_std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=itertools\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.15.0\",\n)\n" + } + }, "crates__itoa-1.0.18": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -5205,7 +6126,7 @@ "https://static.crates.io/crates/jaq-std/2.1.2/download" ], "strip_prefix": "jaq-std-2.1.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"jaq_std\",\n deps = [\n \"@crates__aho-corasick-1.1.5//:aho_corasick\",\n \"@crates__base64-0.22.1//:base64\",\n \"@crates__chrono-0.4.45//:chrono\",\n \"@crates__jaq-core-2.2.1//:jaq_core\",\n \"@crates__libm-0.2.16//:libm\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__regex-lite-0.1.9//:regex_lite\",\n \"@crates__urlencoding-2.1.3//:urlencoding\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"aho-corasick\",\n \"base64\",\n \"chrono\",\n \"default\",\n \"format\",\n \"libm\",\n \"log\",\n \"math\",\n \"regex\",\n \"regex-lite\",\n \"std\",\n \"time\",\n \"urlencoding\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=jaq-std\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.1.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"jaq_std\",\n deps = [\n \"@crates__aho-corasick-1.1.5//:aho_corasick\",\n \"@crates__base64-0.22.1//:base64\",\n \"@crates__chrono-0.4.45//:chrono\",\n \"@crates__jaq-core-2.2.1//:jaq_core\",\n \"@crates__libm-0.2.16//:libm\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__regex-lite-0.1.9//:regex_lite\",\n \"@crates__urlencoding-2.1.3//:urlencoding\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"aho-corasick\",\n \"base64\",\n \"chrono\",\n \"default\",\n \"format\",\n \"libm\",\n \"log\",\n \"math\",\n \"regex\",\n \"regex-lite\",\n \"std\",\n \"time\",\n \"urlencoding\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=jaq-std\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.1.2\",\n)\n" } }, "crates__jiff-0.2.35": { @@ -5286,6 +6207,32 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"jiff_tzdb_platform\",\n deps = [\n \"@crates__jiff-tzdb-0.1.8//:jiff_tzdb\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=jiff-tzdb-platform\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.3\",\n)\n" } }, + "crates__jj-lib-0.44.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "0d58fe15e3acbc89de606b7a10b284498ed908d09f3b7bdf560ca6f92e3a8d63", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/jj-lib/0.44.0/download" + ], + "strip_prefix": "jj-lib-0.44.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"jj_lib\",\n deps = [\n \"@crates__blake2-0.10.6//:blake2\",\n \"@crates__bstr-1.13.1//:bstr\",\n \"@crates__chrono-0.4.45//:chrono\",\n \"@crates__clru-0.6.3//:clru\",\n \"@crates__digest-0.10.7//:digest\",\n \"@crates__dunce-1.0.5//:dunce\",\n \"@crates__either-1.18.0//:either\",\n \"@crates__etcetera-0.11.0//:etcetera\",\n \"@crates__futures-0.3.34//:futures\",\n \"@crates__gix-0.85.0//:gix\",\n \"@crates__gix-ignore-0.21.1//:gix_ignore\",\n \"@crates__globset-0.4.20//:globset\",\n \"@crates__hashbrown-0.17.1//:hashbrown\",\n \"@crates__indexmap-2.14.0//:indexmap\",\n \"@crates__interim-0.2.1//:interim\",\n \"@crates__itertools-0.15.0//:itertools\",\n \"@crates__maplit-1.0.2//:maplit\",\n \"@crates__memchr-2.8.3//:memchr\",\n \"@crates__once_cell-1.21.4//:once_cell\",\n \"@crates__pest-2.9.0//:pest\",\n \"@crates__pollster-1.0.1//:pollster\",\n \"@crates__prost-0.14.4//:prost\",\n \"@crates__rand-0.10.2//:rand\",\n \"@crates__rand_chacha-0.10.0//:rand_chacha\",\n \"@crates__rayon-1.12.0//:rayon\",\n \"@crates__ref-cast-1.0.27//:ref_cast\",\n \"@crates__regex-1.13.1//:regex\",\n \"@crates__serde-1.0.229//:serde\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n \"@crates__strsim-0.11.1//:strsim\",\n \"@crates__tempfile-3.27.0//:tempfile\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__toml_edit-0.25.13-spec-1.1.0//:toml_edit\",\n \"@crates__tracing-0.1.44//:tracing\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__same-file-1.0.6//:same_file\", # cfg(windows)\n \"@crates__winreg-0.56.0//:winreg\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n \"@crates__jj-lib-proc-macros-0.44.0//:jj_lib_proc_macros\",\n \"@crates__pest_derive-2.9.0//:pest_derive\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"git\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=jj-lib\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.44.0\",\n)\n" + } + }, + "crates__jj-lib-proc-macros-0.44.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "d68a9ec87af36ba808fa818f5f1f041cce01df9eb0e21690e854fe612640060e", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/jj-lib-proc-macros/0.44.0/download" + ], + "strip_prefix": "jj-lib-proc-macros-0.44.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"jj_lib_proc_macros\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=jj-lib-proc-macros\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.44.0\",\n)\n" + } + }, "crates__jobserver-0.1.35": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -5322,7 +6269,7 @@ "https://static.crates.io/crates/keccak/0.1.6/download" ], "strip_prefix": "keccak-0.1.6", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"keccak\",\n deps = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(target_arch = \"aarch64\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(target_arch = \"aarch64\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(target_arch = \"aarch64\")\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=keccak\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.6\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"keccak\",\n deps = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(target_arch = \"aarch64\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(target_arch = \"aarch64\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(target_arch = \"aarch64\")\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"asm\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"asm\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"asm\", # aarch64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=keccak\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.6\",\n)\n" } }, "crates__khronos-egl-6.0.0": { @@ -5377,6 +6324,32 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"kqueue_sys\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__libc-0.2.189//:libc\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=kqueue-sys\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.1.2\",\n)\n" } }, + "crates__kstring-2.0.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "558bf9508a558512042d3095138b1f7b8fe90c5467d94f9f1da28b3731c5dbd1", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/kstring/2.0.2/download" + ], + "strip_prefix": "kstring-2.0.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"kstring\",\n deps = [\n \"@crates__static_assertions-1.1.0//:static_assertions\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n \"unsafe\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=kstring\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.0.2\",\n)\n" + } + }, + "crates__kurbo-0.13.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "4b60dfc32f652b926df6192e55525b16d186c69d47876c3ead4da5cc9f8450e2", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/kurbo/0.13.1/download" + ], + "strip_prefix": "kurbo-0.13.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"kurbo\",\n deps = [\n \"@crates__arrayvec-0.7.8//:arrayvec\",\n \"@crates__polycool-0.4.0//:polycool\",\n \"@crates__smallvec-1.15.2//:smallvec\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=kurbo\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.13.1\",\n)\n" + } + }, "crates__lazy_static-1.5.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -5442,17 +6415,17 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"libm\",\n deps = [\n \"@crates__libm-0.2.16//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"arch\",\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=libm\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.16\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"arch\",\n \"default\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"libm\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=libm\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.2.16\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, - "crates__libredox-0.1.20": { + "crates__libredox-0.1.21": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "28d0a00925a9f930d679b6789b721e3a7f9ed110f41b86d2497caa780c3a070a", + "sha256": "d7955dfc218a8afb29dfeffd540e3a6e96baeb94fe7138228dd7cc6937fbbf96", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/libredox/0.1.20/download" + "https://static.crates.io/crates/libredox/0.1.21/download" ], - "strip_prefix": "libredox-0.1.20", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"libredox\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=libredox\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.20\",\n)\n" + "strip_prefix": "libredox-0.1.21", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"libredox\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=libredox\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.21\",\n)\n" } }, "crates__libspa-0.9.2": { @@ -5553,36 +6526,75 @@ "sha256": "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/litemap/0.8.3/download" + "https://static.crates.io/crates/litemap/0.8.3/download" + ], + "strip_prefix": "litemap-0.8.3", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"litemap\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=litemap\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.3\",\n)\n" + } + }, + "crates__lock_api-0.4.14": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/lock_api/0.4.14/download" + ], + "strip_prefix": "lock_api-0.4.14", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"lock_api\",\n deps = [\n \"@crates__scopeguard-1.2.0//:scopeguard\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"atomic_usize\",\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=lock_api\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.14\",\n)\n" + } + }, + "crates__log-0.4.34": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/log/0.4.34/download" + ], + "strip_prefix": "log-0.4.34", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"log\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=log\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.34\",\n)\n" + } + }, + "crates__logos-0.15.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "ff472f899b4ec2d99161c51f60ff7075eeb3097069a36050d8037a6325eb8154", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/logos/0.15.1/download" ], - "strip_prefix": "litemap-0.8.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"litemap\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=litemap\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.3\",\n)\n" + "strip_prefix": "logos-0.15.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"logos\",\n proc_macro_deps = [\n \"@crates__logos-derive-0.15.1//:logos_derive\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"export_derive\",\n \"logos-derive\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=logos\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.15.1\",\n)\n" } }, - "crates__lock_api-0.4.14": { + "crates__logos-codegen-0.15.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965", + "sha256": "192a3a2b90b0c05b27a0b2c43eecdb7c415e29243acc3f89cc8247a5b693045c", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/lock_api/0.4.14/download" + "https://static.crates.io/crates/logos-codegen/0.15.1/download" ], - "strip_prefix": "lock_api-0.4.14", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"lock_api\",\n deps = [\n \"@crates__scopeguard-1.2.0//:scopeguard\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"atomic_usize\",\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=lock_api\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.14\",\n)\n" + "strip_prefix": "logos-codegen-0.15.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"logos_codegen\",\n deps = [\n \"@crates__beef-0.5.2//:beef\",\n \"@crates__fnv-1.0.7//:fnv\",\n \"@crates__lazy_static-1.5.0//:lazy_static\",\n \"@crates__logos-codegen-0.15.1//:build_script_build\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__regex-syntax-0.8.11//:regex_syntax\",\n \"@crates__syn-2.0.119//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=logos-codegen\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.15.1\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n deps = [\n \"@crates__rustc_version-0.4.1//:rustc_version\",\n ],\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"logos-codegen\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=logos-codegen\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.15.1\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, - "crates__log-0.4.33": { + "crates__logos-derive-0.15.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad", + "sha256": "605d9697bcd5ef3a42d38efc51541aa3d6a4a25f7ab6d1ed0da5ac632a26b470", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/log/0.4.33/download" + "https://static.crates.io/crates/logos-derive/0.15.1/download" ], - "strip_prefix": "log-0.4.33", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"log\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=log\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.33\",\n)\n" + "strip_prefix": "logos-derive-0.15.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"logos_derive\",\n deps = [\n \"@crates__logos-codegen-0.15.1//:logos_codegen\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=logos-derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.15.1\",\n)\n" } }, "crates__lopdf-0.42.0": { @@ -5595,7 +6607,7 @@ "https://static.crates.io/crates/lopdf/0.42.0/download" ], "strip_prefix": "lopdf-0.42.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"lopdf\",\n deps = [\n \"@crates__aes-0.8.4//:aes\",\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__cbc-0.1.2//:cbc\",\n \"@crates__chrono-0.4.45//:chrono\",\n \"@crates__ecb-0.1.2//:ecb\",\n \"@crates__encoding_rs-0.8.35//:encoding_rs\",\n \"@crates__flate2-1.1.9//:flate2\",\n \"@crates__getrandom-0.4.3//:getrandom\",\n \"@crates__indexmap-2.14.0//:indexmap\",\n \"@crates__itoa-1.0.18//:itoa\",\n \"@crates__jiff-0.2.35//:jiff\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__md-5-0.10.6//:md5\",\n \"@crates__nom-8.0.0//:nom\",\n \"@crates__rand-0.10.2//:rand\",\n \"@crates__rangemap-1.8.0//:rangemap\",\n \"@crates__rayon-1.12.0//:rayon\",\n \"@crates__sha2-0.10.9//:sha2\",\n \"@crates__stringprep-0.1.5//:stringprep\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__time-0.3.55//:time\",\n \"@crates__ttf-parser-0.25.1//:ttf_parser\",\n \"@crates__weezl-0.1.12//:weezl\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"chrono\",\n \"default\",\n \"jiff\",\n \"rayon\",\n \"time\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=lopdf\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.42.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"lopdf\",\n deps = [\n \"@crates__aes-0.8.4//:aes\",\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__cbc-0.1.2//:cbc\",\n \"@crates__chrono-0.4.45//:chrono\",\n \"@crates__ecb-0.1.2//:ecb\",\n \"@crates__encoding_rs-0.8.35//:encoding_rs\",\n \"@crates__flate2-1.1.9//:flate2\",\n \"@crates__getrandom-0.4.3//:getrandom\",\n \"@crates__indexmap-2.14.0//:indexmap\",\n \"@crates__itoa-1.0.18//:itoa\",\n \"@crates__jiff-0.2.35//:jiff\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__md-5-0.10.6//:md5\",\n \"@crates__nom-8.0.0//:nom\",\n \"@crates__rand-0.10.2//:rand\",\n \"@crates__rangemap-1.8.0//:rangemap\",\n \"@crates__rayon-1.12.0//:rayon\",\n \"@crates__sha2-0.10.9//:sha2\",\n \"@crates__stringprep-0.1.5//:stringprep\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__time-0.3.55//:time\",\n \"@crates__ttf-parser-0.25.1//:ttf_parser\",\n \"@crates__weezl-0.1.12//:weezl\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"chrono\",\n \"default\",\n \"jiff\",\n \"rayon\",\n \"time\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=lopdf\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.42.0\",\n)\n" } }, "crates__lscolors-0.21.0": { @@ -5611,6 +6623,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"lscolors\",\n deps = [\n \"@crates__aho-corasick-1.1.5//:aho_corasick\",\n \"@crates__nu-ansi-term-0.50.3//:nu_ansi_term\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"gnu_legacy\",\n \"nu-ansi-term\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=lscolors\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.21.0\",\n)\n" } }, + "crates__maplit-1.0.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/maplit/1.0.2/download" + ], + "strip_prefix": "maplit-1.0.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"maplit\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=maplit\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.2\",\n)\n" + } + }, "crates__markup5ever-0.39.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -5621,7 +6646,20 @@ "https://static.crates.io/crates/markup5ever/0.39.0/download" ], "strip_prefix": "markup5ever-0.39.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"markup5ever\",\n deps = [\n \"@crates__log-0.4.33//:log\",\n \"@crates__tendril-0.5.1//:tendril\",\n \"@crates__web_atoms-0.2.6//:web_atoms\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=markup5ever\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.39.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"markup5ever\",\n deps = [\n \"@crates__log-0.4.34//:log\",\n \"@crates__tendril-0.5.1//:tendril\",\n \"@crates__web_atoms-0.2.6//:web_atoms\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=markup5ever\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.39.0\",\n)\n" + } + }, + "crates__maybe-async-0.2.11": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "746873a384ad60adc5db74471dfaba74bd278afbdcfd81db93fafcdfc8b5ca0c", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/maybe-async/0.2.11/download" + ], + "strip_prefix": "maybe-async-0.2.11", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"maybe_async\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-2.0.119//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=maybe-async\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.11\",\n)\n" } }, "crates__md-5-0.10.6": { @@ -5725,7 +6763,7 @@ "https://static.crates.io/crates/mio/1.2.2/download" ], "strip_prefix": "mio-1.2.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"mio\",\n deps = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.33//:log\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.33//:log\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.33//:log\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.33//:log\", # x86_64-apple-darwin\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-sys-0.61.2//:windows_sys\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.33//:log\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.33//:log\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"net\",\n \"os-ext\",\n \"os-poll\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"default\", # aarch64-apple-darwin\n \"log\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"default\", # aarch64-unknown-linux-gnu\n \"log\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"default\", # aarch64-unknown-linux-musl\n \"log\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"default\", # x86_64-apple-darwin\n \"log\", # x86_64-apple-darwin\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"default\", # x86_64-unknown-linux-gnu\n \"log\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"default\", # x86_64-unknown-linux-musl\n \"log\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=mio\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.2.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"mio\",\n deps = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.34//:log\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.34//:log\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.34//:log\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.34//:log\", # x86_64-apple-darwin\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-sys-0.61.2//:windows_sys\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.34//:log\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(any(unix, target_os = \"hermit\", target_os = \"wasi\"))\n \"@crates__log-0.4.34//:log\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"net\",\n \"os-ext\",\n \"os-poll\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"default\", # aarch64-apple-darwin\n \"log\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"default\", # aarch64-unknown-linux-gnu\n \"log\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"default\", # aarch64-unknown-linux-musl\n \"log\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"default\", # x86_64-apple-darwin\n \"log\", # x86_64-apple-darwin\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"default\", # x86_64-unknown-linux-gnu\n \"log\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"default\", # x86_64-unknown-linux-musl\n \"log\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=mio\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.2.2\",\n)\n" } }, "crates__moxcms-0.8.1": { @@ -5962,6 +7000,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"nom\",\n deps = [\n \"@crates__memchr-2.8.3//:memchr\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=nom\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"8.0.0\",\n)\n" } }, + "crates__nonempty-0.12.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "9737e026353e5cd0736f98eddae28665118eb6f6600902a7f50db585621fecb6", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/nonempty/0.12.0/download" + ], + "strip_prefix": "nonempty-0.12.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"nonempty\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=nonempty\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.0\",\n)\n" + } + }, "crates__normalize-path-0.2.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -5985,7 +7036,7 @@ "https://static.crates.io/crates/notify/8.2.0/download" ], "strip_prefix": "notify-8.2.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"notify\",\n deps = [\n \"@crates__libc-0.2.189//:libc\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__notify-types-2.1.0//:notify_types\",\n \"@crates__walkdir-2.5.0//:walkdir\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__bitflags-2.13.1//:bitflags\", # cfg(target_os = \"macos\")\n \"@crates__fsevent-sys-4.1.0//:fsevent_sys\", # aarch64-apple-darwin\n \"@crates__kqueue-1.2.1//:kqueue\", # aarch64-apple-darwin\n \"@crates__mio-1.2.2//:mio\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__inotify-0.11.5//:inotify\", # cfg(any(target_os = \"linux\", target_os = \"android\"))\n \"@crates__mio-1.2.2//:mio\", # aarch64-unknown-linux-gnu, cfg(any(target_os = \"linux\", target_os = \"android\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__inotify-0.11.5//:inotify\", # cfg(any(target_os = \"linux\", target_os = \"android\"))\n \"@crates__mio-1.2.2//:mio\", # aarch64-unknown-linux-musl, cfg(any(target_os = \"linux\", target_os = \"android\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__bitflags-2.13.1//:bitflags\", # cfg(target_os = \"macos\")\n \"@crates__fsevent-sys-4.1.0//:fsevent_sys\", # x86_64-apple-darwin\n \"@crates__kqueue-1.2.1//:kqueue\", # x86_64-apple-darwin\n \"@crates__mio-1.2.2//:mio\", # x86_64-apple-darwin\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-sys-0.60.2//:windows_sys\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__inotify-0.11.5//:inotify\", # cfg(any(target_os = \"linux\", target_os = \"android\"))\n \"@crates__mio-1.2.2//:mio\", # cfg(any(target_os = \"linux\", target_os = \"android\")), x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__inotify-0.11.5//:inotify\", # cfg(any(target_os = \"linux\", target_os = \"android\"))\n \"@crates__mio-1.2.2//:mio\", # cfg(any(target_os = \"linux\", target_os = \"android\")), x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"fsevent-sys\",\n \"macos_fsevent\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"kqueue\", # aarch64-apple-darwin\n \"macos_kqueue\", # aarch64-apple-darwin\n \"mio\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"kqueue\", # aarch64-unknown-linux-gnu\n \"macos_kqueue\", # aarch64-unknown-linux-gnu\n \"mio\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"kqueue\", # aarch64-unknown-linux-musl\n \"macos_kqueue\", # aarch64-unknown-linux-musl\n \"mio\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"kqueue\", # x86_64-apple-darwin\n \"macos_kqueue\", # x86_64-apple-darwin\n \"mio\", # x86_64-apple-darwin\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"kqueue\", # x86_64-unknown-linux-gnu\n \"macos_kqueue\", # x86_64-unknown-linux-gnu\n \"mio\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"kqueue\", # x86_64-unknown-linux-musl\n \"macos_kqueue\", # x86_64-unknown-linux-musl\n \"mio\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=notify\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"8.2.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"notify\",\n deps = [\n \"@crates__libc-0.2.189//:libc\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__notify-types-2.1.0//:notify_types\",\n \"@crates__walkdir-2.5.0//:walkdir\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__bitflags-2.13.1//:bitflags\", # cfg(target_os = \"macos\")\n \"@crates__fsevent-sys-4.1.0//:fsevent_sys\", # aarch64-apple-darwin\n \"@crates__kqueue-1.2.1//:kqueue\", # aarch64-apple-darwin\n \"@crates__mio-1.2.2//:mio\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__inotify-0.11.5//:inotify\", # cfg(any(target_os = \"linux\", target_os = \"android\"))\n \"@crates__mio-1.2.2//:mio\", # aarch64-unknown-linux-gnu, cfg(any(target_os = \"linux\", target_os = \"android\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__inotify-0.11.5//:inotify\", # cfg(any(target_os = \"linux\", target_os = \"android\"))\n \"@crates__mio-1.2.2//:mio\", # aarch64-unknown-linux-musl, cfg(any(target_os = \"linux\", target_os = \"android\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__bitflags-2.13.1//:bitflags\", # cfg(target_os = \"macos\")\n \"@crates__fsevent-sys-4.1.0//:fsevent_sys\", # x86_64-apple-darwin\n \"@crates__kqueue-1.2.1//:kqueue\", # x86_64-apple-darwin\n \"@crates__mio-1.2.2//:mio\", # x86_64-apple-darwin\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__windows-sys-0.60.2//:windows_sys\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__inotify-0.11.5//:inotify\", # cfg(any(target_os = \"linux\", target_os = \"android\"))\n \"@crates__mio-1.2.2//:mio\", # cfg(any(target_os = \"linux\", target_os = \"android\")), x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__inotify-0.11.5//:inotify\", # cfg(any(target_os = \"linux\", target_os = \"android\"))\n \"@crates__mio-1.2.2//:mio\", # cfg(any(target_os = \"linux\", target_os = \"android\")), x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"fsevent-sys\",\n \"macos_fsevent\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"kqueue\", # aarch64-apple-darwin\n \"macos_kqueue\", # aarch64-apple-darwin\n \"mio\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"kqueue\", # aarch64-unknown-linux-gnu\n \"macos_kqueue\", # aarch64-unknown-linux-gnu\n \"mio\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"kqueue\", # aarch64-unknown-linux-musl\n \"macos_kqueue\", # aarch64-unknown-linux-musl\n \"mio\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"kqueue\", # x86_64-apple-darwin\n \"macos_kqueue\", # x86_64-apple-darwin\n \"mio\", # x86_64-apple-darwin\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"kqueue\", # x86_64-unknown-linux-gnu\n \"macos_kqueue\", # x86_64-unknown-linux-gnu\n \"mio\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"kqueue\", # x86_64-unknown-linux-musl\n \"macos_kqueue\", # x86_64-unknown-linux-musl\n \"mio\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=notify\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"8.2.0\",\n)\n" } }, "crates__notify-types-2.1.0": { @@ -6687,7 +7738,7 @@ "https://static.crates.io/crates/pcre2/0.2.11/download" ], "strip_prefix": "pcre2-0.2.11", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"pcre2\",\n deps = [\n \"@crates__libc-0.2.189//:libc\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__pcre2-sys-0.2.10//:pcre2_sys\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=pcre2\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.11\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"pcre2\",\n deps = [\n \"@crates__libc-0.2.189//:libc\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__pcre2-sys-0.2.10//:pcre2_sys\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=pcre2\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.11\",\n)\n" } }, "crates__pcre2-sys-0.2.10": { @@ -6713,7 +7764,7 @@ "https://static.crates.io/crates/pdf-inspector/1.17.0/download" ], "strip_prefix": "pdf-inspector-1.17.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"pdf_inspector\",\n deps = [\n \"@crates__log-0.4.33//:log\",\n \"@crates__once_cell-1.21.4//:once_cell\",\n \"@crates__regex-1.13.1//:regex\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__ttf-parser-0.25.1//:ttf_parser\",\n \"@crates__unicode-normalization-0.1.25//:unicode_normalization\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=pdf-inspector\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.17.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"pdf_inspector\",\n deps = [\n \"@crates__log-0.4.34//:log\",\n \"@crates__once_cell-1.21.4//:once_cell\",\n \"@crates__regex-1.13.1//:regex\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__ttf-parser-0.25.1//:ttf_parser\",\n \"@crates__unicode-normalization-0.1.25//:unicode_normalization\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__env_logger-0.11.11//:env_logger\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__lopdf-0.42.0//:lopdf\", # cfg(not(target_arch = \"wasm32\"))\n \"@crates__rayon-1.12.0//:rayon\", # cfg(not(target_arch = \"wasm32\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=pdf-inspector\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.17.0\",\n)\n" } }, "crates__peg-0.8.6": { @@ -6791,7 +7842,7 @@ "https://static.crates.io/crates/percent-encoding/2.3.2/download" ], "strip_prefix": "percent-encoding-2.3.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"percent_encoding\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"std\",\n ] + select({\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"default\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"default\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"default\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"default\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=percent-encoding\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.3.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"percent_encoding\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=percent-encoding\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.3.2\",\n)\n" } }, "crates__pest-2.9.0": { @@ -6934,7 +7985,7 @@ "https://static.crates.io/crates/phf_generator/0.11.3/download" ], "strip_prefix": "phf_generator-0.11.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"phf_generator\",\n deps = [\n \"@crates__phf_shared-0.11.3//:phf_shared\",\n \"@crates__rand-0.8.7//:rand\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=phf_generator\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.11.3\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"phf_generator\",\n deps = [\n \"@crates__phf_shared-0.11.3//:phf_shared\",\n \"@crates__rand-0.8.8//:rand\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=phf_generator\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.11.3\",\n)\n" } }, "crates__phf_generator-0.13.1": { @@ -7028,6 +8079,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"phf_shared\",\n deps = [\n \"@crates__siphasher-1.0.3//:siphasher\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=phf_shared\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.0\",\n)\n" } }, + "crates__pico-args-0.5.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/pico-args/0.5.0/download" + ], + "strip_prefix": "pico-args-0.5.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"pico_args\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"eq-separator\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=pico-args\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.0\",\n)\n" + } + }, "crates__pin-project-lite-0.2.17": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -7142,7 +8206,7 @@ "https://static.crates.io/crates/png/0.18.1/download" ], "strip_prefix": "png-0.18.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"png\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__crc32fast-1.5.0//:crc32fast\",\n \"@crates__fdeflate-0.3.7//:fdeflate\",\n \"@crates__flate2-1.1.9//:flate2\",\n \"@crates__miniz_oxide-0.8.9//:miniz_oxide\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=png\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.18.1\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"png\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__crc32fast-1.5.1//:crc32fast\",\n \"@crates__fdeflate-0.3.7//:fdeflate\",\n \"@crates__flate2-1.1.9//:flate2\",\n \"@crates__miniz_oxide-0.8.9//:miniz_oxide\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=png\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.18.1\",\n)\n" } }, "crates__polling-3.11.0": { @@ -7158,6 +8222,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"polling\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(any(unix, target_os = \"fuchsia\", target_os = \"vxworks\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(any(unix, target_os = \"fuchsia\", target_os = \"vxworks\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(any(unix, target_os = \"fuchsia\", target_os = \"vxworks\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(any(unix, target_os = \"fuchsia\", target_os = \"vxworks\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__concurrent-queue-2.5.0//:concurrent_queue\", # cfg(windows)\n \"@crates__pin-project-lite-0.2.17//:pin_project_lite\", # cfg(windows)\n \"@crates__windows-sys-0.61.2//:windows_sys\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(any(unix, target_os = \"fuchsia\", target_os = \"vxworks\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__rustix-1.1.4//:rustix\", # cfg(any(unix, target_os = \"fuchsia\", target_os = \"vxworks\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=polling\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.11.0\",\n)\n" } }, + "crates__pollster-1.0.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "bc6355899e1c9462875b6757c79f3caa011a1fdae12bbb1a2e72dd1f234f8336", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/pollster/1.0.1/download" + ], + "strip_prefix": "pollster-1.0.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"pollster\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=pollster\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.1\",\n)\n" + } + }, "crates__poly1305-0.8.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -7171,6 +8248,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"poly1305\",\n deps = [\n \"@crates__opaque-debug-0.3.1//:opaque_debug\",\n \"@crates__universal-hash-0.5.1//:universal_hash\",\n ] + select({\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=poly1305\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.0\",\n)\n" } }, + "crates__polycool-0.4.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "50596ddc09eb5ad5f75cacd40209568e66df71baf86e1499a0e99c4cff12a5a6", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/polycool/0.4.0/download" + ], + "strip_prefix": "polycool-0.4.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"polycool\",\n deps = [\n \"@crates__arrayvec-0.7.8//:arrayvec\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=polycool\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.0\",\n)\n" + } + }, "crates__polyval-0.6.2": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -7220,7 +8310,7 @@ "https://static.crates.io/crates/portable-pty/0.9.0/download" ], "strip_prefix": "portable-pty-0.9.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"portable_pty\",\n deps = [\n \"@crates__anyhow-1.0.104//:anyhow\",\n \"@crates__downcast-rs-1.2.1//:downcast_rs\",\n \"@crates__filedescriptor-0.8.3//:filedescriptor\",\n \"@crates__libc-0.2.189//:libc\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__nix-0.28.0//:nix\",\n \"@crates__serial2-0.2.38//:serial2\",\n \"@crates__shell-words-1.1.1//:shell_words\",\n ] + select({\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__bitflags-1.3.2//:bitflags\", # cfg(windows)\n \"@crates__lazy_static-1.5.0//:lazy_static\", # cfg(windows)\n \"@crates__shared_library-0.1.9//:shared_library\", # cfg(windows)\n \"@crates__winapi-0.3.9//:winapi\", # cfg(windows)\n \"@crates__winreg-0.10.1//:winreg\", # cfg(windows)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=portable-pty\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"portable_pty\",\n deps = [\n \"@crates__anyhow-1.0.104//:anyhow\",\n \"@crates__downcast-rs-1.2.1//:downcast_rs\",\n \"@crates__filedescriptor-0.8.3//:filedescriptor\",\n \"@crates__libc-0.2.189//:libc\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__nix-0.28.0//:nix\",\n \"@crates__serial2-0.2.38//:serial2\",\n \"@crates__shell-words-1.1.1//:shell_words\",\n ] + select({\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__bitflags-1.3.2//:bitflags\", # cfg(windows)\n \"@crates__lazy_static-1.5.0//:lazy_static\", # cfg(windows)\n \"@crates__shared_library-0.1.9//:shared_library\", # cfg(windows)\n \"@crates__winapi-0.3.9//:winapi\", # cfg(windows)\n \"@crates__winreg-0.10.1//:winreg\", # cfg(windows)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=portable-pty\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.0\",\n)\n" } }, "crates__potential_utf-0.1.6": { @@ -7288,17 +8378,17 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"pretty_assertions\",\n deps = [\n \"@crates__diff-0.1.13//:diff\",\n \"@crates__yansi-1.0.1//:yansi\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n \"unstable\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=pretty_assertions\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.4.1\",\n)\n" } }, - "crates__prettyplease-0.2.37": { + "crates__prettyplease-0.3.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b", + "sha256": "2bfe0f4c752e450fc2faf62654f1c134747922825d5b04ca717b8874f41a40c0", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/prettyplease/0.2.37/download" + "https://static.crates.io/crates/prettyplease/0.3.0/download" ], - "strip_prefix": "prettyplease-0.2.37", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"prettyplease\",\n deps = [\n \"@crates__prettyplease-0.2.37//:build_script_build\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__syn-2.0.119//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=prettyplease\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.37\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n links = \"prettyplease02\",\n pkg_name = \"prettyplease\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=prettyplease\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.2.37\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "strip_prefix": "prettyplease-0.3.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"prettyplease\",\n deps = [\n \"@crates__prettyplease-0.3.0//:build_script_build\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=prettyplease\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.0\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n links = \"prettyplease03\",\n pkg_name = \"prettyplease\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=prettyplease\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.3.0\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, "crates__primeorder-0.13.6": { @@ -7366,6 +8456,45 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"procfs_core\",\n deps = [\n \"@crates__bitflags-2.13.1//:bitflags\",\n \"@crates__chrono-0.4.45//:chrono\",\n \"@crates__hex-0.4.3//:hex\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"chrono\",\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=procfs-core\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.18.0\",\n)\n" } }, + "crates__prodash-31.0.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "962200e2d7d551451297d9fdce85138374019ada198e30ea9ede38034e27604c", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/prodash/31.0.0/download" + ], + "strip_prefix": "prodash-31.0.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"prodash\",\n deps = [\n \"@crates__parking_lot-0.12.5//:parking_lot\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"parking_lot\",\n \"progress-tree\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=prodash\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"31.0.0\",\n)\n" + } + }, + "crates__prost-0.14.4": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "528ac67416ff8646872a3c02cad9cc4ee5dc9f9540c9b10771855c95cb2e5ae1", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/prost/0.14.4/download" + ], + "strip_prefix": "prost-0.14.4", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"prost\",\n deps = [\n \"@crates__bytes-1.12.1//:bytes\",\n ],\n proc_macro_deps = [\n \"@crates__prost-derive-0.14.4//:prost_derive\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"derive\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=prost\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.4\",\n)\n" + } + }, + "crates__prost-derive-0.14.4": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/prost-derive/0.14.4/download" + ], + "strip_prefix": "prost-derive-0.14.4", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"prost_derive\",\n deps = [\n \"@crates__anyhow-1.0.104//:anyhow\",\n \"@crates__itertools-0.14.0//:itertools\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-2.0.119//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=prost-derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.14.4\",\n)\n" + } + }, "crates__ptr_meta-0.3.2": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -7389,7 +8518,7 @@ "https://static.crates.io/crates/ptr_meta_derive/0.3.2/download" ], "strip_prefix": "ptr_meta_derive-0.3.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"ptr_meta_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=ptr_meta_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"ptr_meta_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=ptr_meta_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.2\",\n)\n" } }, "crates__pxfm-0.1.30": { @@ -7415,7 +8544,7 @@ "https://static.crates.io/crates/quantette/0.6.0/download" ], "strip_prefix": "quantette-0.6.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"quantette\",\n deps = [\n \"@crates__bitvec-1.1.1//:bitvec\",\n \"@crates__bytemuck-1.25.2//:bytemuck\",\n \"@crates__libm-0.2.16//:libm\",\n \"@crates__num-traits-0.2.19//:num_traits\",\n \"@crates__ordered-float-5.4.0//:ordered_float\",\n \"@crates__palette-0.7.7//:palette\",\n \"@crates__rand-0.10.2//:rand\",\n \"@crates__rand_xoshiro-0.8.1//:rand_xoshiro\",\n \"@crates__ref-cast-1.0.27//:ref_cast\",\n \"@crates__wide-1.6.1//:wide\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"kmeans\",\n \"rand\",\n \"rand_xoshiro\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=quantette\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.6.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"quantette\",\n deps = [\n \"@crates__bitvec-1.1.1//:bitvec\",\n \"@crates__bytemuck-1.25.2//:bytemuck\",\n \"@crates__libm-0.2.16//:libm\",\n \"@crates__num-traits-0.2.19//:num_traits\",\n \"@crates__ordered-float-5.4.0//:ordered_float\",\n \"@crates__palette-0.7.7//:palette\",\n \"@crates__rand-0.10.2//:rand\",\n \"@crates__rand_xoshiro-0.8.1//:rand_xoshiro\",\n \"@crates__ref-cast-1.0.27//:ref_cast\",\n \"@crates__wide-1.7.0//:wide\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"kmeans\",\n \"rand\",\n \"rand_xoshiro\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=quantette\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.6.0\",\n)\n" } }, "crates__quick-error-2.0.1": { @@ -7509,17 +8638,17 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"rancor\",\n deps = [\n \"@crates__ptr_meta-0.3.2//:ptr_meta\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rancor\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.3\",\n)\n" } }, - "crates__rand-0.8.7": { + "crates__rand-0.8.8": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "22f6172bdec972074665ed81ed53b71da00bfc44b65a753cfde883ec4c702a1a", + "sha256": "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/rand/0.8.7/download" + "https://static.crates.io/crates/rand/0.8.8/download" ], - "strip_prefix": "rand-0.8.7", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"rand\",\n deps = [\n \"@crates__rand_core-0.6.4//:rand_core\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"small_rng\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rand\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.7\",\n)\n" + "strip_prefix": "rand-0.8.8", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"rand\",\n deps = [\n \"@crates__rand_core-0.6.4//:rand_core\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"small_rng\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rand\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.8\",\n)\n" } }, "crates__rand-0.9.5": { @@ -7545,7 +8674,7 @@ "https://static.crates.io/crates/rand/0.10.2/download" ], "strip_prefix": "rand-0.10.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"rand\",\n deps = [\n \"@crates__chacha20-0.10.1//:chacha20\",\n \"@crates__getrandom-0.4.3//:getrandom\",\n \"@crates__rand_core-0.10.1//:rand_core\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n \"std_rng\",\n \"sys_rng\",\n \"thread_rng\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rand\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"rand\",\n deps = [\n \"@crates__chacha20-0.10.2//:chacha20\",\n \"@crates__getrandom-0.4.3//:getrandom\",\n \"@crates__rand_core-0.10.1//:rand_core\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n \"std_rng\",\n \"sys_rng\",\n \"thread_rng\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rand\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.2\",\n)\n" } }, "crates__rand_chacha-0.9.0": { @@ -7561,6 +8690,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"rand_chacha\",\n deps = [\n \"@crates__ppv-lite86-0.2.21//:ppv_lite86\",\n \"@crates__rand_core-0.9.5//:rand_core\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rand_chacha\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.0\",\n)\n" } }, + "crates__rand_chacha-0.10.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "3e6af7f3e25ded52c41df4e0b1af2d047e45896c2f3281792ed68a1c243daedb", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/rand_chacha/0.10.0/download" + ], + "strip_prefix": "rand_chacha-0.10.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"rand_chacha\",\n deps = [\n \"@crates__ppv-lite86-0.2.21//:ppv_lite86\",\n \"@crates__rand_core-0.10.1//:rand_core\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rand_chacha\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.0\",\n)\n" + } + }, "crates__rand_core-0.6.4": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -7665,6 +8807,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"rcgen\",\n deps = [\n \"@crates__pem-3.0.6//:pem\",\n \"@crates__ring-0.17.14//:ring\",\n \"@crates__rustls-pki-types-1.15.1//:rustls_pki_types\",\n \"@crates__time-0.3.55//:time\",\n \"@crates__x509-parser-0.16.0//:x509_parser\",\n \"@crates__yasna-0.5.2//:yasna\",\n ],\n aliases = {\n \"@crates__rustls-pki-types-1.15.1//:rustls_pki_types\": \"pki_types\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"crypto\",\n \"default\",\n \"pem\",\n \"ring\",\n \"x509-parser\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rcgen\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.13.2\",\n)\n" } }, + "crates__read-fonts-0.41.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "046a7d674daf459825b32f5062056d6882db0d2f5a479fbd76ccfc870ac18709", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/read-fonts/0.41.0/download" + ], + "strip_prefix": "read-fonts-0.41.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"read_fonts\",\n deps = [\n \"@crates__bytemuck-1.25.2//:bytemuck\",\n \"@crates__font-types-0.12.4//:font_types\",\n \"@crates__once_cell-1.21.4//:once_cell\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"experimental_font_api\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=read-fonts\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.41.0\",\n)\n" + } + }, "crates__redox_syscall-0.5.18": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -7701,7 +8856,7 @@ "https://static.crates.io/crates/ref-cast-impl/1.0.27/download" ], "strip_prefix": "ref-cast-impl-1.0.27", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"ref_cast_impl\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=ref-cast-impl\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.27\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"ref_cast_impl\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=ref-cast-impl\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.27\",\n)\n" } }, "crates__regex-1.13.1": { @@ -7782,6 +8937,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"rend\",\n deps = [\n \"@crates__bytecheck-0.8.3//:bytecheck\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"bytecheck\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rend\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.4\",\n)\n" } }, + "crates__resvg-0.48.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "67e3803f97b999e80cbf7c6ecdd07a8102204d92e1633cf48783720c521196bd", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/resvg/0.48.1/download" + ], + "strip_prefix": "resvg-0.48.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"resvg\",\n deps = [\n \"@crates__bytemuck-1.25.2//:bytemuck\",\n \"@crates__gif-0.14.2//:gif\",\n \"@crates__image-webp-0.2.4//:image_webp\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__pico-args-0.5.0//:pico_args\",\n \"@crates__rgb-0.8.53//:rgb\",\n \"@crates__svgtypes-0.16.1//:svgtypes\",\n \"@crates__tiny-skia-0.12.0//:tiny_skia\",\n \"@crates__usvg-0.48.1//:usvg\",\n \"@crates__zune-jpeg-0.5.15//:zune_jpeg\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"gif\",\n \"image-webp\",\n \"memmap-fonts\",\n \"raster-images\",\n \"svgz\",\n \"system-fonts\",\n \"text\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=resvg\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.48.1\",\n)\n" + } + }, "crates__rfc6979-0.4.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -7844,7 +9012,7 @@ "https://static.crates.io/crates/rkyv_derive/0.8.18/download" ], "strip_prefix": "rkyv_derive-0.8.18", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"rkyv_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"bytecheck\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rkyv_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.18\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"rkyv_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"bytecheck\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rkyv_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.18\",\n)\n" } }, "crates__rlimit-0.11.0": { @@ -7860,6 +9028,32 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"rlimit\",\n deps = [\n \"@crates__libc-0.2.189//:libc\",\n \"@crates__rlimit-0.11.0//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rlimit\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.11.0\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"rlimit\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=rlimit\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.11.0\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, + "crates__roxmltree-0.20.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/roxmltree/0.20.0/download" + ], + "strip_prefix": "roxmltree-0.20.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"roxmltree\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"positions\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=roxmltree\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.20.0\",\n)\n" + } + }, + "crates__roxmltree-0.21.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "f1964b10c76125c36f8afe190065a4bf9a87bf324842c05701330bba9f1cacbb", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/roxmltree/0.21.1/download" + ], + "strip_prefix": "roxmltree-0.21.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"roxmltree\",\n deps = [\n \"@crates__memchr-2.8.3//:memchr\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"positions\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=roxmltree\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.21.1\",\n)\n" + } + }, "crates__rpds-1.2.1": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -8143,7 +9337,7 @@ "https://static.crates.io/crates/serde/1.0.229/download" ], "strip_prefix": "serde-1.0.229", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"serde\",\n deps = [\n \"@crates__serde-1.0.229//:build_script_build\",\n \"@crates__serde_core-1.0.229//:serde_core\",\n ],\n proc_macro_deps = [\n \"@crates__serde_derive-1.0.229//:serde_derive\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"derive\",\n \"serde_derive\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.229\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"derive\",\n \"serde_derive\",\n \"std\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"serde\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"1.0.229\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"serde\",\n deps = [\n \"@crates__serde-1.0.229//:build_script_build\",\n \"@crates__serde_core-1.0.229//:serde_core\",\n ],\n proc_macro_deps = [\n \"@crates__serde_derive-1.0.229//:serde_derive\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"derive\",\n \"rc\",\n \"serde_derive\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.229\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"derive\",\n \"rc\",\n \"serde_derive\",\n \"std\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"serde\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"1.0.229\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, "crates__serde_core-1.0.229": { @@ -8156,7 +9350,7 @@ "https://static.crates.io/crates/serde_core/1.0.229/download" ], "strip_prefix": "serde_core-1.0.229", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"serde_core\",\n deps = [\n \"@crates__serde_core-1.0.229//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"result\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde_core\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.229\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"result\",\n \"std\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"serde_core\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde_core\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"1.0.229\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"serde_core\",\n deps = [\n \"@crates__serde_core-1.0.229//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"rc\",\n \"result\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde_core\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.229\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"rc\",\n \"result\",\n \"std\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2021\",\n pkg_name = \"serde_core\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde_core\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"1.0.229\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, "crates__serde_derive-1.0.229": { @@ -8169,7 +9363,7 @@ "https://static.crates.io/crates/serde_derive/1.0.229/download" ], "strip_prefix": "serde_derive-1.0.229", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"serde_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.229\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"serde_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.229\",\n)\n" } }, "crates__serde_json-1.0.151": { @@ -8195,7 +9389,7 @@ "https://static.crates.io/crates/serde_repr/0.1.21/download" ], "strip_prefix": "serde_repr-0.1.21", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"serde_repr\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde_repr\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.21\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"serde_repr\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde_repr\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.21\",\n)\n" } }, "crates__serde_spanned-1.1.1": { @@ -8208,7 +9402,7 @@ "https://static.crates.io/crates/serde_spanned/1.1.1/download" ], "strip_prefix": "serde_spanned-1.1.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"serde_spanned\",\n deps = [\n \"@crates__serde_core-1.0.229//:serde_core\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"serde\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde_spanned\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.1.1\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"serde_spanned\",\n deps = [\n \"@crates__serde_core-1.0.229//:serde_core\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"serde\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=serde_spanned\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.1.1\",\n)\n" } }, "crates__serial2-0.2.38": { @@ -8234,7 +9428,20 @@ "https://static.crates.io/crates/sha1/0.10.7/download" ], "strip_prefix": "sha1-0.10.7", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"sha1\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__digest-0.10.7//:digest\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=sha1\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.7\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"sha1\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__digest-0.10.7//:digest\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86\", target_arch = \"x86_64\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"compress\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=sha1\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.7\",\n)\n" + } + }, + "crates__sha1-checked-0.10.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "89f599ac0c323ebb1c6082821a54962b839832b03984598375bff3975b804423", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/sha1-checked/0.10.0/download" + ], + "strip_prefix": "sha1-checked-0.10.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"sha1_checked\",\n deps = [\n \"@crates__digest-0.10.7//:digest\",\n \"@crates__sha1-0.10.7//:sha1\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=sha1-checked\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.0\",\n)\n" } }, "crates__sha2-0.10.9": { @@ -8247,7 +9454,33 @@ "https://static.crates.io/crates/sha2/0.10.9/download" ], "strip_prefix": "sha2-0.10.9", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"sha2\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__digest-0.10.7//:digest\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=sha2\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.9\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"sha2\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__digest-0.10.7//:digest\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n \"@crates__sha2-asm-0.6.4//:sha2_asm\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n \"@crates__sha2-asm-0.6.4//:sha2_asm\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n \"@crates__sha2-asm-0.6.4//:sha2_asm\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.2.17//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"asm\", # aarch64-apple-darwin\n \"sha2-asm\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"asm\", # aarch64-unknown-linux-gnu\n \"sha2-asm\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"asm\", # aarch64-unknown-linux-musl\n \"sha2-asm\", # aarch64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=sha2\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.9\",\n)\n" + } + }, + "crates__sha2-0.11.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/sha2/0.11.0/download" + ], + "strip_prefix": "sha2-0.11.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"sha2\",\n deps = [\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__digest-0.11.3//:digest\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__cpufeatures-0.3.1//:cpufeatures\", # cfg(any(target_arch = \"aarch64\", target_arch = \"x86_64\", target_arch = \"x86\"))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=sha2\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.11.0\",\n)\n" + } + }, + "crates__sha2-asm-0.6.4": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "b845214d6175804686b2bd482bcffe96651bb2d1200742b712003504a2dac1ab", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/sha2-asm/0.6.4/download" + ], + "strip_prefix": "sha2-asm-0.6.4", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"sha2_asm\",\n deps = [\n \"@crates__sha2-asm-0.6.4//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=sha2-asm\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.6.4\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n build_script_env = {\n \"CC_aarch64_unknown_linux_gnu\": \"$${pwd}/bazel/toolchains/sha2-asm-cc.sh\",\n \"CC_aarch64_unknown_linux_musl\": \"$${pwd}/bazel/toolchains/sha2-asm-cc.sh\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ) + [\n \"@@//bazel/toolchains:sha2-asm-cc.sh\",\n ],\n deps = [\n \"@crates__cc-1.2.67//:cc\",\n ],\n emit_warnings = False,\n edition = \"2018\",\n pkg_name = \"sha2-asm\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=sha2-asm\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.6.4\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, "crates__sha3-0.10.9": { @@ -8260,7 +9493,7 @@ "https://static.crates.io/crates/sha3/0.10.9/download" ], "strip_prefix": "sha3-0.10.9", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"sha3\",\n deps = [\n \"@crates__digest-0.10.7//:digest\",\n \"@crates__keccak-0.1.6//:keccak\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=sha3\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.9\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"sha3\",\n deps = [\n \"@crates__digest-0.10.7//:digest\",\n \"@crates__keccak-0.1.6//:keccak\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"asm\", # aarch64-apple-darwin\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"asm\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"asm\", # aarch64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=sha3\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.10.9\",\n)\n" } }, "crates__shared_library-0.1.9": { @@ -8393,6 +9626,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"similar\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n \"text\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=similar\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.2.0\",\n)\n" } }, + "crates__simplecss-0.2.2": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "7a9c6883ca9c3c7c90e888de77b7a5c849c779d25d74a1269b0218b14e8b136c", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/simplecss/0.2.2/download" + ], + "strip_prefix": "simplecss-0.2.2", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"simplecss\",\n deps = [\n \"@crates__log-0.4.34//:log\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=simplecss\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.2.2\",\n)\n" + } + }, "crates__siphasher-1.0.3": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -8406,6 +9652,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"siphasher\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=siphasher\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.0.3\",\n)\n" } }, + "crates__skrifa-0.44.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "819ab7d62b1d3e72d9d9dea5650bac30424f9111364bb94928dbf5ecad1baa68", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/skrifa/0.44.0/download" + ], + "strip_prefix": "skrifa-0.44.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"skrifa\",\n deps = [\n \"@crates__bytemuck-1.25.2//:bytemuck\",\n \"@crates__read-fonts-0.41.0//:read_fonts\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=skrifa\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.44.0\",\n)\n" + } + }, "crates__slab-0.4.12": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -8419,6 +9678,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"slab\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=slab\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.4.12\",\n)\n" } }, + "crates__slotmap-1.1.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "bdd58c3c93c3d278ca835519292445cb4b0d4dc59ccfdf7ceadaab3f8aeb4038", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/slotmap/1.1.1/download" + ], + "strip_prefix": "slotmap-1.1.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"slotmap\",\n deps = [\n \"@crates__slotmap-1.1.1//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=slotmap\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.1.1\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n deps = [\n \"@crates__version_check-0.9.5//:version_check\",\n ],\n emit_warnings = False,\n edition = \"2018\",\n pkg_name = \"slotmap\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=slotmap\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"1.1.1\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + } + }, "crates__sm3-0.5.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -8575,6 +9847,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"streaming_iterator\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=streaming-iterator\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.9\",\n)\n" } }, + "crates__strict-num-0.1.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "6637bab7722d379c8b41ba849228d680cc12d0a45ba1fa2b48f2a30577a06731", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/strict-num/0.1.1/download" + ], + "strip_prefix": "strict-num-0.1.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"strict_num\",\n deps = [\n \"@crates__float-cmp-0.9.0//:float_cmp\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"approx-eq\",\n \"default\",\n \"float-cmp\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=strict-num\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.1\",\n)\n" + } + }, "crates__string_cache-0.9.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -8692,6 +9977,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"subtle\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"i128\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=subtle\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.6.1\",\n)\n" } }, + "crates__svgtypes-0.16.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "695b5790b3131dafa99b3bbfd25a216edb3d216dad9ca208d4657bfb8f2abc3d", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/svgtypes/0.16.1/download" + ], + "strip_prefix": "svgtypes-0.16.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"svgtypes\",\n deps = [\n \"@crates__kurbo-0.13.1//:kurbo\",\n \"@crates__siphasher-1.0.3//:siphasher\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=svgtypes\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.16.1\",\n)\n" + } + }, "crates__syn-2.0.119": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -8705,17 +10003,17 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"syn\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__unicode-ident-1.0.24//:unicode_ident\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"clone-impls\",\n \"default\",\n \"derive\",\n \"extra-traits\",\n \"fold\",\n \"full\",\n \"parsing\",\n \"printing\",\n \"proc-macro\",\n \"visit\",\n \"visit-mut\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=syn\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.0.119\",\n)\n" } }, - "crates__syn-3.0.3": { + "crates__syn-3.0.4": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3", + "sha256": "e6275cddf4610d1775e6d1fe9469b2e77d0f39fd98fb7450901b821e0c53649f", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/syn/3.0.3/download" + "https://static.crates.io/crates/syn/3.0.4/download" ], - "strip_prefix": "syn-3.0.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"syn\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__unicode-ident-1.0.24//:unicode_ident\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"clone-impls\",\n \"default\",\n \"derive\",\n \"extra-traits\",\n \"fold\",\n \"full\",\n \"parsing\",\n \"printing\",\n \"proc-macro\",\n \"visit-mut\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=syn\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.0.3\",\n)\n" + "strip_prefix": "syn-3.0.4", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"syn\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__unicode-ident-1.0.24//:unicode_ident\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"clone-impls\",\n \"default\",\n \"derive\",\n \"extra-traits\",\n \"fold\",\n \"full\",\n \"parsing\",\n \"printing\",\n \"proc-macro\",\n \"visit\",\n \"visit-mut\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=syn\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.0.4\",\n)\n" } }, "crates__synstructure-0.13.2": { @@ -8897,7 +10195,7 @@ "https://static.crates.io/crates/thiserror-impl/2.0.20/download" ], "strip_prefix": "thiserror-impl-2.0.20", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"thiserror_impl\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=thiserror-impl\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.0.20\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"thiserror_impl\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=thiserror-impl\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.0.20\",\n)\n" } }, "crates__tiff-0.11.3": { @@ -8978,6 +10276,32 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"tiny_keccak\",\n deps = [\n \"@crates__crunchy-0.2.4//:crunchy\",\n \"@crates__tiny-keccak-2.0.2//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"shake\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=tiny-keccak\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.0.2\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"shake\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2018\",\n pkg_name = \"tiny-keccak\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=tiny-keccak\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"2.0.2\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, + "crates__tiny-skia-0.12.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "47ffee5eaaf5527f630fb0e356b90ebdec84d5d18d937c5e440350f88c5a91ea", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/tiny-skia/0.12.0/download" + ], + "strip_prefix": "tiny-skia-0.12.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"tiny_skia\",\n deps = [\n \"@crates__arrayref-0.3.9//:arrayref\",\n \"@crates__arrayvec-0.7.8//:arrayvec\",\n \"@crates__bytemuck-1.25.2//:bytemuck\",\n \"@crates__cfg-if-1.0.4//:cfg_if\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__png-0.18.1//:png\",\n \"@crates__tiny-skia-path-0.12.0//:tiny_skia_path\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"png-format\",\n \"simd\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=tiny-skia\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.0\",\n)\n" + } + }, + "crates__tiny-skia-path-0.12.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "edca365c3faccca67d06593c5980fa6c57687de727a03131735bb85f01fdeeb9", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/tiny-skia-path/0.12.0/download" + ], + "strip_prefix": "tiny-skia-path-0.12.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"tiny_skia_path\",\n deps = [\n \"@crates__arrayref-0.3.9//:arrayref\",\n \"@crates__bytemuck-1.25.2//:bytemuck\",\n \"@crates__strict-num-0.1.1//:strict_num\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=tiny-skia-path\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.0\",\n)\n" + } + }, "crates__tinystr-0.8.4": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -9040,7 +10364,7 @@ "https://static.crates.io/crates/tokio-macros/2.7.2/download" ], "strip_prefix": "tokio-macros-2.7.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"tokio_macros\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=tokio-macros\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.7.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"tokio_macros\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=tokio-macros\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.7.2\",\n)\n" } }, "crates__tokio-util-0.7.19": { @@ -9092,7 +10416,7 @@ "https://static.crates.io/crates/toml_edit/0.25.13+spec-1.1.0/download" ], "strip_prefix": "toml_edit-0.25.13+spec-1.1.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"toml_edit\",\n deps = [\n \"@crates__indexmap-2.14.0//:indexmap\",\n \"@crates__toml_datetime-1.1.1-spec-1.1.0//:toml_datetime\",\n \"@crates__toml_parser-1.1.3-spec-1.1.0//:toml_parser\",\n \"@crates__winnow-1.0.4//:winnow\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"parse\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=toml_edit\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.25.13+spec-1.1.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"toml_edit\",\n deps = [\n \"@crates__indexmap-2.14.0//:indexmap\",\n \"@crates__serde_core-1.0.229//:serde_core\",\n \"@crates__serde_spanned-1.1.1//:serde_spanned\",\n \"@crates__toml_datetime-1.1.1-spec-1.1.0//:toml_datetime\",\n \"@crates__toml_parser-1.1.3-spec-1.1.0//:toml_parser\",\n \"@crates__toml_writer-1.1.2-spec-1.1.0//:toml_writer\",\n \"@crates__winnow-1.0.4//:winnow\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"display\",\n \"parse\",\n \"serde\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=toml_edit\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.25.13+spec-1.1.0\",\n)\n" } }, "crates__toml_parser-1.1.3-spec-1.1.0": { @@ -9118,7 +10442,7 @@ "https://static.crates.io/crates/toml_writer/1.1.2+spec-1.1.0/download" ], "strip_prefix": "toml_writer-1.1.2+spec-1.1.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"toml_writer\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=toml_writer\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.1.2+spec-1.1.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"toml_writer\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"alloc\",\n \"default\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=toml_writer\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.1.2+spec-1.1.0\",\n)\n" } }, "crates__tracing-0.1.44": { @@ -9963,7 +11287,7 @@ "https://static.crates.io/crates/turn/0.17.2/download" ], "strip_prefix": "turn-0.17.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"turn\",\n deps = [\n \"@crates__base64-0.22.1//:base64\",\n \"@crates__futures-0.3.34//:futures\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__md-5-0.10.6//:md5\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__ring-0.17.14//:ring\",\n \"@crates__stun-0.17.2//:stun\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__tokio-util-0.7.19//:tokio_util\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=turn\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"turn\",\n deps = [\n \"@crates__base64-0.22.1//:base64\",\n \"@crates__futures-0.3.34//:futures\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__md-5-0.10.6//:md5\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__ring-0.17.14//:ring\",\n \"@crates__stun-0.17.2//:stun\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__tokio-util-0.7.19//:tokio_util\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=turn\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" } }, "crates__type-map-0.5.1": { @@ -10057,6 +11381,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"uiautomation_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-2.0.119//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"action_derive\",\n \"control_derive\",\n \"default\",\n \"enum_derive\",\n \"pattern_derive\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=uiautomation_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.7.8\",\n)\n" } }, + "crates__uluru-3.1.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "7c8a2469e56e6e5095c82ccd3afb98dad95f7af7929aab6d8ba8d6e0f73657da", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/uluru/3.1.0/download" + ], + "strip_prefix": "uluru-3.1.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"uluru\",\n deps = [\n \"@crates__arrayvec-0.7.8//:arrayvec\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=uluru\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"3.1.0\",\n)\n" + } + }, "crates__unic-langid-0.9.6": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -10109,6 +11446,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"unicode_bidi\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"hardcoded-data\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=unicode-bidi\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.18\",\n)\n" } }, + "crates__unicode-bom-2.0.3": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "7eec5d1121208364f6793f7d2e222bf75a915c19557537745b195b253dd64217", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/unicode-bom/2.0.3/download" + ], + "strip_prefix": "unicode-bom-2.0.3", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"unicode_bom\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=unicode-bom\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.0.3\",\n)\n" + } + }, "crates__unicode-ident-1.0.24": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -10148,6 +11498,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"unicode_properties\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"emoji\",\n \"general-category\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=unicode-properties\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.4\",\n)\n" } }, + "crates__unicode-script-0.5.8": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "383ad40bb927465ec0ce7720e033cb4ca06912855fc35db31b5755d0de75b1ee", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/unicode-script/0.5.8/download" + ], + "strip_prefix": "unicode-script-0.5.8", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"unicode_script\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=unicode-script\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.8\",\n)\n" + } + }, "crates__unicode-segmentation-1.13.3": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -10161,6 +11524,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"unicode_segmentation\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=unicode-segmentation\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.13.3\",\n)\n" } }, + "crates__unicode-vo-0.1.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "b1d386ff53b415b7fe27b50bb44679e2cc4660272694b7b6f3326d8480823a94", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/unicode-vo/0.1.0/download" + ], + "strip_prefix": "unicode-vo-0.1.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"unicode_vo\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=unicode-vo\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.0\",\n)\n" + } + }, "crates__unicode-width-0.1.14": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -10252,6 +11628,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"urlencoding\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=urlencoding\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.1.3\",\n)\n" } }, + "crates__usvg-0.48.1": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "977d0a4abdef933f424a99fe09f95576e089b90aebc6f016a3bc813762493e91", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/usvg/0.48.1/download" + ], + "strip_prefix": "usvg-0.48.1", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"usvg\",\n deps = [\n \"@crates__base64-0.23.1//:base64\",\n \"@crates__data-url-0.3.2//:data_url\",\n \"@crates__flate2-1.1.9//:flate2\",\n \"@crates__fontdb-0.24.0//:fontdb\",\n \"@crates__harfrust-0.12.0//:harfrust\",\n \"@crates__imagesize-0.15.0//:imagesize\",\n \"@crates__kurbo-0.13.1//:kurbo\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__pico-args-0.5.0//:pico_args\",\n \"@crates__roxmltree-0.21.1//:roxmltree\",\n \"@crates__simplecss-0.2.2//:simplecss\",\n \"@crates__siphasher-1.0.3//:siphasher\",\n \"@crates__skrifa-0.44.0//:skrifa\",\n \"@crates__strict-num-0.1.1//:strict_num\",\n \"@crates__svgtypes-0.16.1//:svgtypes\",\n \"@crates__tiny-skia-path-0.12.0//:tiny_skia_path\",\n \"@crates__unicode-bidi-0.3.18//:unicode_bidi\",\n \"@crates__unicode-script-0.5.8//:unicode_script\",\n \"@crates__unicode-vo-0.1.0//:unicode_vo\",\n \"@crates__xmlwriter-0.1.0//:xmlwriter\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"base64\",\n \"flate2\",\n \"fontdb\",\n \"harfrust\",\n \"memmap-fonts\",\n \"skrifa\",\n \"svgz\",\n \"system-fonts\",\n \"text\",\n \"unicode-bidi\",\n \"unicode-script\",\n \"unicode-vo\",\n \"writer\",\n \"xmlwriter\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=usvg\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.48.1\",\n)\n" + } + }, "crates__utf16_iter-1.0.5": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -10330,17 +11719,17 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"uucore_procs\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=uucore_procs\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.0\",\n)\n" } }, - "crates__uuid-1.24.1": { + "crates__uuid-1.26.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "2cefc03fd367c0c6d4305de1b312cf00248c4114f4a0418ce6a6af769e3b0bd9", + "sha256": "b5772d71c9be8a8a6ac2117d949c5b224c1b72241bb611d9a3012edcf8af7812", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/uuid/1.24.1/download" + "https://static.crates.io/crates/uuid/1.26.0/download" ], - "strip_prefix": "uuid-1.24.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"uuid\",\n deps = [\n \"@crates__getrandom-0.4.3//:getrandom\",\n ] + select({\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__serde_core-1.0.229//:serde_core\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__serde_core-1.0.229//:serde_core\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__serde_core-1.0.229//:serde_core\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__serde_core-1.0.229//:serde_core\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"rng\",\n \"std\",\n \"v4\",\n ] + select({\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"serde\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"serde\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"serde\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"serde\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=uuid\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.24.1\",\n)\n" + "strip_prefix": "uuid-1.26.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"uuid\",\n deps = [\n \"@crates__getrandom-0.4.3//:getrandom\",\n ] + select({\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__serde_core-1.0.229//:serde_core\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__serde_core-1.0.229//:serde_core\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__serde_core-1.0.229//:serde_core\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__serde_core-1.0.229//:serde_core\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"rng\",\n \"std\",\n \"v4\",\n ] + select({\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"serde\", # aarch64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"serde\", # aarch64-unknown-linux-musl\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"serde\", # x86_64-unknown-linux-gnu\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"serde\", # x86_64-unknown-linux-musl\n ],\n \"//conditions:default\": [],\n }),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=uuid\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.26.0\",\n)\n" } }, "crates__uutils_term_grid-0.8.0": { @@ -10366,7 +11755,7 @@ "https://static.crates.io/crates/uzers/0.12.2/download" ], "strip_prefix": "uzers-0.12.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"uzers\",\n deps = [\n \"@crates__libc-0.2.189//:libc\",\n \"@crates__log-0.4.33//:log\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"cache\",\n \"default\",\n \"log\",\n \"logging\",\n \"mock\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=uzers\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"uzers\",\n deps = [\n \"@crates__libc-0.2.189//:libc\",\n \"@crates__log-0.4.34//:log\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"cache\",\n \"default\",\n \"log\",\n \"logging\",\n \"mock\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=uzers\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.12.2\",\n)\n" } }, "crates__version-compare-0.2.1": { @@ -10678,7 +12067,7 @@ "https://static.crates.io/crates/webrtc/0.17.2/download" ], "strip_prefix": "webrtc-0.17.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc\",\n deps = [\n \"@crates__arc-swap-1.9.2//:arc_swap\",\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__dtls-0.17.2//:dtls\",\n \"@crates__hex-0.4.3//:hex\",\n \"@crates__interceptor-0.17.2//:interceptor\",\n \"@crates__lazy_static-1.5.0//:lazy_static\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__rcgen-0.13.2//:rcgen\",\n \"@crates__regex-1.13.1//:regex\",\n \"@crates__ring-0.17.14//:ring\",\n \"@crates__rtcp-0.17.2//:rtcp\",\n \"@crates__rtp-0.17.2//:rtp\",\n \"@crates__sdp-0.17.2//:sdp\",\n \"@crates__serde-1.0.229//:serde\",\n \"@crates__serde_json-1.0.151//:serde_json\",\n \"@crates__sha2-0.10.9//:sha2\",\n \"@crates__smol_str-0.2.2//:smol_str\",\n \"@crates__stun-0.17.2//:stun\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__turn-0.17.2//:turn\",\n \"@crates__unicase-2.9.0//:unicase\",\n \"@crates__url-2.5.8//:url\",\n \"@crates__waitgroup-0.1.2//:waitgroup\",\n \"@crates__webrtc-data-0.17.2//:webrtc_data\",\n \"@crates__webrtc-ice-0.17.2//:webrtc_ice\",\n \"@crates__webrtc-mdns-0.17.2//:webrtc_mdns\",\n \"@crates__webrtc-media-0.17.2//:webrtc_media\",\n \"@crates__webrtc-sctp-0.17.2//:webrtc_sctp\",\n \"@crates__webrtc-srtp-0.17.2//:webrtc_srtp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-data-0.17.2//:webrtc_data\": \"data\",\n \"@crates__webrtc-ice-0.17.2//:webrtc_ice\": \"ice\",\n \"@crates__webrtc-mdns-0.17.2//:webrtc_mdns\": \"mdns\",\n \"@crates__webrtc-media-0.17.2//:webrtc_media\": \"media\",\n \"@crates__webrtc-sctp-0.17.2//:webrtc_sctp\": \"sctp\",\n \"@crates__webrtc-srtp-0.17.2//:webrtc_srtp\": \"srtp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc\",\n deps = [\n \"@crates__arc-swap-1.9.2//:arc_swap\",\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__dtls-0.17.2//:dtls\",\n \"@crates__hex-0.4.3//:hex\",\n \"@crates__interceptor-0.17.2//:interceptor\",\n \"@crates__lazy_static-1.5.0//:lazy_static\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__rcgen-0.13.2//:rcgen\",\n \"@crates__regex-1.13.1//:regex\",\n \"@crates__ring-0.17.14//:ring\",\n \"@crates__rtcp-0.17.2//:rtcp\",\n \"@crates__rtp-0.17.2//:rtp\",\n \"@crates__sdp-0.17.2//:sdp\",\n \"@crates__serde-1.0.229//:serde\",\n \"@crates__serde_json-1.0.151//:serde_json\",\n \"@crates__sha2-0.10.9//:sha2\",\n \"@crates__smol_str-0.2.2//:smol_str\",\n \"@crates__stun-0.17.2//:stun\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__turn-0.17.2//:turn\",\n \"@crates__unicase-2.9.0//:unicase\",\n \"@crates__url-2.5.8//:url\",\n \"@crates__waitgroup-0.1.2//:waitgroup\",\n \"@crates__webrtc-data-0.17.2//:webrtc_data\",\n \"@crates__webrtc-ice-0.17.2//:webrtc_ice\",\n \"@crates__webrtc-mdns-0.17.2//:webrtc_mdns\",\n \"@crates__webrtc-media-0.17.2//:webrtc_media\",\n \"@crates__webrtc-sctp-0.17.2//:webrtc_sctp\",\n \"@crates__webrtc-srtp-0.17.2//:webrtc_srtp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-data-0.17.2//:webrtc_data\": \"data\",\n \"@crates__webrtc-ice-0.17.2//:webrtc_ice\": \"ice\",\n \"@crates__webrtc-mdns-0.17.2//:webrtc_mdns\": \"mdns\",\n \"@crates__webrtc-media-0.17.2//:webrtc_media\": \"media\",\n \"@crates__webrtc-sctp-0.17.2//:webrtc_sctp\": \"sctp\",\n \"@crates__webrtc-srtp-0.17.2//:webrtc_srtp\": \"srtp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" } }, "crates__webrtc-data-0.17.2": { @@ -10691,7 +12080,7 @@ "https://static.crates.io/crates/webrtc-data/0.17.2/download" ], "strip_prefix": "webrtc-data-0.17.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_data\",\n deps = [\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__webrtc-sctp-0.17.2//:webrtc_sctp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n aliases = {\n \"@crates__webrtc-sctp-0.17.2//:webrtc_sctp\": \"sctp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-data\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_data\",\n deps = [\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__webrtc-sctp-0.17.2//:webrtc_sctp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n aliases = {\n \"@crates__webrtc-sctp-0.17.2//:webrtc_sctp\": \"sctp\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-data\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" } }, "crates__webrtc-ice-0.17.2": { @@ -10704,7 +12093,7 @@ "https://static.crates.io/crates/webrtc-ice/0.17.2/download" ], "strip_prefix": "webrtc-ice-0.17.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_ice\",\n deps = [\n \"@crates__arc-swap-1.9.2//:arc_swap\",\n \"@crates__crc-3.4.0//:crc\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__serde-1.0.229//:serde\",\n \"@crates__serde_json-1.0.151//:serde_json\",\n \"@crates__stun-0.17.2//:stun\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__turn-0.17.2//:turn\",\n \"@crates__url-2.5.8//:url\",\n \"@crates__uuid-1.24.1//:uuid\",\n \"@crates__waitgroup-0.1.2//:waitgroup\",\n \"@crates__webrtc-mdns-0.17.2//:webrtc_mdns\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-mdns-0.17.2//:webrtc_mdns\": \"mdns\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-ice\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_ice\",\n deps = [\n \"@crates__arc-swap-1.9.2//:arc_swap\",\n \"@crates__crc-3.4.0//:crc\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__serde-1.0.229//:serde\",\n \"@crates__serde_json-1.0.151//:serde_json\",\n \"@crates__stun-0.17.2//:stun\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__turn-0.17.2//:turn\",\n \"@crates__url-2.5.8//:url\",\n \"@crates__uuid-1.26.0//:uuid\",\n \"@crates__waitgroup-0.1.2//:waitgroup\",\n \"@crates__webrtc-mdns-0.17.2//:webrtc_mdns\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-mdns-0.17.2//:webrtc_mdns\": \"mdns\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-ice\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" } }, "crates__webrtc-mdns-0.17.2": { @@ -10717,7 +12106,7 @@ "https://static.crates.io/crates/webrtc-mdns/0.17.2/download" ], "strip_prefix": "webrtc-mdns-0.17.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_mdns\",\n deps = [\n \"@crates__log-0.4.33//:log\",\n \"@crates__socket2-0.5.10//:socket2\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n aliases = {\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"reuse_port\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-mdns\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_mdns\",\n deps = [\n \"@crates__log-0.4.34//:log\",\n \"@crates__socket2-0.5.10//:socket2\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n aliases = {\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"reuse_port\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-mdns\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" } }, "crates__webrtc-media-0.17.2": { @@ -10743,7 +12132,7 @@ "https://static.crates.io/crates/webrtc-sctp/0.17.2/download" ], "strip_prefix": "webrtc-sctp-0.17.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_sctp\",\n deps = [\n \"@crates__arc-swap-1.9.2//:arc_swap\",\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__crc-3.4.0//:crc\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-sctp\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_sctp\",\n deps = [\n \"@crates__arc-swap-1.9.2//:arc_swap\",\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__crc-3.4.0//:crc\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n aliases = {\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-sctp\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" } }, "crates__webrtc-srtp-0.17.2": { @@ -10756,7 +12145,7 @@ "https://static.crates.io/crates/webrtc-srtp/0.17.2/download" ], "strip_prefix": "webrtc-srtp-0.17.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_srtp\",\n deps = [\n \"@crates__aead-0.5.2//:aead\",\n \"@crates__aes-0.8.4//:aes\",\n \"@crates__aes-gcm-0.10.3//:aes_gcm\",\n \"@crates__byteorder-1.5.0//:byteorder\",\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__ctr-0.9.2//:ctr\",\n \"@crates__hmac-0.12.1//:hmac\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__rtcp-0.17.2//:rtcp\",\n \"@crates__rtp-0.17.2//:rtp\",\n \"@crates__sha1-0.10.7//:sha1\",\n \"@crates__subtle-2.6.1//:subtle\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n aliases = {\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-srtp\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_srtp\",\n deps = [\n \"@crates__aead-0.5.2//:aead\",\n \"@crates__aes-0.8.4//:aes\",\n \"@crates__aes-gcm-0.10.3//:aes_gcm\",\n \"@crates__byteorder-1.5.0//:byteorder\",\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__ctr-0.9.2//:ctr\",\n \"@crates__hmac-0.12.1//:hmac\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__rtcp-0.17.2//:rtcp\",\n \"@crates__rtp-0.17.2//:rtp\",\n \"@crates__sha1-0.10.7//:sha1\",\n \"@crates__subtle-2.6.1//:subtle\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__webrtc-util-0.17.2//:webrtc_util\",\n ],\n aliases = {\n \"@crates__webrtc-util-0.17.2//:webrtc_util\": \"util\",\n },\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-srtp\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" } }, "crates__webrtc-util-0.17.2": { @@ -10769,7 +12158,7 @@ "https://static.crates.io/crates/webrtc-util/0.17.2/download" ], "strip_prefix": "webrtc-util-0.17.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_util\",\n deps = [\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__ipnet-2.12.1//:ipnet\",\n \"@crates__lazy_static-1.5.0//:lazy_static\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__bitflags-1.3.2//:bitflags\", # cfg(windows)\n \"@crates__winapi-0.3.9//:winapi\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"//conditions:default\": [],\n }),\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"buffer\",\n \"conn\",\n \"ifaces\",\n \"marshal\",\n \"sync\",\n \"vnet\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-util\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"webrtc_util\",\n deps = [\n \"@crates__bytes-1.12.1//:bytes\",\n \"@crates__ipnet-2.12.1//:ipnet\",\n \"@crates__lazy_static-1.5.0//:lazy_static\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__portable-atomic-1.15.0//:portable_atomic\",\n \"@crates__rand-0.9.5//:rand\",\n \"@crates__thiserror-1.0.69//:thiserror\",\n \"@crates__tokio-1.53.1//:tokio\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__bitflags-1.3.2//:bitflags\", # cfg(windows)\n \"@crates__winapi-0.3.9//:winapi\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__nix-0.26.4//:nix\", # cfg(not(windows))\n ],\n \"//conditions:default\": [],\n }),\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"buffer\",\n \"conn\",\n \"ifaces\",\n \"marshal\",\n \"sync\",\n \"vnet\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=webrtc-util\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.17.2\",\n)\n" } }, "crates__weezl-0.1.12": { @@ -10798,17 +12187,17 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"whoami\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n \"std\",\n \"wasi-wasite\",\n \"wasm-web\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=whoami\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"2.1.3\",\n)\n" } }, - "crates__wide-1.6.1": { + "crates__wide-1.7.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { "remote_patch_strip": 1, - "sha256": "de2aaf408e58689c2096682331b1f42bb2d9f2ed6b11560407d023cd0a6c634e", + "sha256": "8cf05ca94c9fba0c51316899caa1d1e74a064fc310a5efa7375e614343d415be", "type": "tar.gz", "urls": [ - "https://static.crates.io/crates/wide/1.6.1/download" + "https://static.crates.io/crates/wide/1.7.0/download" ], - "strip_prefix": "wide-1.6.1", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"wide\",\n deps = [\n \"@crates__bytemuck-1.25.2//:bytemuck\",\n ] + select({\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__safe_arch-1.2.0//:safe_arch\", # cfg(target_arch = \"x86_64\")\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__safe_arch-1.2.0//:safe_arch\", # cfg(target_arch = \"x86_64\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__safe_arch-1.2.0//:safe_arch\", # cfg(target_arch = \"x86_64\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__safe_arch-1.2.0//:safe_arch\", # cfg(target_arch = \"x86_64\")\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=wide\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.6.1\",\n)\n" + "strip_prefix": "wide-1.7.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"wide\",\n deps = [\n \"@crates__bytemuck-1.25.2//:bytemuck\",\n ] + select({\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__safe_arch-1.2.0//:safe_arch\", # cfg(target_arch = \"x86_64\")\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__safe_arch-1.2.0//:safe_arch\", # cfg(target_arch = \"x86_64\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__safe_arch-1.2.0//:safe_arch\", # cfg(target_arch = \"x86_64\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__safe_arch-1.2.0//:safe_arch\", # cfg(target_arch = \"x86_64\")\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=wide\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"1.7.0\",\n)\n" } }, "crates__widestring-1.2.1": { @@ -10847,7 +12236,7 @@ "https://static.crates.io/crates/winapi/0.3.9/download" ], "strip_prefix": "winapi-0.3.9", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"winapi\",\n deps = [\n \"@crates__winapi-0.3.9//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"accctrl\",\n \"aclapi\",\n \"basetsd\",\n \"consoleapi\",\n \"fileapi\",\n \"guiddef\",\n \"handleapi\",\n \"impl-debug\",\n \"impl-default\",\n \"minwinbase\",\n \"minwindef\",\n \"namedpipeapi\",\n \"processenv\",\n \"processthreadsapi\",\n \"securitybaseapi\",\n \"synchapi\",\n \"timezoneapi\",\n \"winbase\",\n \"winerror\",\n \"winnt\",\n \"winreg\",\n \"winsock2\",\n \"winuser\",\n \"ws2def\",\n \"ws2ipdef\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=winapi\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.9\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"accctrl\",\n \"aclapi\",\n \"basetsd\",\n \"consoleapi\",\n \"fileapi\",\n \"guiddef\",\n \"handleapi\",\n \"impl-debug\",\n \"impl-default\",\n \"minwinbase\",\n \"minwindef\",\n \"namedpipeapi\",\n \"processenv\",\n \"processthreadsapi\",\n \"securitybaseapi\",\n \"synchapi\",\n \"timezoneapi\",\n \"winbase\",\n \"winerror\",\n \"winnt\",\n \"winreg\",\n \"winsock2\",\n \"winuser\",\n \"ws2def\",\n \"ws2ipdef\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2015\",\n pkg_name = \"winapi\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=winapi\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.3.9\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"winapi\",\n deps = [\n \"@crates__winapi-0.3.9//:build_script_build\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"accctrl\",\n \"aclapi\",\n \"basetsd\",\n \"consoleapi\",\n \"fileapi\",\n \"guiddef\",\n \"handleapi\",\n \"impl-debug\",\n \"impl-default\",\n \"minwinbase\",\n \"minwindef\",\n \"namedpipeapi\",\n \"processenv\",\n \"processthreadsapi\",\n \"securitybaseapi\",\n \"std\",\n \"synchapi\",\n \"timezoneapi\",\n \"winbase\",\n \"winerror\",\n \"winnt\",\n \"winreg\",\n \"winsock2\",\n \"winuser\",\n \"ws2def\",\n \"ws2ipdef\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2015\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=winapi\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.3.9\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"accctrl\",\n \"aclapi\",\n \"basetsd\",\n \"consoleapi\",\n \"fileapi\",\n \"guiddef\",\n \"handleapi\",\n \"impl-debug\",\n \"impl-default\",\n \"minwinbase\",\n \"minwindef\",\n \"namedpipeapi\",\n \"processenv\",\n \"processthreadsapi\",\n \"securitybaseapi\",\n \"std\",\n \"synchapi\",\n \"timezoneapi\",\n \"winbase\",\n \"winerror\",\n \"winnt\",\n \"winreg\",\n \"winsock2\",\n \"winuser\",\n \"ws2def\",\n \"ws2ipdef\",\n ],\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2015\",\n pkg_name = \"winapi\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=winapi\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.3.9\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, "crates__winapi-i686-pc-windows-gnu-0.4.0": { @@ -11198,7 +12587,7 @@ "https://static.crates.io/crates/windows-sys/0.61.2/download" ], "strip_prefix": "windows-sys-0.61.2", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"windows_sys\",\n deps = [\n \"@crates__windows-link-0.2.1//:windows_link\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"Wdk\",\n \"Wdk_Foundation\",\n \"Wdk_Storage\",\n \"Wdk_Storage_FileSystem\",\n \"Wdk_System\",\n \"Wdk_System_IO\",\n \"Wdk_System_SystemInformation\",\n \"Win32\",\n \"Win32_Devices\",\n \"Win32_Devices_Communication\",\n \"Win32_Foundation\",\n \"Win32_Graphics\",\n \"Win32_Graphics_Gdi\",\n \"Win32_Media\",\n \"Win32_Media_Audio\",\n \"Win32_Media_Multimedia\",\n \"Win32_Networking\",\n \"Win32_Networking_WinSock\",\n \"Win32_Security\",\n \"Win32_Storage\",\n \"Win32_Storage_FileSystem\",\n \"Win32_Storage_ProjectedFileSystem\",\n \"Win32_System\",\n \"Win32_System_Com\",\n \"Win32_System_Console\",\n \"Win32_System_Diagnostics\",\n \"Win32_System_Diagnostics_Debug\",\n \"Win32_System_IO\",\n \"Win32_System_Ioctl\",\n \"Win32_System_LibraryLoader\",\n \"Win32_System_Pipes\",\n \"Win32_System_Registry\",\n \"Win32_System_RemoteDesktop\",\n \"Win32_System_SystemInformation\",\n \"Win32_System_SystemServices\",\n \"Win32_System_Threading\",\n \"Win32_System_Time\",\n \"Win32_System_WindowsProgramming\",\n \"Win32_UI\",\n \"Win32_UI_Input\",\n \"Win32_UI_Input_KeyboardAndMouse\",\n \"Win32_UI_WindowsAndMessaging\",\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=windows-sys\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.61.2\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"windows_sys\",\n deps = [\n \"@crates__windows-link-0.2.1//:windows_link\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"Wdk\",\n \"Wdk_Foundation\",\n \"Wdk_Storage\",\n \"Wdk_Storage_FileSystem\",\n \"Wdk_System\",\n \"Wdk_System_IO\",\n \"Wdk_System_SystemInformation\",\n \"Win32\",\n \"Win32_Devices\",\n \"Win32_Devices_Communication\",\n \"Win32_Foundation\",\n \"Win32_Graphics\",\n \"Win32_Graphics_Gdi\",\n \"Win32_Media\",\n \"Win32_Media_Audio\",\n \"Win32_Media_Multimedia\",\n \"Win32_Networking\",\n \"Win32_Networking_WinSock\",\n \"Win32_Security\",\n \"Win32_Security_Authorization\",\n \"Win32_Storage\",\n \"Win32_Storage_FileSystem\",\n \"Win32_Storage_ProjectedFileSystem\",\n \"Win32_System\",\n \"Win32_System_Com\",\n \"Win32_System_Console\",\n \"Win32_System_Diagnostics\",\n \"Win32_System_Diagnostics_Debug\",\n \"Win32_System_IO\",\n \"Win32_System_Ioctl\",\n \"Win32_System_LibraryLoader\",\n \"Win32_System_Memory\",\n \"Win32_System_Pipes\",\n \"Win32_System_Registry\",\n \"Win32_System_RemoteDesktop\",\n \"Win32_System_SystemInformation\",\n \"Win32_System_SystemServices\",\n \"Win32_System_Threading\",\n \"Win32_System_Time\",\n \"Win32_System_WindowsProgramming\",\n \"Win32_UI\",\n \"Win32_UI_Input\",\n \"Win32_UI_Input_KeyboardAndMouse\",\n \"Win32_UI_Shell\",\n \"Win32_UI_WindowsAndMessaging\",\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=windows-sys\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.61.2\",\n)\n" } }, "crates__windows-targets-0.48.5": { @@ -11640,7 +13029,7 @@ "https://static.crates.io/crates/wl-clipboard-rs/0.9.3/download" ], "strip_prefix": "wl-clipboard-rs-0.9.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"wl_clipboard_rs\",\n deps = [\n \"@crates__libc-0.2.189//:libc\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__os_pipe-1.2.3//:os_pipe\",\n \"@crates__rustix-1.1.4//:rustix\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__tree_magic_mini-3.2.2//:tree_magic_mini\",\n \"@crates__wayland-backend-0.3.17//:wayland_backend\",\n \"@crates__wayland-client-0.31.15//:wayland_client\",\n \"@crates__wayland-protocols-0.32.13//:wayland_protocols\",\n \"@crates__wayland-protocols-wlr-0.3.12//:wayland_protocols_wlr\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=wl-clipboard-rs\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.3\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"wl_clipboard_rs\",\n deps = [\n \"@crates__libc-0.2.189//:libc\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__os_pipe-1.2.3//:os_pipe\",\n \"@crates__rustix-1.1.4//:rustix\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__tree_magic_mini-3.2.2//:tree_magic_mini\",\n \"@crates__wayland-backend-0.3.17//:wayland_backend\",\n \"@crates__wayland-client-0.31.15//:wayland_client\",\n \"@crates__wayland-protocols-0.32.13//:wayland_protocols\",\n \"@crates__wayland-protocols-wlr-0.3.12//:wayland_protocols_wlr\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=wl-clipboard-rs\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.3\",\n)\n" } }, "crates__write16-1.0.0": { @@ -11757,7 +13146,7 @@ "https://static.crates.io/crates/xcap/0.9.6/download" ], "strip_prefix": "xcap-0.9.6", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"xcap\",\n deps = [\n \"@crates__image-0.25.10//:image\",\n \"@crates__log-0.4.33//:log\",\n \"@crates__scopeguard-1.2.0//:scopeguard\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__xcap-0.9.6//:build_script_build\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__dispatch2-0.3.1//:dispatch2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-av-foundation-0.3.2//:objc2_av_foundation\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-media-0.3.2//:objc2_core_media\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-video-0.3.2//:objc2_core_video\", # cfg(target_os = \"macos\")\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libwayshot-xcap-0.3.3//:libwayshot_xcap\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__pipewire-0.9.2//:pipewire\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__rand-0.9.5//:rand\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__serde-1.0.229//:serde\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__url-2.5.8//:url\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__xcb-1.7.1//:xcb\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__zbus-5.19.0//:zbus\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libwayshot-xcap-0.3.3//:libwayshot_xcap\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__pipewire-0.9.2//:pipewire\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__rand-0.9.5//:rand\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__serde-1.0.229//:serde\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__url-2.5.8//:url\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__xcb-1.7.1//:xcb\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__zbus-5.19.0//:zbus\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__dispatch2-0.3.1//:dispatch2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-av-foundation-0.3.2//:objc2_av_foundation\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-media-0.3.2//:objc2_core_media\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-video-0.3.2//:objc2_core_video\", # cfg(target_os = \"macos\")\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__widestring-1.2.1//:widestring\", # cfg(target_os = \"windows\")\n \"@crates__windows-0.62.2//:windows\", # cfg(target_os = \"windows\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libwayshot-xcap-0.3.3//:libwayshot_xcap\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__pipewire-0.9.2//:pipewire\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__rand-0.9.5//:rand\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__serde-1.0.229//:serde\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__url-2.5.8//:url\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__xcb-1.7.1//:xcb\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__zbus-5.19.0//:zbus\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libwayshot-xcap-0.3.3//:libwayshot_xcap\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__pipewire-0.9.2//:pipewire\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__rand-0.9.5//:rand\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__serde-1.0.229//:serde\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__url-2.5.8//:url\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__xcb-1.7.1//:xcb\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__zbus-5.19.0//:zbus\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=xcap\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.6\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2024\",\n pkg_name = \"xcap\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=xcap\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.9.6\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\n \"@rules_rust//cargo:defs.bzl\",\n \"cargo_build_script\",\n \"cargo_toml_env_vars\",\n)\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"xcap\",\n deps = [\n \"@crates__image-0.25.10//:image\",\n \"@crates__log-0.4.34//:log\",\n \"@crates__scopeguard-1.2.0//:scopeguard\",\n \"@crates__thiserror-2.0.20//:thiserror\",\n \"@crates__xcap-0.9.6//:build_script_build\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__dispatch2-0.3.1//:dispatch2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-av-foundation-0.3.2//:objc2_av_foundation\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-media-0.3.2//:objc2_core_media\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-video-0.3.2//:objc2_core_video\", # cfg(target_os = \"macos\")\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libwayshot-xcap-0.3.3//:libwayshot_xcap\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__pipewire-0.9.2//:pipewire\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__rand-0.9.5//:rand\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__serde-1.0.229//:serde\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__url-2.5.8//:url\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__xcb-1.7.1//:xcb\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__zbus-5.19.0//:zbus\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libwayshot-xcap-0.3.3//:libwayshot_xcap\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__pipewire-0.9.2//:pipewire\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__rand-0.9.5//:rand\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__serde-1.0.229//:serde\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__url-2.5.8//:url\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__xcb-1.7.1//:xcb\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__zbus-5.19.0//:zbus\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__dispatch2-0.3.1//:dispatch2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-0.6.4//:objc2\", # cfg(target_os = \"macos\")\n \"@crates__objc2-app-kit-0.3.2//:objc2_app_kit\", # cfg(target_os = \"macos\")\n \"@crates__objc2-av-foundation-0.3.2//:objc2_av_foundation\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-foundation-0.3.2//:objc2_core_foundation\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-graphics-0.3.2//:objc2_core_graphics\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-media-0.3.2//:objc2_core_media\", # cfg(target_os = \"macos\")\n \"@crates__objc2-core-video-0.3.2//:objc2_core_video\", # cfg(target_os = \"macos\")\n \"@crates__objc2-foundation-0.3.2//:objc2_foundation\", # cfg(target_os = \"macos\")\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__widestring-1.2.1//:widestring\", # cfg(target_os = \"windows\")\n \"@crates__windows-0.62.2//:windows\", # cfg(target_os = \"windows\")\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libwayshot-xcap-0.3.3//:libwayshot_xcap\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__pipewire-0.9.2//:pipewire\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__rand-0.9.5//:rand\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__serde-1.0.229//:serde\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__url-2.5.8//:url\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__xcb-1.7.1//:xcb\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__zbus-5.19.0//:zbus\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libwayshot-xcap-0.3.3//:libwayshot_xcap\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__percent-encoding-2.3.2//:percent_encoding\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__pipewire-0.9.2//:pipewire\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__rand-0.9.5//:rand\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__serde-1.0.229//:serde\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__url-2.5.8//:url\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__xcb-1.7.1//:xcb\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n \"@crates__zbus-5.19.0//:zbus\", # cfg(all(target_os = \"linux\", not(target_env = \"ohos\")))\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=xcap\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.9.6\",\n)\n\ncargo_build_script(\n name = \"_bs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \"**/*.rs\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_name = \"build_script_build\",\n crate_root = \"build.rs\",\n data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n emit_warnings = False,\n edition = \"2024\",\n pkg_name = \"xcap\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=xcap\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n version = \"0.9.6\",\n visibility = [\"//visibility:private\"],\n)\n\nalias(\n name = \"build_script_build\",\n actual = \":_bs\",\n tags = [\"manual\"],\n)\n" } }, "crates__xcb-1.7.1": { @@ -11812,6 +13201,19 @@ "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"xml\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=xml-rs\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.8.29\",\n)\n" } }, + "crates__xmlwriter-0.1.0": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "ec7a2a501ed189703dba8b08142f057e887dfc4b2cc4db2d343ac6376ba3e0b9", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/xmlwriter/0.1.0/download" + ], + "strip_prefix": "xmlwriter-0.1.0", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"xmlwriter\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2018\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=xmlwriter\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.1.0\",\n)\n" + } + }, "crates__xutf-1.4.0": { "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", "attributes": { @@ -11926,7 +13328,7 @@ "https://static.crates.io/crates/zbus/5.19.0/download" ], "strip_prefix": "zbus-5.19.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"zbus\",\n deps = [\n \"@crates__async-broadcast-0.7.2//:async_broadcast\",\n \"@crates__async-executor-1.14.0//:async_executor\",\n \"@crates__async-io-2.6.0//:async_io\",\n \"@crates__async-lock-3.4.2//:async_lock\",\n \"@crates__async-process-2.5.0//:async_process\",\n \"@crates__async-task-4.7.1//:async_task\",\n \"@crates__blocking-1.6.2//:blocking\",\n \"@crates__enumflags2-0.7.12//:enumflags2\",\n \"@crates__event-listener-5.4.2//:event_listener\",\n \"@crates__futures-core-0.3.34//:futures_core\",\n \"@crates__futures-lite-2.6.1//:futures_lite\",\n \"@crates__hex-0.4.3//:hex\",\n \"@crates__ordered-stream-0.2.0//:ordered_stream\",\n \"@crates__serde-1.0.229//:serde\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__tracing-0.1.44//:tracing\",\n \"@crates__uuid-1.24.1//:uuid\",\n \"@crates__winnow-1.0.4//:winnow\",\n \"@crates__zbus_names-4.3.4//:zbus_names\",\n \"@crates__zvariant-5.15.0//:zvariant\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__uds_windows-1.2.1//:uds_windows\", # cfg(windows)\n \"@crates__windows-sys-0.61.2//:windows_sys\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n \"@crates__serde_repr-0.1.21//:serde_repr\",\n \"@crates__zbus_macros-5.19.0//:zbus_macros\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"async-executor\",\n \"async-fs\",\n \"async-io\",\n \"async-lock\",\n \"async-process\",\n \"async-task\",\n \"blocking\",\n \"p2p\",\n \"tokio\",\n \"url\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zbus\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"5.19.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"zbus\",\n deps = [\n \"@crates__async-broadcast-0.7.2//:async_broadcast\",\n \"@crates__async-executor-1.14.0//:async_executor\",\n \"@crates__async-io-2.6.0//:async_io\",\n \"@crates__async-lock-3.4.2//:async_lock\",\n \"@crates__async-process-2.5.0//:async_process\",\n \"@crates__async-task-4.7.1//:async_task\",\n \"@crates__blocking-1.7.0//:blocking\",\n \"@crates__enumflags2-0.7.12//:enumflags2\",\n \"@crates__event-listener-5.4.2//:event_listener\",\n \"@crates__futures-core-0.3.34//:futures_core\",\n \"@crates__futures-lite-2.6.1//:futures_lite\",\n \"@crates__hex-0.4.3//:hex\",\n \"@crates__ordered-stream-0.2.0//:ordered_stream\",\n \"@crates__serde-1.0.229//:serde\",\n \"@crates__tokio-1.53.1//:tokio\",\n \"@crates__tracing-0.1.44//:tracing\",\n \"@crates__uuid-1.26.0//:uuid\",\n \"@crates__winnow-1.0.4//:winnow\",\n \"@crates__zbus_names-4.3.4//:zbus_names\",\n \"@crates__zvariant-5.15.0//:zvariant\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__uds_windows-1.2.1//:uds_windows\", # cfg(windows)\n \"@crates__windows-sys-0.61.2//:windows_sys\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__libc-0.2.189//:libc\", # cfg(unix)\n \"@crates__rustix-1.1.4//:rustix\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n proc_macro_deps = [\n \"@crates__async-trait-0.1.92//:async_trait\",\n \"@crates__serde_repr-0.1.21//:serde_repr\",\n \"@crates__zbus_macros-5.19.0//:zbus_macros\",\n ] + select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-apple-darwin\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(windows)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [\n \"@crates__async-recursion-1.1.1//:async_recursion\", # cfg(unix)\n ],\n \"//conditions:default\": [],\n }),\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"async-executor\",\n \"async-fs\",\n \"async-io\",\n \"async-lock\",\n \"async-process\",\n \"async-task\",\n \"blocking\",\n \"p2p\",\n \"tokio\",\n \"url\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zbus\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"5.19.0\",\n)\n" } }, "crates__zbus-lockstep-0.5.2": { @@ -11965,7 +13367,7 @@ "https://static.crates.io/crates/zbus_macros/5.19.0/download" ], "strip_prefix": "zbus_macros-5.19.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"zbus_macros\",\n deps = [\n \"@crates__proc-macro-crate-3.5.0//:proc_macro_crate\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n \"@crates__zbus_names-4.3.4//:zbus_names\",\n \"@crates__zvariant-5.15.0//:zvariant\",\n \"@crates__zvariant_utils-4.2.0//:zvariant_utils\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zbus_macros\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"5.19.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"zbus_macros\",\n deps = [\n \"@crates__proc-macro-crate-3.5.0//:proc_macro_crate\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n \"@crates__zbus_names-4.3.4//:zbus_names\",\n \"@crates__zvariant-5.15.0//:zvariant\",\n \"@crates__zvariant_utils-4.2.0//:zvariant_utils\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zbus_macros\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"5.19.0\",\n)\n" } }, "crates__zbus_names-4.3.4": { @@ -12121,7 +13523,20 @@ "https://static.crates.io/crates/zerovec-derive/0.11.6/download" ], "strip_prefix": "zerovec-derive-0.11.6", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"zerovec_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zerovec-derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.11.6\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"zerovec_derive\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zerovec-derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.11.6\",\n)\n" + } + }, + "crates__zlib-rs-0.6.7": { + "repoRuleId": "@@bazel_tools//tools/build_defs/repo:http.bzl%http_archive", + "attributes": { + "remote_patch_strip": 1, + "sha256": "34b31d188d9d685a4f9c7b46d6e36631b07058d2cfe190267adce54dc230bf12", + "type": "tar.gz", + "urls": [ + "https://static.crates.io/crates/zlib-rs/0.6.7/download" + ], + "strip_prefix": "zlib-rs-0.6.7", + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"zlib_rs\",\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"c-allocator\",\n \"default\",\n \"rust-allocator\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zlib-rs\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.6.7\",\n)\n" } }, "crates__zmij-1.0.23": { @@ -12186,7 +13601,7 @@ "https://static.crates.io/crates/zune-core/0.5.3/download" ], "strip_prefix": "zune-core-0.5.3", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"zune_core\",\n deps = [\n \"@crates__log-0.4.33//:log\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"log\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zune-core\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.3\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"zune_core\",\n deps = [\n \"@crates__log-0.4.34//:log\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"log\",\n \"std\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2021\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zune-core\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"0.5.3\",\n)\n" } }, "crates__zune-jpeg-0.5.15": { @@ -12225,7 +13640,7 @@ "https://static.crates.io/crates/zvariant_derive/5.15.0/download" ], "strip_prefix": "zvariant_derive-5.15.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"zvariant_derive\",\n deps = [\n \"@crates__proc-macro-crate-3.5.0//:proc_macro_crate\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.3//:syn\",\n \"@crates__zvariant_utils-4.2.0//:zvariant_utils\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zvariant_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"5.15.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_proc_macro\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_proc_macro(\n name = \"zvariant_derive\",\n deps = [\n \"@crates__proc-macro-crate-3.5.0//:proc_macro_crate\",\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__syn-3.0.4//:syn\",\n \"@crates__zvariant_utils-4.2.0//:zvariant_utils\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zvariant_derive\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"5.15.0\",\n)\n" } }, "crates__zvariant_utils-4.2.0": { @@ -12238,7 +13653,7 @@ "https://static.crates.io/crates/zvariant_utils/4.2.0/download" ], "strip_prefix": "zvariant_utils-4.2.0", - "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"zvariant_utils\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__serde-1.0.229//:serde\",\n \"@crates__syn-3.0.3//:syn\",\n \"@crates__winnow-1.0.4//:winnow\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zvariant_utils\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"4.2.0\",\n)\n" + "build_file_content": "###############################################################################\n# @generated\n# DO NOT MODIFY: This file is auto-generated by a crate_universe tool. To \n# regenerate this file, run the following:\n#\n# bazel mod show_repo 'oh-my-pi'\n###############################################################################\n\nload(\"@rules_rust//cargo:defs.bzl\", \"cargo_toml_env_vars\")\n\nload(\"@rules_rust//rust:defs.bzl\", \"rust_library\")\n\n# buildifier: disable=bzl-visibility\nload(\"@rules_rust//crate_universe/private:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\ncargo_toml_env_vars(\n name = \"cargo_toml_env_vars\",\n src = \"Cargo.toml\",\n)\n\nrust_library(\n name = \"zvariant_utils\",\n deps = [\n \"@crates__proc-macro2-1.0.107//:proc_macro2\",\n \"@crates__quote-1.0.47//:quote\",\n \"@crates__serde-1.0.229//:serde\",\n \"@crates__syn-3.0.4//:syn\",\n \"@crates__winnow-1.0.4//:winnow\",\n ],\n compile_data = glob(\n allow_empty = True,\n include = [\"**\"],\n exclude = [\n \"**/* *\",\n \".tmp_git_root/**/*\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n ],\n ),\n crate_features = [\n \"default\",\n ],\n crate_root = \"src/lib.rs\",\n edition = \"2024\",\n rustc_env_files = [\n \":cargo_toml_env_vars\",\n ],\n rustc_flags = [\n \"--cap-lints=allow\",\n ],\n srcs = glob(\n allow_empty = True,\n include = [\"**/*.rs\"],\n ),\n tags = [\n \"cargo-bazel\",\n \"crate-name=zvariant_utils\",\n \"manual\",\n \"noclippy\",\n \"norustfmt\",\n ],\n target_compatible_with = select({\n \"@@//bazel/triples:aarch64-apple-darwin\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:aarch64-unknown-linux-musl\": [],\n \"@@//bazel/triples:x86_64-apple-darwin\": [],\n \"@@//bazel/triples:x86_64-pc-windows-msvc\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-gnu\": [],\n \"@@//bazel/triples:x86_64-unknown-linux-musl\": [],\n \"//conditions:default\": [\"@platforms//:incompatible\"],\n }),\n version = \"4.2.0\",\n)\n" } } } diff --git a/bazel/clippy.bazelrc b/bazel/clippy.bazelrc index c9750746b716..4b2ce304c4e4 100644 --- a/bazel/clippy.bazelrc +++ b/bazel/clippy.bazelrc @@ -1,6 +1,10 @@ # Generated by scripts/gen-clippy-bazelrc.ts from [workspace.lints] in Cargo.toml. # Do not edit by hand; run `bun run gen:clippy` after changing the lint policy. # Applies only to crates that opt in via `[lints] workspace = true`. +# The lint policy is authored against the rustup nightly, which may know +# lints the pinned bazel toolchain predates; those names must not become +# hard errors under the clippy aspect's -Dwarnings. +build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Aunknown_lints build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Amismatched_lifetime_syntaxes build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Wclippy::all build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Dclippy::correctness @@ -10,6 +14,7 @@ build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Wclippy::perf build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Wclippy::style build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Dclippy::suspicious build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Wclippy::allow_attributes_without_reason +build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Aclippy::assert_is_empty build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Aclippy::borrow_as_ptr build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Aclippy::cast_lossless build:clippy-strict --@rules_rust//rust/settings:clippy_flag=-Aclippy::cast_possible_truncation diff --git a/bazel/toolchains/BUILD.bazel b/bazel/toolchains/BUILD.bazel index a9d17f54cda4..fbff24f56f3a 100644 --- a/bazel/toolchains/BUILD.bazel +++ b/bazel/toolchains/BUILD.bazel @@ -10,6 +10,8 @@ # cc toolchain for x86_64-pc-windows-msvc cross builds from linux. package(default_visibility = ["//visibility:public"]) +# cc shim consumed by the sha2-asm crate annotation in MODULE.bazel. +exports_files(["sha2-asm-cc.sh"]) _MUSL_RUST_TOOLCHAINS = { "linux-x64-to-musl-x64": ( diff --git a/bazel/toolchains/sha2-asm-cc.sh b/bazel/toolchains/sha2-asm-cc.sh new file mode 100755 index 000000000000..c4948f362a26 --- /dev/null +++ b/bazel/toolchains/sha2-asm-cc.sh @@ -0,0 +1,28 @@ +#!/bin/sh +# cc shim for sha2-asm's build script under the hermetic zig cross toolchains. +# +# Two flags cc-rs emits are fatal to zig cc: +# * `--target=aarch64-unknown-linux-gnu`: the zig launcher appends its glibc +# suffix to a caller-supplied --target, producing the invalid 4-component +# triple `aarch64-unknown-linux-gnu.2.17`. Dropped — the launcher already +# injects the correct `-target aarch64-linux-gnu.2.17`. +# * `-march=armv8-a+crypto` (hardcoded in sha2-asm's build.rs): zig parses +# -march values with its own + syntax and rejects `armv8-a`. +# Rewritten to the assembler-scoped `-Wa,-march=…`, which zig forwards +# untouched (zig -mcpu features never reach .S assembly jobs). +# +# `CC` still points at the real zig wrapper: cc-rs selects this shim through +# the target-scoped CC_ override, which has higher precedence. +set -eu +n=$# +while [ "$n" -gt 0 ]; do + arg=$1 + shift + n=$((n - 1)) + case $arg in + --target=*) ;; + -march=armv8-a+crypto) set -- "$@" "-Wa,$arg" ;; + *) set -- "$@" "$arg" ;; + esac +done +exec "$CC" "$@" diff --git a/bun.lock b/bun.lock index a97edea44421..c9477d74e4ac 100644 --- a/bun.lock +++ b/bun.lock @@ -21,7 +21,7 @@ }, "packages/agent": { "name": "@oh-my-pi/pi-agent-core", - "version": "18.0.4", + "version": "18.0.11", "dependencies": { "@oh-my-pi/pi-ai": "catalog:", "@oh-my-pi/pi-catalog": "catalog:", @@ -40,8 +40,9 @@ }, "packages/ai": { "name": "@oh-my-pi/pi-ai", - "version": "18.0.4", + "version": "18.0.11", "dependencies": { + "@anthropic-ai/claude-agent-sdk": "^0.3.224", "@oh-my-pi/omptype": "catalog:", "@oh-my-pi/pi-catalog": "catalog:", "@oh-my-pi/pi-utils": "catalog:", @@ -61,19 +62,21 @@ }, "packages/catalog": { "name": "@oh-my-pi/pi-catalog", - "version": "18.0.4", + "version": "18.0.11", "dependencies": { + "@anthropic-ai/claude-agent-sdk": "^0.3.224", "@oh-my-pi/omptype": "catalog:", "@oh-my-pi/pi-utils": "catalog:", }, "devDependencies": { + "@bgotink/kdl": "0.4.0", "@oh-my-pi/pi-ai": "catalog:", "@types/bun": "catalog:", }, }, "packages/coding-agent": { "name": "@oh-my-pi/pi-coding-agent", - "version": "18.0.4", + "version": "18.0.11", "bin": { "omp": "src/cli.ts", }, @@ -90,6 +93,8 @@ "@oh-my-pi/pi-tui": "catalog:", "@oh-my-pi/pi-utils": "catalog:", "@oh-my-pi/pi-wire": "catalog:", + "@oh-my-pi/prime-bridge": "workspace:*", + "@oh-my-pi/prime-bridge-protocol": "workspace:*", "@oh-my-pi/snapcompact": "catalog:", "@opentelemetry/api": "catalog:", "@opentelemetry/api-logs": "catalog:", @@ -118,6 +123,7 @@ "dependencies": { "@oh-my-pi/pi-utils": "catalog:", "@oh-my-pi/pi-wire": "catalog:", + "katex": "catalog:", "lucide-react": "catalog:", "react": "catalog:", "react-dom": "catalog:", @@ -130,7 +136,7 @@ }, "packages/hashline": { "name": "@oh-my-pi/hashline", - "version": "18.0.4", + "version": "18.0.11", "dependencies": { "@oh-my-pi/pi-natives": "catalog:", "@oh-my-pi/pi-utils": "catalog:", @@ -154,6 +160,7 @@ "@oh-my-pi/pi-natives": "catalog:", "@oh-my-pi/pi-utils": "catalog:", "@oh-my-pi/typescript-edit-benchmark": "workspace:*", + "@stencil-hq/vibemon": "^0.3.2", "clsx": "^2.1.1", "d3-scale": "^4.0.2", "d3-shape": "^3.2.0", @@ -174,7 +181,7 @@ }, "packages/mnemopi": { "name": "@oh-my-pi/pi-mnemopi", - "version": "18.0.4", + "version": "18.0.11", "bin": { "mnemopi": "src/cli.ts", }, @@ -200,7 +207,7 @@ }, "packages/natives": { "name": "@oh-my-pi/pi-natives", - "version": "18.0.4", + "version": "18.0.11", "devDependencies": { "@napi-rs/cli": "catalog:", "@types/bun": "catalog:", @@ -215,7 +222,7 @@ }, "packages/omptype": { "name": "@oh-my-pi/omptype", - "version": "18.0.4", + "version": "18.0.11", "devDependencies": { "@ark/attest": "0.56.3", "@ark/schema": "0.56.2", @@ -226,9 +233,29 @@ "arktype": "2.2.3", }, }, + "packages/prime-bridge": { + "name": "@oh-my-pi/prime-bridge", + "version": "18.0.11", + "bin": { + "omp-prime-bridge": "./src/cli.ts", + }, + "dependencies": { + "@oh-my-pi/prime-bridge-protocol": "workspace:*", + }, + "devDependencies": { + "@types/bun": "catalog:", + }, + }, + "packages/prime-bridge-protocol": { + "name": "@oh-my-pi/prime-bridge-protocol", + "version": "18.0.11", + "devDependencies": { + "@types/bun": "catalog:", + }, + }, "packages/snapcompact": { "name": "@oh-my-pi/snapcompact", - "version": "18.0.4", + "version": "18.0.11", "dependencies": { "@oh-my-pi/pi-ai": "catalog:", "@oh-my-pi/pi-catalog": "catalog:", @@ -242,7 +269,7 @@ }, "packages/stats": { "name": "@oh-my-pi/omp-stats", - "version": "18.0.4", + "version": "18.0.11", "bin": { "omp-stats": "./src/index.ts", }, @@ -267,7 +294,7 @@ }, "packages/tui": { "name": "@oh-my-pi/pi-tui", - "version": "18.0.4", + "version": "18.0.11", "dependencies": { "@oh-my-pi/pi-natives": "catalog:", "@oh-my-pi/pi-utils": "catalog:", @@ -303,7 +330,7 @@ }, "packages/utils": { "name": "@oh-my-pi/pi-utils", - "version": "18.0.4", + "version": "18.0.11", "dependencies": { "@oh-my-pi/pi-natives": "catalog:", }, @@ -313,7 +340,7 @@ }, "packages/wire": { "name": "@oh-my-pi/pi-wire", - "version": "18.0.4", + "version": "18.0.11", "devDependencies": { "@types/bun": "catalog:", }, @@ -349,19 +376,21 @@ "@biomejs/biome": "^2.5.3", "@huggingface/transformers": "^4.2.0", "@napi-rs/cli": "3.7.2", - "@oh-my-pi/hashline": "18.0.4", - "@oh-my-pi/omp-stats": "18.0.4", - "@oh-my-pi/omptype": "18.0.4", - "@oh-my-pi/pi-agent-core": "18.0.4", - "@oh-my-pi/pi-ai": "18.0.4", - "@oh-my-pi/pi-catalog": "18.0.4", - "@oh-my-pi/pi-coding-agent": "18.0.4", - "@oh-my-pi/pi-mnemopi": "18.0.4", - "@oh-my-pi/pi-natives": "18.0.4", - "@oh-my-pi/pi-tui": "18.0.4", - "@oh-my-pi/pi-utils": "18.0.4", - "@oh-my-pi/pi-wire": "18.0.4", - "@oh-my-pi/snapcompact": "18.0.4", + "@oh-my-pi/hashline": "18.0.11", + "@oh-my-pi/omp-stats": "18.0.11", + "@oh-my-pi/omptype": "18.0.11", + "@oh-my-pi/pi-agent-core": "18.0.11", + "@oh-my-pi/pi-ai": "18.0.11", + "@oh-my-pi/pi-catalog": "18.0.11", + "@oh-my-pi/pi-coding-agent": "18.0.11", + "@oh-my-pi/pi-mnemopi": "18.0.11", + "@oh-my-pi/pi-natives": "18.0.11", + "@oh-my-pi/pi-tui": "18.0.11", + "@oh-my-pi/pi-utils": "18.0.11", + "@oh-my-pi/pi-wire": "18.0.11", + "@oh-my-pi/prime-bridge": "18.0.11", + "@oh-my-pi/prime-bridge-protocol": "18.0.11", + "@oh-my-pi/snapcompact": "18.0.11", "@opentelemetry/api": "^1.9.1", "@opentelemetry/api-logs": "^0.220.0", "@opentelemetry/context-async-hooks": "^2.9.0", @@ -384,6 +413,7 @@ "chart.js": "^4.5.1", "diff": "^9.0.0", "fastembed": "2.1.0", + "katex": "^0.18.4", "kitty-vt-wasm": "^0.2.0", "lint-staged": "^17.0.8", "lucide-react": "^1.24.0", @@ -403,6 +433,26 @@ "vite-plugin-solid": "^2.11.12", }, "packages": { + "@anthropic-ai/claude-agent-sdk": ["@anthropic-ai/claude-agent-sdk@0.3.251", "", { "optionalDependencies": { "@anthropic-ai/claude-agent-sdk-darwin-arm64": "0.3.251", "@anthropic-ai/claude-agent-sdk-darwin-x64": "0.3.251", "@anthropic-ai/claude-agent-sdk-linux-arm64": "0.3.251", "@anthropic-ai/claude-agent-sdk-linux-arm64-musl": "0.3.251", "@anthropic-ai/claude-agent-sdk-linux-x64": "0.3.251", "@anthropic-ai/claude-agent-sdk-linux-x64-musl": "0.3.251", "@anthropic-ai/claude-agent-sdk-win32-arm64": "0.3.251", "@anthropic-ai/claude-agent-sdk-win32-x64": "0.3.251" }, "peerDependencies": { "@anthropic-ai/sdk": ">=0.93.0", "@modelcontextprotocol/sdk": "^1.29.0", "zod": "^4.0.0" } }, "sha512-DqSi8mH2tQYRlVV0G+lJnQ/WbjJZ/a+8cJ3vPuYoqh8esIIvXHm1ZOXV1UPGsFYRnbBytEoiSGitguEXd+sQ+Q=="], + + "@anthropic-ai/claude-agent-sdk-darwin-arm64": ["@anthropic-ai/claude-agent-sdk-darwin-arm64@0.3.251", "", { "os": "darwin", "cpu": "arm64" }, "sha512-C23h+Dbddcc4gai95+lhm4/94am2IOq+bf3IdEDDS7EPqDQqajo2s5q1/ZSwq9rOc0RJLT7Ws72ZCzYJh67KSg=="], + + "@anthropic-ai/claude-agent-sdk-darwin-x64": ["@anthropic-ai/claude-agent-sdk-darwin-x64@0.3.251", "", { "os": "darwin", "cpu": "x64" }, "sha512-HrLnb3ggk+vMbymUvbosgPmxWp4W6Ot+0mNVjoBYDn5OZrTV3C3LRtbWf7jwcGyKMcg0xJf0AqiudQ2BRrlr8A=="], + + "@anthropic-ai/claude-agent-sdk-linux-arm64": ["@anthropic-ai/claude-agent-sdk-linux-arm64@0.3.251", "", { "os": "linux", "cpu": "arm64" }, "sha512-3E27F5j82EWOyEniRW7crmo0jWYYQmPDdP52jWq6Y6aytiyYIdUFMEGZZ6chVHNlZiU7GsjTa3teKk2xlQ68lQ=="], + + "@anthropic-ai/claude-agent-sdk-linux-arm64-musl": ["@anthropic-ai/claude-agent-sdk-linux-arm64-musl@0.3.251", "", { "os": "linux", "cpu": "arm64" }, "sha512-RTUf7TPBUkQ6oV3pDkEdcD47I0uH0ZpvmZlXHnrLGznFqyLr+7XHupOxUMJD0Jwm9v5qeqpNiPAYB0dL4RYiHg=="], + + "@anthropic-ai/claude-agent-sdk-linux-x64": ["@anthropic-ai/claude-agent-sdk-linux-x64@0.3.251", "", { "os": "linux", "cpu": "x64" }, "sha512-qCD87XPjcNM1u4ukqmcgpHDl3Y6l+cW8j7kPzH91Y5yLBYJ5xYZA2KtJ7AYNEPOteVyOGJw/efmva0S8CRr0fg=="], + + "@anthropic-ai/claude-agent-sdk-linux-x64-musl": ["@anthropic-ai/claude-agent-sdk-linux-x64-musl@0.3.251", "", { "os": "linux", "cpu": "x64" }, "sha512-SzXrdy7jjrjJIuTG+VMRAY0YZ3G/8w21WuhAozwnvnEUAPo6NDv6lgFinu7NO8J6CPE+MK2sGze6JeCF+ljgUg=="], + + "@anthropic-ai/claude-agent-sdk-win32-arm64": ["@anthropic-ai/claude-agent-sdk-win32-arm64@0.3.251", "", { "os": "win32", "cpu": "arm64" }, "sha512-FH1ZLcyc97ie3h7CSlIxA1ppXILgf0V8sFQrWnHyKBrthJXQkMHXhsTq9OZV/2KhXslNf2hTe0gHpZ1nCL1Gmg=="], + + "@anthropic-ai/claude-agent-sdk-win32-x64": ["@anthropic-ai/claude-agent-sdk-win32-x64@0.3.251", "", { "os": "win32", "cpu": "x64" }, "sha512-/jmtFIvfF0UFMxSZ8WV2Aus8aGA3+8Ft6AHvWuBJkY5jM2ubfqi6GnBjKCAL831TTllp2rKZlViANtWWRBvpvg=="], + + "@anthropic-ai/sdk": ["@anthropic-ai/sdk@0.122.0", "", { "dependencies": { "json-schema-to-ts": "^3.1.1", "standardwebhooks": "^1.0.0" }, "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" }, "optionalPeers": ["zod"], "bin": { "anthropic-ai-sdk": "bin/cli" } }, "sha512-GGPNftt0caaz9MDlmNQGHX8855Ojaduyy5pm9Sm1h7HalCn0cWNb5/bweadJF+4yzbal+QL6ztBa09WAAOzLmQ=="], + "@anush008/tokenizers": ["@anush008/tokenizers@0.0.0", "", { "optionalDependencies": { "@anush008/tokenizers-darwin-universal": "0.0.0", "@anush008/tokenizers-linux-x64-gnu": "0.0.0", "@anush008/tokenizers-win32-x64-msvc": "0.0.0" } }, "sha512-IQD9wkVReKAhsEAbDjh/0KrBGTEXelqZLpOBRDaIRvlzZ9sjmUP+gKbpvzyJnei2JHQiE8JAgj7YcNloINbGBw=="], "@anush008/tokenizers-darwin-universal": ["@anush008/tokenizers-darwin-universal@0.0.0", "", { "os": "darwin" }, "sha512-SACpWEooTjFX89dFKRVUhivMxxcZRtA3nJGVepdLyrwTkQ1TZQ8581B5JoXp0TcTMHfgnDaagifvVoBiFEdNCQ=="], @@ -449,29 +499,37 @@ "@babel/plugin-syntax-jsx": ["@babel/plugin-syntax-jsx@7.29.7", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.29.7" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-TSu8+mHCoEaaCDEZ0I3+6mvTBYR4PCxQwf2z9/r5Tbztv6NaLR3B9thGTTxX2WGuGHJqRiAbKPeGTJ5XWXVg6A=="], + "@babel/runtime": ["@babel/runtime@7.29.7", "", {}, "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw=="], + "@babel/template": ["@babel/template@7.29.7", "", { "dependencies": { "@babel/code-frame": "^7.29.7", "@babel/parser": "^7.29.7", "@babel/types": "^7.29.7" } }, "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg=="], "@babel/traverse": ["@babel/traverse@7.29.8", "", { "dependencies": { "@babel/code-frame": "^7.29.7", "@babel/generator": "^7.29.8", "@babel/helper-globals": "^7.29.7", "@babel/parser": "^7.29.8", "@babel/template": "^7.29.7", "@babel/types": "^7.29.8", "debug": "^4.3.1" } }, "sha512-I5z7H3bf/41ktsNVLtpN0wAa336HkqIHQ5BuPLEhTkt1jVSyZpeNKIzTgEWmlxjdg81R0IgUCcaE+Ok3NvrfZg=="], "@babel/types": ["@babel/types@7.29.8", "", { "dependencies": { "@babel/helper-string-parser": "^7.29.7", "@babel/helper-validator-identifier": "^7.29.7" } }, "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg=="], - "@biomejs/biome": ["@biomejs/biome@2.5.9", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.5.9", "@biomejs/cli-darwin-x64": "2.5.9", "@biomejs/cli-linux-arm64": "2.5.9", "@biomejs/cli-linux-arm64-musl": "2.5.9", "@biomejs/cli-linux-x64": "2.5.9", "@biomejs/cli-linux-x64-musl": "2.5.9", "@biomejs/cli-win32-arm64": "2.5.9", "@biomejs/cli-win32-x64": "2.5.9" }, "bin": { "biome": "bin/biome" } }, "sha512-KkgCvdHB4IhtpHpF564plA9jo6fDOwWGQ/3jvreLzgOtRLEDoPqr7QO9qejNA8jKwDsSkAKr77hqBHnyUbIw4g=="], + "@bgotink/kdl": ["@bgotink/kdl@0.4.0", "", {}, "sha512-F0uJCjo5FQvFdcGF5QbYVNfcGiRWlocuzyIdQxottZF2+gu6L2xjMGEu9PIpse2hifAca/19vIospgaETCKxIg=="], + + "@biomejs/biome": ["@biomejs/biome@2.5.10", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.5.10", "@biomejs/cli-darwin-x64": "2.5.10", "@biomejs/cli-linux-arm64": "2.5.10", "@biomejs/cli-linux-arm64-musl": "2.5.10", "@biomejs/cli-linux-x64": "2.5.10", "@biomejs/cli-linux-x64-musl": "2.5.10", "@biomejs/cli-win32-arm64": "2.5.10", "@biomejs/cli-win32-x64": "2.5.10" }, "bin": { "biome": "bin/biome" } }, "sha512-WRKXARA3kTuiV5sxqTpobJ/I0MVd4vk3pOL6wnp5az4LntFIhWTj1RWZq3DI9PCEN3lXcqy7p5aqUHzvq8AXyQ=="], - "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.5.9", "", { "os": "darwin", "cpu": "arm64" }, "sha512-am22pX2aBqznqq1eMyIj/bZ++riF3Lk6ct7cbv+gQK0csFhr+d8O0RkOi2FF2qSgFgANbqNkIZ0/PxlnW2pLFg=="], + "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.5.10", "", { "os": "darwin", "cpu": "arm64" }, "sha512-ItCrxKK6SXVT6flYs0qIuBd4AA3TTTl4d66Re6YI2FuGZnN85NmuYNzkiTJUyYw8qBLv69L5zTUB6uyWd++h3Q=="], - "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.5.9", "", { "os": "darwin", "cpu": "x64" }, "sha512-l44KWDHLDvEnD0N/XcrVs7VXb3A18xL7QS3WB0eL93wbmk529ffIG55vleGCqaunpRUjLrdnjK05Qki1dsjylg=="], + "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.5.10", "", { "os": "darwin", "cpu": "x64" }, "sha512-yLsPU9pAmtChXDu8vhKAzErqe+LeeYuwuUB2FZMkRitsmdodxsYRa9KHrFispsUHzzOu+9HB3nP/TQxyia+Sjw=="], - "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.5.9", "", { "os": "linux", "cpu": "arm64" }, "sha512-ICaK+IYaVZvKbBxX2rwrPT0DdUDMnE9Vm3nQGe+mltQPmUg19pONzkPWGdY4FCsoreDETWDynvdt4ysCbF5gNQ=="], + "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.5.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-VG8uQW/86a1roLaIFvtIbEigxIdzdJ190oGyg1tV7VYeQtOS+x10sflk7WbuXgw91EtZX5DlIIIej1YqkNLlcg=="], - "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.5.9", "", { "os": "linux", "cpu": "arm64" }, "sha512-7ImVPwBLCtkmpR5esd8RHhTqW94f0JLJQum6AneYcy94jRm18TaPPm7slaigGzFhfgt3QiD1Vj52LKmBAnKizA=="], + "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.5.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-t1QAKZwQJRB4dvgJSgFiQ4BNfNPChg69BNonz854qLVxnjT3UvDzQg9mbkTJRu35ZqU0Rw10A73J8Urgbg2RPw=="], - "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.5.9", "", { "os": "linux", "cpu": "x64" }, "sha512-z22Q/zFYSvbIJfW1CbfZPu4X8PddS6Qd2ORbc6h+aT6EcwAxUF3m6fA4HjNvA3TU4X0dTJRwNPB165ES3PJXzg=="], + "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.5.10", "", { "os": "linux", "cpu": "x64" }, "sha512-4O6T0eq2heoHZN0a9UX+rWQoxXEBaKf+lRi2hbsGlHneUz9BWXM76nEWMK7Eeq8gzMxR1khQB6BFpAASpeXqGg=="], - "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.5.9", "", { "os": "linux", "cpu": "x64" }, "sha512-RXGaD0o1/pTTguYw1aeDJh9ad6Lfrui0fI7mBderTyGr7WuUJkBIttgLkR3XJyoxOkkgfBDspaUT8wXArTqLZw=="], + "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.5.10", "", { "os": "linux", "cpu": "x64" }, "sha512-pgDDqp9JybHm2I0KRgzN6i4+lt8xu4iqxUwLzglUMmOmyRTU1AYBGKzh9sNMOtIjah7xoWvKHlLVetvyifzoiQ=="], - "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.5.9", "", { "os": "win32", "cpu": "arm64" }, "sha512-nHK+/HHC+D0ogAHUxomgoSTdjImb6fmNNVTKmf0tyu4eDL1DqPKIHc+i+UL8+b0RnAu8224qo8F2tCVnaT0A3w=="], + "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.5.10", "", { "os": "win32", "cpu": "arm64" }, "sha512-pxAbxduPO4xq/Cvgaa2lOrs9BB0hEXmmDqfMNP4ZOffGOkUrD1/QGw9UAMpFQpX2P8MqTIIRuQKcmetum4Oa6A=="], - "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.5.9", "", { "os": "win32", "cpu": "x64" }, "sha512-Yiq0H56LjXSSw/hd9YkXgSLQfzyDJzbzU2TezozxyNw+uKWAqOtqGVvBfzKRRDiaFF5avGAhHdWKx7LtDOShUw=="], + "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.5.10", "", { "os": "win32", "cpu": "x64" }, "sha512-M+2dgBsl3lXRiTfgPVc2p3anS4Tocojke4rzFLScZ2Y/wmF+36dRb1iHCLiyGqOzQGyTplZH1HnEYviiAqi3nA=="], + + "@bufbuild/protobuf": ["@bufbuild/protobuf@2.14.0", "", {}, "sha512-C3UGsiCwSprE2NKIIFA3hCDlpXTMCAXRZuEVp88L1GY36Y41+rYL5fryE+nOFhp4p4JPQvdV8PQ4DWgHgeTE+w=="], + + "@connectrpc/connect": ["@connectrpc/connect@2.1.2", "", { "peerDependencies": { "@bufbuild/protobuf": "^2.7.0" } }, "sha512-MXkBijtcX09R10Eb6sFeIetc6w6746eio6xtfuyVOH7oQAacT1X0GzMIQFux6Qy8cq3W/T5qX5Bei8YbFtmRGA=="], "@emnapi/core": ["@emnapi/core@1.9.2", "", { "dependencies": { "@emnapi/wasi-threads": "1.2.1", "tslib": "^2.4.0" } }, "sha512-UC+ZhH3XtczQYfOlu3lNEkdW/p4dsJ1r/bP7H8+rhao3TTTMO1ATq/4DdIi23XuGoFY+Cz0JmCbdVl0hz9jZcA=="], @@ -479,19 +537,21 @@ "@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.2.1", "", { "dependencies": { "tslib": "^2.4.0" } }, "sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w=="], + "@hono/node-server": ["@hono/node-server@2.1.1", "", { "peerDependencies": { "hono": "^4" } }, "sha512-ELuehkj5VCBdgEw9zs+ivkKwyzzUCSQuE96YmiPvn1ECBoZCczbFXJLeEGMTYjphP6gydh4pHMqEYPVMYUVgQg=="], + "@huggingface/blake3-jit": ["@huggingface/blake3-jit@0.0.2", "", {}, "sha512-Bq7B5qabyjrJfhBsl85Jd2QBtf+HzRD7h7A9GfN2lzrrsABhOa5evVPgzoCTxR7Ub0QFj7YDK1YkYRWBU25+2w=="], - "@huggingface/hub": ["@huggingface/hub@2.15.0", "", { "dependencies": { "@huggingface/tasks": "^0.21.33", "@huggingface/xetchunk-wasm": "^0.1.0" }, "optionalDependencies": { "cli-progress": "^3.12.0" }, "bin": { "hfjs": "dist/cli.js" } }, "sha512-+sHWNz0YpqTvwuIYDxpyrhyk1o2j9lIJuPzbhUT0kxU8IHP9ZOzeajk/O6RRbZyvAM9h6m219FghDLi0Ayblww=="], + "@huggingface/hub": ["@huggingface/hub@2.16.0", "", { "dependencies": { "@huggingface/tasks": "^0.21.36", "@huggingface/xetchunk-wasm": "^0.2.0" }, "optionalDependencies": { "cli-progress": "^3.12.0" }, "bin": { "hfjs": "dist/cli.js" } }, "sha512-03sZFAiuxCuxWs2WC1w4s1uKCghvfxLsNm053EWDezk/eefvaiRpNjIKXNe7vbO8NBtLDAmlN6/cyf5n3IGaqw=="], "@huggingface/jinja": ["@huggingface/jinja@0.5.9", "", {}, "sha512-uWTG+l3VJRsl7EXxYizuL3P+cCPoc3cRqbWWRcQN0FhejRfbdq0RNhCmbY/YDtnTcz9icdLYuLDjsnz4d8JMuw=="], - "@huggingface/tasks": ["@huggingface/tasks@0.21.35", "", {}, "sha512-Nqw/E01EE8Ykxp44qpsgxyu8g486mAiCWHdkHD6+c0aFU1kdtxsUUrv1AD4Zp4ePlV5sf95A/gKbLLoXP0NXqw=="], + "@huggingface/tasks": ["@huggingface/tasks@0.21.40", "", {}, "sha512-AaCt/0vjNZ+6WIsiLBzcCEHBQtYcz3lKn7+EFSu6Yw5xPBABYtky/iTsgEZrR41QYJqJLT54V2Q7YL1+pGb8Jw=="], "@huggingface/tokenizers": ["@huggingface/tokenizers@0.1.3", "", {}, "sha512-8rF/RRT10u+kn7YuUbUg0OF30K8rjTc78aHpxT+qJ1uWSqxT1MHi8+9ltwYfkFYJzT/oS+qw3JVfHtNMGAdqyA=="], "@huggingface/transformers": ["@huggingface/transformers@4.2.0", "", { "dependencies": { "@huggingface/jinja": "^0.5.6", "@huggingface/tokenizers": "^0.1.3", "onnxruntime-node": "1.24.3", "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c", "sharp": "^0.34.5" } }, "sha512-8BRCoBMH0XsWaEIamuR0LrJGAfftgHAfb2Vrffy0VKlSAE/MnUJ5/h/zTfEP3fDIft+nk7TqB8xXEyABGitBjQ=="], - "@huggingface/xetchunk-wasm": ["@huggingface/xetchunk-wasm@0.1.0", "", { "dependencies": { "@huggingface/blake3-jit": "0.0.2", "gearhash-jit": "1.0.2" } }, "sha512-wWpp2qwPgf9kv1KLJjcDUk/OrpDOsFoQ3Qpz0U5LGn20csoymBf8eneOv6wm/GzPBzlWac1OYiR0aa1vT6aM2Q=="], + "@huggingface/xetchunk-wasm": ["@huggingface/xetchunk-wasm@0.2.0", "", { "dependencies": { "@huggingface/blake3-jit": "0.0.2", "gearhash-jit": "1.0.2" } }, "sha512-cmp7oAAWeCpZGrVQTP/LxDtJdzGMfpxwkEVsZsk5jZQ2FwP2njm8LnyobhnQvLpkSAcJJwUzFJC0PYS9ZsqeTg=="], "@img/colour": ["@img/colour@1.1.0", "", {}, "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ=="], @@ -589,6 +649,8 @@ "@kurkle/color": ["@kurkle/color@0.3.4", "", {}, "sha512-M5UknZPHRu3DEDWoipU6sE8PdkZ6Z/S+v4dD+Ke8IaNlpdSQah50lz1KtcFBa2vsdOnwbbnxJwVM4wty6udA5w=="], + "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.30.0", "", { "dependencies": { "@hono/node-server": "^1.19.9 || ^2.0.5", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.2.1", "express-rate-limit": "^8.2.1", "hono": "^4.11.4", "jose": "^6.1.3", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-xKd8OIzlqNzcqcNumGAa6g+PW2kjD5vrpcKOnfldAUPP3j7lnqMPwlTXQm8gF+UwH72z0lqaRbjr9hqGz0eITA=="], + "@napi-rs/cli": ["@napi-rs/cli@3.7.2", "", { "dependencies": { "@inquirer/prompts": "^8.5.2", "@napi-rs/cross-toolchain": "^1.0.3", "@napi-rs/wasm-tools": "^1.0.1", "@octokit/rest": "^22.0.1", "clipanion": "^4.0.0-rc.4", "colorette": "^2.0.20", "emnapi": "^1.11.1", "es-toolkit": "^1.47.0", "js-yaml": "^4.2.0", "obug": "^2.1.2", "semver": "^7.8.2", "typanion": "^3.14.0" }, "peerDependencies": { "@emnapi/runtime": "^1.7.1" }, "optionalPeers": ["@emnapi/runtime"], "bin": { "napi": "dist/cli.js", "napi-raw": "cli.mjs" } }, "sha512-shDW0Td/XZQpP04Yy+OsMt1ILMKGGkoLcy1zVAsSAK0fLfWm0Upgkmfs/NOV2ZhMQwkgpR3ZEdyHmTwgrUDQuA=="], "@napi-rs/cross-toolchain": ["@napi-rs/cross-toolchain@1.0.3", "", { "dependencies": { "@napi-rs/lzma": "^1.4.5", "@napi-rs/tar": "^1.1.0", "debug": "^4.4.1" }, "peerDependencies": { "@napi-rs/cross-toolchain-arm64-target-aarch64": "^1.0.3", "@napi-rs/cross-toolchain-arm64-target-armv7": "^1.0.3", "@napi-rs/cross-toolchain-arm64-target-ppc64le": "^1.0.3", "@napi-rs/cross-toolchain-arm64-target-s390x": "^1.0.3", "@napi-rs/cross-toolchain-arm64-target-x86_64": "^1.0.3", "@napi-rs/cross-toolchain-x64-target-aarch64": "^1.0.3", "@napi-rs/cross-toolchain-x64-target-armv7": "^1.0.3", "@napi-rs/cross-toolchain-x64-target-ppc64le": "^1.0.3", "@napi-rs/cross-toolchain-x64-target-s390x": "^1.0.3", "@napi-rs/cross-toolchain-x64-target-x86_64": "^1.0.3" }, "optionalPeers": ["@napi-rs/cross-toolchain-arm64-target-aarch64", "@napi-rs/cross-toolchain-arm64-target-armv7", "@napi-rs/cross-toolchain-arm64-target-ppc64le", "@napi-rs/cross-toolchain-arm64-target-s390x", "@napi-rs/cross-toolchain-arm64-target-x86_64", "@napi-rs/cross-toolchain-x64-target-aarch64", "@napi-rs/cross-toolchain-x64-target-armv7", "@napi-rs/cross-toolchain-x64-target-ppc64le", "@napi-rs/cross-toolchain-x64-target-s390x", "@napi-rs/cross-toolchain-x64-target-x86_64"] }, "sha512-ENPfLe4937bsKVTDA6zdABx4pq9w0tHqRrJHyaGxgaPq03a2Bd1unD5XSKjXJjebsABJ+MjAv1A2OvCgK9yehg=="], @@ -709,7 +771,7 @@ "@octokit/plugin-rest-endpoint-methods": ["@octokit/plugin-rest-endpoint-methods@17.0.0", "", { "dependencies": { "@octokit/types": "^16.0.0" }, "peerDependencies": { "@octokit/core": ">=6" } }, "sha512-B5yCyIlOJFPqUUeiD0cnBJwWJO8lkJs5d8+ze9QDP6SvfiXSz1BF+91+0MeI1d2yxgOhU/O+CvtiZ9jSkHhFAw=="], - "@octokit/request": ["@octokit/request@10.0.14", "", { "dependencies": { "@octokit/endpoint": "^11.0.3", "@octokit/request-error": "^7.1.1", "@octokit/types": "^17.0.0", "content-type": "^2.0.0", "json-with-bigint": "^3.5.12", "universal-user-agent": "^7.0.2" } }, "sha512-bgWgiSfFS689/AxQDarU+b3Qu1FYewfVr5vI/jhV84s7GQ3C2OsdRxukGGYKB37MCgwcS50UrfBLlHzhiG13sw=="], + "@octokit/request": ["@octokit/request@10.0.15", "", { "dependencies": { "@octokit/endpoint": "^11.0.3", "@octokit/request-error": "^7.1.1", "@octokit/types": "^17.0.0", "content-type": "^3.0.0", "json-with-bigint": "^3.5.12", "universal-user-agent": "^7.0.2" } }, "sha512-3CBg9aJ0hO9Pjyij8LbK/xYtEaPws9SW7xKz67daPNxQB1q5Y9OMA7DDOG0A6Hwf9ygGu3tvzusg0LXQ8/wAjA=="], "@octokit/request-error": ["@octokit/request-error@7.1.1", "", { "dependencies": { "@octokit/types": "^17.0.0" } }, "sha512-+eaY7G2VVpSf2pc5Gn1+mph837V/d/TYTJAgWL9Tb0ogGYcpN3IlAVFgjL+Vv93F/sevrxkvsYCedtpLdcFLzA=="], @@ -747,6 +809,10 @@ "@oh-my-pi/pi-wire": ["@oh-my-pi/pi-wire@workspace:packages/wire"], + "@oh-my-pi/prime-bridge": ["@oh-my-pi/prime-bridge@workspace:packages/prime-bridge"], + + "@oh-my-pi/prime-bridge-protocol": ["@oh-my-pi/prime-bridge-protocol@workspace:packages/prime-bridge-protocol"], + "@oh-my-pi/snapcompact": ["@oh-my-pi/snapcompact@workspace:packages/snapcompact"], "@oh-my-pi/typescript-edit-benchmark": ["@oh-my-pi/typescript-edit-benchmark@workspace:packages/typescript-edit-benchmark"], @@ -785,7 +851,7 @@ "@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.43.0", "", {}, "sha512-eSYWTm620tTk45EKSedaUL8MFYI8hW164hIXsgIHyxu3VobUB3fFCu5t0hQby6OoWRPsG1KkKUG2M5UadiLiVg=="], - "@oxc-project/types": ["@oxc-project/types@0.146.0", "", {}, "sha512-XC0QsnnhVe7sLIWmYmdPw7x5P0h4W8vUU3Nv1ySgWXtvCz8NizoAEpGXA0sOYoJQV2Rl13LgURAHQ5cI5ILCSA=="], + "@oxc-project/types": ["@oxc-project/types@0.147.0", "", {}, "sha512-IJ3s6ltHLp45S0bh7phkX+gJO7A1Wuz2EaqpAhb8WjqDwbzMiWKHhyyT42tskaWjEYXtHtVCPpnBJVT9+dcRLg=="], "@prettier/sync": ["@prettier/sync@0.6.1", "", { "dependencies": { "make-synchronized": "^0.8.0" }, "peerDependencies": { "prettier": "*" } }, "sha512-yF9G8vK/LYUTF3Cijd7VC9La3b20F20/J/fgoR4H0B8JGOWnZVZX6+I6+vODPosjmMcpdlUV+gUqJQZp3kLOcw=="], @@ -809,40 +875,44 @@ "@puppeteer/browsers": ["@puppeteer/browsers@3.0.6", "", { "dependencies": { "modern-tar": "^0.7.6", "yargs": "^18.0.0" }, "peerDependencies": { "proxy-agent": ">=8.0.1", "yauzl": "^2.10.0 || ^3.4.0" }, "optionalPeers": ["proxy-agent", "yauzl"], "bin": { "browsers": "lib/main-cli.js" } }, "sha512-B/gKoqlFkzhvzsI6jo9K1cZz9o5ypviVv/xu8CwA4grZzyVwN+XfkT+tu8T1zrauuEXv6VhS2oGX+6NL95WcKA=="], - "@rolldown/binding-android-arm-eabi": ["@rolldown/binding-android-arm-eabi@1.2.5", "", { "os": "android", "cpu": "arm" }, "sha512-DLe/i+l8ynIBY7XEQ191TeZvCoowIGa18R+dIV30GW7DiOtp74i/xX8hs8GUjW5ARV7VZuie3d6AumSmCwbeRA=="], + "@rolldown/binding-android-arm-eabi": ["@rolldown/binding-android-arm-eabi@1.2.6", "", { "os": "android", "cpu": "arm" }, "sha512-b+jTcARdTiFLI6jB4a5XjTm0RWd6KcRfQj/I2356fxUZemiho9zQLxo0RtCuMDAyKcLo6cEltkgbQp6d1+sjjQ=="], - "@rolldown/binding-android-arm64": ["@rolldown/binding-android-arm64@1.2.5", "", { "os": "android", "cpu": "arm64" }, "sha512-zXcwKlQApYAOELHd8PwKDFkagYF9Wy4e0RJ+0qnzl9Pjnpj75TEG8ufv40p2J7kCEfwZAsNiuzRIyNNMWT38ig=="], + "@rolldown/binding-android-arm64": ["@rolldown/binding-android-arm64@1.2.6", "", { "os": "android", "cpu": "arm64" }, "sha512-lkWU8ZJaRk9q3CIEY1Tc7vIFALp3Xw5NfGJo2hQg5oIqNgxWi1zI+IiDEK3r70BF5Dzol1tcXsnzsRc8NLhG+Q=="], - "@rolldown/binding-darwin-arm64": ["@rolldown/binding-darwin-arm64@1.2.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-dK4QakI42nzWgJT5sm4y4y/O//D4OxM75/cH28RLV+nzIN9AY+YsbuUVrUTjlLjXR6vpyxFbSsbmNuJ6BP9sww=="], + "@rolldown/binding-darwin-arm64": ["@rolldown/binding-darwin-arm64@1.2.6", "", { "os": "darwin", "cpu": "arm64" }, "sha512-dgR56NYnvAszm7Ob1B2/Vn0e8bUQYZH2UjVaMMtMVOCKFSfjhfLmuA/9+O+F+ajUdG6B/bSssrKW6JJYASa8jA=="], - "@rolldown/binding-darwin-x64": ["@rolldown/binding-darwin-x64@1.2.5", "", { "os": "darwin", "cpu": "x64" }, "sha512-fqSALaUu1Wjd1nK2uW2kJDWdLCc8lx1IcY+MTY26Aurfdx19anlzhqXOgCFbBFQnlFDTn4TC1/7Nz4Bl2mLP3A=="], + "@rolldown/binding-darwin-x64": ["@rolldown/binding-darwin-x64@1.2.6", "", { "os": "darwin", "cpu": "x64" }, "sha512-vpVxFvUCFioJqug7OTvqptkc4yb8UX0AwfDmJpaR/0sWz+BUmqSVAf7c8JkUgnN8YLspb4a/N6NhTyMAmdyQ7Q=="], - "@rolldown/binding-freebsd-x64": ["@rolldown/binding-freebsd-x64@1.2.5", "", { "os": "freebsd", "cpu": "x64" }, "sha512-/vCnNxlkxs9tKxNDcyWUePpJ/PgTzxIaVhoM5SmG8UV+GR/IcPam4VYxi7GIMo7PSDuNqlJqvprqii9NqqVCMw=="], + "@rolldown/binding-freebsd-x64": ["@rolldown/binding-freebsd-x64@1.2.6", "", { "os": "freebsd", "cpu": "x64" }, "sha512-h1wG6Y6K3JlRswxsI64qQJqBAy4vrLuHgRbc8CZMGSWTOFRY6ghMApM1NKzB2I0n5xV1fjkE18SuVl2QpLeNpA=="], - "@rolldown/binding-linux-arm-gnueabihf": ["@rolldown/binding-linux-arm-gnueabihf@1.2.5", "", { "os": "linux", "cpu": "arm" }, "sha512-abk0NLA519LxRCszmbE0jYKuQ9YPocOXTiOXOo6Yr+YAT95VH+PtqYAjOJvGKt3viEd/x4qzabAlwd5bHOOARg=="], + "@rolldown/binding-linux-arm-gnueabihf": ["@rolldown/binding-linux-arm-gnueabihf@1.2.6", "", { "os": "linux", "cpu": "arm" }, "sha512-tbCiqub0q2MVWJKgF5PoAlNWCtQydiOYSLIkd8sByqK/6MMYLJRcSXSYodqYtd0O+Fw7QaVmKKlS4oL94YRZ0w=="], - "@rolldown/binding-linux-arm64-gnu": ["@rolldown/binding-linux-arm64-gnu@1.2.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-Y7eALiJ8lr0M2HH103Js+g7V34wf6snlpZLAsHI90uLhr3PVlNsbFVAXJC9d/V6BnPyKtpSwI+NcB/RLxsQxuA=="], + "@rolldown/binding-linux-arm64-gnu": ["@rolldown/binding-linux-arm64-gnu@1.2.6", "", { "os": "linux", "cpu": "arm64" }, "sha512-oxK9+baEBPhZG5HB4URY+uU04zJWeZlH6Tb9rB5DK4DF9XR1uXNLXt5Q5ZsugTKayNCNLhkcwz/ye74hRI98dg=="], - "@rolldown/binding-linux-arm64-musl": ["@rolldown/binding-linux-arm64-musl@1.2.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-xMvZgnbZg4YVnR/AX2b3oOPDTFYJvUVaJg5FedA/LuvexAtXibZQej4cnTkw3rjsJ/ggUROB64TdtETiim+FYA=="], + "@rolldown/binding-linux-arm64-musl": ["@rolldown/binding-linux-arm64-musl@1.2.6", "", { "os": "linux", "cpu": "arm64" }, "sha512-muWCk27FVBEZtv0MsK8gnfSmgczA8KQ0uRVJbTABKhkRfQc38aUrcb7fhi3BNiyseFmgcRsoMfQsSNJ+DbZdSw=="], - "@rolldown/binding-linux-ppc64-gnu": ["@rolldown/binding-linux-ppc64-gnu@1.2.5", "", { "os": "linux", "cpu": "ppc64" }, "sha512-GRjeqTUDHTo5GwntsLaAMcBahG3nlpjftXWZLN73HiYQlhwEowvarFgQnRnQZtIp4keXX7quXFbG38uPZBa2EA=="], + "@rolldown/binding-linux-ppc64-gnu": ["@rolldown/binding-linux-ppc64-gnu@1.2.6", "", { "os": "linux", "cpu": "ppc64" }, "sha512-eWDoSfU7Co2qj3vgB3Dt4lj1mG6CoWbcJQkRMP3XJplyCMtuaq3LHvPFjS9QIPvMGWVadJC04Xiy0IdcVPtnwQ=="], - "@rolldown/binding-linux-s390x-gnu": ["@rolldown/binding-linux-s390x-gnu@1.2.5", "", { "os": "linux", "cpu": "s390x" }, "sha512-vLNTR45F2Uwc8AufkNXPmB4VliaXs+FvcheEogIzOXzO4l+LzieXF5A/TWxLy5HtqpsRCHUfd0lPVrrdgXdLHQ=="], + "@rolldown/binding-linux-s390x-gnu": ["@rolldown/binding-linux-s390x-gnu@1.2.6", "", { "os": "linux", "cpu": "s390x" }, "sha512-2bWNjRSIayvupRKxXUY2tWG9fYdoUlTqWywHRvE8Eq3GvuQ+f2HeIkve697fIt+IQs/PV8yFsdWuhp1aJ1PdnA=="], - "@rolldown/binding-linux-x64-gnu": ["@rolldown/binding-linux-x64-gnu@1.2.5", "", { "os": "linux", "cpu": "x64" }, "sha512-Mgj59/HTuYeK9Gz2MA+mBWKnHsAgkBSec15ZMb1st3oIfFbX7gCjOae7GydHhzcyQi9Z/7M1QuN9bR3oFqF0jQ=="], + "@rolldown/binding-linux-x64-gnu": ["@rolldown/binding-linux-x64-gnu@1.2.6", "", { "os": "linux", "cpu": "x64" }, "sha512-KekI0gS0wLxe1UBSQSjenBVwou/JkcQPDzBPICGZjxUv9k3RteHDPBQaiOicZUFKRIH2wKEimGwVpnJsbPzu7w=="], - "@rolldown/binding-linux-x64-musl": ["@rolldown/binding-linux-x64-musl@1.2.5", "", { "os": "linux", "cpu": "x64" }, "sha512-mY8AP0/ichsbhAxGnLa3d3+MwV0EfgrPND2bplI3Ym8T6R2pJ0N87bvrKVwNXmdy3jnr6eQBecdqx/HMknBmpA=="], + "@rolldown/binding-linux-x64-musl": ["@rolldown/binding-linux-x64-musl@1.2.6", "", { "os": "linux", "cpu": "x64" }, "sha512-TvtPnfVr+HtyGiDmPK4VWmlNm7QhNNAcK5Q9A7aOXsI8545yCyaoMaicXrFZ72JzeYjaUVk7yT243zT0jzjFKQ=="], - "@rolldown/binding-openharmony-arm64": ["@rolldown/binding-openharmony-arm64@1.2.5", "", { "os": "none", "cpu": "arm64" }, "sha512-8SLssA2oweAxyRgDp789ACfRb/3P+zNRJpzZxSizxF9m8NUDQ4+3xjo8ttjhVGGw6Qxb70oZiEtIjaKikCO7Yw=="], + "@rolldown/binding-openharmony-arm64": ["@rolldown/binding-openharmony-arm64@1.2.6", "", { "os": "none", "cpu": "arm64" }, "sha512-iOo0VEay2XFhaCcH0sps5XIimkSuOnNaZrf6+ZkoSOQBJPKNU48RkmJv0/lSpipexu5P+ouFgafe5IGr/DiQfg=="], - "@rolldown/binding-win32-arm64-msvc": ["@rolldown/binding-win32-arm64-msvc@1.2.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-vGbruD5zquhoc8D9SViXgN2FBJtNdTyQ4DtG+SWiEGlJiAzoKcZ2xp+xuXCffhubVdt0NJlTZqkeRuERy7g8Cw=="], + "@rolldown/binding-win32-arm64-msvc": ["@rolldown/binding-win32-arm64-msvc@1.2.6", "", { "os": "win32", "cpu": "arm64" }, "sha512-y5NTmmasMS455JlOCO4ZM9krIchv3Mvm1crL1iUPGOPgEzSkves9n0SdC5Sjz6+qWDFhd8/JpfWMH8NSWNHe+A=="], - "@rolldown/binding-win32-x64-msvc": ["@rolldown/binding-win32-x64-msvc@1.2.5", "", { "os": "win32", "cpu": "x64" }, "sha512-e/SXpgISz+IoqVcSSI0rx/d/he8zqLex+/rCWpnHpmVfmPIUjag9H6P7zotf0gJHwPUhQxZ/mF8tr6acebT9yw=="], + "@rolldown/binding-win32-x64-msvc": ["@rolldown/binding-win32-x64-msvc@1.2.6", "", { "os": "win32", "cpu": "x64" }, "sha512-np8iZSLfXlAD4kWhiyq/u0Yt8oZDtRQ8lGhQaCXo2rl37KNjeU0GjJuwr4P3oeZ++ROfofsKNBqR5LTO8aXyWQ=="], "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.1", "", {}, "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw=="], "@sinclair/typebox": ["@sinclair/typebox@0.34.52", "", {}, "sha512-XiMQh7qqVlxZzcVD+kkGMNGMzcTrDMLWI7S4x7z1MkCkbDPrekpZXEUK0eZqZFMuHQg2a2DZOcDIh9o5v3Gonw=="], + "@stablelib/base64": ["@stablelib/base64@1.0.1", "", {}, "sha512-1bnPQqSxSuc3Ii6MhBysoWCg58j97aUjuCSZrGSmDxNqtytIi0k8utUenAwTZN4V5mXXYGsVUI9zeBqy+jBOSQ=="], + + "@stencil-hq/vibemon": ["@stencil-hq/vibemon@0.3.2", "", { "dependencies": { "@bufbuild/protobuf": "^2", "@connectrpc/connect": "^2" } }, "sha512-ddVS9+iAXlRsnrfo6XzP9L2SiAHKOZsF51iup+0F8F0uV9ry/P+KUk3seo5vETnvZf2ArTdBCbmBfhXxPLYImQ=="], + "@tailwindcss/node": ["@tailwindcss/node@4.3.3", "", { "dependencies": { "@jridgewell/remapping": "^2.3.5", "enhanced-resolve": "^5.24.1", "jiti": "^2.7.0", "lightningcss": "1.32.0", "magic-string": "^0.30.21", "source-map-js": "^1.2.1", "tailwindcss": "4.3.3" } }, "sha512-/T8IKEsf9VTU6tLjgC7+sv2mOPtQxzE2jMw7u4Tt40Tx+QSZxpzh95/H6cMKoja9XuW7iMdLJYBB0o9G1CaAgg=="], "@tailwindcss/oxide": ["@tailwindcss/oxide@4.3.3", "", { "optionalDependencies": { "@tailwindcss/oxide-android-arm64": "4.3.3", "@tailwindcss/oxide-darwin-arm64": "4.3.3", "@tailwindcss/oxide-darwin-x64": "4.3.3", "@tailwindcss/oxide-freebsd-x64": "4.3.3", "@tailwindcss/oxide-linux-arm-gnueabihf": "4.3.3", "@tailwindcss/oxide-linux-arm64-gnu": "4.3.3", "@tailwindcss/oxide-linux-arm64-musl": "4.3.3", "@tailwindcss/oxide-linux-x64-gnu": "4.3.3", "@tailwindcss/oxide-linux-x64-musl": "4.3.3", "@tailwindcss/oxide-wasm32-wasi": "4.3.3", "@tailwindcss/oxide-win32-arm64-msvc": "4.3.3", "@tailwindcss/oxide-win32-x64-msvc": "4.3.3" } }, "sha512-krXjAikiaFSPaK/FkAQT5UTx3VormQaiZ5hBFlJZ9UFQGB/rwg1MZIhHAG9smMQRTdyJxP6Qt5MwMtdyU5FWrA=="], @@ -891,15 +961,15 @@ "@types/d3-scale": ["@types/d3-scale@4.0.9", "", { "dependencies": { "@types/d3-time": "*" } }, "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw=="], - "@types/d3-shape": ["@types/d3-shape@3.1.8", "", { "dependencies": { "@types/d3-path": "*" } }, "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w=="], + "@types/d3-shape": ["@types/d3-shape@3.2.0", "", { "dependencies": { "@types/d3-path": "*" } }, "sha512-kVd74ta9eof3eJOvbNd1vGKS/XERRyQbT26Og63hIsvDO84cjD5gEOhsXf26w3FSoNlPVz84DOFcKv/oou+fMw=="], "@types/d3-time": ["@types/d3-time@3.0.4", "", {}, "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g=="], - "@types/node": ["@types/node@26.2.0", "", { "dependencies": { "undici-types": "~8.3.0" } }, "sha512-5IviulTZeRNp2vAJ514cc/HUlY5nZ9fCbq9DMyC52BrhFZACo3nI0R7qBxhQmo/d27NFe96ur/b7Wwxklda+kg=="], + "@types/node": ["@types/node@26.3.0", "", { "dependencies": { "undici-types": "~8.3.0" } }, "sha512-L3fgrnchriRC2ExBflb8j4uZZURHZfQsmQeyVzhjcHW4kkwVyo8/0h1B2MVzMTrYUJYu6G7EWs14hW/L9putqw=="], "@types/react": ["@types/react@19.2.18", "", { "dependencies": { "csstype": "^3.2.2" } }, "sha512-AnzbBERsrLKtk2XSfTbYRLjQPdy116Sty4q+T+Bp3IC4l6jNBvreVPAHmpq9qhXQM7CXZPjLVmGMw9sy+hxQ3w=="], - "@types/react-dom": ["@types/react-dom@19.2.4", "", { "peerDependencies": { "@types/react": "^19.2.0" } }, "sha512-Bsc+QHgp+P/F02XDzNCY9jnZNCUuLki36KT7VKrTXXLdHf+vHMNZnW1rVu5DNW/rCK+fya3DATySbLM4yhtKUw=="], + "@types/react-dom": ["@types/react-dom@19.2.5", "", { "peerDependencies": { "@types/react": "^19.2.0" } }, "sha512-fMPwH9v7r/pp43yUd2/Mbiex5KouJwwR3dzHkhLREUC6764VyDsqxhAxv6OFEYR1RhjOyD1naqba8ECDBe7ZQg=="], "@typescript/analyze-trace": ["@typescript/analyze-trace@0.10.1", "", { "dependencies": { "chalk": "^4.1.2", "exit": "^0.1.2", "jsonparse": "^1.3.1", "jsonstream-next": "^3.0.0", "p-limit": "^3.1.0", "split2": "^3.2.2", "treeify": "^1.1.0", "yargs": "^16.2.0" }, "bin": { "analyze-trace": "bin/analyze-trace", "print-trace-types": "bin/print-trace-types", "simplify-trace-types": "bin/simplify-trace-types" } }, "sha512-RnlSOPh14QbopGCApgkSx5UBgGda5MX1cHqp2fsqfiDyCwGL/m1jaeB9fzu7didVS81LQqGZZuxFBcg8YU8EVw=="], @@ -961,8 +1031,14 @@ "@typescript/vfs": ["@typescript/vfs@1.6.1", "", { "dependencies": { "debug": "^4.1.1" }, "peerDependencies": { "typescript": "*" } }, "sha512-JwoxboBh7Oz1v38tPbkrZ62ZXNHAk9bJ7c9x0eI5zBfBnBYGhURdbnh7Z4smN/MV48Y5OCcZb58n972UtbazsA=="], + "accepts": ["accepts@2.0.0", "", { "dependencies": { "mime-types": "^3.0.0", "negotiator": "^1.0.0" } }, "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng=="], + "adm-zip": ["adm-zip@0.5.18", "", {}, "sha512-ufJnssQGbxzLNS1Ho9bCtX4rQKCCvoVuDLHoJyc3F9dOGDB4BkWs2Ci0kv53lqocAEQ/Cbi+I2XCsNYGqVYqng=="], + "ajv": ["ajv@8.20.0", "", { "dependencies": { "fast-deep-equal": "^3.1.3", "fast-uri": "^3.0.1", "json-schema-traverse": "^1.0.0", "require-from-string": "^2.0.2" } }, "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA=="], + + "ajv-formats": ["ajv-formats@3.0.1", "", { "dependencies": { "ajv": "^8.0.0" } }, "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ=="], + "ansi-regex": ["ansi-regex@6.3.0", "", {}, "sha512-WpDfL7NO6j7tH88IDBNVdUJxDh9nmCteAVW9dsep846XdwF4naCBK+/tGLX3KJgcpgMRXCFlTM2hKGoK9FsdrQ=="], "ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="], @@ -979,10 +1055,12 @@ "balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="], - "baseline-browser-mapping": ["baseline-browser-mapping@2.11.15", "", { "bin": { "baseline-browser-mapping": "dist/cli.cjs" } }, "sha512-FwMjJJ7HnyZpWe+oWxegG0fezZyBZUagI5LZEoO3GCbtbKNwRfMH9Ue5d5v01PNePBy1QSfPSDTTeVL0Hb9EzA=="], + "baseline-browser-mapping": ["baseline-browser-mapping@2.11.19", "", { "bin": { "baseline-browser-mapping": "dist/cli.cjs" } }, "sha512-Grytf1xOxOEMTGRwx6rLGKkTabd4vMg3VrKdj/7joCmV0qgh4QwMMO6xh34YEXQqirAuUdgQGa5orJQQ+69RBw=="], "before-after-hook": ["before-after-hook@4.0.0", "", {}, "sha512-q6tR3RPqIB1pMiTRMFcZwuG5T8vwp+vUvEG0vuI6B+Rikh5BfPp2fQ82c925FOs+b0lcFQ8CFrL+KbilfZFhOQ=="], + "body-parser": ["body-parser@2.3.0", "", { "dependencies": { "bytes": "^3.1.2", "content-type": "^2.0.0", "debug": "^4.4.3", "http-errors": "^2.0.1", "iconv-lite": "^0.7.2", "on-finished": "^2.4.1", "qs": "^6.15.2", "raw-body": "^3.0.2", "type-is": "^2.1.0" } }, "sha512-2cGmJupaNgg+QUwVLAucDuWuoMZ6EX9iHDRswZ5lsNYEmwPaRknMPCLZz07yTzVq/83p4o/wzbDZbBrTvGGTIw=="], + "boolean": ["boolean@3.2.0", "", {}, "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw=="], "brace-expansion": ["brace-expansion@5.0.9", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg=="], @@ -991,7 +1069,13 @@ "bun-types": ["bun-types@1.4.0", "", { "dependencies": { "@types/node": "*" } }, "sha512-iIKw23BspnQQYd3prITOBxeUsxBHnwzX6YJfGMuNOZzeNcMmVqzIIVGRm1l69ogaPQmb4wB6BN8mA5bE9YuC5Q=="], - "caniuse-lite": ["caniuse-lite@1.0.30001809", "", {}, "sha512-xxWVywk6a6Arlk+hymeycyn/VgqEfLDxupvhH/xiY5SJ/18kmi9o6MiO320DCUzypORHLtvh0I4i04tUhCNHNQ=="], + "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="], + + "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="], + + "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="], + + "caniuse-lite": ["caniuse-lite@1.0.30001810", "", {}, "sha512-TITQPUkaz+aVk5GL6NhOdwk1aEaNTSDPsGFWrTuhKGtjTF70jL/Oht2W4c6rXUe5fu7Ie19VIahAXHIIiWWNeg=="], "chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="], @@ -1023,10 +1107,22 @@ "colorette": ["colorette@2.0.20", "", {}, "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w=="], - "content-type": ["content-type@2.1.0", "", {}, "sha512-mj7UPXE0jaqaOsukNZRUEfEi2AcL7C/vwmwcHV0O97eO1E1pxBZuyjlZrx5seTaNBg1U6+o35wpa35Qfcc+7ag=="], + "commander": ["commander@8.3.0", "", {}, "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww=="], + + "content-disposition": ["content-disposition@1.1.0", "", {}, "sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g=="], + + "content-type": ["content-type@1.0.5", "", {}, "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA=="], "convert-source-map": ["convert-source-map@2.0.0", "", {}, "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="], + "cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="], + + "cookie-signature": ["cookie-signature@1.2.2", "", {}, "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg=="], + + "cors": ["cors@2.8.6", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw=="], + + "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="], + "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="], "d3-array": ["d3-array@3.2.4", "", { "dependencies": { "internmap": "1 - 2" } }, "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg=="], @@ -1053,6 +1149,8 @@ "define-properties": ["define-properties@1.2.1", "", { "dependencies": { "define-data-property": "^1.0.1", "has-property-descriptors": "^1.0.0", "object-keys": "^1.1.1" } }, "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg=="], + "depd": ["depd@2.0.0", "", {}, "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="], + "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="], "detect-node": ["detect-node@2.1.0", "", {}, "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g=="], @@ -1061,12 +1159,18 @@ "diff": ["diff@9.0.0", "", {}, "sha512-svtcdpS8CgJyqAjEQIXdb3OjhFVVYjzGAPO8WGCmRbrml64SPw/jJD4GoE98aR7r25A0XcgrK3F02yw9R/vhQw=="], + "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="], + + "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="], + "electron-to-chromium": ["electron-to-chromium@1.5.412", "", {}, "sha512-z4rMe3esBzlzovKHj4gxJnsCGZRK5l4baUvm+gCGJBPE+gsyUMKsuU9tnEUtI1dOebXz1ytAPGjvXhmQ7rIPwA=="], "emnapi": ["emnapi@1.11.3", "", { "peerDependencies": { "node-addon-api": ">= 6.1.0" }, "optionalPeers": ["node-addon-api"] }, "sha512-+/ZS90YK/rYfVOHtGLHkGffVsnmD/MAKaBHio+Y4XAtg75RLr4cveV/w0jTkUdLM1CcAlaRgG76mpIemWAlk0A=="], "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], + "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="], + "enhanced-resolve": ["enhanced-resolve@5.24.5", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.3" } }, "sha512-L1l8TNvomm6UVW5B253AGxQagSQr+vGwhMlrrfRS2qmhx46AMpMVJKQYLvWYbysTMY8VoicOvzHzoHMbyzB+4A=="], "entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="], @@ -1075,34 +1179,62 @@ "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="], + "es-object-atoms": ["es-object-atoms@1.1.2", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw=="], + "es-toolkit": ["es-toolkit@1.51.0", "", {}, "sha512-zC2lQGkM7QX+Gm6iM3+WIdZJzthsEd14LvRNJneSO2hzyz/zNBENR8+YXWo1cKxgPBtV6ksPYHELbcwBRzmdCw=="], "es6-error": ["es6-error@4.1.1", "", {}, "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg=="], "escalade": ["escalade@3.2.0", "", {}, "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA=="], + "escape-html": ["escape-html@1.0.3", "", {}, "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="], + "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="], + "etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="], + + "eventsource": ["eventsource@3.0.7", "", { "dependencies": { "eventsource-parser": "^3.0.1" } }, "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA=="], + + "eventsource-parser": ["eventsource-parser@3.1.1", "", {}, "sha512-EKN1vKAMcZ8MlYMpaNuxN6R9yakzH6uajHcHVTqWJzvu5pWw9DyhbP35HH8MVBQ+dZjAfDxk+A8NiR9KWaXiyQ=="], + "exit": ["exit@0.1.2", "", {}, "sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ=="], + "express": ["express@5.2.1", "", { "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", "content-disposition": "^1.0.0", "content-type": "^1.0.5", "cookie": "^0.7.1", "cookie-signature": "^1.2.1", "debug": "^4.4.0", "depd": "^2.0.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "finalhandler": "^2.1.0", "fresh": "^2.0.0", "http-errors": "^2.0.0", "merge-descriptors": "^2.0.0", "mime-types": "^3.0.0", "on-finished": "^2.4.1", "once": "^1.4.0", "parseurl": "^1.3.3", "proxy-addr": "^2.0.7", "qs": "^6.14.0", "range-parser": "^1.2.1", "router": "^2.2.0", "send": "^1.1.0", "serve-static": "^2.2.0", "statuses": "^2.0.1", "type-is": "^2.0.1", "vary": "^1.1.2" } }, "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw=="], + + "express-rate-limit": ["express-rate-limit@8.7.0", "", { "dependencies": { "debug": "^4.4.3", "ip-address": "^10.2.0" }, "peerDependencies": { "express": ">= 4.11" } }, "sha512-hOwV7WOxXfjRpAM1DSJWZDXx3GhplwD8IfwuwvogD8i1Qnkgosw/H45s4ZnFAUHDAhPjlY9hLBvJhKmGMyY26g=="], + + "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="], + + "fast-sha256": ["fast-sha256@1.3.0", "", {}, "sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ=="], + "fast-string-truncated-width": ["fast-string-truncated-width@3.0.3", "", {}, "sha512-0jjjIEL6+0jag3l2XWWizO64/aZVtpiGE3t0Zgqxv0DPuxiMjvB3M24fCyhZUO4KomJQPj3LTSUnDP3GpdwC0g=="], "fast-string-width": ["fast-string-width@3.0.2", "", { "dependencies": { "fast-string-truncated-width": "^3.0.2" } }, "sha512-gX8LrtNEI5hq8DVUfRQMbr5lpaS4nMIWV+7XEbXk2b8kiQIizgnlr12B4dA3ZEx3308ze0O4Q1R+cHts8kyUJg=="], + "fast-uri": ["fast-uri@3.1.6", "", {}, "sha512-7Ical1vFEMr0onbVzEDIreM22I4khW+fzyQPwvAFWBp1iwdshSZRsL4jjRvPG9JP1uiqMHRto+YU6R2/CzDz5Q=="], + "fast-wrap-ansi": ["fast-wrap-ansi@0.2.2", "", { "dependencies": { "fast-string-width": "^3.0.2" } }, "sha512-7F2Fl+TjRSenLqlU3UjSH0iyqopqoZIu7eZVpEirP2g1GtWa2G/ecEmBdgz31+Mxr+ELclgg6sokpSFIQiZ02Q=="], "fastembed": ["fastembed@2.1.0", "", { "dependencies": { "@anush008/tokenizers": "^0.0.0", "@huggingface/hub": "^2.7.1", "onnxruntime-node": "1.21.0", "progress": "^2.0.3", "tar": "^6.2.0" } }, "sha512-oQkpcRHBppJ3+a3w9dU0uytSY0N1cnEa/iVMc8AXEd+tvT529GekOEFhNviJy89R3lvQXF6cdIMTXHj1Gi00xQ=="], "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="], + "finalhandler": ["finalhandler@2.1.1", "", { "dependencies": { "debug": "^4.4.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "on-finished": "^2.4.1", "parseurl": "^1.3.3", "statuses": "^2.0.1" } }, "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA=="], + "flatbuffers": ["flatbuffers@25.9.23", "", {}, "sha512-MI1qs7Lo4Syw0EOzUl0xjs2lsoeqFku44KpngfIduHBYvzm8h2+7K8YMQh1JtVVVrUvhLpNwqVi4DERegUJhPQ=="], + "forwarded": ["forwarded@0.2.0", "", {}, "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="], + "framer-motion": ["framer-motion@12.43.0", "", { "dependencies": { "motion-dom": "^12.43.0", "motion-utils": "^12.39.0", "tslib": "^2.4.0" }, "peerDependencies": { "@emotion/is-prop-valid": "*", "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0" }, "optionalPeers": ["@emotion/is-prop-valid", "react", "react-dom"] }, "sha512-1eaL3RvR/kAlbG7UYcpMptEyzPoENO0c6w7ZnB3/hh2vSAz/6uGAFn6fdoqTBguNstf3MsFhJHsD/0DHiclG+g=="], + "fresh": ["fresh@2.0.0", "", {}, "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A=="], + "fs-minipass": ["fs-minipass@2.1.0", "", { "dependencies": { "minipass": "^3.0.0" } }, "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg=="], "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], + "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="], + "gearhash-jit": ["gearhash-jit@1.0.2", "", {}, "sha512-UhzJL4KXSdqAKepy/tZwmi2Rcy0YMmtiC4DQS4SURCuIWdh8ECZtnXK2ePRMLigfB61hRKdLK/Vgg2bSw73izQ=="], "gensync": ["gensync@1.0.0-beta.2", "", {}, "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg=="], @@ -1111,6 +1243,10 @@ "get-east-asian-width": ["get-east-asian-width@1.6.0", "", {}, "sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA=="], + "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="], + + "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="], + "global-agent": ["global-agent@4.1.3", "", { "dependencies": { "globalthis": "^1.0.2", "matcher": "^4.0.0", "semver": "^7.3.5", "serialize-error": "^8.1.0" } }, "sha512-KUJEViiuFT3I97t+GYMikLPJS2Lfo/S2F+DQuBWzuzaMPnvt5yyZePzArx36fBzpGTxZjIpDbXLeySLgh+k76g=="], "globalthis": ["globalthis@1.0.4", "", { "dependencies": { "define-properties": "^1.2.1", "gopd": "^1.0.1" } }, "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ=="], @@ -1127,26 +1263,50 @@ "has-property-descriptors": ["has-property-descriptors@1.0.2", "", { "dependencies": { "es-define-property": "^1.0.0" } }, "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg=="], + "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="], + + "hasown": ["hasown@2.0.4", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A=="], + + "hono": ["hono@4.13.5", "", {}, "sha512-O6+/eCYRkzzzy0rPWwKLiGBR1nFuUPZynnwjxN1MBA62NNqbT0wQEzQyK2gSO5yDIDB336sXQleAhOHrzlYyKw=="], + "html-entities": ["html-entities@2.3.3", "", {}, "sha512-DV5Ln36z34NNTDgnz0EWGBLZENelNAtkiFA4kyNOG2tDI6Mz1uSWiq1wAKdyjnJwyDiDO7Fa2SO1CTxPXL8VxA=="], + "http-errors": ["http-errors@2.0.1", "", { "dependencies": { "depd": "~2.0.0", "inherits": "~2.0.4", "setprototypeof": "~1.2.0", "statuses": "~2.0.2", "toidentifier": "~1.0.1" } }, "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ=="], + "iconv-lite": ["iconv-lite@0.7.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-IKXpvIzjnC9XTAUbVBcMfGS0EPaIXtW6v+zr+RRp+hqULEpo0owZax6wyRwPOJbWbzjYspQwusTsfVr0ifh4uQ=="], "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="], "internmap": ["internmap@2.0.3", "", {}, "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg=="], + "ip-address": ["ip-address@10.7.0", "", {}, "sha512-BGFsyJd5mpXp3rK6jIdADLNgpJUK1jnjzvYF8lK+VyDab9JAmqN0YOKDdP17HlgKb2+ehPgDc8EtnRLbGCAMhA=="], + + "ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="], + "is-fullwidth-code-point": ["is-fullwidth-code-point@5.1.0", "", { "dependencies": { "get-east-asian-width": "^1.3.1" } }, "sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ=="], + "is-promise": ["is-promise@4.0.0", "", {}, "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ=="], + "is-what": ["is-what@4.1.16", "", {}, "sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A=="], + "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="], + "jiti": ["jiti@2.7.0", "", { "bin": { "jiti": "lib/jiti-cli.mjs" } }, "sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ=="], + "jose": ["jose@6.2.10", "", {}, "sha512-iiW7J9qRFlGxvCOIBDBDxFePQSn7ZMAnrYGhrrOo6siO/MIqwfyilLR27pkfDgUk+raLuzADS8A3S/KLBisc0g=="], + "js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="], "js-yaml": ["js-yaml@4.3.1", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-CY6crGq313MX8GkwvB7tzgp99vjQxY1++5y10/BKN/GUfHqWaOGQMNZkBvqSzsZKWk/ijwHlWzzkLulsGHhjWQ=="], "jsesc": ["jsesc@3.1.0", "", { "bin": { "jsesc": "bin/jsesc" } }, "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA=="], + "json-schema-to-ts": ["json-schema-to-ts@3.1.1", "", { "dependencies": { "@babel/runtime": "^7.18.3", "ts-algebra": "^2.0.0" } }, "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g=="], + + "json-schema-traverse": ["json-schema-traverse@1.0.0", "", {}, "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug=="], + + "json-schema-typed": ["json-schema-typed@8.0.2", "", {}, "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA=="], + "json-stringify-safe": ["json-stringify-safe@5.0.1", "", {}, "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA=="], "json-with-bigint": ["json-with-bigint@3.5.12", "", {}, "sha512-uwbF/wSSuOgC7qqlq27Xp5B6a2MHVug3t0idZdTqu0JnlFvgJuH7ju+KAk/J06C7GfhoYy2gnb9wz2INqcne7w=="], @@ -1157,6 +1317,8 @@ "jsonstream-next": ["jsonstream-next@3.0.0", "", { "dependencies": { "jsonparse": "^1.2.0", "through2": "^4.0.2" }, "bin": { "jsonstream-next": "bin.js" } }, "sha512-aAi6oPhdt7BKyQn1SrIIGZBt0ukKuOUE1qV6kJ3GgioSOYzsRc8z9Hfr1BVmacA/jLe9nARfmgMGgn68BqIAgg=="], + "katex": ["katex@0.18.4", "", { "dependencies": { "commander": "^8.3.0" }, "bin": { "katex": "cli.js" } }, "sha512-IMPntbRLOU+eu88XDiFKqQ8Akhr9Tv7jDMXqPhjG9SI1JMA4DIgXk4x9k4skJz2NZJXBRbC+2pYBLj9olqcZow=="], + "kitty-vt-wasm": ["kitty-vt-wasm@0.2.0", "", {}, "sha512-RJNzy9r5ql8CKkocjkg0FKC1MZoWM0R8leb2VB5hsgrP/4HHlumeODHriOw4Jk2dDsCOmPxWuwFQyqDiy0m8Kw=="], "lightningcss": ["lightningcss@1.32.0", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.32.0", "lightningcss-darwin-arm64": "1.32.0", "lightningcss-darwin-x64": "1.32.0", "lightningcss-freebsd-x64": "1.32.0", "lightningcss-linux-arm-gnueabihf": "1.32.0", "lightningcss-linux-arm64-gnu": "1.32.0", "lightningcss-linux-arm64-musl": "1.32.0", "lightningcss-linux-x64-gnu": "1.32.0", "lightningcss-linux-x64-musl": "1.32.0", "lightningcss-win32-arm64-msvc": "1.32.0", "lightningcss-win32-x64-msvc": "1.32.0" } }, "sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ=="], @@ -1189,7 +1351,7 @@ "lru-cache": ["lru-cache@5.1.1", "", { "dependencies": { "yallist": "^3.0.2" } }, "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w=="], - "lucide-react": ["lucide-react@1.33.0", "", { "peerDependencies": { "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-MTRwMy0ZlL8Ur/vOAiJ9XGHE+kFPC7brq6MxAm0GiGXEBj0qy0jA/pG4N675oSzciO/UCdX8T+5yUQdmDeTLxg=="], + "lucide-react": ["lucide-react@1.34.0", "", { "peerDependencies": { "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-vnjGJNI7Htk5+oWW8gXGuaLgwgAb0T6/iZbBrp9JCfRFwdNWZ0YTm3eyxjOLgwN6r8iyAf3UA70zNmBRBNv7yg=="], "magic-string": ["magic-string@0.30.21", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ=="], @@ -1197,8 +1359,18 @@ "matcher": ["matcher@4.0.0", "", { "dependencies": { "escape-string-regexp": "^4.0.0" } }, "sha512-S6x5wmcDmsDRRU/c2dkccDwQPXoFczc5+HpQ2lON8pnvHlnvHAHj5WlLVvw6n6vNyHuVugYrFohYxbS+pvFpKQ=="], + "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="], + + "media-typer": ["media-typer@1.1.1", "", {}, "sha512-yz3xRaG20c6/BOzvYoDaGtPmGscs7YivItZEEqe6GbwNfHuxu9YNmvnEkMzKldAGY4/80pRcQRZSEnhquk9XuQ=="], + "merge-anything": ["merge-anything@5.1.7", "", { "dependencies": { "is-what": "^4.1.8" } }, "sha512-eRtbOb1N5iyH0tkQDAoQ4Ipsp/5qSR79Dzrz8hEPxRX10RWWR/iQXdoKmBSRCThY1Fh5EhISDtpSc93fpxUniQ=="], + "merge-descriptors": ["merge-descriptors@2.0.0", "", {}, "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g=="], + + "mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="], + + "mime-types": ["mime-types@3.0.2", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A=="], + "minimatch": ["minimatch@10.2.6", "", { "dependencies": { "brace-expansion": "^5.0.8" } }, "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A=="], "minipass": ["minipass@5.0.0", "", {}, "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ=="], @@ -1225,12 +1397,22 @@ "nanoid": ["nanoid@3.3.18", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w=="], + "negotiator": ["negotiator@1.1.0", "", { "dependencies": { "content-type": "^2.1.0" } }, "sha512-NMPBRMJgiQHjbd8phG3Vebdx4kZ1H121rbl5IkMqeOsahptB9BKo/d7oJ3zTXqTgagn2bWlNSXkh0QUGM31RYg=="], + "node-releases": ["node-releases@2.0.53", "", {}, "sha512-D9UOmYG3UH1V+ENW56t5QXBwJw1YEY18ruVeus89Rw+SyIgjPkCO84bRzO3uNIYosJbNwiabWVn48o3uJLjxFQ=="], + "object-assign": ["object-assign@4.1.1", "", {}, "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="], + + "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="], + "object-keys": ["object-keys@1.1.1", "", {}, "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA=="], "obug": ["obug@2.1.4", "", {}, "sha512-4a+OsYv9UktOJKE+l1A4OufDgdRF9PifWj+tJnHURo/P+WOxpG4GzUFL9qCalmWauao6ogiG+QvnCovwPoyAWA=="], + "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="], + + "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="], + "onnxruntime-common": ["onnxruntime-common@1.26.0", "", {}, "sha512-qVyMR4lcWgbkc4getFV+GQijsTnbg/siteoqcDwa3sI/LxbrMSNw4ePyvCq/ymdQaRomCA7YuWmhzsswxvymdw=="], "onnxruntime-node": ["onnxruntime-node@1.26.0", "", { "dependencies": { "adm-zip": "^0.5.16", "global-agent": "^4.1.3", "onnxruntime-common": "1.26.0" }, "os": [ "linux", "win32", "darwin", ] }, "sha512-OHl6PiOEOqxaLHL0N9eFrbzS7IGmu3BtJNH3RTEnRAheCIkfc3gjcjl4sGcjp9C22ZC9YTquDOxSdT/stBQ6BQ=="], @@ -1241,11 +1423,19 @@ "parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="], + "parseurl": ["parseurl@1.3.3", "", {}, "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="], + "path-browserify": ["path-browserify@1.0.1", "", {}, "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g=="], + "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="], + + "path-to-regexp": ["path-to-regexp@8.4.2", "", {}, "sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA=="], + "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="], - "picomatch": ["picomatch@4.0.5", "", {}, "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A=="], + "picomatch": ["picomatch@4.0.7", "", {}, "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA=="], + + "pkce-challenge": ["pkce-challenge@5.0.1", "", {}, "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ=="], "platform": ["platform@1.3.6", "", {}, "sha512-fnWVljUchTro6RiCFvCXBbNhJc2NijN7oIQxbwsyL0buWJPG85v81ehlHI9fXrJsMNgTofEoWIQeClKpgxFLrg=="], @@ -1257,8 +1447,16 @@ "protobufjs": ["protobufjs@7.6.5", "", { "dependencies": { "@protobufjs/aspromise": "^1.1.2", "@protobufjs/base64": "^1.1.2", "@protobufjs/codegen": "^2.0.5", "@protobufjs/eventemitter": "^1.1.1", "@protobufjs/fetch": "^1.1.1", "@protobufjs/float": "^1.0.2", "@protobufjs/path": "^1.1.2", "@protobufjs/pool": "^1.1.0", "@protobufjs/utf8": "^1.1.1", "@types/node": ">=13.7.0", "long": "^5.3.2" } }, "sha512-/FPD0nUc9jH6rfFjji9IBqOz4pcSE3CsT1m7Ep6Mdb0LxSUMj8hgl6GomOvZzpNpAqqGaXA0P3VSrZLFzIhQrw=="], + "proxy-addr": ["proxy-addr@2.0.7", "", { "dependencies": { "forwarded": "0.2.0", "ipaddr.js": "1.9.1" } }, "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg=="], + "puppeteer-core": ["puppeteer-core@25.3.0", "", { "dependencies": { "@puppeteer/browsers": "3.0.6", "chromium-bidi": "16.0.1", "devtools-protocol": "0.0.1638949", "typed-query-selector": "^2.12.2", "webdriver-bidi-protocol": "0.4.2", "ws": "^8.21.0" } }, "sha512-fm+wpUr2oigH1PXZvwgATrM2tYWHMDG8ASzTEe9uukCye4X5Ldx1K5BTHPFKITrIWvQQAQ256d1NpbEveBcKjA=="], + "qs": ["qs@6.16.0", "", { "dependencies": { "es-define-property": "^1.0.1", "side-channel": "^1.1.1" } }, "sha512-h6fhOIaRrID2CbEY2fqs+7t+UXZo+MLAnU5gRIq85uFtdiUPCdsApMlHhXogKVM4HM2DVbIjGNTTYH2OcmP1vA=="], + + "range-parser": ["range-parser@1.3.0", "", {}, "sha512-hek2mFQpPuI4E1BBKrSto+BU3e3x4xuarsbiwr3+lf7p44juvFMV0XFWQAP3xUyqXA4RrXLIoaSUGbSt056ZMw=="], + + "raw-body": ["raw-body@3.0.2", "", { "dependencies": { "bytes": "~3.1.2", "http-errors": "~2.0.1", "iconv-lite": "~0.7.0", "unpipe": "~1.0.0" } }, "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA=="], + "react": ["react@19.2.7", "", {}, "sha512-HNe9WslTbXmFK8o8cmwgAeJFSBvt1bPdHCVKtaaV+WlAN36mpT4hcRpwbf3fY56ar2oIXzsBpOAiIRHAdY0OlQ=="], "react-chartjs-2": ["react-chartjs-2@5.3.1", "", { "peerDependencies": { "chart.js": "^4.1.1", "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-h5IPXKg9EXpjoBzUfyWJvllMjG2mQ4EiuHQFhms/AjUm0XSZHhyRy2xVmLXHKrtcdrPO4mnGqRtYoD0vp95A0A=="], @@ -1273,11 +1471,15 @@ "require-directory": ["require-directory@2.1.1", "", {}, "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q=="], + "require-from-string": ["require-from-string@2.0.2", "", {}, "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw=="], + "roarr": ["roarr@2.15.4", "", { "dependencies": { "boolean": "^3.0.1", "detect-node": "^2.0.4", "globalthis": "^1.0.1", "json-stringify-safe": "^5.0.1", "semver-compare": "^1.0.0", "sprintf-js": "^1.1.2" } }, "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A=="], "robomp-web": ["robomp-web@workspace:python/robomp/web"], - "rolldown": ["rolldown@1.2.5", "", { "dependencies": { "@oxc-project/types": "=0.146.0", "@rolldown/pluginutils": "^1.0.0" }, "optionalDependencies": { "@rolldown/binding-android-arm-eabi": "1.2.5", "@rolldown/binding-android-arm64": "1.2.5", "@rolldown/binding-darwin-arm64": "1.2.5", "@rolldown/binding-darwin-x64": "1.2.5", "@rolldown/binding-freebsd-x64": "1.2.5", "@rolldown/binding-linux-arm-gnueabihf": "1.2.5", "@rolldown/binding-linux-arm64-gnu": "1.2.5", "@rolldown/binding-linux-arm64-musl": "1.2.5", "@rolldown/binding-linux-ppc64-gnu": "1.2.5", "@rolldown/binding-linux-s390x-gnu": "1.2.5", "@rolldown/binding-linux-x64-gnu": "1.2.5", "@rolldown/binding-linux-x64-musl": "1.2.5", "@rolldown/binding-openharmony-arm64": "1.2.5", "@rolldown/binding-win32-arm64-msvc": "1.2.5", "@rolldown/binding-win32-x64-msvc": "1.2.5" }, "bin": { "rolldown": "./bin/cli.mjs" } }, "sha512-VD2IE5PUG4Oj8zz2VGykiYd5wbnjdIiSsNQb8Qu5B+noEp+A78mu2iVvpp27g8es14Tk9rofNs5Tku9iQCS4fA=="], + "rolldown": ["rolldown@1.2.6", "", { "dependencies": { "@oxc-project/types": "=0.147.0", "@rolldown/pluginutils": "^1.0.0" }, "optionalDependencies": { "@rolldown/binding-android-arm-eabi": "1.2.6", "@rolldown/binding-android-arm64": "1.2.6", "@rolldown/binding-darwin-arm64": "1.2.6", "@rolldown/binding-darwin-x64": "1.2.6", "@rolldown/binding-freebsd-x64": "1.2.6", "@rolldown/binding-linux-arm-gnueabihf": "1.2.6", "@rolldown/binding-linux-arm64-gnu": "1.2.6", "@rolldown/binding-linux-arm64-musl": "1.2.6", "@rolldown/binding-linux-ppc64-gnu": "1.2.6", "@rolldown/binding-linux-s390x-gnu": "1.2.6", "@rolldown/binding-linux-x64-gnu": "1.2.6", "@rolldown/binding-linux-x64-musl": "1.2.6", "@rolldown/binding-openharmony-arm64": "1.2.6", "@rolldown/binding-win32-arm64-msvc": "1.2.6", "@rolldown/binding-win32-x64-msvc": "1.2.6" }, "bin": { "rolldown": "./bin/cli.mjs" } }, "sha512-vMM4q3aixf46GiF1Kok8jDPFsEpXgFWGjUHXNkNHNm+Y2adXAG2dbX91jkti3i0ZRsOlcmbuzAz1poObSHCmUA=="], + + "router": ["router@2.2.0", "", { "dependencies": { "debug": "^4.4.0", "depd": "^2.0.0", "is-promise": "^4.0.0", "parseurl": "^1.3.3", "path-to-regexp": "^8.0.0" } }, "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ=="], "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="], @@ -1289,14 +1491,24 @@ "semver-compare": ["semver-compare@1.0.0", "", {}, "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow=="], + "send": ["send@1.2.1", "", { "dependencies": { "debug": "^4.4.3", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "fresh": "^2.0.0", "http-errors": "^2.0.1", "mime-types": "^3.0.2", "ms": "^2.1.3", "on-finished": "^2.4.1", "range-parser": "^1.2.1", "statuses": "^2.0.2" } }, "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ=="], + "serialize-error": ["serialize-error@8.1.0", "", { "dependencies": { "type-fest": "^0.20.2" } }, "sha512-3NnuWfM6vBYoy5gZFvHiYsVbafvI9vZv/+jlIigFn4oP4zjNPK3LhcY0xSCgeb1a5L8jO71Mit9LlNoi2UfDDQ=="], "seroval": ["seroval@1.5.6", "", {}, "sha512-rVQVWjjSvlINzaQPZH5JFqsqEsIWdTxY3iJZCnTL/5gQbXIRooVZKI60tVCkOVfzcRPejboxO2t0P89dg5mQaA=="], "seroval-plugins": ["seroval-plugins@1.5.6", "", { "peerDependencies": { "seroval": "^1.0" } }, "sha512-HXuLAX2pu/UByPpaeo/TaMfvMIi+1QqIoPJYCcAtU8QkVNwgR6MPlGuCQTErV1JwraaMbYaWVIBX7mppzGLATQ=="], + "serve-static": ["serve-static@2.2.1", "", { "dependencies": { "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "parseurl": "^1.3.3", "send": "^1.2.0" } }, "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw=="], + + "setprototypeof": ["setprototypeof@1.2.0", "", {}, "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="], + "sharp": ["sharp@0.34.5", "", { "dependencies": { "@img/colour": "^1.0.0", "detect-libc": "^2.1.2", "semver": "^7.7.3" }, "optionalDependencies": { "@img/sharp-darwin-arm64": "0.34.5", "@img/sharp-darwin-x64": "0.34.5", "@img/sharp-libvips-darwin-arm64": "1.2.4", "@img/sharp-libvips-darwin-x64": "1.2.4", "@img/sharp-libvips-linux-arm": "1.2.4", "@img/sharp-libvips-linux-arm64": "1.2.4", "@img/sharp-libvips-linux-ppc64": "1.2.4", "@img/sharp-libvips-linux-riscv64": "1.2.4", "@img/sharp-libvips-linux-s390x": "1.2.4", "@img/sharp-libvips-linux-x64": "1.2.4", "@img/sharp-libvips-linuxmusl-arm64": "1.2.4", "@img/sharp-libvips-linuxmusl-x64": "1.2.4", "@img/sharp-linux-arm": "0.34.5", "@img/sharp-linux-arm64": "0.34.5", "@img/sharp-linux-ppc64": "0.34.5", "@img/sharp-linux-riscv64": "0.34.5", "@img/sharp-linux-s390x": "0.34.5", "@img/sharp-linux-x64": "0.34.5", "@img/sharp-linuxmusl-arm64": "0.34.5", "@img/sharp-linuxmusl-x64": "0.34.5", "@img/sharp-wasm32": "0.34.5", "@img/sharp-win32-arm64": "0.34.5", "@img/sharp-win32-ia32": "0.34.5", "@img/sharp-win32-x64": "0.34.5" } }, "sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg=="], + "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="], + + "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="], + "sherpa-onnx": ["sherpa-onnx@1.13.2", "", {}, "sha512-hheOLl4JlOzERco73u+1Q/LaNDdFChDe4r3+IlMYIO3wggBZrReHDSxWwRUIW+YLw3eLslyiXw/hfb75aOylEA=="], "sherpa-onnx-darwin-arm64": ["sherpa-onnx-darwin-arm64@1.13.3", "", { "os": "darwin", "cpu": "arm64" }, "sha512-9x86Cbf+BDFONdtCPM3cnjvtAW0ER8tMaHK5pVfz+SHPt8GeuwRXaiR/BzcByFBUyxCgmceO09/WMZOCi44P/g=="], @@ -1313,6 +1525,14 @@ "sherpa-onnx-win-x64": ["sherpa-onnx-win-x64@1.13.6", "", { "os": "win32", "cpu": "x64" }, "sha512-bPMdURD1XCu1Zr3eYYlYx2obc5CMSQhEnd1GQuv7FXjdyOeMJ8jNbQEKFEIAyQdC481FgZvPBb2oSJXaLOOeVw=="], + "side-channel": ["side-channel@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.4", "side-channel-list": "^1.0.1", "side-channel-map": "^1.0.1", "side-channel-weakmap": "^1.0.2" } }, "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ=="], + + "side-channel-list": ["side-channel-list@1.0.1", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.4" } }, "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w=="], + + "side-channel-map": ["side-channel-map@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3" } }, "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA=="], + + "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="], + "signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="], "slice-ansi": ["slice-ansi@9.0.0", "", { "dependencies": { "ansi-styles": "^6.2.3", "is-fullwidth-code-point": "^5.1.0" } }, "sha512-SO/3iYL5S3W57LLEniscOGPZgOqZUPCx6d3dB+52B80yJ0XstzsC/eV8gnA4tM3MHDrKz+OCFSLNjswdSC+/bA=="], @@ -1327,6 +1547,10 @@ "sprintf-js": ["sprintf-js@1.1.3", "", {}, "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA=="], + "standardwebhooks": ["standardwebhooks@1.1.1", "", { "dependencies": { "@stablelib/base64": "^1.0.0", "fast-sha256": "^1.3.0" } }, "sha512-bCbX9ZEyFkWPsRz7Bl3NuQUJohmwGSev/yhr7vhaGPlc4AfIrspIRa6cPTBuI1ItmrTDJ4d/S2hCsfe4+vQGnQ=="], + + "statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="], + "string-argv": ["string-argv@0.3.2", "", {}, "sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q=="], "string-width": ["string-width@8.2.2", "", { "dependencies": { "get-east-asian-width": "^1.5.0", "strip-ansi": "^7.1.2" } }, "sha512-GaPUh5gfdrYzqeVNZvUfT23vYYxXzKYidUcnMtJg/3rxRV63EFZy3k6xfKlmfeJD0176lnUV/Usr3XcwSvFzpg=="], @@ -1351,8 +1575,12 @@ "tinyglobby": ["tinyglobby@0.2.17", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.4" } }, "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g=="], + "toidentifier": ["toidentifier@1.0.1", "", {}, "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="], + "treeify": ["treeify@1.1.0", "", {}, "sha512-1m4RA7xVAJrSGrrXGs0L3YTwyvBs2S8PbRHaLZAkFw7JR8oIFwYtysxlBZhYIa7xSyiYJKZ3iGrrk55cGA3i9A=="], + "ts-algebra": ["ts-algebra@2.0.0", "", {}, "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw=="], + "ts-morph": ["ts-morph@28.0.0", "", { "dependencies": { "@ts-morph/common": "~0.29.0", "code-block-writer": "^13.0.3" } }, "sha512-Wp3tnZ2bzwxyTZMtgWVzXDfm7lB1Drz+y9DmmYH/L702PQhPyVrp3pkou3yIz4qjS14GY9kcpmLiOOMvl8oG1g=="], "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="], @@ -1361,6 +1589,8 @@ "type-fest": ["type-fest@0.20.2", "", {}, "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ=="], + "type-is": ["type-is@2.1.0", "", { "dependencies": { "content-type": "^2.0.0", "media-typer": "^1.1.0", "mime-types": "^3.0.0" } }, "sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA=="], + "typed-query-selector": ["typed-query-selector@2.12.2", "", {}, "sha512-EOPFbyIub4ngnEdqi2yOcNeDLaX/0jcE1JoAXQDDMIthap7FoN795lc/SHfIq2d416VufXpM8z/lD+WRm2gfOQ=="], "typescript": ["typescript@7.0.2", "", { "optionalDependencies": { "@typescript/typescript-aix-ppc64": "7.0.2", "@typescript/typescript-darwin-arm64": "7.0.2", "@typescript/typescript-darwin-x64": "7.0.2", "@typescript/typescript-freebsd-arm64": "7.0.2", "@typescript/typescript-freebsd-x64": "7.0.2", "@typescript/typescript-linux-arm": "7.0.2", "@typescript/typescript-linux-arm64": "7.0.2", "@typescript/typescript-linux-loong64": "7.0.2", "@typescript/typescript-linux-mips64el": "7.0.2", "@typescript/typescript-linux-ppc64": "7.0.2", "@typescript/typescript-linux-riscv64": "7.0.2", "@typescript/typescript-linux-s390x": "7.0.2", "@typescript/typescript-linux-x64": "7.0.2", "@typescript/typescript-netbsd-arm64": "7.0.2", "@typescript/typescript-netbsd-x64": "7.0.2", "@typescript/typescript-openbsd-arm64": "7.0.2", "@typescript/typescript-openbsd-x64": "7.0.2", "@typescript/typescript-sunos-x64": "7.0.2", "@typescript/typescript-win32-arm64": "7.0.2", "@typescript/typescript-win32-x64": "7.0.2" }, "bin": { "tsc": "bin/tsc" } }, "sha512-8FYau96o3NKOhbjKi/qNvG/W5jhzxkbdm5sj9AbZ/5T5sWqn3hJgLfGx27sRKZWTvyzCP8dLRBTf5tBTSRVUNA=="], @@ -1369,10 +1599,14 @@ "universal-user-agent": ["universal-user-agent@7.0.3", "", {}, "sha512-TmnEAEAsBJVZM/AADELsK76llnwcf9vMKuPz8JflO1frO8Lchitr0fNaN9d+Ap0BjKtqWqd/J17qeDnXh8CL2A=="], + "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="], + "update-browserslist-db": ["update-browserslist-db@1.3.1", "", { "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" }, "peerDependencies": { "browserslist": ">= 4.21.0" }, "bin": { "update-browserslist-db": "cli.js" } }, "sha512-ZZ61DsRsOnakl74HAmp3oSN4aXUmEWXf+i/yv0h7tIBfICc3VdrFErQKUUKPgu3AMsTUMbcongALEN4l6GSUrQ=="], "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="], + "vary": ["vary@1.1.2", "", {}, "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="], + "vite": ["vite@8.2.2", "", { "dependencies": { "lightningcss": "^1.33.0", "picomatch": "^4.0.5", "postcss": "^8.5.26", "rolldown": "~1.2.4", "tinyglobby": "^0.2.17" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "@vitejs/devtools": "^0.4.0 || ^0.5.0", "esbuild": "^0.27.0 || ^0.28.0", "jiti": ">=1.21.0", "less": "^4.0.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "@vitejs/devtools", "esbuild", "jiti", "less", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-cFKLV/PRgAUlIRm5WjMjJ86jrftzpqcgH+Us+DS8mI3CDNiH30Whrz8uHL3+MOLPAgqbMBAqWdAHAphOAM+z/Q=="], "vite-plugin-solid": ["vite-plugin-solid@2.11.14", "", { "dependencies": { "@babel/core": "^7.23.3", "@types/babel__core": "^7.20.4", "babel-preset-solid": "^1.8.4", "merge-anything": "^5.1.7", "solid-refresh": "^0.6.3", "vitefu": "^1.0.4" }, "peerDependencies": { "@testing-library/jest-dom": "^5.16.6 || ^5.17.0 || ^6.0.0 || ^7.0.0", "solid-js": "^1.7.2", "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0" }, "optionalPeers": ["@testing-library/jest-dom"] }, "sha512-7ZVBt8rpoyqmlwin2kRIUveaHoF6/kulY7gsnD+qFh4nS29V4OPAnw+ojoAspXIjObiL9o1xh9a/nTuYHm02Rw=="], @@ -1381,8 +1615,12 @@ "webdriver-bidi-protocol": ["webdriver-bidi-protocol@0.4.2", "", {}, "sha512-VSV+fzfChirL3e7jay2yUC7B4HQCGtEWEg/MSSQbK+qWbqeGlRLlXTzPpYr3XGUvbpDHumWZBJxgesg4N7dbtA=="], + "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="], + "wrap-ansi": ["wrap-ansi@10.0.0", "", { "dependencies": { "ansi-styles": "^6.2.3", "string-width": "^8.2.0", "strip-ansi": "^7.1.2" } }, "sha512-SGcvg80f0wUy2/fXES19feHMz8E0JoXv2uNgHOu4Dgi2OrCy1lqwFYEJz1BLbDI0exjPMe/ZdzZ/YpGECBG/aQ=="], + "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="], + "ws": ["ws@8.21.3", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-201TZ/kPWxoPr/OKWjquZR1SWKXcvxdH+e1xrx89b3YbmzLMFCLfnaG1HFIgWzJOEWZ7MvpK++odZufgYR50Rw=="], "y18n": ["y18n@5.0.8", "", {}, "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="], @@ -1399,6 +1637,8 @@ "zod": ["zod@3.25.76", "", {}, "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ=="], + "zod-to-json-schema": ["zod-to-json-schema@3.25.2", "", { "peerDependencies": { "zod": "^3.25.28 || ^4" } }, "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA=="], + "@ark/attest/prettier": ["prettier@3.6.2", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ=="], "@babel/core/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], @@ -1423,6 +1663,8 @@ "@octokit/plugin-rest-endpoint-methods/@octokit/types": ["@octokit/types@16.0.0", "", { "dependencies": { "@octokit/openapi-types": "^27.0.0" } }, "sha512-sKq+9r1Mm4efXW1FCk7hFSeJo4QKreL/tTbR0rz/qx/r1Oa2VV83LTA/H/MuCOX7uCIJmQVRKBcbmWoySjAnSg=="], + "@octokit/request/content-type": ["content-type@3.0.0", "", {}, "sha512-AIi5H6p0xk5uknXcN3/rmhP8jgp69OfSe/JuKiQAFprJ7UGw7mwj7m4XcmDzlrnJDG+cGpphAINGdU3g3g7kDw=="], + "@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/core": ["@opentelemetry/core@2.9.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-m2nckMT80NnmjTYSPjJQObBJ+8dgkoajEOUbznL8AHZ3T3yHRk2P7gI1PhEBc1+lOnrYE9UWrWHqJDsmqjmNbw=="], "@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/resources": ["@opentelemetry/resources@2.9.0", "", { "dependencies": { "@opentelemetry/core": "2.9.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-jyA5MBLQ+Dkl3+JsZkUoUvL7yHvU64kLsvpXKarWm6347Sl1t1bXFTFykUePNpT5WH5pm9a2Qtt03iIYQhZ1Fg=="], @@ -1471,6 +1713,8 @@ "babel-plugin-jsx-dom-expressions/@babel/helper-module-imports": ["@babel/helper-module-imports@7.18.6", "", { "dependencies": { "@babel/types": "^7.18.6" } }, "sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA=="], + "body-parser/content-type": ["content-type@2.1.0", "", {}, "sha512-mj7UPXE0jaqaOsukNZRUEfEi2AcL7C/vwmwcHV0O97eO1E1pxBZuyjlZrx5seTaNBg1U6+o35wpa35Qfcc+7ag=="], + "chalk/ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="], "cli-progress/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="], @@ -1487,8 +1731,12 @@ "minizlib/minipass": ["minipass@3.3.6", "", { "dependencies": { "yallist": "^4.0.0" } }, "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw=="], + "negotiator/content-type": ["content-type@2.1.0", "", {}, "sha512-mj7UPXE0jaqaOsukNZRUEfEi2AcL7C/vwmwcHV0O97eO1E1pxBZuyjlZrx5seTaNBg1U6+o35wpa35Qfcc+7ag=="], + "onnxruntime-web/onnxruntime-common": ["onnxruntime-common@1.24.0-dev.20251116-b39e144322", "", {}, "sha512-BOoomdHYmNRL5r4iQ4bMvsl2t0/hzVQ3OM3PHD0gxeXu1PmggqBv3puZicEUVOA3AtHHYmqZtjMj9FOfGrATTw=="], + "type-is/content-type": ["content-type@2.1.0", "", {}, "sha512-mj7UPXE0jaqaOsukNZRUEfEi2AcL7C/vwmwcHV0O97eO1E1pxBZuyjlZrx5seTaNBg1U6+o35wpa35Qfcc+7ag=="], + "vite/lightningcss": ["lightningcss@1.33.0", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.33.0", "lightningcss-darwin-arm64": "1.33.0", "lightningcss-darwin-x64": "1.33.0", "lightningcss-freebsd-x64": "1.33.0", "lightningcss-linux-arm-gnueabihf": "1.33.0", "lightningcss-linux-arm64-gnu": "1.33.0", "lightningcss-linux-arm64-musl": "1.33.0", "lightningcss-linux-x64-gnu": "1.33.0", "lightningcss-linux-x64-musl": "1.33.0", "lightningcss-win32-arm64-msvc": "1.33.0", "lightningcss-win32-x64-msvc": "1.33.0" } }, "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA=="], "@huggingface/transformers/onnxruntime-node/global-agent": ["global-agent@3.0.0", "", { "dependencies": { "boolean": "^3.0.1", "es6-error": "^4.1.1", "matcher": "^3.0.0", "roarr": "^2.15.3", "semver": "^7.3.2", "serialize-error": "^7.0.1" } }, "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q=="], diff --git a/bunfig.toml b/bunfig.toml index 9ef400261f96..c06542f51dec 100644 --- a/bunfig.toml +++ b/bunfig.toml @@ -2,7 +2,7 @@ telemetry = false [install] minimumReleaseAge = 259200 # 3 days in seconds -minimumReleaseAgeExcludes = ["@types/bun", "bun-types", "kitty-vt-wasm"] +minimumReleaseAgeExcludes = ["@types/bun", "bun-types", "kitty-vt-wasm", "@stencil-hq/vibemon"] linker = "hoisted" exact = true saveTextLockfile = true diff --git a/crates/pi-builtins/Cargo.toml b/crates/pi-builtins/Cargo.toml index cb3eb4e7daba..0395e481127b 100644 --- a/crates/pi-builtins/Cargo.toml +++ b/crates/pi-builtins/Cargo.toml @@ -158,6 +158,11 @@ rlimit = "0.11.0" rustix = { version = "1.1.4", features = ["fs", "process", "time"] } uucore = { version = "0.8.0", features = ["fsxattr", "safe-traversal"] } +[target.'cfg(target_arch = "aarch64")'.dependencies] +# Enable runtime-dispatched ARMv8 hash instructions for uucore's checksum implementations. +sha2 = { version = "0.10", features = ["asm"] } +sha3 = { version = "0.10", features = ["asm"] } + [target."cfg(windows)".dependencies] notify = "=8.2.0" rustix = { version = "1.1.4", features = ["fs", "process", "time"] } diff --git a/crates/pi-natives/BUILD.bazel b/crates/pi-natives/BUILD.bazel index 7627766cea5b..fadddf76a880 100644 --- a/crates/pi-natives/BUILD.bazel +++ b/crates/pi-natives/BUILD.bazel @@ -57,6 +57,7 @@ rust_shared_library( "//crates/pi-ast", "//crates/pi-iso", "//crates/pi-shell", + "//crates/pi-vcs", "//crates/pi-voice", "//crates/pi-walker", ], diff --git a/crates/pi-natives/Cargo.toml b/crates/pi-natives/Cargo.toml index 907774d3d5be..382df037f5e7 100644 --- a/crates/pi-natives/Cargo.toml +++ b/crates/pi-natives/Cargo.toml @@ -45,6 +45,7 @@ zune-jpeg.workspace = true inferno.workspace = true napi.workspace = true napi-derive.workspace = true +pi-vcs.workspace = true parking_lot.workspace = true pdf-inspector.workspace = true phf.workspace = true diff --git a/crates/pi-natives/src/highlight.rs b/crates/pi-natives/src/highlight.rs index e3eb625e3981..455eaa51591c 100644 --- a/crates/pi-natives/src/highlight.rs +++ b/crates/pi-natives/src/highlight.rs @@ -41,6 +41,8 @@ const EXTRA_SYNTAXES: &[&str] = &[ include_str!("syntaxes/Julia.sublime-syntax"), include_str!("syntaxes/Nix.sublime-syntax"), include_str!("syntaxes/Mermaid.sublime-syntax"), + include_str!("syntaxes/TypeScript.sublime-syntax"), + include_str!("syntaxes/TypeScriptReact.sublime-syntax"), ]; fn get_syntax_set() -> &'static SyntaxSet { @@ -201,7 +203,9 @@ pub struct HighlightColors { /// Language alias mappings: (aliases, target syntax name). /// Used for languages not in syntect's default set or with non-standard names. const LANG_ALIASES: &[(&[&str], &str)] = &[ - (&["ts", "tsx", "typescript", "js", "jsx", "javascript", "mjs", "cjs"], "JavaScript"), + (&["ts", "mts", "cts", "typescript"], "TypeScript"), + (&["tsx"], "TypeScriptReact"), + (&["js", "jsx", "javascript", "mjs", "cjs"], "JavaScript"), (&["py", "python"], "Python"), (&["rb", "ruby"], "Ruby"), (&["jl", "julia"], "Julia"), @@ -675,4 +679,23 @@ mod tests { assert!(out.contains("-->")); assert!(out.contains(" note")); } + /// Regression: with the JavaScript grammar, TS type annotations + /// (generic return types, arrow-type params) corrupted parser state, and a + /// later template literal left an unterminated string scope that painted + /// the rest of the file as a string (issue seen in the git TUI diff pane). + #[test] + fn typescript_template_literal_does_not_leak_string_state() { + assert!(get_supported_languages().contains(&"TypeScript".to_string())); + assert!(supports_language_impl("ts")); + assert!(supports_language_impl("tsx")); + + let code = "function icons(): Record<\"close\" | \"hunk\", string> {\n\treturn \ + {};\n}\nfunction chip(label: string): string {\n\tconst text = ` ${label} \ + `;\n\treturn text;\n}\nconst zzz = 1;\n"; + let out = highlight_code_impl(code, Some("ts"), &test_colors()); + let last = out.lines().last().unwrap(); + assert!(last.contains("const"), "trailing code lost keyword highlighting: {last}"); + assert!(last.contains("1"), "trailing code lost number highlighting: {last}"); + assert!(!last.contains("const"), "string scope leaked past template literal: {last}"); + } } diff --git a/crates/pi-natives/src/lib.rs b/crates/pi-natives/src/lib.rs index 4c6b0bde299e..c9290581d716 100644 --- a/crates/pi-natives/src/lib.rs +++ b/crates/pi-natives/src/lib.rs @@ -49,6 +49,7 @@ pub mod snapcompact; pub mod spelling; pub mod svg; pub mod utok; +pub mod vcs; pub use pi_ast::language; pub mod power; @@ -262,7 +263,7 @@ fn create_windows_napi_tokio_runtime() -> Option { /// MUST stay in sync with `VERSION_SENTINEL_EXPORT` in /// `packages/natives/native/index.js` (which derives the name from /// `package.json#version`). -#[napi(js_name = "__piNativesV18_0_4")] +#[napi(js_name = "__piNativesV18_0_11")] pub const fn pi_natives_version_sentinel() {} /// Native module entry point: install crash diagnostics before any tool can diff --git a/crates/pi-natives/src/ps.rs b/crates/pi-natives/src/ps.rs index 3b032b850f09..b739d689f5ec 100644 --- a/crates/pi-natives/src/ps.rs +++ b/crates/pi-natives/src/ps.rs @@ -194,3 +194,43 @@ impl Process { Self { inner } } } + +/// Replace the current process image via `execvp(3)`. +/// +/// On success this never returns: the kernel tears down every other thread and +/// the new program takes over this PID, controlling terminal, and inherited +/// (non-`CLOEXEC`) file descriptors. Callers must flush logs and restore the +/// terminal first — no JS or native cleanup runs after a successful call. +/// +/// # Errors +/// Returns an error, leaving the process untouched, when `argv` is empty, an +/// argument contains an interior NUL byte, or the exec itself fails (e.g. +/// executable not found). Windows has no exec-replace semantics, so this +/// always errors there; callers fall back to spawn-and-wait. +#[napi] +pub fn exec_replace(argv: Vec) -> Result<()> { + #[cfg(unix)] + { + use std::ffi::CString; + + if argv.is_empty() { + return Err(napi::Error::from_reason("exec_replace: argv must not be empty")); + } + let args = argv + .into_iter() + .map(CString::new) + .collect::, _>>() + .map_err(|err| napi::Error::from_reason(format!("exec_replace: {err}")))?; + let mut ptrs: Vec<*const libc::c_char> = args.iter().map(|arg| arg.as_ptr()).collect(); + ptrs.push(std::ptr::null()); + // SAFETY: `ptrs` is a NUL-terminated array of pointers into `args`, which + // outlives the call; execvp only returns on failure. + unsafe { libc::execvp(ptrs[0], ptrs.as_ptr()) }; + Err(napi::Error::from_reason(format!("execvp failed: {}", std::io::Error::last_os_error()))) + } + #[cfg(not(unix))] + { + let _ = argv; + Err(napi::Error::from_reason("exec_replace is unsupported on this platform")) + } +} diff --git a/crates/pi-natives/src/pty.rs b/crates/pi-natives/src/pty.rs index a0df784c8684..f0cd6b23af5c 100644 --- a/crates/pi-natives/src/pty.rs +++ b/crates/pi-natives/src/pty.rs @@ -8,14 +8,17 @@ use std::{ collections::HashMap, io::{Read, Write}, str, - sync::Arc, + sync::{ + Arc, + atomic::{AtomicBool, Ordering}, + }, time::{Duration, Instant}, }; use napi::{ JsString, bindgen_prelude::*, - threadsafe_function::{ThreadsafeFunction, ThreadsafeFunctionCallMode}, + threadsafe_function::{ThreadsafeFunction, ThreadsafeFunctionCallMode, UnknownReturnValue}, }; use napi_derive::napi; use parking_lot::Mutex; @@ -104,17 +107,25 @@ enum ControlMessage { } const CONTROL_MESSAGES_PER_TICK: usize = 64; -const READER_EVENTS_PER_TICK: usize = 256; +/// Capacity of the reader→JS queue. One queued chunk is at most one PTY read +/// (≤64 KiB), so the Rust side holds ~4 MiB before the reader thread's `send` +/// parks — which fills the OS PTY buffer and backpressures the child instead of +/// buffering the surplus in process memory. Same bound as the non-PTY bash +/// bridge (#4078). A separate `pump_pty_chunks` task `call_async`s so the +/// control loop never waits on JS (input/resize/kill/`try_wait` stay live). +const READER_QUEUE_CHUNKS: usize = 64; const POST_CANCEL_DRAIN_TIMEOUT: Duration = Duration::from_millis(300); -const POST_EXIT_DRAIN_TIMEOUT: Duration = Duration::from_millis(300); +/// Idle window used only when the child has already exited, the reader has +/// *not* hit EOF, the bridge queue is empty, and no `on_chunk` is in flight. +/// That is a permanently open slave (daemon / extra holder), not slow JS. +/// A reader parked on a full bridge is backpressure and must not use this. +const STUCK_SLAVE_IDLE: Duration = Duration::from_secs(2); /// How long a cancelled run polls for its SIGKILL'd child before handing the /// reap off to a detached thread rather than blocking the PTY promise. #[cfg(not(windows))] const CANCEL_REAP_TIMEOUT: Duration = Duration::from_millis(500); #[cfg(not(windows))] const CANCEL_REAP_POLL_INTERVAL: Duration = Duration::from_millis(5); -#[cfg(not(windows))] -const FINAL_READER_DRAIN_TIMEOUT: Duration = Duration::from_millis(50); struct PtySessionCore { control_tx: flume::Sender, @@ -147,7 +158,7 @@ impl PtySession { env: &'env Env, options: PtyStartOptions<'env>, #[napi(ts_arg_type = "((error: Error | null, chunk: string) => void) | undefined | null")] - on_chunk: Option>, + on_chunk: Option>, #[napi(ts_arg_type = "((error: Error | null, pid: number) => void) | undefined | null")] on_start: Option>, ) -> Result> { @@ -169,7 +180,7 @@ impl PtySession { env: &'env Env, options: PtyArgvStartOptions<'env>, #[napi(ts_arg_type = "((error: Error | null, chunk: string) => void) | undefined | null")] - on_chunk: Option>, + on_chunk: Option>, #[napi(ts_arg_type = "((error: Error | null, pid: number) => void) | undefined | null")] on_start: Option>, ) -> Result> { @@ -212,7 +223,7 @@ impl PtySession { run_config: PtyRunConfig, timeout_ms: Option, signal: Option>, - on_chunk: Option>, + on_chunk: Option>, on_start: Option>, ) -> Result> { let ct = task::CancelToken::new(timeout_ms, signal); @@ -275,7 +286,7 @@ fn terminate_pty_processes( } fn run_pty_sync( config: PtyRunConfig, - on_chunk: Option>, + on_chunk: Option>, on_start: Option>, control_rx: flume::Receiver, ct: task::CancelToken, @@ -388,7 +399,8 @@ fn run_pty_sync( .try_clone_reader() .map_err(|err| Error::from_reason(format!("Failed to create PTY reader: {err}")))?; - let (reader_tx, reader_rx) = flume::unbounded::(); + let (reader_tx, reader_rx) = flume::bounded::(READER_QUEUE_CHUNKS); + let queued = reader_tx.clone(); let reader_thread = std::thread::spawn(move || { const REPLACEMENT: &str = "\u{FFFD}"; const BUF: usize = 65536; @@ -405,7 +417,12 @@ fn run_pty_sync( let pending = &buf[..it]; match str::from_utf8(pending) { Ok(text) => { - let _ = reader_tx.send(ReaderEvent::Chunk(text.to_string())); + if reader_tx + .send(ReaderEvent::Chunk(text.to_string())) + .is_err() + { + return; + } it = 0; break; }, @@ -414,13 +431,23 @@ fn run_pty_sync( if valid_up_to > 0 { // SAFETY: [..valid_up_to] is guaranteed valid UTF-8 by valid_up_to(). let text = unsafe { str::from_utf8_unchecked(&pending[..valid_up_to]) }; - let _ = reader_tx.send(ReaderEvent::Chunk(text.to_string())); + if reader_tx + .send(ReaderEvent::Chunk(text.to_string())) + .is_err() + { + return; + } buf.copy_within(valid_up_to..it, 0); it -= valid_up_to; } match err.error_len() { Some(invalid_len) => { - let _ = reader_tx.send(ReaderEvent::Chunk(REPLACEMENT.to_string())); + if reader_tx + .send(ReaderEvent::Chunk(REPLACEMENT.to_string())) + .is_err() + { + return; + } buf.copy_within(invalid_len..it, 0); it -= invalid_len; }, @@ -439,11 +466,19 @@ fn run_pty_sync( } for chunk in buf[..it].utf8_chunks() { let valid = chunk.valid(); - if !valid.is_empty() { - let _ = reader_tx.send(ReaderEvent::Chunk(valid.to_string())); + if !valid.is_empty() + && reader_tx + .send(ReaderEvent::Chunk(valid.to_string())) + .is_err() + { + return; } - if !chunk.invalid().is_empty() { - let _ = reader_tx.send(ReaderEvent::Chunk(REPLACEMENT.to_string())); + if !chunk.invalid().is_empty() + && reader_tx + .send(ReaderEvent::Chunk(REPLACEMENT.to_string())) + .is_err() + { + return; } } let _ = reader_tx.send(ReaderEvent::Done); @@ -453,13 +488,45 @@ fn run_pty_sync( let process_group_id = master.process_group_leader().filter(|pgid| *pgid > 0); #[cfg(not(unix))] let process_group_id: Option = None; + let js_gone = Arc::new(AtomicBool::new(false)); + let in_js = Arc::new(AtomicBool::new(false)); + let (pump_done_tx, pump_done_rx) = flume::bounded::<()>(1); + let pump_task = { + let js_gone = Arc::clone(&js_gone); + let in_js = Arc::clone(&in_js); + napi::tokio::spawn(async move { + pump_pty_chunks( + reader_rx, + async move |payload| { + let Some(callback) = on_chunk.as_ref() else { + return true; + }; + let ok = callback.call_async(Ok(payload)).await.is_ok(); + if !ok { + js_gone.store(true, Ordering::Release); + } + ok + }, + Some(in_js.as_ref()), + ) + .await; + let _ = pump_done_tx.send(()); + }) + }; + let abort_pump = pump_task.abort_handle(); + let mut timed_out = false; let mut cancelled = false; - let mut reader_done = false; let mut exit_code: Option = None; let mut terminate_requested = false; let mut reader_drain_deadline: Option = None; - while exit_code.is_none() || !reader_done { + while exit_code.is_none() { + if js_gone.load(Ordering::Acquire) && !terminate_requested { + cancelled = true; + terminate_pty_processes(&mut child, child_pid, process_group_id); + terminate_requested = true; + reader_drain_deadline = Some(Instant::now() + POST_CANCEL_DRAIN_TIMEOUT); + } if !terminate_requested && let Err(err) = ct.heartbeat() { let message = err.to_string(); timed_out = message.contains("Timeout"); @@ -489,30 +556,13 @@ fn run_pty_sync( Err(flume::TryRecvError::Empty | flume::TryRecvError::Disconnected) => break, } } - - for _ in 0..READER_EVENTS_PER_TICK { - match reader_rx.try_recv() { - Ok(ReaderEvent::Chunk(chunk)) => emit_chunk(&chunk, on_chunk.as_ref()), - Ok(ReaderEvent::Done) => { - reader_done = true; - break; - }, - Err(flume::TryRecvError::Empty) => break, - Err(flume::TryRecvError::Disconnected) => { - reader_done = true; - break; - }, - } - } if exit_code.is_none() && let Some(status) = child .try_wait() .map_err(|err| Error::from_reason(format!("Failed checking PTY status: {err}")))? { exit_code = Some(i32::try_from(status.exit_code()).unwrap_or(i32::MAX)); - if !reader_done && reader_drain_deadline.is_none() { - reader_drain_deadline = Some(Instant::now() + POST_EXIT_DRAIN_TIMEOUT); - } + break; } if let Some(deadline) = reader_drain_deadline @@ -520,23 +570,28 @@ fn run_pty_sync( { break; } - if exit_code.is_none() || !reader_done { - let wait_duration = reader_drain_deadline.map_or(Duration::from_millis(16), |deadline| { - deadline - .saturating_duration_since(Instant::now()) - .min(Duration::from_millis(16)) - }); - match reader_rx.recv_timeout(wait_duration) { - Ok(ReaderEvent::Chunk(chunk)) => emit_chunk(&chunk, on_chunk.as_ref()), - Ok(ReaderEvent::Done) => reader_done = true, - Err(flume::RecvTimeoutError::Timeout) => {}, - Err(flume::RecvTimeoutError::Disconnected) => { - reader_done = true; - if exit_code.is_none() { - std::thread::sleep(wait_duration); - } - }, - } + let wait_duration = reader_drain_deadline.map_or(Duration::from_millis(16), |deadline| { + deadline + .saturating_duration_since(Instant::now()) + .min(Duration::from_millis(16)) + }); + match control_rx.recv_timeout(wait_duration) { + Ok(ControlMessage::Input(data)) => { + let _ = writer.write_all(data.as_bytes()); + let _ = writer.flush(); + }, + Ok(ControlMessage::Resize { cols, rows }) => { + let _ = master.resize(PtySize { rows, cols, pixel_width: 0, pixel_height: 0 }); + }, + Ok(ControlMessage::Kill) => { + cancelled = true; + if !terminate_requested { + terminate_pty_processes(&mut child, child_pid, process_group_id); + terminate_requested = true; + reader_drain_deadline = Some(Instant::now() + POST_CANCEL_DRAIN_TIMEOUT); + } + }, + Err(flume::RecvTimeoutError::Timeout | flume::RecvTimeoutError::Disconnected) => {}, } } if exit_code.is_none() { @@ -600,41 +655,11 @@ fn run_pty_sync( // I/O threads to finish processing and eventually close the output pipe. drop(writer); - // Step 2: Drain the reader thread. - // After the child exits and input is closed, ConPTY should flush remaining - // output and signal EOF on the output pipe, causing the reader thread to exit. - // On Windows, use a generous timeout to accommodate ConPTY's async teardown. - if !reader_done { - #[cfg(windows)] - let drain_timeout = Duration::from_millis(500); - #[cfg(not(windows))] - let drain_timeout = FINAL_READER_DRAIN_TIMEOUT; - let finalize_deadline = Instant::now() + drain_timeout; - while Instant::now() < finalize_deadline { - let remaining = finalize_deadline.saturating_duration_since(Instant::now()); - let wait_duration = remaining.min(Duration::from_millis(5)); - match reader_rx.recv_timeout(wait_duration) { - Ok(ReaderEvent::Chunk(chunk)) => emit_chunk(&chunk, on_chunk.as_ref()), - Ok(ReaderEvent::Done) => { - reader_done = true; - break; - }, - Err(flume::RecvTimeoutError::Timeout) => {}, - Err(flume::RecvTimeoutError::Disconnected) => { - reader_done = true; - break; - }, - } - } - } - - // Step 3: Drop master (calls ClosePseudoConsole on Windows). - // ClosePseudoConsole can deadlock if ConPTY tries to flush output - // while nobody is reading the pipe (microsoft/terminal#1810). - // Always offload to a background thread on Windows, then wait with - // a timeout so the thread is reclaimed when ClosePseudoConsole - // completes cleanly. If it hangs, we walk away — the thread leaks, - // but the main thread never blocks. + // Step 2: Drop master so the reader sees EOF if the slave is gone, then + // drain JS. Successful finite runs wait until every accepted chunk has + // reached `on_chunk` (#7421). A reader parked on backpressure is not + // aborted. A descendant holding the slave open is the existing no-join + // case and is the only path that may skip an unbounded wait. #[cfg(windows)] { let (drop_tx, drop_rx) = flume::unbounded::<()>(); @@ -648,19 +673,375 @@ fn run_pty_sync( { drop(master); } + await_pty_output_drain( + pump_done_rx, + reader_thread, + queued, + &in_js, + cancelled || timed_out, + || abort_pump.abort(), + ); + drop(pump_task); + Ok(PtyRunResult { exit_code, cancelled, timed_out }) +} + +/// Drain `rx`, greedily coalescing queued chunks into ≤64 KiB batches, and +/// feed each batch to `forward`, awaiting its completion before pulling more. +/// Mirrors `shell.rs` `pump_chunks` (#4078): JS consumption backpressures the +/// bounded reader queue; the PTY control loop never calls into napi. +async fn pump_pty_chunks( + rx: flume::Receiver, + mut forward: impl AsyncFnMut(String) -> bool, + busy: Option<&AtomicBool>, +) { + const MAX_BATCH_BYTES: usize = 64 * 1024; + const INITIAL_BATCH_CAP: usize = 8 * 1024; + let mut batch = String::with_capacity(INITIAL_BATCH_CAP); + let set_busy = |value: bool| { + if let Some(busy) = busy { + busy.store(value, Ordering::Release); + } + }; + loop { + let first = match rx.recv_async().await { + Ok(ReaderEvent::Chunk(text)) => { + // Hold the idle-check flag before coalesce/forward so a drained + // queue is not mistaken for a stuck-open slave. + set_busy(true); + text + }, + Ok(ReaderEvent::Done) | Err(_) => break, + }; + batch.push_str(&first); + let mut done = false; + while batch.len() < MAX_BATCH_BYTES { + match rx.try_recv() { + Ok(ReaderEvent::Chunk(more)) => batch.push_str(&more), + Ok(ReaderEvent::Done) => { + done = true; + break; + }, + Err(_) => break, + } + } + let payload = std::mem::replace(&mut batch, String::with_capacity(INITIAL_BATCH_CAP)); + let keep_going = payload.is_empty() || forward(payload).await; + set_busy(false); + if !keep_going { + return; + } + if done { + return; + } + } +} - // Step 4: Join reader thread if it finished. - // A detached descendant can keep the PTY slave open forever; do not block - // completion waiting on join when the reader thread did not reach EOF. - if reader_done { - let _ = reader_thread.join(); +/// Wait for the JS pump after the child has exited and the master is dropped. +/// +/// `queued` is a clone of the reader sender, used only to see whether the +/// bridge still holds bytes (backpressure vs open slave). It is dropped as +/// soon as the reader has exited so the pump is not left parked on `recv`. +/// +/// Cancel/timeout must not pin the promise on a slow callback. A successful +/// finite run must not resolve until accepted output reached `on_chunk` +/// (#7421). After reader EOF, wait for the pump with no idle timeout. A +/// reader parked on a full bridge is backpressure, not a hang. Only a +/// permanently open slave (EOF never arrives, queue empty, no in-flight +/// callback) may skip the unbounded wait. `stop_pump` is invoked on every +/// abandonment path, then this waits up to `POST_CANCEL_DRAIN_TIMEOUT` for +/// the pump task to observe abort so `start()` does not resolve while +/// `call_async` is still in Rust. An already-queued napi callback can still +/// run once; TSFN work lives on the JS thread. +fn await_pty_output_drain( + pump_done_rx: flume::Receiver<()>, + reader_thread: std::thread::JoinHandle<()>, + queued: flume::Sender, + in_js: &AtomicBool, + abandon_slow_js: bool, + stop_pump: impl FnOnce(), +) { + let mut stop_pump = Some(stop_pump); + + if abandon_slow_js { + if let Some(stop_pump) = stop_pump.take() { + stop_pump(); + } + drop(queued); + let _ = pump_done_rx.recv_timeout(POST_CANCEL_DRAIN_TIMEOUT); + if reader_thread.is_finished() { + let _ = reader_thread.join(); + } + return; + } + + loop { + if reader_thread.is_finished() { + drop(queued); + // Unbounded by design (#7421, same as shell.rs `drain_handle.await`). + let _ = pump_done_rx.recv(); + let _ = reader_thread.join(); + return; + } + + match pump_done_rx.recv_timeout(STUCK_SLAVE_IDLE) { + Ok(()) | Err(flume::RecvTimeoutError::Disconnected) => { + if reader_thread.is_finished() { + let _ = reader_thread.join(); + } + return; + }, + Err(flume::RecvTimeoutError::Timeout) => { + if reader_thread.is_finished() { + continue; + } + if queued.is_empty() && !in_js.load(Ordering::Acquire) { + if let Some(stop_pump) = stop_pump.take() { + stop_pump(); + } + drop(queued); + let _ = pump_done_rx.recv_timeout(POST_CANCEL_DRAIN_TIMEOUT); + return; + } + }, + } } - Ok(PtyRunResult { exit_code, cancelled, timed_out }) } -fn emit_chunk(text: &str, callback: Option<&ThreadsafeFunction>) { - if let Some(callback) = callback { - callback.call(Ok(text.to_string()), ThreadsafeFunctionCallMode::NonBlocking); +#[cfg(test)] +mod reader_queue_tests { + use std::{ + sync::{ + Arc, + atomic::{AtomicBool, Ordering}, + }, + time::{Duration, Instant}, + }; + + use tokio::time; + + use super::{ + POST_CANCEL_DRAIN_TIMEOUT, READER_QUEUE_CHUNKS, ReaderEvent, STUCK_SLAVE_IDLE, + await_pty_output_drain, pump_pty_chunks, + }; + + /// Regression for the PTY sibling of #4078: a stalled JS consumer + /// (`forward`) must not let the reader queue grow without bound, and chunks + /// must arrive losslessly and in order. Copied from + /// `bridge_pump_bounds_queue_and_delivers_all_bytes`. + #[tokio::test(flavor = "multi_thread")] + async fn pty_pump_bounds_queue_and_delivers_all_bytes() { + const CHUNKS: usize = 512; + const CHUNK_BYTES: usize = 4096; + let (tx, rx) = flume::bounded::(READER_QUEUE_CHUNKS); + let producer = tokio::spawn(async move { + let mut expected = String::with_capacity(CHUNKS * CHUNK_BYTES); + let mut max_queued = 0usize; + for i in 0..CHUNKS { + let chunk = format!("[{i:06}]{}", "x".repeat(CHUNK_BYTES - 8)); + expected.push_str(&chunk); + tx.send_async(ReaderEvent::Chunk(chunk)) + .await + .expect("pump should outlive the producer"); + max_queued = max_queued.max(tx.len()); + } + tx.send_async(ReaderEvent::Done) + .await + .expect("pump should accept Done"); + (expected, max_queued) + }); + + let mut received = String::with_capacity(CHUNKS * CHUNK_BYTES); + time::timeout( + Duration::from_secs(30), + pump_pty_chunks( + rx, + async |payload: String| { + received.push_str(&payload); + time::sleep(Duration::from_micros(500)).await; + true + }, + None, + ), + ) + .await + .expect("pump should finish once the producer hangs up"); + + let (expected, max_queued) = producer.await.expect("producer task"); + assert!( + max_queued <= READER_QUEUE_CHUNKS, + "PTY reader queue grew past its bound: {max_queued} chunks", + ); + assert_eq!(received.len(), expected.len(), "bytes were dropped or duplicated"); + assert_eq!(received, expected, "chunks must arrive losslessly and in order"); + } + + /// When JS dies (`forward` fails), the pump must drop its receiver so parked + /// sends fail fast — the PTY reader keeps draining the child instead of + /// wedging it on a full bridge queue. + #[tokio::test(flavor = "multi_thread")] + async fn pty_pump_death_disconnects_channel_without_blocking_senders() { + let (tx, rx) = flume::bounded::(4); + let pump = tokio::spawn(pump_pty_chunks(rx, async |_payload: String| false, None)); + let producer = tokio::spawn(async move { + let mut disconnected = 0usize; + for _ in 0..64 { + if tx + .send_async(ReaderEvent::Chunk("x".repeat(1024))) + .await + .is_err() + { + disconnected += 1; + } + } + + disconnected + }); + let disconnected = time::timeout(Duration::from_secs(5), producer) + .await + .expect("sends must not park once the consumer died") + .expect("producer task"); + assert!(disconnected > 0, "channel should disconnect after the pump stops"); + time::timeout(Duration::from_secs(5), pump) + .await + .expect("pump should exit after forward fails") + .expect("pump task"); + } + #[test] + fn drain_waits_for_slow_js_after_reader_eof() { + let (pump_tx, pump_rx) = flume::bounded(1); + let reader = std::thread::spawn(|| {}); + let (queued, _) = flume::bounded::(READER_QUEUE_CHUNKS); + let in_js = AtomicBool::new(false); + std::thread::spawn(move || { + std::thread::sleep(Duration::from_millis(2500)); + let _ = pump_tx.send(()); + }); + let start = Instant::now(); + await_pty_output_drain(pump_rx, reader, queued, &in_js, false, || {}); + assert!( + start.elapsed() >= Duration::from_millis(2400), + "must not time out a slow callback after reader EOF", + ); + } + + #[test] + fn drain_drops_sender_clone_after_reader_eof_so_pump_unblocks() { + let (reader_tx, reader_rx) = flume::bounded::(READER_QUEUE_CHUNKS); + let queued = reader_tx.clone(); + drop(reader_tx); + let (pump_tx, pump_rx) = flume::bounded(1); + std::thread::spawn(move || { + let _ = reader_rx.recv(); + let _ = pump_tx.send(()); + }); + let reader = std::thread::spawn(|| {}); + let deadline = Instant::now() + Duration::from_secs(1); + while !reader.is_finished() && Instant::now() < deadline { + std::thread::sleep(Duration::from_millis(1)); + } + assert!(reader.is_finished(), "reader fixture must have exited"); + let in_js = AtomicBool::new(false); + let start = Instant::now(); + await_pty_output_drain(pump_rx, reader, queued, &in_js, false, || {}); + assert!( + start.elapsed() < STUCK_SLAVE_IDLE, + "holding the sender clone after EOF parks the pump until idle timeout", + ); + } + + #[test] + fn drain_gives_up_only_on_open_slave_idle() { + let (_pump_tx, pump_rx) = flume::bounded::<()>(1); + let reader = std::thread::spawn(|| { + std::thread::park(); + }); + let (queued, _) = flume::bounded::(READER_QUEUE_CHUNKS); + let in_js = AtomicBool::new(false); + let stopped = AtomicBool::new(false); + let start = Instant::now(); + await_pty_output_drain(pump_rx, reader, queued, &in_js, false, || { + stopped.store(true, Ordering::Release); + }); + let elapsed = start.elapsed(); + assert!(elapsed >= STUCK_SLAVE_IDLE); + assert!(elapsed < STUCK_SLAVE_IDLE + Duration::from_secs(2)); + assert!(stopped.load(Ordering::Acquire), "open slave must stop the pump"); + } + + #[test] + fn drain_does_not_treat_queued_backpressure_as_stuck_slave() { + let (pump_tx, pump_rx) = flume::bounded(1); + let reader = std::thread::spawn(|| std::thread::park()); + let (queued, _rx) = flume::bounded::(READER_QUEUE_CHUNKS); + queued + .send(ReaderEvent::Chunk("x".into())) + .expect("queue accepts a chunk"); + let in_js = AtomicBool::new(false); + std::thread::spawn(move || { + std::thread::sleep(Duration::from_millis(2500)); + let _ = pump_tx.send(()); + }); + let start = Instant::now(); + await_pty_output_drain(pump_rx, reader, queued, &in_js, false, || {}); + assert!( + start.elapsed() >= Duration::from_millis(2400), + "queued output is backpressure, not a stuck slave", + ); + } + + #[test] + fn drain_does_not_treat_in_flight_callback_as_stuck_slave() { + let (pump_tx, pump_rx) = flume::bounded(1); + let reader = std::thread::spawn(|| std::thread::park()); + let (queued, _) = flume::bounded::(READER_QUEUE_CHUNKS); + let in_js = Arc::new(AtomicBool::new(true)); + let in_js_flag = Arc::clone(&in_js); + std::thread::spawn(move || { + std::thread::sleep(Duration::from_millis(2500)); + in_js_flag.store(false, Ordering::Release); + let _ = pump_tx.send(()); + }); + let start = Instant::now(); + await_pty_output_drain(pump_rx, reader, queued, &in_js, false, || {}); + assert!( + start.elapsed() >= Duration::from_millis(2400), + "an in-flight on_chunk is slow JS, not a stuck slave", + ); + } + + #[test] + fn drain_cancel_does_not_wait_for_slow_js() { + let (_pump_tx, pump_rx) = flume::bounded::<()>(1); + let reader = std::thread::spawn(|| std::thread::park()); + let (queued, _) = flume::bounded::(READER_QUEUE_CHUNKS); + let in_js = AtomicBool::new(true); + let stopped = AtomicBool::new(false); + let start = Instant::now(); + await_pty_output_drain(pump_rx, reader, queued, &in_js, true, || { + stopped.store(true, Ordering::Release); + }); + assert!( + start.elapsed() < Duration::from_secs(2), + "cancel must not pin the promise on a stalled callback", + ); + assert!(start.elapsed() >= POST_CANCEL_DRAIN_TIMEOUT); + assert!(stopped.load(Ordering::Acquire), "cancel must stop the pump"); + } + + #[test] + fn drain_cancel_returns_once_pump_observes_stop() { + let (pump_tx, pump_rx) = flume::bounded::<()>(1); + let reader = std::thread::spawn(|| std::thread::park()); + let (queued, _) = flume::bounded::(READER_QUEUE_CHUNKS); + let in_js = AtomicBool::new(true); + let start = Instant::now(); + await_pty_output_drain(pump_rx, reader, queued, &in_js, true, move || { + drop(pump_tx); + }); + assert!( + start.elapsed() < POST_CANCEL_DRAIN_TIMEOUT, + "after stop disconnects the pump, cancel must not sit out the full drain timeout", + ); } } diff --git a/crates/pi-natives/src/syntaxes/TypeScript.sublime-syntax b/crates/pi-natives/src/syntaxes/TypeScript.sublime-syntax new file mode 100644 index 000000000000..68c9b4a942f2 --- /dev/null +++ b/crates/pi-natives/src/syntaxes/TypeScript.sublime-syntax @@ -0,0 +1,3428 @@ +%YAML 1.2 +--- +# http://www.sublimetext.com/docs/3/syntax.html +name: TypeScript +file_extensions: + - ts + - mts + - cts +scope: source.ts +contexts: + main: + - include: directives + - include: statements + - include: shebang + comment: + - match: /\*\*(?!/) + captures: + 0: punctuation.definition.comment.ts + push: + - meta_scope: comment.block.documentation.ts + - match: \*/ + captures: + 0: punctuation.definition.comment.ts + pop: true + - include: docblock + - match: (/\*)(?:\s*((@)internal)(?=\s|(\*/)))? + captures: + 1: punctuation.definition.comment.ts + 2: storage.type.internaldeclaration.ts + 3: punctuation.decorator.internaldeclaration.ts + push: + - meta_scope: comment.block.ts + - match: \*/ + captures: + 0: punctuation.definition.comment.ts + pop: true + - match: '(^[ \t]+)?((//)(?:\s*((@)internal)(?=\s|$))?)' + captures: + 1: punctuation.whitespace.comment.leading.ts + 2: comment.line.double-slash.ts + 3: punctuation.definition.comment.ts + 4: storage.type.internaldeclaration.ts + 5: punctuation.decorator.internaldeclaration.ts + push: + - meta_content_scope: comment.line.double-slash.ts + - match: (?=$) + pop: true + access-modifier: + - match: '(?]|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^yield|[^\._$[:alnum:]]yield|^throw|[^\._$[:alnum:]]throw|^in|[^\._$[:alnum:]]in|^of|[^\._$[:alnum:]]of|^typeof|[^\._$[:alnum:]]typeof|&&|\|\||\*)\s*(\{)' + captures: + 1: punctuation.definition.block.ts + push: + - meta_scope: meta.objectliteral.ts + - match: '\}' + captures: + 0: punctuation.definition.block.ts + pop: true + - include: object-member + array-binding-pattern: + - match: '(?:(\.\.\.)\s*)?(\[)' + captures: + 1: keyword.operator.rest.ts + 2: punctuation.definition.binding-pattern.array.ts + push: + - match: '\]' + captures: + 0: punctuation.definition.binding-pattern.array.ts + pop: true + - include: binding-element + - include: punctuation-comma + array-binding-pattern-const: + - match: '(?:(\.\.\.)\s*)?(\[)' + captures: + 1: keyword.operator.rest.ts + 2: punctuation.definition.binding-pattern.array.ts + push: + - match: '\]' + captures: + 0: punctuation.definition.binding-pattern.array.ts + pop: true + - include: binding-element-const + - include: punctuation-comma + array-literal: + - match: '\s*(\[)' + captures: + 1: meta.brace.square.ts + push: + - meta_scope: meta.array.literal.ts + - match: '\]' + captures: + 0: meta.brace.square.ts + pop: true + - include: expression + - include: punctuation-comma + arrow-function: + - match: '(?:(?)' + scope: meta.arrow.ts + captures: + 1: storage.modifier.async.ts + 2: variable.parameter.ts + - match: |- + (?x) (?: + (? is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + ) + ) + captures: + 1: storage.modifier.async.ts + push: + - meta_scope: meta.arrow.ts + - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))' + pop: true + - include: comment + - include: type-parameters + - include: function-parameters + - include: arrow-return-type + - include: possibly-arrow-return-type + - match: "=>" + captures: + 0: storage.type.function.arrow.ts + push: + - meta_scope: meta.arrow.ts + - match: '((?<=\}|\S)(?)|((?!\{)(?=\S)))(?!\/[\/\*])' + pop: true + - include: single-line-comment-consuming-line-ending + - include: decl-block + - include: expression + arrow-return-type: + - match: (?<=\))\s*(:) + captures: + 1: keyword.operator.type.annotation.ts + push: + - meta_scope: meta.return.type.arrow.ts + - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))' + pop: true + - include: arrow-return-type-body + arrow-return-type-body: + - match: '(?<=[:])(?=\s*\{)' + push: + - match: '(?<=\})' + pop: true + - include: type-object + - include: type-predicate-operator + - include: type + async-modifier: + - match: '(?) + scope: cast.expr.ts + captures: + 1: meta.brace.angle.ts + 2: storage.modifier.ts + 3: meta.brace.angle.ts + - match: '(?:(?*?\&\|\^]|[^_$[:alnum:]](?:\+\+|\-\-)|[^\+]\+|[^\-]\-))\s*(<)(?!) + captures: + 1: meta.brace.angle.ts + pop: true + - include: type + - match: '(?:(?<=^))\s*(<)(?=[_$[:alpha:]][_$[:alnum:]]*\s*>)' + captures: + 1: meta.brace.angle.ts + push: + - meta_scope: cast.expr.ts + - match: (\>) + captures: + 1: meta.brace.angle.ts + pop: true + - include: type + class-declaration: + - match: '(?\s*$)' + captures: + 1: punctuation.definition.comment.ts + push: + - meta_scope: comment.line.triple-slash.directive.ts + - match: (?=$) + pop: true + - match: (<)(reference|amd-dependency|amd-module) + captures: + 1: punctuation.definition.tag.directive.ts + 2: entity.name.tag.directive.ts + push: + - meta_scope: meta.tag.ts + - match: /> + captures: + 0: punctuation.definition.tag.directive.ts + pop: true + - match: path|types|no-default-lib|lib|name + scope: entity.other.attribute-name.directive.ts + - match: "=" + scope: keyword.operator.assignment.ts + - include: string + docblock: + - match: |- + (?x) + ((@)(?:access|api)) + \s+ + (private|protected|public) + \b + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: constant.language.access-type.jsdoc + - match: |- + (?x) + ((@)author) + \s+ + ( + [^@\s<>*/] + (?:[^@<>*/]|\*[^/])* + ) + (?: + \s* + (<) + ([^>\s]+) + (>) + )? + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: entity.name.type.instance.jsdoc + 4: punctuation.definition.bracket.angle.begin.jsdoc + 5: constant.other.email.link.underline.jsdoc + 6: punctuation.definition.bracket.angle.end.jsdoc + - match: |- + (?x) + ((@)borrows) \s+ + ((?:[^@\s*/]|\*[^/])+) # + \s+ (as) \s+ # as + ((?:[^@\s*/]|\*[^/])+) # + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: entity.name.type.instance.jsdoc + 4: keyword.operator.control.jsdoc + 5: entity.name.type.instance.jsdoc + - match: ((@)example)\s+ + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + push: + - meta_scope: meta.example.jsdoc + - match: (?=@|\*/) + pop: true + - match: ^\s\*\s+ + - match: \G(<)caption(>) + captures: + 0: entity.name.tag.inline.jsdoc + 1: punctuation.definition.bracket.angle.begin.jsdoc + 2: punctuation.definition.bracket.angle.end.jsdoc + push: + - meta_content_scope: constant.other.description.jsdoc + - match: ()|(?=\*/) + captures: + 0: entity.name.tag.inline.jsdoc + 1: punctuation.definition.bracket.angle.begin.jsdoc + 2: punctuation.definition.bracket.angle.end.jsdoc + pop: true + - match: '[^\s@*](?:[^*]|\*[^/])*' + captures: + 0: source.embedded.ts + - match: (?x) ((@)kind) \s+ (class|constant|event|external|file|function|member|mixin|module|namespace|typedef) \b + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: constant.language.symbol-type.jsdoc + - match: |- + (?x) + ((@)see) + \s+ + (?: + # URL + ( + (?=https?://) + (?:[^\s*]|\*[^/])+ + ) + | + # JSDoc namepath + ( + (?! + # Avoid matching bare URIs (also acceptable as links) + https?:// + | + # Avoid matching {@inline tags}; we match those below + (?:\[[^\[\]]*\])? # Possible description [preceding]{@tag} + {@(?:link|linkcode|linkplain|tutorial)\b + ) + # Matched namepath + (?:[^@\s*/]|\*[^/])+ + ) + ) + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: variable.other.link.underline.jsdoc + 4: entity.name.type.instance.jsdoc + - match: |- + (?x) + ((@)template) + \s+ + # One or more valid identifiers + ( + [A-Za-z_$] # First character: non-numeric word character + [\w$.\[\]]* # Rest of identifier + (?: # Possible list of additional identifiers + \s* , \s* + [A-Za-z_$] + [\w$.\[\]]* + )* + ) + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: variable.other.jsdoc + - match: |- + (?x) + ( + (@) + (?:arg|argument|const|constant|member|namespace|param|var) + ) + \s+ + ( + [A-Za-z_$] + [\w$.\[\]]* + ) + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: variable.other.jsdoc + - match: '((@)typedef)\s+(?={)' + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + push: + - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])' + pop: true + - include: jsdoctype + - match: '(?:[^@\s*/]|\*[^/])+' + scope: entity.name.type.instance.jsdoc + - match: '((@)(?:arg|argument|const|constant|member|namespace|param|prop|property|var))\s+(?={)' + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + push: + - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])' + pop: true + - include: jsdoctype + - match: '([A-Za-z_$][\w$.\[\]]*)' + scope: variable.other.jsdoc + - match: |- + (?x) + (\[)\s* + [\w$]+ + (?: + (?:\[\])? # Foo[ ].bar properties within an array + \. # Foo.Bar namespaced parameter + [\w$]+ + )* + (?: + \s* + (=) # [foo=bar] Default parameter value + \s* + ( + # The inner regexes are to stop the match early at */ and to not stop at escaped quotes + (?> + "(?:(?:\*(?!/))|(?:\\(?!"))|[^*\\])*?" | # [foo="bar"] Double-quoted + '(?:(?:\*(?!/))|(?:\\(?!'))|[^*\\])*?' | # [foo='bar'] Single-quoted + \[ (?:(?:\*(?!/))|[^*])*? \] | # [foo=[1,2]] Array literal + (?:(?:\*(?!/))|\s(?!\s*\])|\[.*?(?:\]|(?=\*/))|[^*\s\[\]])* # Everything else + )* + ) + )? + \s*(?:(\])((?:[^*\s]|\*[^\s/])+)?|(?=\*/)) + scope: variable.other.jsdoc + captures: + 1: punctuation.definition.optional-value.begin.bracket.square.jsdoc + 2: keyword.operator.assignment.jsdoc + 3: source.embedded.ts + 4: punctuation.definition.optional-value.end.bracket.square.jsdoc + 5: invalid.illegal.syntax.jsdoc + - match: |- + (?x) + ( + (@) + (?:define|enum|exception|export|extends|lends|implements|modifies + |namespace|private|protected|returns?|suppress|this|throws|type + |yields?) + ) + \s+(?={) + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + push: + - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])' + pop: true + - include: jsdoctype + - match: |- + (?x) + ( + (@) + (?:alias|augments|callback|constructs|emits|event|fires|exports? + |extends|external|function|func|host|lends|listens|interface|memberof!? + |method|module|mixes|mixin|name|requires|see|this|typedef|uses) + ) + \s+ + ( + (?: + [^{}@\s*] | \*[^/] + )+ + ) + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: entity.name.type.instance.jsdoc + - match: '((@)(?:default(?:value)?|license|version))\s+(([''''"]))' + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: variable.other.jsdoc + 4: punctuation.definition.string.begin.jsdoc + push: + - meta_content_scope: variable.other.jsdoc + - match: (\3)|(?=$|\*/) + captures: + 0: variable.other.jsdoc + 1: punctuation.definition.string.end.jsdoc + pop: true + - match: '((@)(?:default(?:value)?|license|tutorial|variation|version))\s+([^\s*]+)' + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: variable.other.jsdoc + - match: '(?x) (@) (?:abstract|access|alias|api|arg|argument|async|attribute|augments|author|beta|borrows|bubbles |callback|chainable|class|classdesc|code|config|const|constant|constructor|constructs|copyright |default|defaultvalue|define|deprecated|desc|description|dict|emits|enum|event|example|exception |exports?|extends|extension(?:_?for)?|external|externs|file|fileoverview|final|fires|for|func |function|generator|global|hideconstructor|host|ignore|implements|implicitCast|inherit[Dd]oc |inner|instance|interface|internal|kind|lends|license|listens|main|member|memberof!?|method |mixes|mixins?|modifies|module|name|namespace|noalias|nocollapse|nocompile|nosideeffects |override|overview|package|param|polymer(?:Behavior)?|preserve|private|prop|property|protected |public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary |suppress|template|this|throws|todo|tutorial|type|typedef|unrestricted|uses|var|variation |version|virtual|writeOnce|yields?) \b' + scope: storage.type.class.jsdoc + captures: + 1: punctuation.definition.block.tag.jsdoc + - include: inline-tags + - match: '((@)(?:[_$[:alpha:]][_$[:alnum:]]*))(?=\s+)' + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + enum-declaration: + - match: '(?) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) | + # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => + (:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) + )) | + (:\s*(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | + (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + captures: + 1: storage.modifier.ts + 2: keyword.operator.rest.ts + 3: entity.name.function.ts variable.language.this.ts + 4: entity.name.function.ts + 5: keyword.operator.optional.ts + - match: '(?x)(?:(?]|\|\||\&\&|\!\=\=|$|((?>=|>>>=|\|= + scope: keyword.operator.assignment.compound.bitwise.ts + - match: "<<|>>>|>>" + scope: keyword.operator.bitwise.shift.ts + - match: "===|!==|==|!=" + scope: keyword.operator.comparison.ts + - match: <=|>=|<>|<|> + scope: keyword.operator.relational.ts + - match: '(?<=[_$[:alnum:]])(\!)\s*(?:(/=)|(?:(/)(?![/*])))' + captures: + 1: keyword.operator.logical.ts + 2: keyword.operator.assignment.compound.ts + 3: keyword.operator.arithmetic.ts + - match: \!|&&|\|\||\?\? + scope: keyword.operator.logical.ts + - match: \&|~|\^|\| + scope: keyword.operator.bitwise.ts + - match: \= + scope: keyword.operator.assignment.ts + - match: "--" + scope: keyword.operator.decrement.ts + - match: \+\+ + scope: keyword.operator.increment.ts + - match: '%|\*|/|-|\+' + scope: keyword.operator.arithmetic.ts + - match: '(?<=[_$[:alnum:])\]])\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)+(?:(/=)|(?:(/)(?![/*]))))' + push: + - match: '(?:(/=)|(?:(/)(?!\*([^\*]|(\*[^\/]))*\*\/)))' + captures: + 1: keyword.operator.assignment.compound.ts + 2: keyword.operator.arithmetic.ts + pop: true + - include: comment + - match: '(?<=[_$[:alnum:])\]])\s*(?:(/=)|(?:(/)(?![/*])))' + captures: + 1: keyword.operator.assignment.compound.ts + 2: keyword.operator.arithmetic.ts + expressionPunctuations: + - include: punctuation-comma + - include: punctuation-accessor + expressionWithoutIdentifiers: + - include: string + - include: regex + - include: comment + - include: function-expression + - include: class-expression + - include: arrow-function + - include: paren-expression-possibly-arrow + - include: cast + - include: ternary-expression + - include: new-expr + - include: instanceof-expr + - include: object-literal + - include: expression-operators + - include: function-call + - include: literal + - include: support-objects + - include: paren-expression + field-declaration: + - match: |- + (?x)(?) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) | + # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => + (:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) + )) | + (:\s*(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | + (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + captures: + 1: meta.definition.property.ts entity.name.function.ts + 2: keyword.operator.optional.ts + 3: keyword.operator.definiteassignment.ts + - match: '\#?[_$[:alpha:]][_$[:alnum:]]*' + scope: meta.definition.property.ts variable.object.property.ts + - match: \? + scope: keyword.operator.optional.ts + - match: \! + scope: keyword.operator.definiteassignment.ts + for-loop: + - match: '(?\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)?\())' + push: + - match: '(?<=\))(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)?\())' + pop: true + - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))' + push: + - meta_scope: meta.function-call.ts + - match: '(?=\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)?\())' + pop: true + - include: function-call-target + - include: comment + - include: function-call-optionals + - include: type-arguments + - include: paren-expression + - match: '(?=(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$))' + push: + - match: '(?<=\>)(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$))' + pop: true + - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))' + push: + - meta_scope: meta.function-call.ts + - match: '(?=(<\s*[\{\[\(]\s*$))' + pop: true + - include: function-call-target + - include: comment + - include: function-call-optionals + - include: type-arguments + function-call-optionals: + - match: \?\. + scope: meta.function-call.ts punctuation.accessor.optional.ts + - match: \! + scope: meta.function-call.ts keyword.operator.definiteassignment.ts + function-call-target: + - include: support-function-call-identifiers + - match: '(\#?[_$[:alpha:]][_$[:alnum:]]*)' + scope: entity.name.function.ts + function-declaration: + - match: '(?) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) + captures: + 1: punctuation.accessor.ts + 2: punctuation.accessor.optional.ts + 3: entity.name.function.ts + - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])' + captures: + 1: punctuation.accessor.ts + 2: punctuation.accessor.optional.ts + 3: variable.other.constant.property.ts + - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[_$[:alpha:]][_$[:alnum:]]*)' + captures: + 1: punctuation.accessor.ts + 2: punctuation.accessor.optional.ts + 3: variable.other.property.ts + - match: "([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])" + scope: variable.other.constant.ts + - match: "[_$[:alpha:]][_$[:alnum:]]*" + scope: variable.other.readwrite.ts + if-statement: + - match: '(?]|\|\||\&\&|\!\=\=|$|(([\&\~\^\|]\s*)?[_$[:alpha:]][_$[:alnum:]]*\s+instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])' + captures: + 1: storage.modifier.ts + 2: storage.modifier.ts + 3: storage.modifier.ts + 4: storage.modifier.async.ts + 5: keyword.operator.new.ts + 6: keyword.generator.asterisk.ts + push: + - meta_scope: meta.method.declaration.ts + - match: '(?=\}|;|,|$)|(?<=\})' + pop: true + - include: method-declaration-name + - include: function-body + - match: |- + (?x)(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + captures: + 1: storage.modifier.ts + 2: storage.modifier.ts + 3: storage.modifier.ts + 4: storage.modifier.async.ts + 5: storage.type.property.ts + 6: keyword.generator.asterisk.ts + push: + - meta_scope: meta.method.declaration.ts + - match: '(?=\}|;|,|$)|(?<=\})' + pop: true + - include: method-declaration-name + - include: function-body + method-declaration-name: + - match: |- + (?x)(?=((\b(?]|\|\||\&\&|\!\=\=|$|((?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + captures: + 1: storage.modifier.async.ts + 2: storage.type.property.ts + 3: keyword.generator.asterisk.ts + push: + - meta_scope: meta.method.declaration.ts + - match: '(?=\}|;|,)|(?<=\})' + pop: true + - include: method-declaration-name + - include: function-body + - match: |- + (?x)(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + captures: + 1: storage.modifier.async.ts + 2: storage.type.property.ts + 3: keyword.generator.asterisk.ts + push: + - match: (?=\(|\<) + pop: true + - include: method-declaration-name + object-member: + - include: comment + - include: object-literal-method-declaration + - match: '(?=\[)' + push: + - meta_scope: meta.object.member.ts meta.object-literal.key.ts + - match: '(?=:)|((?<=[\]])(?=\s*[\(\<]))' + pop: true + - include: comment + - include: array-literal + - match: '(?=[\''\"\`])' + push: + - meta_scope: meta.object.member.ts meta.object-literal.key.ts + - match: '(?=:)|((?<=[\''\"\`])(?=((\s*[\(\<,}])|(\s+(as)\s+))))' + pop: true + - include: comment + - include: string + - match: |- + (?x)(?=(\b(?) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + scope: meta.object.member.ts + captures: + 0: meta.object-literal.key.ts + 1: entity.name.function.ts + - match: '(?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:)' + scope: meta.object.member.ts + captures: + 0: meta.object-literal.key.ts + - match: \.\.\. + captures: + 0: keyword.operator.spread.ts + push: + - meta_scope: meta.object.member.ts + - match: '(?=,|\})' + pop: true + - include: expression + - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$|\/\/|\/\*)' + scope: meta.object.member.ts + captures: + 1: variable.other.readwrite.ts + - match: '(?]|\|\||\&\&|\!\=\=|$|^|((?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))' + captures: + 1: storage.modifier.async.ts + push: + - match: (?<=\)) + pop: true + - include: type-parameters + - match: \( + captures: + 0: meta.brace.round.ts + push: + - match: \) + captures: + 0: meta.brace.round.ts + pop: true + - include: expression-inside-possibly-arrow-parens + - match: '(?<=:)\s*(async)?\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))' + captures: + 1: storage.modifier.async.ts + 2: meta.brace.round.ts + push: + - match: \) + captures: + 0: meta.brace.round.ts + pop: true + - include: expression-inside-possibly-arrow-parens + - match: (?<=:)\s*(async)?\s*(?=\<\s*$) + captures: + 1: storage.modifier.async.ts + push: + - match: (?<=\>) + pop: true + - include: type-parameters + - match: '(?<=\>)\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))' + captures: + 1: meta.brace.round.ts + push: + - match: \) + captures: + 0: meta.brace.round.ts + pop: true + - include: expression-inside-possibly-arrow-parens + - include: possibly-arrow-return-type + - include: expression + - include: punctuation-comma + parameter-array-binding-pattern: + - match: '(?:(\.\.\.)\s*)?(\[)' + captures: + 1: keyword.operator.rest.ts + 2: punctuation.definition.binding-pattern.array.ts + push: + - match: '\]' + captures: + 0: punctuation.definition.binding-pattern.array.ts + pop: true + - include: parameter-binding-element + - include: punctuation-comma + parameter-binding-element: + - include: comment + - include: string + - include: numeric-literal + - include: regex + - include: parameter-object-binding-pattern + - include: parameter-array-binding-pattern + - include: destructuring-parameter-rest + - include: variable-initializer + parameter-name: + - match: '(?) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) | + # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => + (:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) + )) | + (:\s*(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | + (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + captures: + 1: storage.modifier.ts + 2: keyword.operator.rest.ts + 3: entity.name.function.ts variable.language.this.ts + 4: entity.name.function.ts + 5: keyword.operator.optional.ts + - match: '(?x)(?:(?])" + pop: true + - include: type + paren-expression: + - match: \( + captures: + 0: meta.brace.round.ts + push: + - match: \) + captures: + 0: meta.brace.round.ts + pop: true + - include: expression + paren-expression-possibly-arrow: + - match: '(?<=[(=,])\s*(async)?(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))' + captures: + 1: storage.modifier.async.ts + push: + - match: (?<=\)) + pop: true + - include: paren-expression-possibly-arrow-with-typeparameters + - match: '(?<=[(=,]|=>|^return|[^\._$[:alnum:]]return)\s*(async)?(?=\s*((((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\()|(<))\s*$)' + captures: + 1: storage.modifier.async.ts + push: + - match: (?<=\)) + pop: true + - include: paren-expression-possibly-arrow-with-typeparameters + - include: possibly-arrow-return-type + paren-expression-possibly-arrow-with-typeparameters: + - include: type-parameters + - match: \( + captures: + 0: meta.brace.round.ts + push: + - match: \) + captures: + 0: meta.brace.round.ts + pop: true + - include: expression-inside-possibly-arrow-parens + possibly-arrow-return-type: + - match: '(?<=\)|^)\s*(:)(?=\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*=>)' + captures: + 1: meta.arrow.ts meta.return.type.arrow.ts keyword.operator.type.annotation.ts + push: + - meta_content_scope: meta.arrow.ts meta.return.type.arrow.ts + - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))' + pop: true + - include: arrow-return-type-body + property-accessor: + - match: '(?|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[\()]|\\.|\[([^\]\\]|\\.)+\]|\(([^\)\\]|\\.)+\))+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))' + captures: + 1: punctuation.definition.string.begin.ts + push: + - meta_scope: string.regexp.ts + - match: "(/)([dgimsuy]*)" + captures: + 1: punctuation.definition.string.end.ts + 2: keyword.other.ts + pop: true + - include: regexp + - match: '((?' + captures: + 0: keyword.other.back-reference.regexp + 1: variable.other.regexp + - match: '[?+*]|\{(\d+,\d+|\d+,|,\d+|\d+)\}\??' + scope: keyword.operator.quantifier.regexp + - match: \| + scope: keyword.operator.or.regexp + - match: (\()((\?=)|(\?!)|(\?<=)|(\?))?' + captures: + 0: punctuation.definition.group.regexp + 1: punctuation.definition.group.no-capture.regexp + 2: variable.other.regexp + push: + - meta_scope: meta.group.regexp + - match: \) + captures: + 0: punctuation.definition.group.regexp + pop: true + - include: regexp + - match: '(\[)(\^)?' + captures: + 1: punctuation.definition.character-class.regexp + 2: keyword.operator.negation.regexp + push: + - meta_scope: constant.other.character-class.set.regexp + - match: '(\])' + captures: + 1: punctuation.definition.character-class.regexp + pop: true + - match: '(?:.|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))\-(?:[^\]\\]|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))' + scope: constant.other.character-class.range.regexp + captures: + 1: constant.character.numeric.regexp + 2: constant.character.control.regexp + 3: constant.character.escape.backslash.regexp + 4: constant.character.numeric.regexp + 5: constant.character.control.regexp + 6: constant.character.escape.backslash.regexp + - include: regex-character-class + - include: regex-character-class + return-type: + - match: (?<=\))\s*(:)(?=\s*\S) + captures: + 1: keyword.operator.type.annotation.ts + push: + - meta_scope: meta.return.type.ts + - match: "(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\()) + | + (?:(EPSILON|MAX_SAFE_INTEGER|MAX_VALUE|MIN_SAFE_INTEGER|MIN_VALUE|NEGATIVE_INFINITY|POSITIVE_INFINITY)\b(?!\$))) + captures: + 1: punctuation.accessor.ts + 2: punctuation.accessor.optional.ts + 3: support.variable.property.ts + 4: support.constant.ts + - match: |- + (?x) (?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\() + captures: + 1: punctuation.accessor.ts + 2: punctuation.accessor.optional.ts + 3: support.constant.dom.ts + 4: support.variable.property.dom.ts + - match: |- + (?x)(?\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)?`)' + push: + - meta_scope: string.template.ts + - match: (?=`) + pop: true + - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*))' + push: + - match: '(?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)?`)' + pop: true + - include: support-function-call-identifiers + - match: "([_$[:alpha:]][_$[:alnum:]]*)" + scope: entity.name.function.tagged-template.ts + - include: type-arguments + - match: '([_$[:alpha:]][_$[:alnum:]]*)?\s*(?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)`)' + captures: + 1: entity.name.function.tagged-template.ts + push: + - meta_scope: string.template.ts + - match: (?=`) + pop: true + - include: type-arguments + template-substitution-element: + - match: '\$\{' + captures: + 0: punctuation.definition.template-expression.begin.ts + push: + - meta_scope: meta.template.expression.ts + - meta_content_scope: meta.embedded.line.ts + - match: '\}' + captures: + 0: punctuation.definition.template-expression.end.ts + pop: true + - include: expression + template-type: + - include: template-call + - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)" + captures: + 1: entity.name.function.tagged-template.ts + 2: punctuation.definition.string.template.begin.ts + push: + - meta_scope: string.template.ts + - match: "`" + captures: + 0: punctuation.definition.string.template.end.ts + pop: true + - include: template-type-substitution-element + - include: string-character-escape + template-type-substitution-element: + - match: '\$\{' + captures: + 0: punctuation.definition.template-expression.begin.ts + push: + - meta_scope: meta.template.expression.ts + - meta_content_scope: meta.embedded.line.ts + - match: '\}' + captures: + 0: punctuation.definition.template-expression.end.ts + pop: true + - include: type + ternary-expression: + - match: '(?!\?\.\s*[^[:digit:]])(\?)(?!\?)' + captures: + 1: keyword.operator.ternary.ts + push: + - match: \s*(:) + captures: + 1: keyword.operator.ternary.ts + pop: true + - include: expression + this-literal: + - match: '(?])|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))' + pop: true + - include: type + - match: (:) + captures: + 1: keyword.operator.type.annotation.ts + push: + - meta_scope: meta.type.annotation.ts + - match: '(?])|(?=^\s*$)|((?<=\S)(?=\s*$))|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))' + pop: true + - include: type + type-arguments: + - match: \< + captures: + 0: punctuation.definition.typeparameters.begin.ts + push: + - meta_scope: meta.type.parameters.ts + - match: \> + captures: + 0: punctuation.definition.typeparameters.end.ts + pop: true + - include: type-arguments-body + type-arguments-body: + - match: '(?) + pop: true + - include: comment + - include: type-parameters + - match: '(?) + )) + ) + ) + ) + push: + - meta_scope: meta.type.function.ts + - match: (?<=\)) + pop: true + - include: function-parameters + type-function-return-type: + - match: (=>)(?=\s*\S) + captures: + 1: storage.type.function.arrow.ts + push: + - meta_scope: meta.type.function.return.ts + - match: '(?)(?:\?]|//|$)' + pop: true + - include: type-function-return-type-core + - match: "=>" + captures: + 0: storage.type.function.arrow.ts + push: + - meta_scope: meta.type.function.return.ts + - match: '(?)(?]|//|^\s*$)|((?<=\S)(?=\s*$)))' + pop: true + - include: type-function-return-type-core + type-function-return-type-core: + - include: comment + - match: '(?<==>)(?=\s*\{)' + push: + - match: '(?<=\})' + pop: true + - include: type-object + - include: type-predicate-operator + - include: type + type-name: + - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(<)' + captures: + 1: entity.name.type.module.ts + 2: punctuation.accessor.ts + 3: punctuation.accessor.optional.ts + 4: meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + push: + - meta_content_scope: meta.type.parameters.ts + - match: (>) + captures: + 1: meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + pop: true + - include: type-arguments-body + - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(<)' + captures: + 1: entity.name.type.ts + 2: meta.type.parameters.ts punctuation.definition.typeparameters.begin.ts + push: + - meta_content_scope: meta.type.parameters.ts + - match: (>) + captures: + 1: meta.type.parameters.ts punctuation.definition.typeparameters.end.ts + pop: true + - include: type-arguments-body + - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))' + captures: + 1: entity.name.type.module.ts + 2: punctuation.accessor.ts + 3: punctuation.accessor.optional.ts + - match: "[_$[:alpha:]][_$[:alnum:]]*" + scope: entity.name.type.ts + type-object: + - match: '\{' + captures: + 0: punctuation.definition.block.ts + push: + - meta_scope: meta.object.type.ts + - match: '\}' + captures: + 0: punctuation.definition.block.ts + pop: true + - include: comment + - include: method-declaration + - include: indexer-declaration + - include: indexer-mapped-type-declaration + - include: field-declaration + - include: type-annotation + - match: \.\.\. + captures: + 0: keyword.operator.spread.ts + push: + - match: '(?=\}|;|,|$)|(?<=\})' + pop: true + - include: type + - include: punctuation-comma + - include: punctuation-semicolon + - include: type + type-operators: + - include: typeof-operator + - match: '([&|])(?=\s*\{)' + captures: + 0: keyword.operator.type.ts + push: + - match: '(?<=\})' + pop: true + - include: type-object + - match: "[&|]" + captures: + 0: keyword.operator.type.ts + push: + - match: (?=\S) + pop: true + - match: '(?) + captures: + 1: punctuation.definition.typeparameters.end.ts + pop: true + - include: comment + - match: '(?) + scope: keyword.operator.assignment.ts + type-paren-or-function-parameters: + - match: \( + captures: + 0: meta.brace.round.ts + push: + - meta_scope: meta.type.paren.cover.ts + - match: \) + captures: + 0: meta.brace.round.ts + pop: true + - match: |- + (?x)(?:(?) + )) + )) + )) | + (:\s*(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))))) + captures: + 1: storage.modifier.ts + 2: keyword.operator.rest.ts + 3: entity.name.function.ts variable.language.this.ts + 4: entity.name.function.ts + 5: keyword.operator.optional.ts + - match: '(?x)(?:(?:&|{\?]|$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))' + pop: true + - include: expression + undefined-literal: + - match: '(?) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) | + # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => + (:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) + )) | + (:\s*(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | + (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + captures: + 1: meta.definition.variable.ts variable.other.constant.ts entity.name.function.ts + push: + - meta_scope: meta.var-single-variable.expr.ts + - match: '(?=$|^|[;,=}]|((?) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) | + # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => + (:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) + )) | + (:\s*(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | + (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?[\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + captures: + 1: meta.definition.variable.ts entity.name.function.ts + 2: keyword.operator.definiteassignment.ts + push: + - meta_scope: meta.var-single-variable.expr.ts + - match: '(?=$|^|[;,=}]|((?\s*$) + captures: + 1: keyword.operator.assignment.ts + push: + - match: '(?=$|^|[,);}\]]|((?]|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^yield|[^\._$[:alnum:]]yield|^throw|[^\._$[:alnum:]]throw|^in|[^\._$[:alnum:]]in|^of|[^\._$[:alnum:]]of|^typeof|[^\._$[:alnum:]]typeof|&&|\|\||\*)\s*(\{)' + captures: + 1: punctuation.definition.block.tsx + push: + - meta_scope: meta.objectliteral.tsx + - match: '\}' + captures: + 0: punctuation.definition.block.tsx + pop: true + - include: object-member + array-binding-pattern: + - match: '(?:(\.\.\.)\s*)?(\[)' + captures: + 1: keyword.operator.rest.tsx + 2: punctuation.definition.binding-pattern.array.tsx + push: + - match: '\]' + captures: + 0: punctuation.definition.binding-pattern.array.tsx + pop: true + - include: binding-element + - include: punctuation-comma + array-binding-pattern-const: + - match: '(?:(\.\.\.)\s*)?(\[)' + captures: + 1: keyword.operator.rest.tsx + 2: punctuation.definition.binding-pattern.array.tsx + push: + - match: '\]' + captures: + 0: punctuation.definition.binding-pattern.array.tsx + pop: true + - include: binding-element-const + - include: punctuation-comma + array-literal: + - match: '\s*(\[)' + captures: + 1: meta.brace.square.tsx + push: + - meta_scope: meta.array.literal.tsx + - match: '\]' + captures: + 0: meta.brace.square.tsx + pop: true + - include: expression + - include: punctuation-comma + arrow-function: + - match: '(?:(?)' + scope: meta.arrow.tsx + captures: + 1: storage.modifier.async.tsx + 2: variable.parameter.tsx + - match: |- + (?x) (?: + (? is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + ) + ) + captures: + 1: storage.modifier.async.tsx + push: + - meta_scope: meta.arrow.tsx + - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))' + pop: true + - include: comment + - include: type-parameters + - include: function-parameters + - include: arrow-return-type + - include: possibly-arrow-return-type + - match: "=>" + captures: + 0: storage.type.function.arrow.tsx + push: + - meta_scope: meta.arrow.tsx + - match: '((?<=\}|\S)(?)|((?!\{)(?=\S)))(?!\/[\/\*])' + pop: true + - include: single-line-comment-consuming-line-ending + - include: decl-block + - include: expression + arrow-return-type: + - match: (?<=\))\s*(:) + captures: + 1: keyword.operator.type.annotation.tsx + push: + - meta_scope: meta.return.type.arrow.tsx + - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))' + pop: true + - include: arrow-return-type-body + arrow-return-type-body: + - match: '(?<=[:])(?=\s*\{)' + push: + - match: '(?<=\})' + pop: true + - include: type-object + - include: type-predicate-operator + - include: type + async-modifier: + - match: '(?\s*$)' + captures: + 1: punctuation.definition.comment.tsx + push: + - meta_scope: comment.line.triple-slash.directive.tsx + - match: (?=$) + pop: true + - match: (<)(reference|amd-dependency|amd-module) + captures: + 1: punctuation.definition.tag.directive.tsx + 2: entity.name.tag.directive.tsx + push: + - meta_scope: meta.tag.tsx + - match: /> + captures: + 0: punctuation.definition.tag.directive.tsx + pop: true + - match: path|types|no-default-lib|lib|name + scope: entity.other.attribute-name.directive.tsx + - match: "=" + scope: keyword.operator.assignment.tsx + - include: string + docblock: + - match: |- + (?x) + ((@)(?:access|api)) + \s+ + (private|protected|public) + \b + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: constant.language.access-type.jsdoc + - match: |- + (?x) + ((@)author) + \s+ + ( + [^@\s<>*/] + (?:[^@<>*/]|\*[^/])* + ) + (?: + \s* + (<) + ([^>\s]+) + (>) + )? + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: entity.name.type.instance.jsdoc + 4: punctuation.definition.bracket.angle.begin.jsdoc + 5: constant.other.email.link.underline.jsdoc + 6: punctuation.definition.bracket.angle.end.jsdoc + - match: |- + (?x) + ((@)borrows) \s+ + ((?:[^@\s*/]|\*[^/])+) # + \s+ (as) \s+ # as + ((?:[^@\s*/]|\*[^/])+) # + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: entity.name.type.instance.jsdoc + 4: keyword.operator.control.jsdoc + 5: entity.name.type.instance.jsdoc + - match: ((@)example)\s+ + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + push: + - meta_scope: meta.example.jsdoc + - match: (?=@|\*/) + pop: true + - match: ^\s\*\s+ + - match: \G(<)caption(>) + captures: + 0: entity.name.tag.inline.jsdoc + 1: punctuation.definition.bracket.angle.begin.jsdoc + 2: punctuation.definition.bracket.angle.end.jsdoc + push: + - meta_content_scope: constant.other.description.jsdoc + - match: ()|(?=\*/) + captures: + 0: entity.name.tag.inline.jsdoc + 1: punctuation.definition.bracket.angle.begin.jsdoc + 2: punctuation.definition.bracket.angle.end.jsdoc + pop: true + - match: '[^\s@*](?:[^*]|\*[^/])*' + captures: + 0: source.embedded.tsx + - match: (?x) ((@)kind) \s+ (class|constant|event|external|file|function|member|mixin|module|namespace|typedef) \b + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: constant.language.symbol-type.jsdoc + - match: |- + (?x) + ((@)see) + \s+ + (?: + # URL + ( + (?=https?://) + (?:[^\s*]|\*[^/])+ + ) + | + # JSDoc namepath + ( + (?! + # Avoid matching bare URIs (also acceptable as links) + https?:// + | + # Avoid matching {@inline tags}; we match those below + (?:\[[^\[\]]*\])? # Possible description [preceding]{@tag} + {@(?:link|linkcode|linkplain|tutorial)\b + ) + # Matched namepath + (?:[^@\s*/]|\*[^/])+ + ) + ) + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: variable.other.link.underline.jsdoc + 4: entity.name.type.instance.jsdoc + - match: |- + (?x) + ((@)template) + \s+ + # One or more valid identifiers + ( + [A-Za-z_$] # First character: non-numeric word character + [\w$.\[\]]* # Rest of identifier + (?: # Possible list of additional identifiers + \s* , \s* + [A-Za-z_$] + [\w$.\[\]]* + )* + ) + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: variable.other.jsdoc + - match: |- + (?x) + ( + (@) + (?:arg|argument|const|constant|member|namespace|param|var) + ) + \s+ + ( + [A-Za-z_$] + [\w$.\[\]]* + ) + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: variable.other.jsdoc + - match: '((@)typedef)\s+(?={)' + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + push: + - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])' + pop: true + - include: jsdoctype + - match: '(?:[^@\s*/]|\*[^/])+' + scope: entity.name.type.instance.jsdoc + - match: '((@)(?:arg|argument|const|constant|member|namespace|param|prop|property|var))\s+(?={)' + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + push: + - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])' + pop: true + - include: jsdoctype + - match: '([A-Za-z_$][\w$.\[\]]*)' + scope: variable.other.jsdoc + - match: |- + (?x) + (\[)\s* + [\w$]+ + (?: + (?:\[\])? # Foo[ ].bar properties within an array + \. # Foo.Bar namespaced parameter + [\w$]+ + )* + (?: + \s* + (=) # [foo=bar] Default parameter value + \s* + ( + # The inner regexes are to stop the match early at */ and to not stop at escaped quotes + (?> + "(?:(?:\*(?!/))|(?:\\(?!"))|[^*\\])*?" | # [foo="bar"] Double-quoted + '(?:(?:\*(?!/))|(?:\\(?!'))|[^*\\])*?' | # [foo='bar'] Single-quoted + \[ (?:(?:\*(?!/))|[^*])*? \] | # [foo=[1,2]] Array literal + (?:(?:\*(?!/))|\s(?!\s*\])|\[.*?(?:\]|(?=\*/))|[^*\s\[\]])* # Everything else + )* + ) + )? + \s*(?:(\])((?:[^*\s]|\*[^\s/])+)?|(?=\*/)) + scope: variable.other.jsdoc + captures: + 1: punctuation.definition.optional-value.begin.bracket.square.jsdoc + 2: keyword.operator.assignment.jsdoc + 3: source.embedded.tsx + 4: punctuation.definition.optional-value.end.bracket.square.jsdoc + 5: invalid.illegal.syntax.jsdoc + - match: |- + (?x) + ( + (@) + (?:define|enum|exception|export|extends|lends|implements|modifies + |namespace|private|protected|returns?|suppress|this|throws|type + |yields?) + ) + \s+(?={) + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + push: + - match: '(?=\s|\*/|[^{}\[\]A-Za-z_$])' + pop: true + - include: jsdoctype + - match: |- + (?x) + ( + (@) + (?:alias|augments|callback|constructs|emits|event|fires|exports? + |extends|external|function|func|host|lends|listens|interface|memberof!? + |method|module|mixes|mixin|name|requires|see|this|typedef|uses) + ) + \s+ + ( + (?: + [^{}@\s*] | \*[^/] + )+ + ) + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: entity.name.type.instance.jsdoc + - match: '((@)(?:default(?:value)?|license|version))\s+(([''''"]))' + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: variable.other.jsdoc + 4: punctuation.definition.string.begin.jsdoc + push: + - meta_content_scope: variable.other.jsdoc + - match: (\3)|(?=$|\*/) + captures: + 0: variable.other.jsdoc + 1: punctuation.definition.string.end.jsdoc + pop: true + - match: '((@)(?:default(?:value)?|license|tutorial|variation|version))\s+([^\s*]+)' + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + 3: variable.other.jsdoc + - match: '(?x) (@) (?:abstract|access|alias|api|arg|argument|async|attribute|augments|author|beta|borrows|bubbles |callback|chainable|class|classdesc|code|config|const|constant|constructor|constructs|copyright |default|defaultvalue|define|deprecated|desc|description|dict|emits|enum|event|example|exception |exports?|extends|extension(?:_?for)?|external|externs|file|fileoverview|final|fires|for|func |function|generator|global|hideconstructor|host|ignore|implements|implicitCast|inherit[Dd]oc |inner|instance|interface|internal|kind|lends|license|listens|main|member|memberof!?|method |mixes|mixins?|modifies|module|name|namespace|noalias|nocollapse|nocompile|nosideeffects |override|overview|package|param|polymer(?:Behavior)?|preserve|private|prop|property|protected |public|read[Oo]nly|record|require[ds]|returns?|see|since|static|struct|submodule|summary |suppress|template|this|throws|todo|tutorial|type|typedef|unrestricted|uses|var|variation |version|virtual|writeOnce|yields?) \b' + scope: storage.type.class.jsdoc + captures: + 1: punctuation.definition.block.tag.jsdoc + - include: inline-tags + - match: '((@)(?:[_$[:alpha:]][_$[:alnum:]]*))(?=\s+)' + captures: + 1: storage.type.class.jsdoc + 2: punctuation.definition.block.tag.jsdoc + enum-declaration: + - match: '(?) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) | + # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => + (:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) + )) | + (:\s*(?\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | + (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + captures: + 1: storage.modifier.tsx + 2: keyword.operator.rest.tsx + 3: entity.name.function.tsx variable.language.this.tsx + 4: entity.name.function.tsx + 5: keyword.operator.optional.tsx + - match: '(?x)(?:(?]|\|\||\&\&|\!\=\=|$|((?>=|>>>=|\|= + scope: keyword.operator.assignment.compound.bitwise.tsx + - match: "<<|>>>|>>" + scope: keyword.operator.bitwise.shift.tsx + - match: "===|!==|==|!=" + scope: keyword.operator.comparison.tsx + - match: <=|>=|<>|<|> + scope: keyword.operator.relational.tsx + - match: '(?<=[_$[:alnum:]])(\!)\s*(?:(/=)|(?:(/)(?![/*])))' + captures: + 1: keyword.operator.logical.tsx + 2: keyword.operator.assignment.compound.tsx + 3: keyword.operator.arithmetic.tsx + - match: \!|&&|\|\||\?\? + scope: keyword.operator.logical.tsx + - match: \&|~|\^|\| + scope: keyword.operator.bitwise.tsx + - match: \= + scope: keyword.operator.assignment.tsx + - match: "--" + scope: keyword.operator.decrement.tsx + - match: \+\+ + scope: keyword.operator.increment.tsx + - match: '%|\*|/|-|\+' + scope: keyword.operator.arithmetic.tsx + - match: '(?<=[_$[:alnum:])\]])\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)+(?:(/=)|(?:(/)(?![/*]))))' + push: + - match: '(?:(/=)|(?:(/)(?!\*([^\*]|(\*[^\/]))*\*\/)))' + captures: + 1: keyword.operator.assignment.compound.tsx + 2: keyword.operator.arithmetic.tsx + pop: true + - include: comment + - match: '(?<=[_$[:alnum:])\]])\s*(?:(/=)|(?:(/)(?![/*])))' + captures: + 1: keyword.operator.assignment.compound.tsx + 2: keyword.operator.arithmetic.tsx + expressionPunctuations: + - include: punctuation-comma + - include: punctuation-accessor + expressionWithoutIdentifiers: + - include: jsx + - include: string + - include: regex + - include: comment + - include: function-expression + - include: class-expression + - include: arrow-function + - include: paren-expression-possibly-arrow + - include: cast + - include: ternary-expression + - include: new-expr + - include: instanceof-expr + - include: object-literal + - include: expression-operators + - include: function-call + - include: literal + - include: support-objects + - include: paren-expression + field-declaration: + - match: |- + (?x)(?) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) | + # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => + (:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) + )) | + (:\s*(?\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | + (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + captures: + 1: meta.definition.property.tsx entity.name.function.tsx + 2: keyword.operator.optional.tsx + 3: keyword.operator.definiteassignment.tsx + - match: '\#?[_$[:alpha:]][_$[:alnum:]]*' + scope: meta.definition.property.tsx variable.object.property.tsx + - match: \? + scope: keyword.operator.optional.tsx + - match: \! + scope: keyword.operator.definiteassignment.tsx + for-loop: + - match: '(?\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)?\())' + push: + - match: '(?<=\))(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)?\())' + pop: true + - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))' + push: + - meta_scope: meta.function-call.tsx + - match: '(?=\s*(?:(\?\.\s*)|(\!))?((<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)?\())' + pop: true + - include: function-call-target + - include: comment + - include: function-call-optionals + - include: type-arguments + - include: paren-expression + - match: '(?=(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$))' + push: + - match: '(?<=\>)(?!(((([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))|(?<=[\)]))(<\s*[\{\[\(]\s*$))' + pop: true + - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*)(\s*\??\.\s*(\#?[_$[:alpha:]][_$[:alnum:]]*))*)|(\??\.\s*\#?[_$[:alpha:]][_$[:alnum:]]*))' + push: + - meta_scope: meta.function-call.tsx + - match: '(?=(<\s*[\{\[\(]\s*$))' + pop: true + - include: function-call-target + - include: comment + - include: function-call-optionals + - include: type-arguments + function-call-optionals: + - match: \?\. + scope: meta.function-call.tsx punctuation.accessor.optional.tsx + - match: \! + scope: meta.function-call.tsx keyword.operator.definiteassignment.tsx + function-call-target: + - include: support-function-call-identifiers + - match: '(\#?[_$[:alpha:]][_$[:alnum:]]*)' + scope: entity.name.function.tsx + function-declaration: + - match: '(?) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) + captures: + 1: punctuation.accessor.tsx + 2: punctuation.accessor.optional.tsx + 3: entity.name.function.tsx + - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])' + captures: + 1: punctuation.accessor.tsx + 2: punctuation.accessor.optional.tsx + 3: variable.other.constant.property.tsx + - match: '(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(\#?[_$[:alpha:]][_$[:alnum:]]*)' + captures: + 1: punctuation.accessor.tsx + 2: punctuation.accessor.optional.tsx + 3: variable.other.property.tsx + - match: "([[:upper:]][_$[:digit:][:upper:]]*)(?![_$[:alnum:]])" + scope: variable.other.constant.tsx + - match: "[_$[:alpha:]][_$[:alnum:]]*" + scope: variable.other.readwrite.tsx + if-statement: + - match: '(?]|\|\||\&\&|\!\=\=|$|(([\&\~\^\|]\s*)?[_$[:alpha:]][_$[:alnum:]]*\s+instanceof(?![_$[:alnum:]])(?:(?=\.\.\.)|(?!\.)))|((?))' + push: + - meta_scope: meta.tag.tsx + - match: '(/>)|(?:())' + captures: + 1: punctuation.definition.tag.end.tsx + 2: punctuation.definition.tag.begin.tsx + 3: entity.name.tag.namespace.tsx + 4: punctuation.separator.namespace.tsx + 5: entity.name.tag.tsx + 6: support.class.component.tsx + 7: punctuation.definition.tag.end.tsx + pop: true + - match: '(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?)' + captures: + 1: punctuation.definition.tag.begin.tsx + 2: entity.name.tag.namespace.tsx + 3: punctuation.separator.namespace.tsx + 4: entity.name.tag.tsx + 5: support.class.component.tsx + push: + - match: "(?=[/]?>)" + pop: true + - include: comment + - include: type-arguments + - include: jsx-tag-attributes + - match: (>) + captures: + 1: punctuation.definition.tag.end.tsx + push: + - meta_content_scope: meta.jsx.children.tsx + - match: (?=|/\*|//) + captures: + 1: entity.other.attribute-name.namespace.tsx + 2: punctuation.separator.namespace.tsx + 3: entity.other.attribute-name.tsx + jsx-tag-attributes: + - match: \s+ + push: + - meta_scope: meta.tag.attributes.tsx + - match: "(?=[/]?>)" + pop: true + - include: comment + - include: jsx-tag-attribute-name + - include: jsx-tag-attribute-assignment + - include: jsx-string-double-quoted + - include: jsx-string-single-quoted + - include: jsx-evaluated-code + - include: jsx-tag-attributes-illegal + jsx-tag-attributes-illegal: + - match: \S+ + scope: invalid.illegal.attribute.tsx + jsx-tag-in-expression: + - match: |- + (?x) + (?:*]|&&|\|\||\?|\*\/|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^default|[^\._$[:alnum:]]default|^yield|[^\._$[:alnum:]]yield|^)\s* + (?!<\s*[_$[:alpha:]][_$[:alnum:]]*((\s+extends\s+[^=>])|,)) # look ahead is not type parameter of arrow + (?=(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?)) + push: + - match: '(?!(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?))' + pop: true + - include: jsx-tag + jsx-tag-without-attributes: + - match: '(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?)' + captures: + 1: punctuation.definition.tag.begin.tsx + 2: entity.name.tag.namespace.tsx + 3: punctuation.separator.namespace.tsx + 4: entity.name.tag.tsx + 5: support.class.component.tsx + 6: punctuation.definition.tag.end.tsx + push: + - meta_scope: meta.tag.without-attributes.tsx + - meta_content_scope: meta.jsx.children.tsx + - match: '()' + captures: + 1: punctuation.definition.tag.begin.tsx + 2: entity.name.tag.namespace.tsx + 3: punctuation.separator.namespace.tsx + 4: entity.name.tag.tsx + 5: support.class.component.tsx + 6: punctuation.definition.tag.end.tsx + pop: true + - include: jsx-children + jsx-tag-without-attributes-in-expression: + - match: '(?:*]|&&|\|\||\?|\*\/|^await|[^\._$[:alnum:]]await|^return|[^\._$[:alnum:]]return|^default|[^\._$[:alnum:]]default|^yield|[^\._$[:alnum:]]yield|^)\s*(?=(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?))' + push: + - match: '(?!(<)\s*(?:([_$[:alpha:]][-_$[:alnum:].]*)(?))' + pop: true + - include: jsx-tag-without-attributes + label: + - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(:)(?=\s*\{)' + captures: + 1: entity.name.label.tsx + 2: punctuation.separator.label.tsx + push: + - match: '(?<=\})' + pop: true + - include: decl-block + - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(:)' + captures: + 1: entity.name.label.tsx + 2: punctuation.separator.label.tsx + literal: + - include: numeric-literal + - include: boolean-literal + - include: null-literal + - include: undefined-literal + - include: numericConstant-literal + - include: array-literal + - include: this-literal + - include: super-literal + method-declaration: + - match: '(?x)(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(])' + captures: + 1: storage.modifier.tsx + 2: storage.modifier.tsx + 3: storage.modifier.tsx + 4: storage.modifier.async.tsx + 5: keyword.operator.new.tsx + 6: keyword.generator.asterisk.tsx + push: + - meta_scope: meta.method.declaration.tsx + - match: '(?=\}|;|,|$)|(?<=\})' + pop: true + - include: method-declaration-name + - include: function-body + - match: |- + (?x)(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + captures: + 1: storage.modifier.tsx + 2: storage.modifier.tsx + 3: storage.modifier.tsx + 4: storage.modifier.async.tsx + 5: storage.type.property.tsx + 6: keyword.generator.asterisk.tsx + push: + - meta_scope: meta.method.declaration.tsx + - match: '(?=\}|;|,|$)|(?<=\})' + pop: true + - include: method-declaration-name + - include: function-body + method-declaration-name: + - match: |- + (?x)(?=((\b(?]|\|\||\&\&|\!\=\=|$|((?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + captures: + 1: storage.modifier.async.tsx + 2: storage.type.property.tsx + 3: keyword.generator.asterisk.tsx + push: + - meta_scope: meta.method.declaration.tsx + - match: '(?=\}|;|,)|(?<=\})' + pop: true + - include: method-declaration-name + - include: function-body + - match: |- + (?x)(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?[\(]) + captures: + 1: storage.modifier.async.tsx + 2: storage.type.property.tsx + 3: keyword.generator.asterisk.tsx + push: + - match: (?=\(|\<) + pop: true + - include: method-declaration-name + object-member: + - include: comment + - include: object-literal-method-declaration + - match: '(?=\[)' + push: + - meta_scope: meta.object.member.tsx meta.object-literal.key.tsx + - match: '(?=:)|((?<=[\]])(?=\s*[\(\<]))' + pop: true + - include: comment + - include: array-literal + - match: '(?=[\''\"\`])' + push: + - meta_scope: meta.object.member.tsx meta.object-literal.key.tsx + - match: '(?=:)|((?<=[\''\"\`])(?=((\s*[\(\<,}])|(\s+(as)\s+))))' + pop: true + - include: comment + - include: string + - match: |- + (?x)(?=(\b(?) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + scope: meta.object.member.tsx + captures: + 0: meta.object-literal.key.tsx + 1: entity.name.function.tsx + - match: '(?:[_$[:alpha:]][_$[:alnum:]]*)\s*(?=(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*:)' + scope: meta.object.member.tsx + captures: + 0: meta.object-literal.key.tsx + - match: \.\.\. + captures: + 0: keyword.operator.spread.tsx + push: + - meta_scope: meta.object.member.tsx + - match: '(?=,|\})' + pop: true + - include: expression + - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?=,|\}|$|\/\/|\/\*)' + scope: meta.object.member.tsx + captures: + 1: variable.other.readwrite.tsx + - match: '(?]|\|\||\&\&|\!\=\=|$|^|((?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))' + captures: + 1: storage.modifier.async.tsx + push: + - match: (?<=\)) + pop: true + - include: type-parameters + - match: \( + captures: + 0: meta.brace.round.tsx + push: + - match: \) + captures: + 0: meta.brace.round.tsx + pop: true + - include: expression-inside-possibly-arrow-parens + - match: '(?<=:)\s*(async)?\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))' + captures: + 1: storage.modifier.async.tsx + 2: meta.brace.round.tsx + push: + - match: \) + captures: + 0: meta.brace.round.tsx + pop: true + - include: expression-inside-possibly-arrow-parens + - match: (?<=:)\s*(async)?\s*(?=\<\s*$) + captures: + 1: storage.modifier.async.tsx + push: + - match: (?<=\>) + pop: true + - include: type-parameters + - match: '(?<=\>)\s*(\()(?=\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))' + captures: + 1: meta.brace.round.tsx + push: + - match: \) + captures: + 0: meta.brace.round.tsx + pop: true + - include: expression-inside-possibly-arrow-parens + - include: possibly-arrow-return-type + - include: expression + - include: punctuation-comma + parameter-array-binding-pattern: + - match: '(?:(\.\.\.)\s*)?(\[)' + captures: + 1: keyword.operator.rest.tsx + 2: punctuation.definition.binding-pattern.array.tsx + push: + - match: '\]' + captures: + 0: punctuation.definition.binding-pattern.array.tsx + pop: true + - include: parameter-binding-element + - include: punctuation-comma + parameter-binding-element: + - include: comment + - include: string + - include: numeric-literal + - include: regex + - include: parameter-object-binding-pattern + - include: parameter-array-binding-pattern + - include: destructuring-parameter-rest + - include: variable-initializer + parameter-name: + - match: '(?) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) | + # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => + (:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) + )) | + (:\s*(?\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | + (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + captures: + 1: storage.modifier.tsx + 2: keyword.operator.rest.tsx + 3: entity.name.function.tsx variable.language.this.tsx + 4: entity.name.function.tsx + 5: keyword.operator.optional.tsx + - match: '(?x)(?:(?])" + pop: true + - include: type + paren-expression: + - match: \( + captures: + 0: meta.brace.round.tsx + push: + - match: \) + captures: + 0: meta.brace.round.tsx + pop: true + - include: expression + paren-expression-possibly-arrow: + - match: '(?<=[(=,])\s*(async)?(?=\s*((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\(\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))' + captures: + 1: storage.modifier.async.tsx + push: + - match: (?<=\)) + pop: true + - include: paren-expression-possibly-arrow-with-typeparameters + - match: '(?<=[(=,]|=>|^return|[^\._$[:alnum:]]return)\s*(async)?(?=\s*((((<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*))?\()|(<))\s*$)' + captures: + 1: storage.modifier.async.tsx + push: + - match: (?<=\)) + pop: true + - include: paren-expression-possibly-arrow-with-typeparameters + - include: possibly-arrow-return-type + paren-expression-possibly-arrow-with-typeparameters: + - include: type-parameters + - match: \( + captures: + 0: meta.brace.round.tsx + push: + - match: \) + captures: + 0: meta.brace.round.tsx + pop: true + - include: expression-inside-possibly-arrow-parens + possibly-arrow-return-type: + - match: '(?<=\)|^)\s*(:)(?=\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*=>)' + captures: + 1: meta.arrow.tsx meta.return.type.arrow.tsx keyword.operator.type.annotation.tsx + push: + - meta_content_scope: meta.arrow.tsx meta.return.type.arrow.tsx + - match: '(?==>|\{|(^\s*(export|function|class|interface|let|var|const|import|enum|namespace|module|type|abstract|declare)\s+))' + pop: true + - include: arrow-return-type-body + property-accessor: + - match: '(?|&&|\|\||\*\/)\s*(\/)(?![\/*])(?=(?:[^\/\\\[\()]|\\.|\[([^\]\\]|\\.)+\]|\(([^\)\\]|\\.)+\))+\/([dgimsuy]+|(?![\/\*])|(?=\/\*))(?!\s*[a-zA-Z0-9_$]))' + captures: + 1: punctuation.definition.string.begin.tsx + push: + - meta_scope: string.regexp.tsx + - match: "(/)([dgimsuy]*)" + captures: + 1: punctuation.definition.string.end.tsx + 2: keyword.other.tsx + pop: true + - include: regexp + - match: '((?' + captures: + 0: keyword.other.back-reference.regexp + 1: variable.other.regexp + - match: '[?+*]|\{(\d+,\d+|\d+,|,\d+|\d+)\}\??' + scope: keyword.operator.quantifier.regexp + - match: \| + scope: keyword.operator.or.regexp + - match: (\()((\?=)|(\?!)|(\?<=)|(\?))?' + captures: + 0: punctuation.definition.group.regexp + 1: punctuation.definition.group.no-capture.regexp + 2: variable.other.regexp + push: + - meta_scope: meta.group.regexp + - match: \) + captures: + 0: punctuation.definition.group.regexp + pop: true + - include: regexp + - match: '(\[)(\^)?' + captures: + 1: punctuation.definition.character-class.regexp + 2: keyword.operator.negation.regexp + push: + - meta_scope: constant.other.character-class.set.regexp + - match: '(\])' + captures: + 1: punctuation.definition.character-class.regexp + pop: true + - match: '(?:.|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))\-(?:[^\]\\]|(\\(?:[0-7]{3}|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}))|(\\c[A-Z])|(\\.))' + scope: constant.other.character-class.range.regexp + captures: + 1: constant.character.numeric.regexp + 2: constant.character.control.regexp + 3: constant.character.escape.backslash.regexp + 4: constant.character.numeric.regexp + 5: constant.character.control.regexp + 6: constant.character.escape.backslash.regexp + - include: regex-character-class + - include: regex-character-class + return-type: + - match: (?<=\))\s*(:)(?=\s*\S) + captures: + 1: keyword.operator.type.annotation.tsx + push: + - meta_scope: meta.return.type.tsx + - match: "(?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\()) + | + (?:(EPSILON|MAX_SAFE_INTEGER|MAX_VALUE|MIN_SAFE_INTEGER|MIN_VALUE|NEGATIVE_INFINITY|POSITIVE_INFINITY)\b(?!\$))) + captures: + 1: punctuation.accessor.tsx + 2: punctuation.accessor.optional.tsx + 3: support.variable.property.tsx + 4: support.constant.tsx + - match: |- + (?x) (?]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)?\() + captures: + 1: punctuation.accessor.tsx + 2: punctuation.accessor.optional.tsx + 3: support.constant.dom.tsx + 4: support.variable.property.dom.tsx + - match: |- + (?x)(?\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)?`)' + push: + - meta_scope: string.template.tsx + - match: (?=`) + pop: true + - match: '(?=(([_$[:alpha:]][_$[:alnum:]]*\s*\??\.\s*)*|(\??\.\s*)?)([_$[:alpha:]][_$[:alnum:]]*))' + push: + - match: '(?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)?`)' + pop: true + - include: support-function-call-identifiers + - match: "([_$[:alpha:]][_$[:alnum:]]*)" + scope: entity.name.function.tagged-template.tsx + - include: type-arguments + - match: '([_$[:alpha:]][_$[:alnum:]]*)?\s*(?=(<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))(([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>|\<\s*(((keyof|infer|typeof|readonly)\s+)|(([_$[:alpha:]][_$[:alnum:]]*|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\''([^\''\\]|\\.)*\'')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))(?=\s*([\<\>\,\.\[]|=>|&(?!&)|\|(?!\|)))))([^<>\(]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(?<==)\>)*(?))*(?)*(?\s*)`)' + captures: + 1: entity.name.function.tagged-template.tsx + push: + - meta_scope: string.template.tsx + - match: (?=`) + pop: true + - include: type-arguments + template-substitution-element: + - match: '\$\{' + captures: + 0: punctuation.definition.template-expression.begin.tsx + push: + - meta_scope: meta.template.expression.tsx + - meta_content_scope: meta.embedded.line.tsx + - match: '\}' + captures: + 0: punctuation.definition.template-expression.end.tsx + pop: true + - include: expression + template-type: + - include: template-call + - match: "([_$[:alpha:]][_$[:alnum:]]*)?(`)" + captures: + 1: entity.name.function.tagged-template.tsx + 2: punctuation.definition.string.template.begin.tsx + push: + - meta_scope: string.template.tsx + - match: "`" + captures: + 0: punctuation.definition.string.template.end.tsx + pop: true + - include: template-type-substitution-element + - include: string-character-escape + template-type-substitution-element: + - match: '\$\{' + captures: + 0: punctuation.definition.template-expression.begin.tsx + push: + - meta_scope: meta.template.expression.tsx + - meta_content_scope: meta.embedded.line.tsx + - match: '\}' + captures: + 0: punctuation.definition.template-expression.end.tsx + pop: true + - include: type + ternary-expression: + - match: '(?!\?\.\s*[^[:digit:]])(\?)(?!\?)' + captures: + 1: keyword.operator.ternary.tsx + push: + - match: \s*(:) + captures: + 1: keyword.operator.ternary.tsx + pop: true + - include: expression + this-literal: + - match: '(?])|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))' + pop: true + - include: type + - match: (:) + captures: + 1: keyword.operator.type.annotation.tsx + push: + - meta_scope: meta.type.annotation.tsx + - match: '(?])|(?=^\s*$)|((?<=\S)(?=\s*$))|((?<=[\}>\]\)]|[_$[:alpha:]])\s*(?=\{)))' + pop: true + - include: type + type-arguments: + - match: \< + captures: + 0: punctuation.definition.typeparameters.begin.tsx + push: + - meta_scope: meta.type.parameters.tsx + - match: \> + captures: + 0: punctuation.definition.typeparameters.end.tsx + pop: true + - include: type-arguments-body + type-arguments-body: + - match: '(?) + pop: true + - include: comment + - include: type-parameters + - match: '(?) + )) + ) + ) + ) + push: + - meta_scope: meta.type.function.tsx + - match: (?<=\)) + pop: true + - include: function-parameters + type-function-return-type: + - match: (=>)(?=\s*\S) + captures: + 1: storage.type.function.arrow.tsx + push: + - meta_scope: meta.type.function.return.tsx + - match: '(?)(?:\?]|//|$)' + pop: true + - include: type-function-return-type-core + - match: "=>" + captures: + 0: storage.type.function.arrow.tsx + push: + - meta_scope: meta.type.function.return.tsx + - match: '(?)(?]|//|^\s*$)|((?<=\S)(?=\s*$)))' + pop: true + - include: type-function-return-type-core + type-function-return-type-core: + - include: comment + - match: '(?<==>)(?=\s*\{)' + push: + - match: '(?<=\})' + pop: true + - include: type-object + - include: type-predicate-operator + - include: type + type-name: + - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))\s*(<)' + captures: + 1: entity.name.type.module.tsx + 2: punctuation.accessor.tsx + 3: punctuation.accessor.optional.tsx + 4: meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + push: + - meta_content_scope: meta.type.parameters.tsx + - match: (>) + captures: + 1: meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + pop: true + - include: type-arguments-body + - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(<)' + captures: + 1: entity.name.type.tsx + 2: meta.type.parameters.tsx punctuation.definition.typeparameters.begin.tsx + push: + - meta_content_scope: meta.type.parameters.tsx + - match: (>) + captures: + 1: meta.type.parameters.tsx punctuation.definition.typeparameters.end.tsx + pop: true + - include: type-arguments-body + - match: '([_$[:alpha:]][_$[:alnum:]]*)\s*(?:(\.)|(\?\.(?!\s*[[:digit:]])))' + captures: + 1: entity.name.type.module.tsx + 2: punctuation.accessor.tsx + 3: punctuation.accessor.optional.tsx + - match: "[_$[:alpha:]][_$[:alnum:]]*" + scope: entity.name.type.tsx + type-object: + - match: '\{' + captures: + 0: punctuation.definition.block.tsx + push: + - meta_scope: meta.object.type.tsx + - match: '\}' + captures: + 0: punctuation.definition.block.tsx + pop: true + - include: comment + - include: method-declaration + - include: indexer-declaration + - include: indexer-mapped-type-declaration + - include: field-declaration + - include: type-annotation + - match: \.\.\. + captures: + 0: keyword.operator.spread.tsx + push: + - match: '(?=\}|;|,|$)|(?<=\})' + pop: true + - include: type + - include: punctuation-comma + - include: punctuation-semicolon + - include: type + type-operators: + - include: typeof-operator + - match: '([&|])(?=\s*\{)' + captures: + 0: keyword.operator.type.tsx + push: + - match: '(?<=\})' + pop: true + - include: type-object + - match: "[&|]" + captures: + 0: keyword.operator.type.tsx + push: + - match: (?=\S) + pop: true + - match: '(?) + captures: + 1: punctuation.definition.typeparameters.end.tsx + pop: true + - include: comment + - match: '(?) + scope: keyword.operator.assignment.tsx + type-paren-or-function-parameters: + - match: \( + captures: + 0: meta.brace.round.tsx + push: + - meta_scope: meta.type.paren.cover.tsx + - match: \) + captures: + 0: meta.brace.round.tsx + pop: true + - match: |- + (?x)(?:(?) + )) + )) + )) | + (:\s*(?\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))))) + captures: + 1: storage.modifier.tsx + 2: keyword.operator.rest.tsx + 3: entity.name.function.tsx variable.language.this.tsx + 4: entity.name.function.tsx + 5: keyword.operator.optional.tsx + - match: '(?x)(?:(?:&|{\?]|$|;|^\s*$|(?:^\s*(?:abstract|async|class|const|declare|enum|export|function|import|interface|let|module|namespace|return|type|var)\b))' + pop: true + - include: expression + undefined-literal: + - match: '(?) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) | + # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => + (:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) + )) | + (:\s*(?\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | + (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + captures: + 1: meta.definition.variable.tsx variable.other.constant.tsx entity.name.function.tsx + push: + - meta_scope: meta.var-single-variable.expr.tsx + - match: '(?=$|^|[;,=}]|((?) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + )) | + # typeannotation is fn type: < | () | (... | (param: | (param, | (param? | (param= | (param) => + (:\s*( + (<) | + ([(]\s*( + ([)]) | + (\.\.\.) | + ([_$[:alnum:]]+\s*( + ([:,?=])| + ([)]\s*=>) + )) + )) + )) | + (:\s*(?\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*))))))) | + (:\s*(=>|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(<[^<>]*>)|[^<>(),=])+=\s*( + ((async\s+)?( + (function\s*[(<*]) | + (function\s+) | + ([_$[:alpha:]][_$[:alnum:]]*\s*=>) + )) | + ((async\s*)?( + ((<\s*$)|([\(]\s*((([\{\[]\s*)?$)|((\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})\s*((:\s*\{?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))|((\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])\s*((:\s*\[?$)|((\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+\s*)?=\s*)))))) | + # sure shot arrow functions even if => is on new line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? + [(]\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)* + ( + ([)]\s*:) | # (): + ((\.\.\.\s*)?[_$[:alpha:]][_$[:alnum:]]*\s*:) # [(]param: | [(]...param: + ) + ) | + ( + [<]\s*[_$[:alpha:]][_$[:alnum:]]*\s+extends\s*[^=>] # < typeparam extends + ) | + # arrow function possible to detect only with => on same line + ( + (<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<]|\<\s*([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\]))([^=<>]|=[^<])*\>)*\>)*>\s*)? # typeparameters + \(\s*(\/\*([^\*]|(\*[^\/]))*\*\/\s*)*(([_$[:alpha:]]|(\{([^\{\}]|(\{([^\{\}]|\{[^\{\}]*\})*\}))*\})|(\[([^\[\]]|(\[([^\[\]]|\[[^\[\]]*\])*\]))*\])|(\.\.\.\s*[_$[:alpha:]]))([^()\'\"\`]|(\(([^\(\)]|(\(([^\(\)]|\([^\(\)]*\))*\)))*\))|(\'([^\'\\]|\\.)*\')|(\"([^\"\\]|\\.)*\")|(\`([^\`\\]|\\.)*\`))*)?\) # parameters + (\s*:\s*([^<>\(\)\{\}]|\<([^<>]|\<([^<>]|\<[^<>]+\>)+\>)+\>|\([^\(\)]+\)|\{[^\{\}]+\})+)? # return type + \s*=> # arrow operator + ) + )) + ))) + captures: + 1: meta.definition.variable.tsx entity.name.function.tsx + 2: keyword.operator.definiteassignment.tsx + push: + - meta_scope: meta.var-single-variable.expr.tsx + - match: '(?=$|^|[;,=}]|((?\s*$) + captures: + 1: keyword.operator.assignment.tsx + push: + - match: '(?=$|^|[,);}\]]|((?) { } pub type Promise = AsyncTask>; +/// Like [`Blocking`], but the work closure fails with a typed domain error +/// that a reject hook converts on the JS thread. +/// +/// The hook runs with `Env` access, so rejections can carry a real error +/// object (name/code/custom properties) instead of a bare message string. +pub struct BlockingMapped +where + T: Send + 'static, + E: Send + 'static, +{ + tag: &'static str, + cancel_token: CancelToken, + work: Option>, + /// Domain error stashed by `compute` for `reject` to convert with `Env`. + error: Option, + reject_hook: fn(Env, E) -> Error, +} +/// Boxed work closure for [`BlockingMapped`]. +type MappedWork = Box std::result::Result + Send>; + +impl Task for BlockingMapped +where + T: ToNapiValue + Send + 'static + TypeName, + E: Send + 'static, +{ + type JsValue = T; + type Output = T; + + fn compute(&mut self) -> Result { + let _guard = profile_region(self.tag); + let work = self + .work + .take() + .ok_or_else(|| Error::from_reason("BlockingMapped: work already consumed"))?; + let cancel_token = self.cancel_token.clone(); + let tag = self.tag; + // Same FFI-boundary panic guard as [`Blocking::compute`]; see its + // comment for why the unwind must be caught here. + match catch_unwind(AssertUnwindSafe(move || { + crate::crash_handler::blocking_task_panic_scope(move || work(cancel_token)) + })) { + Ok(Ok(value)) => Ok(value), + Ok(Err(domain)) => { + // Stash the typed error; the placeholder reason is replaced in + // `reject`, which has the `Env` needed to build the rich error. + self.error = Some(domain); + Err(Error::from_reason("BlockingMapped: pending domain error")) + }, + Err(payload) => { + let message = crate::crash_handler::panic_payload(&*payload); + dispose_panic_payload(payload); + Err(Error::new( + Status::GenericFailure, + format!("native task `{tag}` panicked: {message}"), + )) + }, + } + } + + fn reject(&mut self, env: Env, err: Error) -> Result { + match self.error.take() { + Some(domain) => Err((self.reject_hook)(env, domain)), + None => Err(err), + } + } + + fn resolve(&mut self, _env: Env, output: Self::Output) -> Result { + Ok(output) + } +} + +/// Promise type produced by [`blocking_mapped`]. +pub type MappedPromise = AsyncTask>; + +/// Like [`blocking`], but the closure fails with a typed domain error and +/// `reject_hook` converts it into the JS error on the JS thread (with `Env`), +/// allowing rejections to carry structured properties. +pub fn blocking_mapped( + tag: &'static str, + cancel_token: impl Into, + reject_hook: fn(Env, E) -> Error, + work: F, +) -> MappedPromise +where + F: FnOnce(CancelToken) -> std::result::Result + Send + 'static, + T: ToNapiValue + TypeName + Send + 'static, + E: Send + 'static, +{ + AsyncTask::new(BlockingMapped { + tag, + cancel_token: cancel_token.into(), + work: Some(Box::new(work)), + error: None, + reject_hook, + }) +} /// Create an `AsyncTask` that runs blocking work on libuv's thread pool. /// diff --git a/crates/pi-natives/src/tty_writer.rs b/crates/pi-natives/src/tty_writer.rs index 276dfad2cc5d..72eb60937c34 100644 --- a/crates/pi-natives/src/tty_writer.rs +++ b/crates/pi-natives/src/tty_writer.rs @@ -38,7 +38,7 @@ use crate::js; struct Inner { /// Bytes accepted from JS but not yet claimed by the pump thread. The /// pump swaps this out wholesale, so enqueue cost is an in-place append - /// and chunks coalesce into one `write(2)` per drain cycle. + /// and chunks coalesce into one contiguous drain buffer per drain cycle. back: Mutex>, /// Bytes accepted but not yet written to the fd. pending: AtomicUsize, @@ -48,25 +48,47 @@ struct Inner { dead: AtomicBool, } +/// Keep each Unix PTY syscall small enough for terminal emulators to consume +/// incrementally. In particular, Terminal.app can stop draining a PTY when a +/// large normal-screen history replay arrives as one multi-hundred-KiB write, +/// leaving the writer blocked and every later frame queued behind it. #[cfg(unix)] -fn write_all(fd: i32, buf: &[u8]) -> std::io::Result<()> { +const MAX_TTY_WRITE_CHUNK_BYTES: usize = 16 * 1024; + +#[cfg(unix)] +fn write_all_with( + mut write: impl FnMut(&[u8]) -> std::io::Result, + buf: &[u8], +) -> std::io::Result<()> { let mut off = 0usize; while off < buf.len() { - // SAFETY: `buf[off..]` is a valid initialized slice; `fd` is owned by - // the writer (dup'd at construction) and stays open until drop. - let rc = unsafe { libc::write(fd, buf[off..].as_ptr().cast(), buf.len() - off) }; - if rc < 0 { - let err = std::io::Error::last_os_error(); - if err.kind() == std::io::ErrorKind::Interrupted { - continue; - } - return Err(err); + let end = (off + MAX_TTY_WRITE_CHUNK_BYTES).min(buf.len()); + match write(&buf[off..end]) { + Ok(0) => return Err(std::io::ErrorKind::WriteZero.into()), + Ok(written) => off += written, + Err(err) if err.kind() == std::io::ErrorKind::Interrupted => {}, + Err(err) => return Err(err), } - off += rc as usize; } Ok(()) } +#[cfg(unix)] +fn write_all(fd: i32, buf: &[u8]) -> std::io::Result<()> { + write_all_with( + |chunk| { + // SAFETY: `chunk` is a valid initialized slice; `fd` is owned by + // the writer (dup'd at construction) and stays open until drop. + let rc = unsafe { libc::write(fd, chunk.as_ptr().cast(), chunk.len()) }; + if rc < 0 { + return Err(std::io::Error::last_os_error()); + } + Ok(rc as usize) + }, + buf, + ) +} + #[cfg(unix)] fn pump_loop(fd: i32, inner: &Inner) { let mut front: Vec = Vec::new(); @@ -268,6 +290,26 @@ impl Drop for TtyWriter { #[cfg(all(test, unix))] mod tests { use super::*; + + #[test] + fn large_frame_is_split_into_bounded_tty_writes() { + let frame = vec![b'x'; MAX_TTY_WRITE_CHUNK_BYTES * 2 + 7]; + let mut requested = Vec::new(); + let mut output = Vec::new(); + write_all_with( + |chunk| { + requested.push(chunk.len()); + output.extend_from_slice(chunk); + Ok(chunk.len()) + }, + &frame, + ) + .unwrap(); + + assert_eq!(requested, [MAX_TTY_WRITE_CHUNK_BYTES, MAX_TTY_WRITE_CHUNK_BYTES, 7]); + assert_eq!(output, frame); + } + fn push(writer: &TtyWriter, data: &[u8]) { writer.append(|back| { back.extend_from_slice(data); diff --git a/crates/pi-natives/src/vcs.rs b/crates/pi-natives/src/vcs.rs new file mode 100644 index 000000000000..5550b879467b --- /dev/null +++ b/crates/pi-natives/src/vcs.rs @@ -0,0 +1,1444 @@ +//! N-API bindings for in-process Git and Jujutsu operations. + +use std::{ + path::{Path, PathBuf}, + sync::Arc, + time::Duration, +}; + +use napi::{Env, Result, bindgen_prelude::*}; +use napi_derive::napi; +use pi_vcs::types as core; +use tokio_util::sync::CancellationToken; + +use crate::task; + +/// Build the JS `VcsError` on the JS thread and hand it to napi as the +/// rejection/throw value. napi retains a reference to the constructed object, +/// so JS receives exactly this error: a real `Error` with `name: "VcsError"`, +/// a machine-readable `code` (the [`pi_vcs::Error::kind`] discriminant), and +/// the CLI result fields (`exitCode`/`stdout`/`stderr`; non-CLI failures +/// mirror the message into `stderr` and synthesize `exitCode: 1`). +fn rich_error(env: Env, err: pi_vcs::Error) -> napi::Error { + let message = err.to_string(); + let kind = err.kind(); + let (exit_code, stdout, stderr) = match err { + pi_vcs::Error::Cli { exit_code, stdout, stderr, .. } => (exit_code, stdout, stderr), + _ => (1, String::new(), message.clone()), + }; + let built: Result = (|| { + let mut object = env.create_error(napi::Error::from_reason(message.clone()))?; + object.set_named_property("name", "VcsError")?; + object.set_named_property("code", kind)?; + object.set_named_property("exitCode", exit_code)?; + object.set_named_property("stdout", stdout.as_str())?; + object.set_named_property("stderr", stderr.as_str())?; + Ok(napi::Error::from(object.to_unknown())) + })(); + built.unwrap_or_else(|_| napi::Error::from_reason(message)) +} +/// Run a tokio-backed VCS future, rejecting with the rich `VcsError` built on +/// the JS thread. A deferred promise is used because napi future rejections +/// can only carry a message string; the deferred resolver runs with `Env` and +/// can hand back a real error object. +fn vcs_future<'env, T: ToNapiValue + Send + 'static>( + env: &'env Env, + tag: &'static str, + work: impl Future> + Send + 'static, +) -> Result> { + let (deferred, promise) = env.create_deferred()?; + spawn(async move { + let _guard = crate::prof::profile_region(tag); + let outcome = work.await; + deferred.resolve(move |env| outcome.map_err(|err| rich_error(env, err))); + }); + Ok(promise) +} + +/// Promise produced by VCS blocking tasks: [`task::MappedPromise`] carrying +/// [`pi_vcs::Error`] for the JS-thread rich-error conversion. Named +/// `Promise` so the napi macro emits a plain `Promise` TS return type. +type Promise = task::MappedPromise; + +fn path_string(path: impl AsRef) -> String { + path.as_ref().to_string_lossy().into_owned() +} +fn cancellation_token(signal: Option) -> Option { + signal.and_then(|value| { + let aborted = value + .coerce_to_object() + .and_then(|object| object.get_named_property::("aborted")) + .unwrap_or(false); + let signal = AbortSignal::from_unknown(value).ok()?; + let token = CancellationToken::new(); + if aborted { + token.cancel(); + } + let abort = token.clone(); + signal.on_abort(move || abort.cancel()); + Some(token) + }) +} + +/// Discovered Git repository paths. +#[napi(object)] +pub struct VcsGitRepoInfo { + pub repo_root: String, + pub git_entry_path: String, + pub git_dir: String, + pub common_dir: String, + pub head_path: String, + pub is_reftable: bool, +} +/// Git status counts. +#[napi(object)] +pub struct VcsStatusSummary { + pub staged: u32, + pub unstaged: u32, + pub untracked: u32, +} +/// Resolved HEAD state. +#[napi(object)] +pub struct VcsHeadState { + pub kind: String, + pub ref_name: Option, + pub branch: Option, + pub commit: Option, +} +/// Linked worktree metadata. +#[napi(object)] +pub struct VcsLinkedWorktree { + pub root: String, + pub primary_root: String, +} +/// One worktree listing row. +#[napi(object)] +pub struct VcsWorktreeEntry { + pub path: String, + pub head: Option, + pub branch: Option, + pub detached: bool, +} +/// Commit author identity. +#[napi(object)] +pub struct VcsCommitAuthor { + pub name: String, + pub email: String, + pub date: Option, +} +/// Commit metadata. +#[napi(object)] +pub struct VcsCommitDetails { + pub sha: String, + pub parents: Vec, + pub author: VcsCommitAuthor, + pub message: String, +} +/// Per-file line counts. +#[napi(object)] +pub struct VcsNumstatEntry { + pub path: String, + pub added: Option, + pub removed: Option, +} +/// Bounded object contents. +#[napi(object)] +pub struct VcsShowResult { + pub data: Buffer, + pub truncated: bool, +} +/// Diff generation options. +#[napi(object)] +#[derive(Default)] +pub struct VcsDiffOptions { + pub cached: Option, + pub base: Option, + pub head: Option, + pub files: Option>, + pub context: Option, + pub binary: Option, +} +/// Status query options. +#[napi(object)] +#[derive(Default)] +pub struct VcsStatusOptions { + pub untracked: Option, + pub pathspecs: Option>, + pub nul_terminated: Option, +} +/// Commit creation options. +#[napi(object)] +#[derive(Default)] +pub struct VcsCommitOptions { + pub author: Option, + pub allow_empty: Option, + pub amend: Option, + pub files: Option>, +} +/// Patch application options. +#[napi(object)] +#[derive(Default)] +pub struct VcsApplyOptions { + pub cached: Option, + pub index_path: Option, + pub reverse: Option, + pub three_way: Option, +} +/// Restore options. +#[napi(object)] +#[derive(Default)] +pub struct VcsRestoreOptions { + pub source: Option, + pub staged: Option, + pub worktree: Option, + pub files: Option>, +} +/// Clean options. +#[napi(object)] +#[derive(Default)] +pub struct VcsCleanOptions { + pub ignored_only: Option, + pub include_ignored: Option, + pub paths: Option>, +} +/// Push options. +#[napi(object)] +#[derive(Default)] +pub struct VcsPushOptions { + pub remote: Option, + pub refspec: Option, + pub force_with_lease: Option, +} +/// Clone options. +#[napi(object)] +#[derive(Default)] +pub struct VcsCloneOptions { + pub ref_name: Option, + pub sha: Option, + pub timeout_ms: Option, +} +/// Selected hunks or line range for a path. +#[napi(object)] +pub struct VcsHunkSelection { + pub path: String, + pub kind: String, + pub indices: Option>, + pub start: Option, + pub end: Option, +} +/// Invalid hunk selection. +#[napi(object)] +pub struct VcsHunkSelectionError { + pub path: String, + pub message: String, +} + +impl From for VcsGitRepoInfo { + fn from(v: core::GitRepoInfo) -> Self { + Self { + repo_root: path_string(v.repo_root), + git_entry_path: path_string(v.git_entry_path), + git_dir: path_string(v.git_dir), + common_dir: path_string(v.common_dir), + head_path: path_string(v.head_path), + is_reftable: v.is_reftable, + } + } +} +impl From for VcsStatusSummary { + fn from(v: core::StatusSummary) -> Self { + Self { staged: v.staged, unstaged: v.unstaged, untracked: v.untracked } + } +} +impl From for VcsHeadState { + fn from(v: core::HeadState) -> Self { + match v { + core::HeadState::Ref { ref_name, branch, commit } => { + Self { kind: "ref".into(), ref_name: Some(ref_name), branch, commit } + }, + core::HeadState::Detached { commit } => { + Self { kind: "detached".into(), ref_name: None, branch: None, commit } + }, + } + } +} +impl From for VcsLinkedWorktree { + fn from(v: core::LinkedWorktree) -> Self { + Self { root: path_string(v.root), primary_root: path_string(v.primary_root) } + } +} +impl From for VcsWorktreeEntry { + fn from(v: core::WorktreeEntry) -> Self { + Self { + path: path_string(v.path), + head: v.head, + branch: v.branch, + detached: v.detached, + } + } +} +impl From for VcsCommitAuthor { + fn from(v: core::CommitAuthor) -> Self { + Self { name: v.name, email: v.email, date: v.date } + } +} +impl From for core::CommitAuthor { + fn from(v: VcsCommitAuthor) -> Self { + Self { name: v.name, email: v.email, date: v.date } + } +} +impl From for VcsCommitDetails { + fn from(v: core::CommitDetails) -> Self { + Self { sha: v.sha, parents: v.parents, author: v.author.into(), message: v.message } + } +} +impl From for VcsNumstatEntry { + fn from(v: core::NumstatEntry) -> Self { + Self { path: v.path, added: v.added, removed: v.removed } + } +} +impl From for VcsShowResult { + fn from(v: core::ShowResult) -> Self { + Self { data: v.bytes.into(), truncated: v.truncated } + } +} +impl From for core::DiffOptions { + fn from(v: VcsDiffOptions) -> Self { + Self { + cached: v.cached.unwrap_or(false), + base: v.base, + head: v.head, + files: v.files.unwrap_or_default(), + context: v.context, + binary: v.binary.unwrap_or(false), + } + } +} +impl TryFrom for core::StatusOptions { + type Error = napi::Error; + + fn try_from(v: VcsStatusOptions) -> Result { + let untracked = match v.untracked.as_deref().unwrap_or("normal") { + "no" => core::UntrackedMode::No, + "normal" => core::UntrackedMode::Normal, + "all" => core::UntrackedMode::All, + x => return Err(napi::Error::from_reason(format!("invalid untracked mode: {x}"))), + }; + Ok(Self { + untracked, + pathspecs: v.pathspecs.unwrap_or_default(), + nul_terminated: v.nul_terminated.unwrap_or(false), + }) + } +} +impl From for core::CommitOptions { + fn from(v: VcsCommitOptions) -> Self { + Self { + author: v.author.map(Into::into), + allow_empty: v.allow_empty.unwrap_or(false), + amend: v.amend.unwrap_or(false), + files: v.files.unwrap_or_default(), + } + } +} +impl From for core::ApplyOptions { + fn from(v: VcsApplyOptions) -> Self { + Self { + cached: v.cached.unwrap_or(false), + index_path: v.index_path.map(PathBuf::from), + reverse: v.reverse.unwrap_or(false), + three_way: v.three_way.unwrap_or(false), + } + } +} +impl From for core::RestoreOptions { + fn from(v: VcsRestoreOptions) -> Self { + Self { + source: v.source, + staged: v.staged.unwrap_or(false), + worktree: v.worktree.unwrap_or(false), + files: v.files.unwrap_or_default(), + } + } +} +impl From for core::CleanOptions { + fn from(v: VcsCleanOptions) -> Self { + Self { + ignored_only: v.ignored_only.unwrap_or(false), + include_ignored: v.include_ignored.unwrap_or(false), + paths: v.paths.unwrap_or_default(), + } + } +} +impl From for core::PushOptions { + fn from(v: VcsPushOptions) -> Self { + Self { + remote: v.remote, + refspec: v.refspec, + force_with_lease: v.force_with_lease.unwrap_or(false), + } + } +} +impl From for core::CloneOptions { + fn from(v: VcsCloneOptions) -> Self { + Self { + ref_name: v.ref_name, + sha: v.sha, + timeout: v.timeout_ms.map(|v| Duration::from_millis(u64::from(v))), + } + } +} +impl TryFrom for core::HunkSelection { + type Error = napi::Error; + + fn try_from(v: VcsHunkSelection) -> Result { + let hunks = match v.kind.as_str() { + "all" => core::HunkSpec::All, + "indices" => core::HunkSpec::Indices(v.indices.unwrap_or_default()), + "lines" => core::HunkSpec::Lines { + start: v + .start + .ok_or_else(|| napi::Error::from_reason("lines selection requires start"))?, + end: v + .end + .ok_or_else(|| napi::Error::from_reason("lines selection requires end"))?, + }, + x => return Err(napi::Error::from_reason(format!("invalid hunk selection kind: {x}"))), + }; + Ok(Self { path: v.path, hunks }) + } +} + +fn blocking( + tag: &'static str, + repo: Arc, + signal: Option, + f: impl FnOnce(&pi_vcs::git::GitRepo) -> pi_vcs::Result + Send + 'static, +) -> Promise { + let ct = task::CancelToken::new(None, signal); + task::blocking_mapped(tag, ct, rich_error, move |ct| { + if ct.heartbeat().is_err() { + return Err(pi_vcs::Error::Canceled); + } + f(&repo) + }) +} +fn repo_blocking( + tag: &'static str, + repo: pi_vcs::Repo, + signal: Option, + f: impl FnOnce(&pi_vcs::Repo) -> pi_vcs::Result + Send + 'static, +) -> Promise { + let ct = task::CancelToken::new(None, signal); + task::blocking_mapped(tag, ct, rich_error, move |ct| { + if ct.heartbeat().is_err() { + return Err(pi_vcs::Error::Canceled); + } + f(&repo) + }) +} + +/// Backend-agnostic repository handle for portable VCS reads. +#[napi] +pub struct VcsRepo { + inner: pi_vcs::Repo, +} + +/// Discover the repository owning a directory. +#[napi] +pub fn vcs_discover(env: Env, dir: String) -> Result> { + pi_vcs::detect(Path::new(&dir)) + .map(|repo| repo.map(|inner| VcsRepo { inner })) + .map_err(|err| rich_error(env, err)) +} + +#[napi] +impl VcsRepo { + /// Backend kind (`"git"` or `"jj"`). + #[napi] + pub fn kind(&self) -> String { + match self.inner.kind() { + core::VcsKind::Git => "git", + core::VcsKind::Jj => "jj", + } + .to_owned() + } + + /// Checkout or workspace root. + #[napi] + pub fn root(&self) -> String { + path_string(self.inner.root()) + } + + /// Primary checkout or default workspace root. + #[napi] + pub fn primary_root(&self) -> String { + path_string(self.inner.primary_root()) + } + + /// Worktree-relative prefix of a directory. + #[napi] + pub fn prefix_of(&self, dir: String) -> Option { + self.inner.prefix_of(Path::new(&dir)) + } + + /// Filesystem target to watch for repository-head changes. + #[napi] + pub fn watch_target(&self) -> String { + path_string(self.inner.watch_target()) + } + + /// Whether this backend implements a portable feature. + #[napi] + pub fn supports(&self, env: Env, feature: String) -> Result { + let parsed = pi_vcs::Feature::parse(&feature).ok_or_else(|| { + rich_error( + env, + pi_vcs::Error::backend( + "vcs supports", + format!("unknown feature `{feature}`; valid: stagedDiff, revDiff"), + ), + ) + })?; + Ok(self.inner.supports(parsed)) + } + + /// Git-specific handle when this repository is backed by Git. + #[napi] + pub fn as_git(&self) -> Option { + self + .inner + .as_git() + .map(|inner| VcsGitRepo { inner: inner.clone() }) + } + + /// Jujutsu-specific handle when this repository is backed by Jujutsu. + #[napi] + pub fn as_jj(&self) -> Option { + self + .inner + .as_jj() + .map(|inner| VcsJjWorkspace { inner: inner.clone() }) + } + + /// Human label for the working copy. + #[napi] + pub fn label(&self, signal: Option) -> Promise> { + repo_blocking("vcs.label", self.inner.clone(), signal, |repo| repo.label()) + } + + /// Working-copy commit id. + #[napi] + pub fn head_id(&self, signal: Option) -> Promise> { + repo_blocking("vcs.headId", self.inner.clone(), signal, |repo| repo.head_id()) + } + + /// Status counts. + #[napi] + pub fn status_summary(&self, signal: Option) -> Promise { + repo_blocking("vcs.statusSummary", self.inner.clone(), signal, |repo| { + repo.status_summary().map(Into::into) + }) + } + + /// Porcelain status. + #[napi] + pub fn status_porcelain( + &self, + options: VcsStatusOptions, + signal: Option, + ) -> Promise { + let options = core::StatusOptions::try_from(options); + repo_blocking("vcs.statusPorcelain", self.inner.clone(), signal, move |repo| { + repo.status_porcelain(&options.map_err(|error| pi_vcs::Error::Backend { + context: "vcs status options", + message: error.to_string(), + })?) + }) + } + + /// Render a patch. + #[napi] + pub fn diff_text(&self, options: VcsDiffOptions, signal: Option) -> Promise { + let options = options.into(); + repo_blocking("vcs.diffText", self.inner.clone(), signal, move |repo| { + repo.diff_text(&options) + }) + } + + /// Changed paths. + #[napi] + pub fn changed_files( + &self, + options: VcsDiffOptions, + signal: Option, + ) -> Promise> { + let options = options.into(); + repo_blocking("vcs.changedFiles", self.inner.clone(), signal, move |repo| { + repo.changed_files(&options) + }) + } + + /// Per-file line counts. + #[napi] + pub fn numstat( + &self, + options: VcsDiffOptions, + signal: Option, + ) -> Promise> { + let options = options.into(); + repo_blocking("vcs.numstat", self.inner.clone(), signal, move |repo| { + repo + .numstat(&options) + .map(|entries| entries.into_iter().map(Into::into).collect()) + }) + } + + /// Every working-copy change since the last commit. + #[napi] + pub fn uncommitted_diff(&self, files: Vec, signal: Option) -> Promise { + repo_blocking("vcs.uncommittedDiff", self.inner.clone(), signal, move |repo| { + repo.uncommitted_diff(&files) + }) + } + + /// Recent subjects. + #[napi] + pub fn log_subjects(&self, count: u32, signal: Option) -> Promise> { + repo_blocking("vcs.logSubjects", self.inner.clone(), signal, move |repo| { + repo.log_subjects(count as usize) + }) + } + + /// Recent one-line commits. + #[napi] + pub fn log_onelines(&self, count: u32, signal: Option) -> Promise> { + repo_blocking("vcs.logOnelines", self.inner.clone(), signal, move |repo| { + repo.log_onelines(count as usize) + }) + } + + /// Commit details. + #[napi] + pub fn commit_details(&self, rev: String, signal: Option) -> Promise { + repo_blocking("vcs.commitDetails", self.inner.clone(), signal, move |repo| { + repo.commit_details(&rev).map(Into::into) + }) + } + + /// List tracked or untracked paths. + #[napi] + pub fn ls_files( + &self, + others: bool, + exclude_standard: bool, + signal: Option, + ) -> Promise> { + repo_blocking("vcs.lsFiles", self.inner.clone(), signal, move |repo| { + repo.ls_files(others, exclude_standard) + }) + } +} + +/// In-process Git repository handle. +#[napi] +pub struct VcsGitRepo { + inner: Arc, +} + +/// Discover the Git checkout containing a directory. +#[napi] +pub fn vcs_git_discover(env: Env, dir: String) -> Result> { + pi_vcs::git::GitRepo::discover(Path::new(&dir)) + .map(|v| v.map(|inner| VcsGitRepo { inner: Arc::new(inner) })) + .map_err(|err| rich_error(env, err)) +} +/// Discover Git metadata without opening the repository. +#[napi] +pub fn vcs_git_repo_info(env: Env, dir: String) -> Result> { + pi_vcs::git::discover_info(Path::new(&dir)) + .map(|v| v.map(Into::into)) + .map_err(|err| rich_error(env, err)) +} + +#[napi] +impl VcsGitRepo { + /// Repository metadata. + #[napi] + pub fn info(&self) -> VcsGitRepoInfo { + self.inner.info().clone().into() + } + + /// Primary checkout root. + #[napi] + pub fn primary_root(&self) -> String { + path_string(self.inner.primary_root()) + } + + /// Linked-worktree metadata. + #[napi] + pub fn linked_worktree(&self) -> Option { + self.inner.linked_worktree().map(Into::into) + } + + /// Resolve HEAD synchronously. + #[napi] + pub fn head_sync(&self, env: Env) -> Result { + self + .inner + .head() + .map(Into::into) + .map_err(|err| rich_error(env, err)) + } + + /// Worktree-relative prefix of a directory. + #[napi] + pub fn prefix_of(&self, dir: String) -> Option { + self.inner.prefix_of(Path::new(&dir)) + } + + /// Resolve HEAD. + #[napi] + pub fn head(&self, signal: Option) -> Promise { + blocking("vcs.head", self.inner.clone(), signal, |r| r.head().map(Into::into)) + } + + /// Resolve HEAD SHA. + #[napi] + pub fn head_sha(&self, signal: Option) -> Promise> { + blocking("vcs.headSha", self.inner.clone(), signal, |r| r.head_sha()) + } + + /// Current branch. + #[napi] + pub fn current_branch(&self, signal: Option) -> Promise> { + blocking("vcs.currentBranch", self.inner.clone(), signal, |r| r.current_branch()) + } + + /// Default remote branch. + #[napi] + pub fn default_branch(&self, signal: Option) -> Promise> { + blocking("vcs.defaultBranch", self.inner.clone(), signal, |r| r.default_branch()) + } + + /// Resolve a revision. + #[napi] + pub fn resolve_ref(&self, name: String, signal: Option) -> Promise> { + blocking("vcs.resolveRef", self.inner.clone(), signal, move |r| r.resolve_ref(&name)) + } + + /// Test revision existence. + #[napi] + pub fn ref_exists(&self, name: String, signal: Option) -> Promise { + blocking("vcs.refExists", self.inner.clone(), signal, move |r| r.ref_exists(&name)) + } + + /// Tags pointing at a revision. + #[napi] + pub fn tags_at(&self, rev: String, signal: Option) -> Promise> { + blocking("vcs.tagsAt", self.inner.clone(), signal, move |r| r.tags_at(&rev)) + } + + /// List branches. + #[napi] + pub fn list_branches(&self, all: bool, signal: Option) -> Promise> { + blocking("vcs.listBranches", self.inner.clone(), signal, move |r| r.list_branches(all)) + } + + /// Whether default porcelain status reports a staged, unstaged, or untracked + /// change. + #[napi] + pub fn is_dirty(&self, signal: Option) -> Promise { + blocking("vcs.isDirty", self.inner.clone(), signal, |repo| repo.is_dirty()) + } + + /// Porcelain status. + #[napi] + pub fn status_porcelain( + &self, + options: VcsStatusOptions, + signal: Option, + ) -> Promise { + let options = core::StatusOptions::try_from(options); + blocking("vcs.statusPorcelain", self.inner.clone(), signal, move |r| { + r.status_porcelain(&options.map_err(|error| pi_vcs::Error::Backend { + context: "git status options", + message: error.to_string(), + })?) + }) + } + + /// Status counts. + #[napi] + pub fn status_summary(&self, signal: Option) -> Promise { + blocking("vcs.statusSummary", self.inner.clone(), signal, |r| { + r.status_summary().map(Into::into) + }) + } + + /// Read config. + #[napi] + pub fn config_get(&self, key: String, signal: Option) -> Promise> { + blocking("vcs.configGet", self.inner.clone(), signal, move |r| r.config_get(&key)) + } + + /// Set config. + #[napi] + pub fn config_set(&self, key: String, value: String, signal: Option) -> Promise<()> { + blocking("vcs.configSet", self.inner.clone(), signal, move |r| r.config_set(&key, &value)) + } + + /// List remotes. + #[napi] + pub fn remote_list(&self, signal: Option) -> Promise> { + blocking("vcs.remoteList", self.inner.clone(), signal, |r| r.remote_list()) + } + + /// Remote URL. + #[napi] + pub fn remote_url(&self, name: String, signal: Option) -> Promise> { + blocking("vcs.remoteUrl", self.inner.clone(), signal, move |r| r.remote_url(&name)) + } + + /// Add remote. + #[napi] + pub fn remote_add(&self, name: String, url: String, signal: Option) -> Promise<()> { + blocking("vcs.remoteAdd", self.inner.clone(), signal, move |r| r.remote_add(&name, &url)) + } + + /// List worktrees. + #[napi] + pub fn worktrees(&self, signal: Option) -> Promise> { + blocking("vcs.worktrees", self.inner.clone(), signal, |r| { + r.worktrees() + .map(|v| v.into_iter().map(Into::into).collect()) + }) + } + + /// Add worktree. + #[napi] + pub fn worktree_add( + &self, + path: String, + ref_name: String, + detach: bool, + signal: Option, + ) -> Promise<()> { + blocking("vcs.worktreeAdd", self.inner.clone(), signal, move |r| { + r.worktree_add(Path::new(&path), &ref_name, detach) + }) + } + + /// Remove worktree. + #[napi] + pub fn worktree_remove( + &self, + path: String, + force: bool, + signal: Option, + ) -> Promise { + blocking("vcs.worktreeRemove", self.inner.clone(), signal, move |r| { + r.worktree_remove(Path::new(&path), force) + }) + } + + /// Prune worktrees. + #[napi] + pub fn worktree_prune(&self, signal: Option) -> Promise<()> { + blocking("vcs.worktreePrune", self.inner.clone(), signal, |r| r.worktree_prune()) + } + + /// Recent subjects. + #[napi] + pub fn log_subjects(&self, count: u32, signal: Option) -> Promise> { + blocking("vcs.logSubjects", self.inner.clone(), signal, move |r| { + r.log_subjects(count as usize) + }) + } + + /// Recent one-line commits. + #[napi] + pub fn log_onelines(&self, count: u32, signal: Option) -> Promise> { + blocking("vcs.logOnelines", self.inner.clone(), signal, move |r| { + r.log_onelines(count as usize) + }) + } + + /// Commits in a range. + #[napi] + pub fn rev_list_range( + &self, + base: String, + head: String, + signal: Option, + ) -> Promise> { + blocking("vcs.revListRange", self.inner.clone(), signal, move |r| { + r.rev_list_range(&base, &head) + }) + } + + /// Best common ancestor of two revisions. + #[napi] + pub fn merge_base( + &self, + a: String, + b: String, + signal: Option, + ) -> Promise> { + blocking("vcs.mergeBase", self.inner.clone(), signal, move |r| r.merge_base(&a, &b)) + } + + /// Commits touching a file. + #[napi] + pub fn rev_list_touching( + &self, + rev: String, + file: String, + limit: u32, + signal: Option, + ) -> Promise> { + blocking("vcs.revListTouching", self.inner.clone(), signal, move |r| { + r.rev_list_touching(&rev, &file, limit as usize) + }) + } + + /// Commit details. + #[napi] + pub fn commit_details(&self, rev: String, signal: Option) -> Promise { + blocking("vcs.commitDetails", self.inner.clone(), signal, move |r| { + r.commit_details(&rev).map(Into::into) + }) + } + + /// List index or untracked paths. + #[napi] + pub fn ls_files( + &self, + others: bool, + exclude_standard: bool, + signal: Option, + ) -> Promise> { + blocking("vcs.lsFiles", self.inner.clone(), signal, move |r| { + r.ls_files(others, exclude_standard) + }) + } + + /// List tree paths. + #[napi] + pub fn ls_tree( + &self, + rev: String, + paths: Vec, + signal: Option, + ) -> Promise> { + blocking("vcs.lsTree", self.inner.clone(), signal, move |r| r.ls_tree(&rev, &paths)) + } + + /// List submodule paths. + #[napi] + pub fn submodule_paths(&self, signal: Option) -> Promise> { + blocking("vcs.submodulePaths", self.inner.clone(), signal, |r| r.submodule_paths()) + } + + /// Read blob bytes. + #[napi] + pub fn show_blob( + &self, + spec: String, + max_bytes: Option, + signal: Option, + ) -> Promise { + blocking("vcs.showBlob", self.inner.clone(), signal, move |r| { + r.show_blob(&spec, max_bytes.map(|v| v as usize)) + .map(Into::into) + }) + } + + /// Read commit and patch bytes. + #[napi] + pub fn show_commit( + &self, + rev: String, + max_bytes: Option, + signal: Option, + ) -> Promise { + blocking("vcs.showCommit", self.inner.clone(), signal, move |r| { + r.show_commit(&rev, max_bytes.map(|v| v as usize)) + .map(Into::into) + }) + } + + /// Local LFS media directory. + #[napi] + pub fn lfs_media_dir(&self, signal: Option) -> Promise> { + blocking("vcs.lfsMediaDir", self.inner.clone(), signal, |r| { + r.lfs_media_dir().map(|v| v.map(path_string)) + }) + } + + /// Render a patch. + #[napi] + pub fn diff_text(&self, options: VcsDiffOptions, signal: Option) -> Promise { + let options = options.into(); + blocking("vcs.diffText", self.inner.clone(), signal, move |r| r.diff_text(&options)) + } + + /// Render a no-index patch between two filesystem paths. + #[napi] + pub fn diff_no_index( + &self, + left: String, + right: String, + binary: bool, + signal: Option, + ) -> Promise { + blocking("vcs.diffNoIndex", self.inner.clone(), signal, move |repo| { + repo.diff_no_index(Path::new(&left), Path::new(&right), binary) + }) + } + + /// Changed paths. + #[napi] + pub fn changed_files( + &self, + options: VcsDiffOptions, + signal: Option, + ) -> Promise> { + let options = options.into(); + blocking("vcs.changedFiles", self.inner.clone(), signal, move |r| r.changed_files(&options)) + } + + /// Per-file line counts. + #[napi] + pub fn numstat( + &self, + options: VcsDiffOptions, + signal: Option, + ) -> Promise> { + let options = options.into(); + blocking("vcs.numstat", self.inner.clone(), signal, move |r| { + r.numstat(&options) + .map(|v| v.into_iter().map(Into::into).collect()) + }) + } + + /// Test for a diff. + #[napi] + pub fn has_diff(&self, options: VcsDiffOptions, signal: Option) -> Promise { + let options = options.into(); + blocking("vcs.hasDiff", self.inner.clone(), signal, move |r| r.has_diff(&options)) + } + + /// Diff two trees. + #[napi] + pub fn diff_tree( + &self, + base: String, + head: String, + binary: bool, + signal: Option, + ) -> Promise { + blocking("vcs.diffTree", self.inner.clone(), signal, move |r| { + r.diff_tree(&base, &head, binary) + }) + } + + /// Stage paths. + #[napi] + pub fn stage_files(&self, files: Vec, signal: Option) -> Promise<()> { + blocking("vcs.stageFiles", self.inner.clone(), signal, move |r| r.stage_files(&files)) + } + + /// Unstage paths. + #[napi] + pub fn unstage(&self, files: Vec, signal: Option) -> Promise<()> { + blocking("vcs.unstage", self.inner.clone(), signal, move |r| r.unstage(&files)) + } + + /// Stage selected hunks. + #[napi] + pub fn stage_hunks( + &self, + selections: Vec, + raw_diff: Option, + signal: Option, + ) -> Promise<()> { + let selections: Result> = selections.into_iter().map(TryInto::try_into).collect(); + blocking("vcs.stageHunks", self.inner.clone(), signal, move |r| { + r.stage_hunks( + &selections.map_err(|error| pi_vcs::Error::Backend { + context: "git hunk selection", + message: error.to_string(), + })?, + raw_diff.as_deref(), + ) + }) + } + + /// Create commit. + #[napi] + pub fn commit_create( + &self, + message: String, + options: VcsCommitOptions, + signal: Option, + ) -> Promise { + let options = options.into(); + blocking("vcs.commitCreate", self.inner.clone(), signal, move |r| { + r.commit_create(&message, &options) + }) + } + + /// Checkout revision. + #[napi] + pub fn checkout(&self, rev: String, signal: Option) -> Promise<()> { + blocking("vcs.checkout", self.inner.clone(), signal, move |r| r.checkout(&rev)) + } + + /// Create branch. + #[napi] + pub fn create_branch( + &self, + name: String, + start: String, + force: bool, + signal: Option, + ) -> Promise<()> { + blocking("vcs.createBranch", self.inner.clone(), signal, move |r| { + r.create_branch(&name, &start, force) + }) + } + + /// Delete branch. + #[napi] + pub fn delete_branch( + &self, + name: String, + force: bool, + signal: Option, + ) -> Promise { + blocking("vcs.deleteBranch", self.inner.clone(), signal, move |r| { + r.delete_branch(&name, force) + }) + } + + /// Create and checkout branch. + #[napi] + pub fn checkout_new_branch(&self, name: String, signal: Option) -> Promise<()> { + blocking("vcs.checkoutNewBranch", self.inner.clone(), signal, move |r| { + r.checkout_new_branch(&name) + }) + } + + /// Restore paths. + #[napi] + pub fn restore(&self, options: VcsRestoreOptions, signal: Option) -> Promise<()> { + let options = options.into(); + blocking("vcs.restore", self.inner.clone(), signal, move |r| r.restore(&options)) + } + + /// Reset repository state. + #[napi] + pub fn reset( + &self, + mode: String, + target: Option, + signal: Option, + ) -> Promise<()> { + let mode = match mode.as_str() { + "soft" => Ok(core::ResetMode::Soft), + "mixed" => Ok(core::ResetMode::Mixed), + "hard" => Ok(core::ResetMode::Hard), + x => Err(napi::Error::from_reason(format!("invalid reset mode: {x}"))), + }; + blocking("vcs.reset", self.inner.clone(), signal, move |r| { + r.reset( + mode.map_err(|error| pi_vcs::Error::Backend { + context: "git reset mode", + message: error.to_string(), + })?, + target.as_deref(), + ) + }) + } + + /// Clean untracked paths. + #[napi] + pub fn clean(&self, options: VcsCleanOptions, signal: Option) -> Promise<()> { + let options = options.into(); + blocking("vcs.clean", self.inner.clone(), signal, move |r| r.clean(&options)) + } + + /// Read tree into index. + #[napi] + pub fn read_tree( + &self, + treeish: String, + index_path: Option, + signal: Option, + ) -> Promise<()> { + blocking("vcs.readTree", self.inner.clone(), signal, move |r| { + r.read_tree(&treeish, index_path.as_deref().map(Path::new)) + }) + } + + /// Write index tree. + #[napi] + pub fn write_tree( + &self, + index_path: Option, + signal: Option, + ) -> Promise { + blocking("vcs.writeTree", self.inner.clone(), signal, move |r| { + r.write_tree(index_path.as_deref().map(Path::new)) + }) + } + + /// Apply patch. + #[napi] + pub fn apply_patch( + &self, + patch: String, + options: VcsApplyOptions, + signal: Option, + ) -> Promise<()> { + let options = options.into(); + blocking("vcs.applyPatch", self.inner.clone(), signal, move |r| { + r.apply_patch(&patch, &options) + }) + } + + /// Check patch applicability. + #[napi] + pub fn can_apply_patch( + &self, + patch: String, + options: VcsApplyOptions, + signal: Option, + ) -> Promise { + let options = options.into(); + blocking("vcs.canApplyPatch", self.inner.clone(), signal, move |r| { + r.can_apply_patch(&patch, &options) + }) + } + + /// Cherry-pick commit. + #[napi] + pub fn cherry_pick(&self, rev: String, signal: Option) -> Promise<()> { + blocking("vcs.cherryPick", self.inner.clone(), signal, move |r| r.cherry_pick(&rev)) + } + + /// Abort cherry-pick. + #[napi] + pub fn cherry_pick_abort(&self, signal: Option) -> Promise<()> { + blocking("vcs.cherryPickAbort", self.inner.clone(), signal, |r| r.cherry_pick_abort()) + } + + /// Skip cherry-pick. + #[napi] + pub fn cherry_pick_skip(&self, signal: Option) -> Promise<()> { + blocking("vcs.cherryPickSkip", self.inner.clone(), signal, |r| r.cherry_pick_skip()) + } + + /// Push stash. + #[napi] + pub fn stash_push(&self, message: Option, signal: Option) -> Promise { + blocking("vcs.stashPush", self.inner.clone(), signal, move |r| { + r.stash_push(message.as_deref()) + }) + } + + /// Pop stash if cleanly applicable. + #[napi] + pub fn stash_try_pop(&self, reinstate_index: bool, signal: Option) -> Promise { + blocking("vcs.stashTryPop", self.inner.clone(), signal, move |r| { + r.stash_try_pop(reinstate_index) + }) + } + + /// Push via Git CLI. + #[napi(ts_return_type = "Promise")] + pub fn push<'e>( + &self, + options: VcsPushOptions, + signal: Option, + env: &'e Env, + ) -> Result> { + let repo = self.inner.clone(); + let options = options.into(); + let cancel = cancellation_token(signal); + vcs_future(env, "vcs.push", async move { repo.push(&options, cancel).await }) + } + + /// Fetch a refspec via Git CLI. + #[napi(ts_return_type = "Promise")] + pub fn fetch<'e>( + &self, + remote: String, + source: String, + target: String, + timeout_ms: Option, + signal: Option, + env: &'e Env, + ) -> Result> { + let repo = self.inner.clone(); + let cancel = cancellation_token(signal); + vcs_future(env, "vcs.fetch", async move { + repo + .fetch( + &remote, + &source, + &target, + timeout_ms.map(|v| Duration::from_millis(u64::from(v))), + cancel, + ) + .await + }) + } +} + +/// Clone a Git repository. +#[napi(ts_return_type = "Promise")] +pub fn vcs_git_clone<'e>( + env: &'e Env, + url: String, + target: String, + options: VcsCloneOptions, + signal: Option, +) -> Result> { + let options = options.into(); + let cancel = cancellation_token(signal); + vcs_future(env, "vcs.clone", async move { + pi_vcs::git::clone(&url, Path::new(&target), &options, cancel).await + }) +} +/// Detach copied Git metadata. +#[napi] +pub fn vcs_detach_git_dir( + worktree_root: String, + source_common_dir: String, + signal: Option, +) -> Promise { + let ct = task::CancelToken::new(None, signal); + task::blocking_mapped("vcs.detachGitDir", ct, rich_error, move |ct| { + if ct.heartbeat().is_err() { + return Err(pi_vcs::Error::Canceled); + } + pi_vcs::git::detach_git_dir(Path::new(&worktree_root), Path::new(&source_common_dir)).map( + |v| { + match v { + core::DetachGitDirResult::NoGit => "no-git", + core::DetachGitDirResult::Independent => "independent", + core::DetachGitDirResult::Detached => "detached", + } + .into() + }, + ) + }) +} +/// Join patch fragments. +#[napi] +pub fn vcs_join_patches(parts: Vec) -> String { + pi_vcs::git::join_patches(&parts) +} +/// Validate hunk selections. +#[napi] +pub fn vcs_validate_hunk_selections( + raw_diff: String, + selections: Vec, +) -> Vec { + let selections: Vec<_> = selections + .into_iter() + .filter_map(|v| v.try_into().ok()) + .collect(); + pi_vcs::git::validate_hunk_selections(&raw_diff, &selections) + .into_iter() + .map(|v| VcsHunkSelectionError { path: v.path, message: v.message }) + .collect() +} +/// Test whether a directory is a pure jj workspace. +#[napi] +pub fn vcs_is_pure_jj(env: Env, dir: String) -> Result { + pi_vcs::is_pure_jj(Path::new(&dir)).map_err(|err| rich_error(env, err)) +} + +/// In-process Jujutsu workspace handle. +#[napi] +pub struct VcsJjWorkspace { + inner: Arc, +} +/// Discover a Jujutsu workspace. +#[napi] +pub fn vcs_jj_discover(env: Env, dir: String) -> Result> { + pi_vcs::jj::JjWorkspace::discover(Path::new(&dir)) + .map(|v| v.map(|inner| VcsJjWorkspace { inner: Arc::new(inner) })) + .map_err(|err| rich_error(env, err)) +} +fn jj_blocking( + tag: &'static str, + ws: Arc, + signal: Option, + f: impl FnOnce(&pi_vcs::jj::JjWorkspace) -> pi_vcs::Result + Send + 'static, +) -> Promise { + let ct = task::CancelToken::new(None, signal); + task::blocking_mapped(tag, ct, rich_error, move |ct| { + if ct.heartbeat().is_err() { + return Err(pi_vcs::Error::Canceled); + } + f(&ws) + }) +} +#[napi] +impl VcsJjWorkspace { + /// Workspace root. + #[napi] + pub fn root(&self) -> String { + path_string(self.inner.root()) + } + + /// Shared store directory. + #[napi] + pub fn store_dir(&self) -> String { + path_string(self.inner.store_dir()) + } + + /// Working-copy label. + #[napi] + pub fn working_copy_label(&self, signal: Option) -> Promise> { + jj_blocking("vcs.jjWorkingCopyLabel", self.inner.clone(), signal, |w| w.working_copy_label()) + } + + /// Status counts. + #[napi] + pub fn status_summary(&self, signal: Option) -> Promise { + jj_blocking("vcs.jjStatusSummary", self.inner.clone(), signal, |w| { + w.status_summary().map(Into::into) + }) + } + + /// Render working-copy patch. + #[napi] + pub fn diff_text( + &self, + files: Vec, + snapshot: bool, + signal: Option, + ) -> Promise { + jj_blocking("vcs.jjDiffText", self.inner.clone(), signal, move |w| { + w.diff_text(&files, snapshot) + }) + } + + /// List changed paths. + #[napi] + pub fn changed_files( + &self, + files: Vec, + snapshot: bool, + signal: Option, + ) -> Promise> { + jj_blocking("vcs.jjChangedFiles", self.inner.clone(), signal, move |w| { + w.changed_files(&files, snapshot) + }) + } +} diff --git a/crates/pi-shell/src/minimizer/filters/docker.rs b/crates/pi-shell/src/minimizer/filters/docker.rs index d6e81d2bdd0b..e1918e36d5e7 100644 --- a/crates/pi-shell/src/minimizer/filters/docker.rs +++ b/crates/pi-shell/src/minimizer/filters/docker.rs @@ -1240,7 +1240,7 @@ mod tests { let out = filter(&kubectl_ctx, input, 0).text; // Falls back — table compaction would try to process this // The key is: doesn't crash, doesn't lose data - assert!(!out.is_empty()); + assert_ne!(out, ""); } #[test] diff --git a/crates/pi-shell/src/shell.rs b/crates/pi-shell/src/shell.rs index cb0cc0e4c1c4..d0bc66d8c391 100644 --- a/crates/pi-shell/src/shell.rs +++ b/crates/pi-shell/src/shell.rs @@ -2131,7 +2131,7 @@ mod tests { assert_eq!(pgrep_result.exit_code, Some(0)); assert_eq!(output, format!("{pid}\n")); assert_eq!(pkill_result.exit_code, Some(0)); - assert!(pkill_output.is_empty()); + assert_eq!(pkill_output, ""); assert!(still_running, "signal 0 must not terminate a matching process"); } @@ -2332,7 +2332,7 @@ mod tests { let _ = second.wait().await; } assert_eq!(result.exit_code, Some(0)); - assert!(output.is_empty()); + assert_eq!(output, ""); assert!(statuses.is_ok(), "pkill did not signal every matching process"); } @@ -2354,7 +2354,7 @@ mod tests { let _ = child.wait().await; } assert_eq!(result.exit_code, Some(0)); - assert!(output.is_empty()); + assert_eq!(output, ""); assert!(status.is_some(), "pidwait returned while its matching process was still running"); } @@ -3605,11 +3605,7 @@ mod tests { .await .expect("run_string head bad flag"); assert_ne!(exit_code(&bad), 0, "invalid flag should be a usage error"); - assert!( - !std::fs::read_to_string(tmp.join("err.txt")) - .expect("err.txt") - .is_empty() - ); + assert_ne!(std::fs::read_to_string(tmp.join("err.txt")).expect("err.txt"), ""); let _ = std::fs::remove_dir_all(&tmp); } diff --git a/crates/pi-shell/src/windows.rs b/crates/pi-shell/src/windows.rs index 4863d5a52a62..443a1b5a42f1 100644 --- a/crates/pi-shell/src/windows.rs +++ b/crates/pi-shell/src/windows.rs @@ -10,8 +10,7 @@ use brush_core::{Shell as BrushShell, ShellValue, ShellVariable}; use winreg::{RegKey, enums::HKEY_LOCAL_MACHINE}; pub fn configure_windows_path(shell: &mut BrushShell) -> Result<()> { - let install_roots = find_git_install_roots(); - let git_paths = find_git_paths(); + let GitDiscovery { install_roots, paths: git_paths } = discover_git(); if install_roots.is_empty() && git_paths.is_empty() { return Ok(()); } @@ -94,26 +93,43 @@ fn normalize_path(path: &Path) -> String { normalized.to_string_lossy().into_owned() } -fn find_git_paths() -> Vec { +struct GitDiscovery { + install_roots: Vec, + paths: Vec, +} + +fn discover_git() -> GitDiscovery { + discover_git_with(query_git_install_path_from_registry, query_git_install_path_from_where) +} + +fn discover_git_with(registry_query: R, where_query: W) -> GitDiscovery +where + R: FnOnce() -> Option, + W: FnOnce() -> Option, +{ + let registry_path = registry_query(); + let where_path = where_query(); + let mut install_roots = Vec::new(); let mut paths = Vec::new(); - let mut seen = HashSet::new(); + let mut seen_roots = HashSet::new(); + let mut seen_paths = HashSet::new(); - for install_path in [query_git_install_path_from_registry(), query_git_install_path_from_where()] - .into_iter() - .flatten() - { + for install_path in [registry_path, where_path].into_iter().flatten() { for path in git_paths_for_install_root(&install_path) { - let normalized = normalize_path(Path::new(&path)); - if normalized.is_empty() { - continue; - } - if seen.insert(normalized) { + let normalized_path = normalize_path(Path::new(&path)); + if !normalized_path.is_empty() && seen_paths.insert(normalized_path) { paths.push(path); } } + + let root = PathBuf::from(&install_path); + let normalized_root = normalize_path(&root); + if !normalized_root.is_empty() && seen_roots.insert(normalized_root) { + install_roots.push(root); + } } - paths + GitDiscovery { install_roots, paths } } fn query_git_install_path_from_registry() -> Option { @@ -206,25 +222,6 @@ fn has_git_command(dir: &Path) -> bool { .any(|name| dir.join(name).is_file()) } -fn find_git_install_roots() -> Vec { - let mut roots = Vec::new(); - let mut seen = HashSet::new(); - for install_path in [query_git_install_path_from_registry(), query_git_install_path_from_where()] - .into_iter() - .flatten() - { - let path = PathBuf::from(install_path); - let normalized = normalize_path(&path); - if normalized.is_empty() { - continue; - } - if seen.insert(normalized) { - roots.push(path); - } - } - roots -} - /// Translate an MSYS2/Git Bash style path entry (e.g. `/usr/bin`, /// `/mingw64/bin`, `/c/Users/foo`) into a Windows-native path so that /// `std::path` based executable lookups in brush-core can resolve binaries @@ -283,8 +280,130 @@ fn is_windows_style_path(value: &str) -> bool { #[cfg(test)] mod tests { + use std::{cell::Cell, fs}; + use super::*; + fn git_install_fixture() -> tempfile::TempDir { + let root = tempfile::tempdir().expect("Git installation fixture"); + let cmd = root.path().join("cmd"); + let bin = root.path().join("bin"); + let usr_bin = root.path().join("usr").join("bin"); + for path in [&cmd, &bin, &usr_bin] { + fs::create_dir_all(path).expect("Git path fixture"); + } + fs::write(cmd.join("git.exe"), []).expect("cmd Git fixture"); + fs::write(bin.join("git.exe"), []).expect("bin Git fixture"); + fs::write(usr_bin.join("ls.exe"), []).expect("usr/bin fixture"); + root + } + + #[test] + fn git_discovery_queries_each_source_once_per_invocation_and_remains_fresh() { + let registry_calls = Cell::new(0); + let where_calls = Cell::new(0); + + for _ in 0..2 { + let discovery = discover_git_with( + || { + registry_calls.set(registry_calls.get() + 1); + None + }, + || { + where_calls.set(where_calls.get() + 1); + None + }, + ); + assert!(discovery.install_roots.is_empty()); + assert!(discovery.paths.is_empty()); + } + + assert_eq!(registry_calls.get(), 2); + assert_eq!(where_calls.get(), 2); + } + + #[test] + fn git_discovery_preserves_provider_and_candidate_order() { + let registry_root = git_install_fixture(); + let where_root = git_install_fixture(); + let registry_path = registry_root.path().to_string_lossy().into_owned(); + let where_path = where_root.path().to_string_lossy().into_owned(); + + let discovery = discover_git_with(|| Some(registry_path), || Some(where_path)); + + assert_eq!(discovery.install_roots, vec![ + registry_root.path().to_path_buf(), + where_root.path().to_path_buf() + ]); + assert_eq!(discovery.paths, vec![ + registry_root + .path() + .join("cmd") + .to_string_lossy() + .into_owned(), + registry_root + .path() + .join("bin") + .to_string_lossy() + .into_owned(), + registry_root + .path() + .join("usr") + .join("bin") + .to_string_lossy() + .into_owned(), + where_root.path().join("cmd").to_string_lossy().into_owned(), + where_root.path().join("bin").to_string_lossy().into_owned(), + where_root + .path() + .join("usr") + .join("bin") + .to_string_lossy() + .into_owned(), + ]); + } + + #[test] + fn git_discovery_deduplicates_the_same_installation_from_both_sources() { + let root = git_install_fixture(); + let registry_path = root.path().to_string_lossy().into_owned(); + let where_path = registry_path.clone(); + + let discovery = discover_git_with(|| Some(registry_path), || Some(where_path)); + + assert_eq!(discovery.install_roots, vec![root.path().to_path_buf()]); + assert_eq!(discovery.paths, vec![ + root.path().join("cmd").to_string_lossy().into_owned(), + root.path().join("bin").to_string_lossy().into_owned(), + root + .path() + .join("usr") + .join("bin") + .to_string_lossy() + .into_owned(), + ]); + } + + #[test] + fn git_discovery_keeps_valid_candidates_when_duplicate_root_spellings_differ() { + let root = git_install_fixture(); + let clean_path = root.path().to_string_lossy().into_owned(); + let decorated_path = format!(" \"{clean_path}\" "); + + let discovery = discover_git_with(|| Some(decorated_path), || Some(clean_path)); + + assert_eq!(discovery.paths, vec![ + root.path().join("cmd").to_string_lossy().into_owned(), + root.path().join("bin").to_string_lossy().into_owned(), + root + .path() + .join("usr") + .join("bin") + .to_string_lossy() + .into_owned(), + ]); + } + #[test] fn drive_letter_segments_translate_to_windows_paths() { assert_eq!(translate_msys_segment("/c/Users/foo", &[]).as_deref(), Some("C:\\Users\\foo"),); diff --git a/crates/pi-vcs/BUILD.bazel b/crates/pi-vcs/BUILD.bazel new file mode 100644 index 000000000000..e52a41dda634 --- /dev/null +++ b/crates/pi-vcs/BUILD.bazel @@ -0,0 +1,25 @@ +load("@crates//:defs.bzl", "aliases", "all_crate_deps") +load("@rules_rust//rust:defs.bzl", "rust_library", "rust_test") + +package(default_visibility = ["//visibility:public"]) + +exports_files(["Cargo.toml"]) + +rust_library( + name = "pi-vcs", + srcs = glob(["src/**/*.rs"]), + aliases = aliases(), + crate_name = "pi_vcs", + edition = "2024", + proc_macro_deps = all_crate_deps(proc_macro = True), + version = "17.1.5", + deps = all_crate_deps(normal = True), +) + +rust_test( + name = "pi-vcs_test", + crate = ":pi-vcs", + edition = "2024", + proc_macro_deps = all_crate_deps(proc_macro_dev = True), + deps = all_crate_deps(normal_dev = True), +) diff --git a/crates/pi-vcs/Cargo.toml b/crates/pi-vcs/Cargo.toml new file mode 100644 index 000000000000..1614155c28ef --- /dev/null +++ b/crates/pi-vcs/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "pi-vcs" +version.workspace = true +edition.workspace = true +license = "MIT" +authors.workspace = true +repository.workspace = true + +[lints] +workspace = true + +[dependencies] +gix.workspace = true +jj-lib.workspace = true +thiserror.workspace = true +tokio.workspace = true +tokio-util.workspace = true + +[target.'cfg(unix)'.dependencies] +libc.workspace = true + +[dev-dependencies] +tempfile = "3" diff --git a/crates/pi-vcs/src/error.rs b/crates/pi-vcs/src/error.rs new file mode 100644 index 000000000000..81ecb5540f1a --- /dev/null +++ b/crates/pi-vcs/src/error.rs @@ -0,0 +1,154 @@ +//! Error type shared by the git and jj backends. +//! +//! Failure modes that TypeScript callers previously detected by regexing +//! subprocess stderr (e.g. an empty cherry-pick) are first-class variants here +//! so the TS layer can match on a structured `kind` instead of message text. + +use std::path::PathBuf; + +/// Crate-wide result alias. +pub type Result = std::result::Result; + +/// Unified error for all VCS operations. +#[derive(Debug, thiserror::Error)] +pub enum Error { + /// The directory is not inside a git repository / jj workspace. + #[error("not a repository: {path}")] + NotARepository { + /// Directory the lookup started from. + path: PathBuf, + }, + + /// A named ref (branch, tag, `refs/...`) does not exist. + #[error("reference not found: {name}")] + RefNotFound { + /// The ref name as given by the caller. + name: String, + }, + + /// A revision/object lookup failed (`rev-parse` style spec, blob path, + /// tree). + #[error("object not found: {spec}")] + ObjectNotFound { + /// The revision or object spec as given by the caller. + spec: String, + }, + + /// Cherry-picking `sha` produced an empty commit (already applied or + /// auto-resolved to HEAD). Callers should skip and continue the range — + /// replaces the historical `/the previous cherry-pick is now empty/` stderr + /// regex. + #[error("cherry-pick of {sha} is empty")] + EmptyCherryPick { + /// The commit that collapsed to a no-op. + sha: String, + }, + + /// A merge-style operation (cherry-pick, stash pop, 3-way apply) hit + /// conflicting changes. + #[error("merge conflict in {} file(s)", paths.len())] + Conflict { + /// Worktree-relative paths left in a conflicted state. + paths: Vec, + }, + + /// A patch did not apply (context mismatch, missing file, malformed input). + #[error("patch does not apply: {message}")] + PatchFailed { + /// Human-readable reason, including the offending path when known. + message: String, + }, + + /// A CLI-backed operation (push/fetch/clone, reftable fallback) exited + /// non-zero. Carries the captured streams for user-facing error surfaces. + #[error("{}", crate::error::cli_message(command, *exit_code, stdout, stderr))] + Cli { + /// Rendered command line (`git push --no-follow-tags …`). + command: String, + /// Process exit code. + exit_code: i32, + /// Captured stdout (may be truncated). + stdout: String, + /// Captured stderr (may be truncated). + stderr: String, + }, + + /// A CLI-backed operation exceeded its deadline and was killed. + #[error("timed out: {command}")] + CliTimeout { + /// Rendered command line. + command: String, + }, + + /// Filesystem error outside any more specific failure mode. + #[error(transparent)] + Io(#[from] std::io::Error), + + /// An underlying gix / jj-lib failure that has no dedicated variant. + #[error("{context}: {message}")] + Backend { + /// Operation being performed (`"git status"`, `"jj snapshot"`, …). + context: &'static str, + /// Backend error rendered as text (full source chain). + message: String, + }, + + /// The operation was canceled via its interrupt flag. + #[error("operation canceled")] + Canceled, + /// The operation has no implementation on this backend (e.g. staged diffs + /// on a Jujutsu workspace, which has no index). + #[error( + "`{operation}` is not supported on a {} repository", + match backend { + crate::VcsKind::Git => "git", + crate::VcsKind::Jj => "jj", + } + )] + Unsupported { + /// Operation or feature name as exposed to JS (camelCase). + operation: &'static str, + /// Backend that lacks it. + backend: crate::VcsKind, + }, +} + +impl Error { + /// Wrap an arbitrary backend error with the operation it occurred in. + pub fn backend(context: &'static str, err: impl std::fmt::Display) -> Self { + Self::Backend { context, message: err.to_string() } + } + + /// Stable machine-readable discriminant for this failure, used as the + /// `code` property on errors crossing the N-API boundary. + pub const fn kind(&self) -> &'static str { + match self { + Self::NotARepository { .. } => "NotARepository", + Self::RefNotFound { .. } => "RefNotFound", + Self::ObjectNotFound { .. } => "ObjectNotFound", + Self::EmptyCherryPick { .. } => "EmptyCherryPick", + Self::Conflict { .. } => "Conflict", + Self::PatchFailed { .. } => "PatchFailed", + Self::Cli { .. } => "Cli", + Self::CliTimeout { .. } => "CliTimeout", + Self::Io(_) => "Io", + Self::Backend { .. } => "Backend", + Self::Canceled => "Canceled", + Self::Unsupported { .. } => "Unsupported", + } + } +} + +/// Format a CLI failure the way the TS wrapper did: prefer stderr, then +/// stdout, then a generic exit-code message. +pub(crate) fn cli_message(command: &str, exit_code: i32, stdout: &str, stderr: &str) -> String { + let stderr = stderr.trim(); + if !stderr.is_empty() { + return stderr.to_owned(); + } + let stdout = stdout.trim(); + if !stdout.is_empty() { + return stdout.to_owned(); + } + format!("{command} failed with exit code {exit_code}") +} diff --git a/crates/pi-vcs/src/git/cli.rs b/crates/pi-vcs/src/git/cli.rs new file mode 100644 index 000000000000..f04672ee7e04 --- /dev/null +++ b/crates/pi-vcs/src/git/cli.rs @@ -0,0 +1,432 @@ +//! The deliberately small git-CLI escape hatch. +//! +//! Two categories are allowed to spawn `git`, per the hybrid policy: +//! - **Credential-bound network transfers** — clone/fetch/push must reuse the +//! user's ssh config and credential helpers, which are subprocess-based by +//! design; no library reaches auth parity (and gitoxide has no send-pack). +//! - **Reftable ref access** — no in-process reftable implementation exists. +//! +//! The runner ports the hardened subprocess contract of the TS wrapper: +//! non-interactive env (`GIT_TERMINAL_PROMPT=0`, askpass rejection, `LC_ALL` +//! handling), `--no-optional-locks` for reads, fsmonitor/untracked-cache +//! disabled, ambient `GIT_DIR`-family vars stripped, bounded output capture, +//! and deadline + SIGTERM→SIGKILL termination via tokio. + +use std::{path::Path, process::Stdio, time::Duration}; + +use tokio::io::AsyncReadExt; +use tokio_util::sync::CancellationToken; + +use super::GitRepo; +use crate::{ + error::{Error, Result}, + types::{CloneOptions, PushOptions}, +}; + +/// Default deadline for local git plumbing via the fallback runner. +pub const COMMAND_TIMEOUT: Duration = Duration::from_mins(5); +/// Default deadline for network transfers (`clone`/`fetch`/`push`); large-repo +/// transfers legitimately outlive [`COMMAND_TIMEOUT`]. +pub const NETWORK_TIMEOUT: Duration = Duration::from_mins(30); +/// Deadline for synchronous plumbing on render paths (reftable HEAD reads): +/// a stalled invocation degrades instead of freezing the UI. +pub const SYNC_TIMEOUT: Duration = Duration::from_secs(5); +/// Maximum captured bytes per stream before truncation. +pub const OUTPUT_LIMIT_BYTES: usize = 8 * 1024 * 1024; + +const TERMINATE_GRACE: Duration = Duration::from_secs(5); +const TRUNCATION_MARKER: &str = "\n[git subprocess output truncated after 8 MiB]\n"; + +/// Captured result of a completed git invocation. +#[derive(Debug, Clone)] +pub(crate) struct CliOutput { + /// Process exit code (`124` designates a deadline kill). + pub exit_code: i32, + /// Captured stdout, possibly truncated. + pub stdout: String, + /// Captured stderr, possibly truncated. + pub stderr: String, +} + +impl CliOutput { + /// Convert a non-zero exit into [`Error::Cli`]. + pub fn into_checked(self, args: &[String]) -> Result { + if self.exit_code == 0 { + return Ok(self); + } + Err(Error::Cli { + command: format!("git {}", args.join(" ")), + exit_code: self.exit_code, + stdout: self.stdout, + stderr: self.stderr, + }) + } +} + +/// Options for one fallback invocation. +#[derive(Debug, Default)] +pub(crate) struct RunOptions { + /// Prefix `--no-optional-locks` and pin lock-free config for reads. + pub read_only: bool, + /// Deadline; [`COMMAND_TIMEOUT`] when unset. + pub timeout: Option, + /// Bytes piped to stdin (commit messages, `update-ref --stdin` scripts). + pub stdin: Option>, + /// Cooperative cancellation: the child is terminated when triggered. + pub cancel: Option, +} + +/// Build the hardened argv prefix: short-lived config pins that stop a +/// transient subprocess from mutating fsmonitor/untracked-cache state. +fn hardened_args(args: &[String], read_only: bool) -> Vec { + let mut out = Vec::with_capacity(args.len() + 5); + for pin in ["core.fsmonitor=false", "core.untrackedCache=false"] { + out.push("-c".to_owned()); + out.push(pin.to_owned()); + } + if read_only && !args.iter().any(|arg| arg == "--no-optional-locks") { + out.push("--no-optional-locks".to_owned()); + } + out.extend(args.iter().cloned()); + out +} + +/// Apply the non-interactive environment contract to a command builder: +/// prompts rejected, editors disabled, ambient repo-location overrides +/// stripped, `LC_MESSAGES=C` for parseable errors while preserving a UTF-8 +/// character locale. +fn apply_env(cmd: &mut tokio::process::Command) { + for stripped in [ + "GIT_DIR", + "GIT_COMMON_DIR", + "GIT_WORK_TREE", + "GIT_INDEX_FILE", + "GIT_OBJECT_DIRECTORY", + "GIT_ALTERNATE_OBJECT_DIRECTORIES", + ] { + cmd.env_remove(stripped); + } + if let Some(lc_all) = std::env::var_os("LC_ALL") { + let lc_all = lc_all.to_string_lossy().into_owned(); + if is_utf8_locale(&lc_all) { + cmd.env("LC_CTYPE", lc_all); + } + } + cmd.env_remove("LC_ALL"); + cmd.env("LC_MESSAGES", "C"); + cmd.env("GIT_OPTIONAL_LOCKS", "0"); + cmd.env("GIT_ASKPASS", "true"); + cmd.env("GIT_EDITOR", "true"); + cmd.env("GIT_TERMINAL_PROMPT", "0"); + cmd.env("SSH_ASKPASS", "false"); +} + +/// Loose match for a UTF-8 character locale (`en_US.UTF-8`, `C.utf8`, …). +fn is_utf8_locale(value: &str) -> bool { + let lower = value.to_ascii_lowercase(); + ["utf-8", "utf8"].iter().any(|needle| { + lower + .split(['.', '_', '-', '@']) + .any(|part| part == *needle) + || lower.ends_with(needle) + || lower.contains(&format!(".{needle}")) + }) +} + +/// Run `git` asynchronously with bounded capture and a deadline. +/// Non-zero exits are returned in [`CliOutput`], not raised. +pub(crate) async fn run(cwd: &Path, args: &[String], options: &RunOptions) -> Result { + let argv = hardened_args(args, options.read_only); + let mut cmd = tokio::process::Command::new("git"); + cmd.args(&argv) + .current_dir(cwd) + .stdin(if options.stdin.is_some() { + Stdio::piped() + } else { + Stdio::null() + }) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()) + .kill_on_drop(true); + apply_env(&mut cmd); + let mut child = cmd.spawn().map_err(|err| spawn_error(cwd, err))?; + + if let Some(stdin) = &options.stdin + && let Some(mut pipe) = child.stdin.take() + { + use tokio::io::AsyncWriteExt; + // A child that exits early (e.g. usage error) closes the pipe; + // that is its answer, not ours to fail on. + let _ = pipe.write_all(stdin).await; + let _ = pipe.shutdown().await; + } + + let stdout = child.stdout.take().expect("stdout piped"); + let stderr = child.stderr.take().expect("stderr piped"); + let stdout_task = tokio::spawn(read_capped(stdout)); + let stderr_task = tokio::spawn(read_capped(stderr)); + + let timeout = options.timeout.unwrap_or(COMMAND_TIMEOUT); + let cancel = options.cancel.clone().unwrap_or_default(); + let exit = tokio::select! { + status = tokio::time::timeout(timeout, child.wait()) => match status { + Ok(status) => status.map_err(Error::Io)?, + Err(_elapsed) => { + terminate(&mut child).await; + stdout_task.abort(); + stderr_task.abort(); + return Err(Error::CliTimeout { command: format!("git {}", argv.join(" ")) }); + }, + }, + () = cancel.cancelled() => { + terminate(&mut child).await; + stdout_task.abort(); + stderr_task.abort(); + return Err(Error::Canceled); + }, + }; + + let stdout = stdout_task + .await + .map_err(|err| Error::backend("git run", err))??; + let stderr = stderr_task + .await + .map_err(|err| Error::backend("git run", err))??; + Ok(CliOutput { exit_code: exit.code().unwrap_or(-1), stdout, stderr }) +} + +/// Run `git` asynchronously and map a non-zero exit to [`Error::Cli`]. +pub(crate) async fn run_checked( + cwd: &Path, + args: &[String], + options: &RunOptions, +) -> Result { + run(cwd, args, options).await?.into_checked(args) +} + +/// Synchronous bounded runner for render paths (reftable ref reads). Enforces +/// [`SYNC_TIMEOUT`] by polling so a stalled git cannot freeze rendering. +pub(crate) fn run_sync(cwd: &Path, args: &[String]) -> Result { + let argv = hardened_args(args, true); + let mut cmd = std::process::Command::new("git"); + cmd.args(&argv) + .current_dir(cwd) + .stdin(Stdio::null()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + // The sync and async builders expose the same env API surface; reuse the + // async configurator through a tokio wrapper would allocate a runtime, so + // mirror the pins directly. + for stripped in [ + "GIT_DIR", + "GIT_COMMON_DIR", + "GIT_WORK_TREE", + "GIT_INDEX_FILE", + "GIT_OBJECT_DIRECTORY", + "GIT_ALTERNATE_OBJECT_DIRECTORIES", + ] { + cmd.env_remove(stripped); + } + cmd.env("LC_MESSAGES", "C"); + cmd.env("GIT_OPTIONAL_LOCKS", "0"); + cmd.env("GIT_TERMINAL_PROMPT", "0"); + let mut child = cmd.spawn().map_err(|err| spawn_error(cwd, err))?; + + let deadline = std::time::Instant::now() + SYNC_TIMEOUT; + loop { + match child.try_wait()? { + Some(status) => { + let output = child.wait_with_output()?; + return Ok(CliOutput { + exit_code: status.code().unwrap_or(-1), + stdout: String::from_utf8_lossy(&output.stdout).into_owned(), + stderr: String::from_utf8_lossy(&output.stderr).into_owned(), + }); + }, + None if std::time::Instant::now() >= deadline => { + let _ = child.kill(); + let _ = child.wait(); + return Err(Error::CliTimeout { command: format!("git {}", argv.join(" ")) }); + }, + None => std::thread::sleep(Duration::from_millis(10)), + } + } +} + +fn spawn_error(cwd: &Path, err: std::io::Error) -> Error { + if err.kind() == std::io::ErrorKind::NotFound { + // A deleted cwd also surfaces as spawn ENOENT; only blame the binary + // when the working directory actually exists. + let message = if cwd.exists() { + "git is not installed.".to_owned() + } else { + format!("working directory does not exist: {}", cwd.display()) + }; + return Error::backend("git spawn", message); + } + Error::Io(err) +} + +/// Read a stream to completion, capping retention at [`OUTPUT_LIMIT_BYTES`] +/// while continuing to drain so the child never blocks on a full pipe. +async fn read_capped(mut stream: impl tokio::io::AsyncRead + Unpin) -> Result { + let mut retained: Vec = Vec::new(); + let mut buf = [0u8; 8 * 1024]; + let mut truncated = false; + loop { + let n = stream.read(&mut buf).await.map_err(Error::Io)?; + if n == 0 { + break; + } + if truncated { + continue; + } + let remaining = OUTPUT_LIMIT_BYTES - retained.len(); + if n <= remaining { + retained.extend_from_slice(&buf[..n]); + } else { + retained.extend_from_slice(&buf[..remaining]); + truncated = true; + } + } + let mut text = String::from_utf8_lossy(&retained).into_owned(); + if truncated { + text.push_str(TRUNCATION_MARKER); + } + Ok(text) +} + +/// SIGTERM, grace period, then SIGKILL. +async fn terminate(child: &mut tokio::process::Child) { + #[cfg(unix)] + if let Some(pid) = child.id() { + // SAFETY: plain kill(2) on a pid we own; no memory is touched. + unsafe { + libc::kill(pid as i32, libc::SIGTERM); + } + if tokio::time::timeout(TERMINATE_GRACE, child.wait()) + .await + .is_ok() + { + return; + } + } + let _ = child.kill().await; + let _ = tokio::time::timeout(TERMINATE_GRACE, child.wait()).await; +} + +// ═══════════════════════════════════════════════════════════════════════════ +// Network operations (public API) +// ═══════════════════════════════════════════════════════════════════════════ + +impl GitRepo { + /// Push the current branch (branch-scoped: never follows tags). + /// + /// `--no-follow-tags` overrides a user's `push.followTags = true`, which + /// would otherwise ride every reachable annotated tag along with the + /// branch — rejected refs on remotes the user cannot tag (e.g. PR-head + /// forks) would fail the call after the branch itself already updated. + pub async fn push( + &self, + options: &PushOptions, + cancel: Option, + ) -> Result<()> { + let mut args = vec!["push".to_owned(), "--no-follow-tags".to_owned()]; + if options.force_with_lease { + args.push("--force-with-lease".to_owned()); + } + if let Some(remote) = &options.remote { + args.push(remote.clone()); + } + if let Some(refspec) = &options.refspec { + args.push(refspec.clone()); + } + run_checked(self.root(), &args, &RunOptions { + timeout: Some(NETWORK_TIMEOUT), + cancel, + ..RunOptions::default() + }) + .await?; + Ok(()) + } + + /// Fetch `+source:target` from a remote. + pub async fn fetch( + &self, + remote: &str, + source: &str, + target: &str, + timeout: Option, + cancel: Option, + ) -> Result<()> { + let args = vec!["fetch".to_owned(), remote.to_owned(), format!("+{source}:{target}")]; + run_checked(self.root(), &args, &RunOptions { + timeout: Some(timeout.unwrap_or(NETWORK_TIMEOUT)), + cancel, + ..RunOptions::default() + }) + .await?; + Ok(()) + } +} + +/// Clone `url` into `target_dir`, removing the partial clone on any failure. +/// +/// Shallow (`--depth 1 --single-branch`) unless a specific SHA is pinned: +/// a shallow clone only fetches the tip, so checking out a non-tip commit +/// would fail with "reference is not a tree". +pub async fn clone( + url: &str, + target_dir: &Path, + options: &CloneOptions, + cancel: Option, +) -> Result<()> { + let absolute = std::path::absolute(target_dir)?; + let parent = absolute + .parent() + .map_or_else(|| absolute.clone(), Path::to_owned); + tokio::fs::create_dir_all(&parent).await?; + + let shallow = options.sha.is_none(); + let mut args = vec!["clone".to_owned()]; + if shallow { + args.push("--depth".to_owned()); + args.push("1".to_owned()); + } + if let Some(ref_name) = &options.ref_name { + args.push("--branch".to_owned()); + args.push(ref_name.clone()); + args.push("--single-branch".to_owned()); + } else if shallow { + args.push("--single-branch".to_owned()); + } + args.push(url.to_owned()); + args.push(absolute.to_string_lossy().into_owned()); + + let run_options = RunOptions { + timeout: Some(options.timeout.unwrap_or(NETWORK_TIMEOUT)), + cancel: cancel.clone(), + ..RunOptions::default() + }; + let outcome = run_checked(&parent, &args, &run_options).await; + if let Err(err) = outcome { + let _ = tokio::fs::remove_dir_all(&absolute).await; + return Err(err); + } + + if let Some(sha) = &options.sha { + let checkout = run_checked(&absolute, &["checkout".to_owned(), sha.clone()], &RunOptions { + cancel, + ..RunOptions::default() + }) + .await; + if checkout.is_err() { + let _ = tokio::fs::remove_dir_all(&absolute).await; + return Err(Error::backend( + "git clone", + format!("failed to checkout SHA {sha} in cloned repository {url}"), + )); + } + } + Ok(()) +} diff --git a/crates/pi-vcs/src/git/diff.rs b/crates/pi-vcs/src/git/diff.rs new file mode 100644 index 000000000000..4dbc3f8d21e5 --- /dev/null +++ b/crates/pi-vcs/src/git/diff.rs @@ -0,0 +1,1551 @@ +//! Git-compatible patch generation. + +use std::{fmt::Write as _, io::Write as _, path::Path}; + +use gix::bstr::{BStr, BString, ByteSlice}; + +use super::{ + GitRepo, + open::{load_index_or_empty, status_with_fresh_index}, +}; +use crate::{ + error::{Error, Result}, + types::{DiffOptions, NumstatEntry, ShowResult}, +}; + +#[derive(Clone)] +struct FileChange { + old_path: String, + new_path: String, + old_id: gix::ObjectId, + new_id: gix::ObjectId, + old_mode: Option, + new_mode: Option, + similarity: Option, + worktree_new: bool, +} + +struct Rendered { + text: String, + added: Option, + removed: Option, +} + +impl GitRepo { + /// Render changes as a git patch. + pub fn diff_text(&self, options: &DiffOptions) -> Result { + let repo = self.gix()?; + let changes = collect_changes(&repo, options)?; + render_changes(&repo, &changes, options.context.unwrap_or(3), options.binary) + .map(|rendered| rendered.into_iter().map(|item| item.text).collect()) + } + + /// Return changed paths, using the destination path for renames. + pub fn changed_files(&self, options: &DiffOptions) -> Result> { + let repo = self.gix()?; + Ok(collect_changes(&repo, options)? + .into_iter() + .map(|change| change.new_path) + .collect()) + } + + /// Return per-file line counts, with no counts for binary files. + pub fn numstat(&self, options: &DiffOptions) -> Result> { + let repo = self.gix()?; + let changes = collect_changes(&repo, options)?; + let rendered = render_changes(&repo, &changes, 0, false)?; + Ok(changes + .into_iter() + .zip(rendered) + .map(|(change, rendered)| NumstatEntry { + path: change.new_path, + added: rendered.added, + removed: rendered.removed, + }) + .collect()) + } + + /// Return whether the selected comparison contains at least one change. + pub fn has_diff(&self, options: &DiffOptions) -> Result { + let repo = self.gix()?; + Ok(!collect_changes(&repo, options)?.is_empty()) + } + + /// Render the recursive patch between two revisions. + pub fn diff_tree(&self, base: &str, head: &str, binary: bool) -> Result { + self.diff_text(&DiffOptions { + base: Some(base.to_owned()), + head: Some(head.to_owned()), + binary, + ..DiffOptions::default() + }) + } + + /// Render a no-index patch between filesystem paths. + pub fn diff_no_index(&self, left: &Path, right: &Path, binary: bool) -> Result { + let repo = self.gix()?; + let left_file = read_no_index_file(self.root(), left)?; + let right_file = read_no_index_file(self.root(), right)?; + if left_file.is_none() && right_file.is_none() { + return Ok(String::new()); + } + let old_path = left_file + .as_ref() + .map_or_else(|| no_index_label(self.root(), right), |_| no_index_label(self.root(), left)); + let new_path = right_file + .as_ref() + .map_or_else(|| no_index_label(self.root(), left), |_| no_index_label(self.root(), right)); + let old_id = write_no_index_blob(&repo, left_file.as_ref())?; + let new_id = write_no_index_blob(&repo, right_file.as_ref())?; + let null = repo.object_hash().null(); + let change = FileChange { + old_path, + new_path, + old_id: old_id.unwrap_or(null), + new_id: new_id.unwrap_or(null), + old_mode: left_file.as_ref().map(|file| file.mode), + new_mode: right_file.as_ref().map(|file| file.mode), + similarity: None, + worktree_new: false, + }; + let mut cache = repo + .diff_resource_cache_for_tree_diff() + .map_err(|err| Error::backend("git diff --no-index", err))?; + render_change(&repo, &mut cache, &change, 3, binary).map(|rendered| rendered.text) + } + + /// Render a commit header and its patch against its first parent. + pub fn show_commit(&self, rev: &str, max_bytes: Option) -> Result { + let repo = self.gix()?; + let id = repo + .rev_parse_single(rev) + .map_err(|err| Error::backend("git show", err))?; + let object = id.object().map_err(|err| Error::backend("git show", err))?; + let commit = object + .peel_to_commit() + .map_err(|err| Error::backend("git show", err))?; + let decoded = commit + .decode() + .map_err(|err| Error::backend("git show", err))?; + let author = commit + .author() + .map_err(|err| Error::backend("git show", err))?; + let author_time = author + .time() + .map_err(|err| Error::backend("git show", err))?; + let mut text = format!( + "commit {}\nAuthor: {} <{}>\nDate: {}\n\n", + commit.id, + author.name, + author.email, + author_time.format_or_unix(gix::date::time::format::DEFAULT) + ); + for line in decoded.message.as_bstr().lines() { + text.push_str(" "); + text.push_str(&String::from_utf8_lossy(line)); + text.push('\n'); + } + text.push('\n'); + + let tree = commit + .tree() + .map_err(|err| Error::backend("git show", err))?; + let parent_tree = if let Some(id) = commit.parent_ids().next() { + let object = id.object().map_err(|err| Error::backend("git show", err))?; + let parent = object + .peel_to_commit() + .map_err(|err| Error::backend("git show", err))?; + Some( + parent + .tree() + .map_err(|err| Error::backend("git show", err))?, + ) + } else { + None + }; + let changes = tree_changes(&repo, parent_tree.as_ref(), Some(&tree), &[])?; + for rendered in render_changes(&repo, &changes, 3, false)? { + text.push_str(&rendered.text); + } + + let mut bytes = text.into_bytes(); + let truncated = max_bytes.is_some_and(|limit| bytes.len() > limit); + if let Some(limit) = max_bytes { + bytes.truncate(limit); + } + Ok(ShowResult { bytes, truncated }) + } +} + +fn collect_changes(repo: &gix::Repository, options: &DiffOptions) -> Result> { + if let Some(base) = options.base.as_deref() { + let old = revision_tree(repo, base)?; + if let Some(head) = options.head.as_deref() { + let new = revision_tree(repo, head)?; + return tree_changes(repo, Some(&old), Some(&new), &options.files); + } + return base_worktree_changes(repo, old.id, &options.files); + } + if options.cached { + return cached_changes(repo, &options.files); + } + worktree_changes(repo, &options.files) +} + +fn revision_tree<'repo>(repo: &'repo gix::Repository, rev: &str) -> Result> { + let id = repo + .rev_parse_single(rev) + .map_err(|err| Error::backend("git diff revision", err))?; + let object = id + .object() + .map_err(|err| Error::backend("git diff revision", err))?; + object + .peel_to_tree() + .map_err(|err| Error::backend("git diff revision", err)) +} + +fn tree_changes( + repo: &gix::Repository, + old: Option<&gix::Tree<'_>>, + new: Option<&gix::Tree<'_>>, + files: &[String], +) -> Result> { + let changes = repo + .diff_tree_to_tree(old, new, None) + .map_err(|err| Error::backend("git diff-tree", err))?; + let mut pathspec = make_pathspec(repo, files, false)?; + let null = repo.object_hash().null(); + let mut out = Vec::with_capacity(changes.len()); + for change in changes { + use gix::object::tree::diff::ChangeDetached; + let item = match change { + ChangeDetached::Addition { location, entry_mode, id, .. } => FileChange { + old_path: path_string(location.as_ref()), + new_path: path_string(location.as_ref()), + old_id: null, + new_id: id, + old_mode: None, + new_mode: Some(entry_mode), + similarity: None, + worktree_new: false, + }, + ChangeDetached::Deletion { location, entry_mode, id, .. } => FileChange { + old_path: path_string(location.as_ref()), + new_path: path_string(location.as_ref()), + old_id: id, + new_id: null, + old_mode: Some(entry_mode), + new_mode: None, + similarity: None, + worktree_new: false, + }, + ChangeDetached::Modification { + location, + previous_entry_mode, + previous_id, + entry_mode, + id, + } => FileChange { + old_path: path_string(location.as_ref()), + new_path: path_string(location.as_ref()), + old_id: previous_id, + new_id: id, + old_mode: Some(previous_entry_mode), + new_mode: Some(entry_mode), + similarity: None, + worktree_new: false, + }, + ChangeDetached::Rewrite { + source_location, + source_entry_mode, + source_id, + diff, + entry_mode, + id, + location, + copy, + .. + } => { + if copy { + continue; + } + FileChange { + old_path: path_string(source_location.as_ref()), + new_path: path_string(location.as_ref()), + old_id: source_id, + new_id: id, + old_mode: Some(source_entry_mode), + new_mode: Some(entry_mode), + similarity: Some( + diff.map_or(100, |stats| (stats.similarity * 100.0).floor() as u8), + ), + worktree_new: false, + } + }, + }; + if item + .old_mode + .or(item.new_mode) + .is_some_and(|mode| mode.kind() == gix::objs::tree::EntryKind::Tree) + { + continue; + } + if pathspec.as_mut().is_none_or(|spec| { + spec.is_included(item.old_path.as_bytes().as_bstr(), Some(false)) + || spec.is_included(item.new_path.as_bytes().as_bstr(), Some(false)) + }) { + out.push(item); + } + } + sort_changes(&mut out); + Ok(out) +} + +fn cached_changes(repo: &gix::Repository, files: &[String]) -> Result> { + let tree_id = repo + .head_tree_id_or_empty() + .map_err(|err| Error::backend("git diff --cached", err))?; + index_changes(repo, tree_id.detach(), files) +} + +fn index_changes( + repo: &gix::Repository, + tree_id: gix::ObjectId, + files: &[String], +) -> Result> { + let index = load_index_or_empty(repo, "git diff --cached")?; + let mut pathspec = make_pathspec(repo, files, false)?; + let mut out = Vec::new(); + repo + .tree_index_status( + &tree_id, + &index, + pathspec.as_mut(), + gix::status::tree_index::TrackRenames::AsConfigured, + |change, _, _| -> Result<_> { + out.push(index_change(repo, change.into_owned())?); + Ok(std::ops::ControlFlow::Continue(())) + }, + ) + .map_err(|err| Error::backend("git diff --cached", err))?; + sort_changes(&mut out); + Ok(out) +} + +fn base_worktree_changes( + repo: &gix::Repository, + base_tree: gix::ObjectId, + files: &[String], +) -> Result> { + let staged = index_changes(repo, base_tree, files)?; + let worktree = worktree_changes(repo, files)?; + let mut combined = std::collections::BTreeMap::new(); + for change in staged { + combined.insert(change.new_path.clone(), change); + } + for change in worktree { + if let Some(previous) = combined.get_mut(&change.old_path) { + previous.new_id = change.new_id; + previous.new_mode = change.new_mode; + previous.new_path = change.new_path; + previous.worktree_new = true; + } else { + combined.insert(change.new_path.clone(), change); + } + } + let mut out = combined + .into_values() + .filter(|change| change.old_id != change.new_id || change.old_mode != change.new_mode) + .collect::>(); + sort_changes(&mut out); + Ok(out) +} + +fn index_change(repo: &gix::Repository, change: gix::diff::index::Change) -> Result { + use gix::diff::index::ChangeRef; + let null = repo.object_hash().null(); + let result = match change { + ChangeRef::Addition { location, entry_mode, id, .. } => FileChange { + old_path: path_string(location.as_ref()), + new_path: path_string(location.as_ref()), + old_id: null, + new_id: id.into_owned(), + old_mode: None, + new_mode: index_mode(entry_mode)?, + similarity: None, + worktree_new: false, + }, + ChangeRef::Deletion { location, entry_mode, id, .. } => FileChange { + old_path: path_string(location.as_ref()), + new_path: path_string(location.as_ref()), + old_id: id.into_owned(), + new_id: null, + old_mode: index_mode(entry_mode)?, + new_mode: None, + similarity: None, + worktree_new: false, + }, + ChangeRef::Modification { + location, + previous_entry_mode, + previous_id, + entry_mode, + id, + .. + } => FileChange { + old_path: path_string(location.as_ref()), + new_path: path_string(location.as_ref()), + old_id: previous_id.into_owned(), + new_id: id.into_owned(), + old_mode: index_mode(previous_entry_mode)?, + new_mode: index_mode(entry_mode)?, + similarity: None, + worktree_new: false, + }, + ChangeRef::Rewrite { + source_location, + source_entry_mode, + source_id, + location, + entry_mode, + id, + copy, + .. + } => { + if copy { + return Err(Error::backend("git diff --cached", "unexpected copy tracking")); + } + let identical = source_id == id; + FileChange { + old_path: path_string(source_location.as_ref()), + new_path: path_string(location.as_ref()), + old_id: source_id.into_owned(), + new_id: id.into_owned(), + old_mode: index_mode(source_entry_mode)?, + new_mode: index_mode(entry_mode)?, + similarity: Some(if identical { 100 } else { u8::MAX }), + worktree_new: false, + } + }, + }; + Ok(result) +} + +fn worktree_changes(repo: &gix::Repository, files: &[String]) -> Result> { + let patterns = bstring_patterns(files); + let mut iter = status_with_fresh_index(repo, "git diff")? + .untracked_files(gix::status::UntrackedFiles::None) + .index_worktree_options_mut(|options| options.dirwalk_options = None) + .into_index_worktree_iter(patterns) + .map_err(|err| Error::backend("git diff", err))?; + let mut pending = Vec::new(); + for item in &mut iter { + let item = item.map_err(|err| Error::backend("git diff", err))?; + if let gix::status::index_worktree::Item::Modification { entry, rela_path, status, .. } = item + { + pending.push((entry, rela_path, status)); + } + } + + let (mut filter, filter_index) = repo + .filter_pipeline(None) + .map_err(|err| Error::backend("git diff filter", err))?; + let null = repo.object_hash().null(); + let mut out = Vec::with_capacity(pending.len()); + for (entry, path, status) in pending { + use gix::status::plumbing::index_as_worktree::{Change, EntryStatus}; + let mut old_id = entry.id; + let mut old_mode = index_mode(entry.mode)?; + let mut new_id = null; + let mut new_mode = None; + match status { + EntryStatus::Change(Change::Removed) => {}, + EntryStatus::Change(Change::Type { .. } | Change::Modification { .. }) => { + if let Some((id, kind, _)) = filter + .worktree_file_to_object(path.as_ref(), &filter_index) + .map_err(|err| Error::backend("git diff filter", err))? + { + new_id = id; + new_mode = Some(kind.into()); + } + }, + EntryStatus::IntentToAdd => { + old_id = null; + old_mode = None; + if let Some((id, kind, _)) = filter + .worktree_file_to_object(path.as_ref(), &filter_index) + .map_err(|err| Error::backend("git diff filter", err))? + { + new_id = id; + new_mode = Some(kind.into()); + } + }, + EntryStatus::Conflict { .. } + | EntryStatus::NeedsUpdate(_) + | EntryStatus::Change(Change::SubmoduleModification(_)) => continue, + } + if new_mode.is_some() && old_id == new_id && old_mode == new_mode { + continue; + } + let path = path_string(path.as_ref()); + out.push(FileChange { + old_path: path.clone(), + new_path: path, + old_id, + new_id, + old_mode, + new_mode, + similarity: None, + worktree_new: true, + }); + } + sort_changes(&mut out); + Ok(out) +} + +fn render_changes( + repo: &gix::Repository, + changes: &[FileChange], + context: u32, + binary_patch: bool, +) -> Result> { + let roots = if changes.iter().any(|change| change.worktree_new) { + gix::diff::blob::pipeline::WorktreeRoots { + old_root: None, + new_root: repo.workdir().map(std::path::Path::to_owned), + } + } else { + Default::default() + }; + let mut cache = repo + .diff_resource_cache(gix::diff::blob::pipeline::Mode::ToGit, roots) + .map_err(|err| Error::backend("git diff", err))?; + let mut out = Vec::with_capacity(changes.len()); + for change in changes { + out.push(render_change(repo, &mut cache, change, context, binary_patch)?); + cache.clear_resource_cache_keep_allocation(); + } + Ok(out) +} + +fn render_change( + repo: &gix::Repository, + cache: &mut gix::diff::blob::Platform, + change: &FileChange, + context: u32, + binary_patch: bool, +) -> Result { + let old_kind = change + .old_mode + .or(change.new_mode) + .ok_or_else(|| Error::backend("git diff", "change has no file mode"))? + .kind(); + let new_kind = change + .new_mode + .or(change.old_mode) + .ok_or_else(|| Error::backend("git diff", "change has no file mode"))? + .kind(); + cache + .set_resource( + change.old_id, + old_kind, + change.old_path.as_bytes().as_bstr(), + gix::diff::blob::ResourceKind::OldOrSource, + repo, + ) + .map_err(|err| Error::backend("git diff", err))?; + cache + .set_resource( + change.new_id, + new_kind, + change.new_path.as_bytes().as_bstr(), + gix::diff::blob::ResourceKind::NewOrDestination, + repo, + ) + .map_err(|err| Error::backend("git diff", err))?; + let prepared = cache + .prepare_diff() + .map_err(|err| Error::backend("git diff", err))?; + + let mut text = String::new(); + text.push_str("diff --git a/"); + text.push_str(&change.old_path); + text.push_str(" b/"); + text.push_str(&change.new_path); + text.push('\n'); + let is_binary = matches!( + prepared.operation, + gix::diff::blob::platform::prepare_diff::Operation::SourceOrDestinationIsBinary + ); + let similarity = if change.similarity == Some(u8::MAX) { + compute_similarity(&prepared) + } else { + change.similarity + }; + append_metadata(&mut text, change, similarity, binary_patch && is_binary); + + match prepared.operation { + gix::diff::blob::platform::prepare_diff::Operation::SourceOrDestinationIsBinary => { + if binary_patch { + text.push_str("GIT binary patch\n"); + let old = object_bytes(repo, change.old_id)?; + let new = object_bytes(repo, change.new_id)?; + append_binary_body(&mut text, &old, &new)?; + append_binary_body(&mut text, &new, &old)?; + } else { + text.push_str("Binary files "); + push_old_path(&mut text, change); + text.push_str(" and "); + push_new_path(&mut text, change); + text.push_str(" differ\n"); + } + Ok(Rendered { text, added: None, removed: None }) + }, + gix::diff::blob::platform::prepare_diff::Operation::InternalDiff { algorithm } => { + // Tokenize with line terminators kept: git's xdiff treats the + // terminator as part of the line, so CRLF content diffs with + // literal `\r` bytes and a final line without a newline is a + // different line than the same text with one. The convenience + // `prepared.interned_input()` strips LF/CRLF and would lose both. + let input = gix::diff::blob::InternedInput::new( + prepared.old.intern_source(), + prepared.new.intern_source(), + ); + let diff = gix::diff::blob::diff_with_slider_heuristics(algorithm, &input); + let added = diff.count_additions(); + let removed = diff.count_removals(); + if added != 0 || removed != 0 { + text.push_str("--- "); + push_old_path(&mut text, change); + text.push('\n'); + text.push_str("+++ "); + push_new_path(&mut text, change); + text.push('\n'); + let old_data = prepared.old.data.as_slice().unwrap_or_default(); + let sink = GitHunks { out: &mut text, old_data }; + gix::diff::blob::UnifiedDiff::new( + &diff, + &input, + sink, + gix::diff::blob::unified_diff::ContextSize::symmetrical(context), + ) + .consume() + .map_err(|err| Error::backend("git diff", err))?; + } + Ok(Rendered { text, added: Some(added), removed: Some(removed) }) + }, + gix::diff::blob::platform::prepare_diff::Operation::ExternalCommand { .. } => { + Err(Error::backend("git diff", "external diff drivers cannot be rendered in-process")) + }, + } +} + +fn append_metadata(out: &mut String, change: &FileChange, similarity: Option, full_ids: bool) { + if let Some(similarity) = similarity { + let _ = writeln!(out, "similarity index {similarity}%"); + out.push_str("rename from "); + out.push_str(&change.old_path); + out.push('\n'); + out.push_str("rename to "); + out.push_str(&change.new_path); + out.push('\n'); + } + match (change.old_mode, change.new_mode) { + (None, Some(mode)) => { + let _ = writeln!(out, "new file mode {:06o}", mode.value()); + }, + (Some(mode), None) => { + let _ = writeln!(out, "deleted file mode {:06o}", mode.value()); + }, + (Some(old), Some(new)) if old != new => { + let _ = writeln!(out, "old mode {:06o}", old.value()); + let _ = writeln!(out, "new mode {:06o}", new.value()); + }, + _ => {}, + } + if change.old_id != change.new_id { + let old = display_id(change.old_id, full_ids); + let new = display_id(change.new_id, full_ids); + out.push_str("index "); + out.push_str(&old); + out.push_str(".."); + out.push_str(&new); + if let (true, Some(mode)) = (change.old_mode == change.new_mode, change.old_mode) { + let _ = write!(out, " {:06o}", mode.value()); + } + out.push('\n'); + } +} + +fn compute_similarity( + prepared: &gix::diff::blob::platform::prepare_diff::Outcome<'_>, +) -> Option { + let gix::diff::blob::platform::prepare_diff::Operation::InternalDiff { algorithm } = + prepared.operation + else { + return Some(50); + }; + let input = gix::diff::blob::InternedInput::new( + prepared.old.intern_source(), + prepared.new.intern_source(), + ); + let diff = gix::diff::blob::Diff::compute(algorithm, &input); + let removed_bytes = diff + .hunks() + .flat_map(|hunk| &input.before[hunk.before.start as usize..hunk.before.end as usize]) + .map(|token| input.interner[*token].len()) + .sum::(); + let old_len = prepared.old.data.as_slice()?.len(); + let new_len = prepared.new.data.as_slice()?.len(); + if old_len.max(new_len) == 0 { + return Some(100); + } + Some((((old_len.saturating_sub(removed_bytes)) * 100) / old_len.max(new_len)) as u8) +} + +struct GitHunks<'a> { + out: &'a mut String, + old_data: &'a [u8], +} + +impl gix::diff::blob::unified_diff::ConsumeHunk for GitHunks<'_> { + type Out = (); + + fn consume_hunk( + &mut self, + header: gix::diff::blob::unified_diff::HunkHeader, + lines: &[(gix::diff::blob::unified_diff::DiffLineKind, &[u8])], + ) -> std::io::Result<()> { + let old_start = zero_start(header.before_hunk_start, header.before_hunk_len); + let new_start = zero_start(header.after_hunk_start, header.after_hunk_len); + self.out.push_str("@@ -"); + push_range(self.out, old_start, header.before_hunk_len); + self.out.push_str(" +"); + push_range(self.out, new_start, header.after_hunk_len); + self.out.push_str(" @@"); + if let Some(function) = function_context(self.old_data, header.before_hunk_start) { + self.out.push(' '); + self.out.push_str(&String::from_utf8_lossy(function)); + } + self.out.push('\n'); + for &(kind, content) in lines { + self.out.push(kind.to_prefix()); + self.out.push_str(&String::from_utf8_lossy(content)); + // Tokens carry their terminator; a token without one is the + // final line of a file that does not end in a newline. + if content.last() != Some(&b'\n') { + self.out.push('\n'); + self.out.push_str("\\ No newline at end of file\n"); + } + } + Ok(()) + } + + fn finish(self) {} +} + +fn append_binary_body(out: &mut String, source: &[u8], target: &[u8]) -> Result<()> { + let literal = zlib_compress(target)?; + let delta = if source.is_empty() || target.is_empty() { + None + } else { + git_delta(source, target, literal.len()) + .map(|delta| { + let size = delta.len(); + zlib_compress(&delta).map(|compressed| (size, compressed)) + }) + .transpose()? + }; + if let Some((size, compressed)) = + delta.filter(|(_, compressed)| compressed.len() < literal.len()) + { + append_binary_block(out, "delta", size, &compressed) + } else { + append_binary_block(out, "literal", target.len(), &literal) + } +} + +fn append_binary_block(out: &mut String, kind: &str, size: usize, compressed: &[u8]) -> Result<()> { + let _ = writeln!(out, "{kind} {size}"); + for line in compressed.chunks(52) { + let len = line.len(); + out.push(if len <= 26 { + char::from(b'A' + u8::try_from(len - 1).unwrap_or(0)) + } else { + char::from(b'a' + u8::try_from(len - 27).unwrap_or(0)) + }); + for chunk in line.chunks(4) { + let mut bytes = [0_u8; 4]; + bytes[..chunk.len()].copy_from_slice(chunk); + let mut value = u32::from_be_bytes(bytes); + let mut encoded = [0_u8; 5]; + for byte in encoded.iter_mut().rev() { + *byte = BASE85[(value % 85) as usize]; + value /= 85; + } + out.push_str( + std::str::from_utf8(&encoded).map_err(|err| Error::backend("git binary patch", err))?, + ); + } + out.push('\n'); + } + out.push('\n'); + Ok(()) +} + +#[derive(Clone, Copy)] +struct DeltaEntry { + offset: usize, + hash: u32, +} + +fn git_delta(source: &[u8], target: &[u8], max_size: usize) -> Option> { + const WINDOW: usize = 16; + let table = rabin_table(); + let remove = rabin_remove_table(&table); + let entry_count = source.len().saturating_sub(1) / WINDOW; + if entry_count == 0 || source.len() > u32::MAX as usize { + return None; + } + let mut bits = 4_u32; + while (1_usize << bits) < entry_count / 4 { + bits += 1; + } + let bucket_count = 1_usize << bits; + let mask = bucket_count - 1; + let mut raw = Vec::::with_capacity(entry_count); + let mut previous = u32::MAX; + for block in (1..=entry_count).rev() { + let end = block * WINDOW; + let mut hash = 0_u32; + for &byte in &source[end - WINDOW + 1..=end] { + hash = rabin_update(hash, byte, &table); + } + if hash == previous { + if let Some(entry) = raw.last_mut() { + entry.offset = end; + } + } else { + raw.push(DeltaEntry { offset: end, hash }); + previous = hash; + } + } + let mut buckets = vec![Vec::new(); bucket_count]; + for entry in raw { + buckets[entry.hash as usize & mask].push(entry); + } + for bucket in &mut buckets { + bucket.sort_unstable_by_key(|entry| entry.offset); + if bucket.len() > 64 { + cull_delta_bucket(bucket); + } + } + + let mut out = Vec::with_capacity(target.len().min(max_size.saturating_add(64))); + push_delta_varint(&mut out, source.len()); + push_delta_varint(&mut out, target.len()); + out.push(0); + let initial = target.len().min(WINDOW); + out.extend_from_slice(&target[..initial]); + let mut insert_count = initial; + let mut position = initial; + let mut hash = target[..initial] + .iter() + .fold(0_u32, |value, &byte| rabin_update(value, byte, &table)); + let mut match_offset = 0_usize; + let mut match_size = 0_usize; + + while position < target.len() { + if match_size < 4096 { + hash ^= remove[target[position - WINDOW] as usize]; + hash = rabin_update(hash, target[position], &table); + for entry in &buckets[hash as usize & mask] { + if entry.hash != hash { + continue; + } + let available = (source.len() - entry.offset).min(target.len() - position); + if available <= match_size { + break; + } + let mut length = 0; + while length < available && source[entry.offset + length] == target[position + length] { + length += 1; + } + if length > match_size { + match_size = length; + match_offset = entry.offset; + if match_size >= 4096 { + break; + } + } + } + } + + if match_size < 4 { + if insert_count == 0 { + out.push(0); + } + out.push(target[position]); + position += 1; + insert_count += 1; + if insert_count == 0x7f { + let slot = out.len() - insert_count - 1; + out[slot] = u8::try_from(insert_count).ok()?; + insert_count = 0; + } + match_size = 0; + } else { + if insert_count != 0 { + while match_offset != 0 + && position != 0 + && source[match_offset - 1] == target[position - 1] + { + match_size += 1; + match_offset -= 1; + position -= 1; + out.pop(); + insert_count -= 1; + if insert_count == 0 { + out.pop(); + break; + } + } + if insert_count != 0 { + let slot = out.len() - insert_count - 1; + out[slot] = u8::try_from(insert_count).ok()?; + } + insert_count = 0; + } + + let leftover = match_size.saturating_sub(0x10000); + match_size -= leftover; + push_delta_copy(&mut out, match_offset, match_size); + position += match_size; + match_offset += match_size; + match_size = if match_offset > u32::MAX as usize { + 0 + } else { + leftover + }; + if match_size < 4096 && position >= WINDOW { + hash = target[position - WINDOW..position] + .iter() + .fold(0_u32, |value, &byte| rabin_update(value, byte, &table)); + } + } + if out.len() > max_size { + return None; + } + } + if insert_count != 0 { + let slot = out.len() - insert_count - 1; + out[slot] = u8::try_from(insert_count).ok()?; + } + Some(out) +} + +fn rabin_table() -> [u32; 256] { + const POLYNOMIAL: u32 = 0xab59_b4d1; + let mut basis = [0_u32; 8]; + basis[0] = POLYNOMIAL; + for index in 1..basis.len() { + let previous = basis[index - 1]; + basis[index] = (previous << 1) + ^ if previous & 0x4000_0000 != 0 { + POLYNOMIAL + } else { + 0 + }; + } + let mut table = [0_u32; 256]; + for (value, slot) in table.iter_mut().enumerate() { + for (bit, basis) in basis.iter().enumerate() { + if value & (1 << bit) != 0 { + *slot ^= basis; + } + } + } + table +} + +fn rabin_remove_table(table: &[u32; 256]) -> [u32; 256] { + let mut remove = [0_u32; 256]; + for (byte, slot) in remove.iter_mut().enumerate() { + let mut value = byte as u32; + for _ in 0..15 { + value = rabin_update(value, 0, table); + } + *slot = value; + } + remove +} + +fn rabin_update(value: u32, byte: u8, table: &[u32; 256]) -> u32 { + (value << 8 | u32::from(byte)) ^ table[(value >> 23) as u8 as usize] +} + +fn cull_delta_bucket(bucket: &mut Vec) { + let original_len = bucket.len(); + let mut kept = Vec::with_capacity(64); + let mut accumulator = 0_isize; + let mut index = 0; + while index < original_len && kept.len() < 64 { + accumulator += (original_len - 64) as isize; + kept.push(bucket[index]); + index += 1; + while accumulator > 0 && index < original_len { + index += 1; + accumulator -= 64; + } + } + *bucket = kept; +} + +fn push_delta_varint(out: &mut Vec, mut value: usize) { + while value >= 0x80 { + out.push((value as u8) | 0x80); + value >>= 7; + } + out.push(value as u8); +} + +fn push_delta_copy(out: &mut Vec, offset: usize, size: usize) { + let mut opcode = 0x80_u8; + let slot = out.len(); + out.push(0); + for index in 0..4 { + let byte = ((offset >> (index * 8)) & 0xff) as u8; + if byte != 0 { + opcode |= 1 << index; + out.push(byte); + } + } + for index in 0..2 { + let byte = ((size >> (index * 8)) & 0xff) as u8; + if byte != 0 { + opcode |= 0x10 << index; + out.push(byte); + } + } + out[slot] = opcode; +} + +const BASE85: &[u8; 85] = + b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~"; + +fn zlib_compress(data: &[u8]) -> Result> { + let mut writer = gix::features::zlib::stream::deflate::Write::new(Vec::new()); + writer + .write_all(data) + .and_then(|()| writer.flush()) + .map_err(|err| Error::backend("git binary patch", err))?; + Ok(writer.into_inner()) +} + +fn object_bytes(repo: &gix::Repository, id: gix::ObjectId) -> Result> { + if id.is_null() { + return Ok(Vec::new()); + } + repo + .find_object(id) + .map(|object| object.detach().data) + .map_err(|err| Error::backend("git diff object", err)) +} + +struct NoIndexFile { + data: Vec, + mode: gix::objs::tree::EntryMode, +} + +fn read_no_index_file(root: &Path, path: &Path) -> Result> { + if is_null_device(path) { + return Ok(None); + } + let resolved = if path.is_absolute() { + path.to_owned() + } else { + root.join(path) + }; + let metadata = match std::fs::symlink_metadata(&resolved) { + Ok(metadata) => metadata, + Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(None), + Err(err) => return Err(err.into()), + }; + let file_type = metadata.file_type(); + let (data, kind) = if file_type.is_symlink() { + let target = std::fs::read_link(&resolved)?; + (os_path_bytes(&target), gix::objs::tree::EntryKind::Link) + } else if file_type.is_file() { + let kind = if is_executable(&metadata) { + gix::objs::tree::EntryKind::BlobExecutable + } else { + gix::objs::tree::EntryKind::Blob + }; + (std::fs::read(&resolved)?, kind) + } else { + return Err(Error::backend( + "git diff --no-index", + format!("unsupported filesystem entry: {}", resolved.display()), + )); + }; + Ok(Some(NoIndexFile { data, mode: kind.into() })) +} + +fn write_no_index_blob( + repo: &gix::Repository, + file: Option<&NoIndexFile>, +) -> Result> { + file + .map(|file| { + repo + .write_blob(&file.data) + .map(gix::Id::detach) + .map_err(|err| Error::backend("git diff --no-index", err)) + }) + .transpose() +} + +fn no_index_label(root: &Path, path: &Path) -> String { + let path = if path.is_absolute() { + path.strip_prefix(root).unwrap_or(path) + } else { + path + }; + path.to_string_lossy().replace('\\', "/") +} + +fn is_null_device(path: &Path) -> bool { + path == Path::new("/dev/null") || path.to_string_lossy().eq_ignore_ascii_case("NUL") +} + +#[cfg(unix)] +fn is_executable(metadata: &std::fs::Metadata) -> bool { + use std::os::unix::fs::PermissionsExt; + metadata.permissions().mode() & 0o111 != 0 +} + +#[cfg(not(unix))] +fn is_executable(_metadata: &std::fs::Metadata) -> bool { + false +} + +#[cfg(unix)] +fn os_path_bytes(path: &Path) -> Vec { + use std::os::unix::ffi::OsStrExt; + path.as_os_str().as_bytes().to_vec() +} + +#[cfg(not(unix))] +fn os_path_bytes(path: &Path) -> Vec { + path.to_string_lossy().into_owned().into_bytes() +} + +fn make_pathspec<'repo>( + repo: &'repo gix::Repository, + files: &[String], + worktree: bool, +) -> Result>> { + if files.is_empty() { + return Ok(None); + } + let index = load_index_or_empty(repo, "git diff pathspec")?; + repo + .pathspec( + false, + bstring_patterns(files), + worktree, + &index, + if worktree { + gix::worktree::stack::state::attributes::Source::WorktreeThenIdMapping + } else { + gix::worktree::stack::state::attributes::Source::IdMapping + }, + ) + .map(Some) + .map_err(|err| Error::backend("git diff pathspec", err)) +} + +fn bstring_patterns(files: &[String]) -> Vec { + files + .iter() + .map(|path| BString::from(path.as_bytes())) + .collect() +} + +fn index_mode(mode: gix::index::entry::Mode) -> Result> { + mode + .to_tree_entry_mode() + .map(Some) + .ok_or_else(|| Error::backend("git diff", "invalid index entry mode")) +} + +fn path_string(path: &BStr) -> String { + String::from_utf8_lossy(path).into_owned() +} + +fn display_id(id: gix::ObjectId, full: bool) -> String { + if id.is_null() { + if full { + "0".repeat(id.kind().len_in_hex()) + } else { + "0000000".to_owned() + } + } else if full { + id.to_string() + } else { + id.to_string().chars().take(7).collect() + } +} + +fn function_context(data: &[u8], hunk_start: u32) -> Option<&[u8]> { + let before = usize::try_from(hunk_start.saturating_sub(1)).ok()?; + let mut candidate = None; + for line in data.split(|&byte| byte == b'\n').take(before) { + let line = line.strip_suffix(b"\r").unwrap_or(line); + if line + .first() + .is_some_and(|byte| !byte.is_ascii_whitespace() && *byte != b'}') + { + candidate = Some(line); + } + } + candidate +} + +const fn zero_start(start: u32, len: u32) -> u32 { + if len == 0 { + start.saturating_sub(1) + } else { + start + } +} + +fn push_range(out: &mut String, start: u32, len: u32) { + out.push_str(&start.to_string()); + if len != 1 { + out.push(','); + out.push_str(&len.to_string()); + } +} + +fn push_old_path(out: &mut String, change: &FileChange) { + if change.old_mode.is_some() { + out.push_str("a/"); + out.push_str(&change.old_path); + } else { + out.push_str("/dev/null"); + } +} + +fn push_new_path(out: &mut String, change: &FileChange) { + if change.new_mode.is_some() { + out.push_str("b/"); + out.push_str(&change.new_path); + } else { + out.push_str("/dev/null"); + } +} + +fn sort_changes(changes: &mut [FileChange]) { + changes.sort_unstable_by(|left, right| { + left + .new_path + .as_bytes() + .cmp(right.new_path.as_bytes()) + .then_with(|| left.old_path.as_bytes().cmp(right.old_path.as_bytes())) + }); +} +#[cfg(test)] +mod tests { + use std::{fs, path::Path, process::Command}; + + use tempfile::TempDir; + + use super::*; + + fn git(dir: &Path, args: &[&str]) -> String { + let output = Command::new("git") + .args(args) + .current_dir(dir) + .output() + .unwrap_or_else(|err| panic!("run git {args:?}: {err}")); + assert!(output.status.success(), "git {args:?}: {}", String::from_utf8_lossy(&output.stderr)); + String::from_utf8(output.stdout).expect("git output is UTF-8") + } + fn git_diff(dir: &Path, args: &[&str]) -> String { + let output = Command::new("git") + .args(args) + .current_dir(dir) + .output() + .unwrap_or_else(|err| panic!("run git {args:?}: {err}")); + assert_eq!( + output.status.code(), + Some(1), + "git {args:?}: {}", + String::from_utf8_lossy(&output.stderr) + ); + String::from_utf8(output.stdout).expect("git output is UTF-8") + } + + fn fixture() -> TempDir { + let dir = tempfile::tempdir().expect("tempdir"); + git(dir.path(), &["init", "-q"]); + git(dir.path(), &["config", "user.name", "Diff Test"]); + git(dir.path(), &["config", "user.email", "diff@example.com"]); + fs::write(dir.path().join("file.txt"), "one\ntwo\nthree\nfour\nfive\nsix\nseven\n") + .expect("write"); + fs::write(dir.path().join("delete.txt"), "delete\n").expect("write"); + git(dir.path(), &["add", "."]); + git(dir.path(), &["commit", "-qm", "initial"]); + dir + } + + #[test] + fn diff_matches_git_for_worktree_text() { + let dir = fixture(); + fs::write(dir.path().join("file.txt"), "one\nchanged\nthree\n").expect("write"); + fs::remove_file(dir.path().join("delete.txt")).expect("delete"); + let repo = GitRepo::discover(dir.path()) + .expect("discover") + .expect("repository"); + let actual = repo.diff_text(&DiffOptions::default()).expect("diff"); + let expected = git(dir.path(), &["diff"]); + assert_eq!(actual, expected); + assert_eq!( + repo.changed_files(&DiffOptions::default()).expect("names"), + git(dir.path(), &["diff", "--name-only"]) + .lines() + .map(str::to_owned) + .collect::>() + ); + let expected_numstat = git(dir.path(), &["diff", "--numstat"]) + .lines() + .map(|line| { + let mut fields = line.split('\t'); + NumstatEntry { + added: fields.next().and_then(|value| value.parse().ok()), + removed: fields.next().and_then(|value| value.parse().ok()), + path: fields.next().unwrap_or_default().to_owned(), + } + }) + .collect::>(); + assert_eq!(repo.numstat(&DiffOptions::default()).expect("numstat"), expected_numstat); + fs::write(dir.path().join("intent.txt"), "intent\n").expect("write intent"); + git(dir.path(), &["add", "-N", "intent.txt"]); + assert_eq!( + repo + .diff_text(&DiffOptions::default()) + .expect("intent-to-add diff"), + git(dir.path(), &["diff"]) + ); + } + + #[test] + fn status_reads_observe_same_tick_stage_on_reused_handle() { + let dir = fixture(); + fs::write(dir.path().join("file.txt"), "changed\n").expect("edit tracked"); + fs::write(dir.path().join("new.txt"), "new\n").expect("write untracked"); + let repo = GitRepo::discover(dir.path()) + .expect("discover") + .expect("repository"); + + // Populate gix's shared index snapshot through status-backed diff before + // staging, then force the write back onto the same mtime tick. + crate::git::pin_index_mtime(&repo); + assert!( + !repo + .diff_text(&DiffOptions::default()) + .expect("initial diff") + .is_empty() + ); + repo + .stage_files(&["file.txt".into(), "new.txt".into()]) + .expect("stage files"); + crate::git::pin_index_mtime(&repo); + + assert_eq!( + repo + .diff_text(&DiffOptions::default()) + .expect("worktree diff"), + git(dir.path(), &["diff"]) + ); + assert_eq!( + repo + .status_porcelain(&crate::types::StatusOptions::default()) + .expect("status"), + git(dir.path(), &["status", "--porcelain"]) + ); + assert_eq!(repo.status_summary().expect("summary"), crate::types::StatusSummary { + staged: 2, + unstaged: 0, + untracked: 0, + }); + assert_eq!(repo.ls_files(true, true).expect("untracked files"), Vec::::new()); + + repo + .commit_create("stage all", &crate::types::CommitOptions::default()) + .expect("commit staged files"); + assert!(!repo.is_dirty().expect("clean after commit")); + assert_eq!( + repo + .status_porcelain(&crate::types::StatusOptions::default()) + .expect("clean status"), + "" + ); + } + + #[test] + fn cached_rename_add_and_path_filters_match_git() { + let dir = fixture(); + git(dir.path(), &["mv", "file.txt", "renamed.txt"]); + fs::write(dir.path().join("renamed.txt"), "one\ntwo\nchanged\nfour\nfive\nsix\nseven\n") + .expect("modify rename"); + fs::write(dir.path().join("added.txt"), "new\n").expect("write"); + git(dir.path(), &["add", "."]); + let repo = GitRepo::discover(dir.path()) + .expect("discover") + .expect("repository"); + let options = DiffOptions { cached: true, ..DiffOptions::default() }; + assert_eq!(repo.diff_text(&options).expect("diff"), git(dir.path(), &["diff", "--cached"])); + let filtered = DiffOptions { files: vec!["added.txt".into()], ..options }; + assert_eq!( + repo.diff_text(&filtered).expect("filtered diff"), + git(dir.path(), &["diff", "--cached", "--", "added.txt"]) + ); + } + + #[test] + fn context_and_two_revision_tree_diff_match_git() { + let dir = fixture(); + fs::write(dir.path().join("file.txt"), "one\ntwo\nthree\nchanged\nfive\nsix\nseven\n") + .expect("write"); + fs::create_dir_all(dir.path().join("src")).expect("create nested directory"); + fs::write(dir.path().join("src/new.py"), "nested\n").expect("write nested file"); + git(dir.path(), &["add", "."]); + git(dir.path(), &["commit", "-qm", "second"]); + let repo = GitRepo::discover(dir.path()) + .expect("discover") + .expect("repository"); + let options = DiffOptions { + base: Some("HEAD^".into()), + head: Some("HEAD".into()), + context: Some(1), + ..DiffOptions::default() + }; + assert_eq!( + repo.diff_text(&options).expect("diff"), + git(dir.path(), &["diff", "-U1", "HEAD^", "HEAD"]) + ); + assert_eq!( + repo.diff_tree("HEAD^", "HEAD", false).expect("diff-tree"), + git(dir.path(), &["diff-tree", "-r", "-p", "HEAD^", "HEAD"]) + ); + assert_eq!( + repo.show_commit("HEAD", None).expect("show").bytes, + git(dir.path(), &["show", "HEAD"]).into_bytes() + ); + fs::write(dir.path().join("file.txt"), "one\ntwo\nthree\nchanged\nfive\nworktree\nseven\n") + .expect("modify worktree"); + let base_only = DiffOptions { base: Some("HEAD^".into()), ..DiffOptions::default() }; + assert_eq!( + repo.diff_text(&base_only).expect("base diff"), + git(dir.path(), &["diff", "HEAD^"]) + ); + } + + #[test] + fn binary_and_missing_newline_match_git() { + let dir = fixture(); + fs::write(dir.path().join("binary.dat"), [0, 1, 2, 3, 4, 5]).expect("write binary"); + let mut state = 1_u32; + let mut large = (0..8192) + .map(|_| { + state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223); + (state >> 24) as u8 + }) + .collect::>(); + fs::write(dir.path().join("large.dat"), &large).expect("write large binary"); + fs::write(dir.path().join("nonewline.txt"), "old").expect("write text"); + git(dir.path(), &["add", "."]); + git(dir.path(), &["commit", "-qm", "binary base"]); + fs::write(dir.path().join("binary.dat"), [0, 1, 9, 3, 4, 5]).expect("modify binary"); + large[4000..4010].fill(42); + fs::write(dir.path().join("large.dat"), &large).expect("modify large binary"); + fs::write(dir.path().join("nonewline.txt"), "new").expect("modify text"); + let repo = GitRepo::discover(dir.path()) + .expect("discover") + .expect("repository"); + assert_eq!( + repo.diff_text(&DiffOptions::default()).expect("diff"), + git(dir.path(), &["diff"]) + ); + let binary = DiffOptions { binary: true, ..DiffOptions::default() }; + assert_eq!( + repo.diff_text(&binary).expect("binary diff"), + git(dir.path(), &["diff", "--binary"]) + ); + let stats = repo.numstat(&DiffOptions::default()).expect("numstat"); + assert!(stats.iter().any(|entry| entry.path == "binary.dat" + && entry.added.is_none() + && entry.removed.is_none())); + fs::write(dir.path().join("new-binary.dat"), [0, 7, 8, 9]).expect("add binary"); + git(dir.path(), &["add", "new-binary.dat"]); + git(dir.path(), &["rm", "-fq", "binary.dat"]); + let cached_binary = DiffOptions { cached: true, binary: true, ..DiffOptions::default() }; + assert_eq!( + repo.diff_text(&cached_binary).expect("cached binary diff"), + git(dir.path(), &["diff", "--cached", "--binary"]) + ); + } + + #[cfg(unix)] + #[test] + fn no_index_text_binary_executable_and_symlink_match_git() { + use std::os::unix::fs::{PermissionsExt, symlink}; + + let dir = fixture(); + fs::write(dir.path().join("untracked.txt"), "untracked\n").expect("write text"); + fs::write(dir.path().join("untracked.dat"), [0, 1, 2, 3, 4]).expect("write binary"); + fs::write(dir.path().join("executable"), "#!/bin/sh\nexit 0\n").expect("write executable"); + let mut permissions = fs::metadata(dir.path().join("executable")) + .expect("metadata") + .permissions(); + permissions.set_mode(0o755); + fs::set_permissions(dir.path().join("executable"), permissions).expect("chmod"); + symlink("untracked.txt", dir.path().join("link")).expect("symlink"); + let repo = GitRepo::discover(dir.path()) + .expect("discover") + .expect("repository"); + for path in ["untracked.txt", "untracked.dat", "executable", "link"] { + assert_eq!( + repo + .diff_no_index(Path::new("/dev/null"), Path::new(path), true) + .expect("no-index diff"), + git_diff(dir.path(), &["diff", "--no-index", "--binary", "/dev/null", path]) + ); + } + } + + #[cfg(unix)] + #[test] + fn mode_change_and_crlf_match_git() { + use std::os::unix::fs::PermissionsExt; + + let dir = fixture(); + fs::write(dir.path().join("crlf.txt"), b"one\r\ntwo\r\n").expect("write CRLF"); + git(dir.path(), &["add", "."]); + git(dir.path(), &["commit", "-qm", "crlf"]); + fs::write(dir.path().join("crlf.txt"), b"one\r\nchanged\r\n").expect("modify CRLF"); + let path = dir.path().join("file.txt"); + let mut permissions = fs::metadata(&path).expect("metadata").permissions(); + permissions.set_mode(0o755); + fs::set_permissions(path, permissions).expect("chmod"); + let repo = GitRepo::discover(dir.path()) + .expect("discover") + .expect("repository"); + assert_eq!( + repo.diff_text(&DiffOptions::default()).expect("diff"), + git(dir.path(), &["diff"]) + ); + } +} diff --git a/crates/pi-vcs/src/git/mod.rs b/crates/pi-vcs/src/git/mod.rs new file mode 100644 index 000000000000..97a542ba945a --- /dev/null +++ b/crates/pi-vcs/src/git/mod.rs @@ -0,0 +1,350 @@ +//! Git backend: gitoxide-powered repository operations. +//! +//! A git-CLI fallback is reserved for credential-bound network transfers +//! (push/fetch/clone) and reftable repositories, which no in-process +//! implementation can read yet. +//! +//! Repository discovery is a pure filesystem walk (no subprocess, no gix open): +//! it mirrors the battle-tested TypeScript walk it replaces — `.git` pointer +//! files, `commondir` indirection, reftable detection — and is cheap enough for +//! synchronous render paths. + +mod cli; +mod diff; +mod mutate; +mod open; +mod patch; +mod read; +use std::{ + path::{Path, PathBuf}, + sync::OnceLock, +}; + +pub use cli::{COMMAND_TIMEOUT, NETWORK_TIMEOUT, OUTPUT_LIMIT_BYTES, SYNC_TIMEOUT, clone}; +pub use mutate::detach_git_dir; +pub use patch::{join_patches, validate_hunk_selections}; + +use crate::{ + error::{Error, Result}, + types::{GitRepoInfo, LinkedWorktree}, +}; + +/// An opened git repository. +/// +/// Construction is filesystem-only; the gitoxide handle is opened lazily on +/// first object/index access and shared across threads. +pub struct GitRepo { + info: GitRepoInfo, + /// Lazily opened gitoxide repository. `None` until an operation needs + /// object database, index, or config access. Never populated for reftable + /// repositories (operations route through the CLI fallback instead). + pub(crate) gix: OnceLock, +} + +impl std::fmt::Debug for GitRepo { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("GitRepo") + .field("info", &self.info) + .finish_non_exhaustive() + } +} + +impl GitRepo { + /// Discover the repository containing `dir` by walking toward the root. + /// + /// Returns `Ok(None)` when `dir` is outside any git repository, or when a + /// `.git` pointer file is unreadable due to permissions (matching the + /// historical wrapper, which treated that as "not a repo" rather than an + /// error). + pub fn discover(dir: &Path) -> Result> { + let Some(info) = discover_info(dir)? else { + return Ok(None); + }; + Ok(Some(Self { info, gix: OnceLock::new() })) + } + + /// Like [`GitRepo::discover`], but errors with [`Error::NotARepository`] + /// when `dir` is outside any repository. + pub fn require(dir: &Path) -> Result { + Self::discover(dir)?.ok_or_else(|| Error::NotARepository { path: dir.to_owned() }) + } + + /// Resolved repository metadata. + pub const fn info(&self) -> &GitRepoInfo { + &self.info + } + + /// Checkout root (may be a linked worktree root). + pub fn root(&self) -> &Path { + &self.info.repo_root + } + + /// Primary checkout root, or the shared common dir for bare-repo worktrees. + pub fn primary_root(&self) -> PathBuf { + if self + .info + .common_dir + .file_name() + .is_some_and(|name| name == ".git") + { + return self + .info + .common_dir + .parent() + .unwrap_or(&self.info.common_dir) + .to_owned(); + } + if self.is_linked_worktree() { + return self.info.common_dir.clone(); + } + self.info.repo_root.clone() + } + + /// Linked-worktree metadata, or `None` for the primary checkout. + pub fn linked_worktree(&self) -> Option { + if !self.is_linked_worktree() { + return None; + } + Some(LinkedWorktree { + root: self.info.repo_root.clone(), + primary_root: self.primary_root(), + }) + } + + /// Whether this checkout is a linked worktree sharing a primary repo's + /// metadata through a `commondir` pointer file. + pub fn is_linked_worktree(&self) -> bool { + self.info.git_dir != self.info.common_dir && self.info.git_dir.join("commondir").is_file() + } + + /// Whether refs live in the reftable format. Operations on such repos fall + /// back to the git CLI for ref access. + pub const fn is_reftable(&self) -> bool { + self.info.is_reftable + } + + /// Path of `dir` relative to the checkout root with a trailing slash — + /// `git rev-parse --show-prefix` equivalent. Empty for the root itself; + /// `None` when `dir` is outside the checkout. + pub fn prefix_of(&self, dir: &Path) -> Option { + relative_prefix(&self.info.repo_root, dir) + } +} + +/// Pin the worktree index mtime to reproduce same-tick snapshot races in tests. +#[cfg(test)] +pub(crate) fn pin_index_mtime(repo: &GitRepo) { + let pinned = std::time::SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(1_700_000_000); + std::fs::File::options() + .write(true) + .open(repo.info().git_dir.join("index")) + .expect("open index") + .set_modified(pinned) + .expect("pin index mtime"); +} +/// Discover repository metadata for `dir` without opening gitoxide. +pub fn discover_info(dir: &Path) -> Result> { + let mut current = std::path::absolute(dir)?; + loop { + let git_entry = current.join(".git"); + if let Some(entry) = entry_type(&git_entry) { + match resolve_info(¤t, &git_entry, entry) { + Ok(Some(info)) => return Ok(Some(info)), + Ok(None) => {}, + Err(err) + if entry == EntryType::File + && err.kind() == std::io::ErrorKind::PermissionDenied => + { + return Ok(None); + }, + Err(err) => return Err(err.into()), + } + } + if !current.pop() { + return Ok(None); + } + } +} + +#[derive(Clone, Copy, PartialEq, Eq)] +enum EntryType { + Directory, + File, +} + +fn entry_type(path: &Path) -> Option { + let meta = std::fs::metadata(path).ok()?; + if meta.is_dir() { + Some(EntryType::Directory) + } else if meta.is_file() { + Some(EntryType::File) + } else { + None + } +} + +fn resolve_info( + repo_root: &Path, + git_entry: &Path, + entry: EntryType, +) -> std::io::Result> { + let git_dir = match entry { + EntryType::Directory => git_entry.to_owned(), + EntryType::File => { + let content = std::fs::read_to_string(git_entry)?; + let Some(target) = parse_gitdir_pointer(&content) else { + return Ok(None); + }; + let resolved = normalize_path(&git_entry.parent().unwrap_or(repo_root).join(target)); + if entry_type(&resolved) != Some(EntryType::Directory) { + return Ok(None); + } + resolved + }, + }; + let common_dir = resolve_common_dir(&git_dir); + let is_reftable = + read_optional(&common_dir.join("config")).is_some_and(|config| config_has_reftable(&config)); + Ok(Some(GitRepoInfo { + repo_root: repo_root.to_owned(), + git_entry_path: git_entry.to_owned(), + head_path: git_dir.join("HEAD"), + git_dir, + common_dir, + is_reftable, + })) +} + +/// Parse the `gitdir: ` pointer written into linked-worktree `.git` +/// files. +fn parse_gitdir_pointer(content: &str) -> Option<&str> { + let rest = content.trim().strip_prefix("gitdir:")?; + let target = rest.trim(); + (!target.is_empty()).then_some(target) +} + +fn resolve_common_dir(git_dir: &Path) -> PathBuf { + match read_optional(&git_dir.join("commondir")) { + Some(content) => { + let relative = content.trim(); + if relative.is_empty() { + git_dir.to_owned() + } else { + normalize_path(&git_dir.join(relative)) + } + }, + None => git_dir.to_owned(), + } +} + +fn read_optional(path: &Path) -> Option { + std::fs::read_to_string(path).ok() +} + +/// Lexically normalize `.`/`..` segments without touching the filesystem, so +/// relative `gitdir`/`commondir` pointers resolve the same way git does. +pub(crate) fn normalize_path(path: &Path) -> PathBuf { + let mut out = PathBuf::new(); + for component in path.components() { + match component { + std::path::Component::CurDir => {}, + std::path::Component::ParentDir => { + if !out.pop() { + out.push(component); + } + }, + other => out.push(other), + } + } + out +} +/// Return `dir` relative to `root` with a trailing slash. +pub(crate) fn relative_prefix(root: &Path, dir: &Path) -> Option { + let absolute = std::path::absolute(dir).ok()?; + let relative = absolute.strip_prefix(root).ok()?; + if relative.as_os_str().is_empty() { + return Some(String::new()); + } + let mut prefix = relative + .to_string_lossy() + .replace(std::path::MAIN_SEPARATOR, "/"); + prefix.push('/'); + Some(prefix) +} + +/// Whether a git config file selects the reftable ref storage. +/// +/// Minimal INI scan of `[extensions] refstorage`, honoring quoted values and +/// `;`/`#` comments outside quotes — enough to classify a repo without a full +/// config parser (reftable repos never reach gitoxide, so its parser is not +/// available for them by construction). +fn config_has_reftable(content: &str) -> bool { + let mut in_extensions = false; + for line in content.lines() { + let line = strip_config_comment(line); + let line = line.trim(); + if let Some(section) = line + .strip_prefix('[') + .and_then(|rest| rest.strip_suffix(']')) + { + in_extensions = section.trim().eq_ignore_ascii_case("extensions"); + continue; + } + if !in_extensions { + continue; + } + let Some((key, value)) = line.split_once('=') else { + continue; + }; + if !key.trim().eq_ignore_ascii_case("refstorage") { + continue; + } + let mut value = value.trim(); + if value.len() >= 2 && value.starts_with('"') && value.ends_with('"') { + value = value[1..value.len() - 1].trim(); + } + let value = value.to_ascii_lowercase(); + if value == "reftable" || value.starts_with("reftable:") { + return true; + } + } + false +} + +/// Truncate a config line at the first `;`/`#` outside double quotes. +fn strip_config_comment(line: &str) -> &str { + let mut in_quotes = false; + for (index, ch) in line.char_indices() { + match ch { + '"' => in_quotes = !in_quotes, + ';' | '#' if !in_quotes => return &line[..index], + _ => {}, + } + } + line +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn reftable_detection_honors_quotes_and_comments() { + assert!(config_has_reftable("[extensions]\n\trefStorage = reftable\n")); + assert!(config_has_reftable("[extensions]\nrefstorage = \"reftable\" ; comment\n")); + assert!(!config_has_reftable("[extensions]\nrefstorage = files\n")); + assert!(!config_has_reftable("[core]\nrefstorage = reftable\n")); + assert!(!config_has_reftable("[extensions]\n# refstorage = reftable\n")); + } + + #[test] + fn gitdir_pointer_parsing() { + assert_eq!( + parse_gitdir_pointer("gitdir: /a/b/.git/worktrees/x\n"), + Some("/a/b/.git/worktrees/x") + ); + assert_eq!(parse_gitdir_pointer("gitdir:../relative"), Some("../relative")); + assert_eq!(parse_gitdir_pointer("not a pointer"), None); + assert_eq!(parse_gitdir_pointer("gitdir: "), None); + } +} diff --git a/crates/pi-vcs/src/git/mutate.rs b/crates/pi-vcs/src/git/mutate.rs new file mode 100644 index 000000000000..b347b38706cd --- /dev/null +++ b/crates/pi-vcs/src/git/mutate.rs @@ -0,0 +1,1618 @@ +//! In-process local Git mutations. + +use std::{ + collections::{BTreeMap, BTreeSet}, + ffi::OsStr, + fs, + path::{Path, PathBuf}, + process::{Command, Stdio}, +}; + +use gix::bstr::{BString, ByteSlice}; + +use super::{GitRepo, normalize_path, open::load_index_or_head}; +use crate::{ + error::{Error, Result}, + types::{CleanOptions, CommitOptions, DetachGitDirResult, ResetMode, RestoreOptions}, +}; + +const INDEX_WRITE: gix::index::write::Options = gix::index::write::Options { + extensions: gix::index::write::Extensions::None, + skip_hash: false, +}; +/// Apply a ref update, synthesizing a committer for the reflog entry when no +/// identity is configured. Reflog lines require a signature, but git never +/// fails branch/reset/stash ref updates over missing identity — only +/// `git commit` demands one — so parity requires a fallback here. +pub(crate) fn update_reference( + repo: &gix::Repository, + op: &'static str, + name: &str, + id: gix::hash::ObjectId, + expected: gix::refs::transaction::PreviousValue, + message: &str, + force_create_reflog: bool, +) -> Result<()> { + let name: gix::refs::FullName = name.try_into().map_err(|err| Error::backend(op, err))?; + let edit = gix::refs::transaction::RefEdit { + change: gix::refs::transaction::Change::Update { + log: gix::refs::transaction::LogChange { + mode: gix::refs::transaction::RefLog::AndReference, + force_create_reflog, + message: message.into(), + }, + expected, + new: gix::refs::Target::Object(id), + }, + name, + deref: false, + }; + let now; + let committer = if let Some(signature) = repo + .committer() + .transpose() + .map_err(|err| Error::backend(op, err))? + { + signature + } else { + now = format!( + "{} +0000", + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_or(0, |elapsed| elapsed.as_secs()) + ); + gix::actor::SignatureRef { + name: "oh-my-pi".into(), + email: "omp@localhost".into(), + time: &now, + } + }; + repo + .edit_references_as(Some(edit), Some(committer)) + .map_err(|err| Error::backend(op, err))?; + Ok(()) +} + +impl GitRepo { + /// Stage worktree files, or every change when `files` is empty. + pub fn stage_files(&self, files: &[String]) -> Result<()> { + let repo = self.gix()?; + let mut index = load_index_or_head(&repo, "git add")?; + let mut selected = collect_stage_paths(self.root(), files)?; + let all = files.is_empty(); + let requested: BTreeSet<&str> = files.iter().map(String::as_str).collect(); + for entry in index.entries() { + let path = entry.path(&index).to_str_lossy().into_owned(); + if (all || requested.iter().any(|wanted| path_matches(&path, wanted))) + && fs::symlink_metadata(self.root().join(&path)).is_ok() + { + selected.insert(path); + } + } + index.remove_entries(|_, path, _| { + let p = path.to_str_lossy(); + (all || requested.iter().any(|wanted| path_matches(&p, wanted))) + && !selected.contains(&p.into_owned()) + }); + for path in selected { + stage_one(&repo, self.root(), &mut index, &path)?; + } + index.sort_entries(); + index + .write(INDEX_WRITE) + .map_err(|err| Error::backend("git add", err)) + } + + /// Reset selected index entries to HEAD while preserving the worktree. + pub fn unstage(&self, files: &[String]) -> Result<()> { + let repo = self.gix()?; + let head = head_tree(&repo)?; + let head_index = index_for_tree(&repo, head.as_ref())?; + let mut current = load_index_or_head(&repo, "git reset")?; + copy_index_paths(&mut current, &head_index, files); + current + .write(INDEX_WRITE) + .map_err(|err| Error::backend("git reset", err)) + } + + /// Create a commit and return its object id. + pub fn commit_create(&self, message: &str, options: &CommitOptions) -> Result { + let repo = self.gix()?; + run_commit_hook(self, &repo, "pre-commit", &[])?; + let mut head = repo + .head() + .map_err(|err| Error::backend("git commit", err))?; + let old_commit = head + .try_peel_to_id() + .map_err(|err| Error::backend("git commit", err))? + .map(|id| id.detach()); + let index = load_index_or_head(&repo, "git commit")?; + let tree = if options.files.is_empty() { + write_index_tree(&repo, &index)? + } else { + let base = index_for_tree( + &repo, + old_commit + .as_ref() + .map(|id| commit_tree(&repo, id)) + .transpose()? + .as_ref(), + )?; + let mut partial = base; + copy_index_paths(&mut partial, &index, &options.files); + write_index_tree(&repo, &partial)? + }; + let (parents, inherited_author) = if options.amend { + let id = old_commit + .ok_or_else(|| Error::backend("git commit", "cannot amend an unborn HEAD"))?; + let commit = repo + .find_commit(id) + .map_err(|err| Error::backend("git commit", err))?; + let parents: Vec = + commit.parent_ids().map(|id| id.detach()).collect(); + let author = commit + .author() + .map_err(|err| Error::backend("git commit", err))? + .to_owned() + .map_err(|err| Error::backend("git commit", err))?; + (parents, Some(author)) + } else { + (old_commit.into_iter().collect(), None) + }; + if !options.allow_empty { + if let Some(parent) = parents.first() { + if commit_tree(&repo, parent)? == tree { + return Err(Error::backend("git commit", "nothing to commit, working tree clean")); + } + } else if tree == repo.empty_tree().id { + return Err(Error::backend("git commit", "nothing to commit, working tree clean")); + } + } + let committer = repo + .committer() + .ok_or_else(|| Error::backend("git commit", "committer identity is not configured"))? + .map_err(|err| Error::backend("git commit", err))?; + let override_author; + let mut author_time = gix::date::parse::TimeBuf::default(); + let author = if let Some(author) = &options.author { + let time = match &author.date { + Some(date) => { + gix::date::parse(date, None).map_err(|err| Error::backend("git commit", err))? + }, + None => gix::date::Time::now_local_or_utc(), + }; + override_author = gix::actor::Signature { + name: author.name.clone().into(), + email: author.email.clone().into(), + time, + }; + override_author.to_ref(&mut author_time) + } else if let Some(author) = inherited_author.as_ref() { + author.to_ref(&mut author_time) + } else { + repo + .author() + .ok_or_else(|| Error::backend("git commit", "author identity is not configured"))? + .map_err(|err| Error::backend("git commit", err))? + }; + let message_path = self.info().git_dir.join("COMMIT_EDITMSG"); + fs::write(&message_path, message)?; + run_commit_hook(self, &repo, "commit-msg", &[message_path.as_os_str()])?; + let message = fs::read_to_string(&message_path) + .map_err(|err| Error::backend("git commit read commit-msg result", err))?; + let commit = repo + .new_commit_as(committer, author, message, tree, parents) + .map_err(|err| Error::backend("git commit", err))?; + let id = commit.id; + let expected = old_commit + .map_or(gix::refs::transaction::PreviousValue::MustNotExist, |old| { + gix::refs::transaction::PreviousValue::MustExistAndMatch(old.into()) + }); + repo + .edit_reference(gix::refs::transaction::RefEdit { + change: gix::refs::transaction::Change::Update { + log: gix::refs::transaction::LogChange { + mode: gix::refs::transaction::RefLog::AndReference, + force_create_reflog: false, + message: if options.amend { + "commit (amend)" + } else { + "commit" + } + .into(), + }, + expected, + new: gix::refs::Target::Object(id), + }, + name: "HEAD" + .try_into() + .map_err(|err| Error::backend("git commit", err))?, + deref: true, + }) + .map_err(|err| Error::backend("git commit", err))?; + let _ = run_commit_hook(self, &repo, "post-commit", &[]); + Ok(id.to_hex().to_string()) + } + + /// Checkout a branch or detached revision without overwriting local changes. + pub fn checkout(&self, rev: &str) -> Result<()> { + let repo = self.gix()?; + let (target, symbolic) = resolve_checkout_target(&repo, rev)?; + checkout_tree(self, &repo, target, false)?; + write_head(self.info().head_path.as_path(), symbolic.as_deref(), target)?; + Ok(()) + } + + /// Create or force-move a local branch. + pub fn create_branch(&self, name: &str, start: &str, force: bool) -> Result<()> { + let repo = self.gix()?; + let id = resolve_commit(&repo, start)?; + let full = format!("refs/heads/{name}"); + if force && branch_is_checked_out(&self.info().common_dir, &full) { + return Err(Error::backend( + "git branch", + format!( + "cannot force update the branch '{name}' checked out at '{}'", + self.root().display() + ), + )); + } + let constraint = if force { + gix::refs::transaction::PreviousValue::Any + } else { + gix::refs::transaction::PreviousValue::MustNotExist + }; + update_reference( + &repo, + "git branch", + &full, + id, + constraint, + &format!("branch: Created from {start}"), + false, + )?; + Ok(()) + } + + /// Delete a local branch, returning false for missing or unsafe deletion. + pub fn delete_branch(&self, name: &str, force: bool) -> Result { + let repo = self.gix()?; + let full = format!("refs/heads/{name}"); + if branch_is_checked_out(&self.info().common_dir, &full) { + return Ok(false); + } + let Ok(mut reference) = repo.find_reference(&full) else { + return Ok(false); + }; + let id = match reference.peel_to_id() { + Ok(id) => id.detach(), + Err(_) => return Ok(false), + }; + if !force { + let Ok(head) = repo.head_commit() else { + return Ok(false); + }; + let mut walk = head + .ancestors() + .all() + .map_err(|err| Error::backend("git branch", err))?; + let merged = walk.any(|item| item.is_ok_and(|info| info.id == id)); + if !merged { + return Ok(false); + } + } + let edit = gix::refs::transaction::RefEdit { + change: gix::refs::transaction::Change::Delete { + expected: gix::refs::transaction::PreviousValue::MustExistAndMatch(id.into()), + log: gix::refs::transaction::RefLog::AndReference, + }, + name: full + .try_into() + .map_err(|err| Error::backend("git branch", err))?, + deref: false, + }; + Ok(repo.edit_reference(edit).is_ok()) + } + + /// Create a branch at HEAD and switch to it without touching files. + pub fn checkout_new_branch(&self, name: &str) -> Result<()> { + self.create_branch(name, "HEAD", false)?; + fs::write(&self.info().head_path, format!("ref: refs/heads/{name}\n"))?; + Ok(()) + } + + /// Restore index and/or worktree paths from a selected source. + pub fn restore(&self, options: &RestoreOptions) -> Result<()> { + let repo = self.gix()?; + let restore_worktree = options.worktree || !options.staged; + let mut index = load_index_or_head(&repo, "git restore")?; + if options.staged { + let source = resolve_tree(&repo, options.source.as_deref().unwrap_or("HEAD"))?; + let source_index = index_for_tree(&repo, Some(&source))?; + copy_index_paths(&mut index, &source_index, &options.files); + index + .write(INDEX_WRITE) + .map_err(|e| Error::backend("git restore", e))?; + } + if restore_worktree { + let source_index = if let Some(source) = options.source.as_deref() { + index_for_tree(&repo, Some(&resolve_tree(&repo, source)?))? + } else { + index + }; + restore_index_paths(self.root(), &repo, &source_index, &options.files)?; + } + Ok(()) + } + + /// Reset HEAD, index, and optionally the worktree to a target commit. + pub fn reset(&self, mode: ResetMode, target: Option<&str>) -> Result<()> { + let repo = self.gix()?; + let id = resolve_commit(&repo, target.unwrap_or("HEAD"))?; + if mode == ResetMode::Hard { + checkout_tree(self, &repo, id, true)?; + } else if mode == ResetMode::Mixed { + self.read_tree(&id.to_hex().to_string(), None)?; + } + update_current_head(&repo, &self.info().head_path, id)?; + Ok(()) + } + + /// Remove untracked files and directories according to ignore mode. + pub fn clean(&self, options: &CleanOptions) -> Result<()> { + let repo = self.gix()?; + let index = load_index_or_head(&repo, "git clean")?; + let tracked: BTreeSet = index + .entries() + .iter() + .map(|e| e.path(&index).to_str_lossy().into_owned()) + .collect(); + let ignores = load_ignore_patterns(self.root()); + let mut paths = Vec::new(); + walk_files(self.root(), self.root(), &mut paths)?; + for rel in paths { + if tracked.contains(&rel) + || !options.paths.is_empty() && !options.paths.iter().any(|p| path_matches(&rel, p)) + { + continue; + } + let ignored = is_ignored(&rel, &ignores); + if (options.ignored_only && !ignored) + || (!options.ignored_only && !options.include_ignored && ignored) + { + continue; + } + let path = self.root().join(&rel); + if path.is_dir() { + fs::remove_dir_all(path)?; + } else { + fs::remove_file(path)?; + } + } + remove_empty_dirs(self.root(), self.root())?; + Ok(()) + } + + /// Replace an index file with the entries from `treeish`. + pub fn read_tree(&self, treeish: &str, index_path: Option<&Path>) -> Result<()> { + let repo = self.gix()?; + let tree = resolve_tree(&repo, treeish)?; + let mut index = repo + .index_from_tree(&tree) + .map_err(|e| Error::backend("git read-tree", e))?; + if let Some(path) = index_path { + index.set_path(path); + } + index + .write(INDEX_WRITE) + .map_err(|e| Error::backend("git read-tree", e)) + } + + /// Write an index as a tree object and return its object id. + pub fn write_tree(&self, index_path: Option<&Path>) -> Result { + let repo = self.gix()?; + let index = match index_path { + Some(path) => gix::index::File::at(path, repo.object_hash(), false, Default::default()) + .map_err(|e| Error::backend("git write-tree", e))?, + None => repo + .open_index() + .map_err(|e| Error::backend("git write-tree", e))?, + }; + Ok(write_index_tree(&repo, &index)?.to_hex().to_string()) + } + + /// Set one repository-local configuration value while preserving formatting. + pub fn config_set(&self, key: &str, value: &str) -> Result<()> { + set_config_file(&self.info().common_dir.join("config"), key, value) + } + + /// Add a remote idempotently when its URL already matches. + pub fn remote_add(&self, name: &str, url: &str) -> Result<()> { + let key = format!("remote.{name}.url"); + let repo = self.gix()?; + if let Some(existing) = repo.config_snapshot().string(&key) { + let existing = existing.to_str_lossy(); + if existing == url { + return Ok(()); + } + return Err(Error::backend( + "git remote add", + format!("remote {name} already exists with URL {existing}, expected {url}"), + )); + } + self.config_set(&key, url) + } + + /// Create a linked worktree and materialize its checkout. + pub fn worktree_add(&self, path: &Path, ref_name: &str, detach: bool) -> Result<()> { + let repo = self.gix()?; + let id = resolve_commit(&repo, ref_name)?; + if path.exists() && fs::read_dir(path)?.next().is_some() { + return Err(Error::backend( + "git worktree add", + "destination already exists and is not empty", + )); + } + fs::create_dir_all(path)?; + let name = worktree_admin_name(&self.info().common_dir, path); + let admin = self.info().common_dir.join("worktrees").join(&name); + fs::create_dir_all(&admin)?; + fs::write(path.join(".git"), format!("gitdir: {}\n", admin.display()))?; + fs::write(admin.join("gitdir"), format!("{}\n", path.join(".git").display()))?; + fs::write(admin.join("commondir"), "../..\n")?; + let head = if detach { + id.to_hex().to_string() + } else { + let full = if ref_name.starts_with("refs/heads/") { + ref_name.to_owned() + } else { + format!("refs/heads/{ref_name}") + }; + if branch_is_checked_out(&self.info().common_dir, &full) { + return Err(Error::backend( + "git worktree add", + format!("'{full}' is already checked out"), + )); + } + if repo + .try_find_reference(&full) + .map_err(|e| Error::backend("git worktree add", e))? + .is_none() + { + update_reference( + &repo, + "git worktree add", + full.as_str(), + id, + gix::refs::transaction::PreviousValue::MustNotExist, + "branch: Created from worktree add", + false, + )?; + } + format!("ref: {full}") + }; + fs::write(admin.join("HEAD"), format!("{head}\n"))?; + let linked = Self::require(path)?; + let linked_repo = linked.gix()?; + checkout_tree(&linked, &linked_repo, id, true)?; + Ok(()) + } + + /// Remove a linked worktree, returning false when dirty and not forced. + pub fn worktree_remove(&self, path: &Path, force: bool) -> Result { + let Some(linked) = Self::discover(path)? else { + return Ok(false); + }; + if !force && tracked_worktree_dirty(&linked)? { + return Ok(false); + } + let admin = linked.info().git_dir.clone(); + fs::remove_dir_all(path)?; + if admin.starts_with(self.info().common_dir.join("worktrees")) { + fs::remove_dir_all(admin)?; + } + Ok(true) + } + + /// Prune linked-worktree administration entries whose back-reference + /// vanished. + pub fn worktree_prune(&self) -> Result<()> { + let root = self.info().common_dir.join("worktrees"); + let Ok(entries) = fs::read_dir(&root) else { + return Ok(()); + }; + for entry in entries { + let entry = entry?; + let back = fs::read_to_string(entry.path().join("gitdir")).unwrap_or_default(); + if back.trim().is_empty() || !Path::new(back.trim()).exists() { + fs::remove_dir_all(entry.path())?; + } + } + Ok(()) + } +} + +fn run_commit_hook( + repository: &GitRepo, + repo: &gix::Repository, + name: &str, + args: &[&OsStr], +) -> Result<()> { + let hooks_dir = repo + .config_snapshot() + .string("core.hooksPath") + .map(|value| PathBuf::from(value.to_str_lossy().into_owned())) + .map_or_else( + || repository.info().git_dir.join("hooks"), + |path| { + if path.is_absolute() { + path + } else { + repository.root().join(path) + } + }, + ); + let hook = hooks_dir.join(name); + if !hook_is_executable(&hook)? { + return Ok(()); + } + let output = Command::new(&hook) + .args(args) + .current_dir(repository.root()) + .env("GIT_DIR", &repository.info().git_dir) + .env("GIT_WORK_TREE", repository.root()) + .env("GIT_TERMINAL_PROMPT", "0") + .stdin(Stdio::null()) + .output() + .map_err(|err| Error::Cli { + command: format!("git commit ({name} hook)"), + exit_code: 1, + stdout: String::new(), + stderr: err.to_string(), + })?; + if output.status.success() { + return Ok(()); + } + Err(Error::Cli { + command: format!("git commit ({name} hook)"), + exit_code: output.status.code().unwrap_or(1), + stdout: String::from_utf8_lossy(&output.stdout).into_owned(), + stderr: String::from_utf8_lossy(&output.stderr).into_owned(), + }) +} + +fn hook_is_executable(path: &Path) -> Result { + let metadata = match fs::metadata(path) { + Ok(metadata) => metadata, + Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(false), + Err(err) => return Err(err.into()), + }; + if !metadata.is_file() { + return Ok(false); + } + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + Ok(metadata.permissions().mode() & 0o111 != 0) + } + #[cfg(not(unix))] + { + Ok(true) + } +} + +fn read_optional_file(path: &Path) -> Result>> { + match fs::read(path) { + Ok(bytes) => Ok(Some(bytes)), + Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(None), + Err(err) => Err(err.into()), + } +} + +/// Sever a copied linked worktree from its source metadata without copying +/// objects. +pub fn detach_git_dir( + worktree_root: &Path, + source_common_dir: &Path, +) -> Result { + let git_entry = worktree_root.join(".git"); + let meta = match fs::symlink_metadata(&git_entry) { + Ok(meta) => meta, + Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(DetachGitDirResult::NoGit), + Err(e) => return Err(e.into()), + }; + let source_common = + fs::canonicalize(source_common_dir).unwrap_or_else(|_| normalize_path(source_common_dir)); + let original = GitRepo::require(worktree_root)?; + let iso_common = fs::canonicalize(&original.info().common_dir) + .unwrap_or_else(|_| normalize_path(&original.info().common_dir)); + if iso_common != source_common { + return Ok(DetachGitDirResult::Independent); + } + let repo = original.gix()?; + let head = read_optional_file(&original.info().head_path)?; + let index = read_optional_file(&original.info().git_dir.join("index"))?; + let refs = snapshot_refs(&repo)?; + let config_values = [ + "user.name", + "user.email", + "core.fileMode", + "core.splitIndex", + "core.sparseCheckout", + "core.sparseCheckoutCone", + ] + .into_iter() + .filter_map(|key| { + repo + .config_snapshot() + .string(key) + .map(|v| (key, v.to_str_lossy().into_owned())) + }) + .collect::>(); + let shared = copy_named_files(&original.info().git_dir, "sharedindex.")?; + let sparse = read_optional_file(&original.info().git_dir.join("info/sparse-checkout"))?; + let shallow = read_optional_file(&source_common.join("shallow"))?; + let own_admin = if meta.is_file() { + registered_admin(&git_entry)? + } else { + None + }; + if meta.is_dir() { + fs::remove_dir_all(&git_entry)?; + } else { + fs::remove_file(&git_entry)?; + } + if let Some(admin) = own_admin { + fs::remove_dir_all(admin)?; + } + gix::init(worktree_root).map_err(|e| Error::backend("git init", e))?; + let objects_info = git_entry.join("objects/info"); + fs::create_dir_all(&objects_info)?; + let mut alternates = vec![source_common.join("objects")]; + if let Ok(chained) = fs::read_to_string(source_common.join("objects/info/alternates")) { + for line in chained + .lines() + .map(str::trim) + .filter(|line| !line.is_empty()) + { + let path = Path::new(line); + alternates.push(if path.is_absolute() { + path.to_owned() + } else { + source_common.join("objects").join(path) + }); + } + } + let alternate_text = alternates + .iter() + .map(|p| p.to_string_lossy()) + .collect::>() + .join("\n") + + "\n"; + fs::write(objects_info.join("alternates"), alternate_text)?; + for (name, id) in refs { + write_loose_ref(&git_entry, &name, id)?; + } + if let Some(head) = head { + fs::write(git_entry.join("HEAD"), head)?; + } + for (key, value) in config_values { + set_config_file(&git_entry.join("config"), key, &value)?; + } + if let Some(bytes) = shallow { + fs::write(git_entry.join("shallow"), bytes)?; + } + if let Some(bytes) = sparse { + fs::create_dir_all(git_entry.join("info"))?; + fs::write(git_entry.join("info/sparse-checkout"), bytes)?; + } + for (name, bytes) in shared { + fs::write(git_entry.join(name), bytes)?; + } + if let Some(bytes) = index { + fs::write(git_entry.join("index"), bytes)?; + } else if let Ok(detached) = GitRepo::require(worktree_root) + && resolve_commit(&detached.gix()?, "HEAD").is_ok() + { + detached.read_tree("HEAD", None)?; + } + Ok(DetachGitDirResult::Detached) +} + +fn resolve_commit(repo: &gix::Repository, spec: &str) -> Result { + let id = repo + .rev_parse_single(spec) + .map_err(|_| Error::ObjectNotFound { spec: spec.to_owned() })?; + let object = id + .object() + .map_err(|_| Error::ObjectNotFound { spec: spec.to_owned() })?; + object + .peel_to_commit() + .map(|commit| commit.id) + .map_err(|_| Error::ObjectNotFound { spec: spec.to_owned() }) +} + +fn resolve_tree(repo: &gix::Repository, spec: &str) -> Result { + let id = repo + .rev_parse_single(spec) + .map_err(|_| Error::ObjectNotFound { spec: spec.to_owned() })?; + let object = id + .object() + .map_err(|_| Error::ObjectNotFound { spec: spec.to_owned() })?; + object + .peel_to_tree() + .map(|tree| tree.id) + .map_err(|_| Error::ObjectNotFound { spec: spec.to_owned() }) +} + +fn commit_tree(repo: &gix::Repository, id: &gix::hash::ObjectId) -> Result { + let commit = repo + .find_commit(*id) + .map_err(|e| Error::backend("git commit", e))?; + commit + .tree_id() + .map(|id| id.detach()) + .map_err(|e| Error::backend("git commit", e)) +} + +fn head_tree(repo: &gix::Repository) -> Result> { + match repo + .head() + .map_err(|e| Error::backend("git reset", e))? + .try_peel_to_id() + .map_err(|e| Error::backend("git reset", e))? + { + Some(id) => Ok(Some( + id.object() + .map_err(|e| Error::backend("git reset", e))? + .peel_to_commit() + .map_err(|e| Error::backend("git reset", e))? + .tree_id() + .map_err(|e| Error::backend("git reset", e))? + .detach(), + )), + None => Ok(None), + } +} + +fn index_for_tree( + repo: &gix::Repository, + tree: Option<&gix::hash::ObjectId>, +) -> Result { + match tree { + Some(tree) => repo + .index_from_tree(tree) + .map_err(|e| Error::backend("git index", e)), + None => Ok(gix::index::File::from_state( + gix::index::State::new(repo.object_hash()), + repo.index_path(), + )), + } +} + +fn collect_stage_paths(root: &Path, files: &[String]) -> Result> { + let ignores = load_ignore_patterns(root); + let mut candidates = Vec::new(); + if files.is_empty() { + walk_files(root, root, &mut candidates)?; + } else { + for item in files { + let path = root.join(item); + if path.is_dir() { + walk_files(root, &path, &mut candidates)?; + } else if path.exists() || fs::symlink_metadata(&path).is_ok() { + candidates.push(item.replace('\\', "/")); + } + } + } + Ok(candidates + .into_iter() + .filter(|path| !is_ignored(path, &ignores)) + .collect()) +} + +fn stage_one( + repo: &gix::Repository, + root: &Path, + index: &mut gix::index::File, + path: &str, +) -> Result<()> { + let full = root.join(path); + let metadata = fs::symlink_metadata(&full)?; + let (data, mode) = if metadata.file_type().is_symlink() { + ( + fs::read_link(&full)? + .to_string_lossy() + .into_owned() + .into_bytes(), + gix::index::entry::Mode::SYMLINK, + ) + } else { + let mode = if is_executable(&metadata) { + gix::index::entry::Mode::FILE_EXECUTABLE + } else { + gix::index::entry::Mode::FILE + }; + (fs::read(&full)?, mode) + }; + let id = repo + .write_blob(&data) + .map_err(|e| Error::backend("git add", e))? + .detach(); + index.remove_entries(|_, p, _| p == path.as_bytes().as_bstr()); + index.dangerously_push_entry( + Default::default(), + id, + gix::index::entry::Flags::empty(), + mode, + path.as_bytes().as_bstr(), + ); + Ok(()) +} + +#[cfg(unix)] +fn is_executable(meta: &fs::Metadata) -> bool { + use std::os::unix::fs::PermissionsExt; + meta.permissions().mode() & 0o111 != 0 +} +#[cfg(not(unix))] +fn is_executable(_: &fs::Metadata) -> bool { + false +} + +fn copy_index_paths(dest: &mut gix::index::File, source: &gix::index::File, files: &[String]) { + let all = files.is_empty(); + dest.remove_entries(|_, path, _| { + all || files + .iter() + .any(|wanted| path_matches(&path.to_str_lossy(), wanted)) + }); + for entry in source.entries() { + let path = entry.path(source); + if all + || files + .iter() + .any(|wanted| path_matches(&path.to_str_lossy(), wanted)) + { + dest.dangerously_push_entry(entry.stat, entry.id, entry.flags, entry.mode, path); + } + } + dest.sort_entries(); +} + +#[derive(Default)] +struct TreeNode { + files: Vec<(BString, gix::index::entry::Mode, gix::hash::ObjectId)>, + dirs: BTreeMap, +} + +fn write_index_tree( + repo: &gix::Repository, + index: &gix::index::File, +) -> Result { + let mut root = TreeNode::default(); + for entry in index + .entries() + .iter() + .filter(|e| e.stage() == gix::index::entry::Stage::Unconflicted) + { + let parts: Vec<&[u8]> = entry.path(index).split(|b| *b == b'/').collect(); + let mut node = &mut root; + for part in &parts[..parts.len().saturating_sub(1)] { + node = node.dirs.entry(BString::from(*part)).or_default(); + } + if let Some(name) = parts.last() { + node + .files + .push((BString::from(*name), entry.mode, entry.id)); + } + } + write_tree_node(repo, root) +} + +fn write_tree_node(repo: &gix::Repository, node: TreeNode) -> Result { + let mut entries = Vec::with_capacity(node.files.len() + node.dirs.len()); + for (name, mode, oid) in node.files { + let mode = gix::objs::tree::EntryMode::try_from(mode.bits()) + .map_err(|m| Error::backend("git write-tree", format!("invalid mode {m:o}")))?; + entries.push(gix::objs::tree::Entry { mode, filename: name, oid }); + } + for (name, child) in node.dirs { + entries.push(gix::objs::tree::Entry { + mode: gix::objs::tree::EntryKind::Tree.into(), + filename: name, + oid: write_tree_node(repo, child)?, + }); + } + entries.sort(); + repo + .write_object(&gix::objs::Tree { entries }) + .map(|id| id.detach()) + .map_err(|e| Error::backend("git write-tree", e)) +} + +fn resolve_checkout_target( + repo: &gix::Repository, + rev: &str, +) -> Result<(gix::hash::ObjectId, Option)> { + let branch = if rev.starts_with("refs/heads/") { + Some(rev.to_owned()) + } else { + let full = format!("refs/heads/{rev}"); + repo + .try_find_reference(&full) + .map_err(|e| Error::backend("git checkout", e))? + .map(|_| full) + }; + Ok((resolve_commit(repo, branch.as_deref().unwrap_or(rev))?, branch)) +} + +fn checkout_tree( + owner: &GitRepo, + repo: &gix::Repository, + commit: gix::hash::ObjectId, + overwrite: bool, +) -> Result<()> { + let tree = commit_tree(repo, &commit)?; + let mut target = repo + .index_from_tree(&tree) + .map_err(|e| Error::backend("git checkout", e))?; + let current = load_index_or_head(repo, "git checkout")?; + let conflicts = checkout_conflicts(owner.root(), repo, ¤t, &target)?; + if !overwrite && !conflicts.is_empty() { + return Err(Error::Conflict { paths: conflicts }); + } + let mut collisions = Vec::new(); + for entry in target.entries() { + let path = entry.path(&target).to_str_lossy().into_owned(); + if current.entry_by_path(path.as_bytes().as_bstr()).is_none() + && fs::symlink_metadata(owner.root().join(&path)).is_ok() + { + collisions.push(path); + } + } + if !collisions.is_empty() { + return Err(Error::Conflict { paths: collisions }); + } + let target_paths: BTreeSet = target + .entries() + .iter() + .map(|e| e.path(&target).to_str_lossy().into_owned()) + .collect(); + for entry in current.entries() { + let path = entry.path(¤t).to_str_lossy(); + if !target_paths.contains(path.as_ref()) { + let full = owner.root().join(path.as_ref()); + if full.is_file() || fs::symlink_metadata(&full).is_ok() { + fs::remove_file(full)?; + } + } + } + let mut opts = repo + .checkout_options(gix::worktree::stack::state::attributes::Source::IdMapping) + .map_err(|e| Error::backend("git checkout", e))?; + opts.overwrite_existing = true; + let progress = gix::progress::Discard; + let interrupt = std::sync::atomic::AtomicBool::new(false); + gix::worktree::state::checkout( + &mut target, + owner.root(), + repo + .objects + .clone() + .into_arc() + .map_err(|e| Error::backend("git checkout", e))?, + &progress, + &progress, + &interrupt, + opts, + ) + .map_err(|e| Error::backend("git checkout", e))?; + target + .write(INDEX_WRITE) + .map_err(|e| Error::backend("git checkout", e)) +} + +fn checkout_conflicts( + root: &Path, + repo: &gix::Repository, + current: &gix::index::File, + target: &gix::index::File, +) -> Result> { + let mut conflicts = Vec::new(); + for entry in current.entries() { + let path = entry.path(current).to_str_lossy().into_owned(); + let target_entry = target.entry_by_path(path.as_bytes().as_bstr()); + if target_entry.is_some_and(|e| e.id == entry.id && e.mode == entry.mode) { + continue; + } + if worktree_id(repo, &root.join(&path), entry.mode)? != Some(entry.id) { + conflicts.push(path); + } + } + conflicts.sort(); + conflicts.dedup(); + Ok(conflicts) +} + +fn worktree_id( + repo: &gix::Repository, + path: &Path, + mode: gix::index::entry::Mode, +) -> Result> { + if !path.exists() && fs::symlink_metadata(path).is_err() { + return Ok(None); + } + let data = if mode == gix::index::entry::Mode::SYMLINK { + fs::read_link(path)? + .to_string_lossy() + .into_owned() + .into_bytes() + } else { + fs::read(path)? + }; + Ok(Some( + gix::objs::compute_hash(repo.object_hash(), gix::objs::Kind::Blob, &data) + .map_err(|e| Error::backend("git checkout", e))?, + )) +} + +fn write_head(path: &Path, symbolic: Option<&str>, id: gix::hash::ObjectId) -> Result<()> { + fs::write(path, match symbolic { + Some(name) => format!("ref: {name}\n"), + None => format!("{}\n", id.to_hex()), + })?; + Ok(()) +} + +fn update_current_head(repo: &gix::Repository, path: &Path, id: gix::hash::ObjectId) -> Result<()> { + let content = fs::read_to_string(path).unwrap_or_default(); + if let Some(name) = content.trim().strip_prefix("ref: ") { + update_reference( + repo, + "git reset", + name, + id, + gix::refs::transaction::PreviousValue::Any, + "reset: moving to target", + false, + )?; + } else { + fs::write(path, format!("{}\n", id.to_hex()))?; + } + Ok(()) +} + +fn restore_index_paths( + root: &Path, + repo: &gix::Repository, + index: &gix::index::File, + files: &[String], +) -> Result<()> { + for entry in index.entries() { + let path = entry.path(index).to_str_lossy(); + if files.is_empty() || files.iter().any(|wanted| path_matches(&path, wanted)) { + let object = repo + .find_object(entry.id) + .map_err(|e| Error::backend("git restore", e))?; + let blob = object + .try_into_blob() + .map_err(|e| Error::backend("git restore", e))?; + let full = root.join(path.as_ref()); + if let Some(parent) = full.parent() { + fs::create_dir_all(parent)?; + } + fs::write(full, &blob.data)?; + } + } + Ok(()) +} + +fn path_matches(path: &str, wanted: &str) -> bool { + let wanted = wanted.trim_end_matches('/'); + path == wanted + || path + .strip_prefix(wanted) + .is_some_and(|r| r.starts_with('/')) +} + +fn walk_files(root: &Path, dir: &Path, out: &mut Vec) -> Result<()> { + for entry in fs::read_dir(dir)? { + let entry = entry?; + let path = entry.path(); + if path == root.join(".git") { + continue; + } + let kind = entry.file_type()?; + if kind.is_dir() { + walk_files(root, &path, out)?; + } else { + out.push( + path + .strip_prefix(root) + .map_err(|e| Error::backend("git walk", e))? + .to_string_lossy() + .replace('\\', "/"), + ); + } + } + Ok(()) +} + +fn load_ignore_patterns(root: &Path) -> Vec { + let mut out = Vec::new(); + for path in [root.join(".gitignore"), root.join(".git/info/exclude")] { + if let Ok(text) = fs::read_to_string(path) { + out.extend( + text + .lines() + .map(str::trim) + .filter(|l| !l.is_empty() && !l.starts_with('#')) + .map(str::to_owned), + ); + } + } + out +} + +fn is_ignored(path: &str, patterns: &[String]) -> bool { + let mut ignored = false; + for raw in patterns { + let (negate, pattern) = raw + .strip_prefix('!') + .map_or((false, raw.as_str()), |p| (true, p)); + let pattern = pattern.trim_start_matches('/').trim_end_matches('/'); + let matches = if pattern.contains('*') { + wildcard_match(pattern, path) || path.split('/').any(|part| wildcard_match(pattern, part)) + } else { + path == pattern + || path.starts_with(&format!("{pattern}/")) + || path.split('/').any(|part| part == pattern) + }; + if matches { + ignored = !negate; + } + } + ignored +} + +const fn wildcard_match(pattern: &str, text: &str) -> bool { + let (mut p, mut t, mut star, mut mark) = (0, 0, None, 0); + let (pb, tb) = (pattern.as_bytes(), text.as_bytes()); + while t < tb.len() { + if p < pb.len() && (pb[p] == b'?' || pb[p] == tb[t]) { + p += 1; + t += 1; + } else if p < pb.len() && pb[p] == b'*' { + star = Some(p); + p += 1; + mark = t; + } else if let Some(s) = star { + p = s + 1; + mark += 1; + t = mark; + } else { + return false; + } + } + while p < pb.len() && pb[p] == b'*' { + p += 1; + } + p == pb.len() +} + +fn remove_empty_dirs(root: &Path, dir: &Path) -> Result { + for entry in fs::read_dir(dir)? { + let path = entry?.path(); + if path.is_dir() && path != root.join(".git") { + remove_empty_dirs(root, &path)?; + } + } + let empty = dir != root && fs::read_dir(dir)?.next().is_none(); + if empty { + fs::remove_dir(dir)?; + } + Ok(empty) +} + +fn set_config_file(path: &Path, key: &str, value: &str) -> Result<()> { + let mut config = if path.exists() { + gix::config::File::from_path_no_includes(path.to_owned(), gix::config::Source::Local) + .map_err(|e| Error::backend("git config", e))? + } else { + gix::config::File::default() + }; + config + .set_raw_value(key, value) + .map_err(|e| Error::backend("git config", e))?; + let mut bytes = Vec::new(); + config.write_to(&mut bytes)?; + fs::write(path, bytes)?; + Ok(()) +} + +fn worktree_admin_name(common: &Path, path: &Path) -> String { + let base = path + .file_name() + .and_then(|s| s.to_str()) + .filter(|s| !s.is_empty()) + .unwrap_or("worktree"); + let mut name = base.to_owned(); + let mut n = 1; + while common.join("worktrees").join(&name).exists() { + name = format!("{base}{n}"); + n += 1; + } + name +} + +fn branch_is_checked_out(common: &Path, full_ref: &str) -> bool { + let expected = format!("ref: {full_ref}"); + if fs::read_to_string(common.join("HEAD")).is_ok_and(|head| head.trim() == expected) { + return true; + } + let Ok(entries) = fs::read_dir(common.join("worktrees")) else { + return false; + }; + entries.filter_map(std::result::Result::ok).any(|entry| { + fs::read_to_string(entry.path().join("HEAD")).is_ok_and(|head| head.trim() == expected) + }) +} + +fn tracked_worktree_dirty(repo: &GitRepo) -> Result { + let gix = repo.gix()?; + let index = load_index_or_head(&gix, "git worktree remove")?; + for entry in index.entries() { + if worktree_id( + &gix, + &repo.root().join(entry.path(&index).to_str_lossy().as_ref()), + entry.mode, + )? != Some(entry.id) + { + return Ok(true); + } + } + Ok(false) +} + +fn snapshot_refs(repo: &gix::Repository) -> Result> { + let platform = repo + .references() + .map_err(|e| Error::backend("git detach", e))?; + let iter = platform + .all() + .map_err(|e| Error::backend("git detach", e))?; + let mut out = Vec::new(); + for reference in iter { + let mut reference = reference.map_err(|e| Error::backend("git detach", e))?; + let name = reference.name().as_bstr().to_str_lossy().into_owned(); + if let Ok(id) = reference.peel_to_id() { + out.push((name, id.detach())); + } + } + Ok(out) +} + +fn copy_named_files(dir: &Path, prefix: &str) -> Result)>> { + let mut out = Vec::new(); + let Ok(entries) = fs::read_dir(dir) else { + return Ok(out); + }; + for entry in entries { + let entry = entry?; + let name = entry.file_name().to_string_lossy().into_owned(); + if name.starts_with(prefix) { + out.push((name, fs::read(entry.path())?)); + } + } + Ok(out) +} + +fn registered_admin(git_entry: &Path) -> Result> { + let text = fs::read_to_string(git_entry)?; + let Some(raw) = text.trim().strip_prefix("gitdir:") else { + return Ok(None); + }; + let admin = normalize_path( + &git_entry + .parent() + .unwrap_or_else(|| Path::new(".")) + .join(raw.trim()), + ); + let back = fs::read_to_string(admin.join("gitdir")).unwrap_or_default(); + let real_back = + fs::canonicalize(back.trim()).unwrap_or_else(|_| normalize_path(Path::new(back.trim()))); + let real_entry = fs::canonicalize(git_entry).unwrap_or_else(|_| normalize_path(git_entry)); + Ok((real_back == real_entry).then_some(admin)) +} + +fn write_loose_ref(git_dir: &Path, name: &str, id: gix::hash::ObjectId) -> Result<()> { + let path = git_dir.join(name); + if let Some(parent) = path.parent() { + fs::create_dir_all(parent)?; + } + fs::write(path, format!("{}\n", id.to_hex()))?; + Ok(()) +} +#[cfg(test)] +mod tests { + use std::process::Command; + + use tempfile::TempDir; + + use super::*; + use crate::types::CommitAuthor; + + fn git(dir: &Path, args: &[&str]) -> String { + let output = Command::new("git") + .arg("-C") + .arg(dir) + .args(args) + .output() + .unwrap(); + assert!(output.status.success(), "git {args:?}: {}", String::from_utf8_lossy(&output.stderr)); + String::from_utf8(output.stdout) + .unwrap() + .trim_end() + .to_owned() + } + + fn fixture() -> (TempDir, GitRepo) { + let temp = tempfile::tempdir().unwrap(); + git(temp.path(), &["init", "-q", "-b", "main"]); + git(temp.path(), &["config", "user.name", "Test"]); + git(temp.path(), &["config", "user.email", "test@example.com"]); + fs::write(temp.path().join("a"), "one\n").unwrap(); + fs::write(temp.path().join("b"), "two\n").unwrap(); + git(temp.path(), &["add", "."]); + git(temp.path(), &["commit", "-qm", "base"]); + let repo = GitRepo::require(temp.path()).unwrap(); + (temp, repo) + } + + #[test] + fn mutate_stage_commit_amend_and_empty() { + let (temp, repo) = fixture(); + fs::write(temp.path().join("a"), "changed\n").unwrap(); + fs::write(temp.path().join("new"), "new\n").unwrap(); + repo.stage_files(&["a".into()]).unwrap(); + assert_eq!(git(temp.path(), &["status", "--porcelain"]), "M a\n?? new"); + let first = repo + .commit_create("change", &CommitOptions { + author: Some(CommitAuthor { + name: "Other".into(), + email: "other@example.com".into(), + date: Some("2020-01-02T03:04:05Z".into()), + }), + ..Default::default() + }) + .unwrap(); + assert_eq!(git(temp.path(), &["rev-parse", "HEAD"]), first); + assert_eq!( + git(temp.path(), &["show", "-s", "--format=%an <%ae>", "HEAD"]), + "Other " + ); + assert!( + repo + .commit_create("empty", &CommitOptions::default()) + .is_err() + ); + fs::write(temp.path().join("a"), "amended\n").unwrap(); + repo.stage_files(&["a".into()]).unwrap(); + let amended = repo + .commit_create("amended", &CommitOptions { amend: true, ..Default::default() }) + .unwrap(); + assert_ne!(first, amended); + assert_eq!(git(temp.path(), &["rev-list", "--count", "HEAD"]), "2"); + repo.stage_files(&[]).unwrap(); + assert_eq!(git(temp.path(), &["status", "--porcelain"]), "A new"); + repo.unstage(&[]).unwrap(); + assert_eq!(git(temp.path(), &["status", "--porcelain"]), "?? new"); + } + + #[cfg(unix)] + fn write_hook(path: &Path, body: &str, executable: bool) { + use std::os::unix::fs::PermissionsExt; + fs::write(path, format!("#!/bin/sh\n{body}\n")).unwrap(); + let mode = if executable { 0o755 } else { 0o644 }; + fs::set_permissions(path, fs::Permissions::from_mode(mode)).unwrap(); + } + + #[test] + fn stage_commit_survives_unadvanced_index_mtime() { + // Regression: a commit right after staging on the same cached handle used + // to read a stale in-memory index snapshot when the on-disk index mtime + // did not advance past the snapshot's (sub-second writes / coarse mtime + // filesystems), failing with "nothing to commit, working tree clean". + let (temp, repo) = fixture(); + // Pin the mtime so the snapshot captured while staging and the index the + // write leaves behind collide on the exact same tick. + crate::git::pin_index_mtime(&repo); + + fs::write(temp.path().join("a"), "changed\n").unwrap(); + repo.stage_files(&["a".into()]).unwrap(); + // Staging bumped the mtime; forcing it back reproduces the same-tick + // collision that made gix serve the pre-stage index. + crate::git::pin_index_mtime(&repo); + + let sha = repo + .commit_create("change", &CommitOptions::default()) + .unwrap(); + assert_eq!(git(temp.path(), &["rev-parse", "HEAD"]), sha); + // The commit must carry the staged content, not the stale base index. + assert_eq!(git(temp.path(), &["show", "HEAD:a"]), "changed"); + } + + #[cfg(unix)] + #[test] + fn commit_hooks_match_git_commit_behavior() { + let (temp, repo) = fixture(); + let hooks = temp.path().join(".git/hooks"); + let pre_commit = hooks.join("pre-commit"); + write_hook(&pre_commit, "echo 'policy says no' >&2\nexit 1", true); + fs::write(temp.path().join("a"), "blocked\n").unwrap(); + repo.stage_files(&["a".into()]).unwrap(); + let before = git(temp.path(), &["rev-parse", "HEAD"]); + let error = repo + .commit_create("blocked", &CommitOptions::default()) + .unwrap_err(); + assert!(matches!( + &error, + Error::Cli { stderr, .. } if stderr.contains("policy says no") + )); + assert_eq!(git(temp.path(), &["rev-parse", "HEAD"]), before); + + fs::remove_file(&pre_commit).unwrap(); + write_hook( + &hooks.join("commit-msg"), + "printf 'rewritten subject\\n\\nrewritten body\\n' > \"$1\"", + true, + ); + repo + .commit_create("original", &CommitOptions::default()) + .unwrap(); + assert_eq!( + git(temp.path(), &["log", "-1", "--pretty=%B"]), + "rewritten subject\n\nrewritten body" + ); + + fs::write(temp.path().join("b"), "changed again\n").unwrap(); + repo.stage_files(&["b".into()]).unwrap(); + fs::remove_file(hooks.join("commit-msg")).unwrap(); + repo + .commit_create("missing hook is skipped", &CommitOptions::default()) + .unwrap(); + + fs::write(temp.path().join("b"), "one more\n").unwrap(); + repo.stage_files(&["b".into()]).unwrap(); + write_hook(&pre_commit, "echo should-not-run >&2\nexit 1", false); + repo + .commit_create("non-executable hook is skipped", &CommitOptions::default()) + .unwrap(); + fs::remove_file(&pre_commit).unwrap(); + repo + .commit_create("subject\n\nbody\n\n", &CommitOptions { + allow_empty: true, + ..CommitOptions::default() + }) + .unwrap(); + assert_eq!(repo.commit_details("HEAD").unwrap().message, "subject\n\nbody\n"); + } + + #[test] + fn mutate_checkout_branches_and_resets() { + let (temp, repo) = fixture(); + repo.create_branch("other", "HEAD", false).unwrap(); + fs::write(temp.path().join("a"), "main\n").unwrap(); + repo.stage_files(&["a".into()]).unwrap(); + let main = repo + .commit_create("main", &CommitOptions::default()) + .unwrap(); + fs::write(temp.path().join("a"), "dirty\n").unwrap(); + assert!(matches!(repo.checkout("other"), Err(Error::Conflict { .. }))); + fs::write(temp.path().join("a"), "main\n").unwrap(); + repo.checkout("other").unwrap(); + assert_eq!(git(temp.path(), &["symbolic-ref", "--short", "HEAD"]), "other"); + repo.checkout("main").unwrap(); + repo.reset(ResetMode::Soft, Some("HEAD^")).unwrap(); + assert!(git(temp.path(), &["status", "--porcelain"]).starts_with("M a")); + repo.reset(ResetMode::Hard, Some(&main)).unwrap(); + assert_eq!(git(temp.path(), &["status", "--porcelain"]), ""); + fs::write(temp.path().join("a"), "mixed\n").unwrap(); + repo.stage_files(&["a".into()]).unwrap(); + repo.reset(ResetMode::Mixed, Some("HEAD^")).unwrap(); + assert_eq!(git(temp.path(), &["status", "--porcelain"]), " M a"); + repo.reset(ResetMode::Hard, Some(&main)).unwrap(); + assert!(repo.delete_branch("other", true).unwrap()); + assert!(!repo.delete_branch("missing", true).unwrap()); + } + + #[test] + fn mutate_clean_and_alternate_index() { + let (temp, repo) = fixture(); + fs::write(temp.path().join(".gitignore"), "ignored\n").unwrap(); + repo.stage_files(&[".gitignore".into()]).unwrap(); + repo + .commit_create("ignore", &CommitOptions::default()) + .unwrap(); + fs::write(temp.path().join("ignored"), "x").unwrap(); + fs::write(temp.path().join("untracked"), "x").unwrap(); + repo.clean(&CleanOptions::default()).unwrap(); + assert!(temp.path().join("ignored").exists()); + assert!(!temp.path().join("untracked").exists()); + repo + .clean(&CleanOptions { ignored_only: true, ..Default::default() }) + .unwrap(); + assert!(!temp.path().join("ignored").exists()); + fs::write(temp.path().join("ignored"), "x").unwrap(); + fs::write(temp.path().join("untracked"), "x").unwrap(); + repo + .clean(&CleanOptions { include_ignored: true, ..Default::default() }) + .unwrap(); + assert!(!temp.path().join("ignored").exists()); + assert!(!temp.path().join("untracked").exists()); + let alternate = temp.path().join("alternate-index"); + repo.read_tree("HEAD", Some(&alternate)).unwrap(); + assert_eq!( + repo.write_tree(Some(&alternate)).unwrap(), + git(temp.path(), &["rev-parse", "HEAD^{tree}"]) + ); + } + + #[cfg(unix)] + #[test] + fn detach_git_dir_does_not_mutate_when_index_snapshot_fails() { + use std::os::unix::fs::PermissionsExt; + + let (temp, repo) = fixture(); + let linked = temp.path().join("../linked-unreadable-index"); + let _ = fs::remove_dir_all(&linked); + repo.worktree_add(&linked, "main", true).unwrap(); + let common = fs::canonicalize(repo.info().common_dir.clone()).unwrap(); + let linked_repo = GitRepo::require(&linked).unwrap(); + let index_path = linked_repo.info().git_dir.join("index"); + let original_mode = fs::metadata(&index_path).unwrap().permissions().mode(); + let pointer_before = fs::read(linked.join(".git")).unwrap(); + fs::set_permissions(&index_path, fs::Permissions::from_mode(0o000)).unwrap(); + + let result = detach_git_dir(&linked, &common); + fs::set_permissions(&index_path, fs::Permissions::from_mode(original_mode)).unwrap(); + assert!(matches!( + &result, + Err(Error::Io(err)) if err.kind() == std::io::ErrorKind::PermissionDenied + )); + assert_eq!(fs::read(linked.join(".git")).unwrap(), pointer_before); + assert_eq!(git(temp.path(), &["rev-parse", "HEAD"]), git(&linked, &["rev-parse", "HEAD"])); + let _ = fs::remove_dir_all(linked); + } + + #[test] + fn mutate_worktree_and_detach() { + let (temp, repo) = fixture(); + let linked = temp.path().join("../linked-mut"); + let _ = fs::remove_dir_all(&linked); + repo.worktree_add(&linked, "main", true).unwrap(); + assert!( + git(temp.path(), &["worktree", "list", "--porcelain"]) + .contains(linked.to_string_lossy().as_ref()) + ); + assert!(repo.worktree_remove(&linked, true).unwrap()); + + let linked = temp.path().join("../linked-detach"); + let _ = fs::remove_dir_all(&linked); + repo.worktree_add(&linked, "main", true).unwrap(); + let common = fs::canonicalize(repo.info().common_dir.clone()).unwrap(); + let source_head = git(temp.path(), &["rev-parse", "HEAD"]); + assert_eq!(detach_git_dir(&linked, &common).unwrap(), DetachGitDirResult::Detached); + let alternates = fs::read_to_string(linked.join(".git/objects/info/alternates")).unwrap(); + assert!(alternates.contains(common.join("objects").to_string_lossy().as_ref())); + assert_eq!(git(&linked, &["rev-parse", "HEAD"]), git(temp.path(), &["rev-parse", "HEAD"])); + assert_eq!(git(temp.path(), &["rev-parse", "HEAD"]), source_head); + assert!( + !git(temp.path(), &["worktree", "list", "--porcelain"]) + .contains(linked.to_string_lossy().as_ref()) + ); + assert!(repo.worktree_prune().is_ok()); + let _ = fs::remove_dir_all(linked); + } +} diff --git a/crates/pi-vcs/src/git/open.rs b/crates/pi-vcs/src/git/open.rs new file mode 100644 index 000000000000..a1d2941fd68d --- /dev/null +++ b/crates/pi-vcs/src/git/open.rs @@ -0,0 +1,159 @@ +//! Lazy gitoxide handle management for [`GitRepo`](super::GitRepo). +//! +//! Owns the single place a `gix::ThreadSafeRepository` is opened: isolated +//! from ambient `GIT_DIR`/`GIT_INDEX_FILE`-style environment overrides (the +//! wrapper always operates on the discovered repository), while still honoring +//! user/system config for identity and diff settings. Reftable repositories +//! must never be opened here — callers route those through [`super::cli`]. + +use gix::{ + open::{Options, Permissions, permissions}, + sec::{Permission, Trust}, +}; + +use super::GitRepo; +use crate::error::{Error, Result}; + +impl GitRepo { + /// Thread-local gitoxide repository for this checkout, opening the shared + /// thread-safe handle on first use. + /// + /// Errors on reftable repositories: they are unreadable in-process and + /// every operation on them must use the CLI fallback instead. + pub(crate) fn gix(&self) -> Result { + if self.info().is_reftable { + return Err(Error::backend( + "git open", + "reftable repository cannot be opened in-process; use the CLI fallback", + )); + } + if let Some(repo) = self.gix.get() { + return Ok(repo.to_thread_local()); + } + let opened = open_options() + .open(self.root()) + .map_err(|err| Error::backend("git open", err))?; + // A concurrent open may have won the race; either handle is equivalent. + let repo = self.gix.get_or_init(move || opened); + Ok(repo.to_thread_local()) + } + + /// Freshly opened gitoxide repository, bypassing the cached handle. + /// + /// The cached handle snapshots config and refs at first open; callers that + /// must observe out-of-band mutations (config writes, remote edits) pay + /// for a fresh open instead. + pub(crate) fn gix_fresh(&self) -> Result { + if self.info().is_reftable { + return Err(Error::backend( + "git open", + "reftable repository cannot be opened in-process; use the CLI fallback", + )); + } + Ok(open_options() + .open(self.root()) + .map_err(|err| Error::backend("git open", err))? + .to_thread_local()) + } +} + +/// Load the persisted worktree index straight from disk, reconstructing it from +/// `HEAD^{tree}` (or an empty index when `HEAD` is unborn) if no index file +/// exists. +/// +/// Reads bypass gix's shared, mtime-gated index snapshot. The cached +/// [`gix`](GitRepo::gix) handle shares one +/// `SharedFileSnapshot` across every thread-local clone and +/// only reloads it when the index file's mtime is *strictly* newer than the +/// snapshot — gix's freshness check is deliberately sub-second-racy (`gix_fs` +/// `recent_snapshot` notes it "relies on sub-section precision or else is a +/// race … up to the caller"). The in-process mutators here write a fresh index +/// within the same mtime tick as the read that populated the snapshot, so a +/// later read through that snapshot would return the pre-mutation index — e.g. +/// a commit right after staging sees an unchanged tree and fails with "nothing +/// to commit, working tree clean". Reading the index from disk makes +/// mutate→read deterministic regardless of filesystem timestamp granularity. +pub(crate) fn load_index_or_head( + repo: &gix::Repository, + op: &'static str, +) -> Result { + match repo.open_index() { + Ok(index) => Ok(index), + Err(gix::worktree::open_index::Error::IndexFile(gix::index::file::init::Error::Io(err))) + if err.kind() == std::io::ErrorKind::NotFound => + { + Ok(repo + .index_or_load_from_head_or_empty() + .map_err(|err| Error::backend(op, err))? + .into_owned()) + }, + Err(err) => Err(Error::backend(op, err)), + } +} + +/// Load the persisted worktree index straight from disk, falling back to an +/// empty index (never `HEAD^{tree}`) when no index file exists. +/// +/// Same snapshot-bypass rationale as [`load_index_or_head`]; the empty-index +/// fallback matches gix's [`index_or_empty`](gix::Repository::index_or_empty). +pub(crate) fn load_index_or_empty( + repo: &gix::Repository, + op: &'static str, +) -> Result { + match repo.open_index() { + Ok(index) => Ok(index), + Err(gix::worktree::open_index::Error::IndexFile(gix::index::file::init::Error::Io(err))) + if err.kind() == std::io::ErrorKind::NotFound => + { + Ok(repo + .index_or_empty() + .map_err(|err| Error::backend(op, err))? + .into_owned_or_cloned()) + }, + Err(err) => Err(Error::backend(op, err)), + } +} + +/// Start a status query with an index loaded directly from disk. +/// +/// Supplying the index is required even after other read paths bypass the +/// shared snapshot: [`gix::Repository::status`] otherwise reacquires that same +/// mtime-gated snapshot internally. +pub(crate) fn status_with_fresh_index<'repo>( + repo: &'repo gix::Repository, + op: &'static str, +) -> Result> { + let index = load_index_or_empty(repo, op)?; + Ok(repo + .status(gix::progress::Discard) + .map_err(|err| Error::backend(op, err))? + .index(index.into())) +} + +/// Open options for repositories the agent operates on. +/// +/// - Environment: deny `GIT_*` location/object overrides — operations bind to +/// the discovered repository, mirroring the env-stripping the subprocess +/// wrapper performed. Home/XDG stay allowed so user config resolves. +/// - Config: user/system/git config allowed (identity, diff drivers), without +/// ever executing the git binary for its install-prefix config. +/// - Trust: full. This is a local dev tool operating on the user's own +/// checkout; ownership quarantine would only reject repos the user already +/// chose to work in. +fn open_options() -> Options { + Options::default() + .permissions(Permissions { + env: permissions::Environment { + xdg_config_home: Permission::Allow, + home: Permission::Allow, + http_transport: Permission::Deny, + identity: Permission::Allow, + objects: Permission::Deny, + git_prefix: Permission::Deny, + ssh_prefix: Permission::Deny, + }, + config: permissions::Config::all(), + attributes: permissions::Attributes::all(), + }) + .with(Trust::Full) +} diff --git a/crates/pi-vcs/src/git/patch.rs b/crates/pi-vcs/src/git/patch.rs new file mode 100644 index 000000000000..81be88861654 --- /dev/null +++ b/crates/pi-vcs/src/git/patch.rs @@ -0,0 +1,2096 @@ +//! Patch application, hunk staging, stash, and cherry-pick for +//! [`GitRepo`](super::GitRepo). +//! +//! Patch joins deliberately preserve binary-patch terminators (issue #8899). +//! Cherry-picks are fail-clean: unlike `git cherry-pick`, conflicts do not put +//! markers or unmerged entries in the checkout. Stash pop is likewise +//! preflighted so a rejected restore leaves no trace (issue #4175). + +use std::{ + collections::{BTreeMap, BTreeSet}, + fs, + path::{Component, Path, PathBuf}, +}; + +use gix::{ + bstr::{BStr, ByteSlice}, + index::entry::{Flags, Mode, Stat}, + merge::tree::TreatAsUnresolved, + objs::tree::EntryKind, + refs::transaction::PreviousValue, +}; + +use super::{GitRepo, mutate::update_reference, open::load_index_or_head}; +use crate::{ + error::{Error, Result}, + types::{ApplyOptions, DiffOptions, HunkSelection, HunkSelectionError, HunkSpec}, +}; + +#[derive(Clone, Debug, PartialEq, Eq)] +struct FileEntry { + id: gix::ObjectId, + mode: Mode, + /// Index entry carries git's intent-to-add flag (`git add -N`): the path + /// is promised but has no staged content yet. + intent_to_add: bool, +} +impl FileEntry { + const fn new(id: gix::ObjectId, mode: Mode) -> Self { + Self { id, mode, intent_to_add: false } + } +} + +#[derive(Clone, Debug)] +struct FilePatch { + old_path: Option, + new_path: Option, + old_mode: Option, + new_mode: Option, + old_oid: Option, + new_oid: Option, + hunks: Vec, + binary: Vec, + raw: String, +} + +#[derive(Clone, Debug)] +struct Hunk { + old_start: usize, + old_count: usize, + new_start: usize, + new_count: usize, + lines: Vec, + raw: String, +} + +#[derive(Clone, Debug)] +struct HunkLine { + kind: u8, + data: Vec, + no_newline: bool, +} + +#[derive(Clone, Debug)] +struct BinaryBlock { + kind: BinaryKind, + size: usize, + encoded: Vec, +} + +#[derive(Clone, Copy, Debug)] +enum BinaryKind { + Literal, + Delta, +} + +#[derive(Debug)] +enum ApplyFailure { + Context(String), + Invalid(String), +} + +impl ApplyFailure { + fn into_error(self) -> Error { + let message = match self { + Self::Context(message) | Self::Invalid(message) => message, + }; + Error::PatchFailed { message } + } +} + +impl GitRepo { + /// Apply a git-format patch to the worktree or index. + pub fn apply_patch(&self, patch_text: &str, options: &ApplyOptions) -> Result<()> { + if patch_text.trim().is_empty() { + return Ok(()); + } + let patches = parse_patch(patch_text).map_err(ApplyFailure::into_error)?; + let repo = self.gix()?; + let mut state = if options.cached { + index_map_at(&repo, options.index_path.as_deref())? + } else { + worktree_map(self, &repo)? + }; + if !options.cached { + augment_patch_sources(self, &repo, &mut state, &patches, options.reverse)?; + } + apply_patches_to_map(&repo, &mut state, &patches, options)?; + if options.cached { + write_index_map_at(&repo, &state, options.index_path.as_deref())?; + } else { + write_patch_worktree(self, &patches, options.reverse, &state)?; + } + Ok(()) + } + + /// Check whether a patch applies without changing the index or worktree. + pub fn can_apply_patch(&self, patch_text: &str, options: &ApplyOptions) -> Result { + if patch_text.trim().is_empty() { + return Ok(true); + } + let Ok(patches) = parse_patch(patch_text) else { + return Ok(false); + }; + let repo = self.gix()?.with_object_memory(); + let mut state = if options.cached { + index_map_at(&repo, options.index_path.as_deref())? + } else { + worktree_map(self, &repo)? + }; + if !options.cached { + augment_patch_sources(self, &repo, &mut state, &patches, options.reverse)?; + } + match apply_patches_to_map(&repo, &mut state, &patches, options) { + Ok(()) => Ok(true), + Err(Error::PatchFailed { .. } | Error::Conflict { .. }) => Ok(false), + Err(err) => Err(err), + } + } + + /// Stage selected hunks from a supplied or freshly generated worktree diff. + pub fn stage_hunks(&self, selections: &[HunkSelection], raw_diff: Option<&str>) -> Result<()> { + if selections.is_empty() { + return Ok(()); + } + let owned; + let raw_diff = if let Some(raw_diff) = raw_diff { + raw_diff + } else { + owned = self.diff_text(&DiffOptions::default())?; + &owned + }; + let files = parse_patch(raw_diff).map_err(ApplyFailure::into_error)?; + let mut by_path = BTreeMap::new(); + for file in &files { + if let Some(path) = file.new_path.as_ref().or(file.old_path.as_ref()) { + by_path.insert(path.as_str(), file); + } + } + let mut parts = Vec::with_capacity(selections.len()); + for selection in selections { + let Some(file) = by_path.get(selection.path.as_str()) else { + return Err(Error::PatchFailed { + message: format!("No diff found for {}", selection.path), + }); + }; + if !file.binary.is_empty() { + if !matches!(selection.hunks, HunkSpec::All) { + return Err(Error::PatchFailed { + message: format!("Cannot select hunks for binary file {}", selection.path), + }); + } + parts.push(file.raw.clone()); + continue; + } + if matches!(selection.hunks, HunkSpec::All) { + parts.push(file.raw.clone()); + continue; + } + let selected = select_hunks(file, &selection.hunks); + if selected.is_empty() { + return Err(Error::PatchFailed { + message: format!("No hunks selected for {}", selection.path), + }); + } + let header = extract_file_header(&file.raw); + let mut part = header.to_owned(); + for hunk in selected { + if !part.ends_with('\n') { + part.push('\n'); + } + part.push_str(&hunk.raw); + } + parts.push(part); + } + let patch = join_patches(&parts); + self.apply_patch(&patch, &ApplyOptions { + cached: true, + index_path: None, + reverse: false, + three_way: false, + }) + } + + /// Cherry-pick one commit with a fail-clean three-way tree merge. + pub fn cherry_pick(&self, rev: &str) -> Result<()> { + let repo = self.gix()?; + let picked_id = repo + .rev_parse_single(rev) + .map_err(|err| Error::backend("git cherry-pick resolve", err))? + .detach(); + let picked = repo + .find_commit(picked_id) + .map_err(|err| Error::backend("git cherry-pick commit", err))?; + let parent_id = picked.parent_ids().next().map(|id| id.detach()); + let head = repo + .head_commit() + .map_err(|err| Error::backend("git cherry-pick HEAD", err))?; + let head_id = head.id().detach(); + let head_tree = head + .tree_id() + .map_err(|err| Error::backend("git cherry-pick HEAD tree", err))?; + let parent_tree = if let Some(parent_id) = parent_id { + repo + .find_commit(parent_id) + .map_err(|err| Error::backend("git cherry-pick parent", err))? + .tree_id() + .map_err(|err| Error::backend("git cherry-pick parent tree", err))? + .detach() + } else { + repo.empty_tree().id().detach() + }; + let picked_tree = picked + .tree_id() + .map_err(|err| Error::backend("git cherry-pick picked tree", err))?; + let options = repo + .tree_merge_options() + .map_err(|err| Error::backend("git cherry-pick options", err))?; + let labels = gix::merge::blob::builtin_driver::text::Labels { + ancestor: Some("base".into()), + current: Some("HEAD".into()), + other: Some(rev.into()), + }; + let mut outcome = repo + .merge_trees(parent_tree, head_tree, picked_tree, labels, options) + .map_err(|err| Error::backend("git cherry-pick merge", err))?; + if outcome.has_unresolved_conflicts(TreatAsUnresolved::default()) { + return Err(Error::Conflict { paths: Vec::new() }); + } + let merged_tree = outcome + .tree + .write() + .map_err(|err| Error::backend("git cherry-pick write tree", err))? + .detach(); + if merged_tree == head_tree.detach() { + return Err(Error::EmptyCherryPick { sha: picked_id.to_string() }); + } + let author = picked + .author() + .map_err(|err| Error::backend("git cherry-pick author", err))?; + let committer = repo + .committer() + .ok_or_else(|| Error::backend("git cherry-pick", "committer identity is not configured"))? + .map_err(|err| Error::backend("git cherry-pick committer", err))?; + let message = picked + .message_raw() + .map_err(|err| Error::backend("git cherry-pick message", err))? + .to_str_lossy(); + repo + .commit_as(committer, author, "HEAD", message.as_ref(), merged_tree, [head_id]) + .map_err(|err| Error::backend("git cherry-pick commit", err))?; + let merged = tree_map(&repo, merged_tree)?; + let previous = index_map(&repo)?; + write_worktree_map(self, &previous, &merged)?; + write_index_map(&repo, &merged) + } + + /// Clear cherry-pick state; fail-clean single-commit picks create none. + pub const fn cherry_pick_abort(&self) -> Result<()> { + Ok(()) + } + + /// Skip cherry-pick state; single-commit picks have no sequencer. + pub const fn cherry_pick_skip(&self) -> Result<()> { + Ok(()) + } + + /// Stash index, tracked worktree changes, and untracked files. + pub fn stash_push(&self, message: Option<&str>) -> Result { + let repo = self.gix()?; + let head = repo + .head_commit() + .map_err(|err| Error::backend("git stash HEAD", err))?; + let head_id = head.id().detach(); + let head_tree = head + .tree_id() + .map_err(|err| Error::backend("git stash HEAD tree", err))? + .detach(); + let head_map = tree_map(&repo, head_tree)?; + let index = index_map(&repo)?; + let tracked_worktree = tracked_worktree_map(self, &repo, &index)?; + let untracked = untracked_worktree_map(self, &repo, &index)?; + if index == head_map && tracked_worktree == index && untracked.is_empty() { + return Ok(false); + } + let index_tree = write_tree_map(&repo, &index)?; + let worktree_tree = write_tree_map(&repo, &tracked_worktree)?; + let untracked_tree = write_tree_map(&repo, &untracked)?; + let label = message.unwrap_or("WIP"); + let index_commit = repo + .new_commit(format!("index on HEAD: {label}"), index_tree, [head_id]) + .map_err(|err| Error::backend("git stash index commit", err))?; + let untracked_commit = repo + .new_commit("untracked files on HEAD", untracked_tree, std::iter::empty::()) + .map_err(|err| Error::backend("git stash untracked commit", err))?; + let stash_commit = repo + .new_commit(label, worktree_tree, [ + head_id, + index_commit.id().detach(), + untracked_commit.id().detach(), + ]) + .map_err(|err| Error::backend("git stash commit", err))?; + update_stash_ref( + &repo, + stash_commit.id().detach(), + PreviousValue::Any, + format!("On HEAD: {label}"), + true, + )?; + write_worktree_map(self, &tracked_worktree, &head_map)?; + write_index_map(&repo, &head_map)?; + for path in untracked.keys() { + remove_worktree_path(self, path)?; + } + Ok(true) + } + + /// Try to pop the top stash without leaving partial conflict state. + pub fn stash_try_pop(&self, reinstate_index: bool) -> Result { + let repo = self.gix()?; + let Some(stash_ref) = repo + .try_find_reference("refs/stash") + .map_err(|err| Error::backend("git stash resolve", err))? + else { + return Ok(false); + }; + let stash_id = stash_ref.id().detach(); + let stash_log = fs::read(self.info().common_dir.join("logs/refs/stash")).ok(); + let stash = repo + .find_commit(stash_id) + .map_err(|err| Error::backend("git stash commit", err))?; + let parents: Vec<_> = stash.parent_ids().map(|id| id.detach()).collect(); + if parents.len() < 2 { + return Err(Error::backend("git stash pop", "stash commit has fewer than two parents")); + } + let base = repo + .find_commit(parents[0]) + .map_err(|err| Error::backend("git stash base", err))?; + let base_tree = base + .tree_id() + .map_err(|err| Error::backend("git stash base tree", err))? + .detach(); + let stash_tree = stash + .tree_id() + .map_err(|err| Error::backend("git stash tree", err))? + .detach(); + let current_index = index_map(&repo)?; + let current_worktree = tracked_worktree_map(self, &repo, ¤t_index)?; + let current_tree = write_tree_map(&repo, ¤t_worktree)?; + let Some(merged_worktree) = merge_tree_maps(&repo, base_tree, current_tree, stash_tree)? + else { + return Ok(false); + }; + let merged_index = if reinstate_index { + let stash_index = repo + .find_commit(parents[1]) + .map_err(|err| Error::backend("git stash index", err))?; + let stash_index_tree = stash_index + .tree_id() + .map_err(|err| Error::backend("git stash index tree", err))? + .detach(); + let current_index_tree = write_tree_map(&repo, ¤t_index)?; + let Some(merged) = + merge_tree_maps(&repo, base_tree, current_index_tree, stash_index_tree)? + else { + return Ok(false); + }; + Some(merged) + } else { + None + }; + let untracked = if let Some(parent) = parents.get(2) { + let untracked_commit = repo + .find_commit(*parent) + .map_err(|err| Error::backend("git stash untracked", err))?; + let tree = untracked_commit + .tree_id() + .map_err(|err| Error::backend("git stash untracked tree", err))?; + tree_map(&repo, tree.detach())? + } else { + BTreeMap::new() + }; + for path in untracked.keys() { + if self.root().join(path).symlink_metadata().is_ok() { + return Ok(false); + } + } + write_worktree_map(self, ¤t_worktree, &merged_worktree)?; + for (path, entry) in &untracked { + write_worktree_entry(self, path, entry, &repo)?; + } + if let Some(merged_index) = merged_index { + write_index_map(&repo, &merged_index)?; + } + drop_stash(self, &repo, &stash_ref, stash_id, stash_log.as_deref())?; + Ok(true) + } +} + +/// Join patch parts verbatim, adding one final newline only when absent. +pub fn join_patches(parts: &[String]) -> String { + let capacity = parts + .iter() + .map(|part| part.len() + usize::from(!part.ends_with('\n'))) + .sum(); + let mut joined = String::with_capacity(capacity); + for part in parts { + joined.push_str(part); + if !part.ends_with('\n') { + joined.push('\n'); + } + } + joined +} + +/// Validate hunk selections against a raw git diff. +pub fn validate_hunk_selections( + raw_diff: &str, + selections: &[HunkSelection], +) -> Vec { + let Ok(files) = parse_patch(raw_diff) else { + return Vec::new(); + }; + let mut by_path = BTreeMap::new(); + for file in &files { + if let Some(path) = file.new_path.as_ref().or(file.old_path.as_ref()) { + by_path.insert(path.as_str(), file); + } + } + let mut errors = Vec::new(); + for selection in selections { + let Some(file) = by_path.get(selection.path.as_str()) else { + continue; + }; + if matches!(selection.hunks, HunkSpec::All) { + continue; + } + if !file.binary.is_empty() { + errors.push(HunkSelectionError { + path: selection.path.clone(), + message: format!("Cannot select hunks for binary file {}", selection.path), + }); + } else if select_hunks(file, &selection.hunks).is_empty() { + errors.push(HunkSelectionError { + path: selection.path.clone(), + message: format!("No hunks selected for {}", selection.path), + }); + } + } + errors +} + +fn parse_patch(text: &str) -> std::result::Result, ApplyFailure> { + let starts: Vec<_> = text + .match_indices("diff --git ") + .filter(|(idx, _)| *idx == 0 || text.as_bytes()[idx - 1] == b'\n') + .map(|(idx, _)| idx) + .collect(); + if starts.is_empty() { + return Err(ApplyFailure::Invalid("patch has no diff --git header".into())); + } + let mut files = Vec::with_capacity(starts.len()); + for (position, start) in starts.iter().copied().enumerate() { + let end = starts.get(position + 1).copied().unwrap_or(text.len()); + files.push(parse_file_patch(&text[start..end])?); + } + Ok(files) +} + +fn parse_file_patch(raw: &str) -> std::result::Result { + let lines: Vec<&str> = raw.split_inclusive('\n').collect(); + let first = lines + .first() + .map(|line| line.trim_end_matches('\n')) + .unwrap_or_default(); + let paths = first + .strip_prefix("diff --git ") + .ok_or_else(|| ApplyFailure::Invalid("invalid diff header".into()))?; + let (old_token, new_token) = split_diff_paths(paths)?; + let mut patch = FilePatch { + old_path: Some(strip_side_path(old_token, 'a')), + new_path: Some(strip_side_path(new_token, 'b')), + old_mode: None, + new_mode: None, + old_oid: None, + new_oid: None, + hunks: Vec::new(), + binary: Vec::new(), + raw: raw.to_owned(), + }; + let mut index = 1; + while index < lines.len() { + let line = lines[index].trim_end_matches('\n'); + if let Some(value) = line.strip_prefix("old mode ") { + patch.old_mode = parse_mode(value); + } else if let Some(value) = line.strip_prefix("new mode ") { + patch.new_mode = parse_mode(value); + } else if let Some(value) = line.strip_prefix("new file mode ") { + patch.old_path = None; + patch.new_mode = parse_mode(value); + } else if let Some(value) = line.strip_prefix("deleted file mode ") { + patch.new_path = None; + patch.old_mode = parse_mode(value); + } else if let Some(value) = line.strip_prefix("rename from ") { + patch.old_path = Some(unquote_path(value)); + } else if let Some(value) = line.strip_prefix("rename to ") { + patch.new_path = Some(unquote_path(value)); + } else if let Some(value) = line.strip_prefix("index ") { + let ids = value.split_whitespace().next().unwrap_or_default(); + if let Some((old, new)) = ids.split_once("..") { + patch.old_oid = Some(old.to_owned()); + patch.new_oid = Some(new.to_owned()); + } + if let Some(mode) = value.split_whitespace().nth(1).and_then(parse_mode) { + patch.old_mode.get_or_insert(mode); + patch.new_mode.get_or_insert(mode); + } + } else if let Some(value) = line.strip_prefix("--- ") { + patch.old_path = parse_marker_path(value, 'a'); + } else if let Some(value) = line.strip_prefix("+++ ") { + patch.new_path = parse_marker_path(value, 'b'); + } else if line.starts_with("@@") { + let (hunk, next) = parse_hunk(&lines, index)?; + patch.hunks.push(hunk); + index = next; + continue; + } else if line == "GIT binary patch" { + index += 1; + while index < lines.len() { + let header = lines[index].trim_end_matches('\n'); + let Some((kind, size)) = parse_binary_header(header) else { + break; + }; + index += 1; + let mut encoded = Vec::new(); + while index < lines.len() { + let data = lines[index].trim_end_matches('\n'); + if data.is_empty() { + index += 1; + break; + } + if parse_binary_header(data).is_some() { + break; + } + encoded.push(data.to_owned()); + index += 1; + } + patch.binary.push(BinaryBlock { kind, size, encoded }); + } + continue; + } + index += 1; + } + if patch.hunks.is_empty() + && patch.binary.is_empty() + && patch.old_path == patch.new_path + && patch.old_mode == patch.new_mode + { + return Err(ApplyFailure::Invalid("patch contains no change".into())); + } + Ok(patch) +} + +fn split_diff_paths(paths: &str) -> std::result::Result<(&str, &str), ApplyFailure> { + if paths.starts_with('"') { + return Err(ApplyFailure::Invalid("quoted paths in diff headers are unsupported".into())); + } + paths + .split_once(' ') + .ok_or_else(|| ApplyFailure::Invalid("invalid diff paths".into())) +} + +fn unquote_path(path: &str) -> String { + path.trim_matches('"').to_owned() +} + +fn strip_side_path(token: &str, side: char) -> String { + let prefix = format!("{side}/"); + unquote_path(token.strip_prefix(&prefix).unwrap_or(token)) +} + +fn parse_marker_path(value: &str, side: char) -> Option { + let path = value.split('\t').next().unwrap_or(value); + if path == "/dev/null" { + None + } else { + Some(strip_side_path(path, side)) + } +} + +fn parse_mode(value: &str) -> Option { + let bits = u32::from_str_radix(value.trim(), 8).ok()?; + Mode::from_bits(bits) +} + +fn parse_hunk(lines: &[&str], start: usize) -> std::result::Result<(Hunk, usize), ApplyFailure> { + let header = lines[start].trim_end_matches('\n'); + let (old_start, old_count, new_start, new_count) = parse_hunk_header(header)?; + let mut body: Vec = Vec::new(); + let mut raw = String::from(lines[start]); + let mut index = start + 1; + while index < lines.len() { + let line = lines[index]; + let bare = line.trim_end_matches('\n'); + if bare.starts_with("@@") || bare.starts_with("diff --git ") || bare == "GIT binary patch" { + break; + } + let Some(kind @ (b' ' | b'+' | b'-')) = bare.as_bytes().first().copied() else { + if bare == "\\ No newline at end of file" { + let Some(previous) = body.last_mut() else { + return Err(ApplyFailure::Invalid("orphan no-newline marker".into())); + }; + previous.no_newline = true; + raw.push_str(line); + index += 1; + continue; + } + break; + }; + body.push(HunkLine { kind, data: bare.as_bytes()[1..].to_vec(), no_newline: false }); + raw.push_str(line); + index += 1; + } + let actual_old = body.iter().filter(|line| line.kind != b'+').count(); + let actual_new = body.iter().filter(|line| line.kind != b'-').count(); + if actual_old != old_count || actual_new != new_count { + return Err(ApplyFailure::Invalid(format!("hunk count mismatch in {header}"))); + } + Ok((Hunk { old_start, old_count, new_start, new_count, lines: body, raw }, index)) +} + +fn parse_hunk_header( + header: &str, +) -> std::result::Result<(usize, usize, usize, usize), ApplyFailure> { + let body = header + .strip_prefix("@@ -") + .and_then(|value| value.split_once(" @@").map(|pair| pair.0)) + .ok_or_else(|| ApplyFailure::Invalid(format!("invalid hunk header: {header}")))?; + let (old, new) = body + .split_once(" +") + .ok_or_else(|| ApplyFailure::Invalid(format!("invalid hunk header: {header}")))?; + let parse_range = |value: &str| -> Option<(usize, usize)> { + let (start, count) = value.split_once(',').unwrap_or((value, "1")); + Some((start.parse().ok()?, count.parse().ok()?)) + }; + let (old_start, old_count) = parse_range(old) + .ok_or_else(|| ApplyFailure::Invalid(format!("invalid hunk range: {header}")))?; + let (new_start, new_count) = parse_range(new) + .ok_or_else(|| ApplyFailure::Invalid(format!("invalid hunk range: {header}")))?; + Ok((old_start, old_count, new_start, new_count)) +} + +fn parse_binary_header(line: &str) -> Option<(BinaryKind, usize)> { + let (kind, size) = line.split_once(' ')?; + let kind = match kind { + "literal" => BinaryKind::Literal, + "delta" => BinaryKind::Delta, + _ => return None, + }; + Some((kind, size.parse().ok()?)) +} + +fn select_hunks<'a>(file: &'a FilePatch, spec: &HunkSpec) -> Vec<&'a Hunk> { + match spec { + HunkSpec::All => file.hunks.iter().collect(), + HunkSpec::Indices(indices) => { + let wanted: BTreeSet<_> = indices + .iter() + .map(|index| (*index).max(1) as usize) + .collect(); + file + .hunks + .iter() + .enumerate() + .filter(|(index, _)| wanted.contains(&(index + 1))) + .map(|(_, hunk)| hunk) + .collect() + }, + HunkSpec::Lines { start, end } => file + .hunks + .iter() + .filter(|hunk| { + let first = hunk.new_start as u32; + let last = first + .saturating_add(hunk.new_count as u32) + .saturating_sub(1); + first <= *end && last >= *start + }) + .collect(), + } +} + +fn extract_file_header(raw: &str) -> &str { + raw.find("\n@@").map_or(raw, |position| &raw[..=position]) +} + +fn apply_patches_to_map( + repo: &gix::Repository, + state: &mut BTreeMap, + patches: &[FilePatch], + options: &ApplyOptions, +) -> Result<()> { + for patch in patches { + let (source_path, target_path, source_mode, target_mode) = + patch_sides(patch, options.reverse); + // A create patch may land on an intent-to-add entry: git treats the + // promised path as absent and stages the real content over it. + if source_path.is_none() + && target_path + .and_then(|path| state.get(path)) + .is_some_and(|entry| !entry.intent_to_add) + { + return Err(Error::PatchFailed { + message: format!("{} already exists", target_path.unwrap_or_default()), + }); + } + let source = source_path.and_then(|path| state.get(path).cloned()); + if source_path.is_some() && source.is_none() { + return Err(Error::PatchFailed { + message: format!("{} does not exist", source_path.unwrap_or_default()), + }); + } + if source_mode.is_some_and(|mode| source.as_ref().is_some_and(|entry| entry.mode != mode)) { + return Err(Error::PatchFailed { + message: format!("mode does not match for {}", source_path.unwrap_or_default()), + }); + } + let source_bytes = match source.as_ref() { + Some(entry) => blob_bytes(repo, entry.id)?, + None => Vec::new(), + }; + let direct = apply_file_bytes(patch, &source_bytes, options.reverse); + let bytes = match direct { + Ok(bytes) => bytes, + Err(ApplyFailure::Context(_)) if options.three_way => { + merge_patch_bytes(repo, patch, source.as_ref(), options.reverse)? + }, + Err(err) => return Err(err.into_error()), + }; + if let Some(path) = source_path + && target_path != Some(path) + { + state.remove(path); + } + if let Some(path) = target_path { + validate_repo_path(path).map_err(ApplyFailure::into_error)?; + let id = repo + .write_blob(&bytes) + .map_err(|err| Error::backend("git apply write blob", err))? + .detach(); + let mode = target_mode + .or_else(|| source.as_ref().map(|entry| entry.mode)) + .or(source_mode) + .unwrap_or(Mode::FILE); + state.insert(path.to_owned(), FileEntry::new(id, mode)); + } + } + Ok(()) +} + +fn patch_sides( + patch: &FilePatch, + reverse: bool, +) -> (Option<&str>, Option<&str>, Option, Option) { + if reverse { + (patch.new_path.as_deref(), patch.old_path.as_deref(), patch.new_mode, patch.old_mode) + } else { + (patch.old_path.as_deref(), patch.new_path.as_deref(), patch.old_mode, patch.new_mode) + } +} + +fn apply_file_bytes( + patch: &FilePatch, + source: &[u8], + reverse: bool, +) -> std::result::Result, ApplyFailure> { + if !patch.binary.is_empty() { + let block = if reverse { + patch.binary.get(1).or_else(|| patch.binary.first()) + } else { + patch.binary.first() + } + .ok_or_else(|| ApplyFailure::Invalid("binary patch has no data block".into()))?; + return decode_binary_block(block, source); + } + if patch.hunks.is_empty() { + return Ok(source.to_vec()); + } + let mut lines = split_lines(source); + let mut offset: isize = 0; + for hunk in &patch.hunks { + let (start, count, replacement, expected) = hunk_sides(hunk, reverse); + let position = if count == 0 { + start as isize + } else { + start.saturating_sub(1) as isize + } + offset; + if position < 0 { + return Err(ApplyFailure::Context("hunk position precedes file".into())); + } + let position = position as usize; + if position.saturating_add(expected.len()) > lines.len() + || lines[position..position + expected.len()] != expected + { + return Err(ApplyFailure::Context(format!("hunk at line {start} does not apply"))); + } + lines.splice(position..position + expected.len(), replacement.clone()); + offset += replacement.len() as isize - expected.len() as isize; + } + Ok(lines.concat()) +} + +fn hunk_sides(hunk: &Hunk, reverse: bool) -> (usize, usize, Vec>, Vec>) { + let mut old = Vec::new(); + let mut new = Vec::new(); + for line in &hunk.lines { + let mut content = line.data.clone(); + if !line.no_newline { + content.push(b'\n'); + } + if line.kind != b'+' { + old.push(content.clone()); + } + if line.kind != b'-' { + new.push(content); + } + } + if reverse { + (hunk.new_start, hunk.new_count, old, new) + } else { + (hunk.old_start, hunk.old_count, new, old) + } +} + +fn split_lines(bytes: &[u8]) -> Vec> { + let mut lines = Vec::new(); + let mut start = 0; + for (index, byte) in bytes.iter().enumerate() { + if *byte == b'\n' { + lines.push(bytes[start..=index].to_vec()); + start = index + 1; + } + } + if start < bytes.len() { + lines.push(bytes[start..].to_vec()); + } + lines +} + +fn decode_binary_block( + block: &BinaryBlock, + base: &[u8], +) -> std::result::Result, ApplyFailure> { + let mut compressed = Vec::new(); + for line in &block.encoded { + let bytes = line.as_bytes(); + let Some(prefix) = bytes.first().copied() else { + return Err(ApplyFailure::Invalid("empty binary data line".into())); + }; + let decoded_len = match prefix { + b'A'..=b'Z' => usize::from(prefix - b'A' + 1), + b'a'..=b'z' => usize::from(prefix - b'a' + 27), + _ => return Err(ApplyFailure::Invalid("invalid binary line length".into())), + }; + let mut decoded = Vec::with_capacity((bytes.len().saturating_sub(1) / 5) * 4); + for chunk in bytes[1..].chunks(5) { + if chunk.len() != 5 { + return Err(ApplyFailure::Invalid("truncated base85 group".into())); + } + let mut value = 0_u32; + for byte in chunk { + let digit = u32::from(decode_base85(*byte)?); + value = value + .checked_mul(85) + .and_then(|value| value.checked_add(digit)) + .ok_or_else(|| ApplyFailure::Invalid("base85 overflow".into()))?; + } + decoded.extend_from_slice(&value.to_be_bytes()); + } + if decoded_len > decoded.len() { + return Err(ApplyFailure::Invalid("binary line length exceeds payload".into())); + } + compressed.extend_from_slice(&decoded[..decoded_len]); + } + let inflate_size = block.size; + let mut inflated = vec![0; inflate_size]; + let mut decoder = gix::features::zlib::Inflate::default(); + let (status, consumed, written) = decoder + .once(&compressed, &mut inflated) + .map_err(|err| ApplyFailure::Invalid(format!("invalid zlib stream: {err}")))?; + if status != gix::features::zlib::Status::StreamEnd || consumed != compressed.len() { + return Err(ApplyFailure::Invalid("incomplete zlib stream".into())); + } + inflated.truncate(written); + if inflated.len() != block.size { + return Err(ApplyFailure::Invalid(format!( + "binary payload size {} != {}", + inflated.len(), + block.size + ))); + } + match block.kind { + BinaryKind::Literal => Ok(inflated), + BinaryKind::Delta => apply_git_delta(base, &inflated), + } +} + +fn decode_base85(byte: u8) -> std::result::Result { + const ALPHABET: &[u8; 85] = + b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~"; + ALPHABET + .iter() + .position(|candidate| *candidate == byte) + .map(|position| position as u8) + .ok_or_else(|| ApplyFailure::Invalid(format!("invalid base85 byte {byte}"))) +} + +fn apply_git_delta(base: &[u8], delta: &[u8]) -> std::result::Result, ApplyFailure> { + let mut cursor = 0; + let base_size = read_delta_varint(delta, &mut cursor)?; + let result_size = read_delta_varint(delta, &mut cursor)?; + if base_size != base.len() { + return Err(ApplyFailure::Context("binary delta base size mismatch".into())); + } + let mut result = Vec::with_capacity(result_size); + while cursor < delta.len() { + let command = delta[cursor]; + cursor += 1; + if command & 0x80 != 0 { + let mut offset = 0_usize; + let mut size = 0_usize; + for bit in 0..4 { + if command & (1 << bit) != 0 { + offset |= usize::from( + *delta + .get(cursor) + .ok_or_else(|| ApplyFailure::Invalid("truncated delta copy offset".into()))?, + ) << (8 * bit); + cursor += 1; + } + } + for bit in 0..3 { + if command & (1 << (4 + bit)) != 0 { + size |= usize::from( + *delta + .get(cursor) + .ok_or_else(|| ApplyFailure::Invalid("truncated delta copy size".into()))?, + ) << (8 * bit); + cursor += 1; + } + } + if size == 0 { + size = 0x1_0000; + } + let end = offset + .checked_add(size) + .ok_or_else(|| ApplyFailure::Invalid("delta copy overflow".into()))?; + let slice = base + .get(offset..end) + .ok_or_else(|| ApplyFailure::Invalid("delta copy exceeds base".into()))?; + result.extend_from_slice(slice); + } else if command != 0 { + let count = usize::from(command); + let end = cursor + .checked_add(count) + .ok_or_else(|| ApplyFailure::Invalid("delta insert overflow".into()))?; + result.extend_from_slice( + delta + .get(cursor..end) + .ok_or_else(|| ApplyFailure::Invalid("truncated delta insert".into()))?, + ); + cursor = end; + } else { + return Err(ApplyFailure::Invalid("invalid zero delta opcode".into())); + } + } + if result.len() != result_size { + return Err(ApplyFailure::Invalid("delta result length mismatch".into())); + } + Ok(result) +} + +fn read_delta_varint(data: &[u8], cursor: &mut usize) -> std::result::Result { + let mut value = 0_usize; + let mut shift = 0; + loop { + let byte = *data + .get(*cursor) + .ok_or_else(|| ApplyFailure::Invalid("truncated delta header".into()))?; + *cursor += 1; + value |= usize::from(byte & 0x7f) + .checked_shl(shift) + .ok_or_else(|| ApplyFailure::Invalid("delta varint overflow".into()))?; + if byte & 0x80 == 0 { + return Ok(value); + } + shift += 7; + if shift >= usize::BITS { + return Err(ApplyFailure::Invalid("delta varint overflow".into())); + } + } +} + +fn merge_patch_bytes( + repo: &gix::Repository, + patch: &FilePatch, + current: Option<&FileEntry>, + reverse: bool, +) -> Result> { + let old_oid = if reverse { + patch.new_oid.as_deref() + } else { + patch.old_oid.as_deref() + } + .ok_or_else(|| Error::PatchFailed { + message: "3-way patch lacks an index base object".into(), + })?; + let base_id = resolve_object(repo, old_oid)?; + let base = blob_bytes(repo, base_id)?; + let theirs = apply_file_bytes(patch, &base, reverse).map_err(ApplyFailure::into_error)?; + let ours = current.map_or_else(|| Ok(Vec::new()), |entry| blob_bytes(repo, entry.id))?; + if ours == base { + return Ok(theirs); + } + if theirs == base || ours == theirs { + return Ok(ours); + } + let mode = current.map_or(Mode::FILE, |entry| entry.mode); + let base_blob = repo + .write_blob(&base) + .map_err(|err| Error::backend("git apply 3-way base", err))? + .detach(); + let ours_blob = repo + .write_blob(&ours) + .map_err(|err| Error::backend("git apply 3-way ours", err))? + .detach(); + let theirs_blob = repo + .write_blob(&theirs) + .map_err(|err| Error::backend("git apply 3-way theirs", err))? + .detach(); + let path = patch + .new_path + .as_deref() + .or(patch.old_path.as_deref()) + .unwrap_or("file"); + let base_tree = + write_tree_map(repo, &BTreeMap::from([(path.to_owned(), FileEntry::new(base_blob, mode))]))?; + let ours_tree = + write_tree_map(repo, &BTreeMap::from([(path.to_owned(), FileEntry::new(ours_blob, mode))]))?; + let theirs_tree = write_tree_map( + repo, + &BTreeMap::from([(path.to_owned(), FileEntry::new(theirs_blob, mode))]), + )?; + let Some(merged) = merge_tree_maps(repo, base_tree, ours_tree, theirs_tree)? else { + return Err(Error::Conflict { paths: vec![path.to_owned()] }); + }; + let entry = merged + .get(path) + .ok_or_else(|| Error::Conflict { paths: vec![path.to_owned()] })?; + blob_bytes(repo, entry.id) +} + +fn resolve_object(repo: &gix::Repository, spec: &str) -> Result { + repo + .rev_parse_single(spec) + .map(|id| id.detach()) + .map_err(|err| Error::backend("git apply resolve base", err)) +} + +fn merge_tree_maps( + repo: &gix::Repository, + base: gix::ObjectId, + ours: gix::ObjectId, + theirs: gix::ObjectId, +) -> Result>> { + let options = repo + .tree_merge_options() + .map_err(|err| Error::backend("git merge options", err))?; + let labels = gix::merge::blob::builtin_driver::text::Labels { + ancestor: Some("base".into()), + current: Some("current".into()), + other: Some("stashed".into()), + }; + let mut outcome = repo + .merge_trees(base, ours, theirs, labels, options) + .map_err(|err| Error::backend("git tree merge", err))?; + if outcome.has_unresolved_conflicts(TreatAsUnresolved::default()) { + return Ok(None); + } + let tree = outcome + .tree + .write() + .map_err(|err| Error::backend("git merge write tree", err))? + .detach(); + Ok(Some(tree_map(repo, tree)?)) +} +fn drop_stash( + repo: &GitRepo, + gix_repo: &gix::Repository, + stash_ref: &gix::Reference<'_>, + stash_id: gix::ObjectId, + log: Option<&[u8]>, +) -> Result<()> { + let Some((previous, prior_log)) = log.and_then(previous_stash_from_log) else { + return stash_ref + .delete() + .map_err(|err| Error::backend("git stash drop", err)); + }; + if previous.is_null() { + return stash_ref + .delete() + .map_err(|err| Error::backend("git stash drop", err)); + } + update_reference( + gix_repo, + "git stash drop", + "refs/stash", + previous, + PreviousValue::MustExistAndMatch(gix::refs::Target::Object(stash_id)), + "stash: drop", + false, + )?; + let log_path = repo.info().common_dir.join("logs/refs/stash"); + fs::write(log_path, prior_log)?; + Ok(()) +} +fn update_stash_ref( + repo: &gix::Repository, + id: gix::ObjectId, + expected: PreviousValue, + message: String, + force_create_reflog: bool, +) -> Result<()> { + update_reference( + repo, + "git stash ref", + "refs/stash", + id, + expected, + &message, + force_create_reflog, + ) +} + +fn previous_stash_from_log(log: &[u8]) -> Option<(gix::ObjectId, &[u8])> { + let end = log.iter().rposition(|byte| *byte != b'\n')? + 1; + let start = log[..end] + .iter() + .rposition(|byte| *byte == b'\n') + .map_or(0, |position| position + 1); + let old_hex = log.get(start..end)?.split(|byte| *byte == b' ').next()?; + let previous = gix::ObjectId::from_hex(old_hex).ok()?; + Some((previous, &log[..start])) +} + +fn blob_bytes(repo: &gix::Repository, id: gix::ObjectId) -> Result> { + repo + .find_blob(id) + .map(|blob| blob.data.clone()) + .map_err(|err| Error::backend("git read blob", err)) +} + +fn index_map(repo: &gix::Repository) -> Result> { + let index = load_index_or_head(repo, "git read index")?; + Ok(index_state_map(&index)) +} + +fn index_map_at( + repo: &gix::Repository, + index_path: Option<&Path>, +) -> Result> { + let Some(path) = index_path else { + return index_map(repo); + }; + match fs::metadata(path) { + Ok(_) => { + let index = gix::index::File::at( + path, + repo.object_hash(), + false, + gix::index::decode::Options::default(), + ) + .map_err(|err| Error::backend("git read alternate index", err))?; + Ok(index_state_map(&index)) + }, + Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(BTreeMap::new()), + Err(err) => Err(err.into()), + } +} + +fn index_state_map(index: &gix::index::State) -> BTreeMap { + let mut map = BTreeMap::new(); + for entry in index.entries() { + if entry.stage() == gix::index::entry::Stage::Unconflicted { + let path = entry.path(index); + map.insert(path.to_str_lossy().into_owned(), FileEntry { + id: entry.id, + mode: entry.mode, + intent_to_add: entry.flags.contains(Flags::INTENT_TO_ADD), + }); + } + } + map +} + +fn tree_map(repo: &gix::Repository, tree: gix::ObjectId) -> Result> { + let index = repo + .index_from_tree(&tree) + .map_err(|err| Error::backend("git read tree", err))?; + let mut map = BTreeMap::new(); + for entry in index.entries() { + let path = entry.path(&index); + map.insert(path.to_str_lossy().into_owned(), FileEntry::new(entry.id, entry.mode)); + } + Ok(map) +} + +fn worktree_map(repo: &GitRepo, gix_repo: &gix::Repository) -> Result> { + let index = index_map(gix_repo)?; + tracked_worktree_map(repo, gix_repo, &index) +} +fn augment_patch_sources( + repo: &GitRepo, + gix_repo: &gix::Repository, + state: &mut BTreeMap, + patches: &[FilePatch], + reverse: bool, +) -> Result<()> { + for patch in patches { + let (source, target, source_mode, target_mode) = patch_sides(patch, reverse); + let path = if let Some(path) = source { + path + } else { + let Some(target) = target else { + continue; + }; + target + }; + if state.contains_key(path) { + continue; + } + let mode = source_mode.or(target_mode).unwrap_or(Mode::FILE); + if let Some((bytes, mode)) = read_worktree_entry(&repo.root().join(path), mode)? { + let id = gix_repo + .write_blob(bytes) + .map_err(|err| Error::backend("git hash patch source", err))? + .detach(); + state.insert(path.to_owned(), FileEntry::new(id, mode)); + } + } + Ok(()) +} + +fn tracked_worktree_map( + repo: &GitRepo, + gix_repo: &gix::Repository, + index: &BTreeMap, +) -> Result> { + let mut map = BTreeMap::new(); + for (path, entry) in index { + let absolute = repo.root().join(path); + if let Some((bytes, mode)) = read_worktree_entry(&absolute, entry.mode)? { + let id = gix_repo + .write_blob(bytes) + .map_err(|err| Error::backend("git hash worktree blob", err))? + .detach(); + map.insert(path.clone(), FileEntry::new(id, mode)); + } + } + Ok(map) +} + +fn untracked_worktree_map( + repo: &GitRepo, + gix_repo: &gix::Repository, + index: &BTreeMap, +) -> Result> { + let mut walk_index = load_index_or_head(gix_repo, "git read index for untracked files")?; + for entry in walk_index.entries_mut() { + entry.flags.insert(Flags::UPTODATE); + } + let options = gix_repo + .dirwalk_options() + .map_err(|err| Error::backend("git untracked options", err))?; + let walk = gix_repo + .dirwalk_iter( + walk_index, + std::iter::empty::(), + Default::default(), + options, + ) + .map_err(|err| Error::backend("git untracked walk", err))?; + let mut map = BTreeMap::new(); + for item in walk { + let item = item.map_err(|err| Error::backend("git untracked walk", err))?; + if item.entry.status != gix::dir::entry::Status::Untracked + || !matches!( + item.entry.disk_kind, + Some(gix::dir::entry::Kind::File | gix::dir::entry::Kind::Symlink) + ) { + continue; + } + let path = item.entry.rela_path.to_str_lossy().into_owned(); + if index.contains_key(&path) { + continue; + } + let absolute = repo.root().join(&path); + if let Some((bytes, mode)) = read_worktree_entry(&absolute, Mode::FILE)? { + let id = gix_repo + .write_blob(bytes) + .map_err(|err| Error::backend("git hash untracked blob", err))? + .detach(); + map.insert(path, FileEntry::new(id, mode)); + } + } + Ok(map) +} + +fn read_worktree_entry(path: &Path, index_mode: Mode) -> Result, Mode)>> { + let metadata = match fs::symlink_metadata(path) { + Ok(metadata) => metadata, + Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(None), + Err(err) => return Err(err.into()), + }; + if metadata.file_type().is_symlink() { + let target = fs::read_link(path)?; + #[cfg(unix)] + let bytes = { + use std::os::unix::ffi::OsStrExt; + target.as_os_str().as_bytes().to_vec() + }; + #[cfg(not(unix))] + let bytes = target.to_string_lossy().as_bytes().to_vec(); + return Ok(Some((bytes, Mode::SYMLINK))); + } + if !metadata.is_file() { + return Ok(None); + } + let mode = worktree_file_mode(&metadata, index_mode); + Ok(Some((fs::read(path)?, mode))) +} + +#[cfg(unix)] +fn worktree_file_mode(metadata: &fs::Metadata, _index_mode: Mode) -> Mode { + use std::os::unix::fs::PermissionsExt; + if metadata.permissions().mode() & 0o111 != 0 { + Mode::FILE_EXECUTABLE + } else { + Mode::FILE + } +} + +#[cfg(not(unix))] +fn worktree_file_mode(_metadata: &fs::Metadata, index_mode: Mode) -> Mode { + index_mode +} + +fn write_index_map(repo: &gix::Repository, map: &BTreeMap) -> Result<()> { + write_index_map_at(repo, map, None) +} + +fn write_index_map_at( + repo: &gix::Repository, + map: &BTreeMap, + index_path: Option<&Path>, +) -> Result<()> { + let mut state = gix::index::State::new(repo.object_hash()); + for (path, entry) in map { + validate_repo_path(path).map_err(ApplyFailure::into_error)?; + // INTENT_TO_ADD lives in the extended flag word; losing it here would + // silently stage promised paths as empty files. + let flags = if entry.intent_to_add { + Flags::EXTENDED | Flags::INTENT_TO_ADD + } else { + Flags::empty() + }; + state.dangerously_push_entry( + Stat::default(), + entry.id, + flags, + entry.mode, + BStr::new(path.as_bytes()), + ); + } + state.sort_entries(); + let mut index = gix::index::File::from_state( + state, + index_path.map_or_else(|| repo.index_path(), Path::to_owned), + ); + index.remove_tree(); + index + .write(gix::index::write::Options::default()) + .map_err(|err| Error::backend("git write index", err)) +} + +fn write_tree_map( + repo: &gix::Repository, + map: &BTreeMap, +) -> Result { + let empty = repo.empty_tree(); + let mut editor = empty + .edit() + .map_err(|err| Error::backend("git edit tree", err))?; + for (path, entry) in map { + validate_repo_path(path).map_err(ApplyFailure::into_error)?; + editor + .upsert(path.as_str(), entry_kind(entry.mode), entry.id) + .map_err(|err| Error::backend("git edit tree", err))?; + } + editor + .write() + .map(|id| id.detach()) + .map_err(|err| Error::backend("git write tree", err)) +} + +fn entry_kind(mode: Mode) -> EntryKind { + if mode == Mode::FILE_EXECUTABLE { + EntryKind::BlobExecutable + } else if mode == Mode::SYMLINK { + EntryKind::Link + } else if mode == Mode::COMMIT { + EntryKind::Commit + } else { + EntryKind::Blob + } +} + +fn write_patch_worktree( + repo: &GitRepo, + patches: &[FilePatch], + reverse: bool, + state: &BTreeMap, +) -> Result<()> { + for patch in patches { + let (source, target, ..) = patch_sides(patch, reverse); + if let Some(source) = source + && target != Some(source) + { + remove_worktree_path(repo, source)?; + } + if let Some(target) = target { + let entry = state.get(target).ok_or_else(|| Error::PatchFailed { + message: format!("missing applied path {target}"), + })?; + write_worktree_entry(repo, target, entry, &repo.gix()?)?; + } + } + Ok(()) +} + +fn write_worktree_map( + repo: &GitRepo, + previous: &BTreeMap, + next: &BTreeMap, +) -> Result<()> { + let gix_repo = repo.gix()?; + for path in previous.keys() { + if !next.contains_key(path) { + remove_worktree_path(repo, path)?; + } + } + for (path, entry) in next { + if previous.get(path) != Some(entry) || !repo.root().join(path).exists() { + write_worktree_entry(repo, path, entry, &gix_repo)?; + } + } + Ok(()) +} + +fn write_worktree_entry( + repo: &GitRepo, + path: &str, + entry: &FileEntry, + gix_repo: &gix::Repository, +) -> Result<()> { + validate_repo_path(path).map_err(ApplyFailure::into_error)?; + let absolute = repo.root().join(path); + if let Some(parent) = absolute.parent() { + fs::create_dir_all(parent)?; + } + let bytes = blob_bytes(gix_repo, entry.id)?; + if entry.mode == Mode::SYMLINK { + let _ = fs::remove_file(&absolute); + #[cfg(unix)] + { + use std::os::unix::{ffi::OsStrExt, fs::symlink}; + symlink(std::ffi::OsStr::from_bytes(&bytes), &absolute)?; + } + #[cfg(not(unix))] + fs::write(&absolute, bytes)?; + return Ok(()); + } + fs::write(&absolute, bytes)?; + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + let permissions = fs::Permissions::from_mode(if entry.mode == Mode::FILE_EXECUTABLE { + 0o755 + } else { + 0o644 + }); + fs::set_permissions(&absolute, permissions)?; + } + Ok(()) +} + +fn remove_worktree_path(repo: &GitRepo, path: &str) -> Result<()> { + validate_repo_path(path).map_err(ApplyFailure::into_error)?; + let absolute = repo.root().join(path); + match fs::remove_file(&absolute) { + Ok(()) => {}, + Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(()), + Err(err) => return Err(err.into()), + } + let mut directory = absolute.parent(); + while let Some(current) = directory { + if current == repo.root() { + break; + } + match fs::remove_dir(current) { + Ok(()) => directory = current.parent(), + Err(_) => break, + } + } + Ok(()) +} + +fn validate_repo_path(path: &str) -> std::result::Result<(), ApplyFailure> { + let candidate = PathBuf::from(path); + if candidate.is_absolute() + || candidate.components().any(|component| { + matches!(component, Component::ParentDir | Component::RootDir | Component::Prefix(_)) + }) || path.is_empty() + { + return Err(ApplyFailure::Invalid(format!("unsafe patch path: {path}"))); + } + Ok(()) +} +#[cfg(test)] +mod tests { + use std::process::Command; + + use tempfile::TempDir; + + use super::*; + + fn git(cwd: &Path, args: &[&str]) -> String { + let output = Command::new("git") + .current_dir(cwd) + .args(args) + .output() + .expect("run git"); + assert!( + output.status.success(), + "git {} failed: {}", + args.join(" "), + String::from_utf8_lossy(&output.stderr) + ); + String::from_utf8(output.stdout).expect("git output is UTF-8") + } + fn git_with_index(cwd: &Path, index: &Path, args: &[&str]) -> String { + let output = Command::new("git") + .current_dir(cwd) + .env("GIT_INDEX_FILE", index) + .args(args) + .output() + .expect("run git with alternate index"); + assert!( + output.status.success(), + "git {} failed: {}", + args.join(" "), + String::from_utf8_lossy(&output.stderr) + ); + String::from_utf8(output.stdout).expect("git output is UTF-8") + } + + fn init(files: &[(&str, &[u8])]) -> TempDir { + let temp = tempfile::tempdir().expect("tempdir"); + git(temp.path(), &["init", "-q"]); + git(temp.path(), &["config", "user.name", "Patch Test"]); + git(temp.path(), &["config", "user.email", "patch@example.com"]); + for (path, bytes) in files { + let absolute = temp.path().join(path); + if let Some(parent) = absolute.parent() { + fs::create_dir_all(parent).expect("create parent"); + } + fs::write(absolute, bytes).expect("write fixture"); + } + git(temp.path(), &["add", "-A"]); + git(temp.path(), &["commit", "-qm", "base"]); + temp + } + + fn repo(path: &Path) -> GitRepo { + GitRepo::require(path).expect("discover repo") + } + + fn reset(path: &Path) { + git(path, &["reset", "--hard", "-q", "HEAD"]); + git(path, &["clean", "-fdq"]); + } + + #[test] + fn patch_stage_hunks_stages_intent_to_add_and_preserves_unrelated_promise() { + let temp = init(&[("base.txt", b"one\ntwo\n")]); + fs::write(temp.path().join("picked.txt"), b"picked\n").expect("write picked"); + fs::write(temp.path().join("promised.txt"), b"promised\n").expect("write promised"); + git(temp.path(), &["add", "-N", "picked.txt", "promised.txt"]); + fs::write(temp.path().join("base.txt"), b"one changed\ntwo\n").expect("edit base"); + let repo = repo(temp.path()); + let raw = repo.diff_text(&DiffOptions::default()).expect("diff"); + repo + .stage_hunks( + &[ + HunkSelection { path: "picked.txt".into(), hunks: HunkSpec::Indices(vec![1]) }, + HunkSelection { path: "base.txt".into(), hunks: HunkSpec::All }, + ], + Some(&raw), + ) + .expect("stage hunks over intent-to-add"); + // git is the oracle: the create patch lands on the promised entry and + // the unrelated intent-to-add flag survives the index rewrite. + let status = git(temp.path(), &["status", "--porcelain"]); + assert!(status.contains("A picked.txt"), "picked.txt staged: {status}"); + assert!(status.contains("M base.txt"), "base.txt staged: {status}"); + assert!(status.contains(" A promised.txt"), "promised.txt keeps intent-to-add: {status}"); + } + + #[test] + fn stage_hunks_commit_split_survives_unadvanced_index_mtime() { + // Regression for #10130 (the issue-966 split-commit repro): two + // back-to-back stage_hunks -> commit_create pairs on one reused handle + // read a stale in-memory index snapshot when every mutation landed in a + // single mtime tick, so the first commit errored "nothing to commit". + let temp = init(&[("tracked.txt", b"original\n")]); + fs::write(temp.path().join("tracked.txt"), b"updated\n").expect("edit tracked"); + fs::write(temp.path().join("new-file.txt"), b"new\n").expect("write new"); + git(temp.path(), &["add", "-N", "new-file.txt"]); + let repo = repo(temp.path()); + let raw = repo.diff_text(&DiffOptions::default()).expect("diff"); + + // Freeze the index mtime so every read collides with the preceding write + // on the same tick — the exact race the fix removes. + crate::git::pin_index_mtime(&repo); + + repo + .stage_hunks( + &[HunkSelection { path: "new-file.txt".into(), hunks: HunkSpec::All }], + Some(&raw), + ) + .expect("stage new file"); + crate::git::pin_index_mtime(&repo); + repo + .commit_create("feat: add new file", &crate::types::CommitOptions::default()) + .expect("commit new file"); + crate::git::pin_index_mtime(&repo); + repo + .stage_hunks( + &[HunkSelection { path: "tracked.txt".into(), hunks: HunkSpec::All }], + Some(&raw), + ) + .expect("stage tracked file"); + crate::git::pin_index_mtime(&repo); + repo + .commit_create("fix: update tracked file", &crate::types::CommitOptions::default()) + .expect("commit tracked file"); + + assert_eq!( + git(temp.path(), &["log", "--format=%s", "-2"]).trim(), + "fix: update tracked file\nfeat: add new file" + ); + assert_eq!(git(temp.path(), &["show", "HEAD:tracked.txt"]), "updated\n"); + assert_eq!(git(temp.path(), &["show", "HEAD~1:new-file.txt"]), "new\n"); + } + + #[test] + fn patch_join_and_validation_preserve_binary_terminators() { + assert_eq!(join_patches(&["one\n\n".into(), "two".into(), String::new()]), "one\n\ntwo\n\n"); + let binary = "diff --git a/a.bin b/a.bin\nindex 1111111..2222222 100644\nGIT binary \ + patch\nliteral 1\nIc${O300000\n\n"; + let errors = validate_hunk_selections(binary, &[ + HunkSelection { path: "missing".into(), hunks: HunkSpec::Indices(vec![1]) }, + HunkSelection { path: "a.bin".into(), hunks: HunkSpec::Indices(vec![1]) }, + ]); + assert_eq!(errors.len(), 1); + assert_eq!(errors[0].path, "a.bin"); + } + + #[test] + fn patch_apply_matches_git_for_text_binary_mode_rename_and_no_eof() { + let binary: Vec = (0_u8..=255).cycle().take(4096).collect(); + let files: Vec<(&str, &[u8])> = vec![ + ("text.txt", b"alpha\nbeta\ngamma\n"), + ("old.txt", b"rename body\nsecond\n"), + ("noeof.txt", b"before"), + ("script.sh", b"#!/bin/sh\necho hi\n"), + ("data.bin", &binary), + ("deleted.txt", b"delete this unique file\n"), + ]; + let ours = init(&files); + let oracle = init(&files); + fs::write(ours.path().join("text.txt"), b"alpha\nBETA\ngamma\n").expect("edit text"); + fs::rename(ours.path().join("old.txt"), ours.path().join("new.txt")).expect("rename"); + fs::write(ours.path().join("new.txt"), b"rename body\nchanged\n").expect("edit rename"); + git(ours.path(), &["add", "-N", "new.txt"]); + fs::remove_file(ours.path().join("deleted.txt")).expect("delete file"); + fs::write(ours.path().join("created.txt"), b"new unique file\n").expect("create file"); + git(ours.path(), &["add", "-N", "created.txt"]); + fs::write(ours.path().join("noeof.txt"), b"after").expect("edit no-eof"); + let mut changed_binary = binary; + changed_binary[7] ^= 0xff; + changed_binary.extend_from_slice(b"\0tail"); + fs::write(ours.path().join("data.bin"), &changed_binary).expect("edit binary"); + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + fs::set_permissions(ours.path().join("script.sh"), fs::Permissions::from_mode(0o755)) + .expect("chmod"); + } + let patch = git(ours.path(), &["diff", "--binary", "--find-renames"]); + reset(ours.path()); + assert!( + repo(ours.path()) + .can_apply_patch(&patch, &ApplyOptions::default()) + .expect("check patch") + ); + repo(ours.path()) + .apply_patch(&patch, &ApplyOptions::default()) + .expect("apply worktree"); + let patch_file = oracle.path().join("change.patch"); + fs::write(&patch_file, &patch).expect("write patch"); + git(oracle.path(), &["apply", "--binary", "change.patch"]); + fs::remove_file(patch_file).expect("remove patch"); + assert_eq!( + git(ours.path(), &["status", "--porcelain"]), + git(oracle.path(), &["status", "--porcelain"]) + ); + for path in ["text.txt", "new.txt", "noeof.txt", "script.sh", "data.bin", "created.txt"] { + assert_eq!( + fs::read(ours.path().join(path)) + .unwrap_or_else(|err| panic!("read ours {path}: {err}")), + fs::read(oracle.path().join(path)).expect("read oracle"), + "{path}" + ); + } + assert!(!ours.path().join("deleted.txt").exists()); + assert!(!oracle.path().join("deleted.txt").exists()); + repo(ours.path()) + .apply_patch(&patch, &ApplyOptions { + cached: false, + index_path: None, + reverse: true, + three_way: false, + }) + .expect("reverse worktree patch"); + let patch_file = oracle.path().join("change.patch"); + fs::write(&patch_file, &patch).expect("write reverse patch"); + git(oracle.path(), &["apply", "--reverse", "--binary", "change.patch"]); + fs::remove_file(patch_file).expect("remove reverse patch"); + assert_eq!( + git(ours.path(), &["status", "--porcelain"]), + git(oracle.path(), &["status", "--porcelain"]) + ); + + reset(ours.path()); + reset(oracle.path()); + repo(ours.path()) + .apply_patch(&patch, &ApplyOptions { + cached: true, + index_path: None, + reverse: false, + three_way: false, + }) + .expect("apply cached"); + let patch_file = oracle.path().join("change.patch"); + fs::write(&patch_file, &patch).expect("write patch"); + git(oracle.path(), &["apply", "--cached", "--binary", "change.patch"]); + fs::remove_file(patch_file).expect("remove patch"); + assert_eq!(git(ours.path(), &["write-tree"]), git(oracle.path(), &["write-tree"])); + assert_eq!( + git(ours.path(), &["status", "--porcelain"]), + git(oracle.path(), &["status", "--porcelain"]) + ); + } + + #[test] + fn patch_stage_hunks_selects_indices_and_lines() { + let original = (1..=20).fold(String::new(), |mut out, line| { + use std::fmt::Write as _; + let _ = writeln!(out, "line {line}"); + out + }); + let temp = init(&[("file.txt", original.as_bytes())]); + let changed = original + .replace("line 2\n", "LINE TWO\n") + .replace("line 18\n", "LINE EIGHTEEN\n"); + fs::write(temp.path().join("file.txt"), changed).expect("edit"); + let diff = git(temp.path(), &["diff", "--unified=1"]); + let repository = repo(temp.path()); + repository + .stage_hunks( + &[HunkSelection { path: "file.txt".into(), hunks: HunkSpec::Indices(vec![1]) }], + Some(&diff), + ) + .expect("stage first hunk"); + let staged = git(temp.path(), &["show", ":file.txt"]); + assert!(staged.contains("LINE TWO")); + assert!(staged.contains("line 18")); + assert!(!staged.contains("LINE EIGHTEEN")); + } + #[test] + fn patch_cached_mixed_creation_uses_dev_null_with_alternate_index() { + let temp = init(&[("tracked.txt", b"base\n")]); + fs::create_dir_all(temp.path().join("src")).expect("create src"); + fs::write(temp.path().join("src/new.py"), b"WIP header\nunchanged\n") + .expect("write WIP file"); + let repository = repo(temp.path()); + let created = repository + .diff_no_index(Path::new("/dev/null"), Path::new("src/new.py"), true) + .expect("creation patch"); + assert!(created.contains("--- /dev/null")); + + git(temp.path(), &["add", "src/new.py"]); + fs::write(temp.path().join("tracked.txt"), b"changed\n").expect("edit tracked"); + fs::write(temp.path().join("src/new.py"), b"WIP header\nagent-edit\n") + .expect("edit WIP file"); + let modified = repository + .diff_text(&DiffOptions { binary: true, ..DiffOptions::default() }) + .expect("mixed tracked patch"); + assert!(modified.contains("--- a/src/new.py")); + + let ours_index = temp.path().join("ours-mixed.index"); + let oracle_index = temp.path().join("oracle-mixed.index"); + repository + .read_tree("HEAD", Some(&ours_index)) + .expect("seed ours index"); + git_with_index(temp.path(), &oracle_index, &["read-tree", "HEAD"]); + let options = ApplyOptions { + cached: true, + index_path: Some(ours_index.clone()), + reverse: false, + three_way: false, + }; + repository + .apply_patch(&created, &options) + .expect("apply creation patch"); + repository + .apply_patch(&modified, &options) + .expect("apply following modification patch"); + + let creation_file = temp.path().join("creation.patch"); + let modified_file = temp.path().join("modified.patch"); + fs::write(&creation_file, &created).expect("write creation patch"); + fs::write(&modified_file, &modified).expect("write modified patch"); + git_with_index(temp.path(), &oracle_index, &[ + "apply", + "--cached", + "--binary", + "creation.patch", + ]); + git_with_index(temp.path(), &oracle_index, &[ + "apply", + "--cached", + "--binary", + "modified.patch", + ]); + let ours_tree = repository + .write_tree(Some(&ours_index)) + .expect("write ours mixed tree"); + let oracle_tree = git_with_index(temp.path(), &oracle_index, &["write-tree"]); + assert_eq!(ours_tree, oracle_tree.trim()); + } + + #[test] + fn patch_cached_alternate_index_matches_git_and_preserves_real_index() { + let temp = init(&[("file.txt", b"base\n")]); + fs::write(temp.path().join("file.txt"), b"patched\n").expect("edit"); + let patch = git(temp.path(), &["diff", "--full-index"]); + reset(temp.path()); + let repository = repo(temp.path()); + let ours_index = temp.path().join("ours.index"); + let oracle_index = temp.path().join("oracle.index"); + repository + .read_tree("HEAD", Some(&ours_index)) + .expect("seed ours index"); + git_with_index(temp.path(), &oracle_index, &["read-tree", "HEAD"]); + let real_index_before = fs::read(temp.path().join(".git/index")).expect("real index"); + let options = ApplyOptions { + cached: true, + index_path: Some(ours_index.clone()), + reverse: false, + three_way: false, + }; + let ours_before_check = fs::read(&ours_index).expect("ours index before check"); + assert!( + repository + .can_apply_patch(&patch, &options) + .expect("alternate index check") + ); + assert_eq!(fs::read(&ours_index).expect("ours index after check"), ours_before_check); + repository + .apply_patch(&patch, &options) + .expect("apply alternate index"); + let patch_file = temp.path().join("alternate.patch"); + fs::write(&patch_file, &patch).expect("write patch"); + git_with_index(temp.path(), &oracle_index, &[ + "apply", + "--cached", + "--binary", + "alternate.patch", + ]); + fs::remove_file(patch_file).expect("remove patch"); + let ours_tree = repository + .write_tree(Some(&ours_index)) + .expect("write ours tree"); + let oracle_tree = git_with_index(temp.path(), &oracle_index, &["write-tree"]); + assert_eq!(ours_tree, oracle_tree.trim()); + assert_eq!( + fs::read(temp.path().join(".git/index")).expect("real index after"), + real_index_before + ); + } + + #[test] + fn patch_three_way_check_merges_drift_and_rejects_conflict() { + let temp = init(&[("file.txt", b"one\ntwo\nthree\n")]); + fs::write(temp.path().join("file.txt"), b"one\nTWO\nthree\n").expect("patch edit"); + let patch = git(temp.path(), &["diff", "--full-index"]); + reset(temp.path()); + fs::write(temp.path().join("file.txt"), b"ONE\ntwo\nthree\n").expect("drift"); + let repository = repo(temp.path()); + assert!( + !repository + .can_apply_patch(&patch, &ApplyOptions::default()) + .expect("direct check") + ); + let three_way = + ApplyOptions { cached: false, index_path: None, reverse: false, three_way: true }; + assert!( + repository + .can_apply_patch(&patch, &three_way) + .expect("three-way check") + ); + repository + .apply_patch(&patch, &three_way) + .expect("three-way apply"); + assert_eq!( + fs::read(temp.path().join("file.txt")).expect("merged file"), + b"ONE\nTWO\nthree\n" + ); + + reset(temp.path()); + fs::write(temp.path().join("file.txt"), b"one\nOTHER\nthree\n").expect("conflict"); + assert!( + !repository + .can_apply_patch(&patch, &three_way) + .expect("conflict check") + ); + } + + #[test] + fn patch_cherry_pick_and_stash_are_fail_clean() { + let temp = init(&[("file.txt", b"base\n"), (".gitignore", b"ignored.txt\n")]); + let base_branch = git(temp.path(), &["branch", "--show-current"]) + .trim() + .to_owned(); + let base_sha = git(temp.path(), &["rev-parse", "HEAD"]).trim().to_owned(); + git(temp.path(), &["checkout", "-qb", "topic"]); + fs::write(temp.path().join("file.txt"), b"base\ntopic\n").expect("topic edit"); + git(temp.path(), &["commit", "-qam", "topic change"]); + let topic = git(temp.path(), &["rev-parse", "HEAD"]).trim().to_owned(); + fs::write(temp.path().join("remaining.txt"), b"remaining\n").expect("remaining edit"); + git(temp.path(), &["add", "remaining.txt"]); + git(temp.path(), &["commit", "-qm", "remaining change"]); + let topic_tip = git(temp.path(), &["rev-parse", "HEAD"]).trim().to_owned(); + git(temp.path(), &["checkout", "-q", &base_branch]); + let repository = repo(temp.path()); + repository.cherry_pick(&topic).expect("clean cherry-pick"); + assert_eq!(fs::read(temp.path().join("file.txt")).expect("read"), b"base\ntopic\n"); + assert!(matches!(repository.cherry_pick(&topic), Err(Error::EmptyCherryPick { .. }))); + for commit in repository + .rev_list_range(&base_sha, &topic_tip) + .expect("topic range") + { + match repository.cherry_pick(&commit) { + Ok(()) | Err(Error::EmptyCherryPick { .. }) => {}, + Err(error) => panic!("range cherry-pick failed: {error}"), + } + } + assert_eq!( + fs::read(temp.path().join("remaining.txt")).expect("remaining landed"), + b"remaining\n" + ); + let conflict = init(&[("file.txt", b"base\n")]); + let conflict_base = git(conflict.path(), &["branch", "--show-current"]) + .trim() + .to_owned(); + git(conflict.path(), &["checkout", "-qb", "other"]); + fs::write(conflict.path().join("file.txt"), b"other\n").expect("other edit"); + git(conflict.path(), &["commit", "-qam", "other"]); + let other = git(conflict.path(), &["rev-parse", "HEAD"]) + .trim() + .to_owned(); + git(conflict.path(), &["checkout", "-q", &conflict_base]); + fs::write(conflict.path().join("file.txt"), b"current\n").expect("current edit"); + git(conflict.path(), &["commit", "-qam", "current"]); + let before_head = git(conflict.path(), &["rev-parse", "HEAD"]); + let before_index = fs::read(conflict.path().join(".git/index")).expect("conflict index"); + assert!(matches!(repo(conflict.path()).cherry_pick(&other), Err(Error::Conflict { .. }))); + assert_eq!(git(conflict.path(), &["rev-parse", "HEAD"]), before_head); + assert_eq!( + fs::read(conflict.path().join(".git/index")).expect("conflict index after"), + before_index + ); + assert_eq!(fs::read(conflict.path().join("file.txt")).expect("conflict file"), b"current\n"); + + fs::write(temp.path().join("file.txt"), b"base\ntopic\nstaged\n").expect("staged edit"); + git(temp.path(), &["add", "file.txt"]); + fs::write(temp.path().join("file.txt"), b"base\ntopic\nstaged\nworktree\n") + .expect("worktree edit"); + fs::write(temp.path().join("untracked.txt"), b"untracked\n").expect("untracked"); + fs::write(temp.path().join("ignored.txt"), b"ignored\n").expect("ignored"); + assert!( + repository + .stash_push(Some("roundtrip")) + .expect("stash push") + ); + assert!(!temp.path().join("untracked.txt").exists()); + assert!(temp.path().join("ignored.txt").exists()); + assert!(repository.stash_try_pop(true).expect("stash pop")); + assert_eq!( + fs::read(temp.path().join("file.txt")).expect("restored"), + b"base\ntopic\nstaged\nworktree\n" + ); + assert_eq!( + fs::read(temp.path().join("untracked.txt")).expect("restored untracked"), + b"untracked\n" + ); + assert_eq!(fs::read(temp.path().join("ignored.txt")).expect("ignored remains"), b"ignored\n"); + + reset(temp.path()); + fs::write(temp.path().join("file.txt"), b"stashed\n").expect("stash conflict edit"); + assert!(repository.stash_push(None).expect("stash conflict")); + fs::write(temp.path().join("file.txt"), b"current\n").expect("current conflict edit"); + let before_file = fs::read(temp.path().join("file.txt")).expect("before file"); + let before_index = fs::read(temp.path().join(".git/index")).expect("before index"); + let before_stash = git(temp.path(), &["rev-parse", "refs/stash"]); + assert!(!repository.stash_try_pop(false).expect("conflicting pop")); + assert_eq!(fs::read(temp.path().join("file.txt")).expect("after file"), before_file); + assert_eq!(fs::read(temp.path().join(".git/index")).expect("after index"), before_index); + assert_eq!(git(temp.path(), &["rev-parse", "refs/stash"]), before_stash); + } + #[test] + fn patch_stash_pop_preserves_older_stack_entry() { + let temp = init(&[("file.txt", b"base\n")]); + let repository = repo(temp.path()); + fs::write(temp.path().join("file.txt"), b"first\n").expect("first stash"); + assert!(repository.stash_push(Some("first")).expect("push first")); + let first = git(temp.path(), &["rev-parse", "refs/stash"]); + fs::write(temp.path().join("file.txt"), b"second\n").expect("second stash"); + assert!(repository.stash_push(Some("second")).expect("push second")); + assert_ne!(git(temp.path(), &["rev-parse", "refs/stash"]), first); + assert!(repository.stash_try_pop(false).expect("pop second")); + assert_eq!(git(temp.path(), &["rev-parse", "refs/stash"]), first); + assert_eq!(fs::read(temp.path().join("file.txt")).expect("second restored"), b"second\n"); + } +} diff --git a/crates/pi-vcs/src/git/read.rs b/crates/pi-vcs/src/git/read.rs new file mode 100644 index 000000000000..98faad1806b8 --- /dev/null +++ b/crates/pi-vcs/src/git/read.rs @@ -0,0 +1,1387 @@ +//! Read-side operations on [`GitRepo`](super::GitRepo). + +use std::{ + collections::{BTreeMap, BTreeSet, HashSet, VecDeque}, + path::{Path, PathBuf}, +}; + +use gix::bstr::ByteSlice; + +use super::{ + GitRepo, + open::{load_index_or_empty, status_with_fresh_index}, +}; +use crate::{ + error::{Error, Result}, + types::{ + CommitAuthor, CommitDetails, HeadState, ShowResult, StatusOptions, StatusSummary, + UntrackedMode, WorktreeEntry, + }, +}; + +impl GitRepo { + /// Resolve the repository HEAD, preserving an unborn symbolic branch. + pub fn head(&self) -> Result { + if self.is_reftable() { + let symbolic = cli_try(self.root(), &["symbolic-ref", "HEAD"])?; + let commit = cli_try(self.root(), &["rev-parse", "--verify", "HEAD"])?; + return Ok(match symbolic { + Some(ref_name) => HeadState::Ref { + branch: ref_name.strip_prefix("refs/heads/").map(str::to_owned), + ref_name, + commit, + }, + None => HeadState::Detached { commit }, + }); + } + let content = std::fs::read_to_string(&self.info().head_path)?; + let value = content.trim(); + if let Some(ref_name) = value.strip_prefix("ref:").map(str::trim) { + return Ok(HeadState::Ref { + ref_name: ref_name.to_owned(), + branch: ref_name.strip_prefix("refs/heads/").map(str::to_owned), + commit: self.peel_symbolic(self.read_ref(ref_name)?)?, + }); + } + Ok(HeadState::Detached { commit: nonempty(value) }) + } + + /// Return the commit currently named by HEAD, if HEAD is born. + pub fn head_sha(&self) -> Result> { + Ok(self.head()?.commit().map(str::to_owned)) + } + + /// Return the checked-out local branch, or `None` for detached HEAD. + pub fn current_branch(&self) -> Result> { + Ok(match self.head()? { + HeadState::Ref { ref_name, branch, .. } => Some(branch.unwrap_or(ref_name)), + HeadState::Detached { .. } => None, + }) + } + + /// Return the default branch advertised by origin or upstream. + pub fn default_branch(&self) -> Result> { + for remote in ["origin", "upstream"] { + let name = format!("refs/remotes/{remote}/HEAD"); + let Some(value) = self.read_ref(&name)? else { + continue; + }; + let Some(target) = value.strip_prefix("ref:").map(str::trim) else { + continue; + }; + let prefix = format!("refs/remotes/{remote}/"); + if let Some(branch) = target.strip_prefix(&prefix).filter(|v| !v.is_empty()) { + return Ok(Some(branch.to_owned())); + } + } + Ok(None) + } + + /// Resolve a ref name or revision expression to its object id. + pub fn resolve_ref(&self, name: &str) -> Result> { + if name == "HEAD" { + return self.head_sha(); + } + if self.is_reftable() { + return cli_try(self.root(), &["rev-parse", "--verify", name]); + } + if name.starts_with("refs/") { + return self + .read_ref(name) + .and_then(|value| self.peel_symbolic(value)); + } + let repo = self.gix()?; + match repo.rev_parse_single(name) { + Ok(id) => Ok(Some(id.detach().to_string())), + Err(_) => Ok(None), + } + } + + /// Test whether a ref or revision resolves. + pub fn ref_exists(&self, name: &str) -> Result { + Ok(self.resolve_ref(name)?.is_some()) + } + + /// List tags pointing at `rev`, peeled through annotated tags. + pub fn tags_at(&self, rev: &str) -> Result> { + if self.is_reftable() { + return cli_lines(self.root(), &[ + "for-each-ref", + "--points-at", + rev, + "--sort=-version:refname", + "--format=%(refname:strip=2)", + "refs/tags", + ]); + } + let Some(target) = self.resolve_ref(rev)? else { + return Ok(Vec::new()); + }; + let repo = self.gix()?; + let refs = repo + .references() + .map_err(|err| Error::backend("git tags", err))?; + let iter = refs.tags().map_err(|err| Error::backend("git tags", err))?; + let mut tags = Vec::new(); + for reference in iter { + let mut reference = reference.map_err(|err| Error::backend("git tags", err))?; + let id = reference + .peel_to_id() + .map_err(|err| Error::backend("git tags", err))?; + if id.to_string() == target + && let Some(name) = reference + .name() + .as_bstr() + .to_str() + .ok() + .and_then(|n| n.strip_prefix("refs/tags/")) + { + tags.push(name.to_owned()); + } + } + version_sort_desc(&mut tags); + Ok(tags) + } + + /// List local branches, optionally including remote-tracking branches. + pub fn list_branches(&self, all: bool) -> Result> { + if self.is_reftable() { + let mut args = vec!["branch"]; + if all { + args.push("-a"); + } + args.push("--format=%(refname:short)"); + return cli_lines(self.root(), &args); + } + let repo = self.gix()?; + let refs = repo + .references() + .map_err(|err| Error::backend("git branch", err))?; + let iter = refs + .all() + .map_err(|err| Error::backend("git branch", err))?; + let mut out = Vec::new(); + for reference in iter { + let reference = reference.map_err(|err| Error::backend("git branch", err))?; + let name = reference + .name() + .as_bstr() + .to_str() + .map_err(|err| Error::backend("git branch", err))?; + if let Some(short) = name.strip_prefix("refs/heads/") { + out.push(short.to_owned()); + } else if all && let Some(short) = name.strip_prefix("refs/remotes/") { + out.push(format!("remotes/{short}")); + } + } + out.sort(); + Ok(out) + } + + /// Whether default porcelain status reports a staged, unstaged, or untracked + /// change. + pub fn is_dirty(&self) -> Result { + let options = StatusOptions::default(); + if self.is_reftable() { + return self + .status_porcelain(&options) + .map(|status| !status.is_empty()); + } + let repo = self.gix()?; + let platform = status_with_fresh_index(&repo, "git status")? + .untracked_files(gix::status::UntrackedFiles::Collapsed); + let iter = platform + .into_iter(options.pathspecs.iter().map(|path| path.as_bytes().into())) + .map_err(|err| Error::backend("git status", err))?; + use gix::status::{Item, index_worktree, plumbing::index_as_worktree::EntryStatus}; + for item in iter { + let item = item.map_err(|err| Error::backend("git status", err))?; + match item { + Item::TreeIndex(_) | Item::IndexWorktree(index_worktree::Item::Rewrite { .. }) => { + return Ok(true); + }, + Item::IndexWorktree(index_worktree::Item::Modification { status, .. }) + if !matches!(status, EntryStatus::NeedsUpdate(_)) => + { + return Ok(true); + }, + Item::IndexWorktree(index_worktree::Item::DirectoryContents { entry, .. }) + if entry.status == gix::dir::entry::Status::Untracked + && (entry.disk_kind != Some(gix::dir::entry::Kind::Directory) + || dir_contains_file( + &self + .info() + .repo_root + .join(bytes_to_path(entry.rela_path.as_bstr())), + )) => + { + return Ok(true); + }, + _ => {}, + } + } + Ok(false) + } + + /// Render git status in porcelain-v1 form. + pub fn status_porcelain(&self, options: &StatusOptions) -> Result { + if self.is_reftable() { + let mut owned = vec!["status".to_owned(), "--porcelain".to_owned()]; + owned.push(match options.untracked { + UntrackedMode::No => "--untracked-files=no".to_owned(), + UntrackedMode::Normal => "--untracked-files=normal".to_owned(), + UntrackedMode::All => "--untracked-files=all".to_owned(), + }); + if options.nul_terminated { + owned.push("-z".to_owned()); + } + if !options.pathspecs.is_empty() { + owned.push("--".to_owned()); + owned.extend(options.pathspecs.iter().cloned()); + } + return cli_text_owned(self.root(), &owned); + } + let repo = self.gix()?; + let untracked = match options.untracked { + UntrackedMode::No => gix::status::UntrackedFiles::None, + UntrackedMode::Normal => gix::status::UntrackedFiles::Collapsed, + UntrackedMode::All => gix::status::UntrackedFiles::Files, + }; + let platform = status_with_fresh_index(&repo, "git status")?.untracked_files(untracked); + let iter = platform + .into_iter(options.pathspecs.iter().map(|path| path.as_bytes().into())) + .map_err(|err| Error::backend("git status", err))?; + let mut states: BTreeMap)> = BTreeMap::new(); + // git emits tracked changes first, then untracked entries, each block + // sorted by path — not one merged sort. + let mut untracked_paths: std::collections::BTreeSet = + std::collections::BTreeSet::new(); + for item in iter { + let item = item.map_err(|err| Error::backend("git status", err))?; + use gix::status::{Item, index_worktree}; + match item { + Item::TreeIndex(change) => { + use gix::diff::index::ChangeRef; + match change { + ChangeRef::Addition { location, .. } => { + set_index(&mut states, &location, 'A', None); + }, + ChangeRef::Deletion { location, .. } => { + set_index(&mut states, &location, 'D', None); + }, + ChangeRef::Modification { location, .. } => { + set_index(&mut states, &location, 'M', None); + }, + ChangeRef::Rewrite { source_location, location, copy, .. } => { + set_index( + &mut states, + &location, + if copy { 'C' } else { 'R' }, + Some(bytes_to_path(&source_location)), + ); + }, + } + }, + Item::IndexWorktree(change) => match change { + index_worktree::Item::Modification { rela_path, status, .. } => { + use gix::status::plumbing::index_as_worktree::{Change, EntryStatus}; + let code = match status { + EntryStatus::Conflict { .. } => 'U', + EntryStatus::Change(Change::Removed) => 'D', + EntryStatus::Change(Change::Type { .. }) => 'T', + EntryStatus::Change( + Change::Modification { .. } | Change::SubmoduleModification(_), + ) => 'M', + // git reports `git add -N` entries as worktree-side + // additions (` A`); the index side stays clean. + EntryStatus::IntentToAdd => 'A', + EntryStatus::NeedsUpdate(_) => continue, + }; + set_worktree(&mut states, rela_path.as_bstr(), code); + }, + index_worktree::Item::DirectoryContents { entry, .. } + if entry.status == gix::dir::entry::Status::Untracked => + { + let mut path = bytes_to_path(entry.rela_path.as_bstr()); + // A collapsed untracked directory renders with a + // trailing slash (`?? newdir/`). + if entry.disk_kind == Some(gix::dir::entry::Kind::Directory) { + // git only lists an untracked directory when at + // least one file exists beneath it; a tree of + // empty directories is invisible to status. + if !dir_contains_file(&self.info().repo_root.join(&path)) { + continue; + } + path.push('/'); + } + untracked_paths.insert(path); + }, + index_worktree::Item::Rewrite { source, dirwalk_entry, copy, .. } => { + let old = match source { + index_worktree::RewriteSource::RewriteFromIndex { + source_rela_path, .. + } => bytes_to_path(source_rela_path.as_bstr()), + index_worktree::RewriteSource::CopyFromDirectoryEntry { + source_dirwalk_entry, + .. + } => bytes_to_path(source_dirwalk_entry.rela_path.as_bstr()), + }; + let new = bytes_to_path(dirwalk_entry.rela_path.as_bstr()); + states.insert(new, (' ', if copy { 'C' } else { 'R' }, Some(old))); + }, + _ => {}, + }, + } + } + let separator = if options.nul_terminated { '\0' } else { '\n' }; + let mut out = String::new(); + for (path, (x, y, old)) in states.into_iter().chain( + untracked_paths + .into_iter() + .map(|path| (path, ('?', '?', None))), + ) { + out.push(x); + out.push(y); + out.push(' '); + if options.nul_terminated { + out.push_str(&path); + out.push(separator); + if let Some(old) = old { + out.push_str(&old); + out.push(separator); + } + } else { + if let Some(old) = old { + out.push_str("e_path(&old)); + out.push_str(" -> "); + } + out.push_str("e_path(&path)); + out.push(separator); + } + } + Ok(out) + } + + /// Count staged, unstaged, and untracked status entries. + pub fn status_summary(&self) -> Result { + let text = self.status_porcelain(&StatusOptions { + untracked: UntrackedMode::Normal, + ..Default::default() + })?; + let mut summary = StatusSummary::default(); + for line in text.lines().filter(|line| line.len() >= 2) { + let bytes = line.as_bytes(); + if bytes[0] == b'?' && bytes[1] == b'?' { + summary.untracked += 1; + } else { + if bytes[0] != b' ' { + summary.staged += 1; + } + if bytes[1] != b' ' { + summary.unstaged += 1; + } + } + } + Ok(summary) + } + + /// Read a scalar git config value. + pub fn config_get(&self, key: &str) -> Result> { + if self.is_reftable() { + return cli_try(self.root(), &["config", "--get", key]); + } + let repo = self.gix_fresh()?; + Ok(repo + .config_snapshot() + .string(key) + .and_then(|v| nonempty(v.to_str_lossy().trim()))) + } + + /// List configured remote names. + pub fn remote_list(&self) -> Result> { + if self.is_reftable() { + return cli_lines(self.root(), &["remote"]); + } + let repo = self.gix_fresh()?; + let mut names = BTreeSet::new(); + for section in repo + .config_snapshot() + .sections_by_name("remote") + .into_iter() + .flatten() + { + if let Some(name) = section + .header() + .subsection_name() + .and_then(|v| v.to_str().ok()) + { + names.insert(name.to_owned()); + } + } + Ok(names.into_iter().collect()) + } + + /// Return a remote's fetch URL. + pub fn remote_url(&self, name: &str) -> Result> { + if self.is_reftable() { + return cli_try(self.root(), &["remote", "get-url", name]); + } + let repo = self.gix_fresh()?; + let Some(remote) = repo.try_find_remote(name.as_bytes().as_bstr()) else { + return Ok(None); + }; + let remote = remote.map_err(|err| Error::backend("git remote", err))?; + Ok(remote + .url(gix::remote::Direction::Fetch) + .map(|url| url.to_bstring().to_str_lossy().into_owned())) + } + + /// List the primary and linked worktrees. + pub fn worktrees(&self) -> Result> { + if self.is_reftable() { + return Ok(parse_worktree_cli(&cli_text(self.root(), &[ + "worktree", + "list", + "--porcelain", + ])?)); + } + let primary_root = self + .info() + .common_dir + .parent() + .filter(|_| { + self + .info() + .common_dir + .file_name() + .is_some_and(|name| name == ".git") + }) + .unwrap_or_else(|| self.root()) + .to_owned(); + let primary_head = + parse_head_with_refs(&self.info().common_dir.join("HEAD"), &self.info().common_dir)?; + let mut out = vec![entry_from_head(primary_root, &primary_head)]; + let admin_root = self.info().common_dir.join("worktrees"); + let Ok(admins) = std::fs::read_dir(admin_root) else { + return Ok(out); + }; + let mut admins: Vec<_> = admins.filter_map(std::result::Result::ok).collect(); + admins.sort_by_key(std::fs::DirEntry::file_name); + for admin in admins { + let dir = admin.path(); + let Ok(pointer) = std::fs::read_to_string(dir.join("gitdir")) else { + continue; + }; + let dotgit = PathBuf::from(pointer.trim()); + let Some(root) = dotgit.parent().map(Path::to_owned) else { + continue; + }; + let head = parse_head_with_refs(&dir.join("HEAD"), &self.info().common_dir)?; + out.push(entry_from_head(root, &head)); + } + Ok(out) + } + + /// Return recent commit subjects, newest first. + pub fn log_subjects(&self, count: usize) -> Result> { + if self.is_reftable() { + return cli_lines(self.root(), &["log", &format!("-n{count}"), "--pretty=format:%s"]); + } + let repo = self.gix()?; + let mut out = Vec::new(); + for id in self.walk_commit_ids("HEAD")?.into_iter().take(count) { + let commit = repo + .find_commit(id) + .map_err(|err| Error::backend("git log", err))?; + out.push(commit_subject(&commit).map_err(|err| Error::backend("git log", err))?); + } + Ok(out) + } + + /// Return recent commits as ` ` lines. + pub fn log_onelines(&self, count: usize) -> Result> { + if self.is_reftable() { + return cli_lines(self.root(), &[ + "log", + &format!("-{count}"), + "--oneline", + "--no-decorate", + ]); + } + let mut out = Vec::new(); + let repo = self.gix()?; + for id in self.walk_commit_ids("HEAD")?.into_iter().take(count) { + let commit = repo + .find_commit(id) + .map_err(|err| Error::backend("git log", err))?; + let short = commit + .short_id() + .map_err(|err| Error::backend("git log", err))?; + out.push(format!( + "{} {}", + short, + commit_subject(&commit).map_err(|err| Error::backend("git log", err))? + )); + } + Ok(out) + } + + /// List commits in `base..head`, oldest first. + pub fn rev_list_range(&self, base: &str, head: &str) -> Result> { + if self.is_reftable() { + return cli_lines(self.root(), &["rev-list", "--reverse", &format!("{base}..{head}")]); + } + let repo = self.gix()?; + let base_id = repo + .rev_parse_single(base) + .map_err(|err| Error::backend("git rev-list", err))? + .detach(); + let head_id = repo + .rev_parse_single(head) + .map_err(|err| Error::backend("git rev-list", err))? + .detach(); + let walk = repo + .rev_walk([head_id]) + .with_hidden([base_id]) + .sorting(gix::revision::walk::Sorting::ByCommitTime( + gix::traverse::commit::simple::CommitTimeOrder::NewestFirst, + )) + .all() + .map_err(|err| Error::backend("git rev-list", err))?; + let mut out = walk + .map(|r| { + r.map(|i| i.id.to_string()) + .map_err(|e| Error::backend("git rev-list", e)) + }) + .collect::>>()?; + out.reverse(); + Ok(out) + } + + /// Return the best common ancestor of `a` and `b` (`git merge-base a b`), + /// or `None` when their histories are unrelated. Used for PR-style diffs, + /// which compare the merge base against the head rather than the two tips. + pub fn merge_base(&self, a: &str, b: &str) -> Result> { + if self.is_reftable() { + // `git merge-base` exits 1 for unrelated histories but 128 for fatal + // failures (missing ref, corrupt object); only the former is `None`. + let args = ["merge-base".to_owned(), a.to_owned(), b.to_owned()]; + let out = super::cli::run_sync(self.root(), &args)?; + return match out.exit_code { + 0 => Ok(nonempty(out.stdout.trim())), + 1 => Ok(None), + _ => out.into_checked(&args).map(|_| None), + }; + } + let repo = self.gix()?; + let a_id = repo + .rev_parse_single(a) + .map_err(|err| Error::backend("git merge-base", err))? + .detach(); + let b_id = repo + .rev_parse_single(b) + .map_err(|err| Error::backend("git merge-base", err))? + .detach(); + match repo.merge_base(a_id, b_id) { + Ok(id) => Ok(Some(id.detach().to_string())), + Err(gix::repository::merge_base::Error::NotFound { .. }) => Ok(None), + Err(err) => Err(Error::backend("git merge-base", err)), + } + } + + /// List commits touching `file`, newest first. + pub fn rev_list_touching(&self, rev: &str, file: &str, limit: usize) -> Result> { + if self.is_reftable() { + return cli_lines(self.root(), &[ + "rev-list", + &format!("--max-count={limit}"), + rev, + "--", + file, + ]); + } + let mut out = Vec::new(); + let repo = self.gix()?; + for id in self.walk_commit_ids(rev)? { + let commit = repo + .find_commit(id) + .map_err(|err| Error::backend("git rev-list", err))?; + let current = tree_entry_id( + &commit + .tree() + .map_err(|e| Error::backend("git rev-list", e))?, + file, + )?; + let parent = match commit.parent_ids().next() { + Some(id) => tree_entry_id( + &id.object() + .map_err(|e| Error::backend("git rev-list", e))? + .into_commit() + .tree() + .map_err(|e| Error::backend("git rev-list", e))?, + file, + )?, + None => None, + }; + if current != parent { + out.push(id.to_string()); + if out.len() == limit { + break; + } + } + } + Ok(out) + } + + /// Read commit identity, parent ids, author, date, and full message. + pub fn commit_details(&self, rev: &str) -> Result { + if self.is_reftable() { + let raw = cli_text(self.root(), &[ + "show", + "-s", + "--format=%H%x00%P%x00%an%x00%ae%x00%aI%x00%B", + rev, + ])?; + return Ok(parse_commit_details(&raw)); + } + let repo = self.gix()?; + let id = repo + .rev_parse_single(rev) + .map_err(|err| Error::backend("git show", err))?; + let commit = id + .object() + .map_err(|err| Error::backend("git show", err))? + .peel_to_commit() + .map_err(|err| Error::backend("git show", err))?; + let author = commit + .author() + .map_err(|err| Error::backend("git show", err))?; + let date = author + .time() + .map_err(|err| Error::backend("git show", err))? + .format(gix::date::time::format::ISO8601_STRICT) + .map_err(|err| Error::backend("git show", err))?; + let raw_message = commit + .message_raw() + .map_err(|err| Error::backend("git show", err))? + .to_str_lossy(); + let message = raw_message + .strip_suffix('\n') + .unwrap_or_else(|| raw_message.as_ref()) + .to_owned(); + Ok(CommitDetails { + sha: commit.id.to_string(), + parents: commit + .parent_ids() + .map(|parent| parent.detach().to_string()) + .collect(), + author: CommitAuthor { + name: author.name.to_str_lossy().into_owned(), + email: author.email.to_str_lossy().into_owned(), + date: Some(date), + }, + message, + }) + } + + /// List index paths, or untracked paths when `others` is true. + pub fn ls_files(&self, others: bool, exclude_standard: bool) -> Result> { + if self.is_reftable() { + let mut args = vec!["ls-files"]; + if others { + args.push("--others"); + } + if exclude_standard { + args.push("--exclude-standard"); + } + return cli_lines(self.root(), &args); + } + if !others { + let repo = self.gix()?; + let index = load_index_or_empty(&repo, "git ls-files")?; + let mut out: Vec<_> = index + .entries() + .iter() + .filter(|e| e.stage() == gix::index::entry::Stage::Unconflicted) + .map(|e| bytes_to_path(e.path(&index))) + .collect(); + out.sort(); + out.dedup(); + return Ok(out); + } + let repo = self.gix()?; + let mut platform = status_with_fresh_index(&repo, "git ls-files")? + .untracked_files(gix::status::UntrackedFiles::Files); + if !exclude_standard { + platform = platform.dirwalk_options(|opts| { + opts.emit_ignored(Some(gix::dir::walk::EmissionMode::Matching)) + }); + } + let iter = platform + .into_index_worktree_iter(std::iter::empty::()) + .map_err(|e| Error::backend("git ls-files", e))?; + let mut out = Vec::new(); + for item in iter { + if let gix::status::index_worktree::Item::DirectoryContents { entry, .. } = + item.map_err(|e| Error::backend("git ls-files", e))? + { + let wanted = entry.status == gix::dir::entry::Status::Untracked + || (!exclude_standard + && matches!(entry.status, gix::dir::entry::Status::Ignored(_))); + if wanted { + out.push(bytes_to_path(entry.rela_path.as_bstr())); + } + } + } + out.sort(); + Ok(out) + } + + /// List recursive blob paths in a tree, optionally filtered by pathspec-like + /// prefixes. + pub fn ls_tree(&self, rev: &str, paths: &[String]) -> Result> { + if self.is_reftable() { + let mut owned = vec![ + "ls-tree".to_owned(), + "--name-only".to_owned(), + "-r".to_owned(), + "-z".to_owned(), + rev.to_owned(), + ]; + if !paths.is_empty() { + owned.push("--".to_owned()); + owned.extend(paths.iter().cloned()); + } + return Ok(cli_text_owned(self.root(), &owned)? + .split('\0') + .filter(|s| !s.is_empty()) + .map(str::to_owned) + .collect()); + } + let repo = self.gix()?; + let tree = repo + .rev_parse_single(rev) + .map_err(|e| Error::backend("git ls-tree", e))? + .object() + .map_err(|e| Error::backend("git ls-tree", e))? + .peel_to_tree() + .map_err(|e| Error::backend("git ls-tree", e))?; + let mut out: Vec<_> = tree + .traverse() + .breadthfirst + .files() + .map_err(|e| Error::backend("git ls-tree", e))? + .into_iter() + .filter(|e| e.mode.is_blob() || e.mode.is_link()) + .map(|e| bytes_to_path(e.filepath.as_bstr())) + .filter(|p| paths.is_empty() || paths.iter().any(|wanted| path_matches(p, wanted))) + .collect(); + out.sort(); + Ok(out) + } + + /// List checked-out submodule paths recursively. + pub fn submodule_paths(&self) -> Result> { + let mut out = Vec::new(); + let mut queue = VecDeque::from([(self.root().to_owned(), String::new())]); + while let Some((root, prefix)) = queue.pop_front() { + for path in parse_gitmodules(&root.join(".gitmodules")) { + let full = root.join(&path); + if !full.join(".git").exists() { + continue; + } + let joined = if prefix.is_empty() { + path.clone() + } else { + format!("{prefix}/{path}") + }; + out.push(joined.clone()); + queue.push_back((full, joined)); + } + } + Ok(out) + } + + /// Read an object or `rev:path` blob, with an optional byte cap. + pub fn show_blob(&self, spec: &str, max_bytes: Option) -> Result { + if self.is_reftable() { + let text = cli_text(self.root(), &["show", spec])?; + return Ok(cap_bytes(text.into_bytes(), max_bytes)); + } + let repo = self.gix()?; + let id = repo + .rev_parse_single(spec) + .map_err(|_| Error::ObjectNotFound { spec: spec.to_owned() })?; + let object = id + .object() + .map_err(|_| Error::ObjectNotFound { spec: spec.to_owned() })?; + Ok(cap_bytes( + { + let mut blob = object + .try_into_blob() + .map_err(|_| Error::ObjectNotFound { spec: spec.to_owned() })?; + blob.take_data() + }, + max_bytes, + )) + } + + /// Resolve Git LFS's local object directory. + pub fn lfs_media_dir(&self) -> Result> { + let base = self.info().common_dir.clone(); + Ok(Some(match self.config_get("lfs.storage")? { + Some(value) => { + let path = PathBuf::from(value); + if path.is_absolute() { + path + } else { + base.join(path) + } + }, + None => base.join("lfs").join("objects"), + })) + } + + /// Return the filesystem target whose metadata changes when HEAD moves. + pub fn head_watch_target(&self) -> PathBuf { + if self.is_reftable() { + self.info().git_dir.join("reftable") + } else { + self.info().head_path.clone() + } + } + + fn read_ref(&self, name: &str) -> Result> { + if !valid_ref_path(name) { + return Ok(None); + } + if self.is_reftable() { + if let Some(target) = cli_try(self.root(), &["symbolic-ref", name])? { + return Ok(Some(format!("ref: {target}"))); + } + return cli_try(self.root(), &["rev-parse", "--verify", name]); + } + for dir in [&self.info().git_dir, &self.info().common_dir] { + if let Ok(value) = std::fs::read_to_string(dir.join(name)) + && let Some(value) = nonempty(value.trim()) + { + return Ok(Some(value)); + } + } + for dir in [&self.info().git_dir, &self.info().common_dir] { + let Ok(content) = std::fs::read_to_string(dir.join("packed-refs")) else { + continue; + }; + for line in content + .lines() + .map(str::trim) + .filter(|line| !line.is_empty() && !line.starts_with(['#', '^'])) + { + if let Some((sha, ref_name)) = line.split_once(' ') + && ref_name == name + { + return Ok(Some(sha.to_owned())); + } + } + } + Ok(None) + } + + fn peel_symbolic(&self, value: Option) -> Result> { + let mut value = value; + let mut seen = HashSet::new(); + while let Some(current) = value { + let Some(target) = current.strip_prefix("ref:").map(str::trim) else { + return Ok(Some(current)); + }; + if !seen.insert(target.to_owned()) { + return Ok(None); + } + value = self.read_ref(target)?; + } + Ok(None) + } + + fn walk_commit_ids(&self, rev: &str) -> Result> { + let repo = self.gix()?; + let id = repo + .rev_parse_single(rev) + .map_err(|err| Error::backend("git rev-list", err))? + .detach(); + repo + .rev_walk([id]) + .sorting(gix::revision::walk::Sorting::ByCommitTime( + gix::traverse::commit::simple::CommitTimeOrder::NewestFirst, + )) + .all() + .map_err(|err| Error::backend("git rev-list", err))? + .map(|item| { + item + .map(|info| info.id) + .map_err(|err| Error::backend("git rev-list", err)) + }) + .collect() + } +} + +fn nonempty(value: &str) -> Option { + (!value.is_empty()).then(|| value.to_owned()) +} +fn valid_ref_path(name: &str) -> bool { + !name.is_empty() + && !name.starts_with('/') + && !name.contains('\\') + && name + .split('/') + .all(|component| !matches!(component, "" | "." | "..")) +} +fn bytes_to_path(value: &gix::bstr::BStr) -> String { + value.to_str_lossy().into_owned() +} + +/// Whether any regular file (or symlink) exists beneath `dir`. git omits +/// untracked directories that hold nothing but empty directories. +fn dir_contains_file(dir: &Path) -> bool { + let Ok(entries) = std::fs::read_dir(dir) else { + return false; + }; + for entry in entries.flatten() { + match entry.file_type() { + Ok(kind) if kind.is_dir() => { + if dir_contains_file(&entry.path()) { + return true; + } + }, + Ok(_) => return true, + Err(_) => {}, + } + } + false +} +fn set_index( + states: &mut BTreeMap)>, + path: &gix::bstr::BStr, + code: char, + old: Option, +) { + states + .entry(bytes_to_path(path)) + .and_modify(|s| { + s.0 = code; + s.2.clone_from(&old); + }) + .or_insert((code, ' ', old)); +} +fn set_worktree( + states: &mut BTreeMap)>, + path: &gix::bstr::BStr, + code: char, +) { + states + .entry(bytes_to_path(path)) + .and_modify(|s| s.1 = code) + .or_insert((' ', code, None)); +} + +fn cli_try(cwd: &Path, args: &[&str]) -> Result> { + let owned: Vec<_> = args.iter().map(|v| (*v).to_owned()).collect(); + let out = super::cli::run_sync(cwd, &owned)?; + if out.exit_code != 0 { + return Ok(None); + } + Ok(nonempty(out.stdout.trim())) +} +fn cli_text(cwd: &Path, args: &[&str]) -> Result { + let owned: Vec<_> = args.iter().map(|v| (*v).to_owned()).collect(); + cli_text_owned(cwd, &owned) +} +fn cli_text_owned(cwd: &Path, args: &[String]) -> Result { + Ok(super::cli::run_sync(cwd, args)?.into_checked(args)?.stdout) +} +fn cli_lines(cwd: &Path, args: &[&str]) -> Result> { + Ok(cli_text(cwd, args)? + .lines() + .filter(|s| !s.is_empty()) + .map(str::to_owned) + .collect()) +} + +fn quote_path(path: &str) -> String { + if path + .bytes() + .all(|b| (0x20..0x7f).contains(&b) && b != b'"' && b != b'\\') + { + return path.to_owned(); + } + let mut out = String::from("\""); + for byte in path.bytes() { + match byte { + b'\\' => out.push_str("\\\\"), + b'"' => out.push_str("\\\""), + b'\n' => out.push_str("\\n"), + b'\r' => out.push_str("\\r"), + b'\t' => out.push_str("\\t"), + 0x20..=0x7e => out.push(char::from(byte)), + _ => { + use std::fmt::Write as _; + let _ = write!(out, "\\{byte:03o}"); + }, + } + } + out.push('"'); + out +} +fn version_sort_desc(values: &mut [String]) { + values.sort_by(|a, b| version_key(b).cmp(&version_key(a)).then_with(|| b.cmp(a))); +} +fn version_key(value: &str) -> Vec<(bool, String)> { + value + .split_inclusive(|c: char| c.is_ascii_digit()) + .map(|s| { + let digits = s.trim_matches(|c: char| !c.is_ascii_digit()); + ( + !digits.is_empty(), + if digits.is_empty() { + s.to_owned() + } else { + format!("{:020}", digits.parse::().unwrap_or(u64::MAX)) + }, + ) + }) + .collect() +} + +fn entry_from_head(path: PathBuf, head: &HeadState) -> WorktreeEntry { + WorktreeEntry { + path, + head: head.commit().map(str::to_owned), + branch: match head { + HeadState::Ref { ref_name, .. } => Some(ref_name.clone()), + HeadState::Detached { .. } => None, + }, + detached: matches!(head, HeadState::Detached { .. }), + } +} +fn parse_head_with_refs(head_path: &Path, common_dir: &Path) -> Result { + let content = std::fs::read_to_string(head_path)?; + let value = content.trim(); + if let Some(name) = value.strip_prefix("ref:").map(str::trim) { + let commit = std::fs::read_to_string(common_dir.join(name)) + .ok() + .and_then(|value| nonempty(value.trim())) + .or_else(|| { + std::fs::read_to_string(common_dir.join("packed-refs")) + .ok()? + .lines() + .filter_map(|line| line.split_once(' ')) + .find_map(|(sha, candidate)| (candidate == name).then(|| sha.to_owned())) + }); + Ok(HeadState::Ref { + ref_name: name.to_owned(), + branch: name.strip_prefix("refs/heads/").map(str::to_owned), + commit, + }) + } else { + Ok(HeadState::Detached { commit: nonempty(value) }) + } +} +fn parse_worktree_cli(raw: &str) -> Vec { + let mut out = Vec::new(); + for record in raw.split("\n\n") { + let mut path = None; + let mut head = None; + let mut branch = None; + let mut detached = false; + for line in record.lines() { + if let Some(v) = line.strip_prefix("worktree ") { + path = Some(PathBuf::from(v)); + } else if let Some(v) = line.strip_prefix("HEAD ") { + head = nonempty(v); + } else if let Some(v) = line.strip_prefix("branch ") { + branch = nonempty(v); + } else if line == "detached" { + detached = true; + } + } + if let Some(path) = path { + out.push(WorktreeEntry { path, head, branch, detached }); + } + } + out +} +fn commit_subject( + commit: &gix::Commit<'_>, +) -> std::result::Result { + Ok(commit + .message()? + .title + .to_str_lossy() + .trim_end_matches('\n') + .to_owned()) +} +fn tree_entry_id(tree: &gix::Tree<'_>, path: &str) -> Result> { + Ok(tree + .lookup_entry_by_path(path) + .map_err(|e| Error::backend("git rev-list", e))? + .map(|e| e.id().detach().to_string())) +} +fn parse_commit_details(raw: &str) -> CommitDetails { + let mut fields = raw.splitn(6, '\0'); + let sha = fields.next().unwrap_or_default().to_owned(); + let parents = fields + .next() + .unwrap_or_default() + .split_whitespace() + .map(str::to_owned) + .collect(); + let name = fields.next().unwrap_or_default().to_owned(); + let email = fields.next().unwrap_or_default().to_owned(); + let date = fields.next().and_then(nonempty); + let raw_message = fields.next().unwrap_or_default(); + let message = raw_message + .strip_suffix('\n') + .unwrap_or(raw_message) + .to_owned(); + CommitDetails { sha, parents, author: CommitAuthor { name, email, date }, message } +} +fn path_matches(path: &str, wanted: &str) -> bool { + let wanted = wanted.trim_end_matches('/'); + path == wanted + || path + .strip_prefix(wanted) + .is_some_and(|rest| rest.starts_with('/')) +} +fn parse_gitmodules(path: &Path) -> Vec { + let Ok(content) = std::fs::read_to_string(path) else { + return Vec::new(); + }; + content + .lines() + .filter_map(|line| { + let line = line.trim(); + let (key, value) = line.split_once('=')?; + (key.trim().eq_ignore_ascii_case("path")).then(|| value.trim().to_owned()) + }) + .collect() +} +fn cap_bytes(mut bytes: Vec, max: Option) -> ShowResult { + let truncated = max.is_some_and(|cap| bytes.len() > cap); + if let Some(cap) = max { + bytes.truncate(cap); + } + ShowResult { bytes, truncated } +} + +#[cfg(test)] +mod tests { + use std::{fs, process::Command}; + + use tempfile::TempDir; + + use super::*; + + type TestResult = std::result::Result<(), Box>; + + fn git(cwd: &Path, args: &[&str]) -> std::result::Result> { + let output = Command::new("git").current_dir(cwd).args(args).output()?; + if !output.status.success() { + return Err( + format!("git {} failed: {}", args.join(" "), String::from_utf8_lossy(&output.stderr)) + .into(), + ); + } + Ok(String::from_utf8(output.stdout)?) + } + + fn repo() -> std::result::Result<(TempDir, GitRepo), Box> { + let dir = tempfile::tempdir()?; + git(dir.path(), &["init", "-b", "main"])?; + git(dir.path(), &["config", "user.name", "Test User"])?; + git(dir.path(), &["config", "user.email", "test@example.com"])?; + let repo = GitRepo::require(dir.path())?; + Ok((dir, repo)) + } + + fn commit(cwd: &Path, name: &str, contents: &str, subject: &str) -> TestResult { + fs::write(cwd.join(name), contents)?; + git(cwd, &["add", name])?; + git(cwd, &["commit", "-m", subject])?; + Ok(()) + } + + #[test] + fn read_head_branch_detached_unborn_and_packed() -> TestResult { + let (dir, repo) = repo()?; + assert_eq!(repo.head()?, HeadState::Ref { + ref_name: "refs/heads/main".to_owned(), + branch: Some("main".to_owned()), + commit: None, + }); + commit(dir.path(), "one", "one\n", "one")?; + let sha = git(dir.path(), &["rev-parse", "HEAD"])?.trim().to_owned(); + assert_eq!(repo.head_sha()?, Some(sha.clone())); + git(dir.path(), &["pack-refs", "--all", "--prune"])?; + assert_eq!(repo.head_sha()?, Some(sha.clone())); + git(dir.path(), &["checkout", "--detach"])?; + assert_eq!(repo.head()?, HeadState::Detached { commit: Some(sha) }); + assert_eq!(repo.current_branch()?, None); + Ok(()) + } + + #[test] + fn merge_base_resolves_rejects_and_errors() -> TestResult { + let (dir, repo) = repo()?; + let root = dir.path(); + commit(root, "base", "base\n", "base")?; + let fork = git(root, &["rev-parse", "HEAD"])?.trim().to_owned(); + + git(root, &["checkout", "-b", "feature"])?; + commit(root, "feature", "feature\n", "feature")?; + git(root, &["checkout", "main"])?; + commit(root, "advance", "advance\n", "advance")?; + + // Divergent branches share the fork commit as their merge base. + assert_eq!(repo.merge_base("main", "feature")?, Some(fork)); + + // Orphan branch has no common ancestor: `None`, not an error. + git(root, &["checkout", "--orphan", "orphan"])?; + git(root, &["rm", "-rf", "."])?; + commit(root, "other", "other\n", "orphan")?; + assert_eq!(repo.merge_base("main", "orphan")?, None); + + // A missing ref is a fatal failure, never reported as "no merge base". + assert!(repo.merge_base("main", "does-not-exist").is_err()); + Ok(()) + } + + #[test] + fn read_status_matches_porcelain_oracle() -> TestResult { + let (dir, repo) = repo()?; + commit(dir.path(), "rename-me", "rename\n", "initial")?; + fs::write(dir.path().join("staged"), "staged\n")?; + git(dir.path(), &["add", "staged"])?; + fs::write(dir.path().join("staged"), "staged\nmodified\n")?; + git(dir.path(), &["mv", "rename-me", "renamed"])?; + fs::write(dir.path().join("untracked"), "new\n")?; + // Intent-to-add (`git add -N`) must surface as an unstaged addition + // (` A`); it was previously skipped and invisible to the git TUI. + fs::write(dir.path().join("promised"), "promised\n")?; + git(dir.path(), &["add", "-N", "promised"])?; + // An untracked DIRECTORY must collapse to one entry (git porcelain + // default) — the status line summary counted 25 instead of 5 on a + // real repo when this used per-file emission. + fs::create_dir(dir.path().join("newdir"))?; + fs::write(dir.path().join("newdir").join("a"), "a\n")?; + fs::write(dir.path().join("newdir").join("b"), "b\n")?; + // Directories containing no files anywhere beneath them are invisible + // to `git status`, even when nested (regression: phantom `?? undefined/` + // entries for empty scaffold dirs). + fs::create_dir_all(dir.path().join("empty").join("nested"))?; + let expected = git(dir.path(), &["status", "--porcelain", "--untracked-files=normal"])?; + let actual = repo.status_porcelain(&StatusOptions::default())?; + assert_eq!(actual.as_bytes(), expected.as_bytes()); + assert_eq!(repo.status_summary()?, StatusSummary { + staged: 2, + unstaged: 2, + untracked: 2, + }); + Ok(()) + } + + #[test] + fn read_range_is_oldest_first_and_config_is_trimmed() -> TestResult { + let (dir, repo) = repo()?; + commit(dir.path(), "one", "one\n", "one")?; + let base = git(dir.path(), &["rev-parse", "HEAD"])?.trim().to_owned(); + commit(dir.path(), "two", "two\n", "two")?; + let second = git(dir.path(), &["rev-parse", "HEAD"])?.trim().to_owned(); + commit(dir.path(), "three", "three\n", "three")?; + let third = git(dir.path(), &["rev-parse", "HEAD"])?.trim().to_owned(); + assert_eq!(repo.rev_list_range(&base, "HEAD")?, vec![second, third]); + git(dir.path(), &["config", "custom.value", " configured "])?; + assert_eq!(repo.config_get("custom.value")?, Some("configured".to_owned())); + assert_eq!(repo.config_get("custom.missing")?, None); + Ok(()) + } + + #[test] + fn read_objects_logs_and_refs() -> TestResult { + let (dir, repo) = repo()?; + commit(dir.path(), "one", "one\n", "first subject")?; + let first = repo.head_sha()?.ok_or("missing HEAD")?; + commit(dir.path(), "two", "two\n", "second subject")?; + let second = repo.head_sha()?.ok_or("missing HEAD")?; + git(dir.path(), &["tag", "-a", "v1.2.0", "-m", "release", "HEAD"])?; + + assert_eq!(repo.resolve_ref("main")?, Some(second.clone())); + assert!(repo.ref_exists("refs/heads/main")?); + assert_eq!(repo.tags_at("HEAD")?, vec!["v1.2.0"]); + assert_eq!(repo.list_branches(false)?, vec!["main"]); + assert_eq!(repo.log_subjects(2)?, vec!["second subject", "first subject"]); + let expected_onelines: Vec<_> = + git(dir.path(), &["log", "-2", "--oneline", "--no-decorate"])? + .lines() + .map(str::to_owned) + .collect(); + assert_eq!(repo.log_onelines(2)?, expected_onelines); + assert_eq!(repo.rev_list_touching("HEAD", "two", 10)?, vec![second.clone()]); + assert_eq!(repo.ls_tree("HEAD", &[])?, vec!["one", "two"]); + let shown = repo.show_blob("HEAD:two", Some(3))?; + assert_eq!(shown.bytes, b"two"); + assert!(shown.truncated); + let details = repo.commit_details("HEAD")?; + assert_eq!(details.sha, second); + assert_eq!(details.parents, vec![first]); + assert_eq!(details.author.name, "Test User"); + assert_eq!(details.message, "second subject"); + + git(dir.path(), &["remote", "add", "origin", "https://example.test/repo"])?; + assert_eq!(repo.remote_list()?, vec!["origin"]); + assert_eq!(repo.remote_url("origin")?.as_deref(), Some("https://example.test/repo")); + assert_eq!(repo.lfs_media_dir()?, Some(repo.info().common_dir.join("lfs").join("objects"))); + assert_eq!(repo.head_watch_target(), repo.info().head_path); + Ok(()) + } + + #[test] + fn read_ls_files_honors_standard_excludes() -> TestResult { + let (dir, repo) = repo()?; + commit(dir.path(), "tracked", "tracked\n", "initial")?; + fs::write(dir.path().join(".gitignore"), "ignored\n")?; + fs::write(dir.path().join("ignored"), "ignored\n")?; + fs::write(dir.path().join("visible"), "visible\n")?; + let all = repo.ls_files(true, false)?; + let expected_all: Vec<_> = git(dir.path(), &["ls-files", "--others"])? + .lines() + .map(str::to_owned) + .collect(); + assert_eq!(all, expected_all); + let filtered = repo.ls_files(true, true)?; + let expected_filtered: Vec<_> = + git(dir.path(), &["ls-files", "--others", "--exclude-standard"])? + .lines() + .map(str::to_owned) + .collect(); + assert_eq!(filtered, expected_filtered); + Ok(()) + } + + #[test] + fn read_worktrees_and_remote_default_branch() -> TestResult { + let (dir, repo) = repo()?; + commit(dir.path(), "tracked", "tracked\n", "initial")?; + git(dir.path(), &["update-ref", "refs/remotes/origin/main", "HEAD"])?; + git(dir.path(), &["symbolic-ref", "refs/remotes/origin/HEAD", "refs/remotes/origin/main"])?; + assert_eq!(repo.default_branch()?, Some("main".to_owned())); + + let linked = dir.path().join("linked"); + let linked_text = linked.to_string_lossy().into_owned(); + git(dir.path(), &["worktree", "add", "-b", "linked-branch", &linked_text])?; + let worktrees = repo.worktrees()?; + assert_eq!(worktrees.len(), 2); + assert_eq!(worktrees[0].path, dir.path()); + assert_eq!(worktrees[1].path, linked.canonicalize()?); + assert_eq!(worktrees[1].branch.as_deref(), Some("refs/heads/linked-branch")); + Ok(()) + } +} diff --git a/crates/pi-vcs/src/jj/mod.rs b/crates/pi-vcs/src/jj/mod.rs new file mode 100644 index 000000000000..1edc166604f8 --- /dev/null +++ b/crates/pi-vcs/src/jj/mod.rs @@ -0,0 +1,96 @@ +//! Jujutsu backend: jj-lib-powered workspace operations. No subprocess at all. +//! +//! Workspace discovery is a pure filesystem walk (`.jj/repo` presence, +//! including the file indirection non-default workspaces use), cheap enough +//! for synchronous render paths. jj-lib loading happens lazily inside +//! operations. + +mod ops; + +use std::path::{Path, PathBuf}; + +use crate::error::{Error, Result}; + +/// An opened Jujutsu workspace. +#[derive(Debug)] +pub struct JjWorkspace { + root: PathBuf, + repo_dir: PathBuf, +} + +impl JjWorkspace { + /// Discover the workspace containing `dir` by walking toward the root. + /// Returns `Ok(None)` when `dir` is not inside a Jujutsu workspace. + pub fn discover(dir: &Path) -> Result> { + let start = std::path::absolute(dir)?; + let mut current = start.as_path(); + loop { + if let Some(repo_dir) = resolve_repo_dir(current) { + return Ok(Some(Self { root: current.to_owned(), repo_dir })); + } + match current.parent() { + Some(parent) => current = parent, + None => return Ok(None), + } + } + } + + /// Like [`JjWorkspace::discover`], but errors with [`Error::NotARepository`] + /// when `dir` is outside any workspace. + pub fn require(dir: &Path) -> Result { + Self::discover(dir)?.ok_or_else(|| Error::NotARepository { path: dir.to_owned() }) + } + + /// Workspace root: the directory containing `.jj`. + pub fn root(&self) -> &Path { + &self.root + } + + /// Default workspace root shared by every workspace in this repository. + pub fn primary_root(&self) -> PathBuf { + self + .repo_dir + .parent() + .and_then(Path::parent) + .map_or_else(|| self.root.clone(), Path::to_owned) + } + + /// Shared repo directory backing this workspace, resolved through the + /// `.jj/repo` file indirection used by non-default workspaces. + pub fn repo_dir(&self) -> &Path { + &self.repo_dir + } + + /// Path of the shared workspace store directory. + pub fn store_dir(&self) -> PathBuf { + self.repo_dir.join("store") + } + + /// Directory whose entries change whenever the repository operation head + /// moves. + pub fn watch_target(&self) -> PathBuf { + self.repo_dir.join("op_heads").join("heads") + } +} + +/// Resolve the `.jj/repo` directory for `root`, or `None` when `root` is not +/// a workspace. jj marks a workspace via `.jj/repo`: a directory in the +/// default workspace, or a FILE (created by `jj workspace add`) whose contents +/// are a path — relative to `.jj` — to the default workspace's repo dir. +fn resolve_repo_dir(root: &Path) -> Option { + let jj_dir = root.join(".jj"); + let repo_path = jj_dir.join("repo"); + let meta = std::fs::metadata(&repo_path).ok()?; + if meta.is_dir() { + return Some(repo_path); + } + if !meta.is_file() { + return None; + } + let target = std::fs::read_to_string(&repo_path).ok()?; + let target = target.trim(); + if target.is_empty() { + return None; + } + Some(crate::git::normalize_path(&jj_dir.join(target))) +} diff --git a/crates/pi-vcs/src/jj/ops.rs b/crates/pi-vcs/src/jj/ops.rs new file mode 100644 index 000000000000..290105a05276 --- /dev/null +++ b/crates/pi-vcs/src/jj/ops.rs @@ -0,0 +1,1221 @@ +//! jj-lib-backed operations on [`JjWorkspace`](super::JjWorkspace): +//! working-copy label, status summary, and git-format diffs. + +use std::{ + collections::{BTreeMap, BTreeSet, BinaryHeap}, + future::Future, + path::PathBuf, + pin::Pin, + sync::Arc, +}; + +use jj_lib::{ + backend::{CommitId, CopyId, TreeValue}, + commit::Commit, + config::{ConfigSource, StackedConfig}, + conflicts::{ConflictMarkerStyle, ConflictMaterializeOptions, materialize_tree_value}, + default_backend_factories::{default_backend_factories, default_working_copy_factories}, + diff_presentation::{ + LineCompareMode, + unified::{DiffLineType, GitDiffPart, git_diff_part, unified_diff_hunks}, + }, + gitignore::GitIgnoreFile, + matchers::{EverythingMatcher, NothingMatcher}, + merge::{Diff, MergedTreeValue}, + merged_tree::MergedTree, + object_id::{HexPrefix, ObjectId as _, PrefixResolution}, + repo::{ReadonlyRepo, Repo}, + repo_path::{RepoPath, RepoPathBuf}, + settings::UserSettings, + working_copy::{SnapshotOptions, WorkingCopyFreshness}, + workspace::Workspace, +}; + +use super::JjWorkspace; +use crate::{ + error::{Error, Result}, + types::{CommitAuthor, CommitDetails, NumstatEntry, StatusOptions, StatusSummary}, +}; + +const DIFF_CONTEXT: usize = 3; + +#[derive(Debug)] +struct TreeChange { + before_path: RepoPathBuf, + after_path: RepoPathBuf, + before: MergedTreeValue, + after: MergedTreeValue, + copy_operation: Option<&'static str>, +} + +impl JjWorkspace { + /// Return the nearest local bookmark, or the shortest unique working-copy + /// change ID. + pub fn working_copy_label(&self) -> Result> { + self.with_current_repo("jj log", |workspace, repo| { + Box::pin(async move { + let Some(wc_id) = repo + .view() + .get_wc_commit_id(workspace.workspace_name()) + .cloned() + else { + return Ok(None); + }; + let wc_commit = repo + .store() + .get_commit_async(&wc_id) + .await + .map_err(|err| Error::backend("jj log", err))?; + + let wc_bookmarks = local_bookmarks_for_commit(repo.as_ref(), &wc_id); + if !wc_bookmarks.is_empty() { + return Ok(Some(wc_bookmarks.join(" "))); + } + + let mut candidates = BTreeSet::new(); + for (_, target) in repo.view().local_bookmarks() { + for id in target.added_ids() { + if repo + .index() + .is_ancestor(id, &wc_id) + .await + .map_err(|err| Error::backend("jj log", err))? + { + candidates.insert(id.clone()); + } + } + } + let mut candidate_iter = candidates.iter(); + let heads = repo + .index() + .heads(&mut candidate_iter) + .await + .map_err(|err| Error::backend("jj log", err))?; + let bookmark_group = heads + .iter() + .map(|id| local_bookmarks_for_commit(repo.as_ref(), id).join(" ")) + .find(|names| !names.is_empty()); + if let Some(names) = bookmark_group { + return Ok(Some(names)); + } + + let prefix_len = repo + .shortest_unique_change_id_prefix_len(wc_commit.change_id()) + .map_err(|err| Error::backend("jj log", err))? + .max(8); + let change_id = wc_commit.change_id().reverse_hex(); + Ok(Some(change_id[..prefix_len.min(change_id.len())].to_owned())) + }) + }) + } + + /// Return the working-copy commit id, or `None` when the workspace has no + /// working-copy commit. + pub fn head_id(&self) -> Result> { + self.with_current_repo("jj log", |workspace, repo| { + Box::pin(async move { + Ok(repo + .view() + .get_wc_commit_id(workspace.workspace_name()) + .map(|id| id.hex())) + }) + }) + } + + /// Count the recorded changes in `@` relative to its merged parent tree. + pub fn status_summary(&self) -> Result { + self.with_current_repo("jj status", |workspace, repo| { + Box::pin(async move { + let Some((before, after)) = + working_copy_trees(workspace, repo.as_ref(), "jj status").await? + else { + return Ok(StatusSummary::default()); + }; + let changes = collect_changes(&before, &after, &[], "jj status")?; + let mut summary = StatusSummary::default(); + for change in changes { + if change.before.is_absent() { + summary.untracked = summary.untracked.saturating_add(1); + } else { + summary.unstaged = summary.unstaged.saturating_add(1); + } + } + Ok(summary) + }) + }) + } + + /// Render `@` versus its merged parents in git porcelain-v1 form. + pub fn status_porcelain(&self, options: &StatusOptions) -> Result { + let pathspecs = options.pathspecs.clone(); + let nul_terminated = options.nul_terminated; + self.with_current_repo("jj status", move |workspace, repo| { + Box::pin(async move { + let Some((before, after)) = + working_copy_trees(workspace, repo.as_ref(), "jj status").await? + else { + return Ok(String::new()); + }; + let changes = collect_changes(&before, &after, &pathspecs, "jj status")?; + Ok(render_status_porcelain(&changes, nul_terminated)) + }) + }) + } + + /// Render `@` versus its merged parents as a git-format patch. + pub fn diff_text(&self, files: &[String], snapshot: bool) -> Result { + let files = files.to_vec(); + self.with_repo(snapshot, "jj diff", move |workspace, repo| { + Box::pin(async move { + let Some((before, after)) = + working_copy_trees(workspace, repo.as_ref(), "jj diff").await? + else { + return Ok(String::new()); + }; + let changes = collect_changes(&before, &after, &files, "jj diff")?; + render_git_diff(repo.as_ref(), &before, &after, changes).await + }) + }) + } + + /// List target paths changed in `@` relative to its merged parents. + pub fn changed_files(&self, files: &[String], snapshot: bool) -> Result> { + let files = files.to_vec(); + self.with_repo(snapshot, "jj diff", move |workspace, repo| { + Box::pin(async move { + let Some((before, after)) = + working_copy_trees(workspace, repo.as_ref(), "jj diff").await? + else { + return Ok(Vec::new()); + }; + Ok(collect_changes(&before, &after, &files, "jj diff")? + .into_iter() + .map(|change| change.after_path.as_internal_file_string().to_owned()) + .collect()) + }) + }) + } + + /// Return per-file line counts for `@` relative to its merged parents. + pub fn numstat(&self, files: &[String]) -> Result> { + let files = files.to_vec(); + self.with_repo(true, "jj diff", move |workspace, repo| { + Box::pin(async move { + let Some((before, after)) = + working_copy_trees(workspace, repo.as_ref(), "jj diff").await? + else { + return Ok(Vec::new()); + }; + let changes = collect_changes(&before, &after, &files, "jj diff")?; + render_numstat(repo.as_ref(), &before, &after, changes).await + }) + }) + } + + /// Return recent commit subjects, newest first. + pub fn log_subjects(&self, count: usize) -> Result> { + self.with_current_repo("jj log", |workspace, repo| { + Box::pin(async move { + Ok(walk_commits(workspace, repo.as_ref(), count, "jj log") + .await? + .into_iter() + .map(|commit| commit_subject(&commit)) + .collect()) + }) + }) + } + + /// Return recent commits as ` ` lines. + pub fn log_onelines(&self, count: usize) -> Result> { + self.with_current_repo("jj log", |workspace, repo| { + Box::pin(async move { + let commits = walk_commits(workspace, repo.as_ref(), count, "jj log").await?; + let mut lines = Vec::with_capacity(commits.len()); + for commit in commits { + let prefix_len = repo + .shortest_unique_change_id_prefix_len(commit.change_id()) + .map_err(|err| Error::backend("jj log", err))? + .max(8); + let change_id = commit.change_id().reverse_hex(); + let prefix = &change_id[..prefix_len.min(change_id.len())]; + lines.push(format!("{prefix} {}", commit_subject(&commit))); + } + Ok(lines) + }) + }) + } + + /// Read commit identity, parents, author, date, and full message. + pub fn commit_details(&self, rev: &str) -> Result { + let rev = rev.to_owned(); + self.with_current_repo("jj show", move |workspace, repo| { + Box::pin(async move { + let commit_id = resolve_commit_id(workspace, repo.as_ref(), &rev)? + .ok_or_else(|| Error::ObjectNotFound { spec: rev.clone() })?; + let commit = repo + .store() + .get_commit_async(&commit_id) + .await + .map_err(|err| Error::backend("jj show", err))?; + let root_id = repo.store().root_commit_id(); + let author = commit.author(); + let date = author + .timestamp + .to_datetime() + .map_err(|err| Error::backend("jj show", err))? + .to_rfc3339(); + let raw_message = commit.description(); + let message = raw_message + .strip_suffix('\n') + .unwrap_or(raw_message) + .to_owned(); + Ok(CommitDetails { + sha: commit.id().hex(), + parents: commit + .parent_ids() + .iter() + .filter(|id| *id != root_id) + .map(|id| id.hex()) + .collect(), + author: CommitAuthor { + name: author.name.clone(), + email: author.email.clone(), + date: Some(date), + }, + message, + }) + }) + }) + } + + /// List paths tracked in `@`. + /// + /// When `others` is true, the result is empty because jj snapshots every + /// non-ignored path into `@`, so it has no distinct untracked set. + pub fn ls_files(&self, others: bool) -> Result> { + if others { + return Ok(Vec::new()); + } + self.with_current_repo("jj files", |workspace, repo| { + Box::pin(async move { + let Some(wc_id) = repo.view().get_wc_commit_id(workspace.workspace_name()) else { + return Ok(Vec::new()); + }; + let commit = repo + .store() + .get_commit_async(wc_id) + .await + .map_err(|err| Error::backend("jj files", err))?; + Ok(tree_entries(&commit.tree(), "jj files")? + .into_keys() + .map(|path| path.as_internal_file_string().to_owned()) + .collect()) + }) + }) + } + + fn with_current_repo(&self, context: &'static str, operation: F) -> Result + where + F: for<'a> FnOnce( + &'a Workspace, + Arc, + ) -> Pin> + 'a>>, + { + self.with_repo(false, context, operation) + } + + fn with_repo(&self, snapshot: bool, context: &'static str, operation: F) -> Result + where + F: for<'a> FnOnce( + &'a Workspace, + Arc, + ) -> Pin> + 'a>>, + { + let settings = user_settings().map_err(|err| Error::backend(context, err))?; + let store_factories = default_backend_factories(); + let working_copy_factories = default_working_copy_factories(); + let mut workspace = + Workspace::load(&settings, &self.root, &store_factories, &working_copy_factories) + .map_err(|err| Error::backend(context, err))?; + let runtime = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + .map_err(|err| Error::backend(context, err))?; + runtime.block_on(async move { + let mut repo = workspace + .repo_loader() + .load_at_head() + .await + .map_err(|err| Error::backend(context, err))?; + if snapshot { + repo = snapshot_working_copy(&mut workspace, repo).await?; + } + operation(&workspace, repo).await + }) + } +} +#[allow( + clippy::future_not_send, + reason = "driven on a per-call current-thread runtime; `&dyn Repo` is !Send" +)] +async fn walk_commits( + workspace: &Workspace, + repo: &dyn Repo, + count: usize, + context: &'static str, +) -> Result> { + if count == 0 { + return Ok(Vec::new()); + } + let Some(wc_id) = repo + .view() + .get_wc_commit_id(workspace.workspace_name()) + .cloned() + else { + return Ok(Vec::new()); + }; + let root_id = repo.store().root_commit_id(); + if &wc_id == root_id { + return Ok(Vec::new()); + } + let wc_commit = repo + .store() + .get_commit_async(&wc_id) + .await + .map_err(|err| Error::backend(context, err))?; + let mut queued = BTreeSet::from([wc_id]); + let mut heap = BinaryHeap::from([(wc_commit.committer().timestamp, wc_commit)]); + let mut commits = Vec::with_capacity(count); + while let Some((_, commit)) = heap.pop() { + for parent in commit + .parents() + .await + .map_err(|err| Error::backend(context, err))? + { + if parent.id() != root_id && queued.insert(parent.id().clone()) { + heap.push((parent.committer().timestamp, parent)); + } + } + commits.push(commit); + if commits.len() == count { + break; + } + } + Ok(commits) +} + +fn commit_subject(commit: &Commit) -> String { + commit + .description() + .lines() + .next() + .unwrap_or_default() + .to_owned() +} + +fn resolve_commit_id( + workspace: &Workspace, + repo: &dyn Repo, + rev: &str, +) -> Result> { + if rev == "@" { + return Ok(repo + .view() + .get_wc_commit_id(workspace.workspace_name()) + .cloned()); + } + if let Some(prefix) = HexPrefix::try_from_reverse_hex(rev) { + let resolution = repo + .resolve_change_id_prefix(&prefix) + .map_err(|err| Error::backend("jj show", err))?; + if let PrefixResolution::SingleMatch(targets) = resolution { + let mut visible = targets.visible_with_offsets().map(|(_, id)| id.clone()); + let first = visible.next(); + if first.is_some() && visible.next().is_none() { + return Ok(first); + } + } + } + if let Some(prefix) = HexPrefix::try_from_hex(rev) { + let resolution = repo + .index() + .resolve_commit_id_prefix(&prefix) + .map_err(|err| Error::backend("jj show", err))?; + if let PrefixResolution::SingleMatch(id) = resolution { + return Ok(Some(id)); + } + } + Ok(None) +} + +fn user_settings() -> std::result::Result { + let mut config = StackedConfig::with_defaults(); + for path in user_config_paths() { + if path.is_dir() { + let _ = config.load_dir(ConfigSource::User, &path); + } else if path.is_file() { + let _ = config.load_file(ConfigSource::User, &path); + } + } + UserSettings::from_config(config) +} + +fn user_config_paths() -> Vec { + if let Some(path) = std::env::var_os("JJ_CONFIG") { + return vec![PathBuf::from(path)]; + } + let mut paths = Vec::new(); + if let Some(config_home) = std::env::var_os("XDG_CONFIG_HOME") + .map(PathBuf::from) + .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".config"))) + { + paths.push(config_home.join("jj").join("config.toml")); + paths.push(config_home.join("jj").join("conf.d")); + } + if let Some(home) = std::env::var_os("HOME") { + paths.push(PathBuf::from(home).join(".jjconfig.toml")); + } + paths +} + +#[allow( + clippy::future_not_send, + reason = "driven on a per-call current-thread runtime; jj-lib's LockedWorkingCopy is !Sync" +)] +async fn snapshot_working_copy( + workspace: &mut Workspace, + repo: Arc, +) -> Result> { + let workspace_name = workspace.workspace_name().to_owned(); + let Some(initial_wc_id) = repo.view().get_wc_commit_id(&workspace_name).cloned() else { + return Ok(repo); + }; + let initial_wc_commit = repo + .store() + .get_commit_async(&initial_wc_id) + .await + .map_err(|err| Error::backend("jj snapshot", err))?; + let mut locked_workspace = workspace + .start_working_copy_mutation() + .await + .map_err(|err| Error::backend("jj snapshot", err))?; + let (repo, wc_commit) = match WorkingCopyFreshness::check_stale( + locked_workspace.locked_wc(), + &initial_wc_commit, + &repo, + ) + .await + .map_err(|err| Error::backend("jj snapshot", err))? + { + WorkingCopyFreshness::Fresh => (repo, initial_wc_commit), + WorkingCopyFreshness::Updated(operation) => { + let repo = repo + .loader() + .load_at(&operation) + .await + .map_err(|err| Error::backend("jj snapshot", err))?; + let Some(wc_id) = repo.view().get_wc_commit_id(&workspace_name) else { + return Ok(repo); + }; + let wc_commit = repo + .store() + .get_commit_async(wc_id) + .await + .map_err(|err| Error::backend("jj snapshot", err))?; + (repo, wc_commit) + }, + WorkingCopyFreshness::WorkingCopyStale => { + return Err(Error::backend( + "jj snapshot", + "working copy is stale; run `jj workspace update-stale`", + )); + }, + WorkingCopyFreshness::SiblingOperation => { + return Err(Error::backend( + "jj snapshot", + "working copy operation is a sibling of the current repository operation", + )); + }, + }; + let everything = EverythingMatcher; + let nothing = NothingMatcher; + let options = SnapshotOptions { + base_ignores: GitIgnoreFile::empty(), + progress: None, + start_tracking_matcher: &everything, + force_tracking_matcher: ¬hing, + max_new_file_size: 1024 * 1024, + }; + let (new_tree, _) = locked_workspace + .locked_wc() + .snapshot(&options) + .await + .map_err(|err| Error::backend("jj snapshot", err))?; + let repo = if new_tree.tree_ids_and_labels() == wc_commit.tree().tree_ids_and_labels() { + repo + } else { + let mut transaction = repo.start_transaction(); + transaction.set_workspace_name(&workspace_name); + transaction.set_is_snapshot(true); + let new_commit = transaction + .repo_mut() + .rewrite_commit(&wc_commit) + .set_tree(new_tree) + .write() + .await + .map_err(|err| Error::backend("jj snapshot", err))?; + transaction + .repo_mut() + .set_wc_commit(workspace_name, new_commit.id().clone()) + .map_err(|err| Error::backend("jj snapshot", err))?; + transaction + .repo_mut() + .rebase_descendants() + .await + .map_err(|err| Error::backend("jj snapshot", err))?; + transaction + .commit("snapshot working copy") + .await + .map_err(|err| Error::backend("jj snapshot", err))? + }; + locked_workspace + .finish(repo.op_id().clone()) + .await + .map_err(|err| Error::backend("jj snapshot", err))?; + Ok(repo) +} + +#[allow( + clippy::future_not_send, + reason = "driven on a per-call current-thread runtime; `&dyn Repo` is !Send" +)] +async fn working_copy_trees( + workspace: &Workspace, + repo: &dyn Repo, + context: &'static str, +) -> Result> { + let Some(wc_id) = repo.view().get_wc_commit_id(workspace.workspace_name()) else { + return Ok(None); + }; + let commit = repo + .store() + .get_commit_async(wc_id) + .await + .map_err(|err| Error::backend(context, err))?; + let parent_tree = commit + .parent_tree(repo) + .await + .map_err(|err| Error::backend(context, err))?; + Ok(Some((parent_tree, commit.tree()))) +} + +fn tree_entries( + tree: &MergedTree, + context: &'static str, +) -> Result> { + tree + .entries() + .map(|(path, value)| { + value + .map(|value| (path, value)) + .map_err(|err| Error::backend(context, err)) + }) + .collect() +} + +fn collect_changes( + before_tree: &MergedTree, + after_tree: &MergedTree, + files: &[String], + context: &'static str, +) -> Result> { + let before = tree_entries(before_tree, context)?; + let after = tree_entries(after_tree, context)?; + let mut changes = Vec::new(); + let mut removed: BTreeSet = before + .keys() + .filter(|path| !after.contains_key(*path)) + .cloned() + .collect(); + + for (path, after_value) in &after { + if let Some(before_value) = before.get(path) { + if before_value != after_value && path_selected(path, path, files) { + changes.push(TreeChange { + before_path: path.clone(), + after_path: path.clone(), + before: before_value.clone(), + after: after_value.clone(), + copy_operation: None, + }); + } + continue; + } + + let source = non_placeholder_copy_id(after_value).and_then(|copy_id| { + before.iter().find_map(|(source_path, source_value)| { + (non_placeholder_copy_id(source_value) == Some(copy_id)).then_some(source_path) + }) + }); + if let Some(source_path) = source { + let operation = if removed.remove(source_path) { + "rename" + } else { + "copy" + }; + if path_selected(source_path, path, files) { + changes.push(TreeChange { + before_path: source_path.clone(), + after_path: path.clone(), + before: before[source_path].clone(), + after: after_value.clone(), + copy_operation: Some(operation), + }); + } + } else if path_selected(path, path, files) { + changes.push(TreeChange { + before_path: path.clone(), + after_path: path.clone(), + before: MergedTreeValue::absent(), + after: after_value.clone(), + copy_operation: None, + }); + } + } + + for path in removed { + if path_selected(&path, &path, files) { + changes.push(TreeChange { + before_path: path.clone(), + after_path: path.clone(), + before: before[&path].clone(), + after: MergedTreeValue::absent(), + copy_operation: None, + }); + } + } + changes.sort_by(|left, right| left.after_path.cmp(&right.after_path)); + Ok(changes) +} +fn render_status_porcelain(changes: &[TreeChange], nul_terminated: bool) -> String { + let mut output = String::new(); + for change in changes { + output.push_str(status_code(change)); + output.push(' '); + let before_path = change.before_path.as_internal_file_string(); + let after_path = change.after_path.as_internal_file_string(); + if nul_terminated { + output.push_str(after_path); + output.push('\0'); + if change.copy_operation.is_some() { + output.push_str(before_path); + output.push('\0'); + } + } else { + if change.copy_operation.is_some() { + output.push_str(before_path); + output.push_str(" -> "); + } + output.push_str(after_path); + output.push('\n'); + } + } + output +} + +fn status_code(change: &TreeChange) -> &'static str { + if change.after.as_resolved().is_none() { + return "UU"; + } + match change.copy_operation { + Some("rename") => "R ", + Some("copy") => "C ", + _ if change.before.is_absent() => "A ", + _ if change.after.is_absent() => "D ", + _ => "M ", + } +} + +fn non_placeholder_copy_id(value: &MergedTreeValue) -> Option<&CopyId> { + match value.as_resolved()? { + Some(TreeValue::File { copy_id, .. }) if !copy_id.as_bytes().is_empty() => Some(copy_id), + _ => None, + } +} + +fn path_selected(before: &RepoPath, after: &RepoPath, files: &[String]) -> bool { + files.is_empty() + || files.iter().any(|file| { + let file = file.trim_matches('/'); + matches_path(before.as_internal_file_string(), file) + || matches_path(after.as_internal_file_string(), file) + }) +} + +fn matches_path(path: &str, prefix: &str) -> bool { + prefix.is_empty() + || path == prefix + || path + .strip_prefix(prefix) + .is_some_and(|tail| tail.starts_with('/')) +} +#[allow( + clippy::future_not_send, + reason = "driven on a per-call current-thread runtime; `&dyn Repo` is !Send" +)] +async fn render_numstat( + repo: &dyn Repo, + before_tree: &MergedTree, + after_tree: &MergedTree, + changes: Vec, +) -> Result> { + let options = conflict_materialize_options(repo); + let mut entries = Vec::with_capacity(changes.len()); + for change in changes { + let (before_part, after_part) = + materialize_diff_parts(repo, before_tree, after_tree, &change, &options).await?; + let (added, removed) = if before_part.content.is_binary || after_part.content.is_binary { + (None, None) + } else { + let mut added = 0u32; + let mut removed = 0u32; + for hunk in unified_diff_hunks( + Diff::new(before_part.content.contents.as_ref(), after_part.content.contents.as_ref()), + 0, + LineCompareMode::Exact, + ) { + for (line_type, _) in hunk.lines { + match line_type { + DiffLineType::Context => {}, + DiffLineType::Removed => removed = removed.saturating_add(1), + DiffLineType::Added => added = added.saturating_add(1), + } + } + } + (Some(added), Some(removed)) + }; + entries.push(NumstatEntry { + path: change.after_path.as_internal_file_string().to_owned(), + added, + removed, + }); + } + Ok(entries) +} + +fn conflict_materialize_options(repo: &dyn Repo) -> ConflictMaterializeOptions { + ConflictMaterializeOptions { + marker_style: ConflictMarkerStyle::Diff, + marker_len: None, + merge: repo.store().merge_options().clone(), + } +} + +#[allow( + clippy::future_not_send, + reason = "driven on a per-call current-thread runtime; `&dyn Repo` is !Send" +)] +async fn materialize_diff_parts( + repo: &dyn Repo, + before_tree: &MergedTree, + after_tree: &MergedTree, + change: &TreeChange, + options: &ConflictMaterializeOptions, +) -> Result<(GitDiffPart, GitDiffPart)> { + let before_value = materialize_tree_value( + repo.store(), + &change.before_path, + change.before.clone(), + before_tree.labels(), + ) + .await + .map_err(|err| Error::backend("jj diff", err))?; + let after_value = materialize_tree_value( + repo.store(), + &change.after_path, + change.after.clone(), + after_tree.labels(), + ) + .await + .map_err(|err| Error::backend("jj diff", err))?; + let before_part = git_diff_part(&change.before_path, before_value, options) + .await + .map_err(|err| Error::backend("jj diff", err))?; + let after_part = git_diff_part(&change.after_path, after_value, options) + .await + .map_err(|err| Error::backend("jj diff", err))?; + Ok((before_part, after_part)) +} + +#[allow( + clippy::future_not_send, + reason = "driven on a per-call current-thread runtime; `&dyn Repo` is !Send" +)] +async fn render_git_diff( + repo: &dyn Repo, + before_tree: &MergedTree, + after_tree: &MergedTree, + changes: Vec, +) -> Result { + let materialize_options = conflict_materialize_options(repo); + let mut output = Vec::new(); + for change in changes { + let (before_part, after_part) = + materialize_diff_parts(repo, before_tree, after_tree, &change, &materialize_options) + .await?; + let before_path = change.before_path.as_internal_file_string(); + let after_path = change.after_path.as_internal_file_string(); + output.extend_from_slice(format!("diff --git a/{before_path} b/{after_path}\n").as_bytes()); + match (before_part.mode, after_part.mode) { + (None, Some(after_mode)) => { + output.extend_from_slice(format!("new file mode {after_mode}\n").as_bytes()); + output.extend_from_slice( + format!("index {}..{}\n", before_part.hash, after_part.hash).as_bytes(), + ); + }, + (Some(before_mode), None) => { + output.extend_from_slice(format!("deleted file mode {before_mode}\n").as_bytes()); + output.extend_from_slice( + format!("index {}..{}\n", before_part.hash, after_part.hash).as_bytes(), + ); + }, + (Some(before_mode), Some(after_mode)) => { + if let Some(operation) = change.copy_operation { + output.extend_from_slice(format!("{operation} from {before_path}\n").as_bytes()); + output.extend_from_slice(format!("{operation} to {after_path}\n").as_bytes()); + } + if before_mode != after_mode { + output.extend_from_slice(format!("old mode {before_mode}\n").as_bytes()); + output.extend_from_slice(format!("new mode {after_mode}\n").as_bytes()); + if before_part.hash != after_part.hash { + output.extend_from_slice( + format!("index {}..{}\n", before_part.hash, after_part.hash).as_bytes(), + ); + } + } else if before_part.hash != after_part.hash { + output.extend_from_slice( + format!("index {}..{} {before_mode}\n", before_part.hash, after_part.hash) + .as_bytes(), + ); + } + }, + (None, None) => continue, + } + if before_part.content.contents == after_part.content.contents { + continue; + } + let before_header = if before_part.mode.is_some() { + format!("a/{before_path}") + } else { + "/dev/null".to_owned() + }; + let after_header = if after_part.mode.is_some() { + format!("b/{after_path}") + } else { + "/dev/null".to_owned() + }; + if before_part.content.is_binary || after_part.content.is_binary { + output.extend_from_slice( + format!("Binary files {before_header} and {after_header} differ\n").as_bytes(), + ); + continue; + } + output.extend_from_slice(format!("--- {before_header}\n+++ {after_header}\n").as_bytes()); + for hunk in unified_diff_hunks( + Diff::new(before_part.content.contents.as_ref(), after_part.content.contents.as_ref()), + DIFF_CONTEXT, + LineCompareMode::Exact, + ) { + let before_start = line_number(&hunk.left_line_range); + let after_start = line_number(&hunk.right_line_range); + output.extend_from_slice( + format!( + "@@ -{},{} +{},{} @@\n", + before_start, + hunk.left_line_range.len(), + after_start, + hunk.right_line_range.len() + ) + .as_bytes(), + ); + for (line_type, tokens) in hunk.lines { + output.push(match line_type { + DiffLineType::Context => b' ', + DiffLineType::Removed => b'-', + DiffLineType::Added => b'+', + }); + for (_, content) in &tokens { + output.extend_from_slice(content); + } + if tokens + .last() + .is_some_and(|(_, content)| !content.ends_with(b"\n")) + { + output.extend_from_slice(b"\n\\ No newline at end of file\n"); + } + } + } + } + Ok(String::from_utf8_lossy(&output).into_owned()) +} + +fn line_number(range: &std::ops::Range) -> usize { + if range.is_empty() { + range.start + } else { + range.start + 1 + } +} + +fn local_bookmarks_for_commit(repo: &dyn Repo, commit_id: &CommitId) -> Vec { + repo + .view() + .local_bookmarks_for_commit(commit_id) + .map(|(name, _)| name.as_str().to_owned()) + .collect() +} + +#[cfg(test)] +mod tests { + use std::{collections::BTreeMap, fs, path::Path, process::Command}; + + use super::*; + + fn init_internal_jj(root: &Path) { + let settings = user_settings().unwrap(); + let runtime = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build() + .unwrap(); + runtime + .block_on(Workspace::init_internal_git(&settings, root, gix::hash::Kind::Sha1)) + .unwrap(); + } + + fn jj_available() -> bool { + Command::new("jj").arg("--version").output().is_ok() + } + + fn run_jj(root: &Path, args: &[&str]) -> String { + let output = Command::new("jj") + .current_dir(root) + .env("JJ_USER", "VCS Test") + .env("JJ_EMAIL", "vcs@example.com") + .args(args) + .output() + .unwrap(); + assert!(output.status.success(), "jj {args:?}: {}", String::from_utf8_lossy(&output.stderr)); + String::from_utf8(output.stdout).unwrap() + } + + fn parse_label(raw: &str) -> Option { + let mut change_id = None; + for line in raw.lines() { + let (change, bookmarks) = line.split_once('|').unwrap_or((line, "")); + if change_id.is_none() && !change.trim().is_empty() { + change_id = Some(change.trim().to_owned()); + } + if !bookmarks.trim().is_empty() { + return Some(bookmarks.split_whitespace().collect::>().join(" ")); + } + } + change_id + } + + fn parse_summary(raw: &str) -> StatusSummary { + let mut summary = StatusSummary::default(); + for line in raw.lines() { + match line.trim().as_bytes().first() { + Some(b'A') => summary.untracked += 1, + Some(_) => summary.unstaged += 1, + None => {}, + } + } + summary + } + + fn patch_files(raw: &str) -> BTreeSet { + raw.lines() + .filter_map(|line| line.strip_prefix("diff --git a/")) + .filter_map(|line| line.split_once(" b/").map(|(_, path)| path.to_owned())) + .collect() + } + + fn parse_status_nul(raw: &str) -> Vec<(String, Vec)> { + let mut entries = Vec::new(); + let mut index = 0; + while index + 3 <= raw.len() { + let token = raw[index..index + 3].to_owned(); + index += 3; + let Some(path_end) = raw[index..].find('\0').map(|offset| index + offset) else { + break; + }; + let mut paths = vec![raw[index..path_end].to_owned()]; + index = path_end + 1; + if token.starts_with('R') || token.starts_with('C') { + let Some(path_end) = raw[index..].find('\0').map(|offset| index + offset) else { + break; + }; + paths.push(raw[index..path_end].to_owned()); + index = path_end + 1; + } + entries.push((token, paths)); + } + entries + } + + fn patch_numstat(raw: &str) -> BTreeMap { + let mut counts = BTreeMap::new(); + let mut current = None; + for line in raw.lines() { + if let Some(header) = line.strip_prefix("diff --git a/") { + current = header.split_once(" b/").map(|(_, path)| path.to_owned()); + if let Some(path) = ¤t { + counts.insert(path.clone(), (0, 0)); + } + continue; + } + let Some(path) = ¤t else { + continue; + }; + let count = counts.get_mut(path).unwrap(); + if line.starts_with('+') && !line.starts_with("+++") { + count.0 += 1; + } else if line.starts_with('-') && !line.starts_with("---") { + count.1 += 1; + } + } + counts + } + + #[test] + fn portable_jj_reads_work_without_the_jj_cli() { + let temp = tempfile::tempdir().unwrap(); + init_internal_jj(temp.path()); + fs::write(temp.path().join("alpha.txt"), "one\ntwo\n").unwrap(); + let repo = crate::detect(temp.path()).unwrap().unwrap(); + assert_eq!(repo.kind(), crate::VcsKind::Jj); + assert_eq!(repo.primary_root(), temp.path()); + assert_eq!(repo.watch_target(), temp.path().join(".jj/repo/op_heads/heads")); + + let patch = repo.diff_text(&crate::DiffOptions::default()).unwrap(); + assert!(patch.contains("diff --git a/alpha.txt b/alpha.txt")); + assert_eq!(repo.status_porcelain(&StatusOptions::default()).unwrap(), "A alpha.txt\n"); + let nul = repo + .status_porcelain(&StatusOptions { nul_terminated: true, ..StatusOptions::default() }) + .unwrap(); + assert_eq!(parse_status_nul(&nul), vec![("A ".to_owned(), vec!["alpha.txt".to_owned()])]); + assert_eq!(repo.changed_files(&crate::DiffOptions::default()).unwrap(), vec!["alpha.txt"]); + assert_eq!(repo.numstat(&crate::DiffOptions::default()).unwrap(), vec![NumstatEntry { + path: "alpha.txt".to_owned(), + added: Some(2), + removed: Some(0), + }]); + assert_eq!(repo.ls_files(false, false).unwrap(), vec!["alpha.txt"]); + assert_eq!(repo.ls_files(true, true).unwrap(), Vec::::new()); + + let head = repo.head_id().unwrap().unwrap(); + let details = repo.commit_details("@").unwrap(); + assert_eq!(details.sha, head); + assert_eq!(details.parents, Vec::::new()); + assert_eq!(details.message, ""); + assert_eq!(repo.log_subjects(1).unwrap(), vec![""]); + let lines = repo.log_onelines(1).unwrap(); + assert_eq!(lines.len(), 1); + let (change_id, subject) = lines[0].split_once(' ').unwrap(); + assert!(change_id.len() >= 8); + assert_eq!(subject, ""); + } + + #[test] + fn jj_operations_match_cli() { + if !jj_available() { + return; + } + let temp = tempfile::tempdir().unwrap(); + run_jj(temp.path(), &["git", "init", "."]); + std::fs::write(temp.path().join("alpha.txt"), "one\ntwo\n").unwrap(); + run_jj(temp.path(), &["bookmark", "create", "main", "-r", "@"]); + let workspace = JjWorkspace::require(temp.path()).unwrap(); + + let label_raw = run_jj(temp.path(), &[ + "log", + "--no-graph", + "--ignore-working-copy", + "-r", + "@ | heads(::@ & bookmarks())", + "-T", + "change_id.shortest(8) ++ \"|\" ++ local_bookmarks ++ \"\\n\"", + ]); + assert_eq!(workspace.working_copy_label().unwrap(), parse_label(&label_raw)); + + let summary_raw = + run_jj(temp.path(), &["diff", "-r", "@", "--summary", "--ignore-working-copy"]); + assert_eq!(workspace.status_summary().unwrap(), parse_summary(&summary_raw)); + + let expected_patch = run_jj(temp.path(), &["diff", "--git", "--ignore-working-copy"]); + let actual_patch = workspace.diff_text(&[], false).unwrap(); + assert_eq!(patch_files(&actual_patch), patch_files(&expected_patch)); + assert_eq!( + actual_patch + .lines() + .filter(|line| line.starts_with("@@ ")) + .count(), + expected_patch + .lines() + .filter(|line| line.starts_with("@@ ")) + .count() + ); + } + + #[test] + fn jj_portable_status_log_and_numstat_match_cli_fixture() { + if !jj_available() { + return; + } + let temp = tempfile::tempdir().unwrap(); + run_jj(temp.path(), &["git", "init", "."]); + fs::write(temp.path().join("rename.txt"), "rename\n").unwrap(); + fs::write(temp.path().join("delete.txt"), "delete\n").unwrap(); + fs::write(temp.path().join("modify.txt"), "before\n").unwrap(); + run_jj(temp.path(), &["commit", "-m", "base"]); + fs::rename(temp.path().join("rename.txt"), temp.path().join("renamed.txt")).unwrap(); + fs::remove_file(temp.path().join("delete.txt")).unwrap(); + fs::write(temp.path().join("modify.txt"), "after\n").unwrap(); + fs::write(temp.path().join("added.txt"), "added\n").unwrap(); + let workspace = JjWorkspace::require(temp.path()).unwrap(); + let patch = workspace.diff_text(&[], true).unwrap(); + + let lines = workspace + .status_porcelain(&StatusOptions::default()) + .unwrap(); + assert!(lines.contains("A added.txt\n")); + assert!(lines.contains("D delete.txt\n")); + assert!(lines.contains("M modify.txt\n")); + assert!(lines.contains("R rename.txt -> renamed.txt\n")); + let nul = workspace + .status_porcelain(&StatusOptions { nul_terminated: true, ..StatusOptions::default() }) + .unwrap(); + let framed = parse_status_nul(&nul); + assert!( + framed + .contains(&("R ".to_owned(), vec!["renamed.txt".to_owned(), "rename.txt".to_owned()])) + ); + + let actual_numstat = workspace + .numstat(&[]) + .unwrap() + .into_iter() + .map(|entry| (entry.path, (entry.added.unwrap(), entry.removed.unwrap()))) + .collect::>(); + assert_eq!(actual_numstat, patch_numstat(&patch)); + assert_eq!(workspace.ls_files(true).unwrap(), Vec::::new()); + + let log = workspace.log_onelines(2).unwrap(); + assert_eq!(log.len(), 2); + assert!(log[1].ends_with(" base")); + let details = workspace.commit_details("@").unwrap(); + assert_eq!(details.sha, workspace.head_id().unwrap().unwrap()); + assert_eq!(details.parents.len(), 1); + } +} diff --git a/crates/pi-vcs/src/lib.rs b/crates/pi-vcs/src/lib.rs new file mode 100644 index 000000000000..f49a8e5fb215 --- /dev/null +++ b/crates/pi-vcs/src/lib.rs @@ -0,0 +1,401 @@ +//! In-process version control for the coding agent. +//! +//! Collapses the git and Jujutsu CLI wrappers into one Rust interface: +//! - **git** ([`git::GitRepo`]) runs on gitoxide. The git binary survives only +//! where an in-process implementation cannot reach parity: credential-bound +//! network transfers (push/fetch/clone reuse the user's ssh config and +//! credential helpers) and reftable repositories (no library implementation +//! of reftable exists yet). +//! - **jj** ([`jj::JjWorkspace`]) runs on jj-lib, which shares the same +//! gitoxide stack for its git backend. No subprocess at all. +//! +//! Discovery ([`GitRepo::discover`], [`JjWorkspace::discover`], [`detect`]) is +//! a pure filesystem walk, cheap enough to call from synchronous render paths. +//! +//! [`GitRepo::discover`]: git::GitRepo::discover +//! [`JjWorkspace::discover`]: jj::JjWorkspace::discover + +pub mod error; +pub mod git; +pub mod jj; +pub mod types; + +use std::{ + path::{Path, PathBuf}, + sync::Arc, +}; + +pub use error::{Error, Result}; +pub use types::*; + +/// Capability points where the backends genuinely diverge. Everything else +/// on [`Repo`] is implemented by both backends. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Feature { + /// Index-relative diffs ([`DiffOptions::cached`]). Git only. + StagedDiff, + /// Two-revision diffs ([`DiffOptions::base`]/[`DiffOptions::head`]). Git + /// only. + RevDiff, +} + +impl Feature { + /// Parse the camelCase feature name used across the N-API boundary. + pub fn parse(name: &str) -> Option { + match name { + "stagedDiff" => Some(Self::StagedDiff), + "revDiff" => Some(Self::RevDiff), + _ => None, + } + } +} + +/// A discovered repository, dispatching portable operations to its backend. +#[derive(Debug, Clone)] +pub enum Repo { + /// Git owns the directory (including jj-git colocated workspaces). + Git(Arc), + /// Jujutsu owns the directory (its root is strictly deeper than any git + /// checkout). + Jj(Arc), +} + +impl Repo { + /// Which VCS backs this repository. + pub const fn kind(&self) -> VcsKind { + match self { + Self::Git(_) => VcsKind::Git, + Self::Jj(_) => VcsKind::Jj, + } + } + + /// Checkout or workspace root. + pub fn root(&self) -> &Path { + match self { + Self::Git(repo) => repo.root(), + Self::Jj(workspace) => workspace.root(), + } + } + + /// Primary checkout or default workspace root. + pub fn primary_root(&self) -> PathBuf { + match self { + Self::Git(repo) => repo.primary_root(), + Self::Jj(workspace) => workspace.primary_root(), + } + } + + /// Path of `dir` relative to the checkout or workspace root. + pub fn prefix_of(&self, dir: &Path) -> Option { + match self { + Self::Git(repo) => repo.prefix_of(dir), + Self::Jj(workspace) => git::relative_prefix(workspace.root(), dir), + } + } + + /// Whether this backend implements `feature`. + pub const fn supports(&self, feature: Feature) -> bool { + match self { + Self::Git(_) => true, + Self::Jj(_) => match feature { + Feature::StagedDiff | Feature::RevDiff => false, + }, + } + } + + /// Human label for the working copy: branch for git, bookmark or change id + /// for Jujutsu. + pub fn label(&self) -> Result> { + match self { + Self::Git(repo) => repo.current_branch(), + Self::Jj(workspace) => workspace.working_copy_label(), + } + } + + /// Commit id currently checked out by the working copy. + pub fn head_id(&self) -> Result> { + match self { + Self::Git(repo) => repo.head_sha(), + Self::Jj(workspace) => workspace.head_id(), + } + } + + /// Count the current staged, unstaged, and untracked changes. + pub fn status_summary(&self) -> Result { + match self { + Self::Git(repo) => repo.status_summary(), + Self::Jj(workspace) => workspace.status_summary(), + } + } + + /// Render current changes in git porcelain-v1 form. + pub fn status_porcelain(&self, options: &StatusOptions) -> Result { + match self { + Self::Git(repo) => repo.status_porcelain(options), + Self::Jj(workspace) => workspace.status_porcelain(options), + } + } + + /// Render the selected changes as a git-format patch. + pub fn diff_text(&self, options: &DiffOptions) -> Result { + match self { + Self::Git(repo) => repo.diff_text(options), + Self::Jj(workspace) => { + require_jj_diff_options(options)?; + workspace.diff_text(&options.files, true) + }, + } + } + + /// Return changed paths, using destination paths for renames. + pub fn changed_files(&self, options: &DiffOptions) -> Result> { + match self { + Self::Git(repo) => repo.changed_files(options), + Self::Jj(workspace) => { + require_jj_diff_options(options)?; + workspace.changed_files(&options.files, true) + }, + } + } + + /// Return per-file added and removed line counts. + pub fn numstat(&self, options: &DiffOptions) -> Result> { + match self { + Self::Git(repo) => repo.numstat(options), + Self::Jj(workspace) => { + require_jj_diff_options(options)?; + workspace.numstat(&options.files) + }, + } + } + + /// Render every working-copy change since the last commit. + pub fn uncommitted_diff(&self, files: &[String]) -> Result { + match self { + Self::Git(repo) => { + if repo.head_sha()?.is_none() { + let unstaged = repo + .diff_text(&DiffOptions { files: files.to_vec(), ..DiffOptions::default() })?; + let staged = repo.diff_text(&DiffOptions { + cached: true, + files: files.to_vec(), + ..DiffOptions::default() + })?; + Ok(git::join_patches(&[unstaged, staged])) + } else { + repo.diff_text(&DiffOptions { + base: Some("HEAD".to_owned()), + files: files.to_vec(), + ..DiffOptions::default() + }) + } + }, + Self::Jj(workspace) => workspace.diff_text(files, true), + } + } + + /// Return recent commit subjects, newest first. + pub fn log_subjects(&self, count: usize) -> Result> { + match self { + Self::Git(repo) => repo.log_subjects(count), + Self::Jj(workspace) => workspace.log_subjects(count), + } + } + + /// Return recent commits in compact one-line form. + pub fn log_onelines(&self, count: usize) -> Result> { + match self { + Self::Git(repo) => repo.log_onelines(count), + Self::Jj(workspace) => workspace.log_onelines(count), + } + } + + /// Read commit identity, parents, author, date, and full message. + pub fn commit_details(&self, rev: &str) -> Result { + match self { + Self::Git(repo) => repo.commit_details(rev), + Self::Jj(workspace) => workspace.commit_details(rev), + } + } + + /// List tracked paths, or untracked paths when `others` is true. + pub fn ls_files(&self, others: bool, exclude_standard: bool) -> Result> { + match self { + Self::Git(repo) => repo.ls_files(others, exclude_standard), + Self::Jj(workspace) => workspace.ls_files(others), + } + } + + /// Filesystem target whose metadata changes when the repository head moves. + pub fn watch_target(&self) -> PathBuf { + match self { + Self::Git(repo) => repo.head_watch_target(), + Self::Jj(workspace) => workspace.watch_target(), + } + } + + /// Access the git-specific handle when this is a git repository. + pub const fn as_git(&self) -> Option<&Arc> { + match self { + Self::Git(repo) => Some(repo), + Self::Jj(_) => None, + } + } + + /// Access the Jujutsu-specific handle when this is a Jujutsu workspace. + pub const fn as_jj(&self) -> Option<&Arc> { + match self { + Self::Git(_) => None, + Self::Jj(workspace) => Some(workspace), + } + } +} + +const fn require_jj_diff_options(options: &DiffOptions) -> Result<()> { + if options.cached { + return Err(Error::Unsupported { operation: "stagedDiff", backend: VcsKind::Jj }); + } + if options.base.is_some() || options.head.is_some() { + return Err(Error::Unsupported { operation: "revDiff", backend: VcsKind::Jj }); + } + Ok(()) +} + +/// Detect which VCS owns `dir`. +/// +/// Both lookups walk upward; the deeper root wins because it is the tree the +/// user actually works in. +/// +/// Colocated jj-git workspaces (same root) resolve to [`Repo::Git`] — git +/// automation is safe there. Returns `Ok(None)` for directories backed by +/// neither tool. +pub fn detect(dir: &Path) -> Result> { + let jj = jj::JjWorkspace::discover(dir)?; + let Some(jj) = jj else { + return Ok(git::GitRepo::discover(dir)?.map(|repo| Repo::Git(Arc::new(repo)))); + }; + match git::GitRepo::discover(dir)? { + Some(repo) if !is_strict_descendant(jj.root(), repo.root()) => { + Ok(Some(Repo::Git(Arc::new(repo)))) + }, + _ => Ok(Some(Repo::Jj(Arc::new(jj)))), + } +} + +/// Detect a "pure" Jujutsu workspace — one where git-mutating automation has +/// no safe target because jj is the nearest (or only) VCS ancestor. +/// +/// Colocated +/// workspaces and git checkouts nested under a jj tree return `false`. +pub fn is_pure_jj(dir: &Path) -> Result { + Ok(matches!(detect(dir)?, Some(Repo::Jj(_)))) +} + +/// Whether `child` is a strict descendant of `ancestor` (equal paths are not). +/// Both must be absolute; the comparison is lexical. +fn is_strict_descendant(child: &Path, ancestor: &Path) -> bool { + child != ancestor && child.starts_with(ancestor) +} +#[cfg(test)] +mod tests { + use std::{fs, path::Path, process::Command}; + + use super::*; + + fn run_git(root: &Path, args: &[&str]) -> String { + let output = Command::new("git") + .current_dir(root) + .args(args) + .output() + .unwrap(); + assert!(output.status.success(), "git {args:?}: {}", String::from_utf8_lossy(&output.stderr)); + String::from_utf8(output.stdout).unwrap() + } + + fn init_git(root: &Path) { + run_git(root, &["init", "-q"]); + run_git(root, &["config", "user.name", "VCS Test"]); + run_git(root, &["config", "user.email", "vcs@example.com"]); + } + + #[test] + fn repo_reports_backend_capabilities() { + let git_dir = tempfile::tempdir().unwrap(); + init_git(git_dir.path()); + let git = detect(git_dir.path()).unwrap().unwrap(); + assert!(git.supports(Feature::StagedDiff)); + assert!(git.supports(Feature::RevDiff)); + + let jj_dir = tempfile::tempdir().unwrap(); + fs::create_dir_all(jj_dir.path().join(".jj/repo")).unwrap(); + let jj = detect(jj_dir.path()).unwrap().unwrap(); + assert!(!jj.supports(Feature::StagedDiff)); + assert!(!jj.supports(Feature::RevDiff)); + } + + #[test] + fn jj_rejects_git_only_diff_options() { + let temp = tempfile::tempdir().unwrap(); + fs::create_dir_all(temp.path().join(".jj/repo")).unwrap(); + let repo = detect(temp.path()).unwrap().unwrap(); + + let staged = repo + .diff_text(&DiffOptions { cached: true, ..DiffOptions::default() }) + .unwrap_err(); + assert_eq!(staged.kind(), "Unsupported"); + assert!(matches!(staged, Error::Unsupported { + operation: "stagedDiff", + backend: VcsKind::Jj, + })); + + let revision = repo + .diff_text(&DiffOptions { base: Some("main".to_owned()), ..DiffOptions::default() }) + .unwrap_err(); + assert_eq!(revision.kind(), "Unsupported"); + assert!(matches!(revision, Error::Unsupported { + operation: "revDiff", + backend: VcsKind::Jj, + })); + } + + #[test] + fn git_uncommitted_diff_matches_head_with_staged_and_unstaged_changes() { + let temp = tempfile::tempdir().unwrap(); + init_git(temp.path()); + fs::write(temp.path().join("tracked.txt"), "base\n").unwrap(); + run_git(temp.path(), &["add", "tracked.txt"]); + run_git(temp.path(), &["commit", "-q", "-m", "base"]); + + fs::write(temp.path().join("tracked.txt"), "base\nunstaged\n").unwrap(); + fs::write(temp.path().join("staged.txt"), "staged\n").unwrap(); + run_git(temp.path(), &["add", "staged.txt"]); + + let expected = run_git(temp.path(), &["diff", "HEAD"]); + let actual = detect(temp.path()) + .unwrap() + .unwrap() + .uncommitted_diff(&[]) + .unwrap(); + assert_eq!(actual, expected); + } + + #[test] + fn git_uncommitted_diff_matches_both_unborn_head_comparisons() { + let temp = tempfile::tempdir().unwrap(); + init_git(temp.path()); + fs::write(temp.path().join("new.txt"), "staged\n").unwrap(); + run_git(temp.path(), &["add", "new.txt"]); + fs::write(temp.path().join("new.txt"), "staged\nunstaged\n").unwrap(); + + let expected = git::join_patches(&[ + run_git(temp.path(), &["diff"]), + run_git(temp.path(), &["diff", "--cached"]), + ]); + let actual = detect(temp.path()) + .unwrap() + .unwrap() + .uncommitted_diff(&[]) + .unwrap(); + assert_eq!(actual, expected); + } +} diff --git a/crates/pi-vcs/src/types.rs b/crates/pi-vcs/src/types.rs new file mode 100644 index 000000000000..95cfc73a9aab --- /dev/null +++ b/crates/pi-vcs/src/types.rs @@ -0,0 +1,329 @@ +//! Data types shared across the git and jj backends and their NAPI surface. +//! +//! These mirror the live surface of the TypeScript wrappers they replace +//! (`utils/git.ts`, `utils/jj.ts`): shapes consumed by the coding agent's +//! commit pipeline, status line, review flow, and worktree isolation machinery. + +use std::{path::PathBuf, time::Duration}; + +/// Which VCS backs a working directory. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum VcsKind { + /// A git repository (possibly a linked worktree). + Git, + /// A Jujutsu workspace (possibly colocated with git). + Jj, +} + +/// Status counts shown by status displays. +/// +/// Jujutsu has no index, so its `staged` is always zero. +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] +pub struct StatusSummary { + /// Files with staged (index) changes. + pub staged: u32, + /// Files with unstaged worktree modifications. + pub unstaged: u32, + /// Untracked files (gitignore-filtered). + pub untracked: u32, +} + +/// Resolved git repository metadata, discovered by walking the filesystem — +/// never a subprocess. Mirrors the TS `GitRepository` shape. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct GitRepoInfo { + /// Checkout root: the directory containing the `.git` entry. + pub repo_root: PathBuf, + /// The `.git` entry itself (directory, or pointer file for linked + /// worktrees). + pub git_entry_path: PathBuf, + /// Resolved git directory (worktree-private for linked worktrees). + pub git_dir: PathBuf, + /// Shared common directory (equals `git_dir` for primary checkouts). + pub common_dir: PathBuf, + /// Path of the `HEAD` file inside `git_dir`. + pub head_path: PathBuf, + /// Whether refs are stored in the reftable format (`extensions.refStorage`). + /// Reftable repos route ref reads through the git CLI: neither gitoxide nor + /// libgit2 can read reftable yet. + pub is_reftable: bool, +} + +/// HEAD resolution: on a ref (born or unborn) or detached at a commit. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum HeadState { + /// HEAD is a symbolic ref. + Ref { + /// Full ref name (`refs/heads/main`). + ref_name: String, + /// Short branch name when the ref lives under `refs/heads/`. + branch: Option, + /// Commit the ref points at; `None` for an unborn branch. + commit: Option, + }, + /// HEAD points directly at a commit. + Detached { + /// The commit SHA; `None` when HEAD is unreadable/empty. + commit: Option, + }, +} + +impl HeadState { + /// Commit SHA HEAD ultimately resolves to, when born. + pub fn commit(&self) -> Option<&str> { + match self { + Self::Ref { commit, .. } | Self::Detached { commit } => commit.as_deref(), + } + } + + /// Short branch name when HEAD is on a local branch. + pub fn branch(&self) -> Option<&str> { + match self { + Self::Ref { branch, .. } => branch.as_deref(), + Self::Detached { .. } => None, + } + } +} + +/// Linked-worktree metadata for a checkout that is not the primary one. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct LinkedWorktree { + /// The worktree's own checkout root. + pub root: PathBuf, + /// The shared primary checkout root that names the project. + pub primary_root: PathBuf, +} + +/// One row of `worktree list`. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct WorktreeEntry { + /// Checkout root of the worktree. + pub path: PathBuf, + /// HEAD commit, when known. + pub head: Option, + /// Checked-out branch ref, when not detached. + pub branch: Option, + /// Whether the worktree is on a detached HEAD. + pub detached: bool, +} + +/// Commit authorship for commit creation and replay flows. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CommitAuthor { + /// Author name. + pub name: String, + /// Author email. + pub email: String, + /// Author date (RFC 3339 / git date format), when overriding "now". + pub date: Option, +} + +/// Commit metadata for replay/rewrite flows (mirror of `git show -s`). +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct CommitDetails { + /// Full commit SHA. + pub sha: String, + /// Parent SHAs; empty for a root commit. + pub parents: Vec, + /// Author identity and date. + pub author: CommitAuthor, + /// Full commit message (subject + body, no trailing newline). + pub message: String, +} + +/// Per-file added/removed line counts (`diff --numstat`). +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct NumstatEntry { + /// Worktree-relative path (new path for renames). + pub path: String, + /// Added lines; `None` for binary files. + pub added: Option, + /// Removed lines; `None` for binary files. + pub removed: Option, +} + +/// Options for diff generation. +/// +/// The output contract is git patch format — the TS layer parses it with the +/// same parsers it applies to `git diff` output today (`parseFileDiffs`, +/// `parseFileHunks`), so header lines, `index`/mode lines, `GIT binary patch` +/// blocks, and rename headers must match the CLI dialect. +#[derive(Debug, Clone, Default)] +pub struct DiffOptions { + /// Diff the index against HEAD instead of the worktree against the index. + pub cached: bool, + /// Base revision; with `head` produces a two-rev diff. + pub base: Option, + /// Head revision (requires `base`). + pub head: Option, + /// Restrict to these worktree-relative paths. + pub files: Vec, + /// Unified context lines (default 3). + pub context: Option, + /// Include binary patch blocks (`GIT binary patch`) instead of the + /// "Binary files differ" placeholder. + pub binary: bool, +} + +/// Untracked-file reporting mode for status queries. +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] +pub enum UntrackedMode { + /// Do not report untracked files. + No, + /// Report untracked directories as single entries (git default). + #[default] + Normal, + /// Report every untracked file individually. + All, +} + +/// Options for porcelain status queries. +#[derive(Debug, Clone, Default)] +pub struct StatusOptions { + /// Untracked reporting mode. + pub untracked: UntrackedMode, + /// Restrict to these pathspecs. + pub pathspecs: Vec, + /// Terminate entries with NUL and disable path quoting (`-z`). + pub nul_terminated: bool, +} + +/// Options for commit creation. +#[derive(Debug, Clone, Default)] +pub struct CommitOptions { + /// Author override; committer stays the repo identity. + pub author: Option, + /// Permit an empty commit. + pub allow_empty: bool, + /// Amend HEAD instead of appending. + pub amend: bool, + /// Commit only these paths (pathspec commit). + pub files: Vec, +} + +/// Which hunks of a file a selection covers. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum HunkSpec { + /// The whole file diff. + All, + /// 1-based hunk indices within the file's diff. + Indices(Vec), + /// Hunks overlapping this 1-based new-file line range. + Lines { + /// First line (inclusive). + start: u32, + /// Last line (inclusive). + end: u32, + }, +} + +/// Selection of hunks to stage for one file. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct HunkSelection { + /// Worktree-relative path as it appears in the diff. + pub path: String, + /// Which hunks to take. + pub hunks: HunkSpec, +} + +/// A rejected hunk selection: the selection names hunks the diff does not +/// have, or selects hunks of a binary file. +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct HunkSelectionError { + /// Path of the offending selection. + pub path: String, + /// Human-readable reason. + pub message: String, +} + +/// Options for patch application (`git apply` semantics). +#[derive(Debug, Clone, Default)] +pub struct ApplyOptions { + /// Apply to the index instead of the worktree. + pub cached: bool, + /// Alternate index file for cached application (`GIT_INDEX_FILE` + /// equivalent); ignored for worktree application. + pub index_path: Option, + /// Apply in reverse. + pub reverse: bool, + /// Fall back to 3-way merge using the patch's recorded blob bases. + pub three_way: bool, +} + +/// Reset mode for tree-wide resets. +#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] +pub enum ResetMode { + /// Move HEAD only. + Soft, + /// Move HEAD and reset the index (git default). + #[default] + Mixed, + /// Move HEAD, reset index and worktree. Destructive. + Hard, +} + +/// Options for `restore`. +#[derive(Debug, Clone, Default)] +pub struct RestoreOptions { + /// Source revision (defaults to HEAD for staged, index for worktree). + pub source: Option, + /// Restore the index. + pub staged: bool, + /// Restore the worktree. + pub worktree: bool, + /// Restrict to these paths. + pub files: Vec, +} + +/// Options for `clean` (untracked file removal). Always recursive (`-d`). +#[derive(Debug, Clone, Default)] +pub struct CleanOptions { + /// Remove only ignored files (`-X`). + pub ignored_only: bool, + /// Remove ignored files too (`-x`). + pub include_ignored: bool, + /// Restrict to these literal paths (no glob expansion). + pub paths: Vec, +} + +/// Options for the CLI-backed `push`. +#[derive(Debug, Clone, Default)] +pub struct PushOptions { + /// Remote name; git's configured default when absent. + pub remote: Option, + /// Refspec to push; the current branch when absent. + pub refspec: Option, + /// Use `--force-with-lease`. + pub force_with_lease: bool, +} + +/// Options for the CLI-backed `clone`. +#[derive(Debug, Clone, Default)] +pub struct CloneOptions { + /// Branch or tag to clone (`--branch`). + pub ref_name: Option, + /// Pin to a specific commit; forces a full (non-shallow) clone. + pub sha: Option, + /// Network deadline override. + pub timeout: Option, +} + +/// Outcome of severing a copied working tree from shared git metadata. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum DetachGitDirResult { + /// The tree had no `.git`; nothing to detach. + NoGit, + /// `.git` already resolves to an independent object DB — left untouched. + Independent, + /// Detached into a standalone repo borrowing the source's objects. + Detached, +} + +/// Bounded object read (`git show` equivalent). +#[derive(Debug, Clone)] +pub struct ShowResult { + /// Object bytes, capped at the requested maximum. + pub bytes: Vec, + /// True when the object was larger than the cap and `bytes` is incomplete. + pub truncated: bool, +} diff --git a/crates/pi-voice/src/audio.rs b/crates/pi-voice/src/audio.rs index efb28d56c8a6..6bbf50e9a49c 100644 --- a/crates/pi-voice/src/audio.rs +++ b/crates/pi-voice/src/audio.rs @@ -16,7 +16,7 @@ use tokio::sync::Notify; use crate::{ VoiceResult, - device::{CaptureDevice, DeviceConfig, PlaybackDevice}, + device::{CaptureDevice, DeviceConfig, PlaybackDevice, playback_drain_periods}, }; // PulseAudio TCP playback stutters with a 20 ms target buffer; 50 ms absorbs @@ -29,15 +29,16 @@ const PLAYBACK_PERIOD_MS: u32 = 20; const CAPTURE_PERIOD_MS: u32 = 50; #[cfg(not(target_os = "linux"))] const CAPTURE_PERIOD_MS: u32 = 20; -// Backends queue up to three periods (AudioQueue buffers, WASAPI padding cap, -// Pulse `maxlength`/ALSA buffer). Draining needs three silence periods -// COMMITTED to the OS behind the tail: once the third is accepted into a -// three-period FIFO, everything ahead of it has played. The callback that -// marks drained races teardown — on Linux the delivery gate may cancel that -// callback's own write after `wait_for_drain` wakes — so count one extra -// empty callback: the racy, possibly-uncommitted write is always the fourth, -// which is margin rather than accounted flush. -const PLAYBACK_DRAIN_CALLBACKS: usize = 4; +// Backends queue up to `device::playback_drain_periods` periods (three for +// AudioQueue buffers/WASAPI padding; PulseAudio scales this with the widened +// remote/`PULSE_LATENCY_MSEC` backlog — see that function). Draining needs +// that many silence periods COMMITTED to the OS behind the tail: once the +// last is accepted into the backend's FIFO, everything ahead of it has +// played. The callback that marks drained races teardown — on Linux the +// delivery gate may cancel that callback's own write after `wait_for_drain` +// wakes — so count one extra empty callback: the racy, possibly-uncommitted +// write is always the last one, which is margin rather than accounted flush. +const PLAYBACK_DRAIN_MARGIN_CALLBACKS: usize = 1; /// Shared render-time state for one playback device: gain, drain, stop. /// @@ -146,6 +147,8 @@ impl PlaybackStream { let mut cursor = 0; let mut empty_callbacks = 0; let config = DeviceConfig { sample_rate, period_ms: PLAYBACK_PERIOD_MS }; + let drain_callbacks = + (playback_drain_periods(config) as usize) + PLAYBACK_DRAIN_MARGIN_CALLBACKS; // The guard travels inside the fill closure: if the backend drops the // callback for any reason (worker exit on device loss, stop), waiters // blocked in `wait_for_drain` wake instead of hanging forever. @@ -161,6 +164,7 @@ impl PlaybackStream { output, &callback_state, &mut empty_callbacks, + drain_callbacks, ); }), ) @@ -234,6 +238,7 @@ fn fill_playback( output: &mut [f32], state: &PlaybackState, empty_callbacks: &mut usize, + drain_callbacks: usize, ) { output.fill(0.0); if state.stopped.load(Ordering::Acquire) { @@ -256,7 +261,7 @@ fn fill_playback( }, Err(TryRecvError::Disconnected) => { *empty_callbacks += 1; - if *empty_callbacks >= PLAYBACK_DRAIN_CALLBACKS { + if *empty_callbacks >= drain_callbacks { state.mark_drained(); } break; @@ -334,6 +339,12 @@ mod tests { use super::*; + // Base three-period assumption (`PULSE_BACKLOG_PERIODS` on Linux; fixed + // for other backends) plus the one callback of teardown-race margin + // (`PLAYBACK_DRAIN_MARGIN_CALLBACKS`) — what every backend uses for a + // period-sized local target. + const LOCAL_DRAIN_CALLBACKS: usize = 3 + PLAYBACK_DRAIN_MARGIN_CALLBACKS; + #[test] fn playback_preserves_chunk_order_and_applies_render_gain() { let state = PlaybackState::new(); @@ -347,20 +358,82 @@ mod tests { let mut empty_callbacks = 0; let mut output = [9.0; 5]; - fill_playback(&rx, &mut current, &mut cursor, &mut output, &state, &mut empty_callbacks); + fill_playback( + &rx, + &mut current, + &mut cursor, + &mut output, + &state, + &mut empty_callbacks, + LOCAL_DRAIN_CALLBACKS, + ); assert_eq!(output, [0.5, -0.5, 0.25, -0.25, 0.0]); assert!(!state.drained.load(Ordering::Acquire)); let mut silence = [1.0; 2]; - while empty_callbacks < PLAYBACK_DRAIN_CALLBACKS { + while empty_callbacks < LOCAL_DRAIN_CALLBACKS { silence.fill(1.0); - fill_playback(&rx, &mut current, &mut cursor, &mut silence, &state, &mut empty_callbacks); + fill_playback( + &rx, + &mut current, + &mut cursor, + &mut silence, + &state, + &mut empty_callbacks, + LOCAL_DRAIN_CALLBACKS, + ); assert_eq!(silence, [0.0, 0.0]); assert_eq!( state.drained.load(Ordering::Acquire), - empty_callbacks >= PLAYBACK_DRAIN_CALLBACKS + empty_callbacks >= LOCAL_DRAIN_CALLBACKS + ); + } + } + + /// Regression guard: a widened playback backlog (remote `PULSE_SERVER` or + /// `PULSE_LATENCY_MSEC`) must not be declared drained after only the + /// local three-period margin — queued audio would still be flushing to + /// the speaker and `AudioPlayback.end()` would clip it. Draining must + /// wait out the full widened `drain_callbacks` count. + #[test] + fn widened_backlog_is_not_drained_within_local_margin() { + let state = PlaybackState::new(); + let (tx, rx) = flume::unbounded::>(); + drop(tx); + let mut current = Vec::new(); + let mut cursor = 0; + let mut empty_callbacks = 0; + let mut output = [0.0; 2]; + let widened_drain_callbacks = LOCAL_DRAIN_CALLBACKS * 4; + + for _ in 0..LOCAL_DRAIN_CALLBACKS { + fill_playback( + &rx, + &mut current, + &mut cursor, + &mut output, + &state, + &mut empty_callbacks, + widened_drain_callbacks, + ); + } + assert!( + !state.drained.load(Ordering::Acquire), + "drained after only the local margin despite a widened backlog" + ); + + while empty_callbacks < widened_drain_callbacks { + fill_playback( + &rx, + &mut current, + &mut cursor, + &mut output, + &state, + &mut empty_callbacks, + widened_drain_callbacks, ); } + assert!(state.drained.load(Ordering::Acquire)); } #[test] diff --git a/crates/pi-voice/src/device/linux.rs b/crates/pi-voice/src/device/linux.rs index ef76dc105e01..d839a3654d44 100644 --- a/crates/pi-voice/src/device/linux.rs +++ b/crates/pi-voice/src/device/linux.rs @@ -375,24 +375,113 @@ impl AlsaOpenError { } } -fn pulse_attr(config: DeviceConfig) -> Result { - let period_bytes = config - .period_samples() - .checked_mul(size_of::()) - .and_then(|value| u32::try_from(value).ok()) - .ok_or_else(|| "audio period is too large".to_owned())?; - let target_bytes = period_bytes - .checked_mul(3) - .ok_or_else(|| "audio period is too large".to_owned())?; - Ok(PaBufferAttr { - maxlength: target_bytes, - tlength: period_bytes, - prebuf: u32::MAX, - minreq: u32::MAX, - fragsize: period_bytes, +/// Network-safe playback target when `PULSE_SERVER` points at a remote +/// server: deep enough to ride SSH/VPN jitter, shallow enough for +/// conversation-grade latency. +const REMOTE_PULSE_LATENCY_MS: u32 = 200; + +/// Latency target for pulse streams. `PULSE_LATENCY_MSEC` wins when set to a +/// positive integer (the `pacat`/`paplay` convention); otherwise a remote +/// `PULSE_SERVER` gets the network-safe default and local servers keep the +/// low-latency callback period. +fn pulse_latency_ms(period_ms: u32) -> u32 { + let latency_override = std::env::var("PULSE_LATENCY_MSEC") + .ok() + .and_then(|raw| parse_latency_msec(&raw)); + let pulse_server_configured = latency_override.is_none() + && std::env::var_os("PULSE_SERVER").is_some_and(|server| !server.is_empty()); + select_pulse_latency_ms(period_ms, latency_override, pulse_server_configured) +} + +fn select_pulse_latency_ms( + period_ms: u32, + latency_override: Option, + pulse_server_configured: bool, +) -> u32 { + latency_override + .unwrap_or(if pulse_server_configured { + REMOTE_PULSE_LATENCY_MS + } else { + period_ms + }) + .max(period_ms) +} + +fn parse_latency_msec(raw: &str) -> Option { + raw.trim().parse::().ok().filter(|ms| *ms > 0) +} + +/// Bytes of mono `f32` covering `ms` at the stream's logical rate (never zero). +fn pulse_bytes(config: DeviceConfig, ms: u32) -> Result { + (config.sample_rate as usize) + .checked_mul(ms as usize) + .map(|samples| (samples / 1000).max(1)) + .and_then(|samples| samples.checked_mul(size_of::())) + .and_then(|bytes| u32::try_from(bytes).ok()) + .ok_or_else(|| "audio buffer is too large".to_owned()) +} + +/// Playback periods `pulse_attr` keeps queued server-side (`maxlength`) for +/// the chosen latency target. `playback_drain_periods` mirrors this so the +/// drain-callback grace period always covers the real backlog depth. +const PULSE_BACKLOG_PERIODS: u32 = 3; + +/// Server-side buffer geometry for one `pa_simple` stream. +/// +/// Local servers keep period-sized buffers: the sink holds one callback +/// period and requests the next, minimizing mouth-to-ear latency. When the +/// server is remote every refill request crosses the network, so a +/// period-sized target underruns into staccato audio; `latency_ms` widens the +/// playback target and the capture backlog instead, trading fixed delay for +/// jitter tolerance. Fields the server ignores for a direction stay at the +/// "server default" sentinel. +fn pulse_attr( + config: DeviceConfig, + direction: c_int, + latency_ms: u32, +) -> Result { + let period_bytes = pulse_bytes(config, config.period_ms)?; + let latency_bytes = pulse_bytes(config, latency_ms.max(config.period_ms))?; + let backlog_bytes = latency_bytes + .checked_mul(PULSE_BACKLOG_PERIODS) + .ok_or_else(|| "audio buffer is too large".to_owned())?; + Ok(if direction == PA_STREAM_RECORD { + PaBufferAttr { + maxlength: backlog_bytes, + tlength: u32::MAX, + prebuf: u32::MAX, + minreq: u32::MAX, + fragsize: period_bytes, + } + } else { + PaBufferAttr { + maxlength: backlog_bytes, + tlength: latency_bytes, + prebuf: u32::MAX, + minreq: u32::MAX, + fragsize: u32::MAX, + } }) } +/// Periods `PulseAudio` may hold queued server-side for a playback stream +/// opened with this config, before a fill callback observing no new data +/// reflects genuine drain rather than an in-flight refill. Mirrors the +/// `PULSE_BACKLOG_PERIODS` multiplier `pulse_attr` applies to the same +/// latency target. ALSA (the fallback backend when `PulseAudio` is +/// unavailable) never widens beyond the base period, so this stays a safe +/// upper bound even if the stream falls back. +pub(crate) fn playback_drain_periods(config: DeviceConfig) -> u32 { + drain_periods_for_latency(config.period_ms, pulse_latency_ms(config.period_ms)) +} + +fn drain_periods_for_latency(period_ms: u32, latency_ms: u32) -> u32 { + latency_ms + .max(period_ms) + .saturating_mul(PULSE_BACKLOG_PERIODS) + .div_ceil(period_ms.max(1)) +} + fn remember_error(slot: &Mutex>, error: String) { if let Ok(mut stored) = slot.lock() { *stored = Some(error); @@ -729,7 +818,7 @@ impl PlaybackDevice { /// Opens the default playback device and starts its worker thread. pub fn start(config: DeviceConfig, mut fill: PlaybackFill) -> VoiceResult { let samples = config.period_samples(); - let attr = pulse_attr(config)?; + let attr = pulse_attr(config, PA_STREAM_PLAYBACK, pulse_latency_ms(config.period_ms))?; let timeout_ms = c_int::try_from(config.period_ms) .unwrap_or(c_int::MAX) .max(1); @@ -829,7 +918,7 @@ impl CaptureDevice { /// Opens the default capture device and starts its worker thread. pub fn start(config: DeviceConfig, mut sink: CaptureSink) -> VoiceResult { let samples = config.period_samples(); - let attr = pulse_attr(config)?; + let attr = pulse_attr(config, PA_STREAM_RECORD, pulse_latency_ms(config.period_ms))?; let timeout_ms = c_int::try_from(config.period_ms) .unwrap_or(c_int::MAX) .max(1); @@ -917,3 +1006,70 @@ impl Drop for CaptureDevice { let _ = self.stop(); } } + +#[cfg(test)] +mod tests { + use super::*; + + fn config(sample_rate: u32, period_ms: u32) -> DeviceConfig { + DeviceConfig { sample_rate, period_ms } + } + + /// Regression guard: the remote-server support must not change the local + /// low-latency geometry (period-sized target, 3x cap). + #[test] + fn local_playback_keeps_period_sized_target() { + let attr = pulse_attr(config(24_000, 20), PA_STREAM_PLAYBACK, 20).unwrap(); + assert_eq!(attr.tlength, 1920); + assert_eq!(attr.maxlength, 5760); + } + + /// A remote latency target must deepen the playback buffer, or the sink + /// starves on network round trips and audio arrives as staccato bursts. + #[test] + fn remote_playback_widens_target_to_latency() { + let attr = pulse_attr(config(24_000, 20), PA_STREAM_PLAYBACK, 200).unwrap(); + assert_eq!(attr.tlength, 19_200); + assert_eq!(attr.maxlength, 57_600); + } + + /// Capture keeps its callback cadence (fragsize) while the backlog widens + /// to absorb network delivery bursts instead of dropping samples. + #[test] + fn remote_capture_keeps_cadence_and_widens_backlog() { + let attr = pulse_attr(config(16_000, 20), PA_STREAM_RECORD, 200).unwrap(); + assert_eq!(attr.fragsize, 1280); + assert_eq!(attr.maxlength, 38_400); + assert_eq!(attr.tlength, u32::MAX); + } + + /// `PULSE_LATENCY_MSEC` accepts only positive integers; anything else + /// falls through to the computed default instead of misconfiguring the + /// stream. + #[test] + fn latency_override_parses_positive_integers_only() { + assert_eq!(parse_latency_msec(" 150 "), Some(150)); + assert_eq!(parse_latency_msec("0"), None); + assert_eq!(parse_latency_msec("abc"), None); + } + /// The environment-derived latency policy keeps local streams at the + /// callback period, widens explicit servers, and gives a valid override + /// precedence without allowing it below the callback period. + #[test] + fn latency_selection_obeys_local_remote_and_override_precedence() { + assert_eq!(select_pulse_latency_ms(50, None, false), 50); + assert_eq!(select_pulse_latency_ms(50, None, true), 200); + assert_eq!(select_pulse_latency_ms(50, Some(150), true), 150); + assert_eq!(select_pulse_latency_ms(50, Some(10), true), 50); + } + + /// Regression guard: drain accounting must scale with the same + /// `PULSE_BACKLOG_PERIODS` multiplier `pulse_attr` uses for `maxlength`, + /// or a widened remote/latency-override target can be declared drained + /// while queued audio still awaits an OS-side flush. + #[test] + fn drain_periods_scale_with_widened_latency() { + assert_eq!(drain_periods_for_latency(20, 20), 3); + assert_eq!(drain_periods_for_latency(20, 200), 30); + } +} diff --git a/crates/pi-voice/src/device/mod.rs b/crates/pi-voice/src/device/mod.rs index 73a161da1f24..3d871efa875e 100644 --- a/crates/pi-voice/src/device/mod.rs +++ b/crates/pi-voice/src/device/mod.rs @@ -11,9 +11,9 @@ //! # Contract //! - [`PlaybackDevice::start`] opens the default speaker and invokes `fill` //! with a mono `f32` buffer roughly every [`DeviceConfig::period_ms`]. The -//! callback runs on a backend-owned audio thread and must not block. Backends -//! keep at most three periods queued OS-side; the engine's drain accounting -//! (`PLAYBACK_DRAIN_CALLBACKS`) depends on that bound. +//! callback runs on a backend-owned audio thread and must not block. Queue +//! depth varies by backend and stream config; [`playback_drain_periods`] +//! reports the bound used by the engine's drain accounting. //! - [`CaptureDevice::start`] opens the default microphone and invokes `sink` //! with non-empty mono `f32` chunks at the requested sample rate, also from a //! backend-owned thread. @@ -87,6 +87,23 @@ impl PlaybackDevice { } } +/// Periods of audio a backend may hold queued OS-side for a playback stream +/// opened with this config, before a fill callback observing no new data +/// can be trusted as genuine drain rather than an in-flight refill. Fixed +/// at three for backends with a hardware/API-enforced queue depth +/// (`CoreAudio` `AudioQueue` buffer count, WASAPI padding cap); `PulseAudio` +/// scales this with the widened remote/`PULSE_LATENCY_MSEC` backlog before +/// the stream even opens (see `linux::playback_drain_periods`). +#[cfg(target_os = "linux")] +pub fn playback_drain_periods(config: DeviceConfig) -> u32 { + imp::playback_drain_periods(config) +} + +#[cfg(not(target_os = "linux"))] +pub const fn playback_drain_periods(_config: DeviceConfig) -> u32 { + 3 +} + /// Running default-microphone capture stream driven by a sink callback. pub struct CaptureDevice { inner: imp::CaptureDevice, diff --git a/deny.toml b/deny.toml index 9163d9b2bef8..4ac9b1e7151e 100644 --- a/deny.toml +++ b/deny.toml @@ -39,6 +39,10 @@ allow = [ exceptions = [ { allow = ["CDDL-1.0"], crate = "inferno@0.12.8" }, { allow = ["WTFPL"], crate = "terminfo@0.9.0" }, + # uluru (via pi-vcs → jj-lib → gix → gix-pack) is MPL-2.0: file-level + # copyleft, satisfied by upstream source availability; no obligations + # attach to our unmodified use. Keep it package-scoped like inferno. + { allow = ["MPL-2.0"], crate = "uluru@3.1.0" }, ] # tree-sitter-graphql 0.1.0 has no SPDX expression in Cargo.toml. Its packaged diff --git a/docs/ai-schema-normalize.md b/docs/ai-schema-normalize.md index 06e43bd115dc..3bf0251a944a 100644 --- a/docs/ai-schema-normalize.md +++ b/docs/ai-schema-normalize.md @@ -56,9 +56,9 @@ Removed in the unified-flow refactor: | `openai-completions` | `adaptSchemaForStrict` (sanitize + enforce when strict mode is enabled) | | `openai-responses`, `openai-codex-responses` | `sanitizeSchemaForOpenAIResponses` before strict-mode adaptation | | `azure-openai-responses` | `sanitizeSchemaForOpenAIResponses`; emits `strict: false` without adaptation | -| Moonshot/Kimi native hosts using MFJS | `normalizeSchemaForMoonshot` | -| Grammar-flavored OpenAI-compatible hosts | `sanitizeSchemaForGrammar` | -| `ollama` | `sanitizeSchemaForOllama` | +| Moonshot/Kimi native hosts using MFJS (`toolSchemaFlavor: "moonshot-mfjs"`) | `normalizeSchemaForMoonshot` | +| Grammar-flavored OpenAI-compatible hosts (`toolSchemaFlavor: "grammar"`) | `sanitizeSchemaForGrammar` | +| `ollama` / `ollama-cloud` tool parameters | `toolWireSchema` → `sanitizeSchemaForOllama` | | `google-generative-ai`, `google-vertex`, Gemini CLI | `normalizeSchemaForGoogle` | | Cloud Code Assist Claude (Antigravity + GCA, `claude-*` model ids) | `normalizeSchemaForCCA` | | MCP `inputSchema` ingestion | `normalizeSchemaForMCP` | diff --git a/docs/approval-mode.md b/docs/approval-mode.md index b2246eda2d94..bc59312f4770 100644 --- a/docs/approval-mode.md +++ b/docs/approval-mode.md @@ -33,9 +33,15 @@ tools: approval: bash: prompt read: allow - mcp__filesystem__delete: deny + mcp__filesystem_delete: deny ``` +For MCP tools, key the policy by the exact final registered name. The ordinary form is +`mcp___`. A redundant `_` prefix is removed from the tool name, +so server `echo` tool `echo_it` is registered as `mcp__echo_it`. Names longer than 64 characters are +capped with a deterministic hash suffix; use the final capped name rather than the uncapped pattern. See +[MCP tool naming](./mcp-server-tool-authoring.md#naming-and-collision-domain). + Resolution per tool call: 1. Evaluate `tool.approval(args)`; omitted/malformed decisions default to tier `exec`. diff --git a/docs/cli-reference.md b/docs/cli-reference.md index a713c9484dca..cb345cd8cd83 100644 --- a/docs/cli-reference.md +++ b/docs/cli-reference.md @@ -211,7 +211,7 @@ Run `omp --help` for each command's own flags and examples. | `auth-broker` | Manage the omp auth-broker (credential vault). | [auth broker / gateway](./auth-broker-gateway.md) | | `auth-gateway` | Run an auth-gateway forward proxy backed by the configured broker. | [auth broker / gateway](./auth-broker-gateway.md) | | `agents` | Manage bundled task agents. | [task agent discovery](./task-agent-discovery.md) | -| `bench` | Benchmark models with the same prompt: time-to-first-token and generation throughput (tokens/s). | | +| `bench` | Benchmark models: TTFT/prefill vs decode throughput with p50/p95 across chat, prefill, generation, and prompt-cache workloads, rendered in a live dashboard (`--prefill-bytes` sizes the synthetic prefill input). | | | `browser-relay` | Run the local CDP relay that lets the browser tool drive your own Chrome tabs. | [computer use](./computer-use.md) | | `cleanse` | Detect and fix project diagnostics with weighted parallel subagents. | | | `commit` | Generate a commit message and update changelogs. | | @@ -222,8 +222,10 @@ Run `omp --help` for each command's own flags and examples. | `gc` | Run storage garbage collection. | | | `grep` | Test the grep tool from the CLI. (The [`grep` tool](./tools/grep.md) is a separate agent tool.) | | | `gallery` | Preview tool renderers across streaming, in-progress, success, and failure states. | | +| `git` | Interactive fullscreen git UI: split diff viewer, staging sidebar, and commit composer. | | | `grievances` | View, clean, or push reported tool issues (auto-QA grievances). | | | `if-bench` | Benchmark instruction following and working memory: one cached thread of glyph array actions with a cat-sound directive that moves through the prompt. | | +| `images`, `img` | Inspect, diagnose, probe, and purge image publication backends. | | | `install` | Install or link an extension package (alias of `plugin install` / `plugin link`). | [extensions](./extensions.md) | | `join` | Join a shared collab session (same as `/join`). | [collab](./collab.md) | | `models` | List, search, and refresh available models. | [models](./models.md) | @@ -234,10 +236,11 @@ Run `omp --help` for each command's own flags and examples. | `setup` | Run onboarding setup or install dependencies for optional features. | | | `shell` | Interactive shell console. | | | `read` | Show what the read tool will return for a path, URL, or internal URI. (The [`read` tool](./tools/read.md) is a separate agent tool.) | | +| `render` | Draw a session's entire thread through the production transcript pipeline (with repaint timing). | | | `ssh` | Manage SSH host configurations. | | | `stats` | View usage statistics. | | -| `update` | Check for and install updates. | | -| `usage` | Show provider usage limits for every authenticated account. | | +| `update` | Check for and install updates; `--canary`/`--stable` switch release channels. | | +| `usage` | Show provider usage limits for every authenticated account; `usage clients` breaks token burn down per client (with `--days`), `usage invalidate` drops cached reports. | | | `tiny-models` | Download tiny local models (session titles + memory). | [local models](./local-models.md) | | `token` | Get the API key or OAuth token for a provider. | [secrets](./secrets.md) | | `ttsr` | Inspect and test Time-Traveling Stream Rules (TTSR). (Covers the CLI command; the [TTSR feature](./ttsr-injection-lifecycle.md) is documented separately.) | | diff --git a/docs/compaction.md b/docs/compaction.md index 03a046a00c9c..124e998c1b50 100644 --- a/docs/compaction.md +++ b/docs/compaction.md @@ -121,7 +121,7 @@ The automatic paths are intentionally different: - On soft-compaction success, `agent.continue()` is scheduled to retry the turn. - **Threshold maintenance** - - Trigger: successful, non-error assistant message whose adjusted context tokens exceed `resolveThresholdTokens(...)`. + - Trigger: successful, non-error assistant message whose adjusted context tokens exceed `resolveThresholdTokens(...)`. The measured count comes from `calculateContextTokens(...)`, which subtracts provider-side orchestration tokens (billable, but never replayed into the conversation prefix) so auto-compaction and context-promotion thresholds are not inflated by them. - Mid-turn maintenance also checks safe tool-loop boundaries before the next provider request when `compaction.midTurnEnabled !== false`. - Tool-output pruning can reduce the measured token count before threshold comparison. - Context promotion is tried before post-turn compaction. @@ -143,7 +143,7 @@ Threshold, incomplete-output, and overflow recovery advance to the next configur Including `snapcompact` in `compaction.methodOrder` replaces the LLM summarization call with a local, deterministic archival pass (`compact` from `@oh-my-pi/snapcompact`): -- The discarded history is serialized, whitespace-collapsed, and printed onto model-aware PNG frames (frame width fixed per shape; frame height hugs the rows actually printed) using bundled public-domain pixel fonts. The shape — and frame size — resolve from the **model id** when the model line was measured: Claude reads X.org `8x13` glyphs on an 11px advance (extra letter-spacing, black ink — `11on16-bw`; high-res lines — Opus 4.7+, Fable, Mythos — get 1932px frames under Anthropic's 4,784 visual-token cap, older lines stay at 1568px), Gemini reads `8x13` glyphs on a 22px pitch (extra leading, black ink — `8on22-bw` at 2048px, since Gemini 3.x bills a fixed 1,120-token budget per image at any pixel size), GPT/Codex read the same `8on22-bw` shape at 1568px (patch billing is area-proportional, so larger frames cannot improve chars per token), and Kimi/GLM read `8x13` glyphs on a 16px pitch (`8on16-bw` at 1568px — kimi's processor downscales past 1792px). A Claude routed through Vertex or OpenRouter keeps its Claude shape. Unmeasured models fall back to their wire API family (Anthropic-family/unknown → `11on16-bw`, Google → `8on22-bw`, OpenAI-compatible → `8on22-bw`); billing (per-family patch/budget formulas, OpenAI's `detail: "original"` hint) always follows the API carrying the request, computed for the resolved frame size. The `snapcompact.shape` setting (default `auto`) forces one of the research-eval variants instead: square grids (`8x8r`/`8x8u`/`6x6u`/`5x8` × sentence-hue/black ink) or the per-model eval winners (`6x12-dim`, `8x13-bw`, `8on16-bw`, `8on22-bw`, `11on16-bw`, and the two-column word-wrapped `doc-8on16-bw`/`-sent`/`-sent-dim`, where `dim` prints stopwords in gray). A forced variant keeps its geometry but is re-priced for the target provider's image billing. The same setting governs inline system-prompt/tool-result imaging (`snapcompact.systemPrompt`, `snapcompact.toolResults`). +- The discarded history is serialized, whitespace-collapsed, and printed onto model-aware PNG frames (frame width fixed per shape; frame height hugs the rows actually printed) using bundled public-domain pixel fonts. The shape — and frame size — resolve from the **model id** when the model line was measured: Claude reads X.org `8x13` glyphs on an 11px advance (extra letter-spacing, black ink — `11on16-bw`; high-res lines — Opus 4.7+, Fable, Mythos — get 1932px frames under Anthropic's 4,784 visual-token cap, older lines stay at 1568px), Gemini reads `8x13` glyphs on a 22px pitch (extra leading, black ink — `8on22-bw` at 2048px, since Gemini 3.x bills a fixed 1,120-token budget per image at any pixel size), GPT/Codex read the same `8on22-bw` shape at 1568px (patch billing is area-proportional, so larger frames cannot improve chars per token), and Kimi/GLM read `8x13` glyphs on a 16px pitch (`8on16-bw` at 1568px — kimi's processor downscales past 1792px). A Claude routed through Vertex or OpenRouter keeps its Claude shape. Auto selection is also font-aware (`resolveShapeForText`): when the model-default font cannot safely render the transcript, or wide CJK glyphs dominate it and the `silver16-bw` grid can render it safely, auto switches to `silver16-bw`; forced variants are never overridden. Unmeasured models fall back to their wire API family (Anthropic-family/unknown → `11on16-bw`, Google → `8on22-bw`, OpenAI-compatible → `8on22-bw`); billing (per-family patch/budget formulas, OpenAI's `detail: "original"` hint) always follows the API carrying the request, computed for the resolved frame size. The `snapcompact.shape` setting (default `auto`) forces one of the research-eval variants instead: square grids (`8x8r`/`8x8u`/`6x6u`/`5x8` × sentence-hue/black ink) or the per-model eval winners (`6x12-dim`, `8x13-bw`, `8on16-bw`, `8on22-bw`, `11on16-bw`, `silver16-bw` — the embedded Silver TrueType font on a 16px grid for CJK and other non-Latin text — and the two-column word-wrapped `doc-8on16-bw`/`-sent`/`-sent-dim`, where `dim` prints stopwords in gray). A forced variant keeps its geometry but is re-priced for the target provider's image billing. The same setting governs inline system-prompt/tool-result imaging (`snapcompact.systemPrompt`, `snapcompact.toolResults`). - Serialization keeps the archive conversation-dense: tool results are truncated head+tail (default 2,000 chars at a 0.6 head ratio), tool-call argument values are capped per value (500) and per call (2,000), and tool output is printed in dim gray ink so conversation reads louder than tool noise. All budgets and the dimming are configurable via `SerializeOptions` (`toolResultMaxChars`, `toolArgMaxChars`, `toolCallMaxChars`, `truncateHeadRatio`, `dimToolResults`). - The snapcompact archive persists under `CompactionEntry.preserveData.snapcompact` as bounded source text plus rendered frames. On each context rebuild it is reconstructed into ordered compaction blocks: plain text at the oldest edge, an imaged middle, then plain text at the newest edge. The entry's `summary` is just the short resume lead-in plus the usual file-operation list. - Later compactions re-render from that bounded source text (`Archive.text`), not by carrying old PNGs forward blindly. `maxFrames` now defaults to `MAX_FRAMES_DEFAULT` (80) and acts only as an upper limit; when the imaged middle is large it foveates internally (HQ/LQ/HQ), while both chronological edges stay verbatim text. @@ -164,6 +164,7 @@ Default prune policy: - Require at least `20_000` total estimated savings. - Never blank a result below `50` tokens (`MIN_PRUNE_TOKENS`): the `[Output truncated - N tokens]` placeholder costs ~8 tokens, so pruning a sub-floor result would grow the context and churn the prompt cache for nothing. (Superseded and useless results keep their own rules — the useless collector already drops no-savings candidates; superseded reads prune for correctness regardless of size.) - Never prune `skill` tool results, `read` results of `skill://` paths, or reads of the active plan reference file (added via `AgentSession`'s plan protection). +- Prompt-cache guard: while the cache is warm, only results whose all-message suffix is at most `8_000` tokens are touched (`PRUNE_CACHE_WARM_SUFFIX_TOKENS`), so a still-cached prefix is never re-written. That window is narrower than the `40_000` age window, so age victims are reclaimed only once the cache is cold: after `PRUNE_IDLE_FLUSH_MS` (90 min) of silence the guard lifts and the whole sent region is eligible, same rule as the supersede pass. During continuous work, deep victims wait for compaction. Pruned tool results are replaced with: @@ -186,9 +187,10 @@ The flag never reaches provider wire formats, and flagged pairs are never remove `prepareCompaction()` only considers entries since the last compaction entry (if any). 1. Find previous compaction index. -2. Compute `boundaryStart = prevCompactionIndex + 1`. -3. Adapt `keepRecentTokens` using measured usage ratio when available. -4. Run `findCutPoint()` over the boundary window. +2. Honor the latest `/clear` `reset_boundary` marker: a boundary after the last reusable compaction supersedes it, so a compaction after an in-place `/clear` only summarizes messages created after the reset (issue #8718). +3. Compute `boundaryStart = prevCompactionIndex + 1`. +4. Adapt `keepRecentTokens` using measured usage ratio when available. +5. Run `findCutPoint()` over the boundary window. Valid cut points include: @@ -247,13 +249,15 @@ Prompt selection: - short UI summary: `compaction-short-summary.md` - handoff document: `handoff-document.md` (used by `generateHandoff(...)`, not serialized compaction) -Remote summarization modes: +Remote summarization modes, consulted in order (each stage falls back to the next while one is available): -- If `compaction.remoteEndpoint` is set and remote compaction is enabled, local summary generation POSTs one of two wire formats: +- **V2 streaming Responses compaction** (tried first, on by default via `compaction.remoteStreamingV2Enabled`): for eligible models — `shouldUseCompactionV2Streaming(...)`: `openai-responses`, `azure-openai-responses`, or `openai-codex-responses` APIs with `remoteCompaction.v2StreamingEnabled` and a resolvable Responses endpoint — compaction forwards the full conversation, including provider-native tool-call history replay, to the model's normal Responses streaming endpoint with a trailing `compaction_trigger` input item, and requires exactly one streamed `compaction` output item. The request carries session routing and prompt-cache identifiers (routing/session-id headers plus `prompt_cache_key`) and resolves the model's reasoning effort the same way a normal turn does. Replacement history is Codex-style: retained real user messages within the `compaction.v2RetainedMessageBudget` (default `64000` tokens, clamped to that ceiling) followed by the compaction item, stored in `preserveData.openaiRemoteCompaction` (version `"v2"`). Transient stream errors retry up to `V2_COMPACTION_MAX_RETRIES` (`2`) times with exponential backoff under a 3-minute timeout (`V2_COMPACTION_TIMEOUT_MS`, same as V1); user aborts are never retried. +- **V1 native `/responses/compact`**: for OpenAI/OpenAI Codex models (`shouldUseOpenAiRemoteCompaction`), when remote compaction is enabled and V2 did not run (ineligible or failed), compaction tries the provider-native `/responses/compact` endpoint. It preserves provider replacement history in `preserveData.openaiRemoteCompaction`. A native failure surfaces its transport error instead of silently switching to generic summarization — unless `compaction.remoteEndpoint` is set, in which case summary generation falls through to that endpoint/local summarization. +- **Custom remote endpoint**: if `compaction.remoteEndpoint` is set and remote compaction is enabled, local summary generation POSTs one of two wire formats: - custom omp summarizer endpoints receive `{ systemPrompt, prompt }` and must return JSON containing at least `{ summary }`. - OpenAI-compatible endpoints whose path ends in `/chat/completions` receive `{ model, messages, stream: false }`, where `messages` contains one system prompt and one user prompt. The summary is read from `choices[0].message.content`, which lets self-hosted servers such as llama.cpp and vLLM act as remote compactors without a separate summarizer shim. -- Compatible OpenAI Responses, Azure OpenAI Responses, and Codex models whose catalog metadata enables V2 streaming compaction first append a `compaction_trigger` to a normal Responses stream. The returned compaction item plus retained real user messages become replacement history, bounded by `compaction.v2RetainedMessageBudget`; the replacement is persisted under `preserveData.openaiRemoteCompaction`. -- If V2 is unavailable or fails, eligible OpenAI/OpenAI Codex models try the provider-native `/responses/compact` path. Native failure then falls back to local summarization. + +When a native remote compaction (V2 or V1) succeeds, local LLM summarization is skipped entirely — the durable history lives in the provider replay payload and the stored `summary` is a placeholder lead-in plus the file-operation list. ### Handoff generation @@ -373,6 +377,8 @@ Can: - cancel compaction (`{ cancel: true }`) - provide full custom compaction payload (`{ compaction: CompactionResult }`) +The hook's `customInstructions` carries only the public user focus. Internal summarizer guidance — currently the plan-mode "Approve and compact context" distillation prompt — travels a separate `internalGuidance` channel on `CompactOptions` that reaches only native summarization, never this hook or `session.compacting`; when both are set the summarizer uses `internalGuidance` while hooks still see the public `customInstructions` (issue #4359). + ### `session.compacting` Prompt/context customization hook for default compaction. diff --git a/docs/config-usage.md b/docs/config-usage.md index 4a3e2681e3fa..2d6f833445bf 100644 --- a/docs/config-usage.md +++ b/docs/config-usage.md @@ -194,20 +194,41 @@ Most non-core config loading flows through the capability registry (`src/capabil ## Provider ordering -Providers are sorted by numeric priority (higher first). Example priorities: +Providers are sorted by numeric priority (higher first). Full set: - Native OMP (`builtin.ts`): `100` +- OMP plugins (`omp-plugins`): `90` - Claude: `80` -- Codex / agents / Claude marketplace: `70` +- Agent Plugins standard (`agent-plugins`): `75` +- Codex / agents / Claude plugins marketplace: `70` - Gemini: `60` +- OpenCode: `55` +- Cursor / Windsurf: `50` +- Cline: `40` +- GitHub Copilot: `30` +- VS Code: `20` +- agents-md (`AGENTS.md` files): `10` +- mcp-json / ssh-json: `5` +- Built-in default rules (`builtin-defaults`): `1` ```text Provider precedence (higher wins) -native (.omp) priority 100 -claude priority 80 -codex / agents / ... priority 70 -gemini priority 60 +native (.omp) priority 100 +omp-plugins priority 90 +claude priority 80 +agent-plugins priority 75 +codex / agents / + claude-plugins priority 70 +gemini priority 60 +opencode priority 55 +cursor / windsurf priority 50 +cline priority 40 +github priority 30 +vscode priority 20 +agents-md priority 10 +mcp-json / ssh-json priority 5 +builtin-defaults priority 1 ``` ## Dedup semantics diff --git a/docs/context-files.md b/docs/context-files.md index 4c17a35d9a24..ca61875ed49c 100644 --- a/docs/context-files.md +++ b/docs/context-files.md @@ -10,7 +10,7 @@ Four similarly named things behave differently. Keep them straight: - **Context files** are read as plain Markdown and shown to the agent in generated project instructions (inside `` with the default prompt template). They are session-opening instructions and background for repository work. - **Sticky rules** come from a top-level native `RULES.md`. They are converted into an always-apply rule that is re-attached near the current turn, so they keep their hold even after the visible conversation grows. See "Sticky rules vs normal context" below. -- **Discovery providers** are the config-source adapters (`native`, `claude`, `codex`, `gemini`, `opencode`, `github`, `agents`, `agents-md`) that know where each tool keeps its files. The same provider that contributes context files may also contribute MCP servers, slash commands, skills, hooks, tools, prompts, and settings. +- **Discovery providers** are the config-source adapters that know where each tool keeps its files. The full registry is `native`, `omp-plugins`, `claude`, `agent-plugins`, `codex`, `agents`, `claude-plugins`, `gemini`, `opencode`, `cursor`, `windsurf`, `cline`, `github`, `vscode`, `agents-md`, `mcp-json`, `ssh-json`, and `builtin-defaults`. Only some contribute context files (`native`, `claude`, `codex`, `gemini`, `opencode`, `github`, `agents`, `agents-md`); the rest contribute other capabilities such as rules, MCP servers, skills, commands, hooks, tools, or SSH hosts. The same provider that contributes context files may also contribute MCP servers, slash commands, skills, hooks, tools, prompts, and settings. - **Model providers** are inference backends such as `anthropic`, `openai`, `google`, `groq`, `ollama`, and `openrouter`. They have nothing to do with context files except that both kinds of id share the one `disabledProviders` list — see "Disabling discovery providers" below and [Providers](./providers.md). Authoring **skills** and **rule** files (as opposed to the sticky `RULES.md`) is covered in [Skills](./skills.md). Customizing the system prompt with `SYSTEM.md` is covered in [System prompt customization](./system-prompt-customization.md). @@ -66,23 +66,34 @@ Put broad, durable project background in `AGENTS.md`. Reserve `RULES.md` for sho | `github` | `.github/copilot-instructions.md` | User + project | Project file `/.github/copilot-instructions.md` only (no ancestor walk-up), plus a user-global `~/.copilot/copilot-instructions.md` (relocate with `COPILOT_HOME`). `AGENTS.md` candidates from `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` are also considered at user scope, where normal one-user-file deduplication applies. | | `agents` | `.agent/AGENTS.md`, `.agents/AGENTS.md` | User + project | User files from `~/.agent/` and `~/.agents/`; project files discovered while walking up from the current directory to the repository root. | | `agents-md` | `AGENTS.md` | Project | Standalone (non-config-directory) `AGENTS.md` files, discovered by walking up from the current directory to the repository root and, when that repository is nested under the user's home directory, through enclosing workspace directories up to but not including the home directory. With no repository root, discovery uses the home directory as the boundary for sessions under home and includes that boundary file. Files whose parent directory name starts with `.` are ignored — those belong to a config-directory provider instead. | +| `claude-md` | `CLAUDE.md` | Project | Standalone (non-config-directory) `CLAUDE.md` files, discovered by walking up from the current directory to the repository root and, when that repository is nested under the user's home directory, through enclosing workspace directories up to but not including the home directory. With no repository root, discovery uses the home directory as the boundary for sessions under home and includes that boundary file. Files whose parent directory name starts with `.` are ignored — those belong to a config-directory provider instead. | | `github` | `.github/instructions/**/*.instructions.md` | Project rules | GitHub Copilot / VS Code instruction files become rules. `applyTo: '*'`, `applyTo: '**'`, or `applyTo: '**/*'` is injected as always-apply content; other `applyTo` globs are listed in the rulebook with a generated description when needed and are readable as `rule://`. Missing `applyTo` also produces a rulebook entry and a discovery warning. | -Providers marked "(no ancestor walk-up)" only look in the current working directory's config directory. If you need ancestor walk-up behavior, prefer the native `.omp/AGENTS.md` format or a standalone `AGENTS.md` (the `agents-md` provider), or launch `omp` from the directory that holds the config directory. +Providers marked "(no ancestor walk-up)" only look in the current working directory's config directory. If you need ancestor walk-up behavior, prefer the native `.omp/AGENTS.md` format or a standalone `AGENTS.md` or `CLAUDE.md` (the `agents-md` / `claude-md` providers), or launch `omp` from the directory that holds the config directory. -## Load order and shadowing +The discovery registry also holds providers that contribute no context files at all: `cursor` (`.cursor/rules/*.mdc` and legacy `.cursorrules` rules, plus MCP servers and settings), `windsurf` (`.windsurf/rules/*.md`, legacy `.windsurfrules`, and global Windsurf rules, plus MCP servers), `cline` (`.clinerules` rules), `vscode` and `mcp-json` (MCP servers), `claude-plugins` (Claude marketplace plugins: skills, commands, rules, hooks, tools, MCP servers), `omp-plugins` (OMP plugins: skills, commands, rules, prompts, hooks, tools, MCP servers), `agent-plugins` (Agent Plugins standard packages: skills and MCP servers), `ssh-json` (SSH hosts), and `builtin-defaults` (built-in default rules). These become relevant for rules and other capabilities, and for the shared `disabledProviders` switch below. -When two providers describe the _same_ scope, the higher-priority provider wins. Provider priorities: +## Load order and shadowing -| Priority | Provider id | -| -------: | ----------------- | -| 100 | `native` | -| 80 | `claude` | -| 70 | `agents`, `codex` | -| 60 | `gemini` | -| 55 | `opencode` | -| 30 | `github` | -| 10 | `agents-md` | +When two providers describe the _same_ scope, the higher-priority provider wins. Full registry priorities: + +| Priority | Provider id | +| -------: | -------------------------------------------------- | +| 100 | `native` | +| 90 | `omp-plugins` | +| 80 | `claude` | +| 75 | `agent-plugins` | +| 70 | `agents`, `claude-plugins`, `codex` | +| 60 | `gemini` | +| 55 | `opencode` | +| 50 | `cursor`, `windsurf` | +| 40 | `cline` | +| 30 | `github` | +| 20 | `vscode` | +| 10 | `agents-md` | +| 10 | `claude-md` | +| 5 | `mcp-json`, `ssh-json` | +| 1 | `builtin-defaults` | Discovered files are then deduplicated by scope: @@ -192,7 +203,7 @@ disabledProviders: | Id kind | Examples | Effect when listed | | ---------------------- | ---------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| Discovery provider ids | `native`, `claude`, `codex`, `gemini`, `opencode`, `github`, `agents`, `agents-md` | The entire config source is removed — not just its context files, but also any MCP servers, slash commands, skills, hooks, tools, prompts, and settings it would have contributed. | +| Discovery provider ids | `native`, `claude`, `codex`, `gemini`, `opencode`, `github`, `agents`, `agents-md`, `claude-md` | The entire config source is removed — not just its context files, but also any MCP servers, slash commands, skills, hooks, tools, prompts, and settings it would have contributed. | | Model provider ids | `anthropic`, `openai`, `google`, `groq`, `ollama`, `openrouter` | The model backend is removed from selection even when its credentials are present. See [Providers](./providers.md). | Ids are exact and the two namespaces do not collide by accident: `google` disables the Google model backend, while `gemini` disables the Gemini CLI discovery files. Disabling a discovery provider is heavier than it looks — disabling `claude`, for instance, also drops Claude-discovered MCP servers, commands, skills, hooks, tools, and settings, not only `CLAUDE.md`. To drop the context file alone and keep everything else the provider contributes, use [`disabledExtensions`](#disabling-a-single-context-file) instead. @@ -247,7 +258,7 @@ Browse the ids interactively with `/extensions`, which lists every discovered co ### A file is not loaded - Native project context is read only from the nearest non-empty `.omp/` directory. That directory must contain a non-empty `AGENTS.md`; if it does not, discovery does not continue to a farther native directory. -- A standalone `AGENTS.md` is handled by `agents-md`, not `native`. +- A standalone `CLAUDE.md` is handled by `claude-md`, not `native`. - `.claude/CLAUDE.md`, `.gemini/GEMINI.md`, and `.github/copilot-instructions.md` are read only from the current working directory's config directory — not from every ancestor. - `~/.codex/AGENTS.md` and `~/.config/opencode/AGENTS.md` are user-level only and have no project equivalent. - Empty files contribute nothing for the native and standalone providers. @@ -256,7 +267,7 @@ Browse the ids interactively with `/extensions`, which lists every discovered co ### The wrong file wins -At one user scope or project depth, the higher-priority provider shadows the others (native > claude > agents/codex > gemini > opencode > github > agents-md). To force deterministic behavior, move your guidance into `.omp/AGENTS.md` (native always wins) or disable the competing discovery provider. +At one user scope or project depth, the higher-priority provider shadows the others (native > claude > agents/codex > gemini > opencode > github > agents-md > claude-md). To force deterministic behavior, move your guidance into `.omp/AGENTS.md` (native always wins) or disable the competing discovery provider. ### User context disappeared diff --git a/docs/environment-variables.md b/docs/environment-variables.md index d3a8398cb9c2..90855d2fcd86 100644 --- a/docs/environment-variables.md +++ b/docs/environment-variables.md @@ -38,6 +38,7 @@ These are consumed via `getEnvApiKey()` (`packages/ai/src/stream.ts`) unless not | `ANTHROPIC_API_KEY` | Anthropic API auth | Using Anthropic without OAuth token | Fallback after `ANTHROPIC_OAUTH_TOKEN` | | `ANTHROPIC_FOUNDRY_API_KEY` | Anthropic via Azure Foundry / enterprise gateway | `CLAUDE_CODE_USE_FOUNDRY` enabled | Takes precedence over `ANTHROPIC_OAUTH_TOKEN` and `ANTHROPIC_API_KEY` when Foundry mode is enabled | | `OPENAI_API_KEY` | OpenAI auth | Using OpenAI-family providers without explicit apiKey argument | Used by OpenAI Completions/Responses providers | +| `OPENAI_CODEX_OAUTH_TOKEN` | OpenAI Codex auth | Using `openai-codex` provider | Environment-supplied Codex OAuth token | | `GEMINI_API_KEY` | Google Gemini auth | Using `google` provider models | Primary key for Gemini provider mapping | | `GOOGLE_API_KEY` | Gemini image tool auth fallback | Using `gemini_image` tool without `GEMINI_API_KEY` | Used by coding-agent image tool fallback path | | `GROQ_API_KEY` | Groq auth | Using Groq models | | @@ -61,7 +62,7 @@ These are consumed via `getEnvApiKey()` (`packages/ai/src/stream.ts`) unless not | `XIAOMI_TOKEN_PLAN_AMS_API_KEY` | Xiaomi MiMo Token Plan auth (AMS) | Using `xiaomi-token-plan-ams` provider | | | `XIAOMI_TOKEN_PLAN_CN_API_KEY` | Xiaomi MiMo Token Plan auth (CN) | Using `xiaomi-token-plan-cn` provider | | | `XIAOMI_TOKEN_PLAN_SGP_API_KEY` | Xiaomi MiMo Token Plan auth (SGP) | Using `xiaomi-token-plan-sgp` provider | | -| `MOONSHOT_API_KEY` | Moonshot auth | Using `moonshot` provider | | +| `MOONSHOT_API_KEY` | Moonshot auth | Using `moonshot` provider | `KIMI_API_KEY` is accepted as a fallback alias | | `XAI_API_KEY` | xAI auth | Using xAI models or as fallback for `xai-oauth` | | | `XAI_OAUTH_TOKEN` | xAI OAuth/SuperGrok auth | Using `xai-oauth` provider | Takes precedence over `XAI_API_KEY` for `xai-oauth` | | `OPENROUTER_API_KEY` | OpenRouter auth | Using OpenRouter models | Also used by image tool when preferred/auto provider is OpenRouter | @@ -78,9 +79,11 @@ These are consumed via `getEnvApiKey()` (`packages/ai/src/stream.ts`) unless not | `QWEN_PORTAL_API_KEY` | Qwen Portal auth | Using `qwen-portal` with API key | Fallback after `QWEN_OAUTH_TOKEN` | | `ZENMUX_API_KEY` | ZenMux auth | Using `zenmux` provider | Used for ZenMux OpenAI and Anthropic-compatible routes | | `VLLM_API_KEY` | vLLM auth/discovery opt-in | Using `vllm` provider (local OpenAI-compatible servers) | Any non-empty value works for no-auth local servers | -| `CURSOR_ACCESS_TOKEN` | Cursor provider auth | Using Cursor provider | | -| `AI_GATEWAY_API_KEY` | Vercel AI Gateway auth | Using `vercel-ai-gateway` provider | | -| `CLOUDFLARE_AI_GATEWAY_API_KEY` | Cloudflare AI Gateway auth | Using `cloudflare-ai-gateway` provider | Base URL must be configured as `https://gateway.ai.cloudflare.com/v1///anthropic` | +| `CURSOR_ACCESS_TOKEN` | Cursor provider auth | Using Cursor provider | `CURSOR_API_KEY` is accepted as an alias | +| `AI_GATEWAY_API_KEY` | Vercel AI Gateway auth | Using `vercel-ai-gateway` provider | `VERCEL_AI_GATEWAY_API_KEY` is accepted as an alias | +| `CLOUDFLARE_AI_GATEWAY_API_KEY` | Cloudflare AI Gateway auth | Using `cloudflare-ai-gateway` provider | Gateway token with AI Gateway Run permission; `/login` stores it with the routing IDs | +| `CLOUDFLARE_ACCOUNT_ID` | Cloudflare AI Gateway account routing | Using an environment-supplied gateway token | Not required when the account ID was stored by `/login` | +| `CLOUDFLARE_GATEWAY_ID` | Cloudflare AI Gateway selection | Using an environment-supplied gateway token | Gateway slug, commonly `default`; not required when stored by `/login` | | `ALIBABA_CODING_PLAN_API_KEY` | Alibaba Coding Plan auth | Using `alibaba-coding-plan` provider | | | `ALIBABA_TOKEN_PLAN_API_KEY` | QwenCloud Token Plan auth | Using `alibaba-token-plan` provider | Preferred provider-specific name | | `BAILIAN_TOKEN_PLAN_API_KEY` | QwenCloud Token Plan auth | Using `alibaba-token-plan` provider | Compatible with Qwen Code's Token Plan preset | @@ -90,8 +93,17 @@ These are consumed via `getEnvApiKey()` (`packages/ai/src/stream.ts`) unless not | `SILICONFLOW_CN_API_KEY` | SiliconFlow (China) auth | Using `siliconflow-cn` provider | | | `KILO_API_KEY` | Kilo auth | Using Kilo models | | | `OLLAMA_CLOUD_API_KEY` | Ollama Cloud auth | Using `ollama-cloud` provider | | +| `CLINE_API_KEY` | ClinePass subscription + free-tier auth | Using the `cline-pass` provider | Official Cline API-key variable | +| `YOLO_AUTO_API_KEY` | Yolo-Auto auth | Using `yolo-auto` provider | Flat-rate Qwen models; validated against `https://yolo-auto.com/v1/models` | | `WAFER_SERVERLESS_API_KEY` | Wafer Serverless auth | Using `wafer-serverless` provider | Pay-as-you-go Wafer SKU; validated against `https://pass.wafer.ai/v1/models` | -| `GITLAB_TOKEN` | GitLab Duo auth | Using `gitlab-duo` provider | | +| `GITLAB_TOKEN` | GitLab Duo auth | Using `gitlab-duo` / `gitlab-duo-agent` providers | Both GitLab providers read the same token | +| `BASETEN_API_KEY` | Baseten auth | Using `baseten` provider | Also configured via the interactive API-key login (`/login baseten`, key from the Baseten dashboard) | +| `COREWEAVE_API_KEY` / `WANDB_API_KEY` | CoreWeave Serverless Inference auth | Using `coreweave` provider | Either variable works (W&B fallback). `COREWEAVE_PROJECT` (fallback `WANDB_INFERENCE_PROJECT`) supplies the required `OpenAI-Project` header | +| `SAKANA_API_KEY` / `FUGU_API_KEY` | Sakana AI auth | Using `sakana` provider | Either variable works; `SAKANA_BASE_URL` / `FUGU_BASE_URL` override the request base URL | +| `DEVIN_API_KEY` | Devin auth | Using `devin` provider | Also available via the interactive login (`/login devin`, OAuth) | +| `AIAND_API_KEY` | ai& auth | Using `aiand` provider | | +| `GMI_API_KEY` | GMI Cloud auth | Using `gmi-cloud` provider | | +| `MODEL_API_KEY` / `META_API_KEY` | Meta Model API auth | Using `meta` provider | Either variable works | ### GitHub/Copilot tokens @@ -332,6 +344,8 @@ therefore completes through the paste-code path. | Variable | Used by | | --------------------------------------------------- | ------------------------------------------------------------------------- | | `EXA_API_KEY` | Exa search/MCP; alternatively use `/login exa` | +| `TINYFISH_API_KEY` | TinyFish search provider (required) | +| `FIRECRAWL_API_KEY` | Firecrawl search provider; when unset Firecrawl falls back to keyless mode | | `BRAVE_API_KEY` | Brave search provider | | `PERPLEXITY_API_KEY` | Perplexity search provider API-key mode | | `PERPLEXITY_COOKIES` | Perplexity cookie-auth search mode | @@ -353,6 +367,8 @@ therefore completes through the paste-code path. | `SEARXNG_ENDPOINT`, `SEARXNG_TOKEN` | SearXNG endpoint and optional bearer token | | `SEARXNG_BASIC_USERNAME`, `SEARXNG_BASIC_PASSWORD` | SearXNG HTTP Basic Auth credentials | +DuckDuckGo search is keyless — it queries the no-JS HTML frontend (`html.duckduckgo.com`) and needs no credentials; it also feeds the credential-free `public` aggregate (alongside startpage, google, ecosia, and mojeek). + SearXNG also reads the equivalent `searxng.endpoint`, `searxng.token`, `searxng.basicUsername`, and `searxng.basicPassword` settings from `~/.omp/agent/config.yml`; environment variables are fallbacks. ### Anthropic web search auth chain @@ -425,6 +441,7 @@ Python subprocess filtering denies common API keys and allows safe base variable | `PI_SUBPROCESS_CMD` | Overrides subagent spawn command (`omp` / `omp.cmd` resolution bypass) | | `PI_TASK_MAX_OUTPUT_BYTES` | Max captured output bytes per subagent (default `500000`) | | `PI_TASK_MAX_OUTPUT_LINES` | Max captured output lines per subagent (default `5000`) | +| `PI_WALK_WORKERS` | Filesystem walker worker count used by the `omp grep` walker and related parallel traversal (`pi-walker`; default `4`; `0` = auto-detect, `1` = serial). Renamed from `PI_GREP_WORKERS`; the old name is no longer read | | `PI_TIMING` | If set (any non-empty value), prints a hierarchical timing-span tree to **stderr** via `logger.printTimings()`. In interactive mode the tree prints once the agent is ready (before the TUI starts); in print mode it prints after the whole prompt batch completes. Print-mode prompts are wrapped in `print:prompt:initial` / `print:prompt:next` spans so each user message shows up as its own row. `PI_TIMING=x` exits the process with code 0 right after printing in interactive mode (use to measure cold startup only). `PI_TIMING=full` lists every module-load entry instead of just the top N. | | `PI_DEBUG_STARTUP` | If set (any non-empty value), streams one synchronous `[startup] :start` / `:done` marker line to **stderr** as each startup phase begins/ends — including command-module imports (`cli:load:`) and the native addon extraction/`dlopen` (`native:*`). Unlike `PI_TIMING` (which prints only once startup completes), the markers survive a hard hang: the last line on stderr names the phase the process is stuck in. Combine with `PI_TIMING` freely; markers and the span tree share the same phase names. | | `PI_PACKAGE_DIR` | Overrides package asset base dir resolution (`docs/`, `examples/`, `CHANGELOG.md`) | diff --git a/docs/extension-loading.md b/docs/extension-loading.md index 4c2c9871a1e7..eef0a3027a10 100644 --- a/docs/extension-loading.md +++ b/docs/extension-loading.md @@ -225,8 +225,8 @@ Implication: if the same module path is both auto-discovered and explicitly conf Each candidate path is loaded via `loadLegacyPiModule()` (`src/extensibility/plugins/legacy-pi-compat.ts`): -- the entry's realpath is resolved, then dynamically imported with an `?mtime` cache-buster so edited source reloads -- a scoped Bun `onLoad` hook rewrites legacy pi-package specifiers (`@mariozechner/*`, `@earendil-works/*`) and bare `@sinclair/typebox` onto the host-bundled copies before evaluation +- the entry's realpath is resolved, then dynamically imported with an `?mtime` cache-buster so edited source reloads. Since 16.3.7 the same mtime tag propagates to every module in the extension-owned dependency graph — relative `./`/`../` imports, package `imports` aliases (`#alias/*`), and extension-local bare dependencies — via the graph-wide `onLoad` rewrite, so same-process re-imports pick up edits across the whole graph, not just the entry file. Host-resolved rewrites (legacy pi-package specifiers, the TypeBox shim) stay untagged `file://` URLs because they point at in-process host code that never changes between reloads +- a scoped Bun `onLoad` hook rewrites legacy pi-package specifiers (`@mariozechner/*`, `@earendil-works/*`) and bare `@sinclair/typebox` onto the host-bundled copies before evaluation. Legacy Pi package-root imports resolve through compat shims: catalog symbols that moved to `@oh-my-pi/pi-catalog/models` (`calculateCost`, `modelsAreEqual`, `getBundledProviders`, plus `getModel`/`getModels` aliases) are re-exported by the legacy pi-ai shim (`src/extensibility/legacy-pi-ai-shim.ts`), and legacy `@oh-my-pi/pi-coding-agent` imports — including `DefaultResourceLoader` — resolve to the compat loader in `src/extensibility/legacy-pi-coding-agent-shim.ts` - factory is selected by `getExtensionFactory(module)`: the module itself if it is a function, otherwise `module.default` - factory must be a function (`ExtensionFactory`) and may return `void` or a promise; loading awaits it before continuing to the next path diff --git a/docs/extensions.md b/docs/extensions.md index bf313d537336..66e42e7529e1 100644 --- a/docs/extensions.md +++ b/docs/extensions.md @@ -171,6 +171,8 @@ long as that extension registration is active. `pi.unregisterProvider(name)` (an extension source cleanup) removes only that runtime override, restoring the built-in or configured usage resolver. +Extension-registered providers (`registerProvider`) can supply `fetchDynamicModels` for runtime model discovery; these fetches are hard-bounded to a 15-second timeout (`RUNTIME_DYNAMIC_MODEL_FETCH_TIMEOUT_MS` in `model-provider-discovery.ts`) so a hung endpoint cannot stall discovery. + In interactive mode, `input` handlers run before the built-in first-message auto-title check. Extensions that call `await pi.setSessionName(...)` from `input` can set the persisted session name and prevent the default auto-generated title from running for that session. Also exposed: @@ -192,6 +194,8 @@ Also exposed: `pi.sendUserMessage(content, { deliverAs })` always goes through prompt flow. Omit `deliverAs` to start a normal prompt when idle; while streaming, omitted `deliverAs` queues the message as a steer. Set `deliverAs: "followUp"` to wait until the current run finishes. +Payloads passed to `pi.sendMessage` are normalized before delivery (`normalizeCustomMessagePayload` in `session/messages.ts`): non-object payloads are coerced to string content under the default custom type, missing `customType`/`attribution` fields are defaulted, and invalid content collapses to an empty string — malformed payloads no longer persist entries that crash later session resumes. + ## 2) Handler context (`ExtensionContext`) Handlers and tool `execute` receive `ctx` with: @@ -293,7 +297,7 @@ Cancelable pre-events: - `after_provider_response` - `context` - `agent_start` / `agent_end` — agent loop lifecycle notification; `agent_end` remains notification-only -- `session_stop` — main-session stop hook, awaited before settle; may continue with `{ continue: true, additionalContext }` or `{ decision: "block", reason }`; capped at 8 consecutive continuations and never fires for task/subagent sessions +- `session_stop` — main-session stop hook, awaited before settle; may continue with `{ continue: true, additionalContext }` or `{ decision: "block", reason }`; capped at 8 consecutive continuations, never fires for task/subagent sessions, and defers until agent-owned background jobs are fully idle (`#hasPendingAsyncWake` in `session/agent-session.ts`) - `turn_start` / `turn_end` - `message_start` / `message_update` / `message_end` — lifecycle notifications; `message_end` receives a detached message snapshot, so use `tool_result` or `context` when an extension needs to change provider context @@ -566,7 +570,7 @@ Current no-op methods in this controller: - `setFooter` - `setHeader` -`setEditorComponent` is wired to the live editor (`ctx.setEditorComponent(factory)`). `setWidget` renders real widget components above or below the editor via `setHookWidget(...)` (`placement: "aboveEditor" | "belowEditor"`; string-array content capped at 10 lines). +`setEditorComponent` is wired to the live editor (`ctx.setEditorComponent(factory)`). `setWidget` renders real widget components above or below the editor via `setHookWidget(...)` (`placement: "aboveEditor" | "belowEditor"`; string-array content capped at 10 lines). `setEditorText` and `pasteToEditor` schedule a repaint after mutating the editor, so prompt changes don't leave stale content on screen. ### RPC mode (`rpc-mode.ts`) diff --git a/docs/fs-scan-cache-architecture.md b/docs/fs-scan-cache-architecture.md index 434cdc9fd2ba..8126a9a52758 100644 --- a/docs/fs-scan-cache-architecture.md +++ b/docs/fs-scan-cache-architecture.md @@ -14,7 +14,7 @@ Current native consumers: `crates/pi-natives/src/grep.rs` uses `WalkRequest` for candidate discovery but explicitly sets `.cache(false)`; the current public `GrepOptions` has no cache field. -The public invalidation binding remains `invalidateFsScanCache(path?)` in `packages/natives/native/index.d.ts` / `index.js`. Coding-agent mutation helpers live in `packages/coding-agent/src/tools/fs-cache-invalidation.ts`. +The N-API DTO layer that bridges walker results to JavaScript lives in `crates/pi-natives/src/iofs.rs`; per its own header, "`pi-walker` owns traversal and cache policy" and `iofs.rs` keeps only the JS-facing shapes and conversions. The public invalidation binding remains `invalidateFsScanCache(path?)` — declared in `iofs.rs` (forwarding to `pi_walker::invalidate_path_string` / `pi_walker::invalidate_all`) and exported in `packages/natives/native/index.d.ts` / `index.js`. Coding-agent mutation helpers live in `packages/coding-agent/src/tools/fs-cache-invalidation.ts`. ## Cache key partitioning @@ -98,7 +98,7 @@ Coding-agent helpers: - `invalidateFsScanAfterDelete(path)` - `invalidateFsScanAfterRename(oldPath, newPath)` — invalidates both sides when different -Current write, hashline, patch, and replace mutation paths call these helpers after successful changes. Any new filesystem mutation path must do the same. +Current write, hashline, patch, replace, auto-repair, sloppy-edit, and ACP-bridge mutation paths call these helpers after successful changes. Any new filesystem mutation path must do the same. ## Adding a cache consumer diff --git a/docs/lsp-config.md b/docs/lsp-config.md index 51303fe406ea..916e6b05d4d5 100644 --- a/docs/lsp-config.md +++ b/docs/lsp-config.md @@ -233,6 +233,7 @@ The following servers ship in `defaults.json` and are eligible for auto-detectio | `pyright` | Python | `pyright-langserver` | | `basedpyright` | Python | `basedpyright-langserver` | | `pylsp` | Python | `pylsp` | +| `ty` | Python | `ty` | | `ruff` | Python (linter) | `ruff` | | `jdtls` | Java | `jdtls` | | `kotlin-lsp` | Kotlin | `kotlin-lsp` | diff --git a/docs/marketplace.md b/docs/marketplace.md index a1d0d510fc3e..950c53281b7d 100644 --- a/docs/marketplace.md +++ b/docs/marketplace.md @@ -15,7 +15,7 @@ In the TUI, `/marketplace` with no arguments opens the interactive plugin browse A **marketplace** is a Git repository (or local directory) containing a catalog file at `.omp-plugin/marketplace.json` (preferred) or `.claude-plugin/marketplace.json` (Claude Code-compatible fallback). The catalog lists available plugins with their sources, descriptions, and metadata. -A **plugin** is a directory containing Claude/OMP plugin content such as skills, commands, agents, hooks, tools, MCP servers, or LSP servers. Marketplace installs also load extension modules declared by `package.json` `omp.extensions`: installation symlinks the cached plugin into the scope's `node_modules` tree and records it in `omp-plugins.lock.json`, the same runtime surfaces used by npm-installed and `omp plugin link`ed plugins. Plugins are identified by `name@marketplace` (e.g. `code-review@claude-plugins-official`). +A **plugin** is a directory containing Claude/OMP plugin content such as skills, commands, agents, rules, hooks, tools, MCP servers, or LSP servers. Marketplace installs also load extension modules declared by `package.json` `omp.extensions`: installation symlinks the cached plugin into the scope's `node_modules` tree and records it in `omp-plugins.lock.json`, the same runtime surfaces used by npm-installed and `omp plugin link`ed plugins. Plugins are identified by `name@marketplace` (e.g. `code-review@claude-plugins-official`). **Scopes**: marketplace plugins can be installed at two scopes: diff --git a/docs/mcp-server-tool-authoring.md b/docs/mcp-server-tool-authoring.md index 2d23f27da25e..4c216fd9ab96 100644 --- a/docs/mcp-server-tool-authoring.md +++ b/docs/mcp-server-tool-authoring.md @@ -146,6 +146,8 @@ Rules: - non-`[a-z_]` chars become `_` - repeated underscores collapse - redundant `_` prefix in tool name is stripped once +- names longer than 64 characters keep a readable prefix and append `_` plus the first eight base-36 + characters of `Bun.hash()` over the full uncapped generated name Different raw names can still sanitize to the same identifier (for example `my-server` and `my.server` both sanitize similarly). Before registry diff --git a/docs/memory.md b/docs/memory.md index 000e94d09087..6dae4e3f62b4 100644 --- a/docs/memory.md +++ b/docs/memory.md @@ -1,6 +1,6 @@ # Autonomous Memory -Oh My Pi supports four memory modes. Memory is disabled by default; select one backend via `/settings` or `config.yml`: +Oh My Pi supports five memory modes. Memory is disabled by default; select one backend via `/settings` or `config.yml`: | `memory.backend` | Storage and behavior | Guide | | ---------------- | ---------------------------------------------------------------------- | ------------------------------------------------------- | @@ -8,6 +8,7 @@ Oh My Pi supports four memory modes. Memory is disabled by default; select one b | `local` | Project-scoped summaries and lessons generated from persisted sessions | This page | | `hindsight` | Remote, bank-scoped Hindsight memory | [Hindsight](#hindsight-remote-backend) | | `mnemopi` | Local Mnemopi SQLite memory | [Mnemopi memory backend](./mnemosyne-memory-backend.md) | +| `sharpshooter` | Friction-gated project decision files (architecture/product/style), consolidated in the background | — | Enable the local summary pipeline: @@ -36,6 +37,9 @@ The agent can read memory files directly using `memory://` URLs with the `read` | `memory://root/MEMORY.md` | Full long-term memory document | | `memory://root/learned.md` | Lessons captured by the `learn` tool | | `memory://root/skills//SKILL.md` | A generated skill playbook | +| `memory://` | Full Mnemopi memory row (working or episodic) with a YAML frontmatter metadata header; only available when `memory.backend` is `mnemopi` | + +The `memory://` form returns the full stored row rather than the clipped recall preview (recall content that exceeds the preview cap ends with a trailing `…`); agents are instructed to read it before any `memory_edit update`. ### `/memory` slash command @@ -44,8 +48,11 @@ The agent can read memory files directly using `memory://` URLs with the `read` | `view` | Show the current backend injection payload | | `stats` | Show backend-specific memory statistics, when supported | | `diagnose` | Show backend-specific diagnostics, when supported | +| `queue` | Show pending memory deltas awaiting consolidation | +| `sync` | Run memory consolidation now | | `clear` / `reset` | Delete active backend memory data/artifacts | | `enqueue` / `rebuild` | Force consolidation/retention work for the active backend | +| `mm …` | Hindsight mental-model maintenance (`list`/`show`/`refresh`/`history`/`seed`/`delete`/`reload`); unsupported in ACP mode | ### Capturing lessons diff --git a/docs/mnemosyne-memory-backend.md b/docs/mnemosyne-memory-backend.md index 204af8c9a469..cb1c61db34aa 100644 --- a/docs/mnemosyne-memory-backend.md +++ b/docs/mnemosyne-memory-backend.md @@ -78,6 +78,14 @@ The coding-agent wrapper applies scoping on top of the underlying `Mnemopi` pack The combined project-plus-global behavior lives in the wrapper. The `@oh-my-pi/pi-mnemopi` package itself still exposes banks and constructor options directly, including `bank` for selecting a bank name. Project-local banks other than the shared bank are stored as sibling bank databases managed by Mnemopi's `BankManager`. +## Recall previews and full-row reads + +Recall results carry clipped content previews, not full rows. Content longer than the preview cap is truncated with a trailing `…`; the result also sets `truncated: true` and `full_length` (original character count), so callers can detect clipping without parsing the marker. The cap is `RecallOptions.contentPreviewChars` (default `500`; `0` disables clipping). + +The full row is always reachable by reading `memory://`, which resolves the live working or episodic row and returns its full content behind a small YAML frontmatter header (`id`, `bank`, `store`, `memory_type`, timestamps, `importance`, `veracity`, `session_id`, `metadata`). The coding-agent's model-facing prompts require this read before any `memory_edit update`, since `update` replaces content wholesale and would otherwise discard the unseen tail of a clipped preview. + +Retention writes a marker-free transcript projection: when the host supplies an `embedText` override alongside the stored transcript, that projection is used for embedding, working-memory FTS indexing (`COALESCE(embed_text, content)`), and rebuild-reembedding, so retention protocol markers in the stored transcript do not pollute vector and full-text recall. + ## LLM and embeddings FTS and embedding paths use the settings below. LLM-backed extraction/consolidation uses the configured local on-device memory model (`providers.memoryModel`) when selected, otherwise `llmMode: smol` resolves the `tiny` role first and then `smol`; `llmMode: remote` uses the OpenAI-compatible endpoint settings; `llmMode: none` disables LLM calls. If no tiny/smol model or current credential resolves, Mnemopi continues without LLM-backed work. diff --git a/docs/models.md b/docs/models.md index 05e1db0a191c..eabf1852d49e 100644 --- a/docs/models.md +++ b/docs/models.md @@ -85,6 +85,11 @@ providers: controller: mlx ``` +### Compaction options + +- `compactionModel` (per model, including `modelOverrides`) — selector for the model used to summarize/compact context when this model's session is compacted, instead of the model itself. +- `remoteCompaction` (provider level or per model) — opts eligible models into provider-native compaction. Supported keys: `enabled`, `api`, `endpoint`, `model`, `v2StreamingEnabled`, `v2Endpoint`, `streamingEndpoint`. Provider-level settings are the baseline; per-model keys override them. + ### Allowed provider/model `api` values - `openai-completions` @@ -170,7 +175,7 @@ ModelRegistry pipeline (on refresh): 5. Merge custom `models`: - same `provider + id` replaces existing - otherwise append -6. Load cached/runtime-discovered models (Ollama, llama.cpp, LM Studio, plus built-in provider managers), then re-apply model overrides. +6. Load cached and runtime-discovered models. This includes local servers, built-in provider managers, and the shared models.dev catalog for known providers. Re-apply model overrides after the merge. ### Provider-model cache and static fingerprint @@ -183,6 +188,14 @@ the static + dynamic merge is bypassed entirely. The fingerprint is memoized per process by tagging the static-models array with a symbol property, so repeated cold-start calls do not re-hash. +### Shared catalog refresh + +The bundled catalog remains the startup and offline baseline. After startup loads bundled and cached rows synchronously, the existing background refresh lifecycle fetches the current shared models.dev catalog for known providers. New model IDs are merged additively into each provider's bundled slice, normalized through that provider's catalog descriptor, and persisted in the model-cache database. This allows newly published models to appear without waiting for a new OMP binary. + +Remote rows can supply current limits, pricing, modalities, and capability flags for newly added IDs, but they cannot introduce code, arbitrary headers, or an unregistered provider. A successful provider endpoint discovery remains authoritative for account availability. The shared catalog is not authoritative: it does not remove bundled models when a remote row disappears. + +Fresh cached snapshots avoid a network request. If refresh fails, OMP keeps the last usable cached snapshot and marks it stale; without a cache, it falls back to the bundled catalog. Provider discovery state records `source` (`bundled`, `models.dev`, `provider`, or `cache`) and `fetchedAt` so callers can distinguish current remote data from an offline fallback. + ## Provider and model identity The registry retains concrete `provider` + `id` identities. Use an exact @@ -377,6 +390,22 @@ So a model can exist in registry but not be selectable until auth is available. `--provider` is legacy; `--model` is preferred. An exact `provider/modelId` is unambiguous; bare ids and fuzzy patterns are resolved against the available concrete models. +Resolution precedence for exact selectors: + +1. exact `provider/modelId` reference +2. exact bare id (case-insensitive); when several providers carry the same id, a preference ranking picks the winner (see below) +3. retired effort-tier variant alias (collapsed catalog entries, e.g. `X`/`X-thinking` twins) +4. provider-scoped fuzzy match, then substring matching with an alias-vs-dated pick + +Glob scope patterns (used by `enabledModels` and CLI `--models`) run separately over concrete models after exact matching. + +When a bare id matches models from multiple providers, preference order is: + +1. recently used model variants +2. provider priority (`modelProviderOrder` setting, then built-in catalog provider priority) +3. recently used providers +4. registry order + ### Initial model selection priority `findInitialModel(...)` uses this order: @@ -429,8 +458,12 @@ String entries apply everywhere. Scoped entries apply when the current working d ## `/model` and `omp models` -Both surfaces keep provider-prefixed concrete models visible and selectable. Selecting a provider -row stores its explicit `provider/modelId`. +Both surfaces keep provider-prefixed concrete models visible and selectable. + +- `/model` shows an all-models view plus one view per provider +- `omp models` (default `ls` action) prints provider-grouped tables of every available model; `omp models find ` filters by provider, id, or name; `omp models refresh` forces an online catalog re-fetch ignoring the model cache TTL; any provider name doubles as an `ls` filter (e.g. `omp models openai-codex`). Flags: `--json`, `-e ` (load extension, repeatable), `--no-extensions`, `--config ` (extra config overlay, repeatable) + +Selecting a provider row stores its explicit `provider/modelId`. ## Context promotion (model-level fallback chains) @@ -514,6 +547,11 @@ Request shaping: Reasoning / thinking: +Custom model entries may define `thinking: { mode, efforts, defaultLevel, requiresEffort }`. +`requiresEffort` defaults to auto-detection; set it to `false` only when the +configured backend has been verified to accept an explicit reasoning-off +request. This keeps the `:off` selector from being clamped to the lowest effort. + - `supportsReasoningEffort` — accept `reasoning_effort`. Default: auto (off for Grok, Z.ai/Zhipu, and Xiaomi MiMo). - `supportsReasoningParams` — whether request shaping may send reasoning params at all. Default: auto (off for GitHub Copilot chat-completions). - `reasoningEffortMap` — partial map from internal effort levels (`minimal|low|medium|high|xhigh|max`) to provider-specific strings (e.g. Fireworks GLM maps `minimal -> "none"`). diff --git a/docs/native-crates.md b/docs/native-crates.md index 8f206f4f5249..01de4391c99b 100644 --- a/docs/native-crates.md +++ b/docs/native-crates.md @@ -8,13 +8,14 @@ The root `Cargo.toml` lists every crate under `crates/` explicitly in `workspace | Crate | Path | Role and consumers | | --------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| `pi-natives` | [`crates/pi-natives`](../crates/pi-natives) | Top-level N-API `cdylib`. It exposes the JS-visible API and depends on `pi-ast`, `pi-iso`, `pi-shell`, `pi-voice`, and `pi-walker`. | +| `pi-natives` | [`crates/pi-natives`](../crates/pi-natives) | Top-level N-API `cdylib`. It exposes the JS-visible API and depends on `pi-ast`, `pi-iso`, `pi-shell`, `pi-vcs`, `pi-voice`, and `pi-walker`. | | `pi-builtins` | [`crates/pi-builtins`](../crates/pi-builtins) | Every builtin the embedded shell installs: a patched fork of brush's POSIX/bash builtins, plus one module per in-process command-line utility (`cat`, `grep`/`rg`, `sed`, `ls`, `find`, `jq`, `fd`, `diff`, `ps`, `top`, `kill`, the moreutils set, …). `src/host.rs` holds the `Utility` trait and the `Host` view of the shell (stdio, working directory, exported environment, cancellation) that the utilities run against. Ports of uutils coreutils/findutils/sed and jaq live here too; see the crate `LICENSE` for third-party notices. | | `pi-shell` | [`crates/pi-shell`](../crates/pi-shell) | Persistent embedded brush shell, command execution/minimization, process plumbing, filesystem walking, and in-process command integration used by `pi-natives`. | | `pi-voice` | [`crates/pi-voice`](../crates/pi-voice) | Cross-platform microphone/playback and Opus/WebRTC support used by the `AudioCapture`, `AudioPlayback`, and `LiveWebRtcPeer` bindings. | | `pi-ast` | [`crates/pi-ast`](../crates/pi-ast) | tree-sitter/ast-grep language registry, matching/editing, block analysis, and summarization support across the workspace grammar set. | | `pi-iso` | [`crates/pi-iso`](../crates/pi-iso) | Isolation backend implementations and diffing for APFS, Linux/Windows clone/reflink paths, overlayfs, ProjFS, and recursive copy fallback. | | `pi-walker` | [`crates/pi-walker`](../crates/pi-walker) | Parallel, cache-aware filesystem walker using ignore rules and globsets; shared by native grep/glob/workspace paths and shell commands. | +| `pi-vcs` | [`crates/pi-vcs`](../crates/pi-vcs) | In-process version control: git on gitoxide (the git binary survives only for credential-bound network transfers and reftable repos) and Jujutsu on jj-lib; unified discovery and operations used by the `vcs*` native bindings. | ## Vendored workspace crates @@ -29,7 +30,7 @@ The root `Cargo.toml` lists every crate under `crates/` explicitly in `workspace ```text @oh-my-pi/pi-natives JS entrypoints -> pi-natives (N-API conversion, platform bindings, task boundaries) - -> pi-ast / pi-iso / pi-voice / pi-walker + -> pi-ast / pi-iso / pi-vcs / pi-voice / pi-walker -> pi-shell -> brush-core (parser, expansion, interpreter) -> pi-builtins (bash builtins + utility builtins; host.rs: per-invocation I/O and cwd) diff --git a/docs/natives-architecture.md b/docs/natives-architecture.md index 92be669a7c02..951054a970b2 100644 --- a/docs/natives-architecture.md +++ b/docs/natives-architecture.md @@ -36,7 +36,8 @@ Current root capabilities include: - search, globbing, workspace scans, AST matching/editing, code summaries, syntax highlighting, text layout, token counting, and structured diffs; - shell, PTY, process, file-lock, isolation, and work-profile primitives; -- desktop capture/input/accessibility, clipboard, audio capture/playback, live WebRTC, device-check, SIXEL, snapcompact rendering, and vector ranking. +- desktop capture/input/accessibility, clipboard, audio capture/playback, live WebRTC, device-check, SIXEL, snapcompact rendering, and vector ranking; +- PDF inspection/Markdown conversion, SVG rasterization, macOS spelling services, and in-process Git/Jujutsu operations. ## Loader and distribution @@ -80,10 +81,10 @@ Set `PI_DEBUG_STARTUP` to emit synchronous `[startup]` markers to stderr around `crates/pi-natives/src/lib.rs` registers the current modules: -- platform/runtime: `appearance`, `clipboard`, `crash_handler`, `desktop`, `devicecheck`, `file_lock`, `iofs`, `power`, `prof`, `ps`, `pty`, `shell`; -- media/live: `audio`, `live`, `sixel`, `snapcompact`; -- code/data: `ast`, `block`, `diff`, `fd`, `glob`, `glob_util`, `grep`, `highlight`, `html`, `keys`, `summary`, `text`, `tokens`, `vectors`, `workspace`; -- isolation/task support: `iso`, `task`, crate-private `utils`, and test-only `testing`; +- platform/runtime: `appearance`, `clipboard`, `crash_handler`, `desktop`, `devicecheck`, `file_lock`, `iofs`, `power`, `prof`, `ps`, `pty`, `shell`, `spelling`, `tty_writer`, `vcs`; +- media/live: `audio`, `live`, `sixel`, `snapcompact`, `svg`; +- code/data: `ast`, `block`, `diff`, `fd`, `glob`, `glob_util`, `grep`, `highlight`, `html`, `keys`, `pdf`, `summary`, `text`, `tokens`, `utok`, `vectors`, `workspace`; +- isolation/task support: `iso`, `task`, plus N-API boundary/conversion helpers (`js`, crate-private `utils`, test-only `testing`); - language metadata re-exported from `pi_ast::language`. Rust `#[napi]` functions, classes, objects, and enums generate the declaration surface. Default snake_case Rust names become camelCase JavaScript names. diff --git a/docs/natives-binding-contract.md b/docs/natives-binding-contract.md index 4c05adfd28bf..76264acebf29 100644 --- a/docs/natives-binding-contract.md +++ b/docs/natives-binding-contract.md @@ -28,20 +28,29 @@ Do not import unexported `native/*` implementation paths from package consumers. | Category | Representative public exports | Rust owner | Call style | | ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- | -------------------- | | Search and workspace | `grep`, `search`, `hasMatch`, `fuzzyFind`, `glob`, `invalidateFsScanCache`, `listWorkspace` | `grep.rs`, `fd.rs`, `glob.rs`, `iofs.rs`, `workspace.rs` | mixed sync/promise | -| AST and code structure | `astGrep`, `astMatch`, `astEdit`, `blockRangeAt`, `enclosingBlockBoundaries`, `summarizeCode` | `ast.rs`, `block.rs`, `summary.rs` | mixed sync/promise | -| Diff and vectors | `diffLines`, `diffWords`, `diffLineRuns`, `structuredPatchHunks`, `cosineSimilarityPairs`, `mmrRerankIndices`, `vectorIndexTopK` | `diff.rs`, `vectors.rs` | sync | +| AST and code structure | `astGrep`, `astMatch`, `astEdit`, `blockRangeAt`, `nodeChainAt`, `enclosingBlockBoundaries`, `summarizeCode` | `ast.rs`, `block.rs`, `summary.rs` | mixed sync/promise | +| Diff and vectors | `diffLines`, `diffWords`, `diffLineRuns`, `structuredPatchHunks`, `DiffStream`, `cosineSimilarityPairs`, `mmrRerankIndices`, `vectorIndexTopK` | `diff.rs`, `vectors.rs` | sync | | Shell and PTY | `executeShell`, `Shell`, `PtySession` | `shell.rs`, `pty.rs` | classes/promises | -| Process and files | `Process`, `FileLock` | `ps.rs`, `file_lock/mod.rs` | classes/mixed | +| Process and files | `Process`, `FileLock`, `execReplace` | `ps.rs`, `file_lock/mod.rs` | classes/mixed | | Desktop and clipboard | `DesktopSession`, `copyToClipboard`, `readImageFromClipboard` | `desktop/mod.rs`, `clipboard.rs` | class, sync, promise | | Audio and live media | `AudioCapture`, `AudioPlayback`, `LiveWebRtcPeer` | `audio.rs`, `live.rs` | classes/mixed | -| Text and highlighting | `wrapTextWithAnsi`, `truncateToWidth`, `sliceWithWidth`, `extractSegments`, `visibleWidth`, `setHangulCompatJamoWidthOverride`, `highlightCode`, language queries | `text.rs`, `highlight.rs` | sync | -| Conversion and rendering | `htmlToMarkdown`, `encodeSixel`, `renderSnapcompactPng`, `snapcompactSupportedChars` | `html.rs`, `sixel.rs`, `snapcompact.rs` | mixed sync/promise | +| Text and highlighting | `wrapTextWithAnsi`, `truncateToWidth`, `sliceWithWidth`, `extractSegments`, `visibleWidth`, `setHangulCompatJamoWidthOverride`, `highlightCode`, `HighlightStream`, language queries | `text.rs`, `highlight.rs` | sync | +| Conversion and rendering | `htmlToMarkdown`, `pdfToMarkdown`, `rasterizeSvg`, `encodeSixel`, `renderSnapcompactPng`, `snapcompactSupportedChars` | `html.rs`, `pdf.rs`, `svg.rs`, `sixel.rs`, `snapcompact.rs` | mixed sync/promise | | Tokens and system | `countTokens`, macOS appearance/power exports, `getWorkProfile`, `deviceCheckGenerateToken` | `tokens.rs`, `appearance.rs`, `power.rs`, `prof.rs`, `devicecheck.rs` | mixed | +| Spelling (macOS) | `macOSCheckSpelling`, `macOSCompleteWord`, `macOSAutocorrectWord`, `macOSSpellingGuesses`, `macOSSpellCheckerAvailable` | `spelling.rs` | mixed sync/promise | +| Version control | `vcsDiscover`, `vcsGitClone`, `vcsDetachGitDir`, `vcsJoinPatches`, `vcsValidateHunkSelections`, `VcsRepo`, `VcsGitRepo`, `VcsJjWorkspace` | `vcs.rs` | mixed sync/promise | +| Terminal output | `TtyWriter` | `tty_writer.rs` | class | | Isolation | `isoBackend`, `isoProbe`, `isoResolve`, `isoIsUnavailableError`, `isoStart`, `isoStop`, `isoDiff` | `iso.rs` | mixed sync/promise | | Keys | `parseKey`, `matchesKey`, Kitty/legacy helpers | `keys.rs` | sync | Consult `native/index.d.ts` for exact option/result fields and signatures. Notable current signatures include `renderSnapcompactPng(...): Promise`, `readImageFromClipboard(): Promise`, and typed-array vector inputs/results. +Newer surface members on existing exports (all present in `native/index.d.ts`): + +- `ShellRunResult.workingDir?` — shell working directory after command completion (added 16.3.0), letting hosts sync cwd without a hidden probe command. +- `GrepOptions.maxCountPerFile?` — per-file content-mode match cap (added 15.10.11). Note `GrepOptions` has no `cache` field; directory grep is always uncached (`FuzzyFindOptions`/`GlobOptions` carry the opt-in `cache` flag). +- `snapcompactSupportedChars(font, chars)` — font glyph-capability probe (added 16.2.7). + ## Sync, Promise, and callback rules The call style is part of the public contract: @@ -62,6 +71,7 @@ Callback parameters generated from napi-rs `ThreadsafeFunction` use an error-fir The generated runtime enum objects currently are: - `AstMatchStrictness` +- `DiffSide` - `Ellipsis` - `Encoding` - `FileType` diff --git a/docs/natives-build-release-debugging.md b/docs/natives-build-release-debugging.md index ba9a1c5f9a3b..9c84dc7d07ac 100644 --- a/docs/natives-build-release-debugging.md +++ b/docs/natives-build-release-debugging.md @@ -306,7 +306,7 @@ Generated declarations currently include exports from these Rust modules: | Area | Representative JS exports | Rust source | | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | -| Search/workspace | `grep`, `search`, `hasMatch`, `fuzzyFind`, `glob`, `listWorkspace`, `invalidateFsScanCache` | `grep.rs`, `fd.rs`, `glob.rs`, `workspace.rs`, `iofs.rs` | +| Search/workspace | `grep`, `search`, `hasMatch`, `fuzzyFind`, `glob`, `listWorkspace`, `invalidateFsScanCache` | `grep.rs`, `fd.rs`, `glob.rs`, `workspace.rs`, `iofs.rs` (cache in `pi-walker`) | | AST/block/summary | `astGrep`, `astEdit`, `blockRangeAt`, `summarizeCode` | `ast.rs`, `block.rs`, `summary.rs` | | Text/highlight/tokens | `visibleWidth`, `truncateToWidth`, `highlightCode`, `countTokens` | `text.rs`, `highlight.rs`, `tokens.rs` | | Shell/PTY/process/keys | `executeShell`, `Shell`, `PtySession`, `Process`, `parseKey` | `shell.rs`, `pty.rs`, `ps.rs`, `keys.rs` | diff --git a/docs/natives-shell-pty-process.md b/docs/natives-shell-pty-process.md index bd1c1351d709..392c2c37994e 100644 --- a/docs/natives-shell-pty-process.md +++ b/docs/natives-shell-pty-process.md @@ -7,6 +7,7 @@ This document covers execution/process/terminal primitives in `@oh-my-pi/pi-nati - `crates/pi-natives/src/shell.rs` - `crates/pi-shell/src/shell.rs` - `crates/pi-shell/src/cancel.rs` +- `crates/pi-builtins` (embedded-shell builtins: bash builtins plus in-process utility/process commands) - `crates/pi-shell/src/windows.rs` (Windows-only PATH enrichment) - `crates/pi-shell/src/process.rs` - `crates/pi-natives/src/pty.rs` @@ -44,7 +45,8 @@ Rust creates `brush_core::Shell` with: - inherited environment disabled (`do_not_inherit_env: true`), followed by explicit environment reconstruction from host env, - profile and rc loading skipped, - bash-mode builtins, with `exec` and `suspend` disabled, -- native `sleep`, `timeout`, and `nohup` builtins registered, +- process builtins registered unconditionally from `pi_builtins::process_builtins()` — `nohup`, `pgrep`, `pkill`, `pidwait`, `ps`, `sleep`, `timeout`, and `top` (`nohup` is withheld when `PI_DISABLE_NOHUP_BUILTIN` is set; `kill` comes from the default bash-mode set, where `pi-builtins`' richer implementation replaces brush's original), +- in-process utility builtins registered from `pi_builtins::utility_builtins()` (see the next section), - skip-list for shell-sensitive vars (`PS1`, `PWD`, `SHLVL`, bash function exports, etc.), - a non-exported `env="$env"` fallback so PowerShell-style `$env:NAME` survives brush parameter expansion unless the user shadows `env`. @@ -56,6 +58,22 @@ Session env behavior: - Windows-only path enrichment (`pi-shell/src/windows.rs`) appends discovered Git-for-Windows paths when present and not already included. - `snapshotPath`, when present, is sourced during session creation with stdout/stderr/stdin wired to null files. +### In-process utility builtins (uutils-derived) + +Beyond the bash builtins, session creation registers the in-process command-line utility builtins implemented in the `pi-builtins` crate (`crates/pi-builtins`) — in-house ports of uutils coreutils/findutils/sed and jaq built on `uucore` 0.8.0. The set includes `cat`, `head`, `tail`, `wc`, `sort`, `uniq`, `ls`, `find`, `grep`, `mkdir`, `rm`, `mv`, `ln`, `sed`, `jq`, `fd`, `diff`, the checksum/`tr`/`cut`/`date` families, and more; `pi_builtins::utility_builtins()` is the authoritative list. + +Three search-related builtins are worth calling out: + +- `grep` is implemented on the ripgrep libraries (`grep-regex`/`grep-searcher`), with recursive directory walks served by `pi-walker`. +- `rg` is a sibling builtin with ripgrep defaults (recursive search, ignore/hidden filtering, binary suppression) — a separate module and argument model, not an alias of `grep`. +- `fd` is backed by `pi-walker`, `globset`, and `regex`. + +Each builtin runs inside the shell process (no `fork`/`exec`) against the `pi-builtins` `Host` view of the shell (`src/host.rs`): stdio routes through the command's (possibly piped/redirected) file descriptors, path operands resolve against the shell working directory, the shell's exported environment is visible, and abort/timeout cancellation is honored. Because these builtins shadow system binaries, registration is gated in `crates/pi-shell/src/shell.rs`: + +- `PI_DISABLE_UUTILS_BUILTINS` disables the whole utility set (bare names resolve to system binaries again), +- `PI_DISABLE_UUTILS_DESTRUCTIVE` disables the destructive shadows (`rm`, `mv`, and `ln`, which can clobber via `-f`) together, +- `PI_DISABLE_RM_BUILTIN` / `PI_DISABLE_MV_BUILTIN` disable `rm`/`mv` individually. + ### Runtime lifecycle and state transitions Persistent shell (`Shell.run`) uses this state machine: @@ -116,7 +134,7 @@ Common surfaced errors include: - `resize(cols, rows)` - `kill()` -Both start methods invoke `onStart(error, pid)` after spawning (the implementation supplies `0` only if a platform child PID is unavailable). `PtyStartOptions` supports `command`, optional `cwd`, `env`, `timeoutMs`, `signal`, `cols`, `rows`, and `shell`; its default shell is `sh`. `PtyArgvStartOptions` instead requires `application` and `args` and has no `shell`. +Both start methods invoke `onStart(error, pid)` after spawning (the implementation supplies `0` only if a platform child PID is unavailable). `PtyStartOptions` supports `command`, optional `cwd`, optional `env`, `timeoutMs`, `signal`, `cols`, `rows`, and `shell`; its default shell is `sh`. `PtyArgvStartOptions` instead requires `application` and `args` and has no `shell`. ### Runtime lifecycle and state transitions diff --git a/docs/natives-text-search-pipeline.md b/docs/natives-text-search-pipeline.md index c9010a53295f..8832c0f06d95 100644 --- a/docs/natives-text-search-pipeline.md +++ b/docs/natives-text-search-pipeline.md @@ -6,7 +6,7 @@ Terminology follows `docs/natives-architecture.md`: - **Generated binding**: public API in `packages/natives/native/index.d.ts`. - **Rust module layer**: N-API exports in `crates/pi-natives/src/*`. -- **Shared scan cache**: optional `pi-walker` directory-entry cache used by discovery flows. +- **Shared scan cache**: `pi-walker`-backed directory-entry cache (`crates/pi-walker/src/cache.rs`) used by discovery flows; N-API filesystem DTOs/conversions live in `crates/pi-natives/src/iofs.rs`. ## Implementation files @@ -14,6 +14,7 @@ Terminology follows `docs/natives-architecture.md`: - `crates/pi-natives/src/grep.rs` - `crates/pi-natives/src/glob.rs` - `crates/pi-natives/src/glob_util.rs` +- `crates/pi-natives/src/fd.rs` - `crates/pi-natives/src/iofs.rs` - `crates/pi-walker/src/lib.rs` - `crates/pi-walker/src/cache.rs` @@ -66,9 +67,9 @@ Terminology follows `docs/natives-architecture.md`: - **Single-file branch** - `grep` resolves path, checks metadata is file, and searches that file. - **Directory branch** - - Candidate discovery uses `pi-walker` without scan caching. - - Walker policy applies hidden/gitignore settings and skips skippable directory errors. - - Entry filtering: file-only + optional glob filter (`glob_util`) + optional type filter mapping (`js`, `ts`, `rust`, etc.). + - Rust builds a `pi_walker::WalkRequest` with `.cache(false)` hard-coded (`build_grep_walk_request`): directory searches stream while the tree is walked and never read or populate the shared scan cache. + - The walk yields file candidates directly to searchers (`glob`/type filters run walker-side; the type filter is applied per candidate). + - Files larger than the size cap are deferred to a trailing prefix pass that reads only the leading window into an owned buffer. ### Search/collection semantics @@ -80,13 +81,18 @@ Terminology follows `docs/natives-architecture.md`: - `content` -> one `GrepMatch` per hit. - `count` and `filesWithMatches` map to count-style entries (`lineNumber=0`, `line=""`, `matchCount` set). - `offset` and `maxCount` are applied during aggregation across sorted file results; `maxCountPerFile` can additionally prevent one hot file consuming the content-mode budget. - - Directory searches use parallel filesystem walking/searching, then aggregate per-file results to preserve global offset/limit semantics. Small ordered callback streams may stop early; larger streams use a bounded ordered window. + - Directory streaming model (`run_streaming_grep`): + - With a content-mode match budget (`maxCount`, no `offset`), the budget terminates the walk itself: small budgets (up to 64 matches) run a sequential early-exit walk, larger ones run a path-ordered walk that searches in windows and commits results after each window (`run_windowed_streaming_grep`), stopping once the budget is satisfied. Deterministic path-ordered first pages are preserved at every budget size. + - Without an early-stop budget, an unordered work-stealing parallel traversal feeds searchers directly (`run_parallel_streaming_grep`); per-file results are sorted by path afterwards. + - `maxCountPerFile` (content mode) caps matches collected per file so one hot file cannot exhaust the global `maxCount` budget before other files are reached. + - Oversized files (beyond the 4 MiB cap) are deferred behind normal-sized results and searched over their leading window only (bounded prefix read via `read_owned_prefix`; no full-file read and no mmap — the bounded owned read avoids mmap page faults). + - `offset` and `maxCount` are applied while aggregating per-file results; the `onMatch` callback fires after aggregation so callback and returned-result semantics match. ### Result shaping back to JS - Rust `SearchResult`/`GrepResult` fields map to TS interfaces via N-API object conversion. - Counters are clamped before crossing N-API where needed. -- `GrepResult.limitReached` is optional and emitted when true; `skippedOversized` reports files skipped over the 4 MiB limit. +- `GrepResult.limitReached` is optional and emitted when true; `skippedOversized` counts oversized files that could not be searched even via the trailing bounded prefix pass. - Streaming callback receives each shaped `GrepMatch` for content or count-style entries. ### Failure behavior @@ -112,10 +118,8 @@ Terminology follows `docs/natives-architecture.md`: ### `glob` flow 1. Caller passes `GlobOptions` directly. `pattern` and `path` are required in the generated type. -2. Rust resolves the search path and compiles pattern via `glob_util::compile_glob`. -3. Entry source: - - `cache=true` -> shared walker cache + optional stale-empty rescan. - - `cache=false` -> a fresh scan that neither reads nor updates the cache. +2. Rust resolves the search path (via `pi_walker::resolve_search_path`) and normalizes the pattern via `glob_util::build_glob_pattern`, compiled into a walker-side `pi_walker::CompiledWalkGlob` filter. +3. Entry source: a `pi_walker::WalkRequest` with the glob filter pushed down walker-side; `.cache(config.cache)` selects cached vs fresh collection, and the walker's `EmptyRecheck` policy performs one fresh rescan when a cached scan filters to empty. 4. Filtering: - skip `.git` always; - skip `node_modules` unless requested (`includeNodeModules`) or pattern mentions `node_modules`; @@ -126,7 +130,7 @@ Terminology follows `docs/natives-architecture.md`: ### `fuzzyFind` flow 1. Rust implementation lives in `fd.rs`; generated export is `fuzzyFind`. -2. Shared `pi-walker` scan source with the same opt-in cache and stale-empty recheck policy. +2. Shared scan source from `pi-walker` with the same cache/no-cache split and walker-side stale-empty recheck policy. 3. Scoring: - exact / starts-with / contains / subsequence-based fuzzy score; - separator/punctuation-normalized scoring path; @@ -135,9 +139,9 @@ Terminology follows `docs/natives-architecture.md`: ### Failure behavior -- Invalid glob pattern returns an error from `glob_util::compile_glob`. +- Invalid glob pattern returns an error from walker glob compilation (`pi_walker::CompiledWalkGlob`). - Search root must resolve to an existing directory for directory discovery flows. -- Cancellation/timeouts propagate as abort errors via the caller-supplied walker heartbeat and result-processing checks. +- Cancellation/timeouts propagate as abort errors via `CancelToken::heartbeat()` checks in walker and result-processing loops. ### Malformed glob handling @@ -164,7 +168,7 @@ These exports are direct native APIs used by tooling; they are not mediated by a `pi-walker` owns traversal and cache policy. `crates/pi-natives/src/iofs.rs` contains only JavaScript-facing DTO conversion, error mapping, and the invalidation export. -The cache stores normalized relative entries (`path`, `fileType`, optional `mtime` and regular-file `size`) keyed by canonical search root plus the effective traversal-level `WalkOptions`: hidden/gitignore and directory-pruning policy, link following, metadata detail, traversal order/depth, root emission, directory-error handling, filesystem boundary, and cache mode. `WalkFilter` predicates, ranking, and result limits run after collection and do not independently partition the cache, so requests with different glob, file-type, size-threshold, or limit values can share an entry. A filter or rank that requires extra metadata can still promote the effective detail policy and thereby select a different key. +The cache stores normalized relative entries (`path`, `fileType`, optional `mtime` and regular-file `size`) keyed by canonical search root plus the full traversal-level `WalkOptions` with the cache flag itself excluded — calls that differ only in `cache` share an entry. Keyed dimensions: hidden/gitignore and directory-pruning policy, link following, metadata detail, traversal order/depth, root emission, directory-error handling, and filesystem boundary. `WalkFilter` predicates, ranking, and result limits run after collection and do not independently partition the cache, so requests with different glob, file-type, size-threshold, or limit values can share an entry. A filter or rank that requires extra metadata can still promote the effective detail policy and thereby select a different key. Configuration is read from environment once: @@ -184,7 +188,7 @@ Configuration is read from environment once: - when the caller enables configured rechecking, an empty cached query at or beyond the threshold is scanned once again. 4. **Invalidation** - `invalidateFsScanCache()` clears all keys; - - `invalidateFsScanCache(path)` removes cached roots containing that path. + - `invalidateFsScanCache(path)` removes every entry whose cached root is a prefix of the target (canonicalization with parent fallback supports create/delete/rename invalidation). The binding lives in `iofs.rs` and forwards to `pi_walker::invalidate_path_string` / `pi_walker::invalidate_all`. Cache favors low-latency repeated scans over immediate consistency. Explicit invalidation is the correctness hook after writes, edits, renames, or deletes. @@ -210,6 +214,7 @@ These are pure, in-memory utilities. - `sliceWithWidth`: column slicing with optional strict width enforcement. - `extractSegments`: extracts before/after segments around an overlay while restoring ANSI state for the `after` segment. - `setHangulCompatJamoWidthOverride(value)` controls U+3131–U+318E width correction for client-terminal compatibility: `0` uses the platform fallback, `1` forces one cell, `2` forces two, and `3` follows Unicode width. +- `sanitizeText` (ANSI/control/surrogate stripping with line-ending normalization) no longer lives in `text.rs`; it moved to `@oh-my-pi/pi-utils` as a pure-JS implementation in `packages/utils/src/sanitize-text.ts`. The native binding was removed in the same change because the JS version was competitive on the benchmarked workloads, and keeping a Rust copy forced every caller (including `pi-utils`) to pull in `@oh-my-pi/pi-natives`. - `visibleWidth`: counts visible terminal cells using caller-supplied tab width. ### Failure behavior @@ -243,17 +248,17 @@ Text functions generally return deterministic transformed output; errors are lim ## Pure utility vs filesystem-dependent flows -| Flow | Filesystem access | Shared cache | Notes | -| ---------------------------- | ----------------- | ------------------------- | -------------------------------------------------------------------- | -| `search` / `hasMatch` | No | No | regex on provided bytes/string only | -| `text` module functions | No | No | ANSI/width utilities only | -| `highlight` module functions | No | No | syntax + ANSI coloring only | -| `countTokens` | No | No | tokenization only | -| `astMatch` | No | No | in-memory syntax-aware match (no disk) | -| `astGrep` / `astEdit` | Yes | Yes (directory discovery) | directory paths use cached traversal; a direct file path bypasses it | -| `glob` | Yes | Optional | directory scans + glob filtering | -| `fuzzyFind` | Yes | Optional | directory scans + fuzzy scoring | -| `grep` (file/dir path) | Yes | No | walker discovery + regex search, optional filters/callback | +| Flow | Filesystem access | Shared cache | Notes | +| ---------------------------- | ----------------- | ------------ | ------------------------------------------------------------ | +| `search` / `hasMatch` | No | No | regex on provided bytes/string only | +| `text` module functions | No | No | ANSI/width utilities only | +| `highlight` module functions | No | No | syntax + ANSI coloring only | +| `countTokens` | No | No | tokenization only | +| `astMatch` | No | No | in-memory syntax-aware match (no disk) | +| `astGrep` / `astEdit` | Yes | Always | directory discovery is cached; a direct file path bypasses it | +| `glob` | Yes | Optional | directory scans + glob filtering (`cache` opt-in) | +| `fuzzyFind` | Yes | Optional | directory scans + fuzzy scoring (`cache` opt-in) | +| `grep` (file/dir path) | Yes | Never | streaming uncached walk feeding searchers | ## End-to-end lifecycle summary diff --git a/docs/non-compaction-retry-policy.md b/docs/non-compaction-retry-policy.md index abc29d803cf5..d497cf2e13d1 100644 --- a/docs/non-compaction-retry-policy.md +++ b/docs/non-compaction-retry-policy.md @@ -195,10 +195,12 @@ Client helpers: Session-level retry events: - `auto_retry_start { attempt, maxAttempts, delayMs, errorMessage, errorId? }` -- `auto_retry_end { success, attempt, finalError?, recoveredErrors? }` +- `auto_retry_end { success, attempt, finalError?, retryErrors? }` - `retry_fallback_applied { from, to, role }` - `retry_fallback_succeeded { model, role }` +On success, `auto_retry_end` also carries additive `retryErrors`: one `RetryErrorUpdate` (`entryId`, `persistenceKey?`, `note`, `retryRecovery`) per persisted error entry left behind by the retry chain, recording how recovery happened (`recovery`: `plain`/`wait`/`credential`/`model`, plus a human-readable `note` such as `rate-limited; switched account; retried`) and which successful message superseded each error (`supersededBy` with timestamp/provider/model/responseId). Extensions and RPC consumers receive the same fields. + Propagation: - emitted through `AgentSession.subscribe(...)` @@ -230,7 +232,7 @@ A new retry chain can still start later on a future retryable error after counte ## Operational caveats - Classification uses normalized `AIError` flags/status plus provider-aware text fallback; it is not limited to structured errors or to regex matching alone. -- Retry strips the failing assistant error from **runtime context** before re-continue, but session history still keeps that error entry. +- Retry strips the failing assistant error from **runtime context** before re-continue, but session history still keeps that error entry. When the retry chain eventually succeeds, each persisted error entry from the chain is marked with a `retryRecovery` marker (`status: "recovered"`, plus kind/attempt/note and the superseding message; entries whose error was rendered moot carry `status: "superseded"` instead). Marked entries render as a dim, non-error one-line note instead of a red failure (live UI included, via the success event's `retryErrors`), and they are excluded when the LLM context is rebuilt — the display transcript still keeps them visible. - `RpcSessionState` currently exposes `autoCompactionEnabled` but not an `autoRetryEnabled` field; RPC callers must track their own toggle state or query settings through other APIs. - Model fallback changes append temporary `model_change` entries and may later restore the primary model when its cooldown expires, depending on `retry.fallbackRevertPolicy`. - Usage-aware fallback runs before a provider request when both `retry.modelFallback` and `retry.usageAwareFallback` are enabled. Unknown/unmapped usage fails open. At the reserve threshold, `"confirm"` asks interactive sessions and keeps the current model when declined; sessions without a confirmation UI automatically apply an eligible configured fallback. `"auto"` applies an eligible fallback without asking. `"fail-closed"` rejects reserve or depleted usage instead of spending it or selecting a fallback. Depleted usage under the other policies applies an eligible fallback without a reserve confirmation. diff --git a/docs/omptype-guide.md b/docs/omptype-guide.md index 15609a212d57..f28ca0ce56c1 100644 --- a/docs/omptype-guide.md +++ b/docs/omptype-guide.md @@ -11,8 +11,9 @@ with a lazy JIT runtime (`packages/omptype`). Author types with - The first two calls run an interpreter; the third call JIT-compiles a specialized validator via `new Function`. Hot-path validation is tens of nanoseconds; failures allocate one small error object with lazy message building. -- There is no `jitless` switch and no `scope()` — lazy JIT removed the startup tax - those existed to dodge. Import `type` directly. +- There is no functional `jitless` mode — lazy JIT removed the startup tax it + existed to dodge. Import `type` directly. (`ScopeOptions` accepts a `jitless` + flag for ArkType compatibility, but the runtime never reads it.) ## The detection contract (don't break it) @@ -76,6 +77,43 @@ if (out instanceof type.errors) { Note on `.or()` typing: schema and string operands infer precisely; object-literal operands degrade — wrap them with `type({...})` first. +## Scopes, modules, and generics + +Recursive or mutually-referencing schemas go through named scopes +(`packages/omptype/src/type.ts`, `scope()` / `type.scope()`): + +```ts +import { type } from "@oh-my-pi/omptype"; + +const types = type.module({ + tree: { value: "number", "children?": "tree[]" }, +}); +``` + +- `type.scope(aliases)` (also exported top-level as `scope()`) returns a + `TypeScope` with `.type`, `.define`, `.resolve`, `.import`, and `.export`; + aliases may reference each other recursively, and `#private` names stay + internal. +- `type.module({...})` compiles a named module — `scope(...).export()` — into + a map of ready schemas. +- `type.generic("", def)` builds runtime generics that other definitions + can instantiate inside a scope. + +## JSON Schema interop + +- `.toJsonSchema()` emits draft-2020-12 by default (`target: "draft-07"` + supported); recursive aliases emit `$defs`/`$ref`. +- `fromJsonSchema(schema)` rebuilds a callable schema from a JSON Schema + document (structural keywords of draft-07 / draft-2020-12, string formats, + `$defs` recursion, enums, `anyOf`/`oneOf`/`allOf`) — the inverse of + `.toJsonSchema()`. +- `type.withJsonSchema(schema, json)` wraps a validation-only schema so + `.toJsonSchema()` emits `json` verbatim even when nested in objects, arrays, + or unions; schemas with defaults or output-changing morphs are rejected. +- Every schema exposes Standard Schema V1 via `~standard` (synchronous + `validate`), enabling direct use with `@t3-oss/env`, tRPC, and other + Standard Schema consumers. + ## Adapters TypeBox-style and Zod-style authoring are backed by the omptype runtime: diff --git a/docs/porting-from-pi-mono.md b/docs/porting-from-pi-mono.md index 5dda6b224102..c759f8f1234f 100644 --- a/docs/porting-from-pi-mono.md +++ b/docs/porting-from-pi-mono.md @@ -48,8 +48,6 @@ Upstream uses different package scopes. Replace them consistently. - `@mariozechner/pi-tui` → `@oh-my-pi/pi-tui` - `@mariozechner/pi-ai` → `@oh-my-pi/pi-ai` - `@mariozechner/pi-utils` → `@oh-my-pi/pi-utils` - - `@mariozechner/pi-catalog` → `@oh-my-pi/pi-catalog` - - `@mariozechner/pi-natives` → `@oh-my-pi/pi-natives` - Some upstream packages publish under the `@earendil-works/*` scope instead of `@mariozechner/*`. Map it the same way (`@earendil-works/pi-coding-agent` → `@oh-my-pi/pi-coding-agent`, and so on). - The bare `typebox` package is not an `@oh-my-pi/*` scope; do not rewrite it as one. See the Extensions divergence in section 15 for how tool-parameter schemas map. @@ -160,13 +158,14 @@ Unless requested, remove upstream compatibility shims. ## 10) Validate the port -Run the checks that cover the port: +Run the checks that cover the port after changes: -- `bun check` for the repository's TypeScript and Rust checks. -- Targeted Bun tests for the packages and behavior you changed (for example, `bun test packages//test/.test.ts`). +- `bun check` +- Run the focused Bun test or smoke scenario that exercises the changed behavior. - If dependencies changed, run `bun install --frozen-lockfile` after updating `bun.lock`. -Tests use Bun's runner, not Vitest. Do not substitute a project-wide `bun test` for targeted coverage; the root `test` script uses the repository's sharded runner. If a check already fails for an unrelated reason, call out the exact command and failure. +If the repo already has failing checks unrelated to your changes, call that out. +Tests use Bun's runner (not Vitest), but do not substitute an indiscriminate project-wide `bun test` for targeted behavioral verification. ## 11) Protect improved features (regression trap list) @@ -348,7 +347,7 @@ Our fork has architectural decisions that differ from upstream. **Do not port th | Upstream | Our Fork | Notes | | ----------------------------------- | ------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- | | `createTool(cwd: string, options?)` | `createTools(session: ToolSession)` via `BUILTIN_TOOLS` registry | Tool factories accept `ToolSession` and can return `null` | -| Per-tool `*Operations` interfaces | Only current per-tool override interfaces remain (for example `FindOperations`) | Used for SSH/remote overrides where present | +| Per-tool `*Operations` interfaces | Only current per-tool override interfaces remain (for example `GlobOperations` in `tools/glob.ts`); `FindOperations` survives only in the legacy shim (`src/extensibility/legacy-pi-coding-agent-shim.ts`) after the find→glob rename | Used for SSH/remote overrides where present | | Node.js `fs/promises` everywhere | Bun file APIs for simple file writes/reads, `node:fs/promises` for dirs, selected sync `node:fs` where needed | Prefer Bun APIs when they simplify | ### Auth Storage diff --git a/docs/porting-to-natives.md b/docs/porting-to-natives.md index 17a4861f8c3e..bac638b3f0a4 100644 --- a/docs/porting-to-natives.md +++ b/docs/porting-to-natives.md @@ -14,7 +14,17 @@ The package has no `packages/natives/src/` wrapper layer. Its entrypoint - eager root: `native/index.js` with generated `native/index.d.ts`; - lazy desktop wrapper: `native/desktop.js` / `desktop.d.ts`; -- lazy clipboard wrapper: `native/clipboard.js` / `clipboard.d.ts`. +- lazy clipboard wrapper: `native/clipboard.js` / `clipboard.d.ts`; +- lazy vcs wrapper: `native/vcs.js` / `vcs.d.ts` (`@oh-my-pi/pi-natives/vcs`). + +The vcs subpath exposes the backend-neutral `Vcs*` repository API (added in +18.0.9, with `VcsGitRepo.mergeBase()` following in 18.0.10): discovery and +Git/Jujutsu operations through `git()` / `repo()` / `require()` / `requireGit()` +returning `VcsGitRepo` / `VcsRepo` / `VcsJjWorkspace` handles (refs and status, +diffs, staging, commits, branches, worktrees, patch application, stash, +cherry-pick, CLI-backed push/fetch/clone, all cancellation-aware), plus the +JS-side error helpers (`isVcsError`) and the `watch(repo, onChange)` head-change +watcher built on `VcsRepo.watchTarget()`. Two commands serve different purposes: diff --git a/docs/provider-compat-reference.md b/docs/provider-compat-reference.md index 6c658a32dd95..711caf144fc3 100644 --- a/docs/provider-compat-reference.md +++ b/docs/provider-compat-reference.md @@ -202,7 +202,7 @@ All providers start from the same neutral wire schema — `toolWireSchema(tool)` - **Schemas**: `sanitizeSchemaForOpenAIResponses` + `adaptSchemaForStrict`. Supports function tools, freeform **custom tools**, and native **computer tools** (`model.supportsComputerUse`). Wire: flat `{ type: "function", name, description, parameters, strict? }`. - **Streaming**: `response.output_item.added` → `response.function_call_arguments.delta` / `response.custom_tool_call_input.delta` → `response.output_item.done`. Tool call ids are composite `callId|itemId` (`normalizeResponsesToolCallId`). -- **Results**: input items of `type: "function_call_output"` with `call_id` (the `callId` half of the composite). Stateful `previous_response_id` chaining across turns. +- **Results**: `function_call_output` and `custom_tool_call_output` items pair with calls by `call_id` (the `callId` half of the composite). Their `output` is either a string or an array of canonical `input_text` and `input_image` blocks. Vision-capable models keep tool-result images inside that array instead of creating synthetic user messages; models without image input receive a text placeholder. Auth-gateway parsing also accepts legacy `output_text`, `text`, and `refusal` blocks, decodes inline data-image URLs into image content, and retains remote image URLs or OpenAI image file IDs as references. File IDs require a Responses-compatible upstream because other provider transports cannot resolve them. `input_file` remains supported for request messages but is rejected in tool outputs until canonical tool results can replay its bytes and references losslessly. Stateful `previous_response_id` chaining works across turns. ### Google Gemini / Vertex (`providers/google-shared.ts`, `google.ts`) @@ -225,8 +225,8 @@ All providers start from the same neutral wire schema — `toolWireSchema(tool)` | Schema normalizer | strict allowlist + budgets | `adaptSchemaForStrict` | `sanitizeSchemaForOpenAIResponses` | `normalizeSchemaForGoogle` / CCA | raw JSON schema | | Args streaming | JSON string fragments | JSON string fragments (MiniMax: objects) | JSON string fragments | complete object, no fragments | JSON string fragments | | Call ids | native | native (+Mistral 9-char, OpenAI 40-char rules) | composite `callId\|itemId` | synthesized; Vertex strips | native | -| Result encoding | `user` + `tool_result` blocks | `role: "tool"` messages | `function_call_output` items | `user` + `functionResponse` parts, single message | `user` + grouped `toolResult` array | -| Images in results | embedded; hoisted on error | placeholder partition | embedded or partitioned | Gemini 3+ embedded, else trailing user turn | embedded | +| Result encoding | `user` + `tool_result` blocks | `role: "tool"` messages | function/custom output items | `user` + `functionResponse` parts, single message | `user` + grouped `toolResult` array | +| Images in results | embedded; hoisted on error | placeholder partition | inside output arrays; placeholder without image input | Gemini 3+ embedded, else trailing user turn | embedded | | Parallel calls | native | native | native | native | native | ### Strict tools lifecycle diff --git a/docs/provider-endpoint-constraints.md b/docs/provider-endpoint-constraints.md index 44dbabe05226..c9bf8dcf6a01 100644 --- a/docs/provider-endpoint-constraints.md +++ b/docs/provider-endpoint-constraints.md @@ -87,6 +87,22 @@ policy: Codex intentionally does not forward caller max-token caps because the backend rejects them. +### Claude Agent SDK + +`claude-agent-sdk` is not an HTTP endpoint; it spawns the local Claude Code +binary through `@anthropic-ai/claude-agent-sdk`. Keep these SDK-specific: + +- no HTTP retry policy — the SDK owns its own process/transport retries +- no `toolChoice` — the SDK does not accept forced tool selection +- no custom tools — omp's `context.tools` are never sent; Claude Code executes + only its own built-in tools +- thinking effort is passed as the SDK's `effort` option, not a wire field +- session continuity resumes by the SDK's own session id, not a provider chain + id +- results carry real token counts but always cost `{ input: 0, output: 0, + cacheRead: 0, cacheWrite: 0 }` — the turn is billed against the user's + Claude Code subscription, not metered per token + ### Anthropic/OpenAI dual-surface providers Kimi Code and Synthetic can be called as OpenAI-compatible or @@ -152,6 +168,19 @@ routing, model ids, or usage accounting. - The OpenAI-compatible path needs common Kimi headers. - It also participates in the OpenAI/Anthropic dual-surface shim. +### ClinePass + +- Requests carry the official Cline CLI client identity (`X-CLIENT-TYPE`, `X-CLIENT-VERSION`, `X-PLATFORM`, `X-CORE-VERSION`, `User-Agent`, and related headers). Inference also carries OMP's stable session key as `X-Task-ID`; account and discovery calls omit it. This is the supported identification contract for Cline-gated roster entries. +- Public catalog ids omit the gateway's `cline-pass/` namespace; Chat Completions adds it on the wire. Free-tier ids retain their full OpenRouter-style namespace because the gateway already receives them in wire form. +- The public `recommended-models` endpoint is authoritative for membership. The required `clinePass` bucket and optional `free` bucket currently resolve to a sixteen-model roster; malformed subscription data is rejected so the generated fallback survives. +- Known ids use a Cline-authored metadata snapshot for exact limits, subscription pricing, input modalities, and per-model reasoning controls. Unknown ids remain usable with conservative limits and no invented reasoning controls until live OpenRouter enrichment or regeneration supplies metadata. +- Subscription models display Cline's API-equivalent list price, but streamed `usage.cost` is the authoritative billed/discounted charge. Free-tier models remain genuinely $0. +- Reasoning is model-specific: effort models send only their advertised wire tiers, Qwen3.7 Plus maps OMP efforts to Cline's nested `reasoning.max_tokens` budget, and thinking-off sends `reasoning: { enabled: false }` where Cline advertises a toggle. +- Cline-hosted Qwen routes receive Anthropic-style ephemeral cache breakpoints. Reasoning continuations replay through `delta.reasoning` only for families that require it. +- Login validates the key against `/users/me`; inference validation then proves model access without consuming quota. +- Subscription-window exhaustion (`clinepass limit`) and free-tier caps (`free limit reached on model ...`) classify as usage limits. Roster rotation and account-policy errors receive provider-specific recovery guidance. +- The dashboard's `/users/me/plan/usage-limits` route accepts the inference API key and reports five-hour, weekly, and monthly utilization; `/users/me` supplies the account label. Usage reporting does not require account OAuth. + ### Fireworks and Firepass - Wire model ids need provider-specific mapping. @@ -163,8 +192,8 @@ routing, model ids, or usage accounting. Check these before adding or forwarding a field: - **Model id.** Some models resolve a wire id from reasoning effort. - Firepass/Fireworks transform ids. OpenRouter suffix handling is path-segment - aware. + ClinePass, Firepass, and Fireworks transform ids. OpenRouter suffix handling + is path-segment aware. - **Max output tokens.** Kimi-family models may require a max-token field even when the caller did not set one. OpenRouter should omit catalog defaults unless explicit. Codex drops caller caps. Responses uses `max_output_tokens`; Chat @@ -195,7 +224,12 @@ Reasoning fields are not interchangeable. - Uses `reasoning: { effort, summary }`. - Can include `reasoning.encrypted_content` for replay. - xAI Grok models may require omitting `reasoning.effort`. -- Some compat paths inject the GPT-5 `# Juice: 0 !important` developer scaffold. +- When reasoning is forced off for GPT-5.6+ Responses models, a trailing + developer item `# Juice: !important` is appended, with `N` mapped from + the requested effort (`none`→0, `minimal`→2, `low`→4, `medium`→8, `high`→48, + `xhigh`→112, `max`→960; default 8) — see `getJuiceValue` in + `packages/ai/src/providers/openai-shared.ts` and the `forceReasoningOff` + path in `packages/ai/src/providers/openai-responses.ts`. ### OpenRouter `reasoning` diff --git a/docs/provider-quirks.md b/docs/provider-quirks.md index e123973d032c..5304e7368290 100644 --- a/docs/provider-quirks.md +++ b/docs/provider-quirks.md @@ -14,12 +14,12 @@ Related references: ## OpenAI Chat Completions -The OpenAI Chat Completions provider implements HTTP POST JSON body streaming over Server-Sent Events (SSE) for the standard OpenAI `/chat/completions` wire contract (`ChatCompletionCreateParamsStreaming` request schema and `ChatCompletionChunk` event payloads). It serves as the primary workhorse transport for OpenAI models as well as dozens of OpenAI-compatible gateways and third-party providers including Groq, Cerebras, Mistral, DeepSeek, Fireworks, Zhipu (Z.AI), Qwen (DashScope), Kimi (Moonshot), Synthetic, GitLab Duo, OpenRouter, Vercel AI Gateway, CoreWeave, HuggingFace, Nvidia NIM, Novita, GMI Cloud, Baseten, NanoGPT, and Sakana/Fugu. The transport is implemented across `packages/ai/src/providers/openai-completions.ts` (main streaming runner `streamOpenAICompletions`), `packages/ai/src/providers/openai-chat-wire.ts` (vendored wire types), `packages/ai/src/providers/openai-shared.ts` (shared request/policy/usage helpers), `packages/ai/src/providers/openai-reasoning-fallback.ts` (400 reasoning-effort recovery), `packages/ai/src/utils/openai-http.ts` (HTTP SSE client `postOpenAIStream`), and `packages/ai/src/utils/empty-completion-retry.ts` (`withEmptyCompletionRetry` wrapper). +The OpenAI Chat Completions provider implements HTTP POST JSON body streaming over Server-Sent Events (SSE) for the standard OpenAI `/chat/completions` wire contract (`ChatCompletionCreateParamsStreaming` request schema and `ChatCompletionChunk` event payloads). It serves as the primary workhorse transport for OpenAI models as well as dozens of OpenAI-compatible gateways and third-party providers including Groq, Cerebras, Mistral, DeepSeek, Fireworks, Zhipu (Z.AI), Qwen (DashScope), Kimi (Moonshot), Synthetic, GitLab Duo, OpenRouter, Vercel AI Gateway, CoreWeave, HuggingFace, Nvidia NIM, Novita, GMI Cloud, Baseten, NanoGPT, and Sakana/Fugu. The transport is implemented across `packages/ai/src/providers/openai-completions.ts` (main streaming runner `streamOpenAICompletions`), `packages/ai/src/providers/openai-chat-wire.ts` (vendored wire types), `packages/ai/src/providers/openai-shared.ts` (shared request/policy/usage helpers), `packages/ai/src/providers/openai-reasoning-fallback.ts` (400 reasoning-effort recovery), `packages/ai/src/utils/openai-http.ts` (HTTP SSE client `postOpenAIStream`), and `packages/ai/src/utils/empty-completion-retry.ts` (`withReplaySafeStreamRetry` wrapper). ### Special casings - **Azure Deployment Name Mapping**: `parseAzureDeploymentNameMap` in `packages/ai/src/providers/openai-shared.ts` parses the `AZURE_OPENAI_DEPLOYMENT_NAME_MAP` environment variable (comma-separated `modelId:deploymentName` pairs) in `createRequestSetup` (`packages/ai/src/providers/openai-completions.ts`) to translate model IDs into Azure deployment names, defaulting to `model.id` if unmapped. - **Gateway Routing & Variant Transformations**: `applyOpenAIGatewayRouting` in `packages/ai/src/providers/openai-shared.ts` injects OpenRouter provider routing preferences (`params.provider`). `applyOpenRouterRoutingVariant` and `applyWireModelIdTransform` append OpenRouter model variant suffixes (`:nitro`, `:floor`, `:online`, `:extended`). `resolveSakanaRequestBaseUrl` handles Sakana/Fugu base URL overrides (`SAKANA_BASE_URL` / `FUGU_BASE_URL`), and `applyCoreWeaveProjectHeader` injects CoreWeave project headers. -- **Empty-Completion Retry**: `streamOpenAICompletions` is wrapped with `withEmptyCompletionRetry` (`packages/ai/src/utils/empty-completion-retry.ts`), which retries a request up to `MAX_EMPTY_COMPLETION_RETRIES` (2 retries with exponential backoff `EMPTY_COMPLETION_BASE_DELAY_MS` = 500ms) if an attempt finishes cleanly with `finish_reason: "stop"` but emits no visible assistant content (`hasVisibleAssistantContent` checks for text, thinking, image, or tool calls) and <= 1 output token. +- **Empty-Completion Retry**: `streamOpenAICompletions` is wrapped with `withReplaySafeStreamRetry` (`packages/ai/src/utils/empty-completion-retry.ts`), which retries a request up to `MAX_EMPTY_COMPLETION_RETRIES` (2 retries with exponential backoff `EMPTY_COMPLETION_BASE_DELAY_MS` = 500ms) if an attempt finishes cleanly with `finish_reason: "stop"` but emits no visible assistant content (`hasVisibleAssistantContent` checks for text, thinking, image, or tool calls) and <= 1 output token. The wrapper buffers pre-output events so discarded attempts are never replayed, and (with `retryProviderErrors: true`, `maxProviderErrorRetries: 1`) also retries transient provider errors before any output is committed. - **Reasoning-Effort 400 Fallback**: `resolveOpenAIReasoningEffortFallback` and `applyOpenAIReasoningEffortFallback` (`packages/ai/src/providers/openai-reasoning-fallback.ts`) intercept 400/422 HTTP error responses caused by unsupported `reasoning_effort` values. It parses allowed levels from error messages (or resolves nearest supported level/null), remembers the fallback per-endpoint/model key (`createOpenAIReasoningEffortFallbackKey`, `rememberOpenAIReasoningEffortFallback`) in provider session state (`getOpenAICompletionsProviderSessionState`), and transparently retries the request without failing the turn. - **Finish Reason Promotion**: In `streamOpenAICompletionsOnce` (`packages/ai/src/providers/openai-completions.ts`), if the backend reports `finish_reason: "stop"` but the turn produced structural `toolCall` blocks or healed tool calls via `StreamMarkupHealing`, `output.stopReason` is promoted from `"stop"` to `"toolUse"` so the agent execution loop correctly invokes tool handlers. - **Mistral Tool ID Normalization**: `normalizeMistralToolId` in `packages/ai/src/providers/openai-completions.ts` restricts tool call IDs for Mistral models to exactly 9 alphanumeric characters (padding with deterministic characters `"ABCDEFGHI"` or truncating). @@ -34,12 +34,12 @@ The OpenAI Chat Completions provider implements HTTP POST JSON body streaming ov - **Stream Markup Healing**: `StreamMarkupHealing` (`packages/ai/src/utils/stream-markup-healing.ts`) is activated when `policy.stream.markupHealingPattern` is configured. It inspects streamed text for XML/markdown-wrapped tool calls (e.g. DSML leaks), parses completed tool calls, emits `toolcall_start`/`toolcall_delta`/`toolcall_end` events, and promotes `stop` finish reasons to `toolUse`. - **Demoted Thinking & Cumulative Reasoning**: `renderDemotedThinking` (`packages/ai/src/dialect/demotion.ts`) handles demoted thinking blocks (`isDemotedThinking`). `lastCumulativeReasoningBySignature` tracks cumulative reasoning streams (e.g., MiniMax-M3) across text block transitions to prevent re-emitting thinking text as duplicate blocks after visible text has started. - **Watchdogs & Terminal Grace Window**: `iterateWithIdleTimeout` (`packages/ai/src/utils/idle-iterator.ts`) monitors stream activity using `getOpenAIStreamFirstEventTimeoutMs` and `getOpenAIStreamIdleTimeoutMs`, injecting `X-Stainless-Timeout` headers downstream. On stream finish, `iterateWithTerminalGrace` enforces a 2,500ms post-finish grace window (`OPENAI_COMPLETIONS_POST_FINISH_GRACE_MS`) allowing trailing usage-only chunks (`stream_options.include_usage`) with cache-read token details (`awaitTrailingUsageDetails`) to arrive before closing the stream. -- **Usage Chunk Parsing**: `parseChunkUsage` and `applyUsagePayload` in `packages/ai/src/providers/openai-completions.ts` process token usage from `chunk.usage` or `choice.usage`. Fields extracted include `prompt_tokens_details.cached_tokens`, `prompt_cache_hit_tokens`, `prompt_cache_miss_tokens`, `completion_tokens_details.reasoning_tokens`, `cache_write_tokens`, and provider-reported costs via `applyOpenRouterReportedCost` (`packages/ai/src/providers/openai-shared.ts`). +- **Usage Chunk Parsing**: `parseChunkUsage` and `applyUsagePayload` in `packages/ai/src/providers/openai-completions.ts` process token usage from `chunk.usage` or `choice.usage`. Fields extracted include `prompt_tokens_details.cached_tokens`, `prompt_cache_hit_tokens`, `prompt_cache_miss_tokens`, `completion_tokens_details.reasoning_tokens`, `cache_write_tokens`, and provider-reported costs via `applyProviderReportedCost` (`packages/ai/src/providers/openai-shared.ts`). ### Auth & usage - **API-Key Validation**: `validateOpenAICompatibleApiKey` in `packages/ai/src/registry/api-key-validation.ts` validates API credentials by issuing a lightweight `POST /chat/completions` request with `messages: [{ role: "user", content: "ping" }]`, `max_tokens: 1`, `temperature: 0`, and `Authorization: Bearer ${apiKey}`. - **Credential Resolution & Env Vars**: `getEnvApiKey` in `packages/ai/src/stream.ts` resolves provider-specific environment variables for OpenAI-compatible providers: `OPENAI_API_KEY`, `GROQ_API_KEY`, `CEREBRAS_API_KEY`, `MISTRAL_API_KEY`, `DEEPSEEK_API_KEY`, `FIREWORKS_API_KEY`, `OPENROUTER_API_KEY`, `TOGETHER_API_KEY`, `SAMBANOVA_API_KEY`, `NEBIUS_API_KEY`, `NOVITA_API_KEY`, `AVALAI_API_KEY`, `CHUTES_API_KEY`, `NANOGPT_API_KEY`, `HYPERBOLIC_API_KEY`, `PERPLEXITY_API_KEY`, `XAI_API_KEY`, and `AZURE_OPENAI_API_KEY`. -- **Usage Accounting & Quota Surfacing**: `calculateOpenAIUsageAccounting` (`packages/ai/src/providers/openai-shared.ts`) reconciles input, output, cache-read, and cache-write tokens into standard `Usage` records. OpenRouter authoritative charges are populated into `output.usage.cost` via `applyOpenRouterReportedCost`. Copilot request counts are stored in `output.usage.premiumRequests`. Transport HTTP errors (e.g. 429 Rate Limit, 408 Timeout, 5xx Server Error) are thrown as `OpenAIHttpError` (`packages/ai/src/utils/openai-http.ts`), capturing status, headers, and error envelope details for upstream error mapping in `AIError.finalize`. +- **Usage Accounting & Quota Surfacing**: `calculateOpenAIUsageAccounting` (`packages/ai/src/providers/openai-shared.ts`) reconciles input, output, cache-read, and cache-write tokens into standard `Usage` records. OpenRouter and ClinePass authoritative gateway charges are populated into `output.usage.cost` via `applyProviderReportedCost`. Copilot request counts are stored in `output.usage.premiumRequests`. Transport HTTP errors (e.g. 429 Rate Limit, 408 Timeout, 5xx Server Error) are thrown as `OpenAIHttpError` (`packages/ai/src/utils/openai-http.ts`), capturing status, headers, and error envelope details for upstream error mapping in `AIError.finalize`. ### Catalog model handling - **Provider Descriptors**: `CATALOG_PROVIDERS` in `packages/catalog/src/provider-models/descriptors.ts` registers all catalog entries using this transport (e.g., `openai`, `groq`, `cerebras`, `mistral`, `deepseek`, `fireworks`, `openrouter`), specifying `api: "openai-completions"`, `defaultModel`, environment variable keys, and documentation URLs. @@ -66,11 +66,11 @@ The OpenAI Responses provider (`packages/ai/src/providers/openai-responses.ts`) - **Composite `callId|itemId` tool IDs**: `normalizeResponsesToolCallId` in `packages/ai/src/utils.ts` handles tool call ID normalization. Tool call identifiers in Responses are composite strings formatted as `${callId}|${itemId}`. The function splits incoming IDs on `|` into distinct `callId` (truncated to 64 chars with `call_` prefix) and `itemId` (prefixed with `fc_` or `ctc_`). When an un-synthesized ID is passed, it generates a hash-based pair (`call_` and `fc_` / `ctc_`). Transformed messages use `normalizeResponsesToolCallIdForTransform` to preserve alignment across tool calls and tool result messages. - **Custom (freeform) tools & computer tools**: Tool conversion in `convertTools` handles function, custom, and computer tools. When `model.applyPatchToolType === "freeform"` (checked via `supportsFreeformApplyPatch`), custom format tools (like `apply_patch`) are encoded as `type: "custom"` with grammar definitions (`compactGrammarDefinition`). When `model.supportsComputerUse === true`, native computer tools (`type: "computer"`) emit `computer_call` and `computer_call_output` items using structured `ComputerAction` lists; models without native computer support fall back to regular function tools. Tool schemas are sanitized via `sanitizeSchemaForOpenAIResponses` and `adaptSchemaForStrict`, and schemas violating strict constraints are quarantined (`findStrictToolSchemaViolation`) to prevent invalid MCP schemas from failing entire requests. - **Service tier & obfuscation opt-out**: `serviceTier` option is passed down to sampling params and reported in output usage via `processResponsesStream`. When `model.compat.supportsObfuscationOptOut` is true, sampling parameters include `stream_options: { include_obfuscation: false }`. -- **Image detail handling**: Image content conversion in `convertResponsesInputContent` and `appendResponsesToolResultMessages` respects `model.compat.supportsImageDetailOriginal`. When false, `"original"` image detail values are mapped to `"auto"` to prevent upstream rejection. Tool result images generate synthetic user input messages attached after tool outputs. +- **Image detail handling**: Image content conversion in `convertResponsesInputContent` and `appendResponsesToolResultMessages` respects `model.compat.supportsImageDetailOriginal`. When false, `"original"` image detail values are mapped to `"auto"` to prevent upstream rejection. The [provider compatibility reference](./provider-compat-reference.md) owns the multimodal tool-result encoding contract. ### Stream behavior - **Stream event protocol (`response.*` lifecycle)**: `processResponsesStream` in `openai-shared.ts` processes SSE events emitted by `/v1/responses`. Handles lifecycle events including `response.created`, `response.output_item.added`, `response.output_text.delta`, `response.reasoning_text.delta`, `response.reasoning_summary_text.delta`, `response.function_call_arguments.delta`, `response.custom_tool_call_input.delta`, `response.output_item.done`, `response.completed`, and `response.done`. Interleaved parallel tool calls are tracked concurrently across `output_index`, `item_id`, and prefixed call ID lookup maps (`openItemsByOutputIndex`, `openItemsByItemId`, `openItemsByPrefixedCallId`). -- **Watchdogs & transient retries**: `streamOpenAIResponsesOnce` uses `iterateWithIdleTimeout` with two timeout thresholds: `streamFirstEventTimeoutMs` (with `X-Stainless-Timeout` request header) for initial response headers/events and `streamIdleTimeoutMs` for inter-event stalls. If a stream terminates prematurely before emitting replay-unsafe output (`isOpenAIResponsesReplayUnsafeEvent`), the single-attempt streamer performs a transient retry (`OPENAI_RESPONSES_MAX_TRANSIENT_STREAM_RETRIES = 1`) after a delay (`OPENAI_RESPONSES_TRANSIENT_STREAM_RETRY_DELAY_MS = 500ms`). The public `streamOpenAIResponses` wraps execution with `withEmptyCompletionRetry` to retry empty completions. +- **Watchdogs & transient retries**: `streamOpenAIResponsesOnce` uses `iterateWithIdleTimeout` with two timeout thresholds: `streamFirstEventTimeoutMs` (with `X-Stainless-Timeout` request header) for initial response headers/events and `streamIdleTimeoutMs` for inter-event stalls. If a stream terminates prematurely before emitting replay-unsafe output (`isOpenAIResponsesReplayUnsafeEvent`), the single-attempt streamer performs a transient retry (`OPENAI_RESPONSES_MAX_TRANSIENT_STREAM_RETRIES = 1`) after a delay (`OPENAI_RESPONSES_TRANSIENT_STREAM_RETRY_DELAY_MS = 500ms`). The public `streamOpenAIResponses` wraps execution with `withReplaySafeStreamRetry` to retry empty completions. ### Auth & usage - Standard OpenAI auth relies on `OPENAI_API_KEY` (or provider-specific environment variables) resolved via `getEnvApiKey` and `resolveOpenAIRequestSetup` in `openai-shared.ts`. Requests pass standard Bearer token authorization headers (`Authorization: Bearer `) alongside optional Stainless/Copilot headers. *(Note: `openai-codex` / ChatGPT subscription plan OAuth auth is handled separately).* @@ -161,7 +161,7 @@ The Anthropic provider (`packages/ai/src/providers/anthropic.ts`) implements the ### Stream behavior - **Event Protocol**: SSE streams in `streamAnthropicOnce` (`packages/ai/src/providers/anthropic.ts`) emit standard framing events: `message_start` (delivering initial input and cache usage), `content_block_start` (initializing block types: text, thinking, tool_use, redacted_thinking, fallback), `content_block_delta` (streaming `text_delta`, `thinking_delta`, `signature_delta`, `input_json_delta`), `message_delta` (delivering `stop_reason` and final `output_tokens`), `content_block_stop`, `message_stop`, and `ping`. - **Fine-Grained Tool Streaming**: Enabled via `fine-grained-tool-streaming-2025-05-14` beta. Incoming `input_json_delta` chunks accumulate in `kStreamingPartialJson`, parsed continuously by `parseStreamingJsonThrottled` to surface streaming tool arguments. -- **Stream Watchdogs & Healing**: Streams are monitored for stall timeouts using `getStreamFirstEventTimeoutMs` and `getStreamIdleTimeoutMs` inside `iterateWithIdleTimeout`. `ping` events (`ANTHROPIC_PING_EVENT`) reset idle timeout multipliers. Empty completion responses (0 tokens) trigger automatic retry via `withEmptyCompletionRetry`. Fast mode (`speed: "fast"`) failures clear session fast mode state (`clearAnthropicFastModeFallback`, `dropAnthropicFastMode`) to fallback to standard execution. +- **Stream Watchdogs & Healing**: Streams are monitored for stall timeouts using `getStreamFirstEventTimeoutMs` and `getStreamIdleTimeoutMs` inside `iterateWithIdleTimeout`. `ping` events (`ANTHROPIC_PING_EVENT`) reset idle timeout multipliers. Empty completion responses (0 tokens) trigger automatic retry via `withReplaySafeStreamRetry`. Fast mode (`speed: "fast"`) failures clear session fast mode state (`clearAnthropicFastModeFallback`, `dropAnthropicFastMode`) to fallback to standard execution. ### Auth & usage - **OAuth Authentication & PKCE**: `AnthropicOAuthFlow` (`packages/ai/src/registry/oauth/anthropic.ts`) performs PKCE `S256` authentication against `https://claude.ai/oauth/authorize` and `https://api.anthropic.com/v1/oauth/token` using decoded Client ID (`OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl`). OAuth tokens carry an absolute grant TTL of 30 days (`ANTHROPIC_OAUTH_GRANT_TTL_MS` in `anthropic-constants.ts`), requiring monthly interactive re-login regardless of refresh token rotation. Account identity is resolved via `extractAccountFromTokenResponse` or `fetchBootstrapIdentity` (`/api/claude_cli/bootstrap`). @@ -409,7 +409,7 @@ The Ollama integration consists of two distinct provider definitions in `package - **Stream Markup Healing**: Stream markup healing (`StreamMarkupHealing` using `getStreamMarkupHealingPattern`) is engaged for text-channel tool call and reasoning recovery. When native `chunk.message.thinking` is present, `suppressHealedThinking` is set to `true` to avoid double-counting reasoning blocks. - **Finish Reason Mapping**: `mapDoneReason` maps `done_reason`: `"length"` -> `"length"`, `"tool_calls"` -> `"toolUse"`, `"load"` -> `"error"`, and `undefined` with tool calls -> `"toolUse"`. Natural `stop` with produced tool calls is promoted to `"toolUse"`. - **Watchdogs & Local Prefill**: Pre-response timeout is armed via `armPreResponseTimeout` with `firstEventTimeoutMs` (derived from `PI_STREAM_FIRST_EVENT_TIMEOUT_MS` or `idleTimeoutMs`) while `timeout: false` is passed to `fetchWithRetry` to avoid premature Bun fetch timeout aborts during heavy local prefill. Retries use delays `[2000, 5000, 10000]`. -- **Empty Completion Retry**: `streamOllama` is wrapped with `withEmptyCompletionRetry` to transparently retry EOS-only empty completions. +- **Empty Completion Retry**: `streamOllama` is wrapped with `withReplaySafeStreamRetry` to transparently retry EOS-only empty completions. ### Auth & usage - **Credential Source**: `loginOllama` (`packages/ai/src/registry/ollama.ts`) prompts for an optional API key (`allowEmpty: true`), defaulting to no-auth local usage with `envVars: ["OLLAMA_API_KEY"]`. `loginOllamaCloud` (`packages/ai/src/registry/ollama-cloud.ts`) mandates an API key created at `https://ollama.com/settings/keys` with `envVars: ["OLLAMA_CLOUD_API_KEY"]`. @@ -495,7 +495,8 @@ The Devin integration (`devin-agent` API) communicates with Codeium Cascade back * User/developer messages map to `ChatMessageSource.USER` with deterministic message IDs (`cascadeId\0index\0role`). * Assistant messages map to `ChatMessageSource.SYSTEM` with text, `thinking`, `signature`, and `toolCalls`. Native Devin assistant turns preserve `responseId` or fall back to `bot-`. * Tool results map to `ChatMessageSource.TOOL` with `toolCallId` and `toolResultIsError`. -* **Session Threading & Stop Patterns:** Session threading passes `options.conversationId` or `options.sessionId` as `cascadeId`. Default stop patterns include `<|user|>`, `<|bot|>`, `<|context_request|>`, `<|endoftext|>`, and `<|end_of_turn|>` (`DEVIN_DEFAULT_STOP_PATTERNS`). Tool selection specifies `auto` choice with `disableParallelToolCalls: true` and ephemeral system prompt caching (`CacheControlType.EPHEMERAL`). +* **Session Threading & Stop Patterns:** Session threading passes `options.conversationId` or `options.sessionId` as `cascadeId`. Default stop patterns include `<|user|>`, `<|bot|>`, `<|context_request|>`, `<|endoftext|>`, and `<|end_of_turn|>` (`DEVIN_DEFAULT_STOP_PATTERNS`). Tool selection specifies `auto` choice and ephemeral system prompt caching (`CacheControlType.EPHEMERAL`); `disableParallelToolCalls` is the inverse of the catalog's `compat.supportsParallelToolCalls`, so configs that natively allow parallel tools can use them. +* **Router Assignment:** Catalog configs with `compat.modelRouter` (currently `adaptive`) are server-side dispatchers, not valid `chatModelUid`s. Before chatting, `assignDevinModel` calls `AssignModel` with the current user/developer prompt and the turn's `cascadeId`, then sends the returned `modelUid` plus `modelAssignmentJwt` on the matching `GetChatMessage` request. A missing assignment fails the turn; the response's `actualModelUid` is surfaced as `AssistantMessage.upstreamModel`. ### Stream behavior * **Protobuf Frame Streaming:** `streamDevin` reads chunked response bytes, parsing 5-byte Connect headers. Decompressed binary payloads are decoded into `GetChatMessageResponseSchema`. @@ -512,14 +513,17 @@ The Devin integration (`devin-agent` API) communicates with Codeium Cascade back * **Session Token Prefixing:** API key credentials are normalized via `normalizeDevinSessionToken` to ensure a `devin-session-token$` prefix. * **JWT Exchange:** `fetchDevinAuthMetadata` sends an initial Connect request (`GetUserJwtRequestSchema`) to `/exa.auth_pb.AuthService/GetUserJwt` using `apiKey` inside `MetadataSchema`. The server returns a `userJwt` (and optional server base URL override) which is included in subsequent chat request metadata. * **CLI OAuth Flow:** `loginDevin` in `packages/ai/src/registry/oauth/devin.ts` executes a PKCE OAuth flow using `https://app.devin.ai/auth/cli/continue`. Tokens are exchanged at `https://api.devin.ai/auth/cli/token` (`exchangeDevinCliToken`) with expiration derived from JWT payload or a 1-year default fallback. -* **Usage Surface:** Devin does not have a separate usage endpoint provider under `packages/ai/src/usage/` (unlike `umans`). Streaming response frames include token counts (`msg.usage`: `inputTokens`, `outputTokens`, `cacheReadTokens`, `cacheWriteTokens`), which feed directly into `calculateCost(model, output.usage)`. +* **Usage Surface:** Streaming response frames include token counts (`msg.usage`: `inputTokens`, `outputTokens`, `cacheReadTokens`, `cacheWriteTokens`), which feed directly into `calculateCost(model, output.usage)`, plus credit metering (`creditCost`, `committedCreditCost`, `committedAcuCost`) surfaced on `usage.credits`. Account plan and balance reporting uses `devinUsageProvider` (`packages/ai/src/usage/devin.ts`), which calls `SeatManagementService/GetUserStatus` with the native CLI identity and maps prompt/flow/flex credit buckets, dated daily/weekly quota windows, plan tier, overage balance, and account/org identity into `/usage`. Credit-billed plans omit undated percent windows so they do not render as exhausted quotas. ### Catalog model handling -* **Model Manager Config:** `devinModelManagerOptions` in `packages/catalog/src/provider-models/special.ts` configures dynamic discovery with `dynamicModelsAuthoritative: true` when an API key is available. `descriptors.ts` registers `devin` in `CATALOG_PROVIDERS` (`DEVIN_API_KEY`, OAuth provider `devin`). -* **Dynamic Discovery:** `fetchDevinModels` in `packages/catalog/src/discovery/devin.ts` invokes the unary Connect RPC `GetCliModelConfigs` (`/exa.api_server_pb.ApiServerService/GetCliModelConfigs`) with `MetadataSchema`. `normalizeDevinModels` converts `ClientModelConfig` into `ModelSpec<"devin-agent">` entries (defaulting to 200k context window, 64k max tokens). -* **Thinking Detection:** `supportsDevinThinking` checks label regex patterns (`/think|thinking|minimal|high|medium|low|xhigh|max|reasoning/i` vs `/\bno thinking\b/i`) and `modelInfo.modelFeatures.supportsThinking`. +* **Model Manager Config:** `devinModelManagerOptions` in `packages/catalog/src/provider-models/special.ts` configures dynamic discovery with `dynamicModelsAuthoritative: true` when an API key is available. `descriptors.ts` registers `devin` in `CATALOG_PROVIDERS` (`DEVIN_API_KEY`, OAuth provider `devin`, `defaultModel: "swe-1-6"`). +* **Static Seed:** Cascade's catalog is credential-scoped, so catalog generation without a `DEVIN_API_KEY` fetches nothing and never marks the provider authoritative — the previous `models.json` snapshot would otherwise be retained forever. `DEVIN_STATIC_MODELS` (`special.ts`) seeds both live SWE-1.6 lanes (`swe-1-6-fast`, `swe-1-6`) as `staticModels` and is pushed unconditionally by `scripts/generate-models.ts`; `CREDENTIAL_SCOPED_PROVIDERS` there keeps Devin out of generation-time fetch and drops its previous-snapshot rows (retiring the dead `devin/swe-1-6-slow` row). A configured `baseUrl` re-points the seed at that host. +* **Dynamic Discovery:** `fetchDevinModels` in `packages/catalog/src/discovery/devin.ts` invokes the unary Connect RPC `GetCliModelConfigs` (`/exa.api_server_pb.ApiServerService/GetCliModelConfigs`) with the native `chisel` discovery metadata from `packages/catalog/src/wire/devin.ts` and every supported display slot. `normalizeDevinModels` drops disabled/internal configs, converts `ClientModelConfig` into `ModelSpec<"devin-agent">` entries (defaulting to 200k context window, 64k max tokens), and preserves server-supplied output caps, pricing dimensions, tool/parallel-tool/image support, description, and `new`/`beta`/`recommended` badges. Exception: `DEVIN_IMAGE_BLIND_UIDS` strips the image modality from `swe-1-6`/`swe-1-6-fast`, whose configs advertise `supports_images` while the backend silently drops the `ChatMessagePrompt.images` field (verified live; every other model reads it). An empty-but-200 catalog response logs a stale-identity-pin warning. Router configs (`displayOption MODEL_ROUTER` or `isModelRouter`) stay standalone with `compat.modelRouter`. +* **Family Collapse:** Server `modelFamilyMetadata` effort lanes collapse first, keyed by the normalized family label and split into a `-fast` sibling for Fast Mode order 1; the server's default member becomes the collapsed spec's `requestModelId` and `thinking.defaultLevel`. The static `DEVIN_VARIANT_COLLAPSE_TABLE` then handles known families whose live config lacks family metadata. +* **Thinking Detection:** `supportsDevinThinking` prefers `modelInfo.modelFeatures.supportsThinking`; the label regex patterns (`/think|thinking|minimal|high|medium|low|xhigh|max|reasoning/i` vs `/\bno thinking\b/i`) are only the no-features fallback. * **Compat Resolution:** `buildDevinCompat` in `packages/catalog/src/compat/devin.ts` sets `trustExplicitThinkingOnly: true` (`ResolvedDevinCompat`), preventing implicit effort ladder inference (`model-thinking.ts`). * **Reasoning Effort Routing:** Devin models use sibling model routing instead of wire reasoning fields (`variant-collapse.ts`). `DEVIN_VARIANT_COLLAPSE_TABLE` maps model families (e.g. `gpt-5-6-luna`, `claude-opus-5`) across wire effort levels (`low`, `medium`, `high`, `xhigh`, `max`) to specific routed sibling model UIDs. +* **Selector Parity:** `DEVIN_VARIANT_COLLAPSE_TABLE.providerAliases` mirrors the native CLI's short labels (`opus`, `claude`/`sonnet`, `haiku`, `gemini`, `gpt`, `codex`, `swe`) and dotted upstream spellings (`gpt-5.6-terra`, `gemini-3.7-flash`, `swe-1.7-lightning`, `grok-4.6`, `glm-5.2`, `claude-haiku-4.5`). Provider aliases resolve only through `resolveVariantAlias(provider, id)` — they are deliberately absent from `resolveBareVariantAlias` and the reverse index, so a bare `gpt` or `opus` keeps its global meaning and cannot re-key config. Families collapsed only at discovery time carry no hand-table alias, so `resolveProviderModelReference` (`packages/coding-agent/src/config/model-resolver.ts`) also reverse-resolves any raw wire uid found in a live model's `thinking.effortRouting`; an exact live model id still wins. ## GitLab Duo @@ -1009,7 +1013,7 @@ LiteLLM is an open-source AI proxy and gateway that unifies access to multiple L - **Anthropic & Bedrock tool compatibility (`packages/ai/src/providers/openai-completions.ts`)**: - When `context.tools` is `undefined` but conversation history contains tool calls, `params.tools` is set to `[]` for Anthropic-via-LiteLLM compatibility. - When `context.tools` is explicitly empty (`[]`, e.g., `/btw` or background turns), `params.tools` and `tool_choice: "none"` are omitted so LiteLLM → Bedrock routes do not generate invalid, empty `toolConfig` blocks. -- **Telemetry & gateway header detection (`packages/ai/src/telemetry.ts`, `packages/ai/src/auth-gateway/http.ts`)**: `detectGatewayFromHeaders` inspects `x-litellm-call-id` (falling back to `x-litellm-model-id` or `x-litellm-model-group`) to populate `pi.gen_ai.gateway.*` span attributes. Auth gateway HTTP endpoints expose `x-litellm-model-id`, `x-litellm-model-api-base`, `x-litellm-response-cost`, and `x-litellm-response-duration-ms`. +- **Telemetry & gateway header detection (`packages/agent/src/telemetry.ts`, `packages/ai/src/auth-gateway/http.ts`)**: `detectGatewayFromHeaders` inspects `x-litellm-call-id` (falling back to `x-litellm-model-id` or `x-litellm-model-group`) to populate `pi.gen_ai.gateway.*` span attributes. Auth gateway HTTP endpoints expose `x-litellm-model-id`, `x-litellm-model-api-base`, `x-litellm-response-cost`, and `x-litellm-response-duration-ms`. ### Auth & usage - **Credentials & env (`packages/catalog/src/provider-models/descriptors.ts`, `packages/ai/src/registry/litellm.ts`)**: Authenticates via `LITELLM_API_KEY`. @@ -1312,7 +1316,7 @@ OpenRouter is a unified multi-provider routing gateway serving hundreds of third ### Auth & usage - **Auth Key Validation via `/api/v1/auth/key`**: `loginOpenRouter` in `packages/ai/src/registry/openrouter.ts` configures API key validation using `validateApiKeyAgainstModelsEndpoint` targeted at `https://openrouter.ai/api/v1/auth/key`. Public `/api/v1/models` returns HTTP 200 for unauthenticated requests, so `/api/v1/auth/key` is used as the canonical identity check (returning 200 for valid keys, 401 otherwise). Key resolution checks `OPENROUTER_API_KEY` via `getEnvApiKey` in `packages/ai/src/stream.ts`. -- **Authoritative Reported Cost Reconciling**: `applyOpenRouterReportedCost` in `packages/ai/src/providers/openai-shared.ts` extracts `rawUsage.cost` echoed in API responses. If estimated token cost is finite and positive, input, output, cache-read, and cache-write costs are scaled by `reportedCost / estimatedCost` to match OpenRouter's exact billable total; otherwise, `usage.cost.input` is assigned the reported cost directly. +- **Authoritative Reported Cost Reconciling**: `applyProviderReportedCost` in `packages/ai/src/providers/openai-shared.ts` extracts `rawUsage.cost` echoed by OpenRouter and ClinePass. If estimated token cost is finite and positive, input, output, cache-read, and cache-write costs are scaled by `reportedCost / estimatedCost` to match the exact billable total; otherwise, `usage.cost.input` is assigned the reported cost directly. ### Catalog model handling - **Descriptor & Unauthenticated Discovery**: Registered as `openrouter` in `CATALOG_PROVIDERS` (`packages/catalog/src/provider-models/descriptors.ts`), with `defaultModel: "openai/gpt-5.5"`, `envVars: ["OPENROUTER_API_KEY"]`, and `catalogDiscovery: { label: "OpenRouter", allowUnauthenticated: true }`. @@ -1678,8 +1682,8 @@ Z.AI provides GLM family models (such as `glm-5.2`) via Zhipu AI's coding plan i - **API Key Login**: `loginZai` in `packages/ai/src/registry/zai.ts` prompts for `ZAI_API_KEY` (dashboard `https://z.ai/manage-apikey/apikey-list`) and validates via a chat completions probe against `https://api.z.ai/api/coding/paas/v4` with model `glm-5.2` (`VALIDATION_MODEL`). - **OAuth flow & browser sign-in**: `zaiCodingPlanProvider` (`packages/ai/src/registry/zai.ts`) routes sign-in to `loginZaiOAuth` / `ZaiOAuthFlow` (`packages/ai/src/registry/oauth/zai.ts`). It initiates authorization at `AUTHORIZE_URL` (`https://chat.z.ai/api/oauth/authorize`, callback port 54548 / paste code fallback) and exchanges authorization codes at `TOKEN_URL` (`https://zcode.z.ai/api/v1/oauth/token`). - **Durable key minting**: `mintZaiApiKey` (`packages/ai/src/registry/oauth/zai.ts`) exchanges the short-lived OAuth token for a business token via `businessLogin` (`https://api.z.ai/api/auth/z/login`), resolves default org/project via `getCustomerInfo` (`BIZ_BASE` = `https://api.z.ai`), creates or reuses key `"oh-my-pi"` (`KEY_NAME`), and copies the secret via `/copy/${apiKey}` to output a durable 49-char `${apiKey}.${secretKey}` token saved as `storeCredentialsAs: "zai"`. -- **Usage & quota fetcher**: `fetchZaiUsage` / `zaiUsageProvider` (`packages/ai/src/usage/zai.ts`) queries `QUOTA_PATH` (`/api/monitor/usage/quota/limit`) on `DEFAULT_ENDPOINT` (`https://api.z.ai`) with direct key authorization. `parseLimitItem` parses `TOKENS_LIMIT` into token quotas (`zai:tokens:`) and `TIME_LIMIT` into request quotas (`zai:requests:` or `zai:features:zread:` when `isZaiFeatureRequestLimit` matches). `buildZaiWindow` maps time units to 1h, 1d, 1mo, or 1w windows, and optionally fetches `MODEL_USAGE_PATH` (`/api/monitor/usage/model-usage`). -- **Credential ranking**: `zaiRankingStrategy` (`packages/ai/src/usage/zai.ts`, registered in `packages/ai/src/auth-storage.ts`) ranks request limits via `rankZaiRequestLimits`, selecting primary 5-hour and secondary weekly quota windows. +- **Usage & quota fetcher**: `fetchZaiUsage` / `zaiUsageProvider` (`packages/ai/src/usage/zai.ts`) queries `QUOTA_PATH` (`/api/monitor/usage/quota/limit`) on `DEFAULT_ENDPOINT` (`https://api.z.ai`) with direct key authorization. `parseLimitItem` parses `TOKENS_LIMIT` into token quotas (`zai:tokens:`), `TIME_LIMIT` into request quotas (`zai:requests:` or `zai:features:zread:` when `isZaiFeatureRequestLimit` matches), and `CREDIT_LIMIT` into credit quotas (`zai:credits:`, unit `credits`) for the credit-based GLM Coding Plan (e.g. 12k credits / 5h + 60k credits / week; `usage` is the allotment, `currentValue` the spend). The payload's `data.level` (e.g. `"lite"`, `"pro"`, `"max"`) is surfaced as `metadata.planType`. `buildZaiWindow` maps time units to 1h, 1d, 1mo, or 1w windows, and optionally fetches `MODEL_USAGE_PATH` (`/api/monitor/usage/model-usage`). +- **Credential ranking**: `zaiRankingStrategy` (`packages/ai/src/usage/zai.ts`, registered in `packages/ai/src/auth-storage.ts`) ranks request limits via `rankZaiRequestLimits` (falling back to the full credential limit set — tokens/requests/credits — when no request quotas exist), selecting primary 5-hour and secondary weekly quota windows. ### Catalog model handling - **Descriptor & PAYG pricing**: `MODELS_DEV_PROVIDER_DESCRIPTORS_CODING_PLANS` in `packages/catalog/src/provider-models/openai-compat.ts` defines `anthropicMessagesDescriptor("zai", "zai", "https://api.z.ai/api/anthropic")`, mapping models.dev `zai` pay-as-you-go pricing key instead of `zai-coding-plan` to avoid surfacing subscription rates as all-$0 Free models (#5598). diff --git a/docs/provider-streaming-internals.md b/docs/provider-streaming-internals.md index 729563e62c12..5764af6f037e 100644 --- a/docs/provider-streaming-internals.md +++ b/docs/provider-streaming-internals.md @@ -5,7 +5,7 @@ This document explains how token/tool streaming is normalized in `@oh-my-pi/pi-a ## End-to-end flow 1. `streamSimple()` (`packages/ai/src/stream.ts`) maps generic options and dispatches to a provider stream function. Heavy built-ins are reached through the lazy wrappers in `packages/ai/src/providers/register-builtins.ts`; thin routing wrappers remain eager. -2. Provider stream functions translate provider-native stream events into the unified `AssistantMessageEvent` sequence. Current built-ins include Anthropic, OpenAI Responses/Completions/Codex/Azure Responses, Google Gemini/Gemini CLI/Vertex, Bedrock Converse, Ollama, Cursor, Devin, pi-native gateway transport, plus GitLab Duo/Kimi/Synthetic wrappers and extension-registered custom APIs. +2. Provider stream functions translate provider-native stream events into the unified `AssistantMessageEvent` sequence. Current built-ins include Anthropic, OpenAI Responses/Completions/Codex/Azure Responses, Google Gemini/Gemini CLI/Vertex, Bedrock Converse, Ollama, Cursor, Devin, pi-native gateway transport, plus GitLab Duo, GitLab Duo Workflow, Kimi, and Synthetic wrappers, and extension-registered custom APIs. (xAI Grok has no dedicated wrapper: both `xai-oauth` and API-key `xai` models are catalog specs with `api: "openai-responses"` at `https://api.x.ai/v1`, riding the shared OpenAI Responses path with catalog-level compat.) 3. Each provider pushes events into `AssistantMessageEventStream` (`packages/ai/src/utils/event-stream.ts`), which exposes: - async iteration for incremental updates - `result()` for the final `AssistantMessage` diff --git a/docs/providers.md b/docs/providers.md index 43a0d168a880..542fad995346 100644 --- a/docs/providers.md +++ b/docs/providers.md @@ -51,6 +51,8 @@ For headless or remote setups backed by a shared auth broker, the CLI exposes `o When a model has no credentials, `omp` tells you to run `/login` or set the provider's environment variable. +For ClinePass, set `CLINE_API_KEY` or run `/login cline-pass` to open the Cline dashboard and validate a newly created API key. OMP refreshes membership from Cline's public recommended-models endpoint and bundles the current sixteen-model roster with Cline-authored limits, subscription pricing, modalities, and per-model reasoning controls for offline startup. New live ids remain selectable before regeneration, using conservative metadata rather than guessed controls. `omp usage` reports five-hour, weekly, and monthly quota windows. Free-tier models are marked `(free)` and work with the same key on any Cline account; subscription models show API-equivalent reference pricing, while streamed gateway cost remains authoritative for actual billed or discounted usage. Requests mirror Cline CLI client headers and a stable per-session task id, Qwen routes use Cline's prompt-cache shape, and Qwen3.7 Plus maps thinking levels to the gateway's token-budget field. + ### Pinning a key in `models.yml` A custom provider's `apiKey` is resolved as **environment-variable-name-or-literal**: if the value names an existing environment variable, that variable's value is used; otherwise the string itself is the key. Prefixing the value with `!` runs it as a shell command and uses the trimmed stdout (see [Model and Provider Configuration](./models.md) for the full value syntax). @@ -80,6 +82,7 @@ Each provider has one or more environment variables that supply a key when no st | Provider ID | Environment variable(s) | | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | | `anthropic` | `ANTHROPIC_OAUTH_TOKEN`, then `ANTHROPIC_API_KEY` (Foundry mode prefers `ANTHROPIC_FOUNDRY_API_KEY` when `CLAUDE_CODE_USE_FOUNDRY=true`) | +| `claude-code` | none (uses Claude Code's own login; run `claude login`) | | `openai` | `OPENAI_API_KEY` | | `openai-codex` | `OPENAI_CODEX_OAUTH_TOKEN` | | `google` | `GEMINI_API_KEY` | @@ -120,7 +123,7 @@ Each provider has one or more environment variables that supply a key when no st | `novita` | `NOVITA_API_KEY` | | `venice` | `VENICE_API_KEY` | | `vercel-ai-gateway` | `AI_GATEWAY_API_KEY` (also `VERCEL_AI_GATEWAY_API_KEY` for catalog discovery) | -| `cloudflare-ai-gateway` | `CLOUDFLARE_AI_GATEWAY_API_KEY` | +| `cloudflare-ai-gateway` | `CLOUDFLARE_AI_GATEWAY_API_KEY` + `CLOUDFLARE_ACCOUNT_ID` + `CLOUDFLARE_GATEWAY_ID` | | `litellm` | `LITELLM_API_KEY`; optional `LITELLM_BASE_URL` for the proxy endpoint | | `kilo` | `KILO_API_KEY` | | `zai` | `ZAI_API_KEY` | @@ -138,6 +141,7 @@ Each provider has one or more environment variables that supply a key when no st | `aimlapi` | `AIMLAPI_API_KEY` | | `gitlab-duo`, `gitlab-duo-agent` | `GITLAB_TOKEN` | | `opencode-zen`, `opencode-go` | `OPENCODE_API_KEY` | +| `cline-pass` | `CLINE_API_KEY` | | `firepass` | `FIREPASS_API_KEY` | | `wafer-serverless` | `WAFER_SERVERLESS_API_KEY` | | `xiaomi` | `XIAOMI_API_KEY` | @@ -149,8 +153,11 @@ Each provider has one or more environment variables that supply a key when no st | `lm-studio` | `LM_STUDIO_API_KEY` (optional; keyless by default) | | `llama.cpp` | `LLAMA_CPP_API_KEY` (only when the server requires auth) | | `vllm` | `VLLM_API_KEY` (optional for an unauthenticated local server) | +| `yolo-auto` | `YOLO_AUTO_API_KEY` | + +`/login cloudflare-ai-gateway` prompts for the gateway token, Cloudflare account ID, and gateway ID, then stores all three together. To use environment variables, set all three values listed above. OMP selects the Anthropic, OpenAI, or Workers AI gateway route for each model; you do not need a `models.yml` base URL override. -OAuth-backed providers such as `anthropic`, `github-copilot`, `cursor`, `ollama-cloud`, `qwen-portal`, `kimi-code`, `xai-oauth`, `wafer-serverless`, `google-gemini-cli`, and `google-antigravity` are normally reached through `/login` rather than an environment variable. See [Environment variables](./environment-variables.md) for search-tool and configuration variables not listed here. +OAuth-backed providers such as `anthropic`, `github-copilot`, `cursor`, `ollama-cloud`, `qwen-portal`, `kimi-code`, `xai-oauth`, `wafer-serverless`, `google-gemini-cli`, `google-antigravity`, `devin`, and the GitLab providers (`gitlab-duo`, `gitlab-duo-agent`) are normally reached through `/login` rather than an environment variable; `claude-code` is similar but detects Claude Code's login instead of running OAuth. Interactive API-key logins exist too: `/login baseten`, `/login coreweave`, and `/login sakana` prompt for a dashboard/API key (`coreweave` additionally requires `COREWEAVE_PROJECT` for the `OpenAI-Project` header). See [Environment variables](./environment-variables.md) for search-tool and configuration variables not listed here. ### `.env` discovery and precedence @@ -180,6 +187,10 @@ OLLAMA_BASE_URL=http://127.0.0.1:11434 - values containing a NUL byte are dropped; - an `OMP_`-prefixed key is also mirrored to the matching `PI_`-prefixed name. +### Claude Code (subscription) + +`claude-code` runs turns through the Claude Agent SDK, which spawns your installed Claude Code binary. Your Pro/Max/Team subscription is billed the same way Claude Code bills it, and no token is stored in omp. Log in once with `claude login`, then `/login claude-code` to confirm and `--model claude-code/opus` (aliases `opus`, `sonnet`, `haiku` or explicit ids). Claude Code executes its own tools; omp shows them in the transcript and routes each permission request through `tools.approvalMode` and `tools.approval.claude-code.`. Set `OMP_CLAUDE_CODE_EXECUTABLE` to pin a specific binary. The subprocess loads project-level Claude Code configuration (`.claude/settings.json`, `.claude/settings.local.json`, `CLAUDE.md`) but not your global `~/.claude/settings.json`, so user-level hooks such as a Stop hook never run inside an omp turn. Override with `OMP_CLAUDE_CODE_SETTING_SOURCES` (comma list of `user`, `project`, `local`; `all` matches the Claude Code CLI default, `none` isolates the subprocess completely). + ## Built-in local engines Three local engines are discovered automatically without needing a `models.yml` entry. Each uses a base URL that can be overridden by an environment variable: @@ -319,6 +330,25 @@ providers: maxTokens: 8192 ``` +### Zhipu BigModel account-balance keys + +`/login zai` targets the global Z.AI Coding Plan endpoint, and `/login zhipu-coding-plan` targets the domestic Zhipu Coding Plan endpoint. Neither flow configures the general pay-as-you-go BigModel endpoint at `https://open.bigmodel.cn/api/paas/v4`. + +Use a custom provider for an API key issued from a standard BigModel account balance: + +```yaml +providers: + bigmodel: + baseUrl: https://open.bigmodel.cn/api/paas/v4 + api: openai-completions + apiKey: BIGMODEL_API_KEY + models: + - id: glm-4.6 + name: GLM-4.6 (BigModel) +``` + +Set `BIGMODEL_API_KEY` to the `.` key before starting `omp`, then select `bigmodel/glm-4.6`. The key does not use an `sk-` prefix. + Keyless local provider (no credentials required): ```yaml diff --git a/docs/python-repl.md b/docs/python-repl.md index 2fac77bbbb40..ace1bdb0fac7 100644 --- a/docs/python-repl.md +++ b/docs/python-repl.md @@ -92,7 +92,7 @@ The runner's source transformer rewrites IPython-style magics to plain Python ca | `%reset` | Clear user globals and re-inject prelude. | | `%load ` | Read a file into a fresh cell and execute. | | `%run ` | `runpy.run_path` and merge globals back. | -| `%%bash` / `%%sh` | Run the cell body via `bash`/`sh`. | +| `%%bash` | Run the cell body via `bash`. The only registered shell cell magic — `%%sh` does not exist, and unregistered names raise `Cell magic function '%%' not found`. | | `%%capture [name]` | Run body with stdout/stderr captured into `name`. | | `%%timeit` | Time the cell body. | | `%%writefile ` | Write body to file. | diff --git a/docs/session-operations-export-share-fork-resume.md b/docs/session-operations-export-share-fork-resume.md index a1cce4f78b54..12ecb52572b3 100644 --- a/docs/session-operations-export-share-fork-resume.md +++ b/docs/session-operations-export-share-fork-resume.md @@ -26,8 +26,9 @@ This document describes operator-visible behavior for session export, sharing, c | `/fork` | Interactive slash command | Yes (active session identity changes) | Creates new session file and switches current session to it (persistent mode only) | Copies artifact directory to new session namespace when present | | `--fork ` | CLI startup | Yes after session creation | Creates a new session fork from the selected source into current cwd/session dir | None | | `/resume [id\|@claude\|@codex]` | Interactive slash command | Yes (active in-memory state replaced) | Switches to a selected/matched session, or imports a selected foreign session | None | -| `--resume` | CLI startup picker | Yes after session creation | Opens selected existing session file | None | +| `--resume` | CLI startup picker | Yes after session creation | Opens selected existing session file (picker opens in current-folder scope; the global list is preloaded only for the empty-everything early exit and instant Tab switching) | None | | `--resume ` | CLI startup | Yes after session creation | Opens existing session; a missing recorded cwd may be re-rooted into the current directory | None | +| `/restart` | Interactive slash command | Yes (process relaunches) | Relaunches omp with the original launch flags and resumes the current session in place | None | | `--continue` | CLI startup | Yes after session creation | Opens terminal breadcrumb or most-recent session; creates new one if none exists | None | ## Export and dump @@ -269,10 +270,10 @@ Use `--prompt-cache-key ` to pin the provider prompt-cache identity explici Without an argument: -1. Opens the session selector populated via `SessionManager.list(currentCwd, currentSessionDir)`. -2. The picker starts in current-folder scope; Tab toggles to all-projects scope, lazily loading and caching `SessionManager.listAll()`. -3. On selection, `SelectorController.handleResumeSession(sessionPath)` calls `session.switchSession(sessionPath)`. -4. UI clears/rebuilds chat and todos, then reports `Resumed session` (or `Resumed session in ` when the resumed session belongs to another project, in which case the process cwd and cwd-derived caches are re-pointed via `applyCwdChange`). +1. Opens the session selector populated via `SessionManager.list(currentCwd, currentSessionDir)`. The picker always opens in current-folder scope; the empty state (`No sessions in current folder. Press Tab to view all.`) invites Tab into all-projects instead of auto-switching (issue #3099). +2. Tab toggles to all-projects scope, lazily loading and caching `SessionManager.listAll()`. +3. On selection, `SelectorController.handleResumeSession(sessionPath)` calls `session.switchSession(sessionPath)`. If the switch is rejected, it returns `false` and the selector stops without applying the new-session UI state. +4. After a successful switch, UI clears/rebuilds chat and todos, then reports `Resumed session` (or `Resumed session in ` when the resumed session belongs to another project, in which case the process cwd and cwd-derived caches are re-pointed via `applyCwdChange`). With an argument: @@ -283,8 +284,8 @@ With an argument: ### `--resume` (no value) -- `main.ts` lists sessions for the current cwd/sessionDir and opens the picker in current-folder scope. When that list is empty it preloads `SessionManager.listAll()` so a user-initiated Tab switch to all-projects scope is immediate; it does not auto-switch scopes. `No sessions found` is printed only when the global list is also empty. -- Selected path is opened with `SessionManager.open(selectedPath)` before session creation. Selecting a session from another project first switches the process into that project's directory and reloads cwd-scoped settings/caches. +- `main.ts` lists sessions for the current cwd/sessionDir and opens the picker in current-folder scope. When that list is empty it preloads `SessionManager.listAll()` so a user-initiated Tab switch to all-projects scope is immediate; it does not auto-switch scopes (issue #3099). `No sessions found` is printed only when the global list is also empty. +- Selected path is opened with `SessionManager.open(selectedPath)` before session creation; the process/project scope then switches to the resumed session's cwd (`switchToResumedProject`), reloading cwd-scoped settings and plugin caches and re-resolving scoped models. ### `--resume ` @@ -332,7 +333,8 @@ This is startup-only behavior; there is no interactive `/continue` slash command 9. Restore configured/effective thinking and per-family service tiers, falling back to current settings when the target branch has no corresponding entries. 10. For a different transcript, reset memory context; for any conversation rewrite, clear session-scoped tool state. 11. Reconnect agent events, run the optional session-switch reconciler (interactive mode uses it to re-enter persisted modes such as plan), and best-effort refresh the workspace-root system-prompt block. Reconciler/prompt-refresh errors are logged rather than rolling back the committed switch. -12. Restore target advisor cost state, finish the bash transition, and notify session-change callbacks when the session id changed. +12. Restore target advisor cost state, finish the bash transition, notify session-change callbacks when the session id changed, and return `true`. +`switchSession()` returns `false` when a before-switch hook cancels or cwd policy rejects the transition. A cross-project switch without a cwd-change callback is rejected rather than silently adopting the target cwd; callback rejection is also cancellation. The interactive selector checks this result and leaves the existing session/UI unchanged. If a throwing step in the guarded transition fails, `switchSession()` restores the captured session, agent queues/messages, tools/prompts, model/thinking/service-tier, provider/cache, memory, and checkpoint state; it reconnects the prior agent subscription and re-runs mode reconciliation before rethrowing. @@ -352,6 +354,7 @@ For `newSession`, `fork`, and `switchSession`: - includes `previousSessionFile` `ExtensionRunner.emit()` returns early on the first cancelling before-event result. +When a before-switch hook cancels, `switchSession()` returns `false` and does not emit the after-switch event. ### Custom tool `onSession` behavior @@ -384,7 +387,6 @@ When session manager is created with `SessionManager.inMemory()` (`--no-session` ## Known implementation caveats (as of current code) -- `SelectorController.handleResumeSession()` does not check the boolean result from `session.switchSession(...)`; a hook-cancelled switch can still proceed through UI "Resumed session" repaint/status path. - `/share` custom-share failures do not degrade to the default encrypted share flow; they terminate the TUI command with an error. - `/export` argument tokenization does not preserve quoted paths with spaces. - `/drop` treats deletion as best-effort: it attempts to delete the current diff --git a/docs/session-switching-and-recent-listing.md b/docs/session-switching-and-recent-listing.md index e99b4091857a..6a978327972a 100644 --- a/docs/session-switching-and-recent-listing.md +++ b/docs/session-switching-and-recent-listing.md @@ -105,11 +105,11 @@ No match throws `Session "..." not found.`. Handled after initial session-manager construction: 1. list current-folder sessions with `SessionManager.list(cwd, parsed.sessionDir)` -2. if empty, probe `SessionManager.listAll()` only to distinguish globally empty state and preload the Tab scope; the picker still opens in current-folder scope +2. if empty, probe `SessionManager.listAll()` only to distinguish globally empty state and preload the Tab scope; the picker itself never auto-switches into all-projects scope (issue #3099) 3. if both lists are empty, print `No sessions found` and exit 4. open the fullscreen TUI picker (`selectSession`) 5. if canceled, print `No session selected` and exit -6. on selection, switch process/project-scoped state to the session's cwd, then `SessionManager.open(selected.path)` +6. on selection, `SessionManager.open(selected.path)`, then switch process/project-scoped state to the session's cwd (`switchToResumedProject`: `setProjectDir`, plugin-cache resets, settings reload) and re-resolve scoped models ### `--continue` @@ -134,11 +134,11 @@ Uses `SessionManager.continueRecent(...)` directly (breadcrumb-first behavior ab Flow: 1. fetch current-folder sessions via `SessionManager.list(currentCwd, currentSessionDir)`; the all-projects list remains lazy even when folder scope is empty -2. mount `SessionSelectorComponent` in the editor area with lazy all-project loading and a `history.db` prompt matcher +2. present `SessionSelectorComponent` as a fullscreen alternate-screen overlay via `ctx.ui.showOverlay` (anchored top-left at full size; the transcript underneath is untouched), wired with lazy all-project loading (`loadAllSessions`), a `history.db` prompt matcher, deletion, and pinned-session markers 3. callbacks: - - select -> lock picker input and call `handleResumeSession(sessionPath)`; a recoverable pre-switch failure unlocks the picker - - cancel -> restore editor and rerender - - exit -> `ctx.shutdown()` + - select -> lock picker input and call `handleResumeSession(sessionPath)`; on success hide the overlay and restore editor focus, a recoverable pre-switch failure unlocks the picker and keeps it open + - cancel -> hide overlay, restore editor focus, rerender + - exit -> hide overlay, then `ctx.shutdown()` `/resume ` resolves local then global matches and switches directly. `/resume @claude` and `/resume @codex` instead open read-only-source import pickers: the selected foreign transcript is persisted as an OMP session, then switched to; deletion, history augmentation, and all-project scope are not offered in those pickers. @@ -170,7 +170,7 @@ Lifecycle/state transition: 2. disconnect agent listeners, abort active work, run the pre-switch reconciler, and flush pending bash/session writes 3. snapshot rollback state (manager, queues, messages, model/thinking/tier, tools/prompts, provider-cache identity, and checkpoint/rewind state), then clear message queues 4. for a different session, drain/detach advisor recorders -5. `sessionManager.setSessionFile(sessionPath)`: update breadcrumb, load/migrate/blob-resolve/index entries, and adopt an existing recorded cwd +5. `sessionManager.setSessionFile(sessionPath)`: update breadcrumb, load/migrate/blob-resolve/index entries, and adopt an existing recorded cwd when permitted by cwd policy 6. sync session id, memory key, inherited provider-cache key, display context, and checkpoint/rewind state 7. emit `session_switch`, replace messages, reset advisor session state, and sync todos 8. close provider sessions for a different session, or for a same-session reload whose replay changed @@ -178,19 +178,19 @@ Lifecycle/state transition: 10. if the loaded branch ended with an interrupted tool flow, append a synthetic abort message and rebuild display context 11. restore configured thinking (`auto` survives as auto) and per-family service tiers, falling back to current settings when no corresponding entry exists 12. reset memory/tool session state as required, reconnect listeners, run mode reconciliation, and refresh the workspace-aware base system prompt -13. restore advisor cost for a different session, finish the bash transition, notify session-change callbacks, and return `true` +13. restore advisor cost for a different session, finish the bash transition, notify session-change callbacks, and return `true` on success +`switchSession()` returns `false` when a before-switch hook cancels or cwd policy rejects the transition. A cross-project switch without a cwd-change callback is rejected rather than silently adopting the target cwd; callback rejection is also cancellation. Any failure after the snapshot restores the previous manager and runtime state, reconnects/reconciles it, marks the bash transition failed, then rethrows. ## UI state rebuild after interactive switch -`SelectorController.handleResumeSession` performs UI reset around `switchSession`: +`SelectorController.handleResumeSession` invokes `switchSession` first. If it returns `false`, the selector stops before applying any new-session UI updates and leaves the existing session/UI unchanged. After a successful switch, it: - stop loading animation - clear status container - clear pending-message UI and pending tool map - reset streaming component/message references -- call `session.switchSession(...)` - if the resumed session's cwd differs from the previous one, re-point the process and cwd-derived caches at it (`applyCwdChange`) - clear chat container and rerender from session context (`renderInitialMessages`) - reload todos from new session artifacts @@ -222,8 +222,7 @@ So visible conversation/todo state is rebuilt from the new session file. - CLI picker cancel -> returns `null`, caller prints `No session selected`, process exits. - Interactive picker cancel -> closes the overlay with no session change. -- Core hook cancellation (`session_before_switch`) -> `switchSession()` returns `false`. -- **Current interactive caveat:** `handleResumeSession` does not inspect that boolean and proceeds with its UI refresh/status path. A hook-cancelled interactive switch therefore keeps the old session but can display a misleading resumed status. +- Core hook or cwd-policy cancellation -> `switchSession()` returns `false`; the interactive selector stops before its UI refresh/status path, preserving the old session and UI. Callback-free cross-project switches are rejected rather than silently adopting the target cwd. ### Empty list paths diff --git a/docs/settings.md b/docs/settings.md index 7cd1d46c50dc..e99c9021ed2f 100644 --- a/docs/settings.md +++ b/docs/settings.md @@ -472,7 +472,7 @@ providers: | `retry.enabled` | boolean | `true` | Retry transient provider errors. | | `retry.maxRetries` | number | `10` | Max retries per request. | | `retry.baseDelayMs` | number | `500` | Initial backoff. | -| `retry.maxDelayMs` | number | `300000` | Backoff ceiling (5 min). | +| `retry.maxDelayMs` | number | `300000` | Backoff ceiling (5 min). Provider-stated waits longer than this fail fast instead of sleeping when no credential or model fallback succeeds; `0` disables the cap (to auto-resume through provider-stated quota resets). | | `retry.modelFallback` | boolean | `true` | Fall back to another model when one is unavailable. | | `retry.fallbackChains` | record | `{}` | Maps roles, model selectors, or `provider/*` wildcards to ordered fallback selectors. Keys containing `/` are model-oriented and win over roles: `provider/model-id` matches that exact model, `provider/*` matches every model of the provider. A `provider/*` _entry_ keeps the failing model's id and swaps the provider. The `default` chain covers every assigned role without its own chain. Unknown models/providers or malformed chains are reported as config warnings at startup. | | `retry.fallbackRevertPolicy` | enum | `cooldown-expiry` | `cooldown-expiry` returns to the primary model once its suppression window ends; `never` stays on the fallback until switched manually. | @@ -628,6 +628,7 @@ memory: | ----------------------------- | ------- | ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `contextPromotion.enabled` | boolean | `false` | Promote to the active model's explicit `contextPromotionTarget` on context overflow. | | `compaction.enabled` | boolean | `true` | Automatic conversation compaction. | +| `compaction.asyncEnabled` | boolean | `true` | Speculatively summarize in the background as context nears the compaction threshold, then splice the ready result in when the threshold is crossed. | | `compaction.midTurnEnabled` | boolean | `true` | Check thresholds at safe mid-turn tool-loop boundaries before the next provider request. | | `compaction.methodOrder` | array | `remote, snapcompact, handoff, shake, soft` | Ordered fallbacks. `remote` uses provider-native OpenAI-compatible server compaction; unavailable or failed methods advance. | | `compaction.thresholdPercent` | number | `-1` | Percent-of-context trigger; `-1` = reserve-based default. | @@ -682,6 +683,7 @@ tui: | `images.autoResize` | boolean | `true` | Resize large images for model compatibility. | | `images.blockImages` | boolean | `false` | Never send images to providers. | | `tui.hyperlinks` | enum | `auto` | `off`, `auto`, `always`. | +| `tui.resizeScrollback` | enum | `rebuild` | How a settled width resize refreshes transcript rows kept in terminal scrollback: `append` replays the transcript at the new width below retained history, `rebuild` erases pane scrollback then replays one current-width copy, `preserve` repaints only the viewport. | For a custom status line, set `statusLine.preset: custom` and configure `statusLine.leftSegments`, `statusLine.rightSegments`, and `statusLine.segmentOptions`. @@ -731,7 +733,8 @@ searxng: | Key | Type | Default | Values / notes | | ----------------------------------- | ------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -| `providers.webSearchOrder` | array | `[]` | Provider IDs in priority order for `web_search` (`perplexity`, `gemini`, `anthropic`, `codex`, `zai`, `exa`, `jina`, `kagi`, `tavily`, `brave`, `kimi`, `parallel`, `synthetic`, `searxng`, …). Duplicates and unknown IDs are ignored; unlisted providers retain their built-in relative order afterward. Empty = built-in order. Replaces the removed `providers.webSearch` enum (a legacy value migrates to the head of this list). | +| `providers.webSearchOrder` | array | `[]` | Provider IDs in priority order for `web_search` (`perplexity`, `gemini`, `anthropic`, `codex`, `xai`, `zai`, `exa`, `tinyfish`, `jina`, `kagi`, `tavily`, `firecrawl`, `brave`, `kimi`, `parallel`, `synthetic`, `searxng`, `startpage`, `duckduckgo`, `ecosia`, `google`, `mojeek`, `public`). Duplicates and unknown IDs are ignored; unlisted providers retain their built-in relative order afterward. Empty = built-in order. Replaces the removed `providers.webSearch` enum (a legacy value migrates to the head of this list). | +| `providers.webSearchExclude` | array | `[]` | Search provider IDs that `web_search` must never use, even as fallbacks. Accepts the same provider IDs as `providers.webSearchOrder`. | | `providers.webSearchTimeoutSeconds` | number | `60` | Hard timeout in seconds supplied to each `web_search` provider transport before the automatic chain advances to the next fallback. Use a larger value for slower model-backed providers; values above `300` are capped at five minutes. This is not a whole-chain deadline, and provider-specific upstream or aggregate limits may still be shorter. | | `providers.webSearchGeminiModel` | string | _(unset)_ | Gemini model ID for Google Search grounding when `web_search` uses Gemini; defaults to `gemini-2.5-flash`, overridden by `GEMINI_SEARCH_MODEL`. | | `providers.imageOrder` | array | `[]` | Image-generation provider IDs in priority order (`openai`, `openai-codex`, `antigravity`, `xai`, `gemini`, `openrouter`). Unlisted providers follow the active session provider and the built-in order. Replaces the removed `providers.image` enum (a legacy value migrates to the head of this list). | @@ -748,7 +751,7 @@ searxng: | `exa.enabled` | boolean | `true` | Enable the Exa web search provider. | | `exa.searchDelayMs` | number | `1000` | Minimum delay between Exa web search requests in milliseconds; set `0` to disable pacing. | | `searxng.endpoint` | string | _(unset)_ | SearXNG instance URL. | -| `searxng.token` | string | _(unset)_ | SearXNG token; also `searxng.basicUsername`/`searxng.basicPassword`/`searxng.categories`/`searxng.language`. | +| `searxng.token` | string | _(unset)_ | SearXNG token; also `searxng.basicUsername`/`searxng.basicPassword`/`searxng.categories`/`searxng.language`/`searxng.engines` (comma-separated engine names or bang shortcuts, e.g. `ddg, br, startpage`, sent as the API's `engines=` parameter)/`searxng.safesearch`. | | `auth.broker.url` | string | _(unset)_ | Auth-broker URL. Overridden by `OMP_AUTH_BROKER_URL`. | | `auth.broker.token` | string | _(unset)_ | Auth-broker token. Overridden by `OMP_AUTH_BROKER_TOKEN`. | | `secrets.enabled` | boolean | `false` | Enable configured secret obfuscation and built-in credential-shaped token redaction before provider requests. See [Secret obfuscation](./secrets.md). | @@ -762,7 +765,7 @@ Every schema path not individually tabulated in this catalog is explicitly defer - Agent behavior and safety: `ask.*`, `eval.*`, `features.*`, `goal.*`, `loop.*`, `model.loopGuard.*`, `model.toolCallLoopGuard.*`, `prewalk.*`, `recap.*`, `tools.*`, and `vault.*`. - Execution and content: `commit.*`, `completion.*`, `edit.*`, `error.*`, `extensionHandlers.*`, `generate_image.*`, `git.*`, `images.*`, `live.*`, `paste.*`, `power.*`, `read.*`, `shellMinimizer.*`, `speech.*`, `terminal.*`, and `title.*`. - Interface and startup: `display.*`, `statusLine.*`, `startup.*`, `stt.*`, `tui.*`, and `ttsr.*`. -- Integrations, storage, and discovery: `async.*`, `bashInterceptor.*`, `codexResets.*`, `collab.*`, `commands.*`, `dev.*`, `exa.*`, `gc.*`, `github.*`, `hindsight.*`, `magicKeywords.*`, `mcp.*`, `memories.*`, `mnemopi.*`, `providers.*`, `searxng.*`, `share.*`, `skills.*`, `task.*`, `todo.*`, `tts.*`, and `workspace.*`. +- Integrations, storage, and discovery: `async.*`, `bashInterceptor.*`, `codexResets.*`, `collab.*`, `commands.*`, `dev.*`, `exa.*`, `gc.*`, `github.*`, `hindsight.*`, `magicKeywords.*`, `mcp.*`, `memories.*`, `mnemopi.*`, `providers.*`, `searxng.*`, `share.*`, `skills.*`, `task.*` (including the subagent wrap-up guard: `task.softRequestBudget` with the `task.softRequestBudgetNotice` steering notice), `todo.*`, `tts.*`, and `workspace.*`. - Ungrouped keys: `setupVersion`, `proseOnlyThinking`, `omitThinking`, `externalThinking`, `includeWorkspaceTree`, `autocompleteMaxVisible`, `emojiAutocomplete`, `extendedContext`, `disabledExtensions`, `inlineToolDescriptors`, and `treeFilterMode`. These settings follow the same schema-defined type and default rules shown above. diff --git a/docs/skills.md b/docs/skills.md index d066bdd58f9e..09ddde2483b1 100644 --- a/docs/skills.md +++ b/docs/skills.md @@ -155,7 +155,12 @@ If `skills.enableSkillCommands` is true, interactive mode registers one slash co - **Enter** → invokes the skill on the `steer` queue while streaming (matches free-text Enter, which also steers), or as a normal idle prompt when the agent is not streaming - **Ctrl+Enter** (`app.message.followUp`) → invokes the skill on the `followUp` queue while streaming, or as a normal idle prompt when the agent is not streaming -There is no flag, mode-selector, or frontmatter knob to override delivery mode — the keybinding _is_ the choice, identical to free-text routing during streaming. +There is no flag, mode-selector, or frontmatter knob to override delivery mode — the keybinding _is_ the choice, identical to free-text routing during streaming. Both submission paths dispatch through `#invokeSkillCommand` in `input-controller.ts`, which delegates to `invokeSkillCommandFromText` in `src/modes/skill-command.ts`. + +Invoked skill content is identified by invocation kind, each with its own prompt template (in `src/prompts/skills/`, rendered by `buildSkillPromptMessage` in `src/extensibility/skills.ts`): + +- **User-invoked** (`user-invocation.md`, used by `/skill:`): the message opens by announcing that the user invoked the skill, embeds the skill body, and appends the skill directory (`[Skill directory: ]`) with instructions to resolve the skill's relative paths (scripts, templates) against it, plus optional `User: `. +- **Autoloaded** (`autoload.md`): a minimal provenance-only format — body followed by `Skill: ` and optional `User: ` — used when subagents auto-inject skills declared via the `autoloadSkills` agent frontmatter field; these hidden messages must not claim the user invoked them. ## `skill://` URL behavior diff --git a/docs/superpowers/plans/2026-09-01-claude-agent-sdk-provider.md b/docs/superpowers/plans/2026-09-01-claude-agent-sdk-provider.md new file mode 100644 index 000000000000..7d69649b35b8 --- /dev/null +++ b/docs/superpowers/plans/2026-09-01-claude-agent-sdk-provider.md @@ -0,0 +1,1537 @@ +# Claude Agent SDK Provider Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Add a built-in omp provider `claude-code` (wire API `claude-agent-sdk`) that runs turns through `@anthropic-ai/claude-agent-sdk`, so a Claude Pro/Max subscription is used via the sanctioned path. + +**Architecture:** A new `KnownApi` whose stream function spawns the SDK `query()` per turn, resumes the SDK session by id, and renders Claude Code's own tool calls into the omp transcript as already-resolved tool call/result pairs (the `cursor-agent` pattern: `kCursorExecResolved` blocks + the agent's `cursorOnToolResult` buffer). Tool permissions flow from the SDK `canUseTool` callback into omp's approval tiers and UI through a `ClaudeSdkHandlers` bridge built in `packages/coding-agent/src/sdk.ts`. + +**Tech Stack:** Bun, TypeScript, `@anthropic-ai/claude-agent-sdk` ^0.3.224 (dynamic import), omp packages `pi-ai`, `pi-catalog`, `pi-agent-core`, `pi-coding-agent`. Tests with `bun test`. + +**Spec:** `docs/superpowers/specs/2026-09-01-claude-agent-sdk-provider-design.md` + +## Global Constraints + +- Provider id is exactly `claude-code`; API id is exactly `claude-agent-sdk`. Never prefix either with `pi-` (that prefix is claimed by the `pi-native` transport in `stream.ts`). +- The SDK is imported only via `await import("@anthropic-ai/claude-agent-sdk")` inside the stream function and the model-discovery factory. No top-level value import anywhere. +- Never pass `permissionMode: "bypassPermissions"` to the SDK. +- No OAuth token handling in omp for this provider. Login only detects Claude Code's own login state. +- All `cost` fields for `claude-code` models are `0`. +- Run `bun run typecheck` (root) and the package tests before every commit. Commit messages end with the session trailer lines used in this branch (see git log). +- Work on branch `feat/claude-agent-sdk-provider`. +- Read the existing precedent before editing: `packages/ai/src/providers/cursor.ts` (`synthesizeCursorExecToolCall` at ~3662, `pairSynthesizedExecResult` at ~3705), `packages/agent/src/agent.ts` lines 1296-1345 (`cursorOnToolResult` sink), `packages/ai/src/stream.ts` `case "cursor-agent"` at ~1014 and ~2284. + +--- + +## File map + +| File | Responsibility | +| --- | --- | +| `packages/catalog/src/types.ts` | `KnownApi` union gains `"claude-agent-sdk"`. No compat type (compat resolves to `undefined`, like `cursor-agent`). | +| `packages/catalog/src/provider-models/descriptors.ts` | `CATALOG_PROVIDERS` entry `claude-code`. | +| `packages/catalog/src/provider-models/special.ts` | `claudeCodeModelManagerOptions()` with SDK `supportedModels()` discovery + static fallback list. | +| `packages/catalog/src/provider-models/claude-code-static.ts` | Static model specs (new). | +| `packages/catalog/src/models.json` | Regenerated with the static `claude-code` models. | +| `packages/ai/src/providers/claude-agent-sdk-types.ts` | `ClaudeSdkHandlers` interface, `ClaudeAgentSdkOptions`, tool tier map, tool name map, effort map (new). | +| `packages/ai/src/providers/claude-agent-sdk.ts` | `streamClaudeAgentSdk` stream function (new). | +| `packages/ai/src/types.ts` | `ApiOptionsMap["claude-agent-sdk"]`, `StreamOptions.claudeSdkHandlers?`. | +| `packages/ai/src/api-registry.ts` | builtin id list. | +| `packages/ai/src/stream.ts` | dispatch + simple-options mapping. | +| `packages/ai/src/registry/claude-code.ts` | provider definition + login detection (new). | +| `packages/ai/src/registry/registry.ts` | one import + one `ALL` entry. | +| `packages/ai/package.json` | dependency. | +| `packages/ai/test/claude-agent-sdk.test.ts` | stream function tests with fake `query` (new). | +| `packages/ai/test/claude-code-login.test.ts` | login detection tests (new). | +| `packages/agent/src/agent.ts` | `claudeSdkHandlers` option threaded into stream options. | +| `packages/coding-agent/src/claude-sdk-bridge.ts` | `ClaudeSdkBridge implements ClaudeSdkHandlers`: session-id persistence, approval routing (new). | +| `packages/coding-agent/src/sdk.ts` | construct the bridge, pass to `Agent`. | +| `packages/coding-agent/test/claude-sdk-bridge.test.ts` | bridge tests (new). | +| `packages/ai/scripts/claude-sdk-smoke.ts` | live smoke, env-gated (new). | +| `docs/providers.md`, `docs/provider-endpoint-constraints.md` | docs. | + +--- + +### Task 1: Catalog wire API and provider entry + +**Files:** +- Modify: `packages/catalog/src/types.ts` (KnownApi union near line 8-23) +- Create: `packages/catalog/src/provider-models/claude-code-static.ts` +- Modify: `packages/catalog/src/provider-models/special.ts` +- Modify: `packages/catalog/src/provider-models/descriptors.ts` +- Modify: `packages/catalog/src/models.json` (regenerated) +- Test: `packages/catalog/test/claude-code-static.test.ts` + +**Interfaces:** +- Produces: `KnownApi` includes `"claude-agent-sdk"`; `CLAUDE_CODE_STATIC_MODELS: ModelSpec<"claude-agent-sdk">[]`; `claudeCodeModelManagerOptions(): ModelManagerOptions<"claude-agent-sdk">`; provider id `"claude-code"` in `KnownProvider`. + +- [ ] **Step 1: Write the failing test** + +```ts +// packages/catalog/test/claude-code-static.test.ts +import { describe, expect, test } from "bun:test"; +import { CLAUDE_CODE_STATIC_MODELS } from "../src/provider-models/claude-code-static"; + +describe("claude-code static models", () => { + test("every model is subscription-billed and on the claude-agent-sdk api", () => { + expect(CLAUDE_CODE_STATIC_MODELS.length).toBeGreaterThanOrEqual(3); + for (const m of CLAUDE_CODE_STATIC_MODELS) { + expect(m.api).toBe("claude-agent-sdk"); + expect(m.provider).toBe("claude-code"); + expect(m.cost).toEqual({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }); + expect(m.reasoning).toBe(true); + expect(m.supportsTools).toBe(true); + } + expect(CLAUDE_CODE_STATIC_MODELS.map(m => m.id)).toEqual( + expect.arrayContaining(["opus", "sonnet", "haiku", "claude-opus-5", "claude-sonnet-5", "claude-haiku-4-5"]), + ); + }); +}); +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `cd packages/catalog && bun test test/claude-code-static.test.ts` +Expected: FAIL, module not found. + +- [ ] **Step 3: Add the API id and static models** + +In `packages/catalog/src/types.ts`, extend the union: + +```ts +export type KnownApi = + | "openai-completions" + // ...existing members unchanged... + | "devin-agent" + | "claude-agent-sdk"; +``` + +`CompatConfigOf` / `CompatOf` need no change; the new API falls to `undefined`. + +Create `packages/catalog/src/provider-models/claude-code-static.ts`: + +```ts +import type { ModelSpec } from "../types"; + +const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 } as const; + +function spec(id: string, name: string, contextWindow: number): ModelSpec<"claude-agent-sdk"> { + return { + id, + name, + api: "claude-agent-sdk", + provider: "claude-code", + baseUrl: "local://claude-code", + reasoning: true, + input: ["text", "image"], + supportsTools: true, + cost: { ...ZERO_COST }, + contextWindow, + maxTokens: 64000, + thinking: { mode: "effort", efforts: ["low", "medium", "high", "xhigh", "max"] }, + } as ModelSpec<"claude-agent-sdk">; +} + +/** Bundled fallback when the SDK model list cannot be fetched. Aliases resolve inside Claude Code. */ +export const CLAUDE_CODE_STATIC_MODELS: ModelSpec<"claude-agent-sdk">[] = [ + spec("opus", "Claude Opus (alias)", 1_000_000), + spec("sonnet", "Claude Sonnet (alias)", 1_000_000), + spec("haiku", "Claude Haiku (alias)", 200_000), + spec("claude-opus-5", "Claude Opus 5", 1_000_000), + spec("claude-sonnet-5", "Claude Sonnet 5", 1_000_000), + spec("claude-haiku-4-5", "Claude Haiku 4.5", 200_000), +]; +``` + +If `ModelSpec` requires fields not listed above (check `packages/catalog/src/types.ts` `ModelSpec` and the `devin` entries in `models.json`), add them with the same values `devin` uses. Do not use `as ModelSpec` to hide a missing required field. + +- [ ] **Step 4: Add the model manager and descriptor** + +In `packages/catalog/src/provider-models/special.ts`, next to `devinModelManagerOptions`: + +```ts +import { CLAUDE_CODE_STATIC_MODELS } from "./claude-code-static"; + +export function claudeCodeModelManagerOptions(): ModelManagerOptions<"claude-agent-sdk"> { + return { + providerId: "claude-code", + cacheProviderId: resolveModelCacheProviderId("claude-code"), + fetchDynamicModels: async () => { + const { fetchClaudeCodeModels } = await claudeCodeDiscovery(); + return fetchClaudeCodeModels(); + }, + }; +} + +const claudeCodeDiscovery = once(() => import("../discovery/claude-code")); +``` + +Create `packages/catalog/src/discovery/claude-code.ts`: + +```ts +import { CLAUDE_CODE_STATIC_MODELS } from "../provider-models/claude-code-static"; +import type { ModelSpec } from "../types"; + +/** + * Ask the SDK which models the logged-in Claude Code account can use. Falls + * back to the static list on any failure (not installed, not logged in). + */ +export async function fetchClaudeCodeModels(): Promise[]> { + try { + const sdk = await import("@anthropic-ai/claude-agent-sdk"); + const q = sdk.query({ prompt: "", options: { maxTurns: 0 } }); + const models = await q.supportedModels(); + await q.return?.(undefined); + if (!Array.isArray(models) || models.length === 0) return CLAUDE_CODE_STATIC_MODELS; + const byId = new Map(CLAUDE_CODE_STATIC_MODELS.map(m => [m.id, m])); + for (const info of models) { + const id = String((info as { value?: string; id?: string }).value ?? (info as { id?: string }).id ?? ""); + if (!id || byId.has(id)) continue; + const base = CLAUDE_CODE_STATIC_MODELS[0]; + byId.set(id, { ...base, id, name: String((info as { displayName?: string }).displayName ?? id) }); + } + return [...byId.values()]; + } catch { + return CLAUDE_CODE_STATIC_MODELS; + } +} +``` + +Check the actual `ModelInfo` shape in `node_modules/@anthropic-ai/claude-agent-sdk/sdk.d.ts` (`grep -n "type ModelInfo" -A8`) and use its real field names instead of the `value`/`id`/`displayName` guesses. `@anthropic-ai/claude-agent-sdk` must be added to `packages/catalog/package.json` dependencies as `"^0.3.224"` for this import to resolve (Task 2 adds it to `packages/ai` too). + +In `packages/catalog/src/provider-models/descriptors.ts`, add to `CATALOG_PROVIDERS` after the `cursor` entry: + +```ts + { + id: "claude-code", + defaultModel: "opus", + envVars: [], + createModelManagerOptions: () => claudeCodeModelManagerOptions(), + allowUnauthenticated: true, + catalogDiscovery: { label: "Claude Code (subscription)", allowUnauthenticated: true }, + }, +``` + +Import `claudeCodeModelManagerOptions` from `./special`. + +- [ ] **Step 5: Regenerate models.json with the static entries** + +Find how `gitlab-duo-agent` static models reach `models.json`: `grep -rn "gitlab-duo-agent\|devin" packages/catalog/scripts/generate-models.ts`. Mirror that path so `claude-code` emits `CLAUDE_CODE_STATIC_MODELS` when discovery is unavailable, then run the generator: `cd packages/catalog && bun scripts/generate-models.ts` (read its header for required flags; run offline-only mode if it supports one). Confirm with: + +```bash +python3 -c "import json;d=json.load(open('packages/catalog/src/models.json'));print(sorted(d['claude-code'].keys()))" +``` + +Expected: the six ids above. + +- [ ] **Step 6: Run tests and typecheck** + +Run: `cd packages/catalog && bun test test/claude-code-static.test.ts && cd ../.. && bun run typecheck` +Expected: PASS. Typecheck may now fail in `packages/ai/src/api-registry.ts` with `BUILTIN_APIS is missing KnownApi values` and in `packages/ai/src/types.ts` ApiOptionsMap exhaustiveness. That is expected; Task 2 fixes it. Note the exact errors in the commit message body. + +- [ ] **Step 7: Commit** + +```bash +git add packages/catalog +git commit -m "feat(catalog): add claude-agent-sdk api and claude-code provider entry" +``` + +--- + +### Task 2: pi-ai types, registry list, dependency, handler interface + +**Files:** +- Create: `packages/ai/src/providers/claude-agent-sdk-types.ts` +- Modify: `packages/ai/src/types.ts` (ApiOptionsMap ~line 75-90; StreamOptions ~line 620-640) +- Modify: `packages/ai/src/api-registry.ts` (BUILTIN_API_IDS) +- Modify: `packages/ai/package.json` +- Test: `packages/ai/test/claude-agent-sdk-types.test.ts` + +**Interfaces:** +- Produces: + +```ts +export interface ClaudeSdkPermissionRequest { toolName: string; input: Record; signal: AbortSignal } +export type ClaudeSdkPermissionResult = { behavior: "allow" } | { behavior: "deny"; message: string }; +export interface ClaudeSdkHandlers { + getSdkSessionId(): string | undefined; + setSdkSessionId(id: string): void; + resetSdkSession(): void; + requestToolPermission(req: ClaudeSdkPermissionRequest): Promise; + onRateLimit?(info: unknown): void; +} +export interface ClaudeAgentSdkOptions extends StreamOptions { cwd?: string; claudeSdkHandlers?: ClaudeSdkHandlers; onToolResult?: CursorToolResultHandler } +export type ClaudeCodeToolTier = "read" | "write" | "exec"; +export function claudeCodeToolTier(toolName: string): ClaudeCodeToolTier +export function claudeCodeToolDisplayName(toolName: string): string +export function claudeCodeEffort(reasoning: Effort | undefined): "low" | "medium" | "high" | "xhigh" | "max" | undefined +``` + +- [ ] **Step 1: Write the failing test** + +```ts +// packages/ai/test/claude-agent-sdk-types.test.ts +import { describe, expect, test } from "bun:test"; +import { + claudeCodeEffort, + claudeCodeToolDisplayName, + claudeCodeToolTier, +} from "../src/providers/claude-agent-sdk-types"; + +describe("claude-agent-sdk maps", () => { + test("tool tiers", () => { + expect(claudeCodeToolTier("Read")).toBe("read"); + expect(claudeCodeToolTier("Grep")).toBe("read"); + expect(claudeCodeToolTier("Edit")).toBe("write"); + expect(claudeCodeToolTier("Write")).toBe("write"); + expect(claudeCodeToolTier("Bash")).toBe("exec"); + expect(claudeCodeToolTier("SomethingNew")).toBe("exec"); + }); + test("display names", () => { + expect(claudeCodeToolDisplayName("Read")).toBe("read"); + expect(claudeCodeToolDisplayName("Glob")).toBe("find"); + expect(claudeCodeToolDisplayName("MultiEdit")).toBe("edit"); + expect(claudeCodeToolDisplayName("WebSearch")).toBe("web_search"); + expect(claudeCodeToolDisplayName("Task")).toBe("task"); + }); + test("effort", () => { + expect(claudeCodeEffort(undefined)).toBeUndefined(); + expect(claudeCodeEffort("minimal")).toBe("low"); + expect(claudeCodeEffort("low")).toBe("low"); + expect(claudeCodeEffort("medium")).toBe("medium"); + expect(claudeCodeEffort("high")).toBe("high"); + expect(claudeCodeEffort("xhigh")).toBe("xhigh"); + expect(claudeCodeEffort("max")).toBe("max"); + }); +}); +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `cd packages/ai && bun test test/claude-agent-sdk-types.test.ts` +Expected: FAIL, module not found. + +- [ ] **Step 3: Create the types module** + +```ts +// packages/ai/src/providers/claude-agent-sdk-types.ts +import type { CursorToolResultHandler, Effort, StreamOptions } from "../types"; + +export interface ClaudeSdkPermissionRequest { + toolName: string; + input: Record; + signal: AbortSignal; +} + +export type ClaudeSdkPermissionResult = { behavior: "allow" } | { behavior: "deny"; message: string }; + +/** + * Host bridge for the claude-agent-sdk provider. Implemented by the + * coding-agent (session persistence + approval UI); the provider only calls it. + */ +export interface ClaudeSdkHandlers { + getSdkSessionId(): string | undefined; + setSdkSessionId(id: string): void; + resetSdkSession(): void; + requestToolPermission(req: ClaudeSdkPermissionRequest): Promise; + onRateLimit?(info: unknown): void; +} + +export interface ClaudeAgentSdkOptions extends StreamOptions { + cwd?: string; + claudeSdkHandlers?: ClaudeSdkHandlers; + /** Sink for provider-executed tool results (the agent's cursorOnToolResult buffer). */ + onToolResult?: CursorToolResultHandler; +} + +export type ClaudeCodeToolTier = "read" | "write" | "exec"; + +const READ_TOOLS = new Set(["Read", "Glob", "Grep", "LS", "WebFetch", "WebSearch", "TodoRead", "TodoWrite", "Task", "Skill"]); +const WRITE_TOOLS = new Set(["Edit", "MultiEdit", "Write", "NotebookEdit"]); + +export function claudeCodeToolTier(toolName: string): ClaudeCodeToolTier { + if (READ_TOOLS.has(toolName)) return "read"; + if (WRITE_TOOLS.has(toolName)) return "write"; + return "exec"; +} + +const DISPLAY_NAMES: Record = { + Read: "read", + Edit: "edit", + MultiEdit: "edit", + Write: "write", + Bash: "bash", + Grep: "grep", + Glob: "find", + LS: "ls", + WebFetch: "fetch", + WebSearch: "web_search", +}; + +export function claudeCodeToolDisplayName(toolName: string): string { + return DISPLAY_NAMES[toolName] ?? toolName.toLowerCase(); +} + +export function claudeCodeEffort( + reasoning: Effort | undefined, +): "low" | "medium" | "high" | "xhigh" | "max" | undefined { + switch (reasoning) { + case "minimal": + case "low": + return "low"; + case "medium": + return "medium"; + case "high": + return "high"; + case "xhigh": + return "xhigh"; + case "max": + return "max"; + default: + return undefined; + } +} +``` + +If `Effort` in `packages/ai/src/types.ts` does not contain `"xhigh"` or `"max"`, drop those cases and the matching test lines; do not widen the omp type. + +- [ ] **Step 4: Wire types, registry list, dependency** + +`packages/ai/src/types.ts`: +- In `ApiOptionsMap` add `"claude-agent-sdk": ClaudeAgentSdkOptions;` (import type from `./providers/claude-agent-sdk-types`). +- In `StreamOptions` (next to `cursorExecHandlers`) add: + +```ts + /** Host bridge for the claude-agent-sdk provider (session id + tool permission). */ + claudeSdkHandlers?: ClaudeSdkHandlers; +``` + +`packages/ai/src/api-registry.ts`: append `"claude-agent-sdk",` to `BUILTIN_API_IDS`. + +`packages/ai/package.json` dependencies: add `"@anthropic-ai/claude-agent-sdk": "^0.3.224"`. Then `bun install` at the repo root. + +- [ ] **Step 5: Run tests and typecheck** + +Run: `cd packages/ai && bun test test/claude-agent-sdk-types.test.ts && cd ../.. && bun run typecheck` +Expected: PASS; typecheck should now fail only in `packages/ai/src/stream.ts` (`Unhandled API` switch exhaustiveness, if enforced). Task 3 and 4 resolve it. + +- [ ] **Step 6: Commit** + +```bash +git add packages/ai/src/providers/claude-agent-sdk-types.ts packages/ai/src/types.ts packages/ai/src/api-registry.ts packages/ai/package.json packages/ai/test/claude-agent-sdk-types.test.ts bun.lock +git commit -m "feat(ai): claude-agent-sdk option types, handler bridge interface, dependency" +``` + +--- + +### Task 3: The stream function + +**Files:** +- Create: `packages/ai/src/providers/claude-agent-sdk.ts` +- Test: `packages/ai/test/claude-agent-sdk.test.ts` + +**Interfaces:** +- Consumes: Task 2 types; `createAssistantMessageEventStream` from `../utils/event-stream` (check the actual export used by `cursor.ts`); `kCursorExecResolved`, `kStreamingBlockKind`, `kStreamingBlockIndex` from `../utils/block-symbols`; `calculateCost` from `@oh-my-pi/pi-catalog/models`. +- Produces: `streamClaudeAgentSdk: StreamFunction<"claude-agent-sdk">`; `setClaudeSdkQueryForTests(fn | undefined)`. + +- [ ] **Step 1: Write the failing tests** + +```ts +// packages/ai/test/claude-agent-sdk.test.ts +import { afterEach, describe, expect, test } from "bun:test"; +import type { Context, Model, ToolResultMessage } from "../src/types"; +import { setClaudeSdkQueryForTests, streamClaudeAgentSdk } from "../src/providers/claude-agent-sdk"; +import type { ClaudeSdkHandlers } from "../src/providers/claude-agent-sdk-types"; +import { kCursorExecResolved } from "../src/utils/block-symbols"; + +const model = { + id: "opus", + name: "opus", + api: "claude-agent-sdk", + provider: "claude-code", + baseUrl: "local://claude-code", + reasoning: true, + input: ["text"], + cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, + contextWindow: 200000, + maxTokens: 64000, +} as unknown as Model<"claude-agent-sdk">; + +function ctx(text = "hi"): Context { + return { systemPrompt: ["sys"], messages: [{ role: "user", content: text, timestamp: 1 }], tools: [] } as unknown as Context; +} + +function handlers(initial?: string): ClaudeSdkHandlers & { id?: string; perms: string[] } { + const h = { + id: initial, + perms: [] as string[], + getSdkSessionId: () => h.id, + setSdkSessionId: (id: string) => { h.id = id; }, + resetSdkSession: () => { h.id = undefined; }, + requestToolPermission: async (req: { toolName: string }) => { + h.perms.push(req.toolName); + return req.toolName === "Bash" ? { behavior: "deny" as const, message: "no" } : { behavior: "allow" as const }; + }, + }; + return h; +} + +const init = { type: "system", subtype: "init", session_id: "sess-1", model: "opus" }; +const textEvents = [ + { type: "stream_event", session_id: "sess-1", parent_tool_use_id: null, event: { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } } }, + { type: "stream_event", session_id: "sess-1", parent_tool_use_id: null, event: { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "hel" } } }, + { type: "stream_event", session_id: "sess-1", parent_tool_use_id: null, event: { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "lo" } } }, + { type: "stream_event", session_id: "sess-1", parent_tool_use_id: null, event: { type: "content_block_stop", index: 0 } }, +]; +const success = { type: "result", subtype: "success", session_id: "sess-1", is_error: false, result: "hello", usage: { input_tokens: 10, output_tokens: 2, cache_read_input_tokens: 3, cache_creation_input_tokens: 4 } }; + +function fake(messages: unknown[], capture?: { params?: unknown }) { + return (params: unknown) => { + if (capture) capture.params = params; + async function* gen() { for (const m of messages) yield m; } + return gen(); + }; +} + +async function collect(stream: AsyncIterable<{ type: string }>) { + const out: { type: string }[] = []; + for await (const e of stream) out.push(e); + return out; +} + +afterEach(() => setClaudeSdkQueryForTests(undefined)); + +describe("streamClaudeAgentSdk", () => { + test("streams text and finishes with usage", async () => { + setClaudeSdkQueryForTests(fake([init, ...textEvents, success]) as never); + const events = await collect(streamClaudeAgentSdk(model, ctx(), { claudeSdkHandlers: handlers() })); + expect(events.map(e => e.type)).toEqual(["start", "text_start", "text_delta", "text_delta", "text_end", "done"]); + const done = events.at(-1) as { message: { usage: { input: number; output: number; cacheRead: number; cacheWrite: number } } }; + expect(done.message.usage).toMatchObject({ input: 10, output: 2, cacheRead: 3, cacheWrite: 4 }); + }); + + test("captures session id from init and passes resume next time", async () => { + const h = handlers(); + setClaudeSdkQueryForTests(fake([init, success]) as never); + await collect(streamClaudeAgentSdk(model, ctx(), { claudeSdkHandlers: h })); + expect(h.id).toBe("sess-1"); + const capture: { params?: { options?: { resume?: string }; prompt?: unknown } } = {}; + setClaudeSdkQueryForTests(fake([init, success], capture) as never); + await collect(streamClaudeAgentSdk(model, ctx("second"), { claudeSdkHandlers: h })); + expect(capture.params?.options?.resume).toBe("sess-1"); + expect(capture.params?.prompt).toBe("second"); + }); + + test("without a session id the prompt is the flattened history", async () => { + const capture: { params?: { prompt?: unknown } } = {}; + setClaudeSdkQueryForTests(fake([init, success], capture) as never); + const c = ctx("later"); + c.messages.unshift({ role: "assistant", content: [{ type: "text", text: "earlier reply" }], timestamp: 0 } as never); + c.messages.unshift({ role: "user", content: "first", timestamp: 0 } as never); + await collect(streamClaudeAgentSdk(model, c, { claudeSdkHandlers: handlers() })); + expect(String(capture.params?.prompt)).toContain("first"); + expect(String(capture.params?.prompt)).toContain("earlier reply"); + expect(String(capture.params?.prompt)).toContain("later"); + }); + + test("tool_use becomes a resolved toolCall and the tool_result is paired via onToolResult", async () => { + const results: ToolResultMessage[] = []; + const assistantToolUse = { type: "assistant", session_id: "sess-1", parent_tool_use_id: null, message: { content: [{ type: "tool_use", id: "tu1", name: "Read", input: { file_path: "/x" } }] } }; + const userToolResult = { type: "user", session_id: "sess-1", parent_tool_use_id: null, message: { content: [{ type: "tool_result", tool_use_id: "tu1", content: "file body", is_error: false }] } }; + setClaudeSdkQueryForTests(fake([init, assistantToolUse, userToolResult, ...textEvents, success]) as never); + const events = await collect(streamClaudeAgentSdk(model, ctx(), { claudeSdkHandlers: handlers(), onToolResult: r => { results.push(r); return undefined; } })); + const tc = events.find(e => e.type === "toolcall_end") as { toolCall: Record }; + expect(tc.toolCall.name).toBe("read"); + expect(tc.toolCall.id).toBe("tu1"); + expect(tc.toolCall[kCursorExecResolved]).toBe(true); + expect(results).toHaveLength(1); + expect(results[0]).toMatchObject({ toolCallId: "tu1", toolName: "read", isError: false }); + expect((events.at(-1) as { reason: string }).reason).toBe("stop"); + }); + + test("canUseTool routes to handlers.requestToolPermission", async () => { + const h = handlers(); + const capture: { params?: { options?: { canUseTool?: (n: string, i: Record, o: { signal: AbortSignal }) => Promise } } } = {}; + setClaudeSdkQueryForTests(fake([init, success], capture) as never); + await collect(streamClaudeAgentSdk(model, ctx(), { claudeSdkHandlers: h })); + const canUseTool = capture.params?.options?.canUseTool!; + expect(await canUseTool("Read", {}, { signal: new AbortController().signal })).toEqual({ behavior: "allow" }); + expect(await canUseTool("Bash", { command: "rm" }, { signal: new AbortController().signal })).toMatchObject({ behavior: "deny" }); + expect(h.perms).toEqual(["Read", "Bash"]); + }); + + test("error result becomes an error event", async () => { + setClaudeSdkQueryForTests(fake([init, { type: "result", subtype: "error_during_execution", session_id: "sess-1", is_error: true, errors: ["boom"], usage: {} }]) as never); + const events = await collect(streamClaudeAgentSdk(model, ctx(), { claudeSdkHandlers: handlers() })); + const last = events.at(-1) as { type: string; reason: string; error: { errorMessage?: string } }; + expect(last.type).toBe("error"); + expect(last.reason).toBe("error"); + expect(last.error.errorMessage).toContain("boom"); + }); + + test("not-logged-in failure names claude login", async () => { + setClaudeSdkQueryForTests((() => { async function* gen() { throw new Error("Not logged in · Please run /login"); } return gen(); }) as never); + const events = await collect(streamClaudeAgentSdk(model, ctx(), { claudeSdkHandlers: handlers() })); + const last = events.at(-1) as { type: string; error: { errorMessage?: string } }; + expect(last.type).toBe("error"); + expect(last.error.errorMessage).toContain("claude login"); + }); +}); +``` + +- [ ] **Step 2: Run tests to verify they fail** + +Run: `cd packages/ai && bun test test/claude-agent-sdk.test.ts` +Expected: FAIL, module not found. + +- [ ] **Step 3: Implement the stream function** + +Read first: how `cursor.ts` creates its stream (`createAssistantMessageEventStream` import and the `output` AssistantMessage skeleton in `streamCursor` ~line 494-560), and `endCurrentTextBlock`/`endCurrentThinkingBlock` helpers there. Copy the small helpers you need into this file rather than importing cursor internals. + +```ts +// packages/ai/src/providers/claude-agent-sdk.ts +import { calculateCost } from "@oh-my-pi/pi-catalog/models"; +import * as AIError from "../error"; +import type { + AssistantMessage, + AssistantMessageEventStream, + Context, + Message, + Model, + StreamFunction, + TextContent, + ThinkingContent, + ToolCall, + ToolResultMessage, +} from "../types"; +import { kCursorExecResolved, kStreamingBlockIndex, kStreamingBlockKind } from "../utils/block-symbols"; +import { createAssistantMessageEventStream } from "../utils/event-stream"; +import { + type ClaudeAgentSdkOptions, + type ClaudeSdkPermissionResult, + claudeCodeEffort, + claudeCodeToolDisplayName, +} from "./claude-agent-sdk-types"; + +type QueryFn = (params: { prompt: unknown; options?: Record }) => AsyncIterable; + +let queryOverride: QueryFn | undefined; +/** Test seam: inject a fake `query`. */ +export function setClaudeSdkQueryForTests(fn: QueryFn | undefined): void { + queryOverride = fn; +} + +async function loadQuery(): Promise { + if (queryOverride) return queryOverride; + const sdk = await import("@anthropic-ai/claude-agent-sdk"); + return sdk.query as unknown as QueryFn; +} + +function resolveExecutable(): string | undefined { + const fromEnv = process.env.OMP_CLAUDE_CODE_EXECUTABLE?.trim(); + if (fromEnv) return fromEnv; + const path = Bun.which("claude"); + return path ?? undefined; +} + +function textOf(content: Message["content"]): string { + if (typeof content === "string") return content; + if (!Array.isArray(content)) return ""; + return content + .filter((p): p is TextContent => (p as { type?: string }).type === "text") + .map(p => p.text) + .join("\n"); +} + +function lastUserMessage(context: Context): Message | undefined { + for (let i = context.messages.length - 1; i >= 0; i--) { + if (context.messages[i].role === "user") return context.messages[i]; + } + return undefined; +} + +function flattenHistory(context: Context): string { + return context.messages + .filter(m => m.role === "user" || m.role === "assistant") + .map(m => `${m.role}: ${textOf(m.content as Message["content"])}`.trim()) + .filter(Boolean) + .join("\n\n"); +} + +function isLoginError(message: string): boolean { + return /not logged in|\/login|authentication|invalid api key|please run .*login/i.test(message); +} + +export const streamClaudeAgentSdk: StreamFunction<"claude-agent-sdk"> = ( + model: Model<"claude-agent-sdk">, + context: Context, + options?: ClaudeAgentSdkOptions, +): AssistantMessageEventStream => { + const stream = createAssistantMessageEventStream(); + const handlers = options?.claudeSdkHandlers; + const output: AssistantMessage = { + role: "assistant", + content: [], + api: "claude-agent-sdk", + provider: model.provider, + model: model.id, + usage: { + input: 0, + output: 0, + cacheRead: 0, + cacheWrite: 0, + totalTokens: 0, + cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }, + }, + stopReason: "stop", + timestamp: Date.now(), + }; + + (async () => { + const abort = new AbortController(); + const onAbort = () => abort.abort(); + options?.signal?.addEventListener("abort", onAbort, { once: true }); + // index in SDK stream -> index in output.content + const openBlocks = new Map(); + const endedStreamedIndexes = new Set(); + let started = false; + const ensureStart = () => { + if (started) return; + started = true; + stream.push({ type: "start", partial: output }); + }; + + try { + const query = await loadQuery(); + const resumeId = handlers?.getSdkSessionId(); + const last = lastUserMessage(context); + const prompt = resumeId ? textOf((last?.content ?? "") as Message["content"]) : flattenHistory(context); + const effort = claudeCodeEffort(options?.reasoning); + const canUseTool = async ( + toolName: string, + input: Record, + opts: { signal: AbortSignal }, + ): Promise => { + if (!handlers) return { behavior: "allow" }; + return handlers.requestToolPermission({ toolName, input, signal: opts.signal }); + }; + const q = query({ + prompt, + options: { + model: model.id, + cwd: options?.cwd, + resume: resumeId, + includePartialMessages: true, + abortController: abort, + systemPrompt: { + type: "preset", + preset: "claude_code", + append: context.systemPrompt?.length ? context.systemPrompt.join("\n\n") : undefined, + }, + ...(effort ? { effort } : {}), + canUseTool, + pathToClaudeCodeExecutable: resolveExecutable(), + env: { ...process.env, CLAUDE_AGENT_SDK_CLIENT_APP: "oh-my-pi" }, + }, + }); + + for await (const raw of q) { + const msg = raw as Record; + if (abort.signal.aborted) break; + switch (msg.type) { + case "system": { + if (msg.subtype === "init" && typeof msg.session_id === "string") handlers?.setSdkSessionId(msg.session_id); + break; + } + case "rate_limit_event": { + handlers?.onRateLimit?.(msg.rate_limit_info); + break; + } + case "stream_event": { + if (msg.parent_tool_use_id) break; + ensureStart(); + handleStreamEvent(msg.event as Record, output, stream, openBlocks, endedStreamedIndexes); + break; + } + case "assistant": { + if (msg.parent_tool_use_id) break; + ensureStart(); + handleAssistantMessage(msg.message as { content: unknown[] }, output, stream, endedStreamedIndexes); + break; + } + case "user": { + if (msg.parent_tool_use_id) break; + await handleUserMessage(msg.message as { content: unknown }, options?.onToolResult); + break; + } + case "result": { + ensureStart(); + closeOpenBlocks(output, stream, openBlocks); + applyUsage(output, model, msg.usage as Record | undefined); + if (msg.is_error) { + const errText = Array.isArray(msg.errors) ? msg.errors.join("; ") : String(msg.result ?? msg.subtype ?? "Claude Code failed"); + output.stopReason = "error"; + output.errorMessage = errText; + stream.push({ type: "error", reason: "error", error: output }); + return; + } + output.stopReason = "stop"; + stream.push({ type: "done", reason: "stop", message: output }); + return; + } + default: + break; + } + } + // Generator ended without a result message. + ensureStart(); + closeOpenBlocks(output, stream, openBlocks); + if (abort.signal.aborted) { + output.stopReason = "aborted"; + stream.push({ type: "error", reason: "aborted", error: output }); + } else { + stream.push({ type: "done", reason: "stop", message: output }); + } + } catch (err) { + ensureStart(); + closeOpenBlocks(output, stream, openBlocks); + const message = err instanceof Error ? err.message : String(err); + if (abort.signal.aborted) { + output.stopReason = "aborted"; + output.errorMessage = message; + stream.push({ type: "error", reason: "aborted", error: output }); + return; + } + output.stopReason = "error"; + output.errorMessage = isLoginError(message) + ? `Claude Code is not logged in. Run 'claude login' in a terminal, then retry. (${message})` + : message; + stream.push({ type: "error", reason: "error", error: output }); + } finally { + options?.signal?.removeEventListener("abort", onAbort); + stream.end(); + } + })(); + + return stream; +}; + +function handleStreamEvent( + event: Record, + output: AssistantMessage, + stream: AssistantMessageEventStream, + openBlocks: Map, + ended: Set, +): void { + const index = Number(event.index ?? -1); + switch (event.type) { + case "content_block_start": { + const block = event.content_block as { type?: string } | undefined; + if (block?.type === "text") { + output.content.push({ type: "text", text: "" }); + openBlocks.set(index, output.content.length - 1); + stream.push({ type: "text_start", contentIndex: output.content.length - 1, partial: output }); + } else if (block?.type === "thinking") { + output.content.push({ type: "thinking", thinking: "" } as ThinkingContent); + openBlocks.set(index, output.content.length - 1); + stream.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output }); + } + // tool_use blocks are taken from the full `assistant` message instead. + break; + } + case "content_block_delta": { + const ci = openBlocks.get(index); + if (ci === undefined) break; + const delta = event.delta as { type?: string; text?: string; thinking?: string }; + const target = output.content[ci]; + if (delta.type === "text_delta" && target.type === "text") { + target.text += delta.text ?? ""; + stream.push({ type: "text_delta", contentIndex: ci, delta: delta.text ?? "", partial: output }); + } else if (delta.type === "thinking_delta" && target.type === "thinking") { + target.thinking += delta.thinking ?? ""; + stream.push({ type: "thinking_delta", contentIndex: ci, delta: delta.thinking ?? "", partial: output }); + } + break; + } + case "content_block_stop": { + const ci = openBlocks.get(index); + if (ci === undefined) break; + openBlocks.delete(index); + ended.add(ci); + const target = output.content[ci]; + if (target.type === "text") stream.push({ type: "text_end", contentIndex: ci, content: target.text, partial: output }); + else if (target.type === "thinking") stream.push({ type: "thinking_end", contentIndex: ci, content: target.thinking, partial: output }); + break; + } + default: + break; + } +} + +function closeOpenBlocks(output: AssistantMessage, stream: AssistantMessageEventStream, openBlocks: Map): void { + for (const ci of openBlocks.values()) { + const target = output.content[ci]; + if (target.type === "text") stream.push({ type: "text_end", contentIndex: ci, content: target.text, partial: output }); + else if (target.type === "thinking") stream.push({ type: "thinking_end", contentIndex: ci, content: target.thinking, partial: output }); + } + openBlocks.clear(); +} + +function handleAssistantMessage( + message: { content: unknown[] }, + output: AssistantMessage, + stream: AssistantMessageEventStream, + ended: Set, +): void { + const streamedText = ended.size > 0; + for (const raw of message.content ?? []) { + const block = raw as { type: string; id?: string; name?: string; input?: Record; text?: string; thinking?: string }; + if (block.type === "tool_use" && block.id && block.name) { + const toolCall: ToolCall & Record = { + type: "toolCall", + id: block.id, + name: claudeCodeToolDisplayName(block.name), + arguments: block.input ?? {}, + [kStreamingBlockIndex]: output.content.length, + [kStreamingBlockKind]: "claude-sdk", + [kCursorExecResolved]: true, + }; + output.content.push(toolCall); + const ci = output.content.length - 1; + stream.push({ type: "toolcall_start", contentIndex: ci, partial: output }); + stream.push({ type: "toolcall_end", contentIndex: ci, toolCall, partial: output }); + } else if (block.type === "text" && !streamedText && block.text) { + // Non-streaming fallback: no stream_event arrived for this text. + output.content.push({ type: "text", text: block.text }); + const ci = output.content.length - 1; + stream.push({ type: "text_start", contentIndex: ci, partial: output }); + stream.push({ type: "text_delta", contentIndex: ci, delta: block.text, partial: output }); + stream.push({ type: "text_end", contentIndex: ci, content: block.text, partial: output }); + } + } +} + +const toolNamesById = new Map(); + +async function handleUserMessage( + message: { content: unknown }, + onToolResult: ClaudeAgentSdkOptions["onToolResult"], +): Promise { + if (!Array.isArray(message.content) || !onToolResult) return; + for (const raw of message.content) { + const block = raw as { type: string; tool_use_id?: string; content?: unknown; is_error?: boolean }; + if (block.type !== "tool_result" || !block.tool_use_id) continue; + const text = typeof block.content === "string" + ? block.content + : Array.isArray(block.content) + ? block.content.map(c => (c as { text?: string }).text ?? "").join("\n") + : ""; + const result: ToolResultMessage = { + role: "toolResult", + toolCallId: block.tool_use_id, + toolName: toolNamesById.get(block.tool_use_id) ?? "tool", + content: [{ type: "text", text }], + isError: Boolean(block.is_error), + timestamp: Date.now(), + } as ToolResultMessage; + await onToolResult(result); + } +} + +function applyUsage(output: AssistantMessage, model: Model<"claude-agent-sdk">, usage: Record | undefined): void { + if (!usage) return; + output.usage.input = usage.input_tokens ?? 0; + output.usage.output = usage.output_tokens ?? 0; + output.usage.cacheRead = usage.cache_read_input_tokens ?? 0; + output.usage.cacheWrite = usage.cache_creation_input_tokens ?? 0; + output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite; + calculateCost(model, output.usage); +} +``` + +Two required fixes while implementing, do not skip: +1. `toolNamesById` must be populated in `handleAssistantMessage` (`toolNamesById.set(block.id, claudeCodeToolDisplayName(block.name))`) and must be per-stream state, not module-level. Move it into the closure and pass it to both helpers. +2. `ToolResultMessage` may not have `timestamp`; match the real interface in `packages/ai/src/types.ts:941`. If `AssistantMessage` lacks `errorMessage`, check how `cursor.ts` reports errors and mirror it. + +- [ ] **Step 4: Run tests until green** + +Run: `cd packages/ai && bun test test/claude-agent-sdk.test.ts` +Expected: PASS (7 tests). + +- [ ] **Step 5: Commit** + +```bash +git add packages/ai/src/providers/claude-agent-sdk.ts packages/ai/test/claude-agent-sdk.test.ts +git commit -m "feat(ai): claude-agent-sdk stream function" +``` + +--- + +### Task 4: Dispatch wiring in stream.ts and agent option threading + +**Files:** +- Modify: `packages/ai/src/stream.ts` (switch at ~1014 and simple-options switch at ~2284) +- Modify: `packages/agent/src/agent.ts` (options interface ~line 276; stream options at ~1428) +- Test: `packages/ai/test/claude-agent-sdk-dispatch.test.ts` + +**Interfaces:** +- Consumes: `streamClaudeAgentSdk`, `ClaudeAgentSdkOptions`, `ClaudeSdkHandlers`. +- Produces: `AgentOptions.claudeSdkHandlers?: ClaudeSdkHandlers` reaching `StreamOptions.claudeSdkHandlers`; `ClaudeAgentSdkOptions.onToolResult` is the agent's `cursorOnToolResult` sink. + +- [ ] **Step 1: Write the failing test** + +```ts +// packages/ai/test/claude-agent-sdk-dispatch.test.ts +import { afterEach, describe, expect, test } from "bun:test"; +import { setClaudeSdkQueryForTests } from "../src/providers/claude-agent-sdk"; +import { streamSimple } from "../src/stream"; +import type { Context, Model } from "../src/types"; + +afterEach(() => setClaudeSdkQueryForTests(undefined)); + +describe("claude-agent-sdk dispatch", () => { + test("streamSimple routes claude-agent-sdk models to the SDK provider", async () => { + let called = false; + setClaudeSdkQueryForTests((() => { called = true; async function* gen() { + yield { type: "system", subtype: "init", session_id: "s" }; + yield { type: "result", subtype: "success", is_error: false, result: "", usage: {} }; + } return gen(); }) as never); + const model = { id: "opus", api: "claude-agent-sdk", provider: "claude-code", reasoning: true, input: ["text"], cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, contextWindow: 1, maxTokens: 1, baseUrl: "local://claude-code" } as unknown as Model<"claude-agent-sdk">; + const context = { systemPrompt: [], messages: [{ role: "user", content: "x", timestamp: 1 }], tools: [] } as unknown as Context; + const events: string[] = []; + for await (const e of streamSimple(model, context, { apiKey: "claude-code-login" })) events.push(e.type); + expect(called).toBe(true); + expect(events.at(-1)).toBe("done"); + }); +}); +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `cd packages/ai && bun test test/claude-agent-sdk-dispatch.test.ts` +Expected: FAIL with `Unhandled API: claude-agent-sdk`. + +- [ ] **Step 3: Wire dispatch** + +In `packages/ai/src/stream.ts`: + +Import: `import { streamClaudeAgentSdk } from "./providers/claude-agent-sdk";` and `import type { ClaudeAgentSdkOptions } from "./providers/claude-agent-sdk-types";` + +In `streamDispatch` switch, after `case "devin-agent"`: + +```ts + case "claude-agent-sdk": + return streamClaudeAgentSdk( + providerModel as Model<"claude-agent-sdk">, + context, + providerOptions as ClaudeAgentSdkOptions, + ); +``` + +In the simple-options mapping switch (the one with `case "cursor-agent": { const execHandlers = ... }`), add: + +```ts + case "claude-agent-sdk": + return castApi<"claude-agent-sdk">({ + ...base, + cwd: options?.cwd, + claudeSdkHandlers: options?.claudeSdkHandlers, + onToolResult: options?.cursorOnToolResult, + }); +``` + +Also check `streamSimple`'s auth gate: `claude-code` models have no real key. Find where `streamSimple` throws when `apiKey` is missing (grep `allowsMissingApiKey` / `apiKey` checks near the top of `streamSimple`) and make sure `claude-agent-sdk` is treated like providers with `allowsMissingApiKey` (Task 5 sets that on the registry def; confirm the runtime path consults it). + +In `packages/agent/src/agent.ts`: +- Add to the options interface next to `cursorExecHandlers`: + +```ts + /** Host bridge for the claude-agent-sdk provider (session id + tool permission). */ + claudeSdkHandlers?: ClaudeSdkHandlers; +``` + +- Store it (`#claudeSdkHandlers`) in the constructor beside `#cursorExecHandlers`, and pass `claudeSdkHandlers: this.#claudeSdkHandlers,` next to `cursorExecHandlers: this.#cursorExecHandlers,` at ~line 1428. Confirm that the agent-loop forwards unknown option fields into the stream options (follow how `cursorExecHandlers` travels from that object into the call at `stream.ts:2285`; add `claudeSdkHandlers` at each hop the same way). + +- [ ] **Step 4: Run tests and typecheck** + +Run: `cd packages/ai && bun test test/claude-agent-sdk-dispatch.test.ts test/claude-agent-sdk.test.ts && cd ../.. && bun run typecheck` +Expected: PASS, typecheck clean. + +- [ ] **Step 5: Commit** + +```bash +git add packages/ai/src/stream.ts packages/agent/src/agent.ts packages/ai/test/claude-agent-sdk-dispatch.test.ts +git commit -m "feat(ai,agent): dispatch claude-agent-sdk and thread the handler bridge" +``` + +--- + +### Task 5: Provider definition with Claude Code login detection + +**Files:** +- Create: `packages/ai/src/registry/claude-code.ts` +- Modify: `packages/ai/src/registry/registry.ts` (import + `ALL`) +- Test: `packages/ai/test/claude-code-login.test.ts` + +**Interfaces:** +- Produces: `claudeCodeProvider` (`id: "claude-code"`), `detectClaudeCodeLogin(home?: string): Promise<{ found: boolean; source: "keychain" | "credentialsFile" | "claudeConfig" | "env" | null; account: string | null }>`, `CLAUDE_CODE_LOGIN_PLACEHOLDER = "claude-code-login"`. + +- [ ] **Step 1: Write the failing test** + +```ts +// packages/ai/test/claude-code-login.test.ts +import { afterEach, beforeEach, describe, expect, test } from "bun:test"; +import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { detectClaudeCodeLogin } from "../src/registry/claude-code"; + +let home: string; +const savedKey = process.env.ANTHROPIC_API_KEY; +const savedTok = process.env.ANTHROPIC_AUTH_TOKEN; + +beforeEach(() => { + home = mkdtempSync(join(tmpdir(), "omp-claude-code-")); + delete process.env.ANTHROPIC_API_KEY; + delete process.env.ANTHROPIC_AUTH_TOKEN; + process.env.OMP_CLAUDE_CODE_SKIP_KEYCHAIN = "1"; +}); +afterEach(() => { + rmSync(home, { recursive: true, force: true }); + if (savedKey !== undefined) process.env.ANTHROPIC_API_KEY = savedKey; + if (savedTok !== undefined) process.env.ANTHROPIC_AUTH_TOKEN = savedTok; + delete process.env.OMP_CLAUDE_CODE_SKIP_KEYCHAIN; +}); + +describe("detectClaudeCodeLogin", () => { + test("nothing present", async () => { + expect(await detectClaudeCodeLogin(home)).toEqual({ found: false, source: null, account: null }); + }); + test("credentials file wins and borrows the account label", async () => { + mkdirSync(join(home, ".claude")); + writeFileSync(join(home, ".claude", ".credentials.json"), JSON.stringify({ claudeAiOauth: { accessToken: "x" } })); + writeFileSync(join(home, ".claude.json"), JSON.stringify({ oauthAccount: { emailAddress: "a@b.c" } })); + expect(await detectClaudeCodeLogin(home)).toEqual({ found: true, source: "credentialsFile", account: "a@b.c" }); + }); + test("claude config marker alone", async () => { + writeFileSync(join(home, ".claude.json"), JSON.stringify({ userID: "u1" })); + expect(await detectClaudeCodeLogin(home)).toMatchObject({ found: true, source: "claudeConfig" }); + }); + test("env fallback", async () => { + process.env.ANTHROPIC_API_KEY = "sk-test"; + expect(await detectClaudeCodeLogin(home)).toMatchObject({ found: true, source: "env" }); + }); +}); +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `cd packages/ai && bun test test/claude-code-login.test.ts` +Expected: FAIL, module not found. + +- [ ] **Step 3: Implement** + +```ts +// packages/ai/src/registry/claude-code.ts +import { execFile } from "node:child_process"; +import { readFileSync, statSync } from "node:fs"; +import { homedir } from "node:os"; +import { join } from "node:path"; +import { promisify } from "node:util"; +import type { OAuthLoginCallbacks } from "./oauth/types"; +import type { ProviderDefinition } from "./types"; + +const execFileAsync = promisify(execFile); + +export const CLAUDE_CODE_LOGIN_PLACEHOLDER = "claude-code-login"; + +export interface ClaudeCodeLoginState { + found: boolean; + source: "keychain" | "credentialsFile" | "claudeConfig" | "env" | null; + account: string | null; +} + +function fileHasContent(path: string): boolean { + try { + return statSync(path).size > 0; + } catch { + return false; + } +} + +function readAccountLabel(home: string): { marker: boolean; label: string | null } { + try { + const raw = JSON.parse(readFileSync(join(home, ".claude.json"), "utf8")) as Record; + const acct = (raw.oauthAccount ?? null) as Record | null; + const label = + (typeof acct?.emailAddress === "string" && acct.emailAddress) || + (typeof acct?.displayName === "string" && acct.displayName) || + null; + const marker = Boolean(label || (acct && typeof acct.accountUuid === "string") || typeof raw.userID === "string"); + return { marker, label }; + } catch { + return { marker: false, label: null }; + } +} + +async function keychainHasCredentials(): Promise { + if (process.platform !== "darwin" || process.env.OMP_CLAUDE_CODE_SKIP_KEYCHAIN) return false; + try { + await execFileAsync("security", ["find-generic-password", "-s", "Claude Code-credentials"], { timeout: 3000 }); + return true; + } catch { + return false; + } +} + +/** Detect Claude Code's own login state. Never throws. */ +export async function detectClaudeCodeLogin(home: string = homedir()): Promise { + const { marker, label } = readAccountLabel(home); + if (await keychainHasCredentials()) return { found: true, source: "keychain", account: label }; + if (fileHasContent(join(home, ".claude", ".credentials.json"))) return { found: true, source: "credentialsFile", account: label }; + if (marker) return { found: true, source: "claudeConfig", account: label }; + if (process.env.ANTHROPIC_API_KEY?.trim() || process.env.ANTHROPIC_AUTH_TOKEN?.trim()) return { found: true, source: "env", account: null }; + return { found: false, source: null, account: null }; +} + +export const claudeCodeProvider = { + id: "claude-code", + name: "Claude Code (subscription)", + allowsMissingApiKey: true, + login: async (cb: OAuthLoginCallbacks) => { + cb.onProgress?.("Checking Claude Code login state..."); + const state = await detectClaudeCodeLogin(); + if (!state.found) { + throw new Error("Claude Code is not logged in. Run 'claude login' in a terminal, then retry /login claude-code."); + } + cb.onProgress?.(`Claude Code login found (${state.source}${state.account ? `, ${state.account}` : ""}).`); + return CLAUDE_CODE_LOGIN_PLACEHOLDER; + }, +} as const satisfies ProviderDefinition; +``` + +Check the macOS keychain service name Claude Code actually uses: run `security dump-keychain 2>/dev/null | grep -i "claude" | head` on this machine, and copy the exact `svce` value into `keychainHasCredentials`. cyboflow's `main/src/utils/claudeCredentials.ts` `probeKeychain` has the working value; prefer that. + +In `packages/ai/src/registry/registry.ts`: `import { claudeCodeProvider } from "./claude-code";` and add `claudeCodeProvider,` to `ALL` right after `cursorProvider,`. + +- [ ] **Step 4: Run tests and typecheck** + +Run: `cd packages/ai && bun test test/claude-code-login.test.ts && cd ../.. && bun run typecheck` +Expected: PASS. + +- [ ] **Step 5: Commit** + +```bash +git add packages/ai/src/registry/claude-code.ts packages/ai/src/registry/registry.ts packages/ai/test/claude-code-login.test.ts +git commit -m "feat(ai): claude-code provider definition with Claude Code login detection" +``` + +--- + +### Task 6: coding-agent bridge (session id persistence + approval UI) + +**Files:** +- Create: `packages/coding-agent/src/claude-sdk-bridge.ts` +- Modify: `packages/coding-agent/src/sdk.ts` (near `new CursorExecHandlers(` at ~2774 and the `Agent` options at ~3262) +- Test: `packages/coding-agent/test/claude-sdk-bridge.test.ts` + +**Interfaces:** +- Consumes: `ClaudeSdkHandlers`, `ClaudeSdkPermissionRequest`, `ClaudeSdkPermissionResult`, `claudeCodeToolTier` from `@oh-my-pi/pi-ai` (export them from `packages/ai/src/index.ts` if not already re-exported; check how `CursorExecHandlers` types are exported); `resolveApproval`, `formatApprovalPrompt`, `truncateForPrompt`, `ApprovalMode` from `./tools/approval`. +- Produces: + +```ts +export const CLAUDE_SDK_SESSION_CUSTOM_TYPE = "claude_sdk_session"; +export interface ClaudeSdkBridgeOptions { + getSettings(): { get(key: string): unknown } | undefined; + isAutoApprove(): boolean; + hasUI(): boolean; + select(prompt: string, choices: string[], opts: { signal?: AbortSignal }): Promise; + loadPersistedSessionId(): string | undefined; + persistSessionId(id: string | undefined): void; +} +export class ClaudeSdkBridge implements ClaudeSdkHandlers +``` + +- [ ] **Step 1: Write the failing test** + +```ts +// packages/coding-agent/test/claude-sdk-bridge.test.ts +import { describe, expect, test } from "bun:test"; +import { ClaudeSdkBridge } from "../src/claude-sdk-bridge"; + +function bridge(overrides: Partial[0]> = {}, settings: Record = {}) { + let persisted: string | undefined; + const selections: string[] = []; + const b = new ClaudeSdkBridge({ + getSettings: () => ({ get: (k: string) => settings[k] }), + isAutoApprove: () => false, + hasUI: () => true, + select: async prompt => { selections.push(prompt); return "Approve"; }, + loadPersistedSessionId: () => persisted, + persistSessionId: id => { persisted = id; }, + ...overrides, + }); + return { b, selections, get persisted() { return persisted; } }; +} + +describe("ClaudeSdkBridge", () => { + test("session id round-trips and resets", () => { + const t = bridge(); + expect(t.b.getSdkSessionId()).toBeUndefined(); + t.b.setSdkSessionId("s1"); + expect(t.b.getSdkSessionId()).toBe("s1"); + expect(t.persisted).toBe("s1"); + t.b.resetSdkSession(); + expect(t.b.getSdkSessionId()).toBeUndefined(); + }); + test("read tier auto-allows under write mode without prompting", async () => { + const t = bridge({}, { "tools.approvalMode": "write" }); + const r = await t.b.requestToolPermission({ toolName: "Read", input: { file_path: "/x" }, signal: new AbortController().signal }); + expect(r).toEqual({ behavior: "allow" }); + expect(t.selections).toHaveLength(0); + }); + test("exec tier prompts under write mode and honors Deny", async () => { + const t = bridge({ select: async () => "Deny" }, { "tools.approvalMode": "write" }); + const r = await t.b.requestToolPermission({ toolName: "Bash", input: { command: "rm -rf /" }, signal: new AbortController().signal }); + expect(r).toMatchObject({ behavior: "deny" }); + }); + test("user policy deny wins", async () => { + const t = bridge({}, { "tools.approvalMode": "yolo", "tools.approval": { "claude-code.Bash": "deny" } }); + const r = await t.b.requestToolPermission({ toolName: "Bash", input: {}, signal: new AbortController().signal }); + expect(r).toMatchObject({ behavior: "deny" }); + }); + test("no UI and prompt required denies with guidance", async () => { + const t = bridge({ hasUI: () => false }, { "tools.approvalMode": "always-ask" }); + const r = await t.b.requestToolPermission({ toolName: "Edit", input: {}, signal: new AbortController().signal }); + expect(r).toMatchObject({ behavior: "deny" }); + expect((r as { message: string }).message).toContain("approvalMode"); + }); +}); +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `cd packages/coding-agent && bun test test/claude-sdk-bridge.test.ts` +Expected: FAIL, module not found. + +- [ ] **Step 3: Implement the bridge** + +```ts +// packages/coding-agent/src/claude-sdk-bridge.ts +import type { ClaudeSdkHandlers, ClaudeSdkPermissionRequest, ClaudeSdkPermissionResult } from "@oh-my-pi/pi-ai"; +import { claudeCodeToolTier } from "@oh-my-pi/pi-ai"; +import { type ApprovalMode, resolveApproval, truncateForPrompt } from "./tools/approval"; + +export const CLAUDE_SDK_SESSION_CUSTOM_TYPE = "claude_sdk_session"; + +export interface ClaudeSdkBridgeOptions { + getSettings(): { get(key: string): unknown } | undefined; + isAutoApprove(): boolean; + hasUI(): boolean; + select(prompt: string, choices: string[], opts: { signal?: AbortSignal }): Promise; + loadPersistedSessionId(): string | undefined; + persistSessionId(id: string | undefined): void; +} + +/** Host side of the claude-agent-sdk provider: session continuity + approval routing. */ +export class ClaudeSdkBridge implements ClaudeSdkHandlers { + #sessionId: string | undefined; + #loaded = false; + + constructor(private readonly options: ClaudeSdkBridgeOptions) {} + + getSdkSessionId(): string | undefined { + if (!this.#loaded) { + this.#sessionId = this.options.loadPersistedSessionId(); + this.#loaded = true; + } + return this.#sessionId; + } + + setSdkSessionId(id: string): void { + this.#loaded = true; + if (this.#sessionId === id) return; + this.#sessionId = id; + this.options.persistSessionId(id); + } + + resetSdkSession(): void { + this.#loaded = true; + if (this.#sessionId === undefined) return; + this.#sessionId = undefined; + this.options.persistSessionId(undefined); + } + + async requestToolPermission(req: ClaudeSdkPermissionRequest): Promise { + const settings = this.options.getSettings(); + const mode: ApprovalMode = this.options.isAutoApprove() + ? "yolo" + : ((settings?.get("tools.approvalMode") as ApprovalMode | undefined) ?? "yolo"); + const userPolicies = (settings?.get("tools.approval") ?? {}) as Record; + const tier = claudeCodeToolTier(req.toolName); + const subject = { name: `claude-code.${req.toolName}`, approval: tier } as Parameters[0]; + const resolved = resolveApproval(subject, req.input, mode, userPolicies); + if (resolved.policy === "allow") return { behavior: "allow" }; + if (resolved.policy === "deny") { + return { behavior: "deny", message: `Tool "${req.toolName}" is blocked by omp policy (tools.approval.claude-code.${req.toolName}: deny).` }; + } + if (!this.options.hasUI()) { + return { + behavior: "deny", + message: + `Tool "${req.toolName}" requires approval but omp has no interactive UI. ` + + `Set tools.approvalMode: yolo or tools.approval.claude-code.${req.toolName}: allow.`, + }; + } + const prompt = `Claude Code wants to run ${req.toolName} (${tier}):\n${truncateForPrompt(JSON.stringify(req.input, null, 2))}`; + let choice: string | undefined; + try { + choice = await this.options.select(prompt, ["Approve", "Deny"], { signal: req.signal }); + } catch { + return { behavior: "deny", message: "Approval aborted in omp." }; + } + return choice === "Approve" ? { behavior: "allow" } : { behavior: "deny", message: "Denied by user in omp." }; + } +} +``` + +Check `resolveApproval`'s first parameter type (`ApprovalSubject = Pick`) and pass `approval` in the shape it expects (a bare tier string is accepted per the `isToolTier` branch in `tools/approval.ts`). Check `truncateForPrompt`'s signature. Export the three `ClaudeSdk*` types and `claudeCodeToolTier` from `packages/ai/src/index.ts` next to the cursor exports. + +- [ ] **Step 4: Wire it in sdk.ts** + +Next to `const cursorExecHandlers = new CursorExecHandlers({` in `packages/coding-agent/src/sdk.ts`: + +```ts + const claudeSdkBridge = new ClaudeSdkBridge({ + getSettings: () => toolContextStore.getContext()?.settings ?? settings, + isAutoApprove: () => toolContextStore.getContext()?.autoApprove === true, + hasUI: () => extensionRunner?.hasUI() ?? false, + select: (prompt, choices, opts) => extensionRunner!.getUIContext().select(prompt, choices, opts), + loadPersistedSessionId: () => { + let id: string | undefined; + for (const entry of sessionManager.getEntries()) { + if (entry.type === "custom" && entry.customType === CLAUDE_SDK_SESSION_CUSTOM_TYPE) { + id = (entry.data as { sdkSessionId?: string } | undefined)?.sdkSessionId; + } + } + return id; + }, + persistSessionId: id => { + sessionManager.appendCustomEntry(CLAUDE_SDK_SESSION_CUSTOM_TYPE, { sdkSessionId: id }); + }, + }); +``` + +Use the real names in scope at that point of `sdk.ts` for the settings object, the extension runner, and the session entries iterator (follow how `USER_TODO_EDIT_CUSTOM_TYPE` is read back in `packages/coding-agent/src/tools/todo.ts:180` for the entry-walk API). Then add `claudeSdkHandlers: claudeSdkBridge,` next to `cursorExecHandlers,` in the `new Agent({...})` options. + +Reset hooks: wherever `sdk.ts` or `session/agent-session.ts` handles compaction completion, `/clear`, fork, and branch/tree switch, call `claudeSdkBridge.resetSdkSession()`. Find them with `grep -n "compaction\|clearSession\|fork\|switchBranch" packages/coding-agent/src/session/agent-session.ts | head -30` and add one call at each. The last persisted `claude_sdk_session` entry with `sdkSessionId: undefined` reads back as "no session", which the loader above already handles. + +- [ ] **Step 5: Run tests and typecheck** + +Run: `cd packages/coding-agent && bun test test/claude-sdk-bridge.test.ts && cd ../.. && bun run typecheck` +Expected: PASS. + +- [ ] **Step 6: Commit** + +```bash +git add packages/coding-agent/src/claude-sdk-bridge.ts packages/coding-agent/src/sdk.ts packages/coding-agent/src/session/agent-session.ts packages/ai/src/index.ts packages/coding-agent/test/claude-sdk-bridge.test.ts +git commit -m "feat(coding-agent): claude sdk bridge for session resume and tool approval" +``` + +--- + +### Task 7: Effort controls, docs, smoke script + +**Files:** +- Modify: `packages/coding-agent/src/thinking.ts`, `packages/coding-agent/src/session/model-controls.ts` (only if the static `thinking.efforts` from Task 1 is not enough for the effort picker to show `low..max`) +- Create: `packages/ai/scripts/claude-sdk-smoke.ts` +- Modify: `docs/providers.md` (provider table + OAuth-backed list), `docs/provider-endpoint-constraints.md` + +**Interfaces:** +- Consumes: everything above. + +- [ ] **Step 1: Verify effort picker** + +Run `bun packages/coding-agent/src/cli.ts --model claude-code/opus --help` (or the repo's dev entry, see `packages/coding-agent/package.json` scripts) and confirm the model resolves. In a dev session run `/thinking` and confirm the ladder shows low, medium, high, xhigh, max. If it does not, follow the `devin-agent` comments in `thinking.ts:241` and `model-controls.ts:591` and add the analogous `claude-agent-sdk` branch that trusts `thinking.efforts` from the model spec. + +- [ ] **Step 2: Smoke script** + +```ts +// packages/ai/scripts/claude-sdk-smoke.ts +// Live check against the real subscription. Run: OMP_CLAUDE_SDK_SMOKE=1 bun packages/ai/scripts/claude-sdk-smoke.ts +import { streamClaudeAgentSdk } from "../src/providers/claude-agent-sdk"; +import type { Context, Model } from "../src/types"; + +if (!process.env.OMP_CLAUDE_SDK_SMOKE) { + console.log("skipped: set OMP_CLAUDE_SDK_SMOKE=1"); + process.exit(0); +} + +const model = { + id: process.env.OMP_CLAUDE_SDK_MODEL ?? "sonnet", + name: "smoke", + api: "claude-agent-sdk", + provider: "claude-code", + baseUrl: "local://claude-code", + reasoning: true, + input: ["text"], + cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }, + contextWindow: 200000, + maxTokens: 4096, +} as unknown as Model<"claude-agent-sdk">; + +let sessionId: string | undefined; +const handlers = { + getSdkSessionId: () => sessionId, + setSdkSessionId: (id: string) => { sessionId = id; }, + resetSdkSession: () => { sessionId = undefined; }, + requestToolPermission: async () => ({ behavior: "deny" as const, message: "smoke test: no tools" }), +}; + +const context = { systemPrompt: [], messages: [{ role: "user", content: "Reply with exactly: OK", timestamp: Date.now() }], tools: [] } as unknown as Context; +let text = ""; +for await (const e of streamClaudeAgentSdk(model, context, { claudeSdkHandlers: handlers, cwd: process.cwd() })) { + if (e.type === "text_delta") text += e.delta; + if (e.type === "error") { console.error("ERROR", e.error.errorMessage); process.exit(1); } +} +if (!/OK/.test(text)) { console.error("unexpected reply:", JSON.stringify(text)); process.exit(1); } +if (!sessionId) { console.error("no session id captured"); process.exit(1); } +console.log("OK", { sessionId, text: text.trim() }); +``` + +Run: `OMP_CLAUDE_SDK_SMOKE=1 bun packages/ai/scripts/claude-sdk-smoke.ts` +Expected: prints `OK { sessionId: "...", text: "OK" }`. If it fails with a login error, run `claude login` and retry; if it fails otherwise, fix the provider before continuing. + +- [ ] **Step 3: Docs** + +`docs/providers.md`: add a row to the provider env table: `` `claude-code` `` with `none (uses Claude Code's own login; run \`claude login\`)`, and add `claude-code` to the OAuth-backed providers sentence near line 152 with the note "detects Claude Code's login instead of running OAuth". Add a short subsection: + +```markdown +### Claude Code (subscription) + +`claude-code` runs turns through the Claude Agent SDK, which spawns your installed Claude Code binary. Your Pro/Max/Team subscription is billed the same way Claude Code bills it, and no token is stored in omp. Log in once with `claude login`, then `/login claude-code` to confirm and `--model claude-code/opus` (aliases `opus`, `sonnet`, `haiku` or explicit ids). Claude Code executes its own tools; omp shows them in the transcript and routes each permission request through `tools.approvalMode` and `tools.approval.claude-code.`. Set `OMP_CLAUDE_CODE_EXECUTABLE` to pin a specific binary. +``` + +`docs/provider-endpoint-constraints.md`: add a `claude-agent-sdk` entry: no HTTP retry, no `toolChoice`, no custom tools (omp tools are not sent), thinking effort via SDK `effort`, session resume by SDK id, results carry token counts with zero cost. + +- [ ] **Step 4: Full test run and typecheck** + +Run: `bun run typecheck && cd packages/ai && bun test && cd ../catalog && bun test && cd ../coding-agent && bun test test/claude-sdk-bridge.test.ts` +Expected: all PASS. + +- [ ] **Step 5: Commit** + +```bash +git add packages/ai/scripts/claude-sdk-smoke.ts docs/providers.md docs/provider-endpoint-constraints.md packages/coding-agent/src/thinking.ts packages/coding-agent/src/session/model-controls.ts +git commit -m "feat(claude-code): effort controls, docs, live smoke script" +``` + +--- + +## Validation gate (run by the orchestrator after all tasks) + +1. `bun run typecheck` clean. +2. `cd packages/ai && bun test`, `cd packages/catalog && bun test`, `cd packages/coding-agent && bun test test/claude-sdk-bridge.test.ts` all green. +3. `OMP_CLAUDE_SDK_SMOKE=1 bun packages/ai/scripts/claude-sdk-smoke.ts` prints OK. +4. Interactive check: `omp --model claude-code/sonnet` (dev entry), ask "list the files in this directory"; expect a rendered `bash` or `ls` tool block, an approval prompt under `tools.approvalMode: write`, and a second turn that resumes (no history replay visible in `claude --resume` transcript). +5. `grep -rn "bypassPermissions" packages/ai/src/providers/claude-agent-sdk.ts` returns nothing. +6. `grep -rn "from \"@anthropic-ai/claude-agent-sdk\"" packages --include='*.ts' | grep -v "import type"` returns nothing (only dynamic imports). diff --git a/docs/superpowers/specs/2026-09-01-claude-agent-sdk-provider-design.md b/docs/superpowers/specs/2026-09-01-claude-agent-sdk-provider-design.md new file mode 100644 index 000000000000..594bf04a5275 --- /dev/null +++ b/docs/superpowers/specs/2026-09-01-claude-agent-sdk-provider-design.md @@ -0,0 +1,180 @@ +# Claude Agent SDK provider (`claude-code` / `claude-agent-sdk`) + +Date: 2026-09-01. Status: approved design. + +## Why + +Anthropic prohibits using a Claude Pro/Max subscription OAuth token from a +non-Anthropic client against the Messages API (Feb 2026 terms, enforced +2026-04-04). omp's built-in `anthropic` OAuth provider does exactly that and +spoofs the Claude Code fingerprint, so it carries account risk. + +Anthropic's help center states that third-party apps authenticating with a +subscription *through the Claude Agent SDK* are allowed +(support.claude.com article 15036540). The SDK spawns the real Claude Code +binary, which owns the login; no token ever enters omp. + +This spec adds a first-class omp provider that drives the Agent SDK. + +## Decisions (from brainstorm) + +| Decision | Choice | +| --- | --- | +| Location | Built-in wire API in `packages/ai` + `packages/catalog` (not an extension). | +| Tools in v1 | Claude Code's own tools run inside the SDK; omp renders them as already-resolved tool calls. | +| Continuity | Resume the SDK session by id; send only the newest user message each turn. | +| Permissions | `canUseTool` routes into omp's approval tiers and prompt UI. | + +## Identity + +- Provider id: `claude-code`. Display name: `Claude Code (subscription)`. +- API id (`KnownApi`): `claude-agent-sdk`. +- Models: fetched at discovery via the SDK `Query.supportedModels()`; static + fallback list `opus`, `sonnet`, `haiku` plus the current concrete ids + (`claude-opus-5`, `claude-sonnet-5`, `claude-haiku-4-5`). `cost` fields are + all zero (subscription billing). `contextWindow` from SDK model info when + present, else 200000. `reasoning: true`, `input: ["text","image"]`, + `supportsTools: true`. +- Auth: `allowsMissingApiKey: true`. `/login claude-code` does not run OAuth. + It detects Claude Code's login state (macOS keychain item, then + `~/.claude/.credentials.json`, then `~/.claude.json` `oauthAccount`/`userID` + marker, then `ANTHROPIC_API_KEY`/`ANTHROPIC_AUTH_TOKEN`) and returns a + placeholder API-key string `claude-code-login` on success, or throws with the + instruction `Run 'claude login' in a terminal, then retry.` +- Dependency: `@anthropic-ai/claude-agent-sdk` in `packages/ai/package.json`, + loaded only through a dynamic import inside the stream function so startup + cost is unchanged (the SDK entry is ~1 MB CJS). +- Executable: `pathToClaudeCodeExecutable` resolves in order: env + `OMP_CLAUDE_CODE_EXECUTABLE`, `claude` on PATH, else undefined (SDK bundled + CLI). + +## Stream function + +File: `packages/ai/src/providers/claude-agent-sdk.ts`, export +`streamClaudeAgentSdk: StreamFunction<"claude-agent-sdk">`. Options type +`ClaudeAgentSdkOptions extends StreamOptions` carries `cwd`, `sessionId`, +`reasoning`, `signal`, and `claudeSdkHandlers?: ClaudeSdkHandlers` (bridge, see +Permissions). + +Request build: + +- `prompt`: text of the last `user` message in `context.messages`. Image + content is passed as SDK content blocks. If there is no stored SDK session + (first turn, or after reset), the prompt is the full flattened omp history + (`role: text` per message) so the SDK sees the conversation once. +- `options`: `model`, `cwd`, `resume: `, + `includePartialMessages: true`, `abortController` wired to `signal`, + `systemPrompt: { type: "preset", preset: "claude_code", append: }`, `effort` mapped from omp reasoning effort + (`minimal|low -> low`, `medium -> medium`, `high -> high`, `xhigh -> xhigh`, + `max -> max`, undefined -> omitted), `canUseTool` (below), + `pathToClaudeCodeExecutable`, `env: { ...process.env, + CLAUDE_AGENT_SDK_CLIENT_APP: "oh-my-pi/" }`. +- Never set `permissionMode: "bypassPermissions"`. + +Event mapping (SDK message -> omp `AssistantMessageEvent`): + +| SDK message | omp events | +| --- | --- | +| `system` subtype `init` | capture `session_id` -> `handlers.setSdkSessionId`. No event. | +| `stream_event` `content_block_start` text / thinking | `text_start` / `thinking_start` | +| `stream_event` `content_block_delta` text_delta / thinking_delta | `text_delta` / `thinking_delta` | +| `stream_event` `content_block_stop` | `text_end` / `thinking_end` | +| `assistant` message `tool_use` block (top level, `parent_tool_use_id === null`) | push `toolCall` block stamped `kCursorExecResolved: true` and `kStreamingBlockKind: "claude-sdk"`; emit `toolcall_start` + `toolcall_end`. Tool name mapped per Rendering. | +| `user` message with `tool_result` blocks | `handlers.onToolResult({ toolCallId, toolName, content, isError })` so the transcript gets the paired result. No stream event. | +| any message with `parent_tool_use_id !== null` | folded: text is appended to the parent Task tool's result via `onToolResult`; no top-level events. | +| `rate_limit_event` | `handlers.onRateLimit(info)` (optional); no stream event. | +| `result` subtype `success` | `done` with `reason: "stop"`, usage from `result.usage` (`input_tokens`, `output_tokens`, `cache_read_input_tokens`, `cache_creation_input_tokens`), cost zero. | +| `result` subtype error (`is_error`) | `error` with `reason: "error"` and the result text. | +| subprocess exit / thrown error | `error`; if the message indicates not logged in, wrap in `AIError` with the `claude login` instruction. | + +Text deltas that arrive as full `assistant` messages without preceding +`stream_event`s (non-streaming fallback) are emitted as start/delta/end for +each block. Duplicate content (both stream_event and assistant for the same +block) is de-duplicated by content index tracking: assistant text blocks are +ignored when a stream_event block already ended at that index. + +No retry wrapper: the central HTTP retry policy does not apply +(`retries: 0` equivalent). Abort ends the query via `abortController.abort()` +and emits `error` with `reason: "aborted"`. + +## Session continuity + +- `ClaudeSdkHandlers.getSdkSessionId(): string | undefined` and + `setSdkSessionId(id)` are implemented in the coding-agent bridge and backed + by a custom session entry type `claude-sdk-session` (`{ sdkSessionId }`) so + resume survives restart. +- omp compaction, fork, branch, or `/clear` calls `handlers.resetSdkSession()` + (clears the id). The next turn sends the full flattened history as the + prompt and captures the new id from `init`. +- If `resume` fails (SDK reports unknown session), the provider clears the id + and retries the turn once with the flattened history. + +## Permissions + +`ClaudeSdkHandlers.requestToolPermission(toolName, input, opts): Promise` +lives beside `CursorExecHandlers` in `packages/coding-agent/src/sdk.ts` and is +threaded the same way: `AgentOptions.claudeSdkHandlers` in +`packages/agent/src/agent.ts` -> stream options -> provider. + +Tier map (Claude Code tool -> omp `ToolTier`): + +| Tier | Tools | +| --- | --- | +| read | `Read`, `Glob`, `Grep`, `LS`, `WebFetch`, `WebSearch`, `TodoRead`, `TodoWrite`, `Task`, `Skill` | +| write | `Edit`, `MultiEdit`, `Write`, `NotebookEdit` | +| exec | `Bash`, `KillShell`, and any unknown tool | + +Resolution: reuse `packages/coding-agent/src/tools/approval.ts` comparison of +tier vs active approval mode plus user overrides keyed `claude-code.`. +`allow` -> `{ behavior: "allow" }`. `deny` -> `{ behavior: "deny", message }`. +`prompt` -> omp's existing tool approval prompt with the tool name and a +truncated JSON of `input`; user accept -> allow, reject -> deny with +`message: "Denied by user in omp"`. Abort signal -> deny. + +## Rendering + +Tool name map for transcript blocks: `Read->read`, `Edit->edit`, +`MultiEdit->edit`, `Write->write`, `Bash->bash`, `Grep->grep`, `Glob->find`, +`LS->ls`, `WebFetch->fetch`, `WebSearch->web_search`, others keep the Claude +Code name lowercased. Arguments are passed through unchanged; renderers must +tolerate unknown keys (they already do for Cursor). + +## Touch list + +| File | Change | +| --- | --- | +| `packages/catalog/src/types.ts` | add `"claude-agent-sdk"` to `KnownApi`; compat type entry | +| `packages/catalog/src/build.ts` | compat case | +| `packages/catalog/src/provider-models/descriptors.ts`, `special.ts` | `claude-code` entry with `specialModelManager` using SDK `supportedModels()` and static fallback | +| `packages/ai/src/types.ts` | `ApiOptionsMap["claude-agent-sdk"] = ClaudeAgentSdkOptions`; `StreamOptions.claudeSdkHandlers?` | +| `packages/ai/src/api-registry.ts` | builtin name list | +| `packages/ai/src/stream.ts` | both dispatch switches | +| `packages/ai/src/providers/claude-agent-sdk.ts` | stream function (new) | +| `packages/ai/src/providers/claude-agent-sdk-types.ts` | `ClaudeSdkHandlers` interface, tier/name maps (new) | +| `packages/ai/src/registry/claude-code.ts` + `registry.ts` | provider def with login detection | +| `packages/ai/package.json` | dependency | +| `packages/agent/src/agent.ts` | `claudeSdkHandlers` option threaded to stream options | +| `packages/coding-agent/src/sdk.ts` | `ClaudeSdkHandlers` implementation (session entry, approval prompt) | +| `packages/coding-agent/src/thinking.ts`, `session/model-controls.ts` | effort support for the new api | +| `docs/providers.md`, `docs/provider-endpoint-constraints.md` | document | + +## Testing + +- `packages/ai/src/providers/__tests__/claude-agent-sdk.test.ts`: fake + `query` async generator injected via a module-level `setQueryForTests` + hook. Cases: text streaming order; thinking; tool_use -> resolved toolCall + + paired result; init captures session id; resume passed when id stored; + flattened prompt when no id; result usage mapping; is_error -> error; + abort -> aborted; canUseTool tier routing allow/deny/prompt. +- `packages/ai/src/registry/__tests__/claude-code.test.ts`: login detection + ordering with a temp HOME. +- Live smoke: `packages/ai/scripts/claude-sdk-smoke.ts`, runs only when + `OMP_CLAUDE_SDK_SMOKE=1`, prompt `Reply with exactly: OK`, asserts the text + and a non-empty session id. + +## Out of scope for v1 + +Bridging omp's own tools into the SDK via MCP, omp `mcp.json` servers, +hooks, subagent transcripts as nested blocks, thinking display controls beyond +`effort`. diff --git a/docs/theme.md b/docs/theme.md index a85a0bc3ea41..92342eb319c6 100644 --- a/docs/theme.md +++ b/docs/theme.md @@ -353,6 +353,6 @@ Use this workflow: - All `colors` tokens are required for custom themes except optional `thinkingMax`, which falls back to `thinkingXhigh`. - `export` and `symbols` are optional. -- `$schema` in theme JSON is informational; runtime validation is enforced by the ArkType schema in code. +- `$schema` in theme JSON is informational; runtime validation is enforced by the ArkType-compatible schema in code (`themeJsonSchema` in `src/modes/theme/schema.ts`). - `setTheme` failure falls back to `dark`; `previewTheme` failure does not replace current theme. - File watcher reload errors or temporary missing files keep the current loaded theme until a successful reload or explicit theme switch. diff --git a/docs/toolconv/pi-native.md b/docs/toolconv/pi-native.md index c924e7b35649..c1c06a39db74 100644 --- a/docs/toolconv/pi-native.md +++ b/docs/toolconv/pi-native.md @@ -13,6 +13,18 @@ routes translate and can lose pi-specific fields; pi-native sends the canonical types directly, preserving service tier, cache markers, thinking budgets, tool-choice variants, images, and tool-call IDs. +### Removed omp tool-call dialect + +Historically, "pi-native" named an in-band tool-call serialization: an XML +dialect of `` blocks, replaced by a sigil-delimited format +(v16.0.10, `f743ddc`, 2026-06-19), then deleted outright (v16.2.2, +`053da98`, 2026-06-27) along with its selection knobs (`tools.format: "pi"`, +`PI_DIALECT=pi`). Nothing in `packages/ai` emits or parses either spelling. +Old references to `` blocks or `§` headers as "the omp tool-call +format" describe a format that no longer exists; the in-band dialects that +remain serve third-party model families (the live list is the registry in +`packages/ai/src/dialect/factory.ts`). + ## Configuration and dispatch A model opts in with: diff --git a/docs/tools/ast-grep.md b/docs/tools/ast-grep.md index 5dc5d1bbb04a..de8ff5f21ffe 100644 --- a/docs/tools/ast-grep.md +++ b/docs/tools/ast-grep.md @@ -19,7 +19,7 @@ | Field | Type | Required | Description | | --- | --- | --- | --- | | `pat` | `string` | Yes | Single AST pattern. The wrapper trims it and rejects empty strings. | -| `path` | `string` | No | File, directory, glob, internal URL, or fetched web URL to search. Separate multiple roots with `;`. Omitted or empty defaults to `.` (the workspace root). Internal-URL globs are rejected. | +| `path` | `string` | No | One file, directory, glob, internal URL with a backing file, or fetched web URL — or several of those as a semicolon-delimited list (`"src; tests"`). Omitted or empty defaults to `.` (the workspace root). Empty entries are rejected. Internal-URL globs are rejected. | | `skip` | `number` | No | Match offset. Defaults to `0`, then `Math.floor(...)`; negatives and non-finite values fail. | Pattern grammar and language support exposed to the model: @@ -41,15 +41,15 @@ Pattern grammar and language support exposed to the model: - match lines rendered under `[PATH#HASH]` as `*LINE:text` in hashline mode or `*LINE|text` otherwise, - continuation lines for multi-line matches rendered with a leading space, - an optional `meta: NAME=value, …` line per match when ast-grep captured metavariables. -- If no matches are found, text is `No matches found` or `No matches found. Parse issues mean the query may be mis-scoped; narrow paths before concluding absence.` plus formatted parse issues. -- If the wrapper truncates visible results, the text ends with `Result limit reached; narrow paths or increase limit.` +- If no matches are found, text is `No matches found` or `No matches found. Parse issues mean the query may be mis-scoped; narrow \`path\` before concluding absence.` plus formatted parse issues. +- If the wrapper truncates visible results, the text ends with `Result limit reached; narrow path or increase limit.` - `details` includes counts and metadata, not full match payloads: - `matchCount`, `fileCount`, `filesSearched`, `limitReached` - optional `parseErrors`, `parseErrorsTotal`, `scopePath`, `searchPath`, `cwd`, `files`, `fileMatches`, `displayContent`, `meta` - Native ranges (`byteStart`, `byteEnd`, `startLine`, `startColumn`, `endLine`, `endColumn`) exist only inside the native result; the wrapper does not emit them directly to the model. ## Flow -1. `AstGrepTool.execute()` trims and validates `pat`, normalizes `skip`, converts semicolon-delimited `path` to roots (default `.`), then delegates scope resolution to `resolveToolSearchScope()`. +1. `AstGrepTool.execute()` validates `pat`, normalizes `skip`, then delegates path resolution to `resolveToolSearchScope()` in `packages/coding-agent/src/tools/path-utils.ts`, which normalizes entries, expands semicolon-delimited lists (plus conditional comma/whitespace splits), and rejects empty `path` entries. 2. Internal URLs are resolved through the shared router; entries without `sourcePath` and internal-URL globs fail. Readable external URLs are materialized to immutable local files for searching. 3. For multiple path inputs, `partitionExistingPaths()` drops missing bases only when at least one surviving base remains; if all bases are missing the call fails. 4. `parseSearchPathPreferringLiteral()` splits a single path into `basePath` plus optional `glob`. `resolveExplicitSearchPaths()` collapses multiple inputs into a common base plus a brace-union glob, or separate `targets` when the common ancestor is not itself one of the requested paths. diff --git a/docs/tools/eval.md b/docs/tools/eval.md index 5c4760a1fd36..84db515620ff 100644 --- a/docs/tools/eval.md +++ b/docs/tools/eval.md @@ -8,6 +8,7 @@ - Entry and dynamic schema: `packages/coding-agent/src/tools/eval.ts` - Backend enablement: `packages/coding-agent/src/tools/eval-backends.ts` - Model-facing prompt: `packages/coding-agent/src/prompts/tools/eval.md` +- Code Mode transport (Codex `code_mode_only` sessions demote non-essential tools into an eval bridge): `packages/coding-agent/src/tools/eval-format/code-mode-declarations.ts`, prompt `packages/coding-agent/src/prompts/tools/eval-code-mode.md` - Shared contracts: `packages/coding-agent/src/eval/backend.ts`, `types.ts`, `executor-base.ts`, `kernel-base.ts` - Host bridges: `packages/coding-agent/src/eval/agent-bridge.ts`, `completion-bridge.ts`, `concurrency-bridge.ts`, `budget-bridge.ts` - JavaScript: `packages/coding-agent/src/eval/js/` @@ -26,7 +27,7 @@ The params object is one cell. There is no `cells` array, header parser, languag | `language` | `"py" \| "js" \| "rb" \| "jl"` | Yes | Explicit backend token. Normally the live schema includes only enabled runtimes; see the all-disabled edge case below. | | `code` | `string` | Yes | Cell body, verbatim. | | `title` | `string` | No | Short transcript label. | -| `timeout` | `number` | No | Runtime-work timeout in seconds. Default 30; `0` disables the cell timeout. Nonzero values are clamped by the tool timeout policy and `tools.maxTimeout`. | +| `timeout` | `number` | No | Runtime-work timeout in seconds. Default 30; `0` disables the cell timeout. Nonzero values are clamped by the tool timeout policy (`TOOL_TIMEOUTS.eval`: 1–3600 s) and `tools.maxTimeout`. | | `reset` | `boolean` | No | Recreate this language's retained runtime before execution. Other language runtimes are untouched. Default `false`. | Example across three calls: @@ -74,6 +75,7 @@ Ruby and Julia are opt-in. When at least one runtime is enabled, disabled runtim - `statusEvents`: deduplicated helper/tool status events. - `notice`: optional backend notice. - `meta`: output truncation/artifact metadata supplied by `toolResult(...)`. +- `async`: present when the cell was auto-backgrounded as an async job (`{ state, jobId, type: "eval" }`). - `isError`: set for backend failure or cancellation. The renderer merges call and result inline, syntax-highlights from the declared language, renders markdown and JSON trees specially, and shows timeout/truncation metadata. `session.allocateOutputArtifact?.("eval")` backs spilled output; `artifact://...` in `meta` reaches the full capture. @@ -89,6 +91,16 @@ The renderer merges call and result inline, syntax-highlights from the declared 7. Output chunks stream into an artifact-aware `OutputSink` and live tail. Rich displays are separated into JSON, image, markdown, and status channels. 8. Success, nonzero exit, and cancellation are assembled into the result shapes above. The output sink is finalized even when execution fails. +## Auto-backgrounding + +With `eval.autoBackground.enabled` (default `false`), a cell that outlives `eval.autoBackground.thresholdMs` (default 60000 ms) is converted into a managed async job instead of blocking the turn: + +- The tool foreground-waits for `resolveAutoBackgroundWaitMs(thresholdMs, clampedCellTimeoutMs)`: the threshold, clamped down to the cell's own clamped timeout minus a 1 s buffer so a deadline expiry resolves inline rather than backgrounding moments before it fires. Raising `timeout` therefore does not extend foreground execution beyond the threshold. A threshold of `0` backgrounds immediately. +- On backgrounding, the tool returns the live output tail plus `Backgrounded as job ; result will be delivered automatically.`, with `details.async = { state: "running", jobId, type: "eval" }`. The job's completion is delivered later like a backgrounded bash command. +- A queued user/peer message (steer) arriving mid-wait backgrounds the cell immediately ("Backgrounded early to handle an incoming message; the cell keeps running."). +- At the async-job manager's running-job capacity the tool falls through to ordinary foreground execution instead of failing. +- A failed, cancelled, or timed-out cell is reported as a failed background job (an errored execution is re-entered into the job manager's failure path), never as a silent success. + ## Runtime behavior ### JavaScript (`js`) @@ -163,7 +175,7 @@ Runs one subagent through `runStructuredSubagent(...)`: - Prelude helpers may read/write files and call arbitrary registered tools; JS exposes network-capable `fetch`. - Python, Ruby, and Julia use retained subprocess kernels speaking framed local IPC. JavaScript uses a worker VM. -- Retained runtimes survive calls until reset, owner cleanup, or process exit. +- Retained runtimes have no heartbeat or idle timer; they survive calls until reset, owner disposal (`EvalRunner.disposeKernels()` calls the `disposeKernelSessionsByOwner` / `disposeRubyKernelSessionsByOwner` / `disposeJuliaKernelSessionsByOwner` / `disposeVmContextsByOwner` family keyed by `kernelOwnerId`, in `packages/coding-agent/src/session/eval-runner.ts`), or process exit. - Cancellation is destructive when needed: JS terminates its worker; managed kernels interrupt and may escalate to shutdown. A reset is likewise destructive to concurrent work sharing that backend session. - Eval-driven `agent()` may run tools and isolated workspaces, but its child is disposed rather than retained for hub follow-up. diff --git a/docs/tools/generate_image.md b/docs/tools/generate_image.md index 43c4c80ac5f4..70714ba9a42e 100644 --- a/docs/tools/generate_image.md +++ b/docs/tools/generate_image.md @@ -24,7 +24,7 @@ The custom tool is registered only when `generate_image.enabled=true` (default ` | `aspect_ratio` | `"1:1" \| "3:4" \| "4:3" \| "9:16" \| "16:9" \| "3:2" \| "2:3"` | No | Requested output aspect ratio. | | `image_size` | `"1024x1024" \| "1536x1024" \| "1024x1536"` | No | Requested output size where the selected provider supports it. | | `input` | `Array<{ path?: string; data?: string; mime_type?: string }>` | No | Input images by local path or inline base64 data. | -| `provider` | `"auto" \| "openai" \| "openai-codex" \| "antigravity" \| "xai" \| "openrouter" \| "gemini"` | No | Per-request provider preference. A concrete value is tried first; `auto` or omission uses configured/session ordering. | +| `provider` | `"auto" \| "openai" \| "openai-codex" \| "antigravity" \| "xai" \| "openrouter" \| "gemini" \| "deepinfra"` | No | Per-request provider preference. A concrete value is tried first; `auto` or omission uses configured/session ordering. | ## Outputs - Success with image data: @@ -35,7 +35,7 @@ The custom tool is registered only when `generate_image.enabled=true` (default ` ## Flow 1. The SDK injects `generate_image` as a custom tool via `getImageGenTools()` only when the feature gate and tool filter allow it. -2. Provider order is: concrete per-request `provider`, entries in `providers.imageOrder`, the active session model's corresponding image provider, then the built-in order `openai`, `openai-codex`, `antigravity`, `xai`, `openrouter`, `gemini`; duplicates are removed. `provider: "auto"` does not add a provider. +2. Provider order is: concrete per-request `provider`, entries in `providers.imageOrder`, the active session model's corresponding image provider, then the built-in order `openai`, `openai-codex`, `antigravity`, `xai`, `openrouter`, `gemini`, `deepinfra`; duplicates are removed. `provider: "auto"` does not add a provider. 3. The tool skips providers without usable credentials. Credentialed provider HTTP failures are collected and the next provider is tried; validation, parsing, local I/O, cancellation, and timeout failures are not fallback conditions. 4. Input images are resolved once, after the first usable provider is found. A `path` is resolved relative to session cwd and content-sniffed. Inline `data` may be raw base64 (requiring `mime_type`) or a `data:;base64,...` URL. 5. Provider-specific aspect-ratio support is checked after provider selection. @@ -46,6 +46,7 @@ The custom tool is registered only when `generate_image.enabled=true` (default ` - OpenRouter: image-capable chat completion endpoint. - xAI: Grok Imagine generation or edit endpoint. - Gemini: Gemini `generateContent` with `responseModalities: ["IMAGE"]`. + - DeepInfra: OpenAI-compatible `images/generations` endpoint (default model `black-forest-labs/FLUX-2-pro`, `DEEPINFRA_API_KEY` accepted). Text-to-image only — edit requests fall through to a later edit-capable provider. 7. Inline images in a successful provider response are saved to temporary files; paths and base64/MIME image metadata are returned. A response with no image data returns a normal zero-image result rather than `isError`. ## Modes / Variants diff --git a/docs/tools/github.md b/docs/tools/github.md index d6f1f9139c48..57a12b829bec 100644 --- a/docs/tools/github.md +++ b/docs/tools/github.md @@ -8,7 +8,10 @@ - Key collaborators: - `packages/coding-agent/src/tools/gh-format.ts` — shorten commit SHAs for summaries. - `packages/coding-agent/src/tools/gh-renderer.ts` — TUI rendering, especially `run_watch` live/result views. - - `packages/coding-agent/src/utils/git.ts` — `gh`/`git` process wrappers, repo locking, branch config writes. + - `packages/coding-agent/src/utils/github.ts` — `gh` process wrapper (`github.run/json/text()`), non-interactive env, command deadline, bounded output capture. + - `packages/coding-agent/src/tools/gh-common.ts` — shared helpers, current-repo resolution, result building. + - `packages/coding-agent/src/utils/repo-lock.ts` — per-repo write serialization (`withRepoLock`). + - `@oh-my-pi/pi-natives/vcs` — git operations (`vcs.git()` / `vcs.requireGit()`: branch/worktree/config/push). - `packages/utils/src/dirs.ts` — base directory for dedicated PR worktrees. - `packages/coding-agent/src/sdk.ts` — session artifact allocation hook. - `packages/coding-agent/src/session/artifacts.ts` — artifact filename format `..log`. @@ -24,7 +27,7 @@ | Field | Type | Required | Description | | --- | --- | --- | --- | | `op` | `"repo_view" \| "file_read" \| "pr_create" \| "pr_checkout" \| "pr_push" \| "search_issues" \| "search_prs" \| "search_code" \| "search_commits" \| "search_repos" \| "run_watch"` | Yes | Dispatch selector. `GithubTool.execute()` switches only on this field. | -| `repo` | `string` | No | `owner/repo` override. Ignored when the identifier argument is already a full GitHub URL. For `search_issues`/`search_prs`/`search_code`/`search_commits`, defaults to the current checkout's `owner/repo` when omitted (skipped when the query already contains a `repo:`/`org:`/`user:`/`owner:` qualifier or when current-repo resolution fails). Required in practice when `gh` cannot infer repo context from the current checkout. | +| `repo` | `string` | No | `[host/]owner/repo` override. The host prefix is optional only when it matches the host `gh` defaults to (github.com, or `GH_HOST` when set); a repository on any other host — including github.com while `GH_HOST` names an enterprise instance — must be qualified, or `gh` sends the request to its default host. Ignored when the identifier argument is already a full GitHub URL. For `search_issues`/`search_prs`/`search_code`/`search_commits`, defaults to the current checkout's repository when omitted (skipped when the query already contains a `repo:`/`org:`/`user:`/`owner:` qualifier or when current-repo resolution fails). Required in practice when `gh` cannot infer repo context from the current checkout. | | `branch` | `string` | No | Used by `repo_view`, `file_read`, `pr_push`, and `run_watch`. `file_read` omits the ref to use the repository's default branch; `run_watch` falls back to the current git branch when `run` is omitted; `pr_push` falls back to the current branch. | | `path` | `string` | No | Required by `file_read`. Repository-relative path to a file in the GitHub repository; leading `/` is rejected. | | `pr` | `string \| string[]` | No | Used by `pr_checkout`. Each item may be a PR number, branch name, or GitHub PR URL. Array form enables batching. Omitted means current branch PR. | @@ -48,7 +51,7 @@ | `tail` | `number` | No | Used only by `run_watch`. Defaults to `15`, floored, clamped to `200`, and must be `> 0`. | ## Outputs -The tool returns a single text result built by `buildTextResult()` in `packages/coding-agent/src/tools/gh.ts`. +The tool returns a single text result built by `buildTextResult()` in `packages/coding-agent/src/tools/gh-common.ts`. - `content`: one text block. Multi-item ops join sections with blank lines and `---` separators. - `sourceUrl`: set for repository/file/PR/run results when a canonical URL is known. @@ -62,18 +65,20 @@ The tool returns a single text result built by `buildTextResult()` in `packages/ `run_watch` is the only streaming op. It emits `onUpdate` snapshots while polling, then returns one final text result. ## Flow -1. `GithubTool.createIf()` exposes the tool only when `git.github.available()` finds `gh` on `PATH`. +1. `GithubTool.createIf()` exposes the tool only when `github.available()` finds `gh` on `PATH`. 2. `GithubTool.execute()` wraps dispatch in `untilAborted()` and switches on `params.op`. 3. Each op normalizes optional strings, arrays, booleans, and numeric caps locally in `packages/coding-agent/src/tools/gh.ts`. -4. CLI execution goes through `git.github.run/json/text()` in `packages/coding-agent/src/utils/git.ts`: - - spawns `gh ...` with `Bun.spawn()`; +4. CLI execution goes through `github.run/json/text()` in `packages/coding-agent/src/utils/github.ts`: + - spawns `gh ...` with `Bun.spawn()` under a non-interactive env, with a 5-minute deadline (`GH_COMMAND_TIMEOUT_MS`) and an 8 MiB captured-output cap; - trims stdout/stderr unless `trimOutput: false`; - maps common auth/repo-context failures into tool-facing `ToolError` messages; - `json()` rejects empty or invalid JSON. + - Current-checkout resolution runs `gh repo view --json url -q .url` and keeps the host: the result is `owner/repo` on github.com and `host/owner/repo` elsewhere. `gh` resolves a host-less `--repo` against `GH_HOST` (github.com by default), so the prefix is what keeps an enterprise checkout off github.com. `gh api` endpoint paths never carry a host, so repo-scoped API calls strip it back off and pass `--hostname` instead; GitHub search qualifiers do the same (`repo:owner/repo` plus `--hostname`). + - A host named by a full URL (a `pr:///…` read, a PR/issue/run URL argument) is preserved as given, including `github.com`, so `GH_HOST` cannot redirect that request. Cache rows drop a prefix naming the host `gh` defaults to — `github.com/owner/repo` and `owner/repo` share one row normally, while under `GH_HOST` the explicit `github.com/` form keeps its own rows because the bare form then means the configured instance. 5. Read-style ops (`repo_view`, `file_read`, `search_*`) fetch repository data and return text or formatted Markdown-like summaries. `file_read` uses GitHub's contents API with the raw-media accept header and preserves the response bytes as text. Single-issue and single-PR views were moved out of the tool and now resolve through the `issue://` / `pr://` internal URL schemes, which share the same SQLite cache. 6. PR diffs moved out of the tool. `pr:///diff` lists changed files, `pr:///diff/` slices a single file, and `pr:///diff/all` returns the full unified diff — see `docs/tools/read.md`. All three variants share one `gh pr diff` invocation through the `pr-diff` cache row. -7. `pr_checkout` resolves PR metadata first, then enters `git.withRepoLock()` before any git mutation so parallel checkout calls for the same primary repo do not race on shared `.git` state. -8. `pr_push` reads PR head metadata back from git branch config, derives a refspec, pushes with `git.push()`, then invalidates the cached `pr://` rows for the pushed PR via `invalidateAllForNumber()` so the next `pr://` read reflects the push. +7. `pr_checkout` resolves PR metadata first, then enters `withRepoLock()` (`packages/coding-agent/src/utils/repo-lock.ts`) before any git mutation so parallel checkout calls for the same primary repo do not race on shared `.git` state. +8. `pr_push` reads PR head metadata back from git branch config, derives a refspec, pushes with `repository.push()` (`@oh-my-pi/pi-natives/vcs`), then invalidates the cached `pr://` rows for the pushed PR via `invalidateAllForNumber()` so the next `pr://` read reflects the push. 9. `pr_create` shells out once, then best-effort re-reads the created PR for a richer summary. 10. `run_watch` chooses either run mode (`run` supplied) or commit mode (`run` omitted), polls GitHub Actions APIs every 3 seconds for the first minute and every 15 seconds after that, emits streaming updates, and may save a full failed-log artifact before returning. 11. Final text goes through `toolResult().text(...)`; if `session.allocateOutputArtifact()` returns a slot, failed-log text is persisted with `Bun.write()`. @@ -128,14 +133,14 @@ Branches: | Required fields | `op` | | Optional fields | `repo`, `pr`, `force` | | `gh` command | For each requested PR: `gh pr view [] [--repo ] --json `; cross-repo PRs may also call `gh repo view --json `. | -| Batching | Yes. `pr` may be `string[]`; each PR is resolved in parallel, but git mutations are serialized per primary repo by `git.withRepoLock()`. | +| Batching | Yes. `pr` may be `string[]`; each PR is resolved in parallel, but git mutations are serialized per primary repo by `withRepoLock()`. | | Output | Single PR: checkout/worktree summary plus `details.repo`, `details.branch`, `details.worktreePath`, `details.remote`, `details.remoteBranch`, `details.checkouts`. Batched: `# Pull Request Worktrees (...)` plus one section per PR and aggregated `details.checkouts`. On partial failure the header becomes `# / Pull Request Worktrees checked out ( failed)` with a trailing `## Failed` list. | Worktree and metadata behavior: - Local branch name is always `pr-`. - Worktree path is `getWorktreeDir("-")` = `path.join(getWorktreesDir(), "-")`, where `` is the PR number and `` is `hashPath(primaryRepoRoot)` (a 7-hex digest of the primary repo root). `getWorktreesDir()` resolves the base in this order: a valid `OMP_WORKTREE_DIR`, the applied `worktree.base` setting, then the profile/XDG-aware data-root default (normally `~/.omp/wt`). Both overrides expand a leading `~` and must resolve to an absolute path; an invalid relative value is ignored and resolution falls through. `resolveAvailableWorktreePath()` appends a `-2`/`-3`… suffix when the resulting path is already registered with git or present on disk. -- Existing worktree detection is by branch ref `refs/heads/pr-` from `git.worktree.list()`. -- New worktree creation calls `git.worktree.add(repoRoot, finalWorktreePath, localBranch, { signal })` after verifying the path is neither already registered nor already present on disk. +- Existing worktree detection is by branch ref `refs/heads/pr-` from `repository.worktrees()` (`@oh-my-pi/pi-natives/vcs`). +- New worktree creation calls `repository.worktreeAdd(finalWorktreePath, localBranch, false, signal)` after verifying the path is neither already registered nor already present on disk. - For same-repo PRs, remote is `origin`. For cross-repo PRs, the tool resolves a clone URL for the head repo, reuses an existing remote with the same URL when possible, or creates `fork-` / `fork--`. - The branch push metadata is persisted with `git config` under the repository's shared `.git/config` as: - `branch.pr-.remote` @@ -145,7 +150,7 @@ Worktree and metadata behavior: - `branch.pr-.ompPrUrl` - `branch.pr-.ompPrIsCrossRepository` - `branch.pr-.ompPrMaintainerCanModify` -- If `refs/heads/pr-` already exists at a different commit, checkout fails unless `force=true`, in which case `git branch --force` resets it to the fetched PR head. +- If `refs/heads/pr-` already exists at a different commit, checkout fails unless `force=true`, in which case `repository.createBranch(..., force=true)` resets it to the fetched PR head. - If a matching worktree already exists, the tool reuses it and reports `reused: true`. ### `pr_push` @@ -226,7 +231,7 @@ Push target resolution reads the `branch..ompPrHeadRef`, `pushRemote`/`rem | --- | --- | | Required fields | `op` | | Optional fields | `repo`, `branch`, `run`, `tail` | -| `gh` command | Repo resolution: `gh repo view --json nameWithOwner -q .nameWithOwner` when `repo` and run URL repo are both absent. Single-run mode uses `gh api --method GET /repos//actions/runs/` and `gh api --method GET /repos//actions/runs//jobs`. Commit mode uses `gh api --method GET /repos//branches/`, `gh api --method GET /repos//actions/runs`, `gh api --method GET /repos//actions/runs//jobs`, and `gh api /repos//actions/jobs//logs` for failed jobs. | +| `gh` command | Repo resolution: `gh repo view --json url -q .url` when `repo` and run URL repo are both absent. Single-run mode uses `gh api --method GET /repos//actions/runs/` and `gh api --method GET /repos//actions/runs//jobs`. Commit mode uses `gh api --method GET /repos//branches/`, `gh api --method GET /repos//actions/runs`, `gh api --method GET /repos//actions/runs//jobs`, and `gh api /repos//actions/jobs//logs` for failed jobs. | | Batching | Implicit batching only in commit mode: all workflow runs for one commit are tracked together. | | Output | Streaming watch snapshots via `onUpdate`, then a final text report. On failure, appends `Full failed-job logs: artifact://` and sets `details.artifactId`. | @@ -234,7 +239,7 @@ Watch flow: - `run` parsing accepts either a decimal run ID or a full run URL. URL repo must match explicit `repo` when both are given. - Poll interval is `3` seconds (`RUN_WATCH_INTERVAL_DEFAULT`) for the first `60` seconds of the watch (`RUN_WATCH_FAST_WINDOW_MS`), then `15` seconds (`RUN_WATCH_INTERVAL_SLOW`). Rate-limited poll errors back off at the slow interval and are retried up to `5` consecutive failures (`RUN_WATCH_MAX_POLL_FAILURES`). Commit mode gives up with a clear message after `90` seconds if no runs ever appear (`RUN_WATCH_NO_RUNS_GIVE_UP_MS`). - Failure grace period is fixed at 5 seconds (`RUN_WATCH_GRACE_DEFAULT`). When any failed job appears before completion, the tool emits a note, waits once, re-fetches state, then collects logs so concurrent failures are included. -- Failed-job logs are fetched with `gh api /repos//actions/jobs//logs` via `git.github.run()`, not `json()`. Non-zero exit leaves `available: false` instead of failing the whole watch. +- Failed-job logs are fetched with `gh api /repos//actions/jobs//logs` via `github.run()`, not `json()`. Non-zero exit leaves `available: false` instead of failing the whole watch. - Inline result includes only the last `tail` lines per failed job. The saved artifact contains full logs (`mode: "full"`). - In commit mode, success is intentionally double-checked: once all known runs are successful, the tool waits one more poll interval and succeeds only if the set of run IDs is unchanged. This avoids returning before late workflow runs appear for the same commit. - `details.watch` drives a specialized renderer in `packages/coding-agent/src/tools/gh-renderer.ts`; non-watch results fall back to generic text rendering. @@ -249,7 +254,7 @@ Watch flow: - `pr_push` uses git network transport to the configured remote. - Subprocesses / native bindings - All `gh` calls use `Bun.spawn(["gh", ...args])`. - - `pr_checkout` and `pr_push` also invoke git helpers from `packages/coding-agent/src/utils/git.ts`. + - `pr_checkout` and `pr_push` also invoke git operations via `@oh-my-pi/pi-natives/vcs` (`vcs.requireGit()`), serialized by `withRepoLock()` from `packages/coding-agent/src/utils/repo-lock.ts`. - Session state (transcript, memory, jobs, checkpoints, registries) - `run_watch` consumes `session.allocateOutputArtifact()` when failed-job logs are persisted. - Returned `details` objects carry run/checkouts metadata for the renderer/UI. @@ -258,12 +263,12 @@ Watch flow: - `gh-renderer` provides compact headers for all ops and a custom live watch view for `run_watch`. - Background work / cancellation - `run_watch` loops until success/failure and uses `scheduler.wait()` between polls. - - `GithubTool.execute()` is wrapped in `untilAborted()`; `git.github.run()` forwards the abort signal into `Bun.spawn()`. + - `GithubTool.execute()` is wrapped in `untilAborted()`; `github.run()` forwards the abort signal into `Bun.spawn()`. ## Limits & Caps -- Search result default: `10` (`SEARCH_LIMIT_DEFAULT` in `packages/coding-agent/src/tools/gh.ts`). +- Search result default: `10` (`SEARCH_LIMIT_DEFAULT` in `packages/coding-agent/src/tools/gh-search.ts`). - Search result max: `50` (`SEARCH_LIMIT_MAX`). -- PR file preview inside the `pr://` view: first `50` files only (`FILE_PREVIEW_LIMIT` in `gh.ts`). For aggregate diffs rejected at GitHub's 20,000-line limit, the `pr:///diff` fetcher falls back to the paginated files API (`100` files per page, at most `3000` files); binary or individually oversized patches remain listed with an unavailable-patch marker. +- PR file preview inside the `pr://` view: first `50` files only (`FILE_PREVIEW_LIMIT` in `gh-search.ts`). For aggregate diffs rejected at GitHub's 20,000-line limit, the `pr:///diff` fetcher falls back to the paginated files API (`100` files per page, at most `3000` files); binary or individually oversized patches remain listed with an unavailable-patch marker. - Run-watch poll interval: `3s` for the first `60s`, then `15s` (`RUN_WATCH_INTERVAL_DEFAULT`, `RUN_WATCH_FAST_WINDOW_MS`, `RUN_WATCH_INTERVAL_SLOW`); commit mode with no runs gives up after `90s` (`RUN_WATCH_NO_RUNS_GIVE_UP_MS`); up to `5` consecutive rate-limited poll failures are tolerated (`RUN_WATCH_MAX_POLL_FAILURES`). - Run-watch failure grace period: `5s` (`RUN_WATCH_GRACE_DEFAULT`). - Run-watch failed-log tail default: `15` lines (`RUN_WATCH_TAIL_DEFAULT`). @@ -275,8 +280,8 @@ Watch flow: ## Errors - Tool creation is skipped entirely when `gh` is not installed. -- `git.github.run()` throws `ToolError("GitHub CLI (gh) is not installed...")` if `gh` is missing at execution time. -- `git.github.text/json()` map common failures to model-facing messages: +- `github.run()` throws `ToolError("GitHub CLI (gh) is not installed...")` if `gh` is missing at execution time. +- `github.text()/json()` map common failures to model-facing messages: - not authenticated → `GitHub CLI is not authenticated. Run \`gh auth login\`.` - missing repo context without explicit `repo` → `GitHub repository context is unavailable. Pass \`repo\` explicitly or run the tool inside a GitHub checkout.` - otherwise stderr/stdout text, or fallback `GitHub CLI command failed: gh ...` diff --git a/docs/tools/glob.md b/docs/tools/glob.md index 50aa8c99ab1a..c4ac7876ff09 100644 --- a/docs/tools/glob.md +++ b/docs/tools/glob.md @@ -18,7 +18,7 @@ | Field | Type | Required | Description | | --- | --- | --- | --- | -| `path` | `string` | No | Glob, file, directory, or path-backed internal URL. Separate multiple targets with `;`; omitted or empty defaults to `.`. Existing paths containing delimiters remain literal when they exist. Each target becomes its own walk root and multi-target scans run concurrently. `memory://` alone supports internal-URL glob patterns; `ssh://` is rejected because it has no local backing path. | +| `path` | `string` | No | Glob, file, directory, or path-backed internal URL — or several of those as a semicolon-delimited list (`"src/**/*.ts; test/**/*.ts"`); omitted or empty defaults to `.`. Empty entries are rejected. Semicolon-delimited lists split unconditionally; entries accidentally joined with comma or whitespace are expanded only after existence validation; existing paths containing delimiters remain literal. Each target becomes its own walk root and multi-target scans run concurrently. `memory://` alone supports internal-URL glob patterns; `ssh://` is rejected because it has no local backing path. | | `hidden` | `boolean` | No | Include hidden files. Defaults to `true`. | | `gitignore` | `boolean` | No | Respect `.gitignore` during local native globbing. Defaults to `true`; set `false` to include gitignored files. | | `limit` | `number` | No | Max returned paths. Defaults to `200`; finite positive inputs are floored then clamped to `1..200`. | @@ -43,7 +43,7 @@ The tool returns a single text block plus structured `details`. ## Flow -1. `GlobTool.execute()` converts the optional semicolon-delimited `path` string into roots (default `.`), preserving an existing delimiter-containing path. Unless custom operations are injected, it expands the roots with `expandDelimitedPathEntries(..., parseFindPattern)`. +1. `GlobTool.execute()` converts the optional semicolon-delimited `path` string into roots (default `.`). Unless custom operations are injected, it expands the roots with `expandDelimitedPathEntries(..., parseFindPattern)`: existing delimiter-containing paths stay intact, semicolon-delimited lists split unconditionally, comma splits are accepted when at least one part resolves, and whitespace splits only when every part resolves. 2. The tool normalizes each entry with `normalizePathLikeInput()` and `/\\/g -> "/"`. Empty normalized entries fail with `` `path` must contain non-empty globs or paths ``. 3. For multi-path local calls, `partitionExistingPaths(..., parseFindPattern)` (`packages/coding-agent/src/tools/path-utils.ts`) stats each base path. Missing entries are skipped; if all are missing, the tool throws `Path not found: ...`. Single missing paths still hard-fail. 4. The tool calls `resolveExplicitFindPatterns()` for multi-entry calls; it parses each entry into its own `(basePath, globPattern, hasGlob)` target so every path is walked as its own root (collapsing to a shared ancestor would scan unrelated siblings). Single-entry calls parse with `parseFindPattern()` directly. diff --git a/docs/tools/grep.md b/docs/tools/grep.md index c9880cf07907..8887dce7c623 100644 --- a/docs/tools/grep.md +++ b/docs/tools/grep.md @@ -21,10 +21,10 @@ | Field | Type | Required | Description | | --- | --- | --- | --- | | `pattern` | `string` | Yes | Regex pattern. `grep.ts` rejects whitespace-only input but preserves it verbatim. The native matcher tries Rust regex first, then PCRE2 for features such as lookaround/backreferences, then targeted literal recovery for malformed braces/parentheses. Multiline is enabled only when the pattern contains a literal newline or the two-character sequence `\\n`. | -| `path` | `string` | No | File, directory, glob, archive member, internal URL, fetched URL, or one-file line selector such as `src/foo.ts:50-100`. Separate multiple roots with `;`. Omitted or empty defaults to `.`. Existing paths containing semicolons remain literal; internal URLs cannot contain glob characters. | +| `path` | `string` | No | One file path, directory path, glob-like path, archive member, readable external URL, internal URL, or one-file line selector such as `src/foo.ts:50-100` — or several of those as a semicolon-delimited list (`"src; tests"`). Omitted or empty defaults to `.`. Empty entries are rejected. Semicolon-delimited lists split unconditionally; entries accidentally joined with comma or whitespace are expanded only after existence validation; existing paths containing delimiters stay intact. Internal URLs cannot contain glob characters. | | `case` | `boolean` | No | Case-sensitive search. Defaults to `true`. Passed to native `ignoreCase` or JS `RegExp` flags for virtual resources. | | `gitignore` | `boolean` | No | Respect `.gitignore` during directory scans. Defaults to `true`. | -| `skip` | `number \| null` | No | File-page offset for multi-file results. Defaults to `0`; finite values are floored and negatives/non-finite values fail. Single-file searches ignore it. | +| `skip` | `number` | No | File-page offset for multi-file results. Defaults to `0`; `grep.ts` floors finite numbers and rejects negative or non-finite values. Single-file searches ignore it because they do not paginate by file. | `grep` is enabled by default (`grep.enabled = true`) and is discoverable rather than essential. Context defaults are configurable with `grep.contextBefore` and `grep.contextAfter`. @@ -49,15 +49,18 @@ The tool returns a single text block in `content[0].text` plus structured `detai ## Flow 1. `GrepTool.execute()` validates and normalizes input in `packages/coding-agent/src/tools/grep.ts`: - rejects whitespace-only patterns while preserving the pattern verbatim; - - defaults omitted or empty `path` to `.` and splits semicolon-delimited roots while preserving existing delimiter-containing paths; + - defaults omitted or empty `path` to `["."]` (the workspace root); - normalizes `skip` to a non-negative integer; - - peels any line-range selector from each root; + - expands delimiter-flattened `path` entries with `expandDelimitedPathEntries()`, keeping existing delimiter-containing paths intact, splitting semicolon-delimited lists unconditionally, accepting comma splits when at least one part resolves, and accepting whitespace splits only when every part resolves; + - peels any line-range selector from each resulting entry; - reads `grep.contextBefore` and `grep.contextAfter` from session settings (`1` and `3` by default); - enables multiline only when `pattern` contains `\n` or an actual newline. 2. Each `path` root is normalized with `normalizePathLikeInput()` again during shared scope resolution; this is a no-op for entries already normalized by delimiter expansion. 3. Archive member paths such as `bundle.zip:src/foo.ts` are materialized to temporary UTF-8 scratch files before native grep. Binary or non-UTF-8 archive members are reported as skipped/unreadable. -4. Internal URLs are resolved before filesystem scope resolution: +4. Internal URLs and external URLs are resolved before filesystem scope resolution (`resolveToolSearchScope()`): - glob metacharacters (`*`, `?`, `[`, `{`) are rejected for internal URLs; + - `ssh://` paths fail early (`ssh://` has no local backing file); + - readable external URLs (`http(s)://`, collapsed `http(s):/host`, `www.` spellings when no local path exists) are fetched and materialized to immutable local files; `ftp`/`ws`/`wss` and declined fetches fail with an explicit error; - resources with `sourcePath` are searched through their backing file; - resources without `sourcePath` are searched in memory with JavaScript `RegExp`; - `omp://` expands to every embedded documentation file via URL completion; @@ -71,7 +74,6 @@ The tool returns a single text block in `content[0].text` plus structured `detai 9. It calls native `grep()` from `@oh-my-pi/pi-natives` with: - `pattern`, `ignoreCase`, `multiline`, `gitignore`; - `hidden: true`; - - `cache: false`; - `contextBefore` / `contextAfter` from settings; - `maxColumns: DEFAULT_MAX_COLUMN` (`512`); - `maxCount: INTERNAL_TOTAL_CAP` (`2000`); @@ -138,18 +140,20 @@ The tool returns a single text block in `content[0].text` plus structured `detai - Final text truncation: `truncateHead()` default byte cap `50 * 1024` bytes (`DEFAULT_MAX_BYTES` in `packages/coding-agent/src/session/streaming-output.ts`). `grep.ts` overrides `maxLines` to `Number.MAX_SAFE_INTEGER`, so normal grep output is byte-capped, not line-capped. - Context defaults: `grep.contextBefore = 1`, `grep.contextAfter = 3` in `packages/coding-agent/src/config/settings-schema.ts`. - Pagination: `skip` is a file-page offset for multi-file scopes. The result text says `Use skip= for the next page` when more files remain. -- Native directory-scan cache: available in `grep.rs`, but this tool always sets `cache: false`. +- Native directory-scan cache: disabled natively for this tool — `GrepOptions` has no `cache` field; `build_grep_walk_request` hard-codes `.cache(false)` in `crates/pi-natives/src/grep.rs`. - Native grep wall-clock budget: `30_000ms` per invocation (`SEARCH_GREP_TIMEOUT_MS` in `packages/coding-agent/src/tools/grep.ts`); hitting it raises `Grep timed out after 30s; ...`. - Native per-file size cap: `4 * 1024 * 1024` bytes (`MAX_FILE_BYTES` in `crates/pi-natives/src/grep.rs`, mirrored as `NATIVE_GREP_MAX_FILE_BYTES` in `grep.ts`). Oversized filesystem files are skipped and surfaced as partial coverage (names for explicit files, a count for directory scans). Oversized virtual resources are searched in line-boundary chunks for line mode; multiline virtual searches fall back to JavaScript regex. ## Errors - `Pattern must not be empty` when trimmed `pattern` is empty. - `Skip must be a non-negative number` for negative or non-finite `skip`. -- `` `path` must contain non-empty paths or globs `` when a normalized root is empty. +- `Search scope entries must be non-empty paths or globs` when any normalized `path` entry is empty. - `Glob patterns are not supported for internal URLs: ...` for internal URL + glob metacharacters. +- `Cannot search a remote ssh:// path (no local file): ...` for `ssh://` inputs, with a hint to `read` the remote path or grep a specific remote file. +- `Cannot search external URL: ... Use \`read\` to fetch web content, then search the returned text.` for non-fetchable external URL schemes (`ftp`/`ws`/`wss`) or declined fetches. - Line-range selector errors include `Line-range selector requires a single file, not a glob: ...`, `Line-range selector requires a single file: ... is a directory`, and `Path not found for line-range selector: ...`. - `Cannot search archive member(s): ...` when all archive selectors are unreadable, binary, or non-UTF-8. -- `Path not found: ...; list each target in the semicolon-delimited \`path\`` when a filesystem-backed resolved base path is missing, or when every multi-root filesystem entry is missing (with an archive hint when unreadable archive members contributed). +- `Path not found: ...` when a filesystem-backed resolved base path is missing (multi-path calls append the hint `(\`path\` list entries must each exist relative to cwd)`), or `Path not found: ...; list each target in the semicolon-delimited \`path\`` when every multi-path filesystem entry is missing (with an archive hint when unreadable archive members contributed). - Virtual-resource JavaScript regex compilation can report `Invalid regex: ...`. Filesystem-backed native search normally falls back from Rust regex to PCRE2 and finally to a literal pattern rather than rejecting regex syntax. - Multi-file native scans skip per-file open/search failures inside `grep.rs`; the scan continues with surviving files. - ``Grep timed out after 30s; narrow paths or pattern, or scope with `glob` first`` when native grep hits `SEARCH_GREP_TIMEOUT_MS`. diff --git a/docs/tools/inspect_image.md b/docs/tools/inspect_image.md index 903ef3367e4f..3a1ea8849080 100644 --- a/docs/tools/inspect_image.md +++ b/docs/tools/inspect_image.md @@ -16,7 +16,7 @@ | Field | Type | Required | Description | | --- | --- | --- | --- | -| `path` | `string` | Yes | Local image path (resolved relative to `session.cwd`), current-turn `Image #N` label, or `attachment://N` / `image://N` URI. Attachment indexes are 1-based. | +| `path` | `string` | Yes | Local image path (resolved relative to `session.cwd`), local `.svg`/`.svgz` path with an explicit `:img` selector, current-turn `Image #N` label, or `attachment://N` / `image://N` URI. Attachment indexes are 1-based. | | `question` | `string` | Yes | User prompt sent as a text content block alongside the image. | ## Outputs @@ -27,6 +27,7 @@ The tool returns a single `AgentToolResult`: - `model`: `/` of the selected model. - `imagePath`: resolved filesystem path for a file input, or the canonical attachment URI for an attachment input. - `mimeType`: MIME type actually sent to the model after optional resize/re-encode. + - `usage`: token usage from the model response. Model-visible output is single-shot, not streamed by this tool. @@ -40,30 +41,33 @@ TUI rendering adds presentation-only truncation from `packages/coding-agent/src/ ## Flow 1. `InspectImageTool.execute(...)` rejects immediately if `images.blockImages` is enabled in session settings. 2. It reads `session.modelRegistry`; missing registry, empty registry, missing API key, or unresolved model each raise `ToolError` from `packages/coding-agent/src/tools/inspect-image.ts`. -3. Model selection tries, in order, `@vision`, `@default`, the active model string from the session, then `availableModels[0]`. `expandRoleAlias(...)` and `resolveModelFromString(...)` handle each lookup. -4. The chosen model must advertise `input.includes("image")`; otherwise execution fails before reading the file. -5. The tool interprets exact `Image #N` labels (including bracketed labels), `attachment://N`, and `image://N` as 1-based references into the current turn's image attachments. Other values are loaded as files: `loadImageInput(...)` resolves the path with `resolveReadPath(...)`, detects MIME type with `readImageMetadata(...)`, and rejects files larger than `MAX_IMAGE_INPUT_BYTES` (`20 * 1024 * 1024`, 20 MiB). Attachment bytes have the same 20 MiB cap. -6. File metadata is detected from headers. Attachment inputs use their supplied image MIME type. Supported MIME types are `image/png`, `image/jpeg`, `image/gif`, and `image/webp`. -7. The loader uses `excludeWebP: webpExclusionForModel(model)` (`true` only for models that cannot decode WebP, such as the Ollama family). It calls `resizeImage(...)` when `images.autoResize` is true, or when WebP must be re-encoded for the selected model. Resize failures are swallowed and the original bytes are kept. -8. If the file header or attachment MIME type is unsupported, `execute(...)` throws `ToolError("inspect_image only supports PNG, JPEG, GIF, and WEBP files detected by file content.")`. -9. The tool calls `instrumentedCompleteSimple(...)` with one user message containing two content parts in order: +3. Model selection tries, in order, `@vision`, `@default`, the active model string from the session — each must resolve to a model advertising image input — then the first image-capable model sharing the active model's provider, then the first image-capable model overall. `expandRoleAlias(...)` and `resolveModelFromString(...)` handle each lookup. +4. If no image-capable model is found, execution fails before reading the file. +5. `parseImageAttachmentReference(...)` interprets exact `Image #N` labels (optionally bracketed), `attachment://N`, and `image://N` (case-insensitive) as 1-based references into the turn's image attachments (`session.getImageAttachments()` loaded via `loadImageAttachmentInput(...)`). A reference with no attachments or an out-of-range index raises a `ToolError` listing the available attachments. Other values are loaded as files: `loadImageInput(...)` resolves the path with `resolveReadPath(...)`, detects MIME type with `readImageMetadata(...)`, and rejects files larger than `MAX_IMAGE_INPUT_BYTES` (`20 * 1024 * 1024`, 20 MiB). Attachment bytes have the same 20 MiB cap. +6. A path ending in `:img` selects SVG loading: `splitPathAndSelPreferringLiteral(...)` splits the selector and `loadSvgImageInput(...)` rasterizes `.svg`/`.svgz` bytes to PNG (`rasterizeSvg` from `@oh-my-pi/pi-natives`, max edge 2048px) before the normal encode/resize pipeline. A `:img` selector on a non-SVG file fails with an explicit error. +7. File metadata is detected from headers. Attachment inputs use their supplied image MIME type. Supported MIME types are `image/png`, `image/jpeg`, `image/gif`, and `image/webp`. +8. The loader uses `excludeWebP: webpExclusionForModel(model)` (`true` only for models that cannot decode WebP, such as the Ollama family). It calls `resizeImage(...)` when `images.autoResize` is true, or when WebP must be re-encoded for the selected model. Resize failures are swallowed and the original bytes are kept. +9. If the file header or attachment MIME type is unsupported, `execute(...)` throws `ToolError("inspect_image only supports PNG, JPEG, GIF, and WEBP files detected by file content.")`. +10. The tool calls `instrumentedCompleteSimple(...)` with one user message containing two content parts in order: - `{ type: "image", data: imageInput.data, mimeType: imageInput.mimeType }` - `{ type: "text", text: params.question }` -10. `systemPrompt` is a one-element array rendered from `packages/coding-agent/src/prompts/tools/inspect-image-system.md`; telemetry is tagged with oneshot kind `inspect_image`. The request carries the thinking effort selected on the resolved vision/default model role. -11. The model call uses the caller signal plus `inspect_image.timeoutMs` (default 300,000 ms); `0` disables this timeout. Provider errors, aborts, and timeouts become `ToolError`s. -12. `extractTextContent(...)` from `packages/coding-agent/src/commit/utils.ts` concatenates only `text` content blocks from the assistant message, trims the result, and the tool fails if nothing remains. -13. Success returns the text plus `details`; `inspectImageToolRenderer` formats the result for the TUI. +11. `systemPrompt` is a one-element array rendered from `packages/coding-agent/src/prompts/tools/inspect-image-system.md`; telemetry is tagged with oneshot kind `inspect_image`. The request carries the thinking effort selected on the resolved vision/default model role. +12. The model call uses the caller signal plus `inspect_image.timeoutMs` (default 300,000 ms); `0` disables this timeout. Provider errors, aborts, and timeouts become `ToolError`s. +13. `extractTextContent(...)` from `packages/coding-agent/src/commit/utils.ts` concatenates only `text` content blocks from the assistant message, trims the result, and the tool fails if nothing remains. +14. Success returns the text plus `details`; `inspectImageToolRenderer` formats the result for the TUI. ## Modes / Variants - **Original image path**: `images.autoResize` disabled. The original file bytes are base64-encoded and sent with the detected MIME type. - **Auto-resized path**: `images.autoResize` enabled. `resizeImage(...)` may downscale and re-encode the image before upload. +- **SVG path**: `.svg:img` / `.svgz:img` rasterizes the vector source to PNG before upload; the 20 MiB cap applies to the source file. - **Unsupported image path**: file exists but header sniffing does not identify PNG/JPEG/GIF/WEBP. The tool returns a `ToolError` before any model call. - **Oversize image path**: file size exceeds 20 MiB before upload. The tool returns a `ToolError` before any model call. - **Attachment path**: resolve a current-turn pasted/uploaded image by its `Image #N` label or attachment URI without reading a filesystem path. ## Side Effects - Filesystem - - For file inputs, resolves and reads the target image from disk. + - For file inputs, resolves and reads the target image from disk: stats the file once with `Bun.file(...).stat()` and reads it fully with `fs.readFile(...)`. + - SVG inputs are additionally rasterized to PNG in memory. - Attachment inputs are loaded from the current turn's in-memory image attachment list. - Network - Sends the final base64 image payload plus question text to the selected model through `instrumentedCompleteSimple(...)` / the configured simple completion implementation. @@ -78,6 +82,7 @@ TUI rendering adds presentation-only truncation from `packages/coding-agent/src/ - Metadata sniff cap: `DEFAULT_IMAGE_METADATA_HEADER_BYTES = 256 * 1024` bytes. Format detection only reads up to 256 KiB from the file header. - Availability is gated by `inspect_image.mode` (`auto`|`on`|`off`, default `auto`) in `packages/coding-agent/src/config/settings-schema.ts`, resolved with the session-scoped `/vision` override and the active model's image capability in `packages/coding-agent/src/utils/inspect-image-mode.ts` / `packages/coding-agent/src/tools/index.ts`. `auto` registers the tool only when the active model lacks native image input; the legacy `inspect_image.enabled` boolean migrates to `mode` (`true`→`on`, `false`→`off`). - Upload input cap: `MAX_IMAGE_INPUT_BYTES = 20 * 1024 * 1024` bytes (20 MiB) in `packages/coding-agent/src/utils/image-loading.ts`. +- SVG rasterization cap: `SVG_IMAGE_MAX_EDGE_PX = 2048` (max width/height of the rasterized PNG) in `packages/coding-agent/src/utils/image-loading.ts`. - Vision request timeout: `inspect_image.timeoutMs` defaults to `300_000` ms (5 minutes); set it to `0` to disable. - Auto-resize defaults in `packages/coding-agent/src/utils/image-resize.ts`: - `maxWidth: 1568` @@ -106,8 +111,10 @@ TUI rendering adds presentation-only truncation from `packages/coding-agent/src/ - Input file: - `Image file too large: exceeds limit.` from `ImageInputTooLargeError`, remapped to `ToolError`. - `inspect_image only supports PNG, JPEG, GIF, and WEBP files detected by file content.` when header sniffing fails. - - `No image attachments are available in this turn...` when a reference is used without current-turn image attachments. - - `Could not resolve image attachment ... Available image attachments: ...` when the 1-based reference is out of range. + - `inspect_image ':img' only supports .svg and .svgz files.` when the `:img` selector targets a non-SVG file. + - `Could not rasterize SVG: ` when SVG rasterization fails. + - `No image attachments are available in this turn. path="" must be a readable file path or attachment URI.` when an attachment reference is used but the turn has no image attachments. + - `Could not resolve image attachment ''. Available image attachments: