diff --git a/AGENTS.md b/AGENTS.md index ccf430e..597a415 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -18,6 +18,17 @@ - Do not reintroduce `@vercel/ncc` for routine builds; the current dependency set relies on package exports that ncc has previously failed to bundle correctly. - Keep the esbuild target aligned with the action runtime in `action.yml`. +## Wait Deadlines + +- Create the shared `continue-after-seconds` or `abort-after-seconds` deadline in `main.ts` after parsing inputs and before the first Actions API read. +- Treat the limit as a monotonic total-elapsed-time deadline across repository workflow lookup, workflow-run discovery, job and step reads, and sleeps. +- Start the separate `initial-wait-seconds` window when workflow-run discovery begins; do not let repository workflow lookup consume it, and keep its sleep bounded by the shared action deadline. +- Propagate the shared deadline signal and monotonic checkpoint through every potentially blocking Actions API read, including each pagination page and retry attempt. +- Keep GitHub API retry backoffs on the shared abortable, chunk-safe scheduler so a deadline does not leave an Octokit retry timer running. +- On an ordinary terminal failure, cancel the shared signal before reporting the original error; keep cancellation separate from deadline expiration and timer disposal. +- Schedule long deadlines and sleeps in bounded timer chunks; never pass a delay above Node's timer maximum directly to `setTimeout`. +- Use fake timers for deadline regression tests; do not add real sleeps. + ## Docs - Keep README inputs and outputs aligned with `action.yml` and the source input parsing. diff --git a/CHANGELOG.md b/CHANGELOG.md index a40cd06..5defb7a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ ## Unreleased +### Bug fixes 🐛 + +- Enforce `continue-after-seconds` and `abort-after-seconds` as total elapsed-time deadlines starting before the first Actions API read and covering workflow discovery, job and step reads, initial waiting, and polling. +- Keep the `initial-wait-seconds` discovery window anchored to workflow-run discovery so repository workflow lookup does not consume its retry opportunity, while still bounding it by the action deadline. +- Safely chunk long timer delays and check the monotonic boundary before follow-up discovery reads, pagination pages, and retries so timer overflow or delayed callbacks cannot shorten or extend the configured deadline. +- Cancel queued GitHub API retry backoffs when the shared deadline expires or an ordinary terminal API failure ends the action, instead of allowing their timers to keep the step running. +- Keep configured 5xx retries independent from the one primary-rate-limit retry, and avoid retrying primary limits with missing or malformed reset headers. + ## 3.3.2 ### Bug fixes 🐛 diff --git a/README.md b/README.md index 6c84033..13990d0 100644 --- a/README.md +++ b/README.md @@ -51,6 +51,12 @@ jobs: To avoid waiting prolonged periods of time, you may wish to bail on a run or continuing a workflow run regardless of the status of the previous run. +The `continue-after-seconds` and `abort-after-seconds` limits measure total +elapsed waiting time. The deadline starts after inputs are parsed and before +the first Actions API read, then covers workflow and run discovery, job and +step inspection, configured API retry backoffs, the initial wait, and polling +sleeps. A deadline cancels a queued retry wait through the same request signal. + You can bail from a run using the built-in GitHub Actions [`jobs..timeout-minutes`](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions#jobsjob_idtimeout-minutes) setting ```diff @@ -259,12 +265,12 @@ jobs: | Name | Type | Description | | ------------------------ | ------- | ------------------------------------------------------------------------------------------------------------------------------------------- | | `token` | string | GitHub access token used for Actions API reads (defaults to `github.token`) | -| `continue-after-seconds` | number | Maximum number of seconds to wait before moving forward (unbound by default). Mutually exclusive with abort-after-seconds | -| `abort-after-seconds` | number | Maximum number of seconds to wait before aborting the job (unbound by default). Mutually exclusive with continue-after-seconds | +| `continue-after-seconds` | number | Maximum elapsed seconds from before the first Actions API read, including later API reads and sleeps, before moving forward (unbound by default). Mutually exclusive with abort-after-seconds | +| `abort-after-seconds` | number | Maximum elapsed seconds from before the first Actions API read, including later API reads and sleeps, before aborting the job (unbound by default). Mutually exclusive with continue-after-seconds | | `poll-interval-seconds` | number | Number of seconds to wait in between checks for previous run completion (defaults to 60) | | `same-branch-only` | boolean | Only wait on other runs from the same branch (defaults to true) | | `branch` | string | Branch name to use for same-branch filtering (defaults to the current branch) | -| `initial-wait-seconds` | number | Total elapsed seconds within which period the action will refresh the list of current runs, if no runs were found in the first attempt | +| `initial-wait-seconds` | number | Seconds from the start of workflow-run discovery within which the action refreshes current runs when none are found initially; bounded by any continue or abort deadline | | `job-to-wait-for` | string | Name of the workflow's job to wait for (unbound by default). | | `step-to-wait-for` | string | Name of the step to wait for (unbound by default). Requires job-to-wait-for to be set. | | `queue-name` | string | Custom substring used to group matching runs across workflows (defaults to the current workflow only). | diff --git a/__tests__/deadline.test.ts b/__tests__/deadline.test.ts new file mode 100644 index 0000000..fbf0689 --- /dev/null +++ b/__tests__/deadline.test.ts @@ -0,0 +1,218 @@ +import { afterEach, describe, expect, it, vi } from 'vitest'; + +import { + ActionDeadline, + DeadlineReached, + MAX_TIMER_DELAY_MILLISECONDS, + type DeadlineTiming, +} from '../src/deadline'; + +interface ScheduledTimer { + callback: () => void; + milliseconds: number; +} + +const manualTiming = () => { + let now = 0; + let nextTimer = 1; + const timers = new Map(); + const scheduledDelays: number[] = []; + const clearedTimers: number[] = []; + const timing: DeadlineTiming = { + now: () => now, + setTimeout: (callback, milliseconds) => { + const timer = nextTimer++; + timers.set(timer, { callback, milliseconds }); + scheduledDelays.push(milliseconds); + return timer as unknown as ReturnType; + }, + clearTimeout: (timer) => { + const timerId = timer as unknown as number; + timers.delete(timerId); + clearedTimers.push(timerId); + }, + }; + + return { + timing, + advanceTo: (milliseconds: number) => { + now = milliseconds; + }, + deliverNextTimer: () => { + const entry = timers.entries().next().value as [number, ScheduledTimer] | undefined; + if (!entry) { + throw new Error('No timer is scheduled'); + } + const [timer, scheduled] = entry; + timers.delete(timer); + scheduled.callback(); + return scheduled.milliseconds; + }, + scheduledDelays, + clearedTimers, + timerCount: () => timers.size, + }; +}; + +const deferred = () => { + let resolve!: (value: T) => void; + let reject!: (error: unknown) => void; + const promise = new Promise((resolvePromise, rejectPromise) => { + resolve = resolvePromise; + reject = rejectPromise; + }); + return { promise, reject, resolve }; +}; + +describe('ActionDeadline', () => { + afterEach(() => { + vi.restoreAllMocks(); + }); + + it.each(['continue', 'abort'] as const)( + 'chunks a long %s deadline without expiring before monotonic time reaches it', + async (mode) => { + const fake = manualTiming(); + const seconds = 2_147_484; + const deadline = new ActionDeadline({ mode, seconds }, fake.timing); + + expect(deadline.signal?.aborted).toBe(false); + expect(fake.scheduledDelays).toEqual([MAX_TIMER_DELAY_MILLISECONDS]); + + fake.advanceTo(MAX_TIMER_DELAY_MILLISECONDS); + expect(fake.deliverNextTimer()).toBe(MAX_TIMER_DELAY_MILLISECONDS); + + expect(deadline.signal?.aborted).toBe(false); + expect(fake.scheduledDelays).toEqual([MAX_TIMER_DELAY_MILLISECONDS, 353]); + + fake.advanceTo(seconds * 1000); + fake.deliverNextTimer(); + + expect(deadline.signal?.aborted).toBe(true); + await expect(deadline.race(async () => 'too late')).rejects.toEqual( + new DeadlineReached(mode, seconds), + ); + expect(fake.scheduledDelays.every((delay) => delay <= MAX_TIMER_DELAY_MILLISECONDS)).toBe( + true, + ); + }, + ); + + it('clears the currently armed timer during cleanup after a chunk re-arms', () => { + const fake = manualTiming(); + const deadline = new ActionDeadline({ mode: 'abort', seconds: 2_147_484 }, fake.timing); + + fake.advanceTo(MAX_TIMER_DELAY_MILLISECONDS); + fake.deliverNextTimer(); + expect(fake.timerCount()).toBe(1); + + deadline.dispose(); + + expect(fake.timerCount()).toBe(0); + expect(fake.clearedTimers).toHaveLength(1); + }); + + it('chunks a long polling sleep without scheduling a timer beyond the Node limit', async () => { + const fake = manualTiming(); + const seconds = 2_147_484; + const deadline = new ActionDeadline(undefined, fake.timing); + const sleep = deadline.sleepSeconds(seconds); + + expect(fake.scheduledDelays).toEqual([MAX_TIMER_DELAY_MILLISECONDS]); + + fake.advanceTo(MAX_TIMER_DELAY_MILLISECONDS); + fake.deliverNextTimer(); + for (let microtask = 0; microtask < 8; microtask += 1) { + await Promise.resolve(); + } + + expect(fake.scheduledDelays).toEqual([MAX_TIMER_DELAY_MILLISECONDS, 353]); + + fake.advanceTo(seconds * 1000); + fake.deliverNextTimer(); + + await expect(sleep).resolves.toBeUndefined(); + expect(fake.scheduledDelays.every((delay) => delay <= MAX_TIMER_DELAY_MILLISECONDS)).toBe(true); + }); + + it('re-checks monotonic time when an operation resolves before the timer callback is delivered', async () => { + const fake = manualTiming(); + const operation = deferred(); + const deadline = new ActionDeadline({ mode: 'abort', seconds: 1 }, fake.timing); + const result = deadline.race(() => operation.promise); + + fake.advanceTo(1_001); + operation.resolve('late value'); + + await expect(result).rejects.toEqual(new DeadlineReached('abort', 1)); + expect(deadline.signal?.aborted).toBe(true); + }); + + it('re-checks monotonic time when an operation rejects before the timer callback is delivered', async () => { + const fake = manualTiming(); + const operation = deferred(); + const deadline = new ActionDeadline({ mode: 'continue', seconds: 1 }, fake.timing); + const result = deadline.race(() => operation.promise); + + fake.advanceTo(1_001); + operation.reject(new Error('late API failure')); + + await expect(result).rejects.toEqual(new DeadlineReached('continue', 1)); + expect(deadline.signal?.aborted).toBe(true); + }); + + it('allows an operation that resolves immediately before the deadline', async () => { + const fake = manualTiming(); + const operation = deferred(); + const deadline = new ActionDeadline({ mode: 'continue', seconds: 1 }, fake.timing); + const result = deadline.race(() => operation.promise); + + fake.advanceTo(999); + operation.resolve('on time'); + + await expect(result).resolves.toBe('on time'); + expect(deadline.signal?.aborted).toBe(false); + }); + + it('treats the exact monotonic boundary as expired', async () => { + const fake = manualTiming(); + const deadline = new ActionDeadline({ mode: 'continue', seconds: 1 }, fake.timing); + + fake.advanceTo(1_000); + + await expect(deadline.race(async () => 'boundary value')).rejects.toEqual( + new DeadlineReached('continue', 1), + ); + expect(deadline.signal?.aborted).toBe(true); + }); + + it('cancels pending work idempotently without marking the configured deadline as reached', () => { + const fake = manualTiming(); + const deadline = new ActionDeadline({ mode: 'abort', seconds: 10 }, fake.timing); + const reason = new Error('terminal API failure'); + + deadline.cancel(reason); + deadline.cancel(new Error('later cancellation')); + + expect(deadline.signal?.aborted).toBe(true); + expect(deadline.signal?.reason).toBe(reason); + expect(() => deadline.throwIfReached()).not.toThrow(); + expect(fake.timerCount()).toBe(1); + + deadline.dispose(); + expect(fake.timerCount()).toBe(0); + }); + + it('preserves the configured deadline outcome when cancellation follows expiration', async () => { + const fake = manualTiming(); + const deadline = new ActionDeadline({ mode: 'continue', seconds: 1 }, fake.timing); + + fake.advanceTo(1_000); + fake.deliverNextTimer(); + deadline.cancel(new Error('terminal API failure')); + + await expect(deadline.race(async () => 'too late')).rejects.toEqual( + new DeadlineReached('continue', 1), + ); + }); +}); diff --git a/__tests__/github.test.ts b/__tests__/github.test.ts index a590c9e..7087d75 100644 --- a/__tests__/github.test.ts +++ b/__tests__/github.test.ts @@ -1,7 +1,13 @@ import { warning } from '@actions/core'; import { afterEach, describe, expect, it, vi } from 'vitest'; -import { createThrottleOptions, OctokitGitHub, type WorkflowRun } from '../src/github'; +import { ActionDeadline, DeadlineReached, type DeadlineTiming } from '../src/deadline'; +import { + createThrottleOptions, + OctokitGitHub, + type GitHubRequestOptions, + type WorkflowRun, +} from '../src/github'; vi.mock('@actions/core', () => ({ debug: vi.fn(), @@ -33,11 +39,76 @@ const replaceOctokit = (client: OctokitGitHub, octokit: TestOctokit) => { (client as unknown as { octokit: TestOctokit }).octokit = octokit; }; +const mockRequestMethod = () => { + const bound = vi.fn(); + const defaults = vi.fn().mockReturnValue(bound); + const request = Object.assign(vi.fn(), { defaults }); + return { request, bound, defaults }; +}; + const CLIENT_ERROR_STATUSES = Array.from({ length: 100 }, (_, index) => 400 + index); const ACTIVE_RUN_STATUSES = ['in_progress', 'queued', 'waiting']; +const advanceUntilCalled = async (mock: ReturnType) => { + for (let attempt = 0; attempt < 10 && mock.mock.calls.length === 0; attempt += 1) { + await vi.advanceTimersToNextTimerAsync(); + } +}; + +const advanceUntilCallCount = async (mock: ReturnType, count: number) => { + for (let attempt = 0; attempt < 20 && mock.mock.calls.length < count; attempt += 1) { + await vi.advanceTimersToNextTimerAsync(); + } +}; + +const flushUntilTimerScheduled = async () => { + for (let attempt = 0; attempt < 50 && vi.getTimerCount() === 0; attempt += 1) { + await Promise.resolve(); + } +}; + +const flushMicrotasks = async () => { + for (let attempt = 0; attempt < 50; attempt += 1) { + await Promise.resolve(); + } +}; + +const flushShortDelayWorkUntilCalled = async (mock: ReturnType) => { + for (let attempt = 0; attempt < 20 && mock.mock.calls.length === 0; attempt += 1) { + await vi.advanceTimersByTimeAsync(1); + await flushMicrotasks(); + } +}; + +const manualTiming = () => { + let now = 0; + let nextTimer = 1; + const timers = new Map void>(); + const timing: DeadlineTiming = { + now: () => now, + setTimeout: (callback) => { + const timer = nextTimer++; + timers.set(timer, callback); + return timer as unknown as ReturnType; + }, + clearTimeout: (timer) => { + timers.delete(timer as unknown as number); + }, + }; + + return { + timing, + advanceTo: (milliseconds: number) => { + now = milliseconds; + }, + timerCount: () => timers.size, + }; +}; + const clientWithRunPages = (...pagesByCall: WorkflowRunPages[]) => { const client = new OctokitGitHub('fake-token'); + const listWorkflowRuns = mockRequestMethod(); + const listWorkflowRunsForRepo = mockRequestMethod(); let paginateCalls = 0; let pagesScanned = 0; const paginate = vi.fn( @@ -64,13 +135,19 @@ const clientWithRunPages = (...pagesByCall: WorkflowRunPages[]) => { replaceOctokit(client, { actions: { - listWorkflowRuns: vi.fn(), - listWorkflowRunsForRepo: vi.fn(), + listWorkflowRuns: listWorkflowRuns.request, + listWorkflowRunsForRepo: listWorkflowRunsForRepo.request, }, paginate, }); - return { client, paginate, pagesScanned: () => pagesScanned }; + return { + client, + listWorkflowRuns, + listWorkflowRunsForRepo, + paginate, + pagesScanned: () => pagesScanned, + }; }; const clientWithDynamicRunPages = ( @@ -112,6 +189,8 @@ const clientWithDynamicRunPages = ( describe('github', () => { afterEach(() => { + vi.useRealTimers(); + vi.unstubAllEnvs(); vi.restoreAllMocks(); vi.clearAllMocks(); }); @@ -136,20 +215,419 @@ describe('github', () => { expect(fetchMock).toHaveBeenCalledTimes(1); } }); + + it('cancels a pending 5xx retry backoff when its request signal is aborted', async () => { + vi.useFakeTimers(); + const fetchMock = vi.spyOn(globalThis, 'fetch').mockImplementation(async (_url, options) => { + options?.signal?.throwIfAborted(); + return new Response(JSON.stringify({ message: 'server error' }), { + status: 500, + headers: { 'content-type': 'application/json' }, + }); + }); + const controller = new AbortController(); + const client = new OctokitGitHub('fake-token', 2); + const request = client.run('org', 'repo', 42, { signal: controller.signal }); + const settled = vi.fn(); + void request.then(settled, settled); + + await advanceUntilCalled(fetchMock); + await flushUntilTimerScheduled(); + await flushMicrotasks(); + expect(fetchMock).toHaveBeenCalledOnce(); + expect(vi.getTimerCount()).toBeGreaterThan(0); + expect(settled).not.toHaveBeenCalled(); + + controller.abort(); + await flushShortDelayWorkUntilCalled(settled); + + expect(settled).toHaveBeenCalledOnce(); + await request.catch(() => undefined); + await vi.advanceTimersByTimeAsync(1_000); + expect(fetchMock).toHaveBeenCalledOnce(); + }); + + it('cancels a pending primary-rate-limit backoff when its request signal is aborted', async () => { + vi.useFakeTimers(); + vi.setSystemTime(new Date('2026-07-15T12:00:00Z')); + const resetAtSeconds = Math.floor(Date.now() / 1000) + 600; + const fetchMock = vi.spyOn(globalThis, 'fetch').mockImplementation(async (_url, options) => { + options?.signal?.throwIfAborted(); + return new Response(JSON.stringify({ message: 'API rate limit exceeded' }), { + status: 403, + headers: { + 'content-type': 'application/json', + 'x-ratelimit-remaining': '0', + 'x-ratelimit-reset': String(resetAtSeconds), + }, + }); + }); + const controller = new AbortController(); + const client = new OctokitGitHub('fake-token'); + const request = client.run('org', 'repo', 42, { signal: controller.signal }); + const settled = vi.fn(); + void request.then(settled, settled); + + await advanceUntilCalled(fetchMock); + await flushUntilTimerScheduled(); + await flushMicrotasks(); + expect(fetchMock).toHaveBeenCalledOnce(); + expect(vi.getTimerCount()).toBeGreaterThan(0); + expect(settled).not.toHaveBeenCalled(); + + controller.abort(); + await flushShortDelayWorkUntilCalled(settled); + + expect(settled).toHaveBeenCalledOnce(); + await request.catch(() => undefined); + await vi.advanceTimersByTimeAsync(600_000); + expect(fetchMock).toHaveBeenCalledOnce(); + }); + + it('cancels a paginated retry backoff when its request signal is aborted', async () => { + vi.useFakeTimers(); + const controller = new AbortController(); + const fetchMock = vi.spyOn(globalThis, 'fetch').mockImplementation(async (_url, options) => { + if (controller.signal.aborted) { + return new Response(JSON.stringify({ message: 'cleanup' }), { + status: 401, + headers: { 'content-type': 'application/json' }, + }); + } + return new Response(JSON.stringify({ message: 'server error' }), { + status: 500, + headers: { 'content-type': 'application/json' }, + }); + }); + const request = new OctokitGitHub('fake-token', 2).workflows('org', 'repo', { + signal: controller.signal, + }); + const settled = vi.fn(); + void request.then(settled, settled); + + try { + await advanceUntilCalled(fetchMock); + await flushUntilTimerScheduled(); + await flushMicrotasks(); + expect(fetchMock).toHaveBeenCalledOnce(); + expect(fetchMock.mock.calls[0]?.[1]?.signal).toBe(controller.signal); + expect(vi.getTimerCount()).toBeGreaterThan(0); + + controller.abort(); + await flushShortDelayWorkUntilCalled(settled); + + expect(settled).toHaveBeenCalledOnce(); + await request.catch(() => undefined); + expect(vi.getTimerCount()).toBe(0); + + await vi.advanceTimersByTimeAsync(1_000); + expect(fetchMock).toHaveBeenCalledOnce(); + } finally { + controller.abort(); + await advanceUntilCalled(settled); + await request.catch(() => undefined); + } + }); + + it('logs only the one primary-rate-limit retry that is actually scheduled', async () => { + vi.useFakeTimers(); + vi.setSystemTime(new Date('2026-07-15T12:00:00Z')); + const resetAtSeconds = Math.floor(Date.now() / 1000) - 1; + const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue( + new Response(JSON.stringify({ message: 'API rate limit exceeded' }), { + status: 403, + headers: { + 'content-type': 'application/json', + 'x-ratelimit-remaining': '0', + 'x-ratelimit-reset': String(resetAtSeconds), + }, + }), + ); + const request = new OctokitGitHub('fake-token').run('org', 'repo', 42); + const rejection = expect(request).rejects.toMatchObject({ status: 403 }); + const settled = vi.fn(); + void request.then(settled, settled); + + await advanceUntilCalled(fetchMock); + await advanceUntilCallCount(fetchMock, 2); + await flushShortDelayWorkUntilCalled(settled); + await rejection; + + expect(fetchMock).toHaveBeenCalledTimes(2); + const messages = vi + .mocked(warning) + .mock.calls.map(([message]) => (typeof message === 'string' ? message : message.message)); + expect( + messages.filter((message) => message.startsWith('Request quota exhausted for request')), + ).toHaveLength(2); + expect(messages.filter((message) => message.startsWith('Retrying after'))).toEqual([ + 'Retrying after 0 seconds!', + ]); + }); + + it('does not reinterpret a secondary limit as a primary limit', async () => { + vi.useFakeTimers(); + vi.setSystemTime(new Date('2026-07-15T12:00:00Z')); + const resetAtSeconds = Math.floor(Date.now() / 1000) + 600; + const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue( + new Response(JSON.stringify({ message: 'You have exceeded a secondary rate limit' }), { + status: 403, + headers: { + 'content-type': 'application/json', + 'retry-after': '60', + 'x-ratelimit-remaining': '0', + 'x-ratelimit-reset': String(resetAtSeconds), + }, + }), + ); + const controller = new AbortController(); + const request = new OctokitGitHub('fake-token').run('org', 'repo', 42, { + signal: controller.signal, + }); + const rejection = request.then( + () => undefined, + (error: unknown) => error, + ); + const settled = vi.fn(); + void request.then(settled, settled); + + try { + await advanceUntilCalled(fetchMock); + await flushShortDelayWorkUntilCalled(settled); + + expect(settled).toHaveBeenCalledOnce(); + await expect(rejection).resolves.toMatchObject({ + message: 'You have exceeded a secondary rate limit', + status: 403, + }); + expect(fetchMock).toHaveBeenCalledOnce(); + const messages = vi + .mocked(warning) + .mock.calls.map(([message]) => (typeof message === 'string' ? message : message.message)); + expect( + messages.filter((message) => + message.startsWith('Secondary rate limit detected for request'), + ), + ).toHaveLength(1); + expect(messages.filter((message) => message.startsWith('Retrying after'))).toEqual([]); + + await vi.advanceTimersByTimeAsync(600_000); + expect(fetchMock).toHaveBeenCalledOnce(); + expect(vi.getTimerCount()).toBe(0); + } finally { + controller.abort(); + await request.catch(() => undefined); + } + }); }); describe('API wrappers', () => { - it('paginates workflows with repository coordinates', async () => { - const listRepoWorkflows = vi.fn(); - const paginate = vi.fn().mockResolvedValue([{ id: 123, name: 'CI' }]); + it.each([ + [ + 'workflow', + (client: OctokitGitHub, options: GitHubRequestOptions) => + client.workflows('org', 'repo', options), + 1, + ], + [ + 'workflow-run', + (client: OctokitGitHub, options: GitHubRequestOptions) => + client.runs('org', 'repo', 123, {}, options), + ACTIVE_RUN_STATUSES.length, + ], + [ + 'job', + (client: OctokitGitHub, options: GitHubRequestOptions) => + client.jobs('org', 'repo', 42, options), + 1, + ], + ] as const)( + 'aborts pending %s pagination fetches', + async (_description, startRequest, expectedFetches) => { + vi.useFakeTimers(); + const pendingRejects: Array<(reason?: unknown) => void> = []; + const observedSignals: Array = []; + const fetchMock = vi.spyOn(globalThis, 'fetch').mockImplementation( + async (_url, options) => + new Promise((_resolve, reject) => { + const signal = options?.signal; + observedSignals.push(signal); + pendingRejects.push(reject); + signal?.addEventListener('abort', () => reject(signal.reason), { once: true }); + }), + ); + const controller = new AbortController(); + const request = startRequest(new OctokitGitHub('fake-token'), { + signal: controller.signal, + }); + const settled = vi.fn(); + void request.then(settled, settled); + + await advanceUntilCallCount(fetchMock, expectedFetches); + expect(fetchMock).toHaveBeenCalledTimes(expectedFetches); + + controller.abort(); + try { + await flushShortDelayWorkUntilCalled(settled); + + expect(observedSignals).toHaveLength(expectedFetches); + expect( + observedSignals.every((signal) => signal === controller.signal && signal.aborted), + ).toBe(true); + expect(settled).toHaveBeenCalledOnce(); + await request.catch(() => undefined); + expect(vi.getTimerCount()).toBe(0); + } finally { + for (const reject of pendingRejects) { + reject(new Error('test cleanup')); + } + await advanceUntilCalled(settled); + await request.catch(() => undefined); + } + }, + ); + + it('keeps the abort signal bound on subsequent pagination pages', async () => { + vi.useFakeTimers(); + let rejectSecondPage: ((reason?: unknown) => void) | undefined; + const fetchMock = vi + .spyOn(globalThis, 'fetch') + .mockResolvedValueOnce( + new Response(JSON.stringify({ total_count: 2, workflows: [{ id: 1, name: 'First' }] }), { + status: 200, + headers: { + 'content-type': 'application/json', + link: '; rel="next"', + }, + }), + ) + .mockImplementationOnce( + async (_url, options) => + new Promise((_resolve, reject) => { + rejectSecondPage = reject; + options?.signal?.addEventListener('abort', () => reject(options.signal?.reason), { + once: true, + }); + }), + ); + const controller = new AbortController(); + const request = new OctokitGitHub('fake-token').workflows('org', 'repo', { + signal: controller.signal, + }); + const settled = vi.fn(); + void request.then(settled, settled); + + await advanceUntilCallCount(fetchMock, 2); + expect(fetchMock).toHaveBeenCalledTimes(2); + expect( + fetchMock.mock.calls.every(([, options]) => options?.signal === controller.signal), + ).toBe(true); + + controller.abort(); + try { + await flushShortDelayWorkUntilCalled(settled); + + expect(settled).toHaveBeenCalledOnce(); + await request.catch(() => undefined); + expect(vi.getTimerCount()).toBe(0); + } finally { + rejectSecondPage?.(new Error('test cleanup')); + await advanceUntilCalled(settled); + await request.catch(() => undefined); + } + }); + + it('does not start another pagination page after the monotonic deadline', async () => { + const fake = manualTiming(); + const deadline = new ActionDeadline({ mode: 'abort', seconds: 1 }, fake.timing); + const fetchMock = vi + .spyOn(globalThis, 'fetch') + .mockImplementationOnce(async () => { + fake.advanceTo(1_000); + return new Response( + JSON.stringify({ total_count: 2, workflows: [{ id: 1, name: 'First' }] }), + { + status: 200, + headers: { + 'content-type': 'application/json', + link: '; rel="next"', + }, + }, + ); + }) + .mockResolvedValueOnce( + new Response(JSON.stringify({ total_count: 2, workflows: [{ id: 2, name: 'Second' }] }), { + status: 200, + headers: { 'content-type': 'application/json' }, + }), + ); + const requestOptions = { + signal: deadline.signal, + checkDeadline: deadline.throwIfReached, + } as GitHubRequestOptions; + const request = new OctokitGitHub('fake-token').workflows('org', 'repo', requestOptions); + + try { + await expect(request).rejects.toEqual(new DeadlineReached('abort', 1)); + expect(fetchMock).toHaveBeenCalledOnce(); + expect(deadline.signal.aborted).toBe(true); + } finally { + deadline.dispose(); + await request.catch(() => undefined); + } + + expect(fake.timerCount()).toBe(0); + }); + + it.each([ + ['the default GitHub API', undefined, 'https://api.github.com'], + [ + 'a configured GitHub Enterprise API', + 'https://github.example/api/v3', + 'https://github.example/api/v3', + ], + ] as const)('uses %s base URL', async (_description, configuredUrl, expectedUrl) => { + vi.stubEnv('GITHUB_API_URL', configuredUrl); + const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue( + new Response(JSON.stringify({ id: 42 }), { + status: 200, + headers: { 'content-type': 'application/json' }, + }), + ); + + await new OctokitGitHub('fake-token').run('org', 'repo', 42); + + const request = fetchMock.mock.calls[0]?.[0]; + expect(request).toBeDefined(); + expect(request instanceof Request ? request.url : String(request)).toBe( + `${expectedUrl}/repos/org/repo/actions/runs/42`, + ); + }); + + it('paginates workflows with repository coordinates and forwards an abort signal', async () => { + const listRepoWorkflows = mockRequestMethod(); + const paginate = vi + .fn() + .mockResolvedValueOnce([{ id: 123, name: 'CI' }]) + .mockResolvedValueOnce([{ id: 456, name: 'Deploy' }]); const client = new OctokitGitHub('fake-token'); replaceOctokit(client, { - actions: { listRepoWorkflows }, + actions: { listRepoWorkflows: listRepoWorkflows.request }, paginate, }); await expect(client.workflows('org', 'repo')).resolves.toEqual([{ id: 123, name: 'CI' }]); - expect(paginate).toHaveBeenCalledWith(listRepoWorkflows, { + const signal = new AbortController().signal; + await expect(client.workflows('org', 'repo', { signal })).resolves.toEqual([ + { id: 456, name: 'Deploy' }, + ]); + expect(paginate).toHaveBeenNthCalledWith(1, listRepoWorkflows.request, { + owner: 'org', + repo: 'repo', + per_page: 100, + }); + expect(listRepoWorkflows.defaults).toHaveBeenCalledWith({ request: { signal } }); + expect(paginate).toHaveBeenNthCalledWith(2, listRepoWorkflows.bound, { owner: 'org', repo: 'repo', per_page: 100, @@ -210,6 +688,35 @@ describe('github', () => { job_id: 8, }); }); + + it('forwards abort signals for job and step reads', async () => { + const listJobsForWorkflowRun = mockRequestMethod(); + const getJobForWorkflowRun = vi.fn().mockResolvedValue({ data: { steps: [] } }); + const paginate = vi.fn().mockResolvedValue([]); + const client = new OctokitGitHub('fake-token'); + replaceOctokit(client, { + actions: { listJobsForWorkflowRun: listJobsForWorkflowRun.request, getJobForWorkflowRun }, + paginate, + }); + const signal = new AbortController().signal; + + await client.jobs('org', 'repo', 42, { signal }); + await client.steps('org', 'repo', 7, { signal }); + + expect(listJobsForWorkflowRun.defaults).toHaveBeenCalledWith({ request: { signal } }); + expect(paginate).toHaveBeenCalledWith(listJobsForWorkflowRun.bound, { + owner: 'org', + repo: 'repo', + run_id: 42, + per_page: 100, + }); + expect(getJobForWorkflowRun).toHaveBeenCalledWith({ + owner: 'org', + repo: 'repo', + job_id: 7, + request: { signal }, + }); + }); }); describe('runs', () => { @@ -234,7 +741,17 @@ describe('github', () => { conclusion: 'success', display_title: 'deploy-api', }); - const { client } = clientWithRunPages([], [[matchingRun, completedRun]], []); + const missingStatusRun = run({ + id: 3, + status: null, + conclusion: null, + display_title: 'deploy-api', + }); + const { client } = clientWithRunPages( + [], + [[matchingRun, completedRun, missingStatusRun]], + [], + ); await expect(client.runs('org', 'repo', 123, { queueName: 'deploy-api' })).resolves.toEqual([ matchingRun, @@ -419,6 +936,38 @@ describe('github', () => { expect(paginate.mock.calls.every(([, options]) => !('workflow_id' in options))).toBe(true); expect(paginate.mock.calls.map(([, options]) => options.status)).toEqual(ACTIVE_RUN_STATUSES); }); + + it('forwards abort signals through workflow and repository run pagination', async () => { + const signal = new AbortController().signal; + const { client, listWorkflowRuns, listWorkflowRunsForRepo, paginate } = clientWithRunPages( + [], + [], + [], + [], + [], + [], + ); + + await client.runs('org', 'repo', 123, {}, { signal }); + await client.activeRunsForRepo('org', 'repo', {}, { signal }); + + expect(paginate).toHaveBeenCalledTimes(ACTIVE_RUN_STATUSES.length * 2); + expect(listWorkflowRuns.defaults).toHaveBeenCalledTimes(ACTIVE_RUN_STATUSES.length); + expect(listWorkflowRunsForRepo.defaults).toHaveBeenCalledTimes(ACTIVE_RUN_STATUSES.length); + expect(listWorkflowRuns.defaults).toHaveBeenCalledWith({ request: { signal } }); + expect(listWorkflowRunsForRepo.defaults).toHaveBeenCalledWith({ request: { signal } }); + expect(paginate.mock.calls.every(([, options]) => !('request' in options))).toBe(true); + expect( + paginate.mock.calls + .slice(0, ACTIVE_RUN_STATUSES.length) + .every(([request]) => request === listWorkflowRuns.bound), + ).toBe(true); + expect( + paginate.mock.calls + .slice(ACTIVE_RUN_STATUSES.length) + .every(([request]) => request === listWorkflowRunsForRepo.bound), + ).toBe(true); + }); }); describe('rate-limit logging', () => { @@ -446,5 +995,15 @@ describe('github', () => { expect(warning).toHaveBeenCalledWith('Request quota exhausted for request GET /rate-limited'); expect(warning).not.toHaveBeenCalledWith('Retrying after 30 seconds!'); }); + + it('can defer primary retry scheduling to the abortable request hook', () => { + const throttleOptions = createThrottleOptions(false); + + expect( + throttleOptions.onRateLimit(30, { method: 'GET', url: '/rate-limited' }, {}, 0), + ).toBeUndefined(); + expect(warning).toHaveBeenCalledWith('Request quota exhausted for request GET /rate-limited'); + expect(warning).not.toHaveBeenCalledWith('Retrying after 30 seconds!'); + }); }); }); diff --git a/__tests__/main.test.ts b/__tests__/main.test.ts index 084cf71..73aba04 100644 --- a/__tests__/main.test.ts +++ b/__tests__/main.test.ts @@ -1,17 +1,20 @@ -import { debug, setFailed } from '@actions/core'; +import { debug, setFailed, setOutput } from '@actions/core'; import { afterEach, describe, expect, it, vi } from 'vitest'; +import { ActionDeadline } from '../src/deadline'; import { run, type ActionGitHubClient, type GitHubClientFactory, type WaiterFactory, } from '../src/main'; +import { retryRequest } from '../src/retry'; vi.mock('@actions/core', () => ({ debug: vi.fn(), info: vi.fn(), setFailed: vi.fn(), + setOutput: vi.fn(), })); const environment = ( @@ -40,6 +43,8 @@ const actionClient = (overrides: Partial = {}): ActionGitHub describe('main', () => { afterEach(() => { + vi.useRealTimers(); + vi.restoreAllMocks(); vi.clearAllMocks(); }); @@ -53,7 +58,10 @@ describe('main', () => { await run(environment(), githubFactory, waiterFactory); expect(githubFactory).toHaveBeenCalledWith('secret', 2); - expect(workflows).toHaveBeenCalledWith('softprops', 'turnstyle'); + expect(workflows).toHaveBeenCalledWith('softprops', 'turnstyle', { + checkDeadline: expect.any(Function), + signal: expect.any(AbortSignal), + }); expect(waiterFactory).toHaveBeenCalledWith( 123, github, @@ -64,12 +72,54 @@ describe('main', () => { runId: 42, retries: 2, }), + expect.any(ActionDeadline), ); expect(wait).toHaveBeenCalledOnce(); expect(setFailed).not.toHaveBeenCalled(); expect(debug).toHaveBeenCalledWith('Found 1 workflows in softprops/turnstyle'); }); + it('uses the default GitHub client factory', async () => { + const response = new Response( + JSON.stringify({ + total_count: 1, + workflows: [{ id: 123, name: 'CI', path: '.github/workflows/main.yml' }], + }), + { status: 200, headers: { 'content-type': 'application/json' } }, + ); + Object.defineProperty(response, 'url', { + value: 'https://api.github.com/repos/softprops/turnstyle/actions/workflows', + }); + const fetchMock = vi.spyOn(globalThis, 'fetch').mockResolvedValue(response); + const wait = vi.fn().mockResolvedValue(undefined); + const waiterFactory: WaiterFactory = vi.fn(() => ({ wait })); + + await run(environment(), undefined, waiterFactory); + + expect(fetchMock).toHaveBeenCalledOnce(); + expect(setFailed).not.toHaveBeenCalled(); + expect(waiterFactory).toHaveBeenCalledWith( + 123, + expect.any(Object), + expect.any(Object), + expect.any(ActionDeadline), + ); + expect(wait).toHaveBeenCalledOnce(); + }); + + it('uses the default waiter factory', async () => { + const runs = vi.fn().mockResolvedValue([]); + const github = actionClient({ + workflows: async () => [{ id: 123, name: 'CI' }], + runs, + }); + + await run(environment(), () => github); + + expect(runs).toHaveBeenCalledOnce(); + expect(setFailed).not.toHaveBeenCalled(); + }); + it('reports a missing workflow without starting a waiter', async () => { const github = actionClient({ workflows: async () => [{ id: 1, name: 'Other' }] }); const githubFactory: GitHubClientFactory = () => github; @@ -110,6 +160,112 @@ describe('main', () => { expect(setFailed).toHaveBeenCalledWith('API unavailable'); }); + it.each([ + ['abort', 'INPUT_ABORT-AFTER-SECONDS', 'Aborted after waiting 1 seconds'], + ['continue', 'INPUT_CONTINUE-AFTER-SECONDS', undefined], + ] as const)( + 'bounds a pending workflow lookup in %s mode from the start of the action', + async (mode, inputName, expectedFailure) => { + vi.useFakeTimers(); + let workflowSignal: AbortSignal | undefined; + const workflows = vi.fn( + async (_owner: string, _repo: string, options?: { signal?: AbortSignal }) => { + workflowSignal = options?.signal; + return new Promise(() => undefined); + }, + ); + const waiterFactory: WaiterFactory = vi.fn(); + const result = run( + environment({ [inputName]: '1' }), + () => actionClient({ workflows }), + waiterFactory, + ); + + await vi.advanceTimersByTimeAsync(999); + expect(setFailed).not.toHaveBeenCalled(); + await vi.advanceTimersByTimeAsync(1); + await result; + + expect(workflows).toHaveBeenCalledOnce(); + expect(workflowSignal).toBeDefined(); + expect(workflowSignal?.aborted).toBe(true); + expect(waiterFactory).not.toHaveBeenCalled(); + expect(setOutput).toHaveBeenCalledWith('force_continued', mode === 'continue' ? '1' : ''); + expect(setOutput).toHaveBeenCalledWith('previous_run_id', ''); + expect(setOutput).toHaveBeenCalledWith('previous_run_url', ''); + if (expectedFailure) { + expect(setFailed).toHaveBeenCalledWith(expectedFailure); + } else { + expect(setFailed).not.toHaveBeenCalled(); + } + expect(vi.getTimerCount()).toBe(0); + }, + ); + + it.each([ + ['abort', 'INPUT_ABORT-AFTER-SECONDS', 'Aborted after waiting 0 seconds'], + ['continue', 'INPUT_CONTINUE-AFTER-SECONDS', undefined], + ] as const)( + 'does not start workflow lookup for an already-expired zero-second %s deadline', + async (mode, inputName, expectedFailure) => { + vi.useFakeTimers(); + const githubFactory: GitHubClientFactory = vi.fn(); + const waiterFactory: WaiterFactory = vi.fn(); + + await run(environment({ [inputName]: '0' }), githubFactory, waiterFactory); + + expect(githubFactory).not.toHaveBeenCalled(); + expect(waiterFactory).not.toHaveBeenCalled(); + expect(setOutput).toHaveBeenCalledWith('force_continued', mode === 'continue' ? '1' : ''); + expect(setOutput).toHaveBeenCalledWith('previous_run_id', ''); + expect(setOutput).toHaveBeenCalledWith('previous_run_url', ''); + if (expectedFailure) { + expect(setFailed).toHaveBeenCalledWith(expectedFailure); + } else { + expect(setFailed).not.toHaveBeenCalled(); + } + expect(vi.getTimerCount()).toBe(0); + }, + ); + + it('shares workflow lookup elapsed time with the waiter deadline', async () => { + vi.useFakeTimers(); + const workflows = vi.fn( + async (_owner: string, _repo: string, options?: { signal?: AbortSignal }) => { + await new Promise((resolve) => setTimeout(resolve, 800)); + options?.signal?.throwIfAborted(); + return [{ id: 123, name: 'CI' }]; + }, + ); + const waiterStarted = vi.fn(); + const waiterFactory: WaiterFactory = vi.fn((_workflowId, _github, _input, deadline) => ({ + wait: async () => { + waiterStarted(); + await deadline.race(() => new Promise(() => undefined)); + return undefined; + }, + })); + const result = run( + environment({ 'INPUT_CONTINUE-AFTER-SECONDS': '1' }), + () => actionClient({ workflows }), + waiterFactory, + ); + + await vi.advanceTimersByTimeAsync(800); + expect(waiterStarted).toHaveBeenCalledOnce(); + expect(setOutput).not.toHaveBeenCalledWith('force_continued', '1'); + + await vi.advanceTimersByTimeAsync(199); + expect(setOutput).not.toHaveBeenCalledWith('force_continued', '1'); + + await vi.advanceTimersByTimeAsync(1); + await result; + + expect(setOutput).toHaveBeenCalledWith('force_continued', '1'); + expect(setFailed).not.toHaveBeenCalled(); + expect(vi.getTimerCount()).toBe(0); + }); + it.each([ ['an Error', new Error('wait failed'), 'wait failed'], ['a non-Error value', 'wait failed', 'wait failed'], @@ -123,4 +279,60 @@ describe('main', () => { expect(setFailed).toHaveBeenCalledWith(expectedMessage); }); + + it('cancels concurrent discovery work before reporting the original API failure', async () => { + vi.useFakeTimers(); + const originalError = Object.assign(new Error('Bad credentials'), { status: 401 }); + const serverOperation = vi + .fn() + .mockRejectedValue(Object.assign(new Error('server error'), { status: 500 })); + const pendingAborted = vi.fn(); + let sharedSignal: AbortSignal | undefined; + const runs = vi.fn( + async ( + _owner: string, + _repo: string, + _workflowId: number, + _filters?: unknown, + requestOptions?: { signal?: AbortSignal }, + ) => { + sharedSignal = requestOptions?.signal; + if (!sharedSignal) { + throw new Error('missing shared signal'); + } + + const retryingStatus = retryRequest(serverOperation, 1, sharedSignal); + const pendingStatus = new Promise((_resolve, reject) => { + sharedSignal?.addEventListener( + 'abort', + () => { + pendingAborted(); + reject(sharedSignal?.reason); + }, + { once: true }, + ); + }); + await Promise.all([retryingStatus, pendingStatus, Promise.reject(originalError)]); + return []; + }, + ); + const setTimeoutSpy = vi.spyOn(globalThis, 'setTimeout'); + + await run(environment({ 'INPUT_ABORT-AFTER-SECONDS': '10', INPUT_RETRIES: '1' }), () => + actionClient({ + workflows: async () => [{ id: 123, name: 'CI' }], + runs, + }), + ); + + expect(setFailed).toHaveBeenCalledWith('Bad credentials'); + expect(sharedSignal?.aborted).toBe(true); + expect(pendingAborted).toHaveBeenCalledOnce(); + expect(serverOperation).toHaveBeenCalledOnce(); + expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 1_000); + expect(vi.getTimerCount()).toBe(0); + + await vi.advanceTimersByTimeAsync(1_000); + expect(serverOperation).toHaveBeenCalledOnce(); + }); }); diff --git a/__tests__/retry.test.ts b/__tests__/retry.test.ts new file mode 100644 index 0000000..831d3fd --- /dev/null +++ b/__tests__/retry.test.ts @@ -0,0 +1,347 @@ +import { afterEach, describe, expect, it, vi } from 'vitest'; + +import { ActionDeadline, DeadlineReached, type DeadlineTiming } from '../src/deadline'; +import { retryRequest } from '../src/retry'; + +const flushMicrotasks = async () => { + for (let attempt = 0; attempt < 20; attempt += 1) { + await Promise.resolve(); + } +}; + +const manualTiming = () => { + let now = 0; + let nextTimer = 1; + const timers = new Map void>(); + const timing: DeadlineTiming = { + now: () => now, + setTimeout: (callback) => { + const timer = nextTimer++; + timers.set(timer, callback); + return timer as unknown as ReturnType; + }, + clearTimeout: (timer) => { + timers.delete(timer as unknown as number); + }, + }; + + return { + timing, + advanceTo: (milliseconds: number) => { + now = milliseconds; + }, + timerCount: () => timers.size, + }; +}; + +const primaryRateLimitError = (resetAtSeconds?: string) => + Object.assign(new Error('rate limited'), { + status: 403, + response: { + headers: { + 'x-ratelimit-remaining': '0', + ...(resetAtSeconds === undefined ? {} : { 'x-ratelimit-reset': resetAtSeconds }), + }, + }, + }); + +describe('abortable retry scheduling', () => { + afterEach(() => { + vi.useRealTimers(); + vi.restoreAllMocks(); + }); + + it('preserves quadratic 5xx retry delays for deadline-bound requests', async () => { + vi.useFakeTimers(); + const controller = new AbortController(); + const operation = vi + .fn<(retryCount: number) => Promise>() + .mockRejectedValueOnce(Object.assign(new Error('first failure'), { status: 500 })) + .mockRejectedValueOnce(Object.assign(new Error('second failure'), { status: 502 })) + .mockResolvedValue('ok'); + const result = retryRequest(operation, 2, controller.signal); + + await vi.advanceTimersByTimeAsync(999); + expect(operation).toHaveBeenCalledTimes(1); + await vi.advanceTimersByTimeAsync(1); + expect(operation).toHaveBeenNthCalledWith(2, 1); + await vi.advanceTimersByTimeAsync(3_999); + expect(operation).toHaveBeenCalledTimes(2); + await vi.advanceTimersByTimeAsync(1); + + await expect(result).resolves.toBe('ok'); + expect(operation).toHaveBeenNthCalledWith(1, 0); + expect(operation).toHaveBeenNthCalledWith(3, 2); + expect(vi.getTimerCount()).toBe(0); + }); + + it.each([ + ['a client error', Object.assign(new Error('client error'), { status: 429 })], + ['an error without a status', new Error('network error')], + ['a non-Error rejection', { status: 429 }], + ])('does not retry %s', async (_description, error) => { + const operation = vi.fn().mockRejectedValue(error); + + await expect(retryRequest(operation, 2, new AbortController().signal)).rejects.toBe(error); + expect(operation).toHaveBeenCalledOnce(); + }); + + it('stops after the configured number of server-error retries', async () => { + vi.useFakeTimers(); + const error = Object.assign(new Error('server error'), { status: 503 }); + const operation = vi.fn().mockRejectedValue(error); + const result = retryRequest(operation, 1, new AbortController().signal); + const rejection = expect(result).rejects.toBe(error); + + await vi.advanceTimersByTimeAsync(1_000); + + await rejection; + expect(operation).toHaveBeenCalledTimes(2); + expect(vi.getTimerCount()).toBe(0); + }); + + it('cancels a pending server-error retry timer when the signal aborts', async () => { + vi.useFakeTimers(); + const controller = new AbortController(); + const operation = vi + .fn() + .mockRejectedValue(Object.assign(new Error('server error'), { status: 500 })); + const result = retryRequest(operation, 2, controller.signal); + + await flushMicrotasks(); + expect(vi.getTimerCount()).toBe(1); + + controller.abort(); + await expect(result).rejects.toBe(controller.signal.reason); + + expect(operation).toHaveBeenCalledOnce(); + expect(vi.getTimerCount()).toBe(0); + }); + + it('does not start a retry after the monotonic deadline when timer delivery is delayed', async () => { + vi.useFakeTimers(); + const fake = manualTiming(); + const deadline = new ActionDeadline({ mode: 'abort', seconds: 1 }, fake.timing); + const error = Object.assign(new Error('server error'), { status: 500 }); + const operation = vi.fn().mockImplementation(async () => { + fake.advanceTo(1_000); + throw error; + }); + const result = retryRequest(operation, 1, deadline.signal, undefined, deadline.throwIfReached); + const rejection = result.then( + () => undefined, + (error: unknown) => error, + ); + + try { + await vi.runAllTimersAsync(); + await expect(rejection).resolves.toEqual(new DeadlineReached('abort', 1)); + expect(operation).toHaveBeenCalledOnce(); + expect(deadline.signal.aborted).toBe(true); + } finally { + deadline.cancel(); + deadline.dispose(); + await result.catch(() => undefined); + } + + expect(fake.timerCount()).toBe(0); + expect(vi.getTimerCount()).toBe(0); + }); + + it('preserves one primary-rate-limit retry using the reset header', async () => { + vi.useFakeTimers(); + vi.setSystemTime(new Date('2026-07-15T12:00:00Z')); + const error = Object.assign(new Error('rate limited'), { + status: 403, + response: { + headers: { + 'x-ratelimit-remaining': '0', + 'x-ratelimit-reset': String(Math.floor(Date.now() / 1000) + 30), + }, + }, + }); + const operation = vi.fn().mockRejectedValueOnce(error).mockResolvedValue('ok'); + const result = retryRequest(operation, 0); + + await vi.advanceTimersByTimeAsync(30_999); + expect(operation).toHaveBeenCalledOnce(); + await vi.advanceTimersByTimeAsync(1); + + await expect(result).resolves.toBe('ok'); + expect(operation).toHaveBeenNthCalledWith(2, 1); + expect(vi.getTimerCount()).toBe(0); + }); + + it('retries a primary limit independently after a server-error retry', async () => { + vi.useFakeTimers(); + vi.setSystemTime(new Date('2026-07-15T12:00:00Z')); + const primaryError = primaryRateLimitError(String(Math.floor(Date.now() / 1000) + 5)); + const operation = vi + .fn<(attempt: number) => Promise>() + .mockRejectedValueOnce(Object.assign(new Error('server error'), { status: 500 })) + .mockRejectedValueOnce(primaryError) + .mockResolvedValue('ok'); + const result = retryRequest(operation, 1); + void result.catch(() => undefined); + + await vi.advanceTimersByTimeAsync(999); + expect(operation).toHaveBeenCalledOnce(); + await vi.advanceTimersByTimeAsync(1); + expect(operation).toHaveBeenNthCalledWith(2, 1); + await vi.advanceTimersByTimeAsync(4_999); + expect(operation).toHaveBeenCalledTimes(2); + await vi.advanceTimersByTimeAsync(1); + + await expect(result).resolves.toBe('ok'); + expect(operation).toHaveBeenNthCalledWith(3, 2); + expect(vi.getTimerCount()).toBe(0); + }); + + it('uses the first server-error delay after a primary-limit retry', async () => { + vi.useFakeTimers(); + vi.setSystemTime(new Date('2026-07-15T12:00:00Z')); + const primaryError = primaryRateLimitError(String(Math.floor(Date.now() / 1000) + 5)); + const operation = vi + .fn<(attempt: number) => Promise>() + .mockRejectedValueOnce(primaryError) + .mockRejectedValueOnce(Object.assign(new Error('server error'), { status: 500 })) + .mockResolvedValue('ok'); + const result = retryRequest(operation, 1); + + await vi.advanceTimersByTimeAsync(5_999); + expect(operation).toHaveBeenCalledOnce(); + await vi.advanceTimersByTimeAsync(1); + expect(operation).toHaveBeenNthCalledWith(2, 1); + await vi.advanceTimersByTimeAsync(999); + expect(operation).toHaveBeenCalledTimes(2); + await vi.advanceTimersByTimeAsync(1); + + await expect(result).resolves.toBe('ok'); + expect(operation).toHaveBeenNthCalledWith(3, 2); + expect(vi.getTimerCount()).toBe(0); + }); + + it('keeps primary and server retry limits and delays independent in a longer sequence', async () => { + vi.useFakeTimers(); + vi.setSystemTime(new Date('2026-07-15T12:00:00Z')); + const primaryError = primaryRateLimitError(String(Math.floor(Date.now() / 1000) + 10)); + const operation = vi + .fn<(attempt: number) => Promise>() + .mockRejectedValueOnce(Object.assign(new Error('first server error'), { status: 500 })) + .mockRejectedValueOnce(primaryError) + .mockRejectedValueOnce(Object.assign(new Error('second server error'), { status: 502 })) + .mockRejectedValueOnce(Object.assign(new Error('third server error'), { status: 503 })) + .mockResolvedValue('ok'); + const result = retryRequest(operation, 3); + void result.catch(() => undefined); + + await vi.advanceTimersByTimeAsync(1_000); + expect(operation).toHaveBeenCalledTimes(2); + await vi.advanceTimersByTimeAsync(10_000); + expect(operation).toHaveBeenCalledTimes(3); + await vi.advanceTimersByTimeAsync(3_999); + expect(operation).toHaveBeenCalledTimes(3); + await vi.advanceTimersByTimeAsync(1); + expect(operation).toHaveBeenCalledTimes(4); + await vi.advanceTimersByTimeAsync(8_999); + expect(operation).toHaveBeenCalledTimes(4); + await vi.advanceTimersByTimeAsync(1); + + await expect(result).resolves.toBe('ok'); + expect(operation).toHaveBeenCalledTimes(5); + expect(operation.mock.calls.map(([attempt]) => attempt)).toEqual([0, 1, 2, 3, 4]); + expect(vi.getTimerCount()).toBe(0); + }); + + it('permits only one primary-limit retry and reports scheduling once', async () => { + vi.useFakeTimers(); + vi.setSystemTime(new Date('2026-07-15T12:00:00Z')); + const primaryError = primaryRateLimitError(String(Math.floor(Date.now() / 1000) - 1)); + const operation = vi.fn().mockRejectedValue(primaryError); + const onPrimaryRateLimitRetry = vi.fn(); + + await expect(retryRequest(operation, 0, undefined, onPrimaryRateLimitRetry)).rejects.toBe( + primaryError, + ); + + expect(operation).toHaveBeenCalledTimes(2); + expect(onPrimaryRateLimitRetry).toHaveBeenCalledOnce(); + expect(onPrimaryRateLimitRetry).toHaveBeenCalledWith(0); + expect(vi.getTimerCount()).toBe(0); + }); + + it.each([ + ['You have exceeded a secondary rate limit', 403], + ['SECONDARY RATE LIMIT', 429], + ['secondary rate', 403], + ])( + 'does not reinterpret secondary-limit message %j as a primary limit', + async (message, status) => { + vi.useFakeTimers(); + vi.setSystemTime(new Date('2026-07-15T12:00:00Z')); + const controller = new AbortController(); + const details = { + status, + response: { + headers: { + 'retry-after': '60', + 'x-ratelimit-remaining': '0', + 'x-ratelimit-reset': String(Math.floor(Date.now() / 1000) + 600), + }, + }, + }; + const error = + status === 429 ? { message, ...details } : Object.assign(new Error(message), details); + const operation = vi.fn().mockRejectedValue(error); + const onPrimaryRateLimitRetry = vi.fn(); + const result = retryRequest(operation, 0, controller.signal, onPrimaryRateLimitRetry); + const settled = vi.fn(); + void result.then(settled, (reason: unknown) => settled('rejected', reason)); + + try { + await flushMicrotasks(); + + expect(settled).toHaveBeenCalledWith('rejected', error); + expect(operation).toHaveBeenCalledOnce(); + expect(onPrimaryRateLimitRetry).not.toHaveBeenCalled(); + expect(vi.getTimerCount()).toBe(0); + } finally { + controller.abort(); + await result.catch(() => undefined); + } + }, + ); + + it.each([ + ['a missing reset header', undefined], + ['an empty reset header', ''], + ['a malformed reset header', 'not-a-number'], + ['a whitespace-only reset header', ' '], + ['a negative reset header', '-1'], + ['a fractional reset header', '1.5'], + ['an exponential reset header', '1e9'], + ['a hexadecimal reset header', '0x10'], + ['an unsafe-integer reset header', String(Number.MAX_SAFE_INTEGER + 1)], + ])('does not schedule a primary retry for %s', async (_description, resetAtSeconds) => { + vi.useFakeTimers(); + const controller = new AbortController(); + const error = primaryRateLimitError(resetAtSeconds); + const operation = vi.fn().mockRejectedValue(error); + const onPrimaryRateLimitRetry = vi.fn(); + const result = retryRequest(operation, 0, controller.signal, onPrimaryRateLimitRetry); + const settled = vi.fn(); + void result.then(settled, (reason: unknown) => settled('rejected', reason)); + + try { + await flushMicrotasks(); + + expect(settled).toHaveBeenCalledWith('rejected', error); + expect(operation).toHaveBeenCalledOnce(); + expect(onPrimaryRateLimitRetry).not.toHaveBeenCalled(); + expect(vi.getTimerCount()).toBe(0); + } finally { + controller.abort(); + await result.catch(() => undefined); + } + }); +}); diff --git a/__tests__/wait.test.ts b/__tests__/wait.test.ts index 6118acc..96e6d6f 100644 --- a/__tests__/wait.test.ts +++ b/__tests__/wait.test.ts @@ -941,7 +941,7 @@ describe('wait', () => { await waitPromise; assert.deepStrictEqual(messages, [ - `🔎 Waiting for ${input.initialWaitSeconds} seconds before checking for runs again...`, + `🔎 Waiting until the ${input.initialWaitSeconds}-second initial discovery window expires before checking again...`, '✋Awaiting run 1 ...', ]); } finally { @@ -1148,7 +1148,7 @@ describe('wait', () => { await waiter.wait(); expect(messages).toEqual([ - 'Step missing-step not found in job 7, awaiting full run for safety', + 'Step missing-step not found in job 7, awaiting job completion for safety', '✋Awaiting job run completion from job job-url ...', ]); }); @@ -1285,12 +1285,25 @@ describe('wait', () => { await waiter.wait(); - expect(mockedRunsFunc).toHaveBeenCalledWith('org', 'repo', workflow1.id, { - branch: undefined, - }); - expect(activeRunsForRepo).toHaveBeenCalledWith('org', 'repo', { - branch: undefined, - }); + expect(mockedRunsFunc).toHaveBeenCalledWith( + 'org', + 'repo', + workflow1.id, + { branch: undefined }, + { + checkDeadline: expect.any(Function), + signal: expect.any(AbortSignal), + }, + ); + expect(activeRunsForRepo).toHaveBeenCalledWith( + 'org', + 'repo', + { branch: undefined }, + { + checkDeadline: expect.any(Function), + signal: expect.any(AbortSignal), + }, + ); const hasSearchMessage = debugMessages.some((msg) => msg.includes('Searching active workflow runs across repository'), @@ -1457,9 +1470,16 @@ describe('wait', () => { expect(hasSearchMessage).toBe(false); const hasQueueMessage = debugMessages.some((msg) => msg.includes('matches queue')); expect(hasQueueMessage).toBe(false); - expect(mockedRunsFunc).toHaveBeenCalledWith('org', 'repo', workflow1.id, { - branch: undefined, - }); + expect(mockedRunsFunc).toHaveBeenCalledWith( + 'org', + 'repo', + workflow1.id, + { branch: undefined }, + { + checkDeadline: expect.any(Function), + signal: expect.any(AbortSignal), + }, + ); }); it('keeps queue-name discovery bounded on repositories with many workflows', async () => { diff --git a/__tests__/wait/deadline.test.ts b/__tests__/wait/deadline.test.ts new file mode 100644 index 0000000..9243bb5 --- /dev/null +++ b/__tests__/wait/deadline.test.ts @@ -0,0 +1,501 @@ +import { setOutput } from '@actions/core'; +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; + +import { ActionDeadline, systemDeadlineTiming, type DeadlineTiming } from '../../src/deadline'; +import type { WorkflowJob, WorkflowRun, WorkflowStep } from '../../src/github'; +import type { Input } from '../../src/input'; +import { retryRequest } from '../../src/retry'; +import { Waiter, type WaiterGitHubClient } from '../../src/wait'; + +vi.mock('@actions/core', () => ({ + setOutput: vi.fn(), +})); + +const workflowId = 123; + +const input = (overrides: Partial = {}): Input => ({ + githubToken: 'fake-token', + owner: 'org', + repo: 'repo', + branch: 'master', + workflowName: 'CI', + workflowPath: undefined, + runId: 2, + runAttempt: 1, + pollIntervalSeconds: 60, + continueAfterSeconds: undefined, + abortAfterSeconds: undefined, + sameBranchOnly: false, + jobToWaitFor: undefined, + stepToWaitFor: undefined, + initialWaitSeconds: 0, + queueName: undefined, + retries: 0, + ...overrides, +}); + +const workflowRun = (overrides: Partial = {}): WorkflowRun => + ({ + id: 1, + status: 'in_progress', + conclusion: null, + head_branch: 'master', + html_url: 'https://example.com/runs/1', + created_at: '2026-07-15T10:00:00Z', + run_started_at: '2026-07-15T10:00:00Z', + ...overrides, + }) as WorkflowRun; + +const workflowJob = (overrides: Partial = {}): WorkflowJob => + ({ + id: 7, + name: 'deploy', + status: 'in_progress', + conclusion: null, + html_url: 'https://example.com/jobs/7', + ...overrides, + }) as WorkflowJob; + +const workflowStep = (overrides: Partial = {}): WorkflowStep => + ({ + number: 1, + name: 'publish', + status: 'in_progress', + conclusion: null, + ...overrides, + }) as WorkflowStep; + +const deferredPromise = () => { + let resolve!: (value: T | PromiseLike) => void; + let reject!: (reason?: unknown) => void; + const promise = new Promise((resolvePromise, rejectPromise) => { + resolve = resolvePromise; + reject = rejectPromise; + }); + return { promise, resolve, reject }; +}; + +const manualTiming = () => { + let now = 0; + let nextTimer = 1; + const timers = new Map void>(); + const timing: DeadlineTiming = { + now: () => now, + setTimeout: (callback) => { + const timer = nextTimer++; + timers.set(timer, callback); + return timer as unknown as ReturnType; + }, + clearTimeout: (timer) => { + timers.delete(timer as unknown as number); + }, + }; + + return { + timing, + advanceTo: (milliseconds: number) => { + now = milliseconds; + }, + timerCount: () => timers.size, + }; +}; + +const client = (overrides: Partial = {}): WaiterGitHubClient => ({ + run: async () => { + throw new Error('current run unavailable'); + }, + runs: async () => [], + activeRunsForRepo: async () => [], + jobs: async () => [], + steps: async () => [], + ...overrides, +}); + +const waiter = (waiterInput: Input, githubClient: WaiterGitHubClient, messages: string[] = []) => + new Waiter(workflowId, githubClient, waiterInput, (message) => messages.push(message), vi.fn()); + +const observeSettlement = (promise: Promise) => { + const settled = vi.fn(); + void promise.then( + (value) => settled('fulfilled', value), + (error: unknown) => settled('rejected', error), + ); + return settled; +}; + +describe('wait deadlines', () => { + beforeEach(() => { + vi.useFakeTimers(); + vi.setSystemTime(new Date('2026-07-15T12:00:00Z')); + vi.mocked(setOutput).mockClear(); + }); + + afterEach(() => { + vi.useRealTimers(); + }); + + it.each([ + ['abort', { abortAfterSeconds: 1 }, 'rejected'], + ['continue', { continueAfterSeconds: 1 }, 'fulfilled'], + ] as const)( + 'enforces a one-second %s deadline during a longer poll interval', + async (_mode, timeoutInput, expectedState) => { + const waitPromise = waiter( + input({ ...timeoutInput, pollIntervalSeconds: 60 }), + client({ runs: vi.fn().mockResolvedValue([workflowRun()]) }), + ).wait(); + const settled = observeSettlement(waitPromise); + + await vi.advanceTimersByTimeAsync(1_000); + + expect(settled).toHaveBeenCalledWith(expectedState, expect.anything()); + if (expectedState === 'rejected') { + await expect(waitPromise).rejects.toThrow('Aborted after waiting 1 seconds'); + } else { + await expect(waitPromise).resolves.toBe(1); + } + }, + ); + + it('describes initial wait as one discovery window instead of a new full-duration sleep', async () => { + const messages: string[] = []; + const waitPromise = waiter( + input({ continueAfterSeconds: 1, initialWaitSeconds: 60 }), + client({ runs: vi.fn().mockResolvedValue([]) }), + messages, + ).wait(); + + await vi.advanceTimersByTimeAsync(0); + + expect(messages).toContain( + '🔎 Waiting until the 60-second initial discovery window expires before checking again...', + ); + expect(messages).not.toContain('🔎 Waiting for 60 seconds before checking for runs again...'); + + await vi.advanceTimersByTimeAsync(1_000); + await expect(waitPromise).resolves.toBe(1); + }); + + it('starts the initial discovery window after pre-wait lifecycle work', async () => { + const waiterInput = input({ continueAfterSeconds: 10, initialWaitSeconds: 1 }); + const deadline = ActionDeadline.fromInput(waiterInput); + await vi.advanceTimersByTimeAsync(2_000); + const runs = vi.fn().mockResolvedValue([]); + const waitPromise = new Waiter( + workflowId, + client({ runs }), + waiterInput, + vi.fn(), + vi.fn(), + systemDeadlineTiming, + deadline, + ).wait(); + + try { + await vi.advanceTimersByTimeAsync(0); + expect(runs).toHaveBeenCalledOnce(); + + await vi.advanceTimersByTimeAsync(999); + expect(runs).toHaveBeenCalledOnce(); + + await vi.advanceTimersByTimeAsync(1); + await expect(waitPromise).resolves.toBeUndefined(); + expect(runs).toHaveBeenCalledTimes(2); + } finally { + deadline.dispose(); + await waitPromise.catch(() => undefined); + } + + expect(vi.getTimerCount()).toBe(0); + }); + + it('bounds the separate initial discovery window by the remaining action deadline', async () => { + const waiterInput = input({ continueAfterSeconds: 3, initialWaitSeconds: 5 }); + const deadline = ActionDeadline.fromInput(waiterInput); + await vi.advanceTimersByTimeAsync(2_000); + const runs = vi.fn().mockResolvedValue([]); + const waitPromise = new Waiter( + workflowId, + client({ runs }), + waiterInput, + vi.fn(), + vi.fn(), + systemDeadlineTiming, + deadline, + ).wait(); + const settled = observeSettlement(waitPromise); + + try { + await vi.advanceTimersByTimeAsync(999); + expect(settled).not.toHaveBeenCalled(); + + await vi.advanceTimersByTimeAsync(1); + expect(settled).toHaveBeenCalledWith('fulfilled', 3); + await expect(waitPromise).resolves.toBe(3); + expect(runs).toHaveBeenCalledOnce(); + expect(setOutput).toHaveBeenCalledWith('force_continued', '1'); + } finally { + deadline.dispose(); + await waitPromise.catch(() => undefined); + } + + expect(vi.getTimerCount()).toBe(0); + }); + + it('counts discovery time against the deadline before polling', async () => { + const currentRun = deferredPromise(); + const waitPromise = waiter( + input({ abortAfterSeconds: 1, pollIntervalSeconds: 60 }), + client({ + run: vi.fn().mockReturnValue(currentRun.promise), + runs: vi.fn().mockResolvedValue([workflowRun()]), + }), + ).wait(); + const settled = observeSettlement(waitPromise); + + await vi.advanceTimersByTimeAsync(800); + currentRun.resolve(workflowRun({ id: 2 })); + await vi.advanceTimersByTimeAsync(199); + expect(settled).not.toHaveBeenCalled(); + + await vi.advanceTimersByTimeAsync(1); + + expect(settled).toHaveBeenCalledWith('rejected', expect.any(Error)); + await expect(waitPromise).rejects.toThrow('Aborted after waiting 1 seconds'); + }); + + it('does not start a follow-up discovery read after the monotonic deadline', async () => { + const fake = manualTiming(); + const waiterInput = input({ abortAfterSeconds: 1 }); + const deadline = ActionDeadline.fromInput(waiterInput, fake.timing); + const runs = vi.fn().mockResolvedValue([]); + const run = vi.fn().mockImplementation(async () => { + fake.advanceTo(1_000); + return workflowRun({ id: waiterInput.runId }); + }); + const waitPromise = new Waiter( + workflowId, + client({ run, runs }), + waiterInput, + vi.fn(), + vi.fn(), + fake.timing, + deadline, + ).wait(); + + try { + await expect(waitPromise).rejects.toThrow('Aborted after waiting 1 seconds'); + expect(run).toHaveBeenCalledOnce(); + expect(runs).not.toHaveBeenCalled(); + expect(deadline.signal.aborted).toBe(true); + } finally { + deadline.dispose(); + await waitPromise.catch(() => undefined); + } + + expect(fake.timerCount()).toBe(0); + }); + + it.each([ + ['abort', { abortAfterSeconds: 1 }, 'rejected'], + ['continue', { continueAfterSeconds: 1 }, 'fulfilled'], + ] as const)( + 'enforces a one-second %s deadline during a longer initial wait', + async (_mode, timeoutInput, expectedState) => { + const waitPromise = waiter( + input({ ...timeoutInput, initialWaitSeconds: 60 }), + client({ runs: vi.fn().mockResolvedValue([]) }), + ).wait(); + const settled = observeSettlement(waitPromise); + + await vi.advanceTimersByTimeAsync(1_000); + + expect(settled).toHaveBeenCalledWith(expectedState, expect.anything()); + if (expectedState === 'rejected') { + await expect(waitPromise).rejects.toThrow('Aborted after waiting 1 seconds'); + } else { + await expect(waitPromise).resolves.toBe(1); + } + }, + ); + + it('continues when workflow-run discovery is pending at the deadline', async () => { + const runs = vi.fn().mockReturnValue(new Promise(() => {})); + const waitPromise = waiter(input({ continueAfterSeconds: 1 }), client({ runs })).wait(); + const settled = observeSettlement(waitPromise); + + await vi.advanceTimersByTimeAsync(1_000); + + expect(settled).toHaveBeenCalledWith('fulfilled', 1); + await expect(waitPromise).resolves.toBe(1); + expect(runs.mock.calls[0][4].signal.aborted).toBe(true); + }); + + it('aborts when repository queue discovery is pending at the deadline', async () => { + const activeRunsForRepo = vi.fn().mockReturnValue(new Promise(() => {})); + const waitPromise = waiter( + input({ abortAfterSeconds: 1, queueName: 'deploy' }), + client({ runs: vi.fn().mockResolvedValue([]), activeRunsForRepo }), + ).wait(); + const settled = observeSettlement(waitPromise); + + await vi.advanceTimersByTimeAsync(1_000); + + expect(settled).toHaveBeenCalledWith('rejected', expect.any(Error)); + await expect(waitPromise).rejects.toThrow('Aborted after waiting 1 seconds'); + expect(activeRunsForRepo.mock.calls[0][3].signal.aborted).toBe(true); + }); + + it('aborts a pending jobs request and forwards the deadline signal', async () => { + const jobs = vi.fn().mockReturnValue(new Promise(() => {})); + const waitPromise = waiter( + input({ abortAfterSeconds: 1, jobToWaitFor: 'deploy' }), + client({ runs: vi.fn().mockResolvedValue([workflowRun()]), jobs }), + ).wait(); + const settled = observeSettlement(waitPromise); + + await vi.advanceTimersByTimeAsync(1_000); + + expect(settled).toHaveBeenCalledWith('rejected', expect.any(Error)); + await expect(waitPromise).rejects.toThrow('Aborted after waiting 1 seconds'); + expect(jobs.mock.calls[0][3].signal.aborted).toBe(true); + }); + + it('aborts a pending steps request and forwards the deadline signal', async () => { + const steps = vi.fn().mockReturnValue(new Promise(() => {})); + const waitPromise = waiter( + input({ abortAfterSeconds: 1, jobToWaitFor: 'deploy', stepToWaitFor: 'publish' }), + client({ + runs: vi.fn().mockResolvedValue([workflowRun()]), + jobs: vi.fn().mockResolvedValue([workflowJob()]), + steps, + }), + ).wait(); + const settled = observeSettlement(waitPromise); + + await vi.advanceTimersByTimeAsync(1_000); + + expect(settled).toHaveBeenCalledWith('rejected', expect.any(Error)); + await expect(waitPromise).rejects.toThrow('Aborted after waiting 1 seconds'); + expect(steps.mock.calls[0][3].signal.aborted).toBe(true); + }); + + it('keeps the deadline outcome when an API promise resolves immediately afterward', async () => { + const runs = deferredPromise(); + const messages: string[] = []; + const waitPromise = waiter( + input({ abortAfterSeconds: 1 }), + client({ runs: vi.fn().mockReturnValue(runs.promise) }), + messages, + ).wait(); + const settled = observeSettlement(waitPromise); + + await vi.advanceTimersByTimeAsync(1_000); + runs.resolve([]); + await vi.advanceTimersByTimeAsync(0); + + expect(settled).toHaveBeenCalledWith('rejected', expect.any(Error)); + await expect(waitPromise).rejects.toThrow('Aborted after waiting 1 seconds'); + expect(messages).toEqual(['🛑Exceeded wait seconds. Aborting...']); + }); + + it('cleans up the deadline timer after successful completion', async () => { + const run = vi.fn().mockResolvedValue(workflowRun({ id: 2 })); + const runs = vi.fn().mockResolvedValue([]); + const waitPromise = waiter(input({ abortAfterSeconds: 10 }), client({ run, runs })).wait(); + + await expect(waitPromise).resolves.toBeUndefined(); + + const signal = run.mock.calls[0][3].signal as AbortSignal; + expect(runs.mock.calls[0][4].signal).toBe(signal); + expect(signal.aborted).toBe(false); + expect(vi.getTimerCount()).toBe(0); + + await vi.advanceTimersByTimeAsync(10_000); + expect(signal.aborted).toBe(false); + }); + + it('propagates API failures that happen before the deadline and cleans up', async () => { + const runs = vi.fn().mockRejectedValue(new Error('API unavailable')); + const waitPromise = waiter(input({ abortAfterSeconds: 10 }), client({ runs })).wait(); + + await expect(waitPromise).rejects.toThrow('API unavailable'); + + expect(runs.mock.calls[0][4].signal.aborted).toBe(true); + expect(vi.getTimerCount()).toBe(0); + }); + + it('cancels concurrent discovery work before propagating an owned-deadline failure', async () => { + const originalError = Object.assign(new Error('Bad credentials'), { status: 401 }); + const serverOperation = vi + .fn() + .mockRejectedValue(Object.assign(new Error('server error'), { status: 500 })); + const pendingAborted = vi.fn(); + let sharedSignal: AbortSignal | undefined; + const runs = vi.fn( + async ( + _owner: string, + _repo: string, + _workflowId: number, + _filters?: unknown, + requestOptions?: { signal?: AbortSignal }, + ) => { + sharedSignal = requestOptions?.signal; + if (!sharedSignal) { + throw new Error('missing shared signal'); + } + + const retryingStatus = retryRequest(serverOperation, 1, sharedSignal); + const pendingStatus = new Promise((_resolve, reject) => { + sharedSignal?.addEventListener( + 'abort', + () => { + pendingAborted(); + reject(sharedSignal?.reason); + }, + { once: true }, + ); + }); + await Promise.all([retryingStatus, pendingStatus, Promise.reject(originalError)]); + return []; + }, + ); + const setTimeoutSpy = vi.spyOn(globalThis, 'setTimeout'); + const waitPromise = waiter(input({ abortAfterSeconds: 10 }), client({ runs })).wait(); + + await expect(waitPromise).rejects.toBe(originalError); + + expect(sharedSignal?.aborted).toBe(true); + expect(pendingAborted).toHaveBeenCalledOnce(); + expect(serverOperation).toHaveBeenCalledOnce(); + expect(setTimeoutSpy).toHaveBeenCalledWith(expect.any(Function), 1_000); + expect(vi.getTimerCount()).toBe(0); + + await vi.advanceTimersByTimeAsync(1_000); + expect(serverOperation).toHaveBeenCalledOnce(); + }); + + it('reuses one deadline signal and leaves no timers after repeated polling', async () => { + const run = vi.fn().mockResolvedValue(workflowRun({ id: 3 })); + const runs = vi + .fn() + .mockResolvedValueOnce([workflowRun({ id: 2 })]) + .mockResolvedValueOnce([workflowRun({ id: 1 })]) + .mockResolvedValue([]); + const waitPromise = waiter( + input({ runId: 3, abortAfterSeconds: 10, pollIntervalSeconds: 1 }), + client({ run, runs }), + ).wait(); + + await vi.advanceTimersByTimeAsync(2_000); + await expect(waitPromise).resolves.toBeUndefined(); + + const signals = [ + ...run.mock.calls.map((call) => call[3].signal as AbortSignal), + ...runs.mock.calls.map((call) => call[4].signal as AbortSignal), + ]; + expect(new Set(signals).size).toBe(1); + expect(signals[0].aborted).toBe(false); + expect(vi.getTimerCount()).toBe(0); + }); +}); diff --git a/__tests__/wait/predecessor-selection.test.ts b/__tests__/wait/predecessor-selection.test.ts new file mode 100644 index 0000000..74e33d5 --- /dev/null +++ b/__tests__/wait/predecessor-selection.test.ts @@ -0,0 +1,110 @@ +import { setOutput } from '@actions/core'; +import { beforeEach, describe, expect, it, vi } from 'vitest'; + +import type { WorkflowRun } from '../../src/github'; +import type { Input } from '../../src/input'; +import { Waiter, type WaiterGitHubClient } from '../../src/wait'; + +vi.mock('@actions/core', () => ({ + setOutput: vi.fn(), +})); + +const input = (overrides: Partial = {}): Input => ({ + githubToken: 'fake-token', + owner: 'org', + repo: 'repo', + branch: 'master', + workflowName: 'CI', + workflowPath: undefined, + runId: 2, + runAttempt: 1, + pollIntervalSeconds: 0, + continueAfterSeconds: undefined, + abortAfterSeconds: undefined, + sameBranchOnly: false, + jobToWaitFor: undefined, + stepToWaitFor: undefined, + initialWaitSeconds: 0, + queueName: undefined, + retries: 0, + ...overrides, +}); + +const workflowRun = (overrides: Partial = {}): WorkflowRun => + ({ + id: 1, + run_attempt: 1, + status: 'in_progress', + conclusion: null, + head_branch: 'master', + html_url: 'https://example.com/runs/1', + created_at: '2026-07-15T10:00:00Z', + run_started_at: '2026-07-15T10:00:00Z', + ...overrides, + }) as WorkflowRun; + +const client = (overrides: Partial): WaiterGitHubClient => ({ + run: async () => { + throw new Error('current run unavailable'); + }, + runs: async () => [], + activeRunsForRepo: async () => [], + jobs: async () => [], + steps: async () => [], + ...overrides, +}); + +describe('predecessor selection edge cases', () => { + beforeEach(() => { + vi.mocked(setOutput).mockClear(); + }); + + it('does not block on active status metadata with a successful conclusion', async () => { + const successfulRun = workflowRun({ conclusion: 'success' }); + const debugMessages: string[] = []; + const waiter = new Waiter( + 123, + client({ runs: vi.fn().mockResolvedValue([successfulRun]) }), + input(), + vi.fn(), + (message) => debugMessages.push(message), + ); + + await waiter.wait(); + + expect(debugMessages).toContain('Skipping run 1, status: in_progress, conclusion: success'); + expect(setOutput).toHaveBeenCalledWith('previous_run_id', ''); + }); + + it.each([ + [ + 'a rerun missing its actual start time', + input({ runId: 2, runAttempt: 1 }), + workflowRun({ id: 2, run_attempt: 1 }), + workflowRun({ id: 1, run_attempt: 2, run_started_at: undefined }), + ], + [ + 'a higher-ID first attempt missing all timestamps before a current rerun', + input({ runId: 1, runAttempt: 2 }), + workflowRun({ id: 1, run_attempt: 2 }), + workflowRun({ id: 2, run_attempt: 1, run_started_at: undefined, created_at: undefined }), + ], + ])('conservatively ignores %s', async (_description, waiterInput, currentRun, candidate) => { + const infoMessages: string[] = []; + const waiter = new Waiter( + 123, + client({ + run: vi.fn().mockResolvedValue(currentRun), + runs: vi.fn().mockResolvedValue([candidate]), + }), + waiterInput, + (message) => infoMessages.push(message), + vi.fn(), + ); + + await waiter.wait(); + + expect(infoMessages).toEqual([]); + expect(setOutput).toHaveBeenCalledWith('previous_run_id', ''); + }); +}); diff --git a/action.yml b/action.yml index 31f9fae..db22ba1 100644 --- a/action.yml +++ b/action.yml @@ -15,9 +15,9 @@ inputs: poll-interval-seconds: description: "Number of seconds to wait in between checks for previous run completion (defaults to 60)" continue-after-seconds: - description: "Maximum number of seconds to wait before moving forward (unbound by default). Mutually exclusive with abort-after-seconds" + description: "Maximum elapsed seconds, starting before the first Actions API read and including later API reads and sleeps, before moving forward (unbound by default). Mutually exclusive with abort-after-seconds" abort-after-seconds: - description: "Maximum number of seconds to wait before failing the step (unbound by default). Mutually exclusive with continue-after-seconds" + description: "Maximum elapsed seconds, starting before the first Actions API read and including later API reads and sleeps, before failing the step (unbound by default). Mutually exclusive with continue-after-seconds" same-branch-only: description: "Only wait on other runs from the same branch (defaults to true)" branch: @@ -27,7 +27,7 @@ inputs: step-to-wait-for: description: "Name of the job's step to wait for (unbound by default). Requires job-to-wait-for to be set" initial-wait-seconds: - description: "Total elapsed seconds within which period the action will refresh the list of current runs, if no runs were found in the first poll (0 by default, ie doesn't retry)" + description: "Seconds from the start of workflow-run discovery within which the action refreshes current runs when none were found in the first poll, bounded by any continue or abort deadline (0 by default, ie doesn't retry)" queue-name: description: 'Custom name for grouping runs by the value if not specified will take the workflow name (unbound by default)' retries: diff --git a/dist/index.js b/dist/index.js index 102254e..e98e414 100644 --- a/dist/index.js +++ b/dist/index.js @@ -1,49 +1,49 @@ -"use strict";var lf=Object.create;var Os=Object.defineProperty;var Ef=Object.getOwnPropertyDescriptor;var hf=Object.getOwnPropertyNames;var Qf=Object.getPrototypeOf,Bf=Object.prototype.hasOwnProperty;var m=(t,e)=>()=>{try{return e||t((e={exports:{}}).exports,e),e.exports}catch(r){throw e=0,r}},df=(t,e)=>{for(var r in e)Os(t,r,{get:e[r],enumerable:!0})},pu=(t,e,r,A)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of hf(e))!Bf.call(t,s)&&s!==r&&Os(t,s,{get:()=>e[s],enumerable:!(A=Ef(e,s))||A.enumerable});return t};var Oe=(t,e,r)=>(r=t!=null?lf(Qf(t)):{},pu(e||!t||!t.__esModule?Os(r,"default",{value:t,enumerable:!0}):r,t)),If=t=>pu(Os({},"__esModule",{value:!0}),t);var Tu=m(Gr=>{"use strict";var kM=require("net"),mf=require("tls"),ni=require("http"),ku=require("https"),wf=require("events"),DM=require("assert"),yf=require("util");Gr.httpOverHttp=bf;Gr.httpsOverHttp=kf;Gr.httpOverHttps=Df;Gr.httpsOverHttps=Rf;function bf(t){var e=new pt(t);return e.request=ni.request,e}function kf(t){var e=new pt(t);return e.request=ni.request,e.createSocket=Du,e.defaultPort=443,e}function Df(t){var e=new pt(t);return e.request=ku.request,e}function Rf(t){var e=new pt(t);return e.request=ku.request,e.createSocket=Du,e.defaultPort=443,e}function pt(t){var e=this;e.options=t||{},e.proxyOptions=e.options.proxy||{},e.maxSockets=e.options.maxSockets||ni.Agent.defaultMaxSockets,e.requests=[],e.sockets=[],e.on("free",function(A,s,o,n){for(var i=Ru(s,o,n),a=0,c=e.requests.length;a=this.maxSockets){o.requests.push(n);return}o.createSocket(n,function(i){i.on("free",a),i.on("close",c),i.on("agentRemove",c),e.onSocket(i);function a(){o.emit("free",i,n)}function c(l){o.removeSocket(i),i.removeListener("free",a),i.removeListener("close",c),i.removeListener("agentRemove",c)}})};pt.prototype.createSocket=function(e,r){var A=this,s={};A.sockets.push(s);var o=ii({},A.proxyOptions,{method:"CONNECT",path:e.host+":"+e.port,agent:!1,headers:{host:e.host+":"+e.port}});e.localAddress&&(o.localAddress=e.localAddress),o.proxyAuth&&(o.headers=o.headers||{},o.headers["Proxy-Authorization"]="Basic "+new Buffer(o.proxyAuth).toString("base64")),_t("making CONNECT request");var n=A.request(o);n.useChunkedEncodingByDefault=!1,n.once("response",i),n.once("upgrade",a),n.once("connect",c),n.once("error",l),n.end();function i(g){g.upgrade=!0}function a(g,E,d){process.nextTick(function(){c(g,E,d)})}function c(g,E,d){if(n.removeAllListeners(),E.removeAllListeners(),g.statusCode!==200){_t("tunneling socket could not be established, statusCode=%d",g.statusCode),E.destroy();var B=new Error("tunneling socket could not be established, statusCode="+g.statusCode);B.code="ECONNRESET",e.request.emit("error",B),A.removeSocket(s);return}if(d.length>0){_t("got illegal response body from proxy"),E.destroy();var B=new Error("got illegal response body from proxy");B.code="ECONNRESET",e.request.emit("error",B),A.removeSocket(s);return}return _t("tunneling connection has established"),A.sockets[A.sockets.indexOf(s)]=E,r(E)}function l(g){n.removeAllListeners(),_t(`tunneling socket could not be established, cause=%s -`,g.message,g.stack);var E=new Error("tunneling socket could not be established, cause="+g.message);E.code="ECONNRESET",e.request.emit("error",E),A.removeSocket(s)}};pt.prototype.removeSocket=function(e){var r=this.sockets.indexOf(e);if(r!==-1){this.sockets.splice(r,1);var A=this.requests.shift();A&&this.createSocket(A,function(s){A.request.onSocket(s)})}};function Du(t,e){var r=this;pt.prototype.createSocket.call(r,t,function(A){var s=t.request.getHeader("host"),o=ii({},r.options,{socket:A,servername:s?s.replace(/:.*$/,""):t.host}),n=mf.connect(0,o);r.sockets[r.sockets.indexOf(A)]=n,e(n)})}function Ru(t,e,r){return typeof t=="string"?{host:t,port:e,localAddress:r}:t}function ii(t){for(var e=1,r=arguments.length;e{Fu.exports=Tu()});var se=m((FM,Uu)=>{Uu.exports={kClose:Symbol("close"),kDestroy:Symbol("destroy"),kDispatch:Symbol("dispatch"),kUrl:Symbol("url"),kWriting:Symbol("writing"),kResuming:Symbol("resuming"),kQueue:Symbol("queue"),kConnect:Symbol("connect"),kConnecting:Symbol("connecting"),kKeepAliveDefaultTimeout:Symbol("default keep alive timeout"),kKeepAliveMaxTimeout:Symbol("max keep alive timeout"),kKeepAliveTimeoutThreshold:Symbol("keep alive timeout threshold"),kKeepAliveTimeoutValue:Symbol("keep alive timeout"),kKeepAlive:Symbol("keep alive"),kHeadersTimeout:Symbol("headers timeout"),kBodyTimeout:Symbol("body timeout"),kServerName:Symbol("server name"),kLocalAddress:Symbol("local address"),kHost:Symbol("host"),kNoRef:Symbol("no ref"),kBodyUsed:Symbol("used"),kBody:Symbol("abstracted request body"),kRunning:Symbol("running"),kBlocking:Symbol("blocking"),kPending:Symbol("pending"),kSize:Symbol("size"),kBusy:Symbol("busy"),kQueued:Symbol("queued"),kFree:Symbol("free"),kConnected:Symbol("connected"),kClosed:Symbol("closed"),kNeedDrain:Symbol("need drain"),kReset:Symbol("reset"),kDestroyed:Symbol.for("nodejs.stream.destroyed"),kResume:Symbol("resume"),kOnError:Symbol("on error"),kMaxHeadersSize:Symbol("max headers size"),kRunningIdx:Symbol("running index"),kPendingIdx:Symbol("pending index"),kError:Symbol("error"),kClients:Symbol("clients"),kClient:Symbol("client"),kParser:Symbol("parser"),kOnDestroyed:Symbol("destroy callbacks"),kPipelining:Symbol("pipelining"),kSocket:Symbol("socket"),kHostHeader:Symbol("host header"),kConnector:Symbol("connector"),kStrictContentLength:Symbol("strict content length"),kMaxRedirections:Symbol("maxRedirections"),kMaxRequests:Symbol("maxRequestsPerClient"),kProxy:Symbol("proxy agent options"),kCounter:Symbol("socket request counter"),kInterceptors:Symbol("dispatch interceptors"),kMaxResponseSize:Symbol("max response size"),kHTTP2Session:Symbol("http2Session"),kHTTP2SessionState:Symbol("http2Session state"),kRetryHandlerDefaultRetry:Symbol("retry agent default retry"),kConstruct:Symbol("constructable"),kListeners:Symbol("listeners"),kHTTPContext:Symbol("http context"),kMaxConcurrentStreams:Symbol("max concurrent streams"),kNoProxyAgent:Symbol("no proxy agent"),kHttpProxyAgent:Symbol("http proxy agent"),kHttpsProxyAgent:Symbol("https proxy agent")}});var q=m((SM,Al)=>{"use strict";var Nu=Symbol.for("undici.error.UND_ERR"),oe=class extends Error{constructor(e){super(e),this.name="UndiciError",this.code="UND_ERR"}static[Symbol.hasInstance](e){return e&&e[Nu]===!0}[Nu]=!0},Gu=Symbol.for("undici.error.UND_ERR_CONNECT_TIMEOUT"),ai=class extends oe{constructor(e){super(e),this.name="ConnectTimeoutError",this.message=e||"Connect Timeout Error",this.code="UND_ERR_CONNECT_TIMEOUT"}static[Symbol.hasInstance](e){return e&&e[Gu]===!0}[Gu]=!0},Mu=Symbol.for("undici.error.UND_ERR_HEADERS_TIMEOUT"),ci=class extends oe{constructor(e){super(e),this.name="HeadersTimeoutError",this.message=e||"Headers Timeout Error",this.code="UND_ERR_HEADERS_TIMEOUT"}static[Symbol.hasInstance](e){return e&&e[Mu]===!0}[Mu]=!0},Lu=Symbol.for("undici.error.UND_ERR_HEADERS_OVERFLOW"),gi=class extends oe{constructor(e){super(e),this.name="HeadersOverflowError",this.message=e||"Headers Overflow Error",this.code="UND_ERR_HEADERS_OVERFLOW"}static[Symbol.hasInstance](e){return e&&e[Lu]===!0}[Lu]=!0},vu=Symbol.for("undici.error.UND_ERR_BODY_TIMEOUT"),ui=class extends oe{constructor(e){super(e),this.name="BodyTimeoutError",this.message=e||"Body Timeout Error",this.code="UND_ERR_BODY_TIMEOUT"}static[Symbol.hasInstance](e){return e&&e[vu]===!0}[vu]=!0},_u=Symbol.for("undici.error.UND_ERR_RESPONSE_STATUS_CODE"),li=class extends oe{constructor(e,r,A,s){super(e),this.name="ResponseStatusCodeError",this.message=e||"Response Status Code Error",this.code="UND_ERR_RESPONSE_STATUS_CODE",this.body=s,this.status=r,this.statusCode=r,this.headers=A}static[Symbol.hasInstance](e){return e&&e[_u]===!0}[_u]=!0},xu=Symbol.for("undici.error.UND_ERR_INVALID_ARG"),Ei=class extends oe{constructor(e){super(e),this.name="InvalidArgumentError",this.message=e||"Invalid Argument Error",this.code="UND_ERR_INVALID_ARG"}static[Symbol.hasInstance](e){return e&&e[xu]===!0}[xu]=!0},Yu=Symbol.for("undici.error.UND_ERR_INVALID_RETURN_VALUE"),hi=class extends oe{constructor(e){super(e),this.name="InvalidReturnValueError",this.message=e||"Invalid Return Value Error",this.code="UND_ERR_INVALID_RETURN_VALUE"}static[Symbol.hasInstance](e){return e&&e[Yu]===!0}[Yu]=!0},Ju=Symbol.for("undici.error.UND_ERR_ABORT"),Vs=class extends oe{constructor(e){super(e),this.name="AbortError",this.message=e||"The operation was aborted",this.code="UND_ERR_ABORT"}static[Symbol.hasInstance](e){return e&&e[Ju]===!0}[Ju]=!0},Ou=Symbol.for("undici.error.UND_ERR_ABORTED"),Qi=class extends Vs{constructor(e){super(e),this.name="AbortError",this.message=e||"Request aborted",this.code="UND_ERR_ABORTED"}static[Symbol.hasInstance](e){return e&&e[Ou]===!0}[Ou]=!0},Hu=Symbol.for("undici.error.UND_ERR_INFO"),Bi=class extends oe{constructor(e){super(e),this.name="InformationalError",this.message=e||"Request information",this.code="UND_ERR_INFO"}static[Symbol.hasInstance](e){return e&&e[Hu]===!0}[Hu]=!0},Pu=Symbol.for("undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"),di=class extends oe{constructor(e){super(e),this.name="RequestContentLengthMismatchError",this.message=e||"Request body length does not match content-length header",this.code="UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"}static[Symbol.hasInstance](e){return e&&e[Pu]===!0}[Pu]=!0},Vu=Symbol.for("undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH"),Ii=class extends oe{constructor(e){super(e),this.name="ResponseContentLengthMismatchError",this.message=e||"Response body length does not match content-length header",this.code="UND_ERR_RES_CONTENT_LENGTH_MISMATCH"}static[Symbol.hasInstance](e){return e&&e[Vu]===!0}[Vu]=!0},qu=Symbol.for("undici.error.UND_ERR_DESTROYED"),Ci=class extends oe{constructor(e){super(e),this.name="ClientDestroyedError",this.message=e||"The client is destroyed",this.code="UND_ERR_DESTROYED"}static[Symbol.hasInstance](e){return e&&e[qu]===!0}[qu]=!0},Wu=Symbol.for("undici.error.UND_ERR_CLOSED"),pi=class extends oe{constructor(e){super(e),this.name="ClientClosedError",this.message=e||"The client is closed",this.code="UND_ERR_CLOSED"}static[Symbol.hasInstance](e){return e&&e[Wu]===!0}[Wu]=!0},zu=Symbol.for("undici.error.UND_ERR_SOCKET"),fi=class extends oe{constructor(e,r){super(e),this.name="SocketError",this.message=e||"Socket error",this.code="UND_ERR_SOCKET",this.socket=r}static[Symbol.hasInstance](e){return e&&e[zu]===!0}[zu]=!0},Zu=Symbol.for("undici.error.UND_ERR_NOT_SUPPORTED"),mi=class extends oe{constructor(e){super(e),this.name="NotSupportedError",this.message=e||"Not supported error",this.code="UND_ERR_NOT_SUPPORTED"}static[Symbol.hasInstance](e){return e&&e[Zu]===!0}[Zu]=!0},Ku=Symbol.for("undici.error.UND_ERR_BPL_MISSING_UPSTREAM"),wi=class extends oe{constructor(e){super(e),this.name="MissingUpstreamError",this.message=e||"No upstream has been added to the BalancedPool",this.code="UND_ERR_BPL_MISSING_UPSTREAM"}static[Symbol.hasInstance](e){return e&&e[Ku]===!0}[Ku]=!0},ju=Symbol.for("undici.error.UND_ERR_HTTP_PARSER"),yi=class extends Error{constructor(e,r,A){super(e),this.name="HTTPParserError",this.code=r?`HPE_${r}`:void 0,this.data=A?A.toString():void 0}static[Symbol.hasInstance](e){return e&&e[ju]===!0}[ju]=!0},Xu=Symbol.for("undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE"),bi=class extends oe{constructor(e){super(e),this.name="ResponseExceededMaxSizeError",this.message=e||"Response content exceeded max size",this.code="UND_ERR_RES_EXCEEDED_MAX_SIZE"}static[Symbol.hasInstance](e){return e&&e[Xu]===!0}[Xu]=!0},$u=Symbol.for("undici.error.UND_ERR_REQ_RETRY"),ki=class extends oe{constructor(e,r,{headers:A,data:s}){super(e),this.name="RequestRetryError",this.message=e||"Request retry error",this.code="UND_ERR_REQ_RETRY",this.statusCode=r,this.data=s,this.headers=A}static[Symbol.hasInstance](e){return e&&e[$u]===!0}[$u]=!0},el=Symbol.for("undici.error.UND_ERR_RESPONSE"),Di=class extends oe{constructor(e,r,{headers:A,data:s}){super(e),this.name="ResponseError",this.message=e||"Response error",this.code="UND_ERR_RESPONSE",this.statusCode=r,this.data=s,this.headers=A}static[Symbol.hasInstance](e){return e&&e[el]===!0}[el]=!0},tl=Symbol.for("undici.error.UND_ERR_PRX_TLS"),Ri=class extends oe{constructor(e,r,A){super(r,{cause:e,...A??{}}),this.name="SecureProxyConnectionError",this.message=r||"Secure Proxy Connection failed",this.code="UND_ERR_PRX_TLS",this.cause=e}static[Symbol.hasInstance](e){return e&&e[tl]===!0}[tl]=!0},rl=Symbol.for("undici.error.UND_ERR_WS_MESSAGE_SIZE_EXCEEDED"),Ti=class extends oe{constructor(e){super(e),this.name="MessageSizeExceededError",this.message=e||"Max decompressed message size exceeded",this.code="UND_ERR_WS_MESSAGE_SIZE_EXCEEDED"}static[Symbol.hasInstance](e){return e&&e[rl]===!0}get[rl](){return!0}};Al.exports={AbortError:Vs,HTTPParserError:yi,UndiciError:oe,HeadersTimeoutError:ci,HeadersOverflowError:gi,BodyTimeoutError:ui,RequestContentLengthMismatchError:di,ConnectTimeoutError:ai,ResponseStatusCodeError:li,InvalidArgumentError:Ei,InvalidReturnValueError:hi,RequestAbortedError:Qi,ClientDestroyedError:Ci,ClientClosedError:pi,InformationalError:Bi,SocketError:fi,NotSupportedError:mi,ResponseContentLengthMismatchError:Ii,BalancedPoolMissingUpstreamError:wi,ResponseExceededMaxSizeError:bi,RequestRetryError:ki,ResponseError:Di,SecureProxyConnectionError:Ri,MessageSizeExceededError:Ti}});var Ws=m((UM,sl)=>{"use strict";var qs={},Fi=["Accept","Accept-Encoding","Accept-Language","Accept-Ranges","Access-Control-Allow-Credentials","Access-Control-Allow-Headers","Access-Control-Allow-Methods","Access-Control-Allow-Origin","Access-Control-Expose-Headers","Access-Control-Max-Age","Access-Control-Request-Headers","Access-Control-Request-Method","Age","Allow","Alt-Svc","Alt-Used","Authorization","Cache-Control","Clear-Site-Data","Connection","Content-Disposition","Content-Encoding","Content-Language","Content-Length","Content-Location","Content-Range","Content-Security-Policy","Content-Security-Policy-Report-Only","Content-Type","Cookie","Cross-Origin-Embedder-Policy","Cross-Origin-Opener-Policy","Cross-Origin-Resource-Policy","Date","Device-Memory","Downlink","ECT","ETag","Expect","Expect-CT","Expires","Forwarded","From","Host","If-Match","If-Modified-Since","If-None-Match","If-Range","If-Unmodified-Since","Keep-Alive","Last-Modified","Link","Location","Max-Forwards","Origin","Permissions-Policy","Pragma","Proxy-Authenticate","Proxy-Authorization","RTT","Range","Referer","Referrer-Policy","Refresh","Retry-After","Sec-WebSocket-Accept","Sec-WebSocket-Extensions","Sec-WebSocket-Key","Sec-WebSocket-Protocol","Sec-WebSocket-Version","Server","Server-Timing","Service-Worker-Allowed","Service-Worker-Navigation-Preload","Set-Cookie","SourceMap","Strict-Transport-Security","Supports-Loading-Mode","TE","Timing-Allow-Origin","Trailer","Transfer-Encoding","Upgrade","Upgrade-Insecure-Requests","User-Agent","Vary","Via","WWW-Authenticate","X-Content-Type-Options","X-DNS-Prefetch-Control","X-Frame-Options","X-Permitted-Cross-Domain-Policies","X-Powered-By","X-Requested-With","X-XSS-Protection"];for(let t=0;t{"use strict";var{wellknownHeaderNames:ol,headerNameLowerCasedRecord:Tf}=Ws(),Si=class t{value=null;left=null;middle=null;right=null;code;constructor(e,r,A){if(A===void 0||A>=e.length)throw new TypeError("Unreachable");if((this.code=e.charCodeAt(A))>127)throw new TypeError("key must be ascii string");e.length!==++A?this.middle=new t(e,r,A):this.value=r}add(e,r){let A=e.length;if(A===0)throw new TypeError("Unreachable");let s=0,o=this;for(;;){let n=e.charCodeAt(s);if(n>127)throw new TypeError("key must be ascii string");if(o.code===n)if(A===++s){o.value=r;break}else if(o.middle!==null)o=o.middle;else{o.middle=new t(e,r,s);break}else if(o.code=65&&(o|=32);s!==null;){if(o===s.code){if(r===++A)return s;s=s.middle;break}s=s.code{"use strict";var LA=require("node:assert"),{kDestroyed:gl,kBodyUsed:Mr,kListeners:Ui,kBody:cl}=se(),{IncomingMessage:Ff}=require("node:http"),js=require("node:stream"),Sf=require("node:net"),{Blob:Uf}=require("node:buffer"),Nf=require("node:util"),{stringify:Gf}=require("node:querystring"),{EventEmitter:Mf}=require("node:events"),{InvalidArgumentError:Ee}=q(),{headerNameLowerCasedRecord:Lf}=Ws(),{tree:ul}=al(),[vf,_f]=process.versions.node.split(".").map(t=>Number(t)),Ks=class{constructor(e){this[cl]=e,this[Mr]=!1}async*[Symbol.asyncIterator](){LA(!this[Mr],"disturbed"),this[Mr]=!0,yield*this[cl]}};function xf(t){return Xs(t)?(Bl(t)===0&&t.on("data",function(){LA(!1)}),typeof t.readableDidRead!="boolean"&&(t[Mr]=!1,Mf.prototype.on.call(t,"data",function(){this[Mr]=!0})),t):t&&typeof t.pipeTo=="function"?new Ks(t):t&&typeof t!="string"&&!ArrayBuffer.isView(t)&&Ql(t)?new Ks(t):t}function Yf(){}function Xs(t){return t&&typeof t=="object"&&typeof t.pipe=="function"&&typeof t.on=="function"}function ll(t){if(t===null)return!1;if(t instanceof Uf)return!0;if(typeof t!="object")return!1;{let e=t[Symbol.toStringTag];return(e==="Blob"||e==="File")&&("stream"in t&&typeof t.stream=="function"||"arrayBuffer"in t&&typeof t.arrayBuffer=="function")}}function Jf(t,e){if(t.includes("?")||t.includes("#"))throw new Error('Query params cannot be passed when url already contains "?" or "#".');let r=Gf(e);return r&&(t+="?"+r),t}function El(t){let e=parseInt(t,10);return e===Number(t)&&e>=0&&e<=65535}function Zs(t){return t!=null&&t[0]==="h"&&t[1]==="t"&&t[2]==="t"&&t[3]==="p"&&(t[4]===":"||t[4]==="s"&&t[5]===":")}function hl(t){if(typeof t=="string"){if(t=new URL(t),!Zs(t.origin||t.protocol))throw new Ee("Invalid URL protocol: the URL must start with `http:` or `https:`.");return t}if(!t||typeof t!="object")throw new Ee("Invalid URL: The URL argument must be a non-null object.");if(!(t instanceof URL)){if(t.port!=null&&t.port!==""&&El(t.port)===!1)throw new Ee("Invalid URL: port must be a valid integer or a string representation of an integer.");if(t.path!=null&&typeof t.path!="string")throw new Ee("Invalid URL path: the path must be a string or null/undefined.");if(t.pathname!=null&&typeof t.pathname!="string")throw new Ee("Invalid URL pathname: the pathname must be a string or null/undefined.");if(t.hostname!=null&&typeof t.hostname!="string")throw new Ee("Invalid URL hostname: the hostname must be a string or null/undefined.");if(t.origin!=null&&typeof t.origin!="string")throw new Ee("Invalid URL origin: the origin must be a string or null/undefined.");if(!Zs(t.origin||t.protocol))throw new Ee("Invalid URL protocol: the URL must start with `http:` or `https:`.");let e=t.port!=null?t.port:t.protocol==="https:"?443:80,r=t.origin!=null?t.origin:`${t.protocol||""}//${t.hostname||""}:${e}`,A=t.path!=null?t.path:`${t.pathname||""}${t.search||""}`;return r[r.length-1]==="/"&&(r=r.slice(0,r.length-1)),A&&A[0]!=="/"&&(A=`/${A}`),new URL(`${r}${A}`)}if(!Zs(t.origin||t.protocol))throw new Ee("Invalid URL protocol: the URL must start with `http:` or `https:`.");return t}function Of(t){if(t=hl(t),t.pathname!=="/"||t.search||t.hash)throw new Ee("invalid url");return t}function Hf(t){if(t[0]==="["){let r=t.indexOf("]");return LA(r!==-1),t.substring(1,r)}let e=t.indexOf(":");return e===-1?t:t.substring(0,e)}function Pf(t){if(!t)return null;LA(typeof t=="string");let e=Hf(t);return Sf.isIP(e)?"":e}function Vf(t){return JSON.parse(JSON.stringify(t))}function qf(t){return t!=null&&typeof t[Symbol.asyncIterator]=="function"}function Ql(t){return t!=null&&(typeof t[Symbol.iterator]=="function"||typeof t[Symbol.asyncIterator]=="function")}function Bl(t){if(t==null)return 0;if(Xs(t)){let e=t._readableState;return e&&e.objectMode===!1&&e.ended===!0&&Number.isFinite(e.length)?e.length:null}else{if(ll(t))return t.size!=null?t.size:null;if(Cl(t))return t.byteLength}return null}function dl(t){return t&&!!(t.destroyed||t[gl]||js.isDestroyed?.(t))}function Wf(t,e){t==null||!Xs(t)||dl(t)||(typeof t.destroy=="function"?(Object.getPrototypeOf(t).constructor===Ff&&(t.socket=null),t.destroy(e)):e&&queueMicrotask(()=>{t.emit("error",e)}),t.destroyed!==!0&&(t[gl]=!0))}var zf=/timeout=(\d+)/;function Zf(t){let e=t.toString().match(zf);return e?parseInt(e[1],10)*1e3:null}function Il(t){return typeof t=="string"?Lf[t]??t.toLowerCase():ul.lookup(t)??t.toString("latin1").toLowerCase()}function Kf(t){return ul.lookup(t)??t.toString("latin1").toLowerCase()}function jf(t,e){e===void 0&&(e={});for(let r=0;rn.toString("utf8")):o.toString("utf8")}}return"content-length"in e&&"content-disposition"in e&&(e["content-disposition"]=Buffer.from(e["content-disposition"]).toString("latin1")),e}function Xf(t){let e=t.length,r=new Array(e),A=!1,s=-1,o,n,i=0;for(let a=0;a{r.close(),r.byobRequest?.respond(0)});else{let o=Buffer.isBuffer(s)?s:Buffer.from(s);o.byteLength&&r.enqueue(new Uint8Array(o))}return r.desiredSize>0},async cancel(r){await e.return()},type:"bytes"})}function om(t){return t&&typeof t=="object"&&typeof t.append=="function"&&typeof t.delete=="function"&&typeof t.get=="function"&&typeof t.getAll=="function"&&typeof t.has=="function"&&typeof t.set=="function"&&t[Symbol.toStringTag]==="FormData"}function nm(t,e){return"addEventListener"in t?(t.addEventListener("abort",e,{once:!0}),()=>t.removeEventListener("abort",e)):(t.addListener("abort",e),()=>t.removeListener("abort",e))}var im=typeof String.prototype.toWellFormed=="function",am=typeof String.prototype.isWellFormed=="function";function pl(t){return im?`${t}`.toWellFormed():Nf.toUSVString(t)}function cm(t){return am?`${t}`.isWellFormed():pl(t)===`${t}`}function fl(t){switch(t){case 34:case 40:case 41:case 44:case 47:case 58:case 59:case 60:case 61:case 62:case 63:case 64:case 91:case 92:case 93:case 123:case 125:return!1;default:return t>=33&&t<=126}}function gm(t){if(t.length===0)return!1;for(let e=0;e{"use strict";var z=require("node:diagnostics_channel"),Mi=require("node:util"),$s=Mi.debuglog("undici"),Gi=Mi.debuglog("fetch"),Ar=Mi.debuglog("websocket"),bl=!1,dm={beforeConnect:z.channel("undici:client:beforeConnect"),connected:z.channel("undici:client:connected"),connectError:z.channel("undici:client:connectError"),sendHeaders:z.channel("undici:client:sendHeaders"),create:z.channel("undici:request:create"),bodySent:z.channel("undici:request:bodySent"),headers:z.channel("undici:request:headers"),trailers:z.channel("undici:request:trailers"),error:z.channel("undici:request:error"),open:z.channel("undici:websocket:open"),close:z.channel("undici:websocket:close"),socketError:z.channel("undici:websocket:socket_error"),ping:z.channel("undici:websocket:ping"),pong:z.channel("undici:websocket:pong")};if($s.enabled||Gi.enabled){let t=Gi.enabled?Gi:$s;z.channel("undici:client:beforeConnect").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o}}=e;t("connecting to %s using %s%s",`${o}${s?`:${s}`:""}`,A,r)}),z.channel("undici:client:connected").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o}}=e;t("connected to %s using %s%s",`${o}${s?`:${s}`:""}`,A,r)}),z.channel("undici:client:connectError").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o},error:n}=e;t("connection to %s using %s%s errored - %s",`${o}${s?`:${s}`:""}`,A,r,n.message)}),z.channel("undici:client:sendHeaders").subscribe(e=>{let{request:{method:r,path:A,origin:s}}=e;t("sending request to %s %s/%s",r,s,A)}),z.channel("undici:request:headers").subscribe(e=>{let{request:{method:r,path:A,origin:s},response:{statusCode:o}}=e;t("received response to %s %s/%s - HTTP %d",r,s,A,o)}),z.channel("undici:request:trailers").subscribe(e=>{let{request:{method:r,path:A,origin:s}}=e;t("trailers received from %s %s/%s",r,s,A)}),z.channel("undici:request:error").subscribe(e=>{let{request:{method:r,path:A,origin:s},error:o}=e;t("request to %s %s/%s errored - %s",r,s,A,o.message)}),bl=!0}if(Ar.enabled){if(!bl){let t=$s.enabled?$s:Ar;z.channel("undici:client:beforeConnect").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o}}=e;t("connecting to %s%s using %s%s",o,s?`:${s}`:"",A,r)}),z.channel("undici:client:connected").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o}}=e;t("connected to %s%s using %s%s",o,s?`:${s}`:"",A,r)}),z.channel("undici:client:connectError").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o},error:n}=e;t("connection to %s%s using %s%s errored - %s",o,s?`:${s}`:"",A,r,n.message)}),z.channel("undici:client:sendHeaders").subscribe(e=>{let{request:{method:r,path:A,origin:s}}=e;t("sending request to %s %s/%s",r,s,A)})}z.channel("undici:websocket:open").subscribe(t=>{let{address:{address:e,port:r}}=t;Ar("connection opened %s%s",e,r?`:${r}`:"")}),z.channel("undici:websocket:close").subscribe(t=>{let{websocket:e,code:r,reason:A}=t;Ar("closed connection to %s - %s %s",e.url,r,A)}),z.channel("undici:websocket:socket_error").subscribe(t=>{Ar("connection errored - %s",t.message)}),z.channel("undici:websocket:ping").subscribe(t=>{Ar("ping received")}),z.channel("undici:websocket:pong").subscribe(t=>{Ar("pong received")})}kl.exports={channels:dm}});var Fl=m((LM,Tl)=>{"use strict";var{InvalidArgumentError:ee,NotSupportedError:Im}=q(),ft=require("node:assert"),{isValidHTTPToken:Rl,isValidHeaderValue:Li,isStream:Cm,destroy:pm,isBuffer:fm,isFormDataLike:mm,isIterable:wm,isBlobLike:ym,buildURL:bm,validateHandler:km,getServerName:Dm,normalizedMethodRecords:Rm}=J(),{channels:it}=Lr(),{headerNameLowerCasedRecord:Dl}=Ws(),Tm=/[^\u0021-\u00ff]/,He=Symbol("handler"),vi=class{constructor(e,{path:r,method:A,body:s,headers:o,query:n,idempotent:i,blocking:a,upgrade:c,headersTimeout:l,bodyTimeout:g,reset:E,throwOnError:d,expectContinue:B,servername:p},w){if(typeof r!="string")throw new ee("path must be a string");if(r[0]!=="/"&&!(r.startsWith("http://")||r.startsWith("https://"))&&A!=="CONNECT")throw new ee("path must be an absolute URL or start with a slash");if(Tm.test(r))throw new ee("invalid request path");if(typeof A!="string")throw new ee("method must be a string");if(Rm[A]===void 0&&!Rl(A))throw new ee("invalid request method");if(c&&typeof c!="string")throw new ee("upgrade must be a string");if(c&&!Li(c))throw new ee("invalid upgrade header");if(l!=null&&(!Number.isFinite(l)||l<0))throw new ee("invalid headersTimeout");if(g!=null&&(!Number.isFinite(g)||g<0))throw new ee("invalid bodyTimeout");if(E!=null&&typeof E!="boolean")throw new ee("invalid reset");if(B!=null&&typeof B!="boolean")throw new ee("invalid expectContinue");if(this.headersTimeout=l,this.bodyTimeout=g,this.throwOnError=d===!0,this.method=A,this.abort=null,s==null)this.body=null;else if(Cm(s)){this.body=s;let I=this.body._readableState;(!I||!I.autoDestroy)&&(this.endHandler=function(){pm(this)},this.body.on("end",this.endHandler)),this.errorHandler=y=>{this.abort?this.abort(y):this.error=y},this.body.on("error",this.errorHandler)}else if(fm(s))this.body=s.byteLength?s:null;else if(ArrayBuffer.isView(s))this.body=s.buffer.byteLength?Buffer.from(s.buffer,s.byteOffset,s.byteLength):null;else if(s instanceof ArrayBuffer)this.body=s.byteLength?Buffer.from(s):null;else if(typeof s=="string")this.body=s.length?Buffer.from(s):null;else if(mm(s)||wm(s)||ym(s))this.body=s;else throw new ee("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable");if(this.completed=!1,this.aborted=!1,this.upgrade=c||null,this.path=n?bm(r,n):r,this.origin=e,this.idempotent=i??(A==="HEAD"||A==="GET"),this.blocking=a??!1,this.reset=E??null,this.host=null,this.contentLength=null,this.contentType=null,this.headers=[],this.expectContinue=B??!1,Array.isArray(o)){if(o.length%2!==0)throw new ee("headers array must be even");for(let I=0;I{"use strict";var Fm=require("node:events"),to=class extends Fm{dispatch(){throw new Error("not implemented")}close(){throw new Error("not implemented")}destroy(){throw new Error("not implemented")}compose(...e){let r=Array.isArray(e[0])?e[0]:e,A=this.dispatch.bind(this);for(let s of r)if(s!=null){if(typeof s!="function")throw new TypeError(`invalid interceptor, expected function received ${typeof s}`);if(A=s(A),A==null||typeof A!="function"||A.length!==2)throw new TypeError("invalid interceptor")}return new _i(this,A)}},_i=class extends to{#e=null;#t=null;constructor(e,r){super(),this.#e=e,this.#t=r}dispatch(...e){this.#t(...e)}close(...e){return this.#e.close(...e)}destroy(...e){return this.#e.destroy(...e)}};Sl.exports=to});var Yr=m((_M,Ul)=>{"use strict";var Sm=vA(),{ClientDestroyedError:xi,ClientClosedError:Um,InvalidArgumentError:vr}=q(),{kDestroy:Nm,kClose:Gm,kClosed:_A,kDestroyed:_r,kDispatch:Yi,kInterceptors:sr}=se(),mt=Symbol("onDestroyed"),xr=Symbol("onClosed"),ro=Symbol("Intercepted Dispatch"),Ji=Symbol("webSocketOptions"),Oi=class extends Sm{constructor(e){super(),this[_r]=!1,this[mt]=null,this[_A]=!1,this[xr]=[],this[Ji]=e?.webSocket??{}}get webSocketOptions(){return{maxFragments:this[Ji].maxFragments??131072,maxPayloadSize:this[Ji].maxPayloadSize??128*1024*1024}}get destroyed(){return this[_r]}get closed(){return this[_A]}get interceptors(){return this[sr]}set interceptors(e){if(e){for(let r=e.length-1;r>=0;r--)if(typeof this[sr][r]!="function")throw new vr("interceptor must be an function")}this[sr]=e}close(e){if(e===void 0)return new Promise((A,s)=>{this.close((o,n)=>o?s(o):A(n))});if(typeof e!="function")throw new vr("invalid callback");if(this[_r]){queueMicrotask(()=>e(new xi,null));return}if(this[_A]){this[xr]?this[xr].push(e):queueMicrotask(()=>e(null,null));return}this[_A]=!0,this[xr].push(e);let r=()=>{let A=this[xr];this[xr]=null;for(let s=0;sthis.destroy()).then(()=>{queueMicrotask(r)})}destroy(e,r){if(typeof e=="function"&&(r=e,e=null),r===void 0)return new Promise((s,o)=>{this.destroy(e,(n,i)=>n?o(n):s(i))});if(typeof r!="function")throw new vr("invalid callback");if(this[_r]){this[mt]?this[mt].push(r):queueMicrotask(()=>r(null,null));return}e||(e=new xi),this[_r]=!0,this[mt]=this[mt]||[],this[mt].push(r);let A=()=>{let s=this[mt];this[mt]=null;for(let o=0;o{queueMicrotask(A)})}[ro](e,r){if(!this[sr]||this[sr].length===0)return this[ro]=this[Yi],this[Yi](e,r);let A=this[Yi].bind(this);for(let s=this[sr].length-1;s>=0;s--)A=this[sr][s](A);return this[ro]=A,A(e,r)}dispatch(e,r){if(!r||typeof r!="object")throw new vr("handler must be an object");try{if(!e||typeof e!="object")throw new vr("opts must be an object.");if(this[_r]||this[mt])throw new xi;if(this[_A])throw new Um;return this[ro](e,r)}catch(A){if(typeof r.onError!="function")throw new vr("invalid onError method");return r.onError(A),!1}}};Ul.exports=Oi});var Zi=m((xM,Ll)=>{"use strict";var Jr=0,Hi=1e3,Pi=(Hi>>1)-1,wt,Vi=Symbol("kFastTimer"),yt=[],qi=-2,Wi=-1,Gl=0,Nl=1;function zi(){Jr+=Pi;let t=0,e=yt.length;for(;t=r._idleStart+r._idleTimeout&&(r._state=Wi,r._idleStart=-1,r._onTimeout(r._timerArg)),r._state===Wi?(r._state=qi,--e!==0&&(yt[t]=yt[e])):++t}yt.length=e,yt.length!==0&&Ml()}function Ml(){wt?wt.refresh():(clearTimeout(wt),wt=setTimeout(zi,Pi),wt.unref&&wt.unref())}var Ao=class{[Vi]=!0;_state=qi;_idleTimeout=-1;_idleStart=-1;_onTimeout;_timerArg;constructor(e,r,A){this._onTimeout=e,this._idleTimeout=r,this._timerArg=A,this.refresh()}refresh(){this._state===qi&&yt.push(this),(!wt||yt.length===1)&&Ml(),this._state=Gl}clear(){this._state=Wi,this._idleStart=-1}};Ll.exports={setTimeout(t,e,r){return e<=Hi?setTimeout(t,e,r):new Ao(t,e,r)},clearTimeout(t){t[Vi]?t.clear():clearTimeout(t)},setFastTimeout(t,e,r){return new Ao(t,e,r)},clearFastTimeout(t){t.clear()},now(){return Jr},tick(t=0){Jr+=t-Hi+1,zi(),zi()},reset(){Jr=0,yt.length=0,clearTimeout(wt),wt=null},kFastTimer:Vi}});var xA=m((OM,Jl)=>{"use strict";var Mm=require("node:net"),vl=require("node:assert"),Yl=J(),{InvalidArgumentError:Lm,ConnectTimeoutError:vm}=q(),so=Zi();function _l(){}var Ki,ji;global.FinalizationRegistry&&!(process.env.NODE_V8_COVERAGE||process.env.UNDICI_NO_FG)?ji=class{constructor(e){this._maxCachedSessions=e,this._sessionCache=new Map,this._sessionRegistry=new global.FinalizationRegistry(r=>{if(this._sessionCache.size=this._maxCachedSessions){let{value:A}=this._sessionCache.keys().next();this._sessionCache.delete(A)}this._sessionCache.set(e,r)}}};function _m({allowH2:t,maxCachedSessions:e,socketPath:r,timeout:A,session:s,...o}){if(e!=null&&(!Number.isInteger(e)||e<0))throw new Lm("maxCachedSessions must be a positive integer or zero");let n={path:r,...o},i=new ji(e??100);return A=A??1e4,t=t??!1,function({hostname:c,host:l,protocol:g,port:E,servername:d,localAddress:B,httpSocket:p},w){let I;if(g==="https:"){Ki||(Ki=require("node:tls")),d=d||n.servername||Yl.getServerName(l)||null;let T=d||c;vl(T);let S=s||i.get(T)||null;E=E||443,I=Ki.connect({highWaterMark:16384,...n,servername:d,session:S,localAddress:B,ALPNProtocols:t?["http/1.1","h2"]:["http/1.1"],socket:p,port:E,host:c}),I.on("session",function(O){i.set(T,O)})}else vl(!p,"httpSocket can only be sent on TLS update"),E=E||80,I=Mm.connect({highWaterMark:64*1024,...n,localAddress:B,port:E,host:c});if(n.keepAlive==null||n.keepAlive){let T=n.keepAliveInitialDelay===void 0?6e4:n.keepAliveInitialDelay;I.setKeepAlive(!0,T)}let y=xm(new WeakRef(I),{timeout:A,hostname:c,port:E});return I.setNoDelay(!0).once(g==="https:"?"secureConnect":"connect",function(){if(queueMicrotask(y),w){let T=w;w=null,T(null,this)}}).on("error",function(T){if(queueMicrotask(y),w){let S=w;w=null,S(T)}}),I}}var xm=process.platform==="win32"?(t,e)=>{if(!e.timeout)return _l;let r=null,A=null,s=so.setFastTimeout(()=>{r=setImmediate(()=>{A=setImmediate(()=>xl(t.deref(),e))})},e.timeout);return()=>{so.clearFastTimeout(s),clearImmediate(r),clearImmediate(A)}}:(t,e)=>{if(!e.timeout)return _l;let r=null,A=so.setFastTimeout(()=>{r=setImmediate(()=>{xl(t.deref(),e)})},e.timeout);return()=>{so.clearFastTimeout(A),clearImmediate(r)}};function xl(t,e){if(t==null)return;let r="Connect Timeout Error";Array.isArray(t.autoSelectFamilyAttemptedAddresses)?r+=` (attempted addresses: ${t.autoSelectFamilyAttemptedAddresses.join(", ")},`:r+=` (attempted address: ${e.hostname}:${e.port},`,r+=` timeout: ${e.timeout}ms)`,Yl.destroy(t,new vm(r))}Jl.exports=_m});var Ol=m(oo=>{"use strict";Object.defineProperty(oo,"__esModule",{value:!0});oo.enumToMap=void 0;function Ym(t){let e={};return Object.keys(t).forEach(r=>{let A=t[r];typeof A=="number"&&(e[r]=A)}),e}oo.enumToMap=Ym});var Hl=m(k=>{"use strict";Object.defineProperty(k,"__esModule",{value:!0});k.SPECIAL_HEADERS=k.HEADER_STATE=k.MINOR=k.MAJOR=k.CONNECTION_TOKEN_CHARS=k.HEADER_CHARS=k.TOKEN=k.STRICT_TOKEN=k.HEX=k.URL_CHAR=k.STRICT_URL_CHAR=k.USERINFO_CHARS=k.MARK=k.ALPHANUM=k.NUM=k.HEX_MAP=k.NUM_MAP=k.ALPHA=k.FINISH=k.H_METHOD_MAP=k.METHOD_MAP=k.METHODS_RTSP=k.METHODS_ICE=k.METHODS_HTTP=k.METHODS=k.LENIENT_FLAGS=k.FLAGS=k.TYPE=k.ERROR=void 0;var Jm=Ol(),Om;(function(t){t[t.OK=0]="OK",t[t.INTERNAL=1]="INTERNAL",t[t.STRICT=2]="STRICT",t[t.LF_EXPECTED=3]="LF_EXPECTED",t[t.UNEXPECTED_CONTENT_LENGTH=4]="UNEXPECTED_CONTENT_LENGTH",t[t.CLOSED_CONNECTION=5]="CLOSED_CONNECTION",t[t.INVALID_METHOD=6]="INVALID_METHOD",t[t.INVALID_URL=7]="INVALID_URL",t[t.INVALID_CONSTANT=8]="INVALID_CONSTANT",t[t.INVALID_VERSION=9]="INVALID_VERSION",t[t.INVALID_HEADER_TOKEN=10]="INVALID_HEADER_TOKEN",t[t.INVALID_CONTENT_LENGTH=11]="INVALID_CONTENT_LENGTH",t[t.INVALID_CHUNK_SIZE=12]="INVALID_CHUNK_SIZE",t[t.INVALID_STATUS=13]="INVALID_STATUS",t[t.INVALID_EOF_STATE=14]="INVALID_EOF_STATE",t[t.INVALID_TRANSFER_ENCODING=15]="INVALID_TRANSFER_ENCODING",t[t.CB_MESSAGE_BEGIN=16]="CB_MESSAGE_BEGIN",t[t.CB_HEADERS_COMPLETE=17]="CB_HEADERS_COMPLETE",t[t.CB_MESSAGE_COMPLETE=18]="CB_MESSAGE_COMPLETE",t[t.CB_CHUNK_HEADER=19]="CB_CHUNK_HEADER",t[t.CB_CHUNK_COMPLETE=20]="CB_CHUNK_COMPLETE",t[t.PAUSED=21]="PAUSED",t[t.PAUSED_UPGRADE=22]="PAUSED_UPGRADE",t[t.PAUSED_H2_UPGRADE=23]="PAUSED_H2_UPGRADE",t[t.USER=24]="USER"})(Om=k.ERROR||(k.ERROR={}));var Hm;(function(t){t[t.BOTH=0]="BOTH",t[t.REQUEST=1]="REQUEST",t[t.RESPONSE=2]="RESPONSE"})(Hm=k.TYPE||(k.TYPE={}));var Pm;(function(t){t[t.CONNECTION_KEEP_ALIVE=1]="CONNECTION_KEEP_ALIVE",t[t.CONNECTION_CLOSE=2]="CONNECTION_CLOSE",t[t.CONNECTION_UPGRADE=4]="CONNECTION_UPGRADE",t[t.CHUNKED=8]="CHUNKED",t[t.UPGRADE=16]="UPGRADE",t[t.CONTENT_LENGTH=32]="CONTENT_LENGTH",t[t.SKIPBODY=64]="SKIPBODY",t[t.TRAILING=128]="TRAILING",t[t.TRANSFER_ENCODING=512]="TRANSFER_ENCODING"})(Pm=k.FLAGS||(k.FLAGS={}));var Vm;(function(t){t[t.HEADERS=1]="HEADERS",t[t.CHUNKED_LENGTH=2]="CHUNKED_LENGTH",t[t.KEEP_ALIVE=4]="KEEP_ALIVE"})(Vm=k.LENIENT_FLAGS||(k.LENIENT_FLAGS={}));var M;(function(t){t[t.DELETE=0]="DELETE",t[t.GET=1]="GET",t[t.HEAD=2]="HEAD",t[t.POST=3]="POST",t[t.PUT=4]="PUT",t[t.CONNECT=5]="CONNECT",t[t.OPTIONS=6]="OPTIONS",t[t.TRACE=7]="TRACE",t[t.COPY=8]="COPY",t[t.LOCK=9]="LOCK",t[t.MKCOL=10]="MKCOL",t[t.MOVE=11]="MOVE",t[t.PROPFIND=12]="PROPFIND",t[t.PROPPATCH=13]="PROPPATCH",t[t.SEARCH=14]="SEARCH",t[t.UNLOCK=15]="UNLOCK",t[t.BIND=16]="BIND",t[t.REBIND=17]="REBIND",t[t.UNBIND=18]="UNBIND",t[t.ACL=19]="ACL",t[t.REPORT=20]="REPORT",t[t.MKACTIVITY=21]="MKACTIVITY",t[t.CHECKOUT=22]="CHECKOUT",t[t.MERGE=23]="MERGE",t[t["M-SEARCH"]=24]="M-SEARCH",t[t.NOTIFY=25]="NOTIFY",t[t.SUBSCRIBE=26]="SUBSCRIBE",t[t.UNSUBSCRIBE=27]="UNSUBSCRIBE",t[t.PATCH=28]="PATCH",t[t.PURGE=29]="PURGE",t[t.MKCALENDAR=30]="MKCALENDAR",t[t.LINK=31]="LINK",t[t.UNLINK=32]="UNLINK",t[t.SOURCE=33]="SOURCE",t[t.PRI=34]="PRI",t[t.DESCRIBE=35]="DESCRIBE",t[t.ANNOUNCE=36]="ANNOUNCE",t[t.SETUP=37]="SETUP",t[t.PLAY=38]="PLAY",t[t.PAUSE=39]="PAUSE",t[t.TEARDOWN=40]="TEARDOWN",t[t.GET_PARAMETER=41]="GET_PARAMETER",t[t.SET_PARAMETER=42]="SET_PARAMETER",t[t.REDIRECT=43]="REDIRECT",t[t.RECORD=44]="RECORD",t[t.FLUSH=45]="FLUSH"})(M=k.METHODS||(k.METHODS={}));k.METHODS_HTTP=[M.DELETE,M.GET,M.HEAD,M.POST,M.PUT,M.CONNECT,M.OPTIONS,M.TRACE,M.COPY,M.LOCK,M.MKCOL,M.MOVE,M.PROPFIND,M.PROPPATCH,M.SEARCH,M.UNLOCK,M.BIND,M.REBIND,M.UNBIND,M.ACL,M.REPORT,M.MKACTIVITY,M.CHECKOUT,M.MERGE,M["M-SEARCH"],M.NOTIFY,M.SUBSCRIBE,M.UNSUBSCRIBE,M.PATCH,M.PURGE,M.MKCALENDAR,M.LINK,M.UNLINK,M.PRI,M.SOURCE];k.METHODS_ICE=[M.SOURCE];k.METHODS_RTSP=[M.OPTIONS,M.DESCRIBE,M.ANNOUNCE,M.SETUP,M.PLAY,M.PAUSE,M.TEARDOWN,M.GET_PARAMETER,M.SET_PARAMETER,M.REDIRECT,M.RECORD,M.FLUSH,M.GET,M.POST];k.METHOD_MAP=Jm.enumToMap(M);k.H_METHOD_MAP={};Object.keys(k.METHOD_MAP).forEach(t=>{/^H/.test(t)&&(k.H_METHOD_MAP[t]=k.METHOD_MAP[t])});var qm;(function(t){t[t.SAFE=0]="SAFE",t[t.SAFE_WITH_CB=1]="SAFE_WITH_CB",t[t.UNSAFE=2]="UNSAFE"})(qm=k.FINISH||(k.FINISH={}));k.ALPHA=[];for(let t=65;t<=90;t++)k.ALPHA.push(String.fromCharCode(t)),k.ALPHA.push(String.fromCharCode(t+32));k.NUM_MAP={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9};k.HEX_MAP={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,A:10,B:11,C:12,D:13,E:14,F:15,a:10,b:11,c:12,d:13,e:14,f:15};k.NUM=["0","1","2","3","4","5","6","7","8","9"];k.ALPHANUM=k.ALPHA.concat(k.NUM);k.MARK=["-","_",".","!","~","*","'","(",")"];k.USERINFO_CHARS=k.ALPHANUM.concat(k.MARK).concat(["%",";",":","&","=","+","$",","]);k.STRICT_URL_CHAR=["!",'"',"$","%","&","'","(",")","*","+",",","-",".","/",":",";","<","=",">","@","[","\\","]","^","_","`","{","|","}","~"].concat(k.ALPHANUM);k.URL_CHAR=k.STRICT_URL_CHAR.concat([" ","\f"]);for(let t=128;t<=255;t++)k.URL_CHAR.push(t);k.HEX=k.NUM.concat(["a","b","c","d","e","f","A","B","C","D","E","F"]);k.STRICT_TOKEN=["!","#","$","%","&","'","*","+","-",".","^","_","`","|","~"].concat(k.ALPHANUM);k.TOKEN=k.STRICT_TOKEN.concat([" "]);k.HEADER_CHARS=[" "];for(let t=32;t<=255;t++)t!==127&&k.HEADER_CHARS.push(t);k.CONNECTION_TOKEN_CHARS=k.HEADER_CHARS.filter(t=>t!==44);k.MAJOR=k.NUM_MAP;k.MINOR=k.MAJOR;var Or;(function(t){t[t.GENERAL=0]="GENERAL",t[t.CONNECTION=1]="CONNECTION",t[t.CONTENT_LENGTH=2]="CONTENT_LENGTH",t[t.TRANSFER_ENCODING=3]="TRANSFER_ENCODING",t[t.UPGRADE=4]="UPGRADE",t[t.CONNECTION_KEEP_ALIVE=5]="CONNECTION_KEEP_ALIVE",t[t.CONNECTION_CLOSE=6]="CONNECTION_CLOSE",t[t.CONNECTION_UPGRADE=7]="CONNECTION_UPGRADE",t[t.TRANSFER_ENCODING_CHUNKED=8]="TRANSFER_ENCODING_CHUNKED"})(Or=k.HEADER_STATE||(k.HEADER_STATE={}));k.SPECIAL_HEADERS={connection:Or.CONNECTION,"content-length":Or.CONTENT_LENGTH,"proxy-connection":Or.CONNECTION,"transfer-encoding":Or.TRANSFER_ENCODING,upgrade:Or.UPGRADE}});var Xi=m((VM,Pl)=>{"use strict";var{Buffer:Wm}=require("node:buffer");Pl.exports=Wm.from("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","base64")});var ql=m((qM,Vl)=>{"use strict";var{Buffer:zm}=require("node:buffer");Vl.exports=zm.from("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","base64")});var YA=m((WM,eE)=>{"use strict";var Wl=["GET","HEAD","POST"],Zm=new Set(Wl),Km=[101,204,205,304],zl=[301,302,303,307,308],jm=new Set(zl),Zl=["1","7","9","11","13","15","17","19","20","21","22","23","25","37","42","43","53","69","77","79","87","95","101","102","103","104","109","110","111","113","115","117","119","123","135","137","139","143","161","179","389","427","465","512","513","514","515","526","530","531","532","540","548","554","556","563","587","601","636","989","990","993","995","1719","1720","1723","2049","3659","4045","4190","5060","5061","6000","6566","6665","6666","6667","6668","6669","6679","6697","10080"],Xm=new Set(Zl),Kl=["","no-referrer","no-referrer-when-downgrade","same-origin","origin","strict-origin","origin-when-cross-origin","strict-origin-when-cross-origin","unsafe-url"],$m=new Set(Kl),ew=["follow","manual","error"],jl=["GET","HEAD","OPTIONS","TRACE"],tw=new Set(jl),rw=["navigate","same-origin","no-cors","cors"],Aw=["omit","same-origin","include"],sw=["default","no-store","reload","no-cache","force-cache","only-if-cached"],ow=["content-encoding","content-language","content-location","content-type","content-length"],nw=["half"],Xl=["CONNECT","TRACE","TRACK"],iw=new Set(Xl),$l=["audio","audioworklet","font","image","manifest","paintworklet","script","style","track","video","xslt",""],aw=new Set($l);eE.exports={subresource:$l,forbiddenMethods:Xl,requestBodyHeader:ow,referrerPolicy:Kl,requestRedirect:ew,requestMode:rw,requestCredentials:Aw,requestCache:sw,redirectStatus:zl,corsSafeListedMethods:Wl,nullBodyStatus:Km,safeMethods:jl,badPorts:Zl,requestDuplex:nw,subresourceSet:aw,badPortsSet:Xm,redirectStatusSet:jm,corsSafeListedMethodsSet:Zm,safeMethodsSet:tw,forbiddenMethodsSet:iw,referrerPolicySet:$m}});var ea=m((zM,tE)=>{"use strict";var $i=Symbol.for("undici.globalOrigin.1");function cw(){return globalThis[$i]}function gw(t){if(t===void 0){Object.defineProperty(globalThis,$i,{value:void 0,writable:!0,enumerable:!1,configurable:!1});return}let e=new URL(t);if(e.protocol!=="http:"&&e.protocol!=="https:")throw new TypeError(`Only http & https urls are allowed, received ${e.protocol}`);Object.defineProperty(globalThis,$i,{value:e,writable:!0,enumerable:!1,configurable:!1})}tE.exports={getGlobalOrigin:cw,setGlobalOrigin:gw}});var ye=m((ZM,aE)=>{"use strict";var io=require("node:assert"),uw=new TextEncoder,JA=/^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/,lw=/[\u000A\u000D\u0009\u0020]/,Ew=/[\u0009\u000A\u000C\u000D\u0020]/g,hw=/^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;function Qw(t){io(t.protocol==="data:");let e=sE(t,!0);e=e.slice(5);let r={position:0},A=Hr(",",e,r),s=A.length;if(A=fw(A,!0,!0),r.position>=e.length)return"failure";r.position++;let o=e.slice(s+1),n=oE(o);if(/;(\u0020){0,}base64$/i.test(A)){let a=iE(n);if(n=dw(a),n==="failure")return"failure";A=A.slice(0,-6),A=A.replace(/(\u0020)+$/,""),A=A.slice(0,-1)}A.startsWith(";")&&(A="text/plain"+A);let i=ta(A);return i==="failure"&&(i=ta("text/plain;charset=US-ASCII")),{mimeType:i,body:n}}function sE(t,e=!1){if(!e)return t.href;let r=t.href,A=t.hash.length,s=A===0?r:r.substring(0,r.length-A);return!A&&r.endsWith("#")?s.slice(0,-1):s}function ao(t,e,r){let A="";for(;r.position=48&&t<=57||t>=65&&t<=70||t>=97&&t<=102}function AE(t){return t>=48&&t<=57?t-48:(t&223)-55}function Bw(t){let e=t.length,r=new Uint8Array(e),A=0;for(let s=0;st.length)return"failure";e.position++;let A=Hr(";",t,e);if(A=no(A,!1,!0),A.length===0||!JA.test(A))return"failure";let s=r.toLowerCase(),o=A.toLowerCase(),n={type:s,subtype:o,parameters:new Map,essence:`${s}/${o}`};for(;e.positionlw.test(c),t,e);let i=ao(c=>c!==";"&&c!=="=",t,e);if(i=i.toLowerCase(),e.positiont.length)break;let a=null;if(t[e.position]==='"')a=nE(t,e,!0),Hr(";",t,e);else if(a=Hr(";",t,e),a=no(a,!1,!0),a.length===0)continue;i.length!==0&&JA.test(i)&&(a.length===0||hw.test(a))&&!n.parameters.has(i)&&n.parameters.set(i,a)}return n}function dw(t){t=t.replace(Ew,"");let e=t.length;if(e%4===0&&t.charCodeAt(e-1)===61&&(--e,t.charCodeAt(e-1)===61&&--e),e%4===1||/[^+/0-9A-Za-z]/.test(t.length===e?t:t.substring(0,e)))return"failure";let r=Buffer.from(t,"base64");return new Uint8Array(r.buffer,r.byteOffset,r.byteLength)}function nE(t,e,r){let A=e.position,s="";for(io(t[e.position]==='"'),e.position++;s+=ao(n=>n!=='"'&&n!=="\\",t,e),!(e.position>=t.length);){let o=t[e.position];if(e.position++,o==="\\"){if(e.position>=t.length){s+="\\";break}s+=t[e.position],e.position++}else{io(o==='"');break}}return r?s:t.slice(A,e.position)}function Iw(t){io(t!=="failure");let{parameters:e,essence:r}=t,A=r;for(let[s,o]of e.entries())A+=";",A+=s,A+="=",JA.test(o)||(o=o.replace(/(\\|")/g,"\\$1"),o='"'+o,o+='"'),A+=o;return A}function Cw(t){return t===13||t===10||t===9||t===32}function no(t,e=!0,r=!0){return ra(t,e,r,Cw)}function pw(t){return t===13||t===10||t===9||t===12||t===32}function fw(t,e=!0,r=!0){return ra(t,e,r,pw)}function ra(t,e,r,A){let s=0,o=t.length-1;if(e)for(;s0&&A(t.charCodeAt(o));)o--;return s===0&&o===t.length-1?t:t.slice(s,o+1)}function iE(t){let e=t.length;if(65535>e)return String.fromCharCode.apply(null,t);let r="",A=0,s=65535;for(;Ae&&(s=e-A),r+=String.fromCharCode.apply(null,t.subarray(A,A+=s));return r}function mw(t){switch(t.essence){case"application/ecmascript":case"application/javascript":case"application/x-ecmascript":case"application/x-javascript":case"text/ecmascript":case"text/javascript":case"text/javascript1.0":case"text/javascript1.1":case"text/javascript1.2":case"text/javascript1.3":case"text/javascript1.4":case"text/javascript1.5":case"text/jscript":case"text/livescript":case"text/x-ecmascript":case"text/x-javascript":return"text/javascript";case"application/json":case"text/json":return"application/json";case"image/svg+xml":return"image/svg+xml";case"text/xml":case"application/xml":return"application/xml"}return t.subtype.endsWith("+json")?"application/json":t.subtype.endsWith("+xml")?"application/xml":""}aE.exports={dataURLProcessor:Qw,URLSerializer:sE,collectASequenceOfCodePoints:ao,collectASequenceOfCodePointsFast:Hr,stringPercentDecode:oE,parseMIMEType:ta,collectAnHTTPQuotedString:nE,serializeAMimeType:Iw,removeChars:ra,removeHTTPWhitespace:no,minimizeSupportedMimeType:mw,HTTP_TOKEN_CODEPOINTS:JA,isomorphicDecode:iE}});var de=m((KM,cE)=>{"use strict";var{types:at,inspect:ww}=require("node:util"),{markAsUncloneable:yw}=require("node:worker_threads"),{toUSVString:bw}=J(),b={};b.converters={};b.util={};b.errors={};b.errors.exception=function(t){return new TypeError(`${t.header}: ${t.message}`)};b.errors.conversionFailed=function(t){let e=t.types.length===1?"":" one of",r=`${t.argument} could not be converted to${e}: ${t.types.join(", ")}.`;return b.errors.exception({header:t.prefix,message:r})};b.errors.invalidArgument=function(t){return b.errors.exception({header:t.prefix,message:`"${t.value}" is an invalid ${t.type}.`})};b.brandCheck=function(t,e,r){if(r?.strict!==!1){if(!(t instanceof e)){let A=new TypeError("Illegal invocation");throw A.code="ERR_INVALID_THIS",A}}else if(t?.[Symbol.toStringTag]!==e.prototype[Symbol.toStringTag]){let A=new TypeError("Illegal invocation");throw A.code="ERR_INVALID_THIS",A}};b.argumentLengthCheck=function({length:t},e,r){if(t{});b.util.ConvertToInt=function(t,e,r,A){let s,o;e===64?(s=Math.pow(2,53)-1,r==="unsigned"?o=0:o=Math.pow(-2,53)+1):r==="unsigned"?(o=0,s=Math.pow(2,e)-1):(o=Math.pow(-2,e)-1,s=Math.pow(2,e-1)-1);let n=Number(t);if(n===0&&(n=0),A?.enforceRange===!0){if(Number.isNaN(n)||n===Number.POSITIVE_INFINITY||n===Number.NEGATIVE_INFINITY)throw b.errors.exception({header:"Integer conversion",message:`Could not convert ${b.util.Stringify(t)} to an integer.`});if(n=b.util.IntegerPart(n),ns)throw b.errors.exception({header:"Integer conversion",message:`Value must be between ${o}-${s}, got ${n}.`});return n}return!Number.isNaN(n)&&A?.clamp===!0?(n=Math.min(Math.max(n,o),s),Math.floor(n)%2===0?n=Math.floor(n):n=Math.ceil(n),n):Number.isNaN(n)||n===0&&Object.is(0,n)||n===Number.POSITIVE_INFINITY||n===Number.NEGATIVE_INFINITY?0:(n=b.util.IntegerPart(n),n=n%Math.pow(2,e),r==="signed"&&n>=Math.pow(2,e)-1?n-Math.pow(2,e):n)};b.util.IntegerPart=function(t){let e=Math.floor(Math.abs(t));return t<0?-1*e:e};b.util.Stringify=function(t){switch(b.util.Type(t)){case"Symbol":return`Symbol(${t.description})`;case"Object":return ww(t);case"String":return`"${t}"`;default:return`${t}`}};b.sequenceConverter=function(t){return(e,r,A,s)=>{if(b.util.Type(e)!=="Object")throw b.errors.exception({header:r,message:`${A} (${b.util.Stringify(e)}) is not iterable.`});let o=typeof s=="function"?s():e?.[Symbol.iterator]?.(),n=[],i=0;if(o===void 0||typeof o.next!="function")throw b.errors.exception({header:r,message:`${A} is not iterable.`});for(;;){let{done:a,value:c}=o.next();if(a)break;n.push(t(c,r,`${A}[${i++}]`))}return n}};b.recordConverter=function(t,e){return(r,A,s)=>{if(b.util.Type(r)!=="Object")throw b.errors.exception({header:A,message:`${s} ("${b.util.Type(r)}") is not an Object.`});let o={};if(!at.isProxy(r)){let i=[...Object.getOwnPropertyNames(r),...Object.getOwnPropertySymbols(r)];for(let a of i){let c=t(a,A,s),l=e(r[a],A,s);o[c]=l}return o}let n=Reflect.ownKeys(r);for(let i of n)if(Reflect.getOwnPropertyDescriptor(r,i)?.enumerable){let c=t(i,A,s),l=e(r[i],A,s);o[c]=l}return o}};b.interfaceConverter=function(t){return(e,r,A,s)=>{if(s?.strict!==!1&&!(e instanceof t))throw b.errors.exception({header:r,message:`Expected ${A} ("${b.util.Stringify(e)}") to be an instance of ${t.name}.`});return e}};b.dictionaryConverter=function(t){return(e,r,A)=>{let s=b.util.Type(e),o={};if(s==="Null"||s==="Undefined")return o;if(s!=="Object")throw b.errors.exception({header:r,message:`Expected ${e} to be one of: Null, Undefined, Object.`});for(let n of t){let{key:i,defaultValue:a,required:c,converter:l}=n;if(c===!0&&!Object.hasOwn(e,i))throw b.errors.exception({header:r,message:`Missing required key "${i}".`});let g=e[i],E=Object.hasOwn(n,"defaultValue");if(E&&g!==null&&(g??=a()),c||E||g!==void 0){if(g=l(g,r,`${A}.${i}`),n.allowedValues&&!n.allowedValues.includes(g))throw b.errors.exception({header:r,message:`${g} is not an accepted type. Expected one of ${n.allowedValues.join(", ")}.`});o[i]=g}}return o}};b.nullableConverter=function(t){return(e,r,A)=>e===null?e:t(e,r,A)};b.converters.DOMString=function(t,e,r,A){if(t===null&&A?.legacyNullToEmptyString)return"";if(typeof t=="symbol")throw b.errors.exception({header:e,message:`${r} is a symbol, which cannot be converted to a DOMString.`});return String(t)};b.converters.ByteString=function(t,e,r){let A=b.converters.DOMString(t,e,r);for(let s=0;s255)throw new TypeError(`Cannot convert argument to a ByteString because the character at index ${s} has a value of ${A.charCodeAt(s)} which is greater than 255.`);return A};b.converters.USVString=bw;b.converters.boolean=function(t){return!!t};b.converters.any=function(t){return t};b.converters["long long"]=function(t,e,r){return b.util.ConvertToInt(t,64,"signed",void 0,e,r)};b.converters["unsigned long long"]=function(t,e,r){return b.util.ConvertToInt(t,64,"unsigned",void 0,e,r)};b.converters["unsigned long"]=function(t,e,r){return b.util.ConvertToInt(t,32,"unsigned",void 0,e,r)};b.converters["unsigned short"]=function(t,e,r,A){return b.util.ConvertToInt(t,16,"unsigned",A,e,r)};b.converters.ArrayBuffer=function(t,e,r,A){if(b.util.Type(t)!=="Object"||!at.isAnyArrayBuffer(t))throw b.errors.conversionFailed({prefix:e,argument:`${r} ("${b.util.Stringify(t)}")`,types:["ArrayBuffer"]});if(A?.allowShared===!1&&at.isSharedArrayBuffer(t))throw b.errors.exception({header:"ArrayBuffer",message:"SharedArrayBuffer is not allowed."});if(t.resizable||t.growable)throw b.errors.exception({header:"ArrayBuffer",message:"Received a resizable ArrayBuffer."});return t};b.converters.TypedArray=function(t,e,r,A,s){if(b.util.Type(t)!=="Object"||!at.isTypedArray(t)||t.constructor.name!==e.name)throw b.errors.conversionFailed({prefix:r,argument:`${A} ("${b.util.Stringify(t)}")`,types:[e.name]});if(s?.allowShared===!1&&at.isSharedArrayBuffer(t.buffer))throw b.errors.exception({header:"ArrayBuffer",message:"SharedArrayBuffer is not allowed."});if(t.buffer.resizable||t.buffer.growable)throw b.errors.exception({header:"ArrayBuffer",message:"Received a resizable ArrayBuffer."});return t};b.converters.DataView=function(t,e,r,A){if(b.util.Type(t)!=="Object"||!at.isDataView(t))throw b.errors.exception({header:e,message:`${r} is not a DataView.`});if(A?.allowShared===!1&&at.isSharedArrayBuffer(t.buffer))throw b.errors.exception({header:"ArrayBuffer",message:"SharedArrayBuffer is not allowed."});if(t.buffer.resizable||t.buffer.growable)throw b.errors.exception({header:"ArrayBuffer",message:"Received a resizable ArrayBuffer."});return t};b.converters.BufferSource=function(t,e,r,A){if(at.isAnyArrayBuffer(t))return b.converters.ArrayBuffer(t,e,r,{...A,allowShared:!1});if(at.isTypedArray(t))return b.converters.TypedArray(t,t.constructor,e,r,{...A,allowShared:!1});if(at.isDataView(t))return b.converters.DataView(t,e,r,{...A,allowShared:!1});throw b.errors.conversionFailed({prefix:e,argument:`${r} ("${b.util.Stringify(t)}")`,types:["BufferSource"]})};b.converters["sequence"]=b.sequenceConverter(b.converters.ByteString);b.converters["sequence>"]=b.sequenceConverter(b.converters["sequence"]);b.converters["record"]=b.recordConverter(b.converters.ByteString,b.converters.ByteString);cE.exports={webidl:b}});var Fe=m((jM,wE)=>{"use strict";var{Transform:kw}=require("node:stream"),gE=require("node:zlib"),{redirectStatusSet:Dw,referrerPolicySet:Rw,badPortsSet:Tw}=YA(),{getGlobalOrigin:uE}=ea(),{collectASequenceOfCodePoints:or,collectAnHTTPQuotedString:Fw,removeChars:Sw,parseMIMEType:Uw}=ye(),{performance:Nw}=require("node:perf_hooks"),{isBlobLike:Gw,ReadableStreamFrom:Mw,isValidHTTPToken:lE,normalizedMethodRecordsBase:Lw}=J(),nr=require("node:assert"),{isUint8Array:vw}=require("node:util/types"),{webidl:OA}=de(),EE=[],go;try{go=require("node:crypto");let t=["sha256","sha384","sha512"];EE=go.getHashes().filter(e=>t.includes(e))}catch{}function hE(t){let e=t.urlList,r=e.length;return r===0?null:e[r-1].toString()}function _w(t,e){if(!Dw.has(t.status))return null;let r=t.headersList.get("location",!0);return r!==null&&BE(r)&&(QE(r)||(r=xw(r)),r=new URL(r,hE(t))),r&&!r.hash&&(r.hash=e),r}function QE(t){for(let e=0;e126||r<32)return!1}return!0}function xw(t){return Buffer.from(t,"binary").toString("utf8")}function PA(t){return t.urlList[t.urlList.length-1]}function Yw(t){let e=PA(t);return fE(e)&&Tw.has(e.port)?"blocked":"allowed"}function Jw(t){return t instanceof Error||t?.constructor?.name==="Error"||t?.constructor?.name==="DOMException"}function Ow(t){for(let e=0;e=32&&r<=126||r>=128&&r<=255))return!1}return!0}var Hw=lE;function BE(t){return(t[0]===" "||t[0]===" "||t[t.length-1]===" "||t[t.length-1]===" "||t.includes(` -`)||t.includes("\r")||t.includes("\0"))===!1}function Pw(t,e){let{headersList:r}=e,A=(r.get("referrer-policy",!0)??"").split(","),s="";if(A.length>0)for(let o=A.length;o!==0;o--){let n=A[o-1].trim();if(Rw.has(n)){s=n;break}}s!==""&&(t.referrerPolicy=s)}function Vw(){return"allowed"}function qw(){return"success"}function Ww(){return"success"}function zw(t){let e=null;e=t.mode,t.headersList.set("sec-fetch-mode",e,!0)}function Zw(t){let e=t.origin;if(!(e==="client"||e===void 0)){if(t.responseTainting==="cors"||t.mode==="websocket")t.headersList.append("origin",e,!0);else if(t.method!=="GET"&&t.method!=="HEAD"){switch(t.referrerPolicy){case"no-referrer":e=null;break;case"no-referrer-when-downgrade":case"strict-origin":case"strict-origin-when-cross-origin":t.origin&&sa(t.origin)&&!sa(PA(t))&&(e=null);break;case"same-origin":uo(t,PA(t))||(e=null);break;default:}t.headersList.append("origin",e,!0)}}}function Pr(t,e){return t}function Kw(t,e,r){return!t?.startTime||t.startTime4096&&(A=s);let o=uo(t,A),n=HA(A)&&!HA(t.url);switch(e){case"origin":return s??Aa(r,!0);case"unsafe-url":return A;case"same-origin":return o?s:"no-referrer";case"origin-when-cross-origin":return o?A:s;case"strict-origin-when-cross-origin":{let i=PA(t);return uo(A,i)?A:HA(A)&&!HA(i)?"no-referrer":s}default:return n?"no-referrer":s}}function Aa(t,e){return nr(t instanceof URL),t=new URL(t),t.protocol==="file:"||t.protocol==="about:"||t.protocol==="blank:"?"no-referrer":(t.username="",t.password="",t.hash="",e&&(t.pathname="",t.search=""),t)}function HA(t){if(!(t instanceof URL))return!1;if(t.href==="about:blank"||t.href==="about:srcdoc"||t.protocol==="data:"||t.protocol==="file:")return!0;return e(t.origin);function e(r){if(r==null||r==="null")return!1;let A=new URL(r);return!!(A.protocol==="https:"||A.protocol==="wss:"||/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(A.hostname)||A.hostname==="localhost"||A.hostname.includes("localhost.")||A.hostname.endsWith(".localhost"))}}function ty(t,e){if(go===void 0)return!0;let r=IE(e);if(r==="no metadata"||r.length===0)return!0;let A=Ay(r),s=sy(r,A);for(let o of s){let n=o.algo,i=o.hash,a=go.createHash(n).update(t).digest("base64");if(a[a.length-1]==="="&&(a[a.length-2]==="="?a=a.slice(0,-2):a=a.slice(0,-1)),oy(a,i))return!0}return!1}var ry=/(?sha256|sha384|sha512)-((?[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i;function IE(t){let e=[],r=!0;for(let A of t.split(" ")){r=!1;let s=ry.exec(A);if(s===null||s.groups===void 0||s.groups.algo===void 0)continue;let o=s.groups.algo.toLowerCase();EE.includes(o)&&e.push(s.groups)}return r===!0?"no metadata":e}function Ay(t){let e=t[0].algo;if(e[3]==="5")return e;for(let r=1;r{t=A,e=s}),resolve:t,reject:e}}function ay(t){return t.controller.state==="aborted"}function cy(t){return t.controller.state==="aborted"||t.controller.state==="terminated"}function gy(t){return Lw[t.toLowerCase()]??t}function uy(t){let e=JSON.stringify(t);if(e===void 0)throw new TypeError("Value is not JSON serializable");return nr(typeof e=="string"),e}var ly=Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));function CE(t,e,r=0,A=1){class s{#e;#t;#r;constructor(n,i){this.#e=n,this.#t=i,this.#r=0}next(){if(typeof this!="object"||this===null||!(#e in this))throw new TypeError(`'next' called on an object that does not implement interface ${t} Iterator.`);let n=this.#r,i=this.#e[e],a=i.length;if(n>=a)return{value:void 0,done:!0};let{[r]:c,[A]:l}=i[n];this.#r=n+1;let g;switch(this.#t){case"key":g=c;break;case"value":g=l;break;case"key+value":g=[c,l];break}return{value:g,done:!1}}}return delete s.prototype.constructor,Object.setPrototypeOf(s.prototype,ly),Object.defineProperties(s.prototype,{[Symbol.toStringTag]:{writable:!1,enumerable:!1,configurable:!0,value:`${t} Iterator`},next:{writable:!0,enumerable:!0,configurable:!0}}),function(o,n){return new s(o,n)}}function Ey(t,e,r,A=0,s=1){let o=CE(t,r,A,s),n={keys:{writable:!0,enumerable:!0,configurable:!0,value:function(){return OA.brandCheck(this,e),o(this,"key")}},values:{writable:!0,enumerable:!0,configurable:!0,value:function(){return OA.brandCheck(this,e),o(this,"value")}},entries:{writable:!0,enumerable:!0,configurable:!0,value:function(){return OA.brandCheck(this,e),o(this,"key+value")}},forEach:{writable:!0,enumerable:!0,configurable:!0,value:function(a,c=globalThis){if(OA.brandCheck(this,e),OA.argumentLengthCheck(arguments,1,`${t}.forEach`),typeof a!="function")throw new TypeError(`Failed to execute 'forEach' on '${t}': parameter 1 is not of type 'Function'.`);for(let{0:l,1:g}of o(this,"key+value"))a.call(c,g,l,this)}}};return Object.defineProperties(e.prototype,{...n,[Symbol.iterator]:{writable:!0,enumerable:!1,configurable:!0,value:n.entries.value}})}async function hy(t,e,r){let A=e,s=r,o;try{o=t.stream.getReader()}catch(n){s(n);return}try{A(await pE(o))}catch(n){s(n)}}function Qy(t){return t instanceof ReadableStream||t[Symbol.toStringTag]==="ReadableStream"&&typeof t.tee=="function"}function By(t){try{t.close(),t.byobRequest?.respond(0)}catch(e){if(!e.message.includes("Controller is already closed")&&!e.message.includes("ReadableStream is already closed"))throw e}}var dy=/[^\x00-\xFF]/;function co(t){return nr(!dy.test(t)),t}async function pE(t){let e=[],r=0;for(;;){let{done:A,value:s}=await t.read();if(A)return Buffer.concat(e,r);if(!vw(s))throw new TypeError("Received non-Uint8Array chunk");e.push(s),r+=s.length}}function Iy(t){nr("protocol"in t);let e=t.protocol;return e==="about:"||e==="blob:"||e==="data:"}function sa(t){return typeof t=="string"&&t[5]===":"&&t[0]==="h"&&t[1]==="t"&&t[2]==="t"&&t[3]==="p"&&t[4]==="s"||t.protocol==="https:"}function fE(t){nr("protocol"in t);let e=t.protocol;return e==="http:"||e==="https:"}function Cy(t,e){let r=t;if(!r.startsWith("bytes"))return"failure";let A={position:5};if(e&&or(a=>a===" "||a===" ",r,A),r.charCodeAt(A.position)!==61)return"failure";A.position++,e&&or(a=>a===" "||a===" ",r,A);let s=or(a=>{let c=a.charCodeAt(0);return c>=48&&c<=57},r,A),o=s.length?Number(s):null;if(e&&or(a=>a===" "||a===" ",r,A),r.charCodeAt(A.position)!==45)return"failure";A.position++,e&&or(a=>a===" "||a===" ",r,A);let n=or(a=>{let c=a.charCodeAt(0);return c>=48&&c<=57},r,A),i=n.length?Number(n):null;return A.positioni?"failure":{rangeStartValue:o,rangeEndValue:i}}function py(t,e,r){let A="bytes ";return A+=co(`${t}`),A+="-",A+=co(`${e}`),A+="/",A+=co(`${r}`),A}var oa=class extends kw{#e;constructor(e){super(),this.#e=e}_transform(e,r,A){if(!this._inflateStream){if(e.length===0){A();return}this._inflateStream=(e[0]&15)===8?gE.createInflate(this.#e):gE.createInflateRaw(this.#e),this._inflateStream.on("data",this.push.bind(this)),this._inflateStream.on("end",()=>this.push(null)),this._inflateStream.on("error",s=>this.destroy(s))}this._inflateStream.write(e,r,A)}_final(e){this._inflateStream&&(this._inflateStream.end(),this._inflateStream=null),e()}};function fy(t){return new oa(t)}function my(t){let e=null,r=null,A=null,s=mE("content-type",t);if(s===null)return"failure";for(let o of s){let n=Uw(o);n==="failure"||n.essence==="*/*"||(A=n,A.essence!==r?(e=null,A.parameters.has("charset")&&(e=A.parameters.get("charset")),r=A.essence):!A.parameters.has("charset")&&e!==null&&A.parameters.set("charset",e))}return A??"failure"}function wy(t){let e=t,r={position:0},A=[],s="";for(;r.positiono!=='"'&&o!==",",e,r),r.positiono===9||o===32),A.push(s),s=""}return A}function mE(t,e){let r=e.get(t,!0);return r===null?null:wy(r)}var yy=new TextDecoder;function by(t){return t.length===0?"":(t[0]===239&&t[1]===187&&t[2]===191&&(t=t.subarray(3)),yy.decode(t))}var na=class{get baseUrl(){return uE()}get origin(){return this.baseUrl?.origin}policyContainer=dE()},ia=class{settingsObject=new na},ky=new ia;wE.exports={isAborted:ay,isCancelled:cy,isValidEncodedURL:QE,createDeferredPromise:iy,ReadableStreamFrom:Mw,tryUpgradeRequestToAPotentiallyTrustworthyURL:ny,clampAndCoarsenConnectionTimingInfo:Kw,coarsenedSharedCurrentTime:jw,determineRequestsReferrer:ey,makePolicyContainer:dE,clonePolicyContainer:$w,appendFetchMetadata:zw,appendRequestOriginHeader:Zw,TAOCheck:Ww,corsCheck:qw,crossOriginResourcePolicyCheck:Vw,createOpaqueTimingInfo:Xw,setRequestReferrerPolicyOnRedirect:Pw,isValidHTTPToken:lE,requestBadPort:Yw,requestCurrentURL:PA,responseURL:hE,responseLocationURL:_w,isBlobLike:Gw,isURLPotentiallyTrustworthy:HA,isValidReasonPhrase:Ow,sameOrigin:uo,normalizeMethod:gy,serializeJavascriptValueToJSONString:uy,iteratorMixin:Ey,createIterator:CE,isValidHeaderName:Hw,isValidHeaderValue:BE,isErrorLike:Jw,fullyReadBody:hy,bytesMatch:ty,isReadableStreamLike:Qy,readableStreamClose:By,isomorphicEncode:co,urlIsLocal:Iy,urlHasHttpsScheme:sa,urlIsHttpHttpsScheme:fE,readAllBytes:pE,simpleRangeHeaderValue:Cy,buildContentRange:py,parseMetadata:IE,createInflate:fy,extractMimeType:my,getDecodeSplit:mE,utf8DecodeBytes:by,environmentSettingsObject:ky}});var xt=m((XM,yE)=>{"use strict";yE.exports={kUrl:Symbol("url"),kHeaders:Symbol("headers"),kSignal:Symbol("signal"),kState:Symbol("state"),kDispatcher:Symbol("dispatcher")}});var ca=m(($M,bE)=>{"use strict";var{Blob:Dy,File:Ry}=require("node:buffer"),{kState:bt}=xt(),{webidl:ct}=de(),aa=class t{constructor(e,r,A={}){let s=r,o=A.type,n=A.lastModified??Date.now();this[bt]={blobLike:e,name:s,type:o,lastModified:n}}stream(...e){return ct.brandCheck(this,t),this[bt].blobLike.stream(...e)}arrayBuffer(...e){return ct.brandCheck(this,t),this[bt].blobLike.arrayBuffer(...e)}slice(...e){return ct.brandCheck(this,t),this[bt].blobLike.slice(...e)}text(...e){return ct.brandCheck(this,t),this[bt].blobLike.text(...e)}get size(){return ct.brandCheck(this,t),this[bt].blobLike.size}get type(){return ct.brandCheck(this,t),this[bt].blobLike.type}get name(){return ct.brandCheck(this,t),this[bt].name}get lastModified(){return ct.brandCheck(this,t),this[bt].lastModified}get[Symbol.toStringTag](){return"File"}};ct.converters.Blob=ct.interfaceConverter(Dy);function Ty(t){return t instanceof Ry||t&&(typeof t.stream=="function"||typeof t.arrayBuffer=="function")&&t[Symbol.toStringTag]==="File"}bE.exports={FileLike:aa,isFileLike:Ty}});var qA=m((eL,FE)=>{"use strict";var{isBlobLike:lo,iteratorMixin:Fy}=Fe(),{kState:fe}=xt(),{kEnumerableProperty:Vr}=J(),{FileLike:kE,isFileLike:Sy}=ca(),{webidl:te}=de(),{File:TE}=require("node:buffer"),DE=require("node:util"),RE=globalThis.File??TE,VA=class t{constructor(e){if(te.util.markAsUncloneable(this),e!==void 0)throw te.errors.conversionFailed({prefix:"FormData constructor",argument:"Argument 1",types:["undefined"]});this[fe]=[]}append(e,r,A=void 0){te.brandCheck(this,t);let s="FormData.append";if(te.argumentLengthCheck(arguments,2,s),arguments.length===3&&!lo(r))throw new TypeError("Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'");e=te.converters.USVString(e,s,"name"),r=lo(r)?te.converters.Blob(r,s,"value",{strict:!1}):te.converters.USVString(r,s,"value"),A=arguments.length===3?te.converters.USVString(A,s,"filename"):void 0;let o=ga(e,r,A);this[fe].push(o)}delete(e){te.brandCheck(this,t);let r="FormData.delete";te.argumentLengthCheck(arguments,1,r),e=te.converters.USVString(e,r,"name"),this[fe]=this[fe].filter(A=>A.name!==e)}get(e){te.brandCheck(this,t);let r="FormData.get";te.argumentLengthCheck(arguments,1,r),e=te.converters.USVString(e,r,"name");let A=this[fe].findIndex(s=>s.name===e);return A===-1?null:this[fe][A].value}getAll(e){te.brandCheck(this,t);let r="FormData.getAll";return te.argumentLengthCheck(arguments,1,r),e=te.converters.USVString(e,r,"name"),this[fe].filter(A=>A.name===e).map(A=>A.value)}has(e){te.brandCheck(this,t);let r="FormData.has";return te.argumentLengthCheck(arguments,1,r),e=te.converters.USVString(e,r,"name"),this[fe].findIndex(A=>A.name===e)!==-1}set(e,r,A=void 0){te.brandCheck(this,t);let s="FormData.set";if(te.argumentLengthCheck(arguments,2,s),arguments.length===3&&!lo(r))throw new TypeError("Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'");e=te.converters.USVString(e,s,"name"),r=lo(r)?te.converters.Blob(r,s,"name",{strict:!1}):te.converters.USVString(r,s,"name"),A=arguments.length===3?te.converters.USVString(A,s,"name"):void 0;let o=ga(e,r,A),n=this[fe].findIndex(i=>i.name===e);n!==-1?this[fe]=[...this[fe].slice(0,n),o,...this[fe].slice(n+1).filter(i=>i.name!==e)]:this[fe].push(o)}[DE.inspect.custom](e,r){let A=this[fe].reduce((o,n)=>(o[n.name]?Array.isArray(o[n.name])?o[n.name].push(n.value):o[n.name]=[o[n.name],n.value]:o[n.name]=n.value,o),{__proto__:null});r.depth??=e,r.colors??=!0;let s=DE.formatWithOptions(r,A);return`FormData ${s.slice(s.indexOf("]")+2)}`}};Fy("FormData",VA,fe,"name","value");Object.defineProperties(VA.prototype,{append:Vr,delete:Vr,get:Vr,getAll:Vr,has:Vr,set:Vr,[Symbol.toStringTag]:{value:"FormData",configurable:!0}});function ga(t,e,r){if(typeof e!="string"){if(Sy(e)||(e=e instanceof Blob?new RE([e],"blob",{type:e.type}):new kE(e,"blob",{type:e.type})),r!==void 0){let A={type:e.type,lastModified:e.lastModified};e=e instanceof TE?new RE([e],r,A):new kE(e,r,A)}}return{name:t,value:e}}FE.exports={FormData:VA,makeEntry:ga}});var LE=m((tL,ME)=>{"use strict";var{isUSVString:SE,bufferToLowerCasedHeaderName:Uy}=J(),{utf8DecodeBytes:Ny}=Fe(),{HTTP_TOKEN_CODEPOINTS:Gy,isomorphicDecode:UE}=ye(),{isFileLike:My}=ca(),{makeEntry:Ly}=qA(),Eo=require("node:assert"),{File:vy}=require("node:buffer"),_y=globalThis.File??vy,xy=Buffer.from('form-data; name="'),NE=Buffer.from("; filename"),Yy=Buffer.from("--"),Jy=Buffer.from(`--\r -`);function Oy(t){for(let e=0;e70)return!1;for(let r=0;r=48&&A<=57||A>=65&&A<=90||A>=97&&A<=122||A===39||A===45||A===95))return!1}return!0}function Py(t,e){Eo(e!=="failure"&&e.essence==="multipart/form-data");let r=e.parameters.get("boundary");if(r===void 0)return"failure";let A=Buffer.from(`--${r}`,"utf8"),s=[],o={position:0};for(;t[o.position]===13&&t[o.position+1]===10;)o.position+=2;let n=t.length;for(;t[n-1]===10&&t[n-2]===13;)n-=2;for(n!==t.length&&(t=t.subarray(0,n));;){if(t.subarray(o.position,o.position+A.length).equals(A))o.position+=A.length;else return"failure";if(o.position===t.length-2&&ho(t,Yy,o)||o.position===t.length-4&&ho(t,Jy,o))return s;if(t[o.position]!==13||t[o.position+1]!==10)return"failure";o.position+=2;let i=Vy(t,o);if(i==="failure")return"failure";let{name:a,filename:c,contentType:l,encoding:g}=i;o.position+=2;let E;{let B=t.indexOf(A.subarray(2),o.position);if(B===-1)return"failure";E=t.subarray(o.position,B-4),o.position+=E.length,g==="base64"&&(E=Buffer.from(E.toString(),"base64"))}if(t[o.position]!==13||t[o.position+1]!==10)return"failure";o.position+=2;let d;c!==null?(l??="text/plain",Oy(l)||(l=""),d=new _y([E],c,{type:l})):d=Ny(Buffer.from(E)),Eo(SE(a)),Eo(typeof d=="string"&&SE(d)||My(d)),s.push(Ly(a,d,c))}}function Vy(t,e){let r=null,A=null,s=null,o=null;for(;;){if(t[e.position]===13&&t[e.position+1]===10)return r===null?"failure":{name:r,filename:A,contentType:s,encoding:o};let n=qr(i=>i!==10&&i!==13&&i!==58,t,e);if(n=ua(n,!0,!0,i=>i===9||i===32),!Gy.test(n.toString())||t[e.position]!==58)return"failure";switch(e.position++,qr(i=>i===32||i===9,t,e),Uy(n)){case"content-disposition":{if(r=A=null,!ho(t,xy,e)||(e.position+=17,r=GE(t,e),r===null))return"failure";if(ho(t,NE,e)){let i=e.position+NE.length;if(t[i]===42&&(e.position+=1,i+=1),t[i]!==61||t[i+1]!==34||(e.position+=12,A=GE(t,e),A===null))return"failure"}break}case"content-type":{let i=qr(a=>a!==10&&a!==13,t,e);i=ua(i,!1,!0,a=>a===9||a===32),s=UE(i);break}case"content-transfer-encoding":{let i=qr(a=>a!==10&&a!==13,t,e);i=ua(i,!1,!0,a=>a===9||a===32),o=UE(i);break}default:qr(i=>i!==10&&i!==13,t,e)}if(t[e.position]!==13&&t[e.position+1]!==10)return"failure";e.position+=2}}function GE(t,e){Eo(t[e.position-1]===34);let r=qr(A=>A!==10&&A!==13&&A!==34,t,e);return t[e.position]!==34?null:(e.position++,r=new TextDecoder().decode(r).replace(/%0A/ig,` -`).replace(/%0D/ig,"\r").replace(/%22/g,'"'),r)}function qr(t,e,r){let A=r.position;for(;A0&&A(t[o]);)o--;return s===0&&o===t.length-1?t:t.subarray(s,o+1)}function ho(t,e,r){if(t.length{"use strict";var WA=J(),{ReadableStreamFrom:qy,isBlobLike:vE,isReadableStreamLike:Wy,readableStreamClose:zy,createDeferredPromise:Zy,fullyReadBody:Ky,extractMimeType:jy,utf8DecodeBytes:YE}=Fe(),{FormData:_E}=qA(),{kState:zr}=xt(),{webidl:Xy}=de(),{Blob:$y}=require("node:buffer"),la=require("node:assert"),{isErrored:JE,isDisturbed:eb}=require("node:stream"),{isArrayBuffer:tb}=require("node:util/types"),{serializeAMimeType:rb}=ye(),{multipartFormDataParser:Ab}=LE(),Ea;try{let t=require("node:crypto");Ea=e=>t.randomInt(0,e)}catch{Ea=t=>Math.floor(Math.random(t))}var Qo=new TextEncoder;function sb(){}var OE=globalThis.FinalizationRegistry&&process.version.indexOf("v18")!==0,HE;OE&&(HE=new FinalizationRegistry(t=>{let e=t.deref();e&&!e.locked&&!eb(e)&&!JE(e)&&e.cancel("Response object has been garbage collected").catch(sb)}));function PE(t,e=!1){let r=null;t instanceof ReadableStream?r=t:vE(t)?r=t.stream():r=new ReadableStream({async pull(a){let c=typeof s=="string"?Qo.encode(s):s;c.byteLength&&a.enqueue(c),queueMicrotask(()=>zy(a))},start(){},type:"bytes"}),la(Wy(r));let A=null,s=null,o=null,n=null;if(typeof t=="string")s=t,n="text/plain;charset=UTF-8";else if(t instanceof URLSearchParams)s=t.toString(),n="application/x-www-form-urlencoded;charset=UTF-8";else if(tb(t))s=new Uint8Array(t.slice());else if(ArrayBuffer.isView(t))s=new Uint8Array(t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength));else if(WA.isFormDataLike(t)){let a=`----formdata-undici-0${`${Ea(1e11)}`.padStart(11,"0")}`,c=`--${a}\r -Content-Disposition: form-data`;let l=w=>w.replace(/\n/g,"%0A").replace(/\r/g,"%0D").replace(/"/g,"%22"),g=w=>w.replace(/\r?\n|\r/g,`\r -`),E=[],d=new Uint8Array([13,10]);o=0;let B=!1;for(let[w,I]of t)if(typeof I=="string"){let y=Qo.encode(c+`; name="${l(g(w))}"\r +"use strict";var mf=Object.create;var Vs=Object.defineProperty;var wf=Object.getOwnPropertyDescriptor;var yf=Object.getOwnPropertyNames;var bf=Object.getPrototypeOf,Df=Object.prototype.hasOwnProperty;var m=(t,e)=>()=>{try{return e||t((e={exports:{}}).exports,e),e.exports}catch(r){throw e=0,r}},kf=(t,e)=>{for(var r in e)Vs(t,r,{get:e[r],enumerable:!0})},ku=(t,e,r,A)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of yf(e))!Df.call(t,s)&&s!==r&&Vs(t,s,{get:()=>e[s],enumerable:!(A=wf(e,s))||A.enumerable});return t};var Je=(t,e,r)=>(r=t!=null?mf(bf(t)):{},ku(e||!t||!t.__esModule?Vs(r,"default",{value:t,enumerable:!0}):r,t)),Rf=t=>ku(Vs({},"__esModule",{value:!0}),t);var Lu=m(vr=>{"use strict";var xM=require("net"),Uf=require("tls"),ui=require("http"),Nu=require("https"),Nf=require("events"),YM=require("assert"),Gf=require("util");vr.httpOverHttp=Mf;vr.httpsOverHttp=Lf;vr.httpOverHttps=vf;vr.httpsOverHttps=_f;function Mf(t){var e=new ft(t);return e.request=ui.request,e}function Lf(t){var e=new ft(t);return e.request=ui.request,e.createSocket=Gu,e.defaultPort=443,e}function vf(t){var e=new ft(t);return e.request=Nu.request,e}function _f(t){var e=new ft(t);return e.request=Nu.request,e.createSocket=Gu,e.defaultPort=443,e}function ft(t){var e=this;e.options=t||{},e.proxyOptions=e.options.proxy||{},e.maxSockets=e.options.maxSockets||ui.Agent.defaultMaxSockets,e.requests=[],e.sockets=[],e.on("free",function(A,s,o,n){for(var i=Mu(s,o,n),a=0,c=e.requests.length;a=this.maxSockets){o.requests.push(n);return}o.createSocket(n,function(i){i.on("free",a),i.on("close",c),i.on("agentRemove",c),e.onSocket(i);function a(){o.emit("free",i,n)}function c(u){o.removeSocket(i),i.removeListener("free",a),i.removeListener("close",c),i.removeListener("agentRemove",c)}})};ft.prototype.createSocket=function(e,r){var A=this,s={};A.sockets.push(s);var o=li({},A.proxyOptions,{method:"CONNECT",path:e.host+":"+e.port,agent:!1,headers:{host:e.host+":"+e.port}});e.localAddress&&(o.localAddress=e.localAddress),o.proxyAuth&&(o.headers=o.headers||{},o.headers["Proxy-Authorization"]="Basic "+new Buffer(o.proxyAuth).toString("base64")),xt("making CONNECT request");var n=A.request(o);n.useChunkedEncodingByDefault=!1,n.once("response",i),n.once("upgrade",a),n.once("connect",c),n.once("error",u),n.end();function i(g){g.upgrade=!0}function a(g,E,I){process.nextTick(function(){c(g,E,I)})}function c(g,E,I){if(n.removeAllListeners(),E.removeAllListeners(),g.statusCode!==200){xt("tunneling socket could not be established, statusCode=%d",g.statusCode),E.destroy();var d=new Error("tunneling socket could not be established, statusCode="+g.statusCode);d.code="ECONNRESET",e.request.emit("error",d),A.removeSocket(s);return}if(I.length>0){xt("got illegal response body from proxy"),E.destroy();var d=new Error("got illegal response body from proxy");d.code="ECONNRESET",e.request.emit("error",d),A.removeSocket(s);return}return xt("tunneling connection has established"),A.sockets[A.sockets.indexOf(s)]=E,r(E)}function u(g){n.removeAllListeners(),xt(`tunneling socket could not be established, cause=%s +`,g.message,g.stack);var E=new Error("tunneling socket could not be established, cause="+g.message);E.code="ECONNRESET",e.request.emit("error",E),A.removeSocket(s)}};ft.prototype.removeSocket=function(e){var r=this.sockets.indexOf(e);if(r!==-1){this.sockets.splice(r,1);var A=this.requests.shift();A&&this.createSocket(A,function(s){A.request.onSocket(s)})}};function Gu(t,e){var r=this;ft.prototype.createSocket.call(r,t,function(A){var s=t.request.getHeader("host"),o=li({},r.options,{socket:A,servername:s?s.replace(/:.*$/,""):t.host}),n=Uf.connect(0,o);r.sockets[r.sockets.indexOf(A)]=n,e(n)})}function Mu(t,e,r){return typeof t=="string"?{host:t,port:e,localAddress:r}:t}function li(t){for(var e=1,r=arguments.length;e{vu.exports=Lu()});var se=m((HM,xu)=>{xu.exports={kClose:Symbol("close"),kDestroy:Symbol("destroy"),kDispatch:Symbol("dispatch"),kUrl:Symbol("url"),kWriting:Symbol("writing"),kResuming:Symbol("resuming"),kQueue:Symbol("queue"),kConnect:Symbol("connect"),kConnecting:Symbol("connecting"),kKeepAliveDefaultTimeout:Symbol("default keep alive timeout"),kKeepAliveMaxTimeout:Symbol("max keep alive timeout"),kKeepAliveTimeoutThreshold:Symbol("keep alive timeout threshold"),kKeepAliveTimeoutValue:Symbol("keep alive timeout"),kKeepAlive:Symbol("keep alive"),kHeadersTimeout:Symbol("headers timeout"),kBodyTimeout:Symbol("body timeout"),kServerName:Symbol("server name"),kLocalAddress:Symbol("local address"),kHost:Symbol("host"),kNoRef:Symbol("no ref"),kBodyUsed:Symbol("used"),kBody:Symbol("abstracted request body"),kRunning:Symbol("running"),kBlocking:Symbol("blocking"),kPending:Symbol("pending"),kSize:Symbol("size"),kBusy:Symbol("busy"),kQueued:Symbol("queued"),kFree:Symbol("free"),kConnected:Symbol("connected"),kClosed:Symbol("closed"),kNeedDrain:Symbol("need drain"),kReset:Symbol("reset"),kDestroyed:Symbol.for("nodejs.stream.destroyed"),kResume:Symbol("resume"),kOnError:Symbol("on error"),kMaxHeadersSize:Symbol("max headers size"),kRunningIdx:Symbol("running index"),kPendingIdx:Symbol("pending index"),kError:Symbol("error"),kClients:Symbol("clients"),kClient:Symbol("client"),kParser:Symbol("parser"),kOnDestroyed:Symbol("destroy callbacks"),kPipelining:Symbol("pipelining"),kSocket:Symbol("socket"),kHostHeader:Symbol("host header"),kConnector:Symbol("connector"),kStrictContentLength:Symbol("strict content length"),kMaxRedirections:Symbol("maxRedirections"),kMaxRequests:Symbol("maxRequestsPerClient"),kProxy:Symbol("proxy agent options"),kCounter:Symbol("socket request counter"),kInterceptors:Symbol("dispatch interceptors"),kMaxResponseSize:Symbol("max response size"),kHTTP2Session:Symbol("http2Session"),kHTTP2SessionState:Symbol("http2Session state"),kRetryHandlerDefaultRetry:Symbol("retry agent default retry"),kConstruct:Symbol("constructable"),kListeners:Symbol("listeners"),kHTTPContext:Symbol("http context"),kMaxConcurrentStreams:Symbol("max concurrent streams"),kNoProxyAgent:Symbol("no proxy agent"),kHttpProxyAgent:Symbol("http proxy agent"),kHttpsProxyAgent:Symbol("https proxy agent")}});var q=m((PM,gl)=>{"use strict";var Yu=Symbol.for("undici.error.UND_ERR"),oe=class extends Error{constructor(e){super(e),this.name="UndiciError",this.code="UND_ERR"}static[Symbol.hasInstance](e){return e&&e[Yu]===!0}[Yu]=!0},Ou=Symbol.for("undici.error.UND_ERR_CONNECT_TIMEOUT"),Ei=class extends oe{constructor(e){super(e),this.name="ConnectTimeoutError",this.message=e||"Connect Timeout Error",this.code="UND_ERR_CONNECT_TIMEOUT"}static[Symbol.hasInstance](e){return e&&e[Ou]===!0}[Ou]=!0},Ju=Symbol.for("undici.error.UND_ERR_HEADERS_TIMEOUT"),hi=class extends oe{constructor(e){super(e),this.name="HeadersTimeoutError",this.message=e||"Headers Timeout Error",this.code="UND_ERR_HEADERS_TIMEOUT"}static[Symbol.hasInstance](e){return e&&e[Ju]===!0}[Ju]=!0},Hu=Symbol.for("undici.error.UND_ERR_HEADERS_OVERFLOW"),Qi=class extends oe{constructor(e){super(e),this.name="HeadersOverflowError",this.message=e||"Headers Overflow Error",this.code="UND_ERR_HEADERS_OVERFLOW"}static[Symbol.hasInstance](e){return e&&e[Hu]===!0}[Hu]=!0},Pu=Symbol.for("undici.error.UND_ERR_BODY_TIMEOUT"),di=class extends oe{constructor(e){super(e),this.name="BodyTimeoutError",this.message=e||"Body Timeout Error",this.code="UND_ERR_BODY_TIMEOUT"}static[Symbol.hasInstance](e){return e&&e[Pu]===!0}[Pu]=!0},Vu=Symbol.for("undici.error.UND_ERR_RESPONSE_STATUS_CODE"),Bi=class extends oe{constructor(e,r,A,s){super(e),this.name="ResponseStatusCodeError",this.message=e||"Response Status Code Error",this.code="UND_ERR_RESPONSE_STATUS_CODE",this.body=s,this.status=r,this.statusCode=r,this.headers=A}static[Symbol.hasInstance](e){return e&&e[Vu]===!0}[Vu]=!0},qu=Symbol.for("undici.error.UND_ERR_INVALID_ARG"),Ii=class extends oe{constructor(e){super(e),this.name="InvalidArgumentError",this.message=e||"Invalid Argument Error",this.code="UND_ERR_INVALID_ARG"}static[Symbol.hasInstance](e){return e&&e[qu]===!0}[qu]=!0},Wu=Symbol.for("undici.error.UND_ERR_INVALID_RETURN_VALUE"),Ci=class extends oe{constructor(e){super(e),this.name="InvalidReturnValueError",this.message=e||"Invalid Return Value Error",this.code="UND_ERR_INVALID_RETURN_VALUE"}static[Symbol.hasInstance](e){return e&&e[Wu]===!0}[Wu]=!0},zu=Symbol.for("undici.error.UND_ERR_ABORT"),zs=class extends oe{constructor(e){super(e),this.name="AbortError",this.message=e||"The operation was aborted",this.code="UND_ERR_ABORT"}static[Symbol.hasInstance](e){return e&&e[zu]===!0}[zu]=!0},Zu=Symbol.for("undici.error.UND_ERR_ABORTED"),pi=class extends zs{constructor(e){super(e),this.name="AbortError",this.message=e||"Request aborted",this.code="UND_ERR_ABORTED"}static[Symbol.hasInstance](e){return e&&e[Zu]===!0}[Zu]=!0},Ku=Symbol.for("undici.error.UND_ERR_INFO"),fi=class extends oe{constructor(e){super(e),this.name="InformationalError",this.message=e||"Request information",this.code="UND_ERR_INFO"}static[Symbol.hasInstance](e){return e&&e[Ku]===!0}[Ku]=!0},ju=Symbol.for("undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"),mi=class extends oe{constructor(e){super(e),this.name="RequestContentLengthMismatchError",this.message=e||"Request body length does not match content-length header",this.code="UND_ERR_REQ_CONTENT_LENGTH_MISMATCH"}static[Symbol.hasInstance](e){return e&&e[ju]===!0}[ju]=!0},Xu=Symbol.for("undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH"),wi=class extends oe{constructor(e){super(e),this.name="ResponseContentLengthMismatchError",this.message=e||"Response body length does not match content-length header",this.code="UND_ERR_RES_CONTENT_LENGTH_MISMATCH"}static[Symbol.hasInstance](e){return e&&e[Xu]===!0}[Xu]=!0},$u=Symbol.for("undici.error.UND_ERR_DESTROYED"),yi=class extends oe{constructor(e){super(e),this.name="ClientDestroyedError",this.message=e||"The client is destroyed",this.code="UND_ERR_DESTROYED"}static[Symbol.hasInstance](e){return e&&e[$u]===!0}[$u]=!0},el=Symbol.for("undici.error.UND_ERR_CLOSED"),bi=class extends oe{constructor(e){super(e),this.name="ClientClosedError",this.message=e||"The client is closed",this.code="UND_ERR_CLOSED"}static[Symbol.hasInstance](e){return e&&e[el]===!0}[el]=!0},tl=Symbol.for("undici.error.UND_ERR_SOCKET"),Di=class extends oe{constructor(e,r){super(e),this.name="SocketError",this.message=e||"Socket error",this.code="UND_ERR_SOCKET",this.socket=r}static[Symbol.hasInstance](e){return e&&e[tl]===!0}[tl]=!0},rl=Symbol.for("undici.error.UND_ERR_NOT_SUPPORTED"),ki=class extends oe{constructor(e){super(e),this.name="NotSupportedError",this.message=e||"Not supported error",this.code="UND_ERR_NOT_SUPPORTED"}static[Symbol.hasInstance](e){return e&&e[rl]===!0}[rl]=!0},Al=Symbol.for("undici.error.UND_ERR_BPL_MISSING_UPSTREAM"),Ri=class extends oe{constructor(e){super(e),this.name="MissingUpstreamError",this.message=e||"No upstream has been added to the BalancedPool",this.code="UND_ERR_BPL_MISSING_UPSTREAM"}static[Symbol.hasInstance](e){return e&&e[Al]===!0}[Al]=!0},sl=Symbol.for("undici.error.UND_ERR_HTTP_PARSER"),Ti=class extends Error{constructor(e,r,A){super(e),this.name="HTTPParserError",this.code=r?`HPE_${r}`:void 0,this.data=A?A.toString():void 0}static[Symbol.hasInstance](e){return e&&e[sl]===!0}[sl]=!0},ol=Symbol.for("undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE"),Fi=class extends oe{constructor(e){super(e),this.name="ResponseExceededMaxSizeError",this.message=e||"Response content exceeded max size",this.code="UND_ERR_RES_EXCEEDED_MAX_SIZE"}static[Symbol.hasInstance](e){return e&&e[ol]===!0}[ol]=!0},nl=Symbol.for("undici.error.UND_ERR_REQ_RETRY"),Si=class extends oe{constructor(e,r,{headers:A,data:s}){super(e),this.name="RequestRetryError",this.message=e||"Request retry error",this.code="UND_ERR_REQ_RETRY",this.statusCode=r,this.data=s,this.headers=A}static[Symbol.hasInstance](e){return e&&e[nl]===!0}[nl]=!0},il=Symbol.for("undici.error.UND_ERR_RESPONSE"),Ui=class extends oe{constructor(e,r,{headers:A,data:s}){super(e),this.name="ResponseError",this.message=e||"Response error",this.code="UND_ERR_RESPONSE",this.statusCode=r,this.data=s,this.headers=A}static[Symbol.hasInstance](e){return e&&e[il]===!0}[il]=!0},al=Symbol.for("undici.error.UND_ERR_PRX_TLS"),Ni=class extends oe{constructor(e,r,A){super(r,{cause:e,...A??{}}),this.name="SecureProxyConnectionError",this.message=r||"Secure Proxy Connection failed",this.code="UND_ERR_PRX_TLS",this.cause=e}static[Symbol.hasInstance](e){return e&&e[al]===!0}[al]=!0},cl=Symbol.for("undici.error.UND_ERR_WS_MESSAGE_SIZE_EXCEEDED"),Gi=class extends oe{constructor(e){super(e),this.name="MessageSizeExceededError",this.message=e||"Max decompressed message size exceeded",this.code="UND_ERR_WS_MESSAGE_SIZE_EXCEEDED"}static[Symbol.hasInstance](e){return e&&e[cl]===!0}get[cl](){return!0}};gl.exports={AbortError:zs,HTTPParserError:Ti,UndiciError:oe,HeadersTimeoutError:hi,HeadersOverflowError:Qi,BodyTimeoutError:di,RequestContentLengthMismatchError:mi,ConnectTimeoutError:Ei,ResponseStatusCodeError:Bi,InvalidArgumentError:Ii,InvalidReturnValueError:Ci,RequestAbortedError:pi,ClientDestroyedError:yi,ClientClosedError:bi,InformationalError:fi,SocketError:Di,NotSupportedError:ki,ResponseContentLengthMismatchError:wi,BalancedPoolMissingUpstreamError:Ri,ResponseExceededMaxSizeError:Fi,RequestRetryError:Si,ResponseError:Ui,SecureProxyConnectionError:Ni,MessageSizeExceededError:Gi}});var Ks=m((VM,ul)=>{"use strict";var Zs={},Mi=["Accept","Accept-Encoding","Accept-Language","Accept-Ranges","Access-Control-Allow-Credentials","Access-Control-Allow-Headers","Access-Control-Allow-Methods","Access-Control-Allow-Origin","Access-Control-Expose-Headers","Access-Control-Max-Age","Access-Control-Request-Headers","Access-Control-Request-Method","Age","Allow","Alt-Svc","Alt-Used","Authorization","Cache-Control","Clear-Site-Data","Connection","Content-Disposition","Content-Encoding","Content-Language","Content-Length","Content-Location","Content-Range","Content-Security-Policy","Content-Security-Policy-Report-Only","Content-Type","Cookie","Cross-Origin-Embedder-Policy","Cross-Origin-Opener-Policy","Cross-Origin-Resource-Policy","Date","Device-Memory","Downlink","ECT","ETag","Expect","Expect-CT","Expires","Forwarded","From","Host","If-Match","If-Modified-Since","If-None-Match","If-Range","If-Unmodified-Since","Keep-Alive","Last-Modified","Link","Location","Max-Forwards","Origin","Permissions-Policy","Pragma","Proxy-Authenticate","Proxy-Authorization","RTT","Range","Referer","Referrer-Policy","Refresh","Retry-After","Sec-WebSocket-Accept","Sec-WebSocket-Extensions","Sec-WebSocket-Key","Sec-WebSocket-Protocol","Sec-WebSocket-Version","Server","Server-Timing","Service-Worker-Allowed","Service-Worker-Navigation-Preload","Set-Cookie","SourceMap","Strict-Transport-Security","Supports-Loading-Mode","TE","Timing-Allow-Origin","Trailer","Transfer-Encoding","Upgrade","Upgrade-Insecure-Requests","User-Agent","Vary","Via","WWW-Authenticate","X-Content-Type-Options","X-DNS-Prefetch-Control","X-Frame-Options","X-Permitted-Cross-Domain-Policies","X-Powered-By","X-Requested-With","X-XSS-Protection"];for(let t=0;t{"use strict";var{wellknownHeaderNames:ll,headerNameLowerCasedRecord:xf}=Ks(),Li=class t{value=null;left=null;middle=null;right=null;code;constructor(e,r,A){if(A===void 0||A>=e.length)throw new TypeError("Unreachable");if((this.code=e.charCodeAt(A))>127)throw new TypeError("key must be ascii string");e.length!==++A?this.middle=new t(e,r,A):this.value=r}add(e,r){let A=e.length;if(A===0)throw new TypeError("Unreachable");let s=0,o=this;for(;;){let n=e.charCodeAt(s);if(n>127)throw new TypeError("key must be ascii string");if(o.code===n)if(A===++s){o.value=r;break}else if(o.middle!==null)o=o.middle;else{o.middle=new t(e,r,s);break}else if(o.code=65&&(o|=32);s!==null;){if(o===s.code){if(r===++A)return s;s=s.middle;break}s=s.code{"use strict";var _A=require("node:assert"),{kDestroyed:Bl,kBodyUsed:_r,kListeners:vi,kBody:dl}=se(),{IncomingMessage:Yf}=require("node:http"),eo=require("node:stream"),Of=require("node:net"),{Blob:Jf}=require("node:buffer"),Hf=require("node:util"),{stringify:Pf}=require("node:querystring"),{EventEmitter:Vf}=require("node:events"),{InvalidArgumentError:Ee}=q(),{headerNameLowerCasedRecord:qf}=Ks(),{tree:Il}=Ql(),[Wf,zf]=process.versions.node.split(".").map(t=>Number(t)),$s=class{constructor(e){this[dl]=e,this[_r]=!1}async*[Symbol.asyncIterator](){_A(!this[_r],"disturbed"),this[_r]=!0,yield*this[dl]}};function Zf(t){return to(t)?(wl(t)===0&&t.on("data",function(){_A(!1)}),typeof t.readableDidRead!="boolean"&&(t[_r]=!1,Vf.prototype.on.call(t,"data",function(){this[_r]=!0})),t):t&&typeof t.pipeTo=="function"?new $s(t):t&&typeof t!="string"&&!ArrayBuffer.isView(t)&&ml(t)?new $s(t):t}function Kf(){}function to(t){return t&&typeof t=="object"&&typeof t.pipe=="function"&&typeof t.on=="function"}function Cl(t){if(t===null)return!1;if(t instanceof Jf)return!0;if(typeof t!="object")return!1;{let e=t[Symbol.toStringTag];return(e==="Blob"||e==="File")&&("stream"in t&&typeof t.stream=="function"||"arrayBuffer"in t&&typeof t.arrayBuffer=="function")}}function jf(t,e){if(t.includes("?")||t.includes("#"))throw new Error('Query params cannot be passed when url already contains "?" or "#".');let r=Pf(e);return r&&(t+="?"+r),t}function pl(t){let e=parseInt(t,10);return e===Number(t)&&e>=0&&e<=65535}function Xs(t){return t!=null&&t[0]==="h"&&t[1]==="t"&&t[2]==="t"&&t[3]==="p"&&(t[4]===":"||t[4]==="s"&&t[5]===":")}function fl(t){if(typeof t=="string"){if(t=new URL(t),!Xs(t.origin||t.protocol))throw new Ee("Invalid URL protocol: the URL must start with `http:` or `https:`.");return t}if(!t||typeof t!="object")throw new Ee("Invalid URL: The URL argument must be a non-null object.");if(!(t instanceof URL)){if(t.port!=null&&t.port!==""&&pl(t.port)===!1)throw new Ee("Invalid URL: port must be a valid integer or a string representation of an integer.");if(t.path!=null&&typeof t.path!="string")throw new Ee("Invalid URL path: the path must be a string or null/undefined.");if(t.pathname!=null&&typeof t.pathname!="string")throw new Ee("Invalid URL pathname: the pathname must be a string or null/undefined.");if(t.hostname!=null&&typeof t.hostname!="string")throw new Ee("Invalid URL hostname: the hostname must be a string or null/undefined.");if(t.origin!=null&&typeof t.origin!="string")throw new Ee("Invalid URL origin: the origin must be a string or null/undefined.");if(!Xs(t.origin||t.protocol))throw new Ee("Invalid URL protocol: the URL must start with `http:` or `https:`.");let e=t.port!=null?t.port:t.protocol==="https:"?443:80,r=t.origin!=null?t.origin:`${t.protocol||""}//${t.hostname||""}:${e}`,A=t.path!=null?t.path:`${t.pathname||""}${t.search||""}`;return r[r.length-1]==="/"&&(r=r.slice(0,r.length-1)),A&&A[0]!=="/"&&(A=`/${A}`),new URL(`${r}${A}`)}if(!Xs(t.origin||t.protocol))throw new Ee("Invalid URL protocol: the URL must start with `http:` or `https:`.");return t}function Xf(t){if(t=fl(t),t.pathname!=="/"||t.search||t.hash)throw new Ee("invalid url");return t}function $f(t){if(t[0]==="["){let r=t.indexOf("]");return _A(r!==-1),t.substring(1,r)}let e=t.indexOf(":");return e===-1?t:t.substring(0,e)}function em(t){if(!t)return null;_A(typeof t=="string");let e=$f(t);return Of.isIP(e)?"":e}function tm(t){return JSON.parse(JSON.stringify(t))}function rm(t){return t!=null&&typeof t[Symbol.asyncIterator]=="function"}function ml(t){return t!=null&&(typeof t[Symbol.iterator]=="function"||typeof t[Symbol.asyncIterator]=="function")}function wl(t){if(t==null)return 0;if(to(t)){let e=t._readableState;return e&&e.objectMode===!1&&e.ended===!0&&Number.isFinite(e.length)?e.length:null}else{if(Cl(t))return t.size!=null?t.size:null;if(Dl(t))return t.byteLength}return null}function yl(t){return t&&!!(t.destroyed||t[Bl]||eo.isDestroyed?.(t))}function Am(t,e){t==null||!to(t)||yl(t)||(typeof t.destroy=="function"?(Object.getPrototypeOf(t).constructor===Yf&&(t.socket=null),t.destroy(e)):e&&queueMicrotask(()=>{t.emit("error",e)}),t.destroyed!==!0&&(t[Bl]=!0))}var sm=/timeout=(\d+)/;function om(t){let e=t.toString().match(sm);return e?parseInt(e[1],10)*1e3:null}function bl(t){return typeof t=="string"?qf[t]??t.toLowerCase():Il.lookup(t)??t.toString("latin1").toLowerCase()}function nm(t){return Il.lookup(t)??t.toString("latin1").toLowerCase()}function im(t,e){e===void 0&&(e={});for(let r=0;rn.toString("utf8")):o.toString("utf8")}}return"content-length"in e&&"content-disposition"in e&&(e["content-disposition"]=Buffer.from(e["content-disposition"]).toString("latin1")),e}function am(t){let e=t.length,r=new Array(e),A=!1,s=-1,o,n,i=0;for(let a=0;a{r.close(),r.byobRequest?.respond(0)});else{let o=Buffer.isBuffer(s)?s:Buffer.from(s);o.byteLength&&r.enqueue(new Uint8Array(o))}return r.desiredSize>0},async cancel(r){await e.return()},type:"bytes"})}function Qm(t){return t&&typeof t=="object"&&typeof t.append=="function"&&typeof t.delete=="function"&&typeof t.get=="function"&&typeof t.getAll=="function"&&typeof t.has=="function"&&typeof t.set=="function"&&t[Symbol.toStringTag]==="FormData"}function dm(t,e){return"addEventListener"in t?(t.addEventListener("abort",e,{once:!0}),()=>t.removeEventListener("abort",e)):(t.addListener("abort",e),()=>t.removeListener("abort",e))}var Bm=typeof String.prototype.toWellFormed=="function",Im=typeof String.prototype.isWellFormed=="function";function kl(t){return Bm?`${t}`.toWellFormed():Hf.toUSVString(t)}function Cm(t){return Im?`${t}`.isWellFormed():kl(t)===`${t}`}function Rl(t){switch(t){case 34:case 40:case 41:case 44:case 47:case 58:case 59:case 60:case 61:case 62:case 63:case 64:case 91:case 92:case 93:case 123:case 125:return!1;default:return t>=33&&t<=126}}function pm(t){if(t.length===0)return!1;for(let e=0;e{"use strict";var z=require("node:diagnostics_channel"),Yi=require("node:util"),ro=Yi.debuglog("undici"),xi=Yi.debuglog("fetch"),nr=Yi.debuglog("websocket"),Ul=!1,km={beforeConnect:z.channel("undici:client:beforeConnect"),connected:z.channel("undici:client:connected"),connectError:z.channel("undici:client:connectError"),sendHeaders:z.channel("undici:client:sendHeaders"),create:z.channel("undici:request:create"),bodySent:z.channel("undici:request:bodySent"),headers:z.channel("undici:request:headers"),trailers:z.channel("undici:request:trailers"),error:z.channel("undici:request:error"),open:z.channel("undici:websocket:open"),close:z.channel("undici:websocket:close"),socketError:z.channel("undici:websocket:socket_error"),ping:z.channel("undici:websocket:ping"),pong:z.channel("undici:websocket:pong")};if(ro.enabled||xi.enabled){let t=xi.enabled?xi:ro;z.channel("undici:client:beforeConnect").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o}}=e;t("connecting to %s using %s%s",`${o}${s?`:${s}`:""}`,A,r)}),z.channel("undici:client:connected").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o}}=e;t("connected to %s using %s%s",`${o}${s?`:${s}`:""}`,A,r)}),z.channel("undici:client:connectError").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o},error:n}=e;t("connection to %s using %s%s errored - %s",`${o}${s?`:${s}`:""}`,A,r,n.message)}),z.channel("undici:client:sendHeaders").subscribe(e=>{let{request:{method:r,path:A,origin:s}}=e;t("sending request to %s %s/%s",r,s,A)}),z.channel("undici:request:headers").subscribe(e=>{let{request:{method:r,path:A,origin:s},response:{statusCode:o}}=e;t("received response to %s %s/%s - HTTP %d",r,s,A,o)}),z.channel("undici:request:trailers").subscribe(e=>{let{request:{method:r,path:A,origin:s}}=e;t("trailers received from %s %s/%s",r,s,A)}),z.channel("undici:request:error").subscribe(e=>{let{request:{method:r,path:A,origin:s},error:o}=e;t("request to %s %s/%s errored - %s",r,s,A,o.message)}),Ul=!0}if(nr.enabled){if(!Ul){let t=ro.enabled?ro:nr;z.channel("undici:client:beforeConnect").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o}}=e;t("connecting to %s%s using %s%s",o,s?`:${s}`:"",A,r)}),z.channel("undici:client:connected").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o}}=e;t("connected to %s%s using %s%s",o,s?`:${s}`:"",A,r)}),z.channel("undici:client:connectError").subscribe(e=>{let{connectParams:{version:r,protocol:A,port:s,host:o},error:n}=e;t("connection to %s%s using %s%s errored - %s",o,s?`:${s}`:"",A,r,n.message)}),z.channel("undici:client:sendHeaders").subscribe(e=>{let{request:{method:r,path:A,origin:s}}=e;t("sending request to %s %s/%s",r,s,A)})}z.channel("undici:websocket:open").subscribe(t=>{let{address:{address:e,port:r}}=t;nr("connection opened %s%s",e,r?`:${r}`:"")}),z.channel("undici:websocket:close").subscribe(t=>{let{websocket:e,code:r,reason:A}=t;nr("closed connection to %s - %s %s",e.url,r,A)}),z.channel("undici:websocket:socket_error").subscribe(t=>{nr("connection errored - %s",t.message)}),z.channel("undici:websocket:ping").subscribe(t=>{nr("ping received")}),z.channel("undici:websocket:pong").subscribe(t=>{nr("pong received")})}Nl.exports={channels:km}});var vl=m((ZM,Ll)=>{"use strict";var{InvalidArgumentError:ee,NotSupportedError:Rm}=q(),mt=require("node:assert"),{isValidHTTPToken:Ml,isValidHeaderValue:Oi,isStream:Tm,destroy:Fm,isBuffer:Sm,isFormDataLike:Um,isIterable:Nm,isBlobLike:Gm,buildURL:Mm,validateHandler:Lm,getServerName:vm,normalizedMethodRecords:_m}=O(),{channels:it}=xr(),{headerNameLowerCasedRecord:Gl}=Ks(),xm=/[^\u0021-\u00ff]/,He=Symbol("handler"),Ji=class{constructor(e,{path:r,method:A,body:s,headers:o,query:n,idempotent:i,blocking:a,upgrade:c,headersTimeout:u,bodyTimeout:g,reset:E,throwOnError:I,expectContinue:d,servername:p},y){if(typeof r!="string")throw new ee("path must be a string");if(r[0]!=="/"&&!(r.startsWith("http://")||r.startsWith("https://"))&&A!=="CONNECT")throw new ee("path must be an absolute URL or start with a slash");if(xm.test(r))throw new ee("invalid request path");if(typeof A!="string")throw new ee("method must be a string");if(_m[A]===void 0&&!Ml(A))throw new ee("invalid request method");if(c&&typeof c!="string")throw new ee("upgrade must be a string");if(c&&!Oi(c))throw new ee("invalid upgrade header");if(u!=null&&(!Number.isFinite(u)||u<0))throw new ee("invalid headersTimeout");if(g!=null&&(!Number.isFinite(g)||g<0))throw new ee("invalid bodyTimeout");if(E!=null&&typeof E!="boolean")throw new ee("invalid reset");if(d!=null&&typeof d!="boolean")throw new ee("invalid expectContinue");if(this.headersTimeout=u,this.bodyTimeout=g,this.throwOnError=I===!0,this.method=A,this.abort=null,s==null)this.body=null;else if(Tm(s)){this.body=s;let B=this.body._readableState;(!B||!B.autoDestroy)&&(this.endHandler=function(){Fm(this)},this.body.on("end",this.endHandler)),this.errorHandler=w=>{this.abort?this.abort(w):this.error=w},this.body.on("error",this.errorHandler)}else if(Sm(s))this.body=s.byteLength?s:null;else if(ArrayBuffer.isView(s))this.body=s.buffer.byteLength?Buffer.from(s.buffer,s.byteOffset,s.byteLength):null;else if(s instanceof ArrayBuffer)this.body=s.byteLength?Buffer.from(s):null;else if(typeof s=="string")this.body=s.length?Buffer.from(s):null;else if(Um(s)||Nm(s)||Gm(s))this.body=s;else throw new ee("body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable");if(this.completed=!1,this.aborted=!1,this.upgrade=c||null,this.path=n?Mm(r,n):r,this.origin=e,this.idempotent=i??(A==="HEAD"||A==="GET"),this.blocking=a??!1,this.reset=E??null,this.host=null,this.contentLength=null,this.contentType=null,this.headers=[],this.expectContinue=d??!1,Array.isArray(o)){if(o.length%2!==0)throw new ee("headers array must be even");for(let B=0;B{"use strict";var Ym=require("node:events"),so=class extends Ym{dispatch(){throw new Error("not implemented")}close(){throw new Error("not implemented")}destroy(){throw new Error("not implemented")}compose(...e){let r=Array.isArray(e[0])?e[0]:e,A=this.dispatch.bind(this);for(let s of r)if(s!=null){if(typeof s!="function")throw new TypeError(`invalid interceptor, expected function received ${typeof s}`);if(A=s(A),A==null||typeof A!="function"||A.length!==2)throw new TypeError("invalid interceptor")}return new Hi(this,A)}},Hi=class extends so{#e=null;#t=null;constructor(e,r){super(),this.#e=e,this.#t=r}dispatch(...e){this.#t(...e)}close(...e){return this.#e.close(...e)}destroy(...e){return this.#e.destroy(...e)}};_l.exports=so});var Hr=m((jM,xl)=>{"use strict";var Om=xA(),{ClientDestroyedError:Pi,ClientClosedError:Jm,InvalidArgumentError:Yr}=q(),{kDestroy:Hm,kClose:Pm,kClosed:YA,kDestroyed:Or,kDispatch:Vi,kInterceptors:ir}=se(),wt=Symbol("onDestroyed"),Jr=Symbol("onClosed"),oo=Symbol("Intercepted Dispatch"),qi=Symbol("webSocketOptions"),Wi=class extends Om{constructor(e){super(),this[Or]=!1,this[wt]=null,this[YA]=!1,this[Jr]=[],this[qi]=e?.webSocket??{}}get webSocketOptions(){return{maxFragments:this[qi].maxFragments??131072,maxPayloadSize:this[qi].maxPayloadSize??128*1024*1024}}get destroyed(){return this[Or]}get closed(){return this[YA]}get interceptors(){return this[ir]}set interceptors(e){if(e){for(let r=e.length-1;r>=0;r--)if(typeof this[ir][r]!="function")throw new Yr("interceptor must be an function")}this[ir]=e}close(e){if(e===void 0)return new Promise((A,s)=>{this.close((o,n)=>o?s(o):A(n))});if(typeof e!="function")throw new Yr("invalid callback");if(this[Or]){queueMicrotask(()=>e(new Pi,null));return}if(this[YA]){this[Jr]?this[Jr].push(e):queueMicrotask(()=>e(null,null));return}this[YA]=!0,this[Jr].push(e);let r=()=>{let A=this[Jr];this[Jr]=null;for(let s=0;sthis.destroy()).then(()=>{queueMicrotask(r)})}destroy(e,r){if(typeof e=="function"&&(r=e,e=null),r===void 0)return new Promise((s,o)=>{this.destroy(e,(n,i)=>n?o(n):s(i))});if(typeof r!="function")throw new Yr("invalid callback");if(this[Or]){this[wt]?this[wt].push(r):queueMicrotask(()=>r(null,null));return}e||(e=new Pi),this[Or]=!0,this[wt]=this[wt]||[],this[wt].push(r);let A=()=>{let s=this[wt];this[wt]=null;for(let o=0;o{queueMicrotask(A)})}[oo](e,r){if(!this[ir]||this[ir].length===0)return this[oo]=this[Vi],this[Vi](e,r);let A=this[Vi].bind(this);for(let s=this[ir].length-1;s>=0;s--)A=this[ir][s](A);return this[oo]=A,A(e,r)}dispatch(e,r){if(!r||typeof r!="object")throw new Yr("handler must be an object");try{if(!e||typeof e!="object")throw new Yr("opts must be an object.");if(this[Or]||this[wt])throw new Pi;if(this[YA])throw new Jm;return this[oo](e,r)}catch(A){if(typeof r.onError!="function")throw new Yr("invalid onError method");return r.onError(A),!1}}};xl.exports=Wi});var ea=m((XM,Hl)=>{"use strict";var Pr=0,zi=1e3,Zi=(zi>>1)-1,yt,Ki=Symbol("kFastTimer"),bt=[],ji=-2,Xi=-1,Ol=0,Yl=1;function $i(){Pr+=Zi;let t=0,e=bt.length;for(;t=r._idleStart+r._idleTimeout&&(r._state=Xi,r._idleStart=-1,r._onTimeout(r._timerArg)),r._state===Xi?(r._state=ji,--e!==0&&(bt[t]=bt[e])):++t}bt.length=e,bt.length!==0&&Jl()}function Jl(){yt?yt.refresh():(clearTimeout(yt),yt=setTimeout($i,Zi),yt.unref&&yt.unref())}var no=class{[Ki]=!0;_state=ji;_idleTimeout=-1;_idleStart=-1;_onTimeout;_timerArg;constructor(e,r,A){this._onTimeout=e,this._idleTimeout=r,this._timerArg=A,this.refresh()}refresh(){this._state===ji&&bt.push(this),(!yt||bt.length===1)&&Jl(),this._state=Ol}clear(){this._state=Xi,this._idleStart=-1}};Hl.exports={setTimeout(t,e,r){return e<=zi?setTimeout(t,e,r):new no(t,e,r)},clearTimeout(t){t[Ki]?t.clear():clearTimeout(t)},setFastTimeout(t,e,r){return new no(t,e,r)},clearFastTimeout(t){t.clear()},now(){return Pr},tick(t=0){Pr+=t-zi+1,$i(),$i()},reset(){Pr=0,bt.length=0,clearTimeout(yt),yt=null},kFastTimer:Ki}});var OA=m((tL,zl)=>{"use strict";var Vm=require("node:net"),Pl=require("node:assert"),Wl=O(),{InvalidArgumentError:qm,ConnectTimeoutError:Wm}=q(),io=ea();function Vl(){}var ta,ra;global.FinalizationRegistry&&!(process.env.NODE_V8_COVERAGE||process.env.UNDICI_NO_FG)?ra=class{constructor(e){this._maxCachedSessions=e,this._sessionCache=new Map,this._sessionRegistry=new global.FinalizationRegistry(r=>{if(this._sessionCache.size=this._maxCachedSessions){let{value:A}=this._sessionCache.keys().next();this._sessionCache.delete(A)}this._sessionCache.set(e,r)}}};function zm({allowH2:t,maxCachedSessions:e,socketPath:r,timeout:A,session:s,...o}){if(e!=null&&(!Number.isInteger(e)||e<0))throw new qm("maxCachedSessions must be a positive integer or zero");let n={path:r,...o},i=new ra(e??100);return A=A??1e4,t=t??!1,function({hostname:c,host:u,protocol:g,port:E,servername:I,localAddress:d,httpSocket:p},y){let B;if(g==="https:"){ta||(ta=require("node:tls")),I=I||n.servername||Wl.getServerName(u)||null;let T=I||c;Pl(T);let S=s||i.get(T)||null;E=E||443,B=ta.connect({highWaterMark:16384,...n,servername:I,session:S,localAddress:d,ALPNProtocols:t?["http/1.1","h2"]:["http/1.1"],socket:p,port:E,host:c}),B.on("session",function(J){i.set(T,J)})}else Pl(!p,"httpSocket can only be sent on TLS update"),E=E||80,B=Vm.connect({highWaterMark:64*1024,...n,localAddress:d,port:E,host:c});if(n.keepAlive==null||n.keepAlive){let T=n.keepAliveInitialDelay===void 0?6e4:n.keepAliveInitialDelay;B.setKeepAlive(!0,T)}let w=Zm(new WeakRef(B),{timeout:A,hostname:c,port:E});return B.setNoDelay(!0).once(g==="https:"?"secureConnect":"connect",function(){if(queueMicrotask(w),y){let T=y;y=null,T(null,this)}}).on("error",function(T){if(queueMicrotask(w),y){let S=y;y=null,S(T)}}),B}}var Zm=process.platform==="win32"?(t,e)=>{if(!e.timeout)return Vl;let r=null,A=null,s=io.setFastTimeout(()=>{r=setImmediate(()=>{A=setImmediate(()=>ql(t.deref(),e))})},e.timeout);return()=>{io.clearFastTimeout(s),clearImmediate(r),clearImmediate(A)}}:(t,e)=>{if(!e.timeout)return Vl;let r=null,A=io.setFastTimeout(()=>{r=setImmediate(()=>{ql(t.deref(),e)})},e.timeout);return()=>{io.clearFastTimeout(A),clearImmediate(r)}};function ql(t,e){if(t==null)return;let r="Connect Timeout Error";Array.isArray(t.autoSelectFamilyAttemptedAddresses)?r+=` (attempted addresses: ${t.autoSelectFamilyAttemptedAddresses.join(", ")},`:r+=` (attempted address: ${e.hostname}:${e.port},`,r+=` timeout: ${e.timeout}ms)`,Wl.destroy(t,new Wm(r))}zl.exports=zm});var Zl=m(ao=>{"use strict";Object.defineProperty(ao,"__esModule",{value:!0});ao.enumToMap=void 0;function Km(t){let e={};return Object.keys(t).forEach(r=>{let A=t[r];typeof A=="number"&&(e[r]=A)}),e}ao.enumToMap=Km});var Kl=m(D=>{"use strict";Object.defineProperty(D,"__esModule",{value:!0});D.SPECIAL_HEADERS=D.HEADER_STATE=D.MINOR=D.MAJOR=D.CONNECTION_TOKEN_CHARS=D.HEADER_CHARS=D.TOKEN=D.STRICT_TOKEN=D.HEX=D.URL_CHAR=D.STRICT_URL_CHAR=D.USERINFO_CHARS=D.MARK=D.ALPHANUM=D.NUM=D.HEX_MAP=D.NUM_MAP=D.ALPHA=D.FINISH=D.H_METHOD_MAP=D.METHOD_MAP=D.METHODS_RTSP=D.METHODS_ICE=D.METHODS_HTTP=D.METHODS=D.LENIENT_FLAGS=D.FLAGS=D.TYPE=D.ERROR=void 0;var jm=Zl(),Xm;(function(t){t[t.OK=0]="OK",t[t.INTERNAL=1]="INTERNAL",t[t.STRICT=2]="STRICT",t[t.LF_EXPECTED=3]="LF_EXPECTED",t[t.UNEXPECTED_CONTENT_LENGTH=4]="UNEXPECTED_CONTENT_LENGTH",t[t.CLOSED_CONNECTION=5]="CLOSED_CONNECTION",t[t.INVALID_METHOD=6]="INVALID_METHOD",t[t.INVALID_URL=7]="INVALID_URL",t[t.INVALID_CONSTANT=8]="INVALID_CONSTANT",t[t.INVALID_VERSION=9]="INVALID_VERSION",t[t.INVALID_HEADER_TOKEN=10]="INVALID_HEADER_TOKEN",t[t.INVALID_CONTENT_LENGTH=11]="INVALID_CONTENT_LENGTH",t[t.INVALID_CHUNK_SIZE=12]="INVALID_CHUNK_SIZE",t[t.INVALID_STATUS=13]="INVALID_STATUS",t[t.INVALID_EOF_STATE=14]="INVALID_EOF_STATE",t[t.INVALID_TRANSFER_ENCODING=15]="INVALID_TRANSFER_ENCODING",t[t.CB_MESSAGE_BEGIN=16]="CB_MESSAGE_BEGIN",t[t.CB_HEADERS_COMPLETE=17]="CB_HEADERS_COMPLETE",t[t.CB_MESSAGE_COMPLETE=18]="CB_MESSAGE_COMPLETE",t[t.CB_CHUNK_HEADER=19]="CB_CHUNK_HEADER",t[t.CB_CHUNK_COMPLETE=20]="CB_CHUNK_COMPLETE",t[t.PAUSED=21]="PAUSED",t[t.PAUSED_UPGRADE=22]="PAUSED_UPGRADE",t[t.PAUSED_H2_UPGRADE=23]="PAUSED_H2_UPGRADE",t[t.USER=24]="USER"})(Xm=D.ERROR||(D.ERROR={}));var $m;(function(t){t[t.BOTH=0]="BOTH",t[t.REQUEST=1]="REQUEST",t[t.RESPONSE=2]="RESPONSE"})($m=D.TYPE||(D.TYPE={}));var ew;(function(t){t[t.CONNECTION_KEEP_ALIVE=1]="CONNECTION_KEEP_ALIVE",t[t.CONNECTION_CLOSE=2]="CONNECTION_CLOSE",t[t.CONNECTION_UPGRADE=4]="CONNECTION_UPGRADE",t[t.CHUNKED=8]="CHUNKED",t[t.UPGRADE=16]="UPGRADE",t[t.CONTENT_LENGTH=32]="CONTENT_LENGTH",t[t.SKIPBODY=64]="SKIPBODY",t[t.TRAILING=128]="TRAILING",t[t.TRANSFER_ENCODING=512]="TRANSFER_ENCODING"})(ew=D.FLAGS||(D.FLAGS={}));var tw;(function(t){t[t.HEADERS=1]="HEADERS",t[t.CHUNKED_LENGTH=2]="CHUNKED_LENGTH",t[t.KEEP_ALIVE=4]="KEEP_ALIVE"})(tw=D.LENIENT_FLAGS||(D.LENIENT_FLAGS={}));var M;(function(t){t[t.DELETE=0]="DELETE",t[t.GET=1]="GET",t[t.HEAD=2]="HEAD",t[t.POST=3]="POST",t[t.PUT=4]="PUT",t[t.CONNECT=5]="CONNECT",t[t.OPTIONS=6]="OPTIONS",t[t.TRACE=7]="TRACE",t[t.COPY=8]="COPY",t[t.LOCK=9]="LOCK",t[t.MKCOL=10]="MKCOL",t[t.MOVE=11]="MOVE",t[t.PROPFIND=12]="PROPFIND",t[t.PROPPATCH=13]="PROPPATCH",t[t.SEARCH=14]="SEARCH",t[t.UNLOCK=15]="UNLOCK",t[t.BIND=16]="BIND",t[t.REBIND=17]="REBIND",t[t.UNBIND=18]="UNBIND",t[t.ACL=19]="ACL",t[t.REPORT=20]="REPORT",t[t.MKACTIVITY=21]="MKACTIVITY",t[t.CHECKOUT=22]="CHECKOUT",t[t.MERGE=23]="MERGE",t[t["M-SEARCH"]=24]="M-SEARCH",t[t.NOTIFY=25]="NOTIFY",t[t.SUBSCRIBE=26]="SUBSCRIBE",t[t.UNSUBSCRIBE=27]="UNSUBSCRIBE",t[t.PATCH=28]="PATCH",t[t.PURGE=29]="PURGE",t[t.MKCALENDAR=30]="MKCALENDAR",t[t.LINK=31]="LINK",t[t.UNLINK=32]="UNLINK",t[t.SOURCE=33]="SOURCE",t[t.PRI=34]="PRI",t[t.DESCRIBE=35]="DESCRIBE",t[t.ANNOUNCE=36]="ANNOUNCE",t[t.SETUP=37]="SETUP",t[t.PLAY=38]="PLAY",t[t.PAUSE=39]="PAUSE",t[t.TEARDOWN=40]="TEARDOWN",t[t.GET_PARAMETER=41]="GET_PARAMETER",t[t.SET_PARAMETER=42]="SET_PARAMETER",t[t.REDIRECT=43]="REDIRECT",t[t.RECORD=44]="RECORD",t[t.FLUSH=45]="FLUSH"})(M=D.METHODS||(D.METHODS={}));D.METHODS_HTTP=[M.DELETE,M.GET,M.HEAD,M.POST,M.PUT,M.CONNECT,M.OPTIONS,M.TRACE,M.COPY,M.LOCK,M.MKCOL,M.MOVE,M.PROPFIND,M.PROPPATCH,M.SEARCH,M.UNLOCK,M.BIND,M.REBIND,M.UNBIND,M.ACL,M.REPORT,M.MKACTIVITY,M.CHECKOUT,M.MERGE,M["M-SEARCH"],M.NOTIFY,M.SUBSCRIBE,M.UNSUBSCRIBE,M.PATCH,M.PURGE,M.MKCALENDAR,M.LINK,M.UNLINK,M.PRI,M.SOURCE];D.METHODS_ICE=[M.SOURCE];D.METHODS_RTSP=[M.OPTIONS,M.DESCRIBE,M.ANNOUNCE,M.SETUP,M.PLAY,M.PAUSE,M.TEARDOWN,M.GET_PARAMETER,M.SET_PARAMETER,M.REDIRECT,M.RECORD,M.FLUSH,M.GET,M.POST];D.METHOD_MAP=jm.enumToMap(M);D.H_METHOD_MAP={};Object.keys(D.METHOD_MAP).forEach(t=>{/^H/.test(t)&&(D.H_METHOD_MAP[t]=D.METHOD_MAP[t])});var rw;(function(t){t[t.SAFE=0]="SAFE",t[t.SAFE_WITH_CB=1]="SAFE_WITH_CB",t[t.UNSAFE=2]="UNSAFE"})(rw=D.FINISH||(D.FINISH={}));D.ALPHA=[];for(let t=65;t<=90;t++)D.ALPHA.push(String.fromCharCode(t)),D.ALPHA.push(String.fromCharCode(t+32));D.NUM_MAP={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9};D.HEX_MAP={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,A:10,B:11,C:12,D:13,E:14,F:15,a:10,b:11,c:12,d:13,e:14,f:15};D.NUM=["0","1","2","3","4","5","6","7","8","9"];D.ALPHANUM=D.ALPHA.concat(D.NUM);D.MARK=["-","_",".","!","~","*","'","(",")"];D.USERINFO_CHARS=D.ALPHANUM.concat(D.MARK).concat(["%",";",":","&","=","+","$",","]);D.STRICT_URL_CHAR=["!",'"',"$","%","&","'","(",")","*","+",",","-",".","/",":",";","<","=",">","@","[","\\","]","^","_","`","{","|","}","~"].concat(D.ALPHANUM);D.URL_CHAR=D.STRICT_URL_CHAR.concat([" ","\f"]);for(let t=128;t<=255;t++)D.URL_CHAR.push(t);D.HEX=D.NUM.concat(["a","b","c","d","e","f","A","B","C","D","E","F"]);D.STRICT_TOKEN=["!","#","$","%","&","'","*","+","-",".","^","_","`","|","~"].concat(D.ALPHANUM);D.TOKEN=D.STRICT_TOKEN.concat([" "]);D.HEADER_CHARS=[" "];for(let t=32;t<=255;t++)t!==127&&D.HEADER_CHARS.push(t);D.CONNECTION_TOKEN_CHARS=D.HEADER_CHARS.filter(t=>t!==44);D.MAJOR=D.NUM_MAP;D.MINOR=D.MAJOR;var Vr;(function(t){t[t.GENERAL=0]="GENERAL",t[t.CONNECTION=1]="CONNECTION",t[t.CONTENT_LENGTH=2]="CONTENT_LENGTH",t[t.TRANSFER_ENCODING=3]="TRANSFER_ENCODING",t[t.UPGRADE=4]="UPGRADE",t[t.CONNECTION_KEEP_ALIVE=5]="CONNECTION_KEEP_ALIVE",t[t.CONNECTION_CLOSE=6]="CONNECTION_CLOSE",t[t.CONNECTION_UPGRADE=7]="CONNECTION_UPGRADE",t[t.TRANSFER_ENCODING_CHUNKED=8]="TRANSFER_ENCODING_CHUNKED"})(Vr=D.HEADER_STATE||(D.HEADER_STATE={}));D.SPECIAL_HEADERS={connection:Vr.CONNECTION,"content-length":Vr.CONTENT_LENGTH,"proxy-connection":Vr.CONNECTION,"transfer-encoding":Vr.TRANSFER_ENCODING,upgrade:Vr.UPGRADE}});var Aa=m((sL,jl)=>{"use strict";var{Buffer:Aw}=require("node:buffer");jl.exports=Aw.from("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","base64")});var $l=m((oL,Xl)=>{"use strict";var{Buffer:sw}=require("node:buffer");Xl.exports=sw.from("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","base64")});var JA=m((nL,iE)=>{"use strict";var eE=["GET","HEAD","POST"],ow=new Set(eE),nw=[101,204,205,304],tE=[301,302,303,307,308],iw=new Set(tE),rE=["1","7","9","11","13","15","17","19","20","21","22","23","25","37","42","43","53","69","77","79","87","95","101","102","103","104","109","110","111","113","115","117","119","123","135","137","139","143","161","179","389","427","465","512","513","514","515","526","530","531","532","540","548","554","556","563","587","601","636","989","990","993","995","1719","1720","1723","2049","3659","4045","4190","5060","5061","6000","6566","6665","6666","6667","6668","6669","6679","6697","10080"],aw=new Set(rE),AE=["","no-referrer","no-referrer-when-downgrade","same-origin","origin","strict-origin","origin-when-cross-origin","strict-origin-when-cross-origin","unsafe-url"],cw=new Set(AE),gw=["follow","manual","error"],sE=["GET","HEAD","OPTIONS","TRACE"],uw=new Set(sE),lw=["navigate","same-origin","no-cors","cors"],Ew=["omit","same-origin","include"],hw=["default","no-store","reload","no-cache","force-cache","only-if-cached"],Qw=["content-encoding","content-language","content-location","content-type","content-length"],dw=["half"],oE=["CONNECT","TRACE","TRACK"],Bw=new Set(oE),nE=["audio","audioworklet","font","image","manifest","paintworklet","script","style","track","video","xslt",""],Iw=new Set(nE);iE.exports={subresource:nE,forbiddenMethods:oE,requestBodyHeader:Qw,referrerPolicy:AE,requestRedirect:gw,requestMode:lw,requestCredentials:Ew,requestCache:hw,redirectStatus:tE,corsSafeListedMethods:eE,nullBodyStatus:nw,safeMethods:sE,badPorts:rE,requestDuplex:dw,subresourceSet:Iw,badPortsSet:aw,redirectStatusSet:iw,corsSafeListedMethodsSet:ow,safeMethodsSet:uw,forbiddenMethodsSet:Bw,referrerPolicySet:cw}});var oa=m((iL,aE)=>{"use strict";var sa=Symbol.for("undici.globalOrigin.1");function Cw(){return globalThis[sa]}function pw(t){if(t===void 0){Object.defineProperty(globalThis,sa,{value:void 0,writable:!0,enumerable:!1,configurable:!1});return}let e=new URL(t);if(e.protocol!=="http:"&&e.protocol!=="https:")throw new TypeError(`Only http & https urls are allowed, received ${e.protocol}`);Object.defineProperty(globalThis,sa,{value:e,writable:!0,enumerable:!1,configurable:!1})}aE.exports={getGlobalOrigin:Cw,setGlobalOrigin:pw}});var ye=m((aL,QE)=>{"use strict";var go=require("node:assert"),fw=new TextEncoder,HA=/^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/,mw=/[\u000A\u000D\u0009\u0020]/,ww=/[\u0009\u000A\u000C\u000D\u0020]/g,yw=/^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;function bw(t){go(t.protocol==="data:");let e=uE(t,!0);e=e.slice(5);let r={position:0},A=qr(",",e,r),s=A.length;if(A=Sw(A,!0,!0),r.position>=e.length)return"failure";r.position++;let o=e.slice(s+1),n=lE(o);if(/;(\u0020){0,}base64$/i.test(A)){let a=hE(n);if(n=kw(a),n==="failure")return"failure";A=A.slice(0,-6),A=A.replace(/(\u0020)+$/,""),A=A.slice(0,-1)}A.startsWith(";")&&(A="text/plain"+A);let i=na(A);return i==="failure"&&(i=na("text/plain;charset=US-ASCII")),{mimeType:i,body:n}}function uE(t,e=!1){if(!e)return t.href;let r=t.href,A=t.hash.length,s=A===0?r:r.substring(0,r.length-A);return!A&&r.endsWith("#")?s.slice(0,-1):s}function uo(t,e,r){let A="";for(;r.position=48&&t<=57||t>=65&&t<=70||t>=97&&t<=102}function gE(t){return t>=48&&t<=57?t-48:(t&223)-55}function Dw(t){let e=t.length,r=new Uint8Array(e),A=0;for(let s=0;st.length)return"failure";e.position++;let A=qr(";",t,e);if(A=co(A,!1,!0),A.length===0||!HA.test(A))return"failure";let s=r.toLowerCase(),o=A.toLowerCase(),n={type:s,subtype:o,parameters:new Map,essence:`${s}/${o}`};for(;e.positionmw.test(c),t,e);let i=uo(c=>c!==";"&&c!=="=",t,e);if(i=i.toLowerCase(),e.positiont.length)break;let a=null;if(t[e.position]==='"')a=EE(t,e,!0),qr(";",t,e);else if(a=qr(";",t,e),a=co(a,!1,!0),a.length===0)continue;i.length!==0&&HA.test(i)&&(a.length===0||yw.test(a))&&!n.parameters.has(i)&&n.parameters.set(i,a)}return n}function kw(t){t=t.replace(ww,"");let e=t.length;if(e%4===0&&t.charCodeAt(e-1)===61&&(--e,t.charCodeAt(e-1)===61&&--e),e%4===1||/[^+/0-9A-Za-z]/.test(t.length===e?t:t.substring(0,e)))return"failure";let r=Buffer.from(t,"base64");return new Uint8Array(r.buffer,r.byteOffset,r.byteLength)}function EE(t,e,r){let A=e.position,s="";for(go(t[e.position]==='"'),e.position++;s+=uo(n=>n!=='"'&&n!=="\\",t,e),!(e.position>=t.length);){let o=t[e.position];if(e.position++,o==="\\"){if(e.position>=t.length){s+="\\";break}s+=t[e.position],e.position++}else{go(o==='"');break}}return r?s:t.slice(A,e.position)}function Rw(t){go(t!=="failure");let{parameters:e,essence:r}=t,A=r;for(let[s,o]of e.entries())A+=";",A+=s,A+="=",HA.test(o)||(o=o.replace(/(\\|")/g,"\\$1"),o='"'+o,o+='"'),A+=o;return A}function Tw(t){return t===13||t===10||t===9||t===32}function co(t,e=!0,r=!0){return ia(t,e,r,Tw)}function Fw(t){return t===13||t===10||t===9||t===12||t===32}function Sw(t,e=!0,r=!0){return ia(t,e,r,Fw)}function ia(t,e,r,A){let s=0,o=t.length-1;if(e)for(;s0&&A(t.charCodeAt(o));)o--;return s===0&&o===t.length-1?t:t.slice(s,o+1)}function hE(t){let e=t.length;if(65535>e)return String.fromCharCode.apply(null,t);let r="",A=0,s=65535;for(;Ae&&(s=e-A),r+=String.fromCharCode.apply(null,t.subarray(A,A+=s));return r}function Uw(t){switch(t.essence){case"application/ecmascript":case"application/javascript":case"application/x-ecmascript":case"application/x-javascript":case"text/ecmascript":case"text/javascript":case"text/javascript1.0":case"text/javascript1.1":case"text/javascript1.2":case"text/javascript1.3":case"text/javascript1.4":case"text/javascript1.5":case"text/jscript":case"text/livescript":case"text/x-ecmascript":case"text/x-javascript":return"text/javascript";case"application/json":case"text/json":return"application/json";case"image/svg+xml":return"image/svg+xml";case"text/xml":case"application/xml":return"application/xml"}return t.subtype.endsWith("+json")?"application/json":t.subtype.endsWith("+xml")?"application/xml":""}QE.exports={dataURLProcessor:bw,URLSerializer:uE,collectASequenceOfCodePoints:uo,collectASequenceOfCodePointsFast:qr,stringPercentDecode:lE,parseMIMEType:na,collectAnHTTPQuotedString:EE,serializeAMimeType:Rw,removeChars:ia,removeHTTPWhitespace:co,minimizeSupportedMimeType:Uw,HTTP_TOKEN_CODEPOINTS:HA,isomorphicDecode:hE}});var Be=m((cL,dE)=>{"use strict";var{types:at,inspect:Nw}=require("node:util"),{markAsUncloneable:Gw}=require("node:worker_threads"),{toUSVString:Mw}=O(),b={};b.converters={};b.util={};b.errors={};b.errors.exception=function(t){return new TypeError(`${t.header}: ${t.message}`)};b.errors.conversionFailed=function(t){let e=t.types.length===1?"":" one of",r=`${t.argument} could not be converted to${e}: ${t.types.join(", ")}.`;return b.errors.exception({header:t.prefix,message:r})};b.errors.invalidArgument=function(t){return b.errors.exception({header:t.prefix,message:`"${t.value}" is an invalid ${t.type}.`})};b.brandCheck=function(t,e,r){if(r?.strict!==!1){if(!(t instanceof e)){let A=new TypeError("Illegal invocation");throw A.code="ERR_INVALID_THIS",A}}else if(t?.[Symbol.toStringTag]!==e.prototype[Symbol.toStringTag]){let A=new TypeError("Illegal invocation");throw A.code="ERR_INVALID_THIS",A}};b.argumentLengthCheck=function({length:t},e,r){if(t{});b.util.ConvertToInt=function(t,e,r,A){let s,o;e===64?(s=Math.pow(2,53)-1,r==="unsigned"?o=0:o=Math.pow(-2,53)+1):r==="unsigned"?(o=0,s=Math.pow(2,e)-1):(o=Math.pow(-2,e)-1,s=Math.pow(2,e-1)-1);let n=Number(t);if(n===0&&(n=0),A?.enforceRange===!0){if(Number.isNaN(n)||n===Number.POSITIVE_INFINITY||n===Number.NEGATIVE_INFINITY)throw b.errors.exception({header:"Integer conversion",message:`Could not convert ${b.util.Stringify(t)} to an integer.`});if(n=b.util.IntegerPart(n),ns)throw b.errors.exception({header:"Integer conversion",message:`Value must be between ${o}-${s}, got ${n}.`});return n}return!Number.isNaN(n)&&A?.clamp===!0?(n=Math.min(Math.max(n,o),s),Math.floor(n)%2===0?n=Math.floor(n):n=Math.ceil(n),n):Number.isNaN(n)||n===0&&Object.is(0,n)||n===Number.POSITIVE_INFINITY||n===Number.NEGATIVE_INFINITY?0:(n=b.util.IntegerPart(n),n=n%Math.pow(2,e),r==="signed"&&n>=Math.pow(2,e)-1?n-Math.pow(2,e):n)};b.util.IntegerPart=function(t){let e=Math.floor(Math.abs(t));return t<0?-1*e:e};b.util.Stringify=function(t){switch(b.util.Type(t)){case"Symbol":return`Symbol(${t.description})`;case"Object":return Nw(t);case"String":return`"${t}"`;default:return`${t}`}};b.sequenceConverter=function(t){return(e,r,A,s)=>{if(b.util.Type(e)!=="Object")throw b.errors.exception({header:r,message:`${A} (${b.util.Stringify(e)}) is not iterable.`});let o=typeof s=="function"?s():e?.[Symbol.iterator]?.(),n=[],i=0;if(o===void 0||typeof o.next!="function")throw b.errors.exception({header:r,message:`${A} is not iterable.`});for(;;){let{done:a,value:c}=o.next();if(a)break;n.push(t(c,r,`${A}[${i++}]`))}return n}};b.recordConverter=function(t,e){return(r,A,s)=>{if(b.util.Type(r)!=="Object")throw b.errors.exception({header:A,message:`${s} ("${b.util.Type(r)}") is not an Object.`});let o={};if(!at.isProxy(r)){let i=[...Object.getOwnPropertyNames(r),...Object.getOwnPropertySymbols(r)];for(let a of i){let c=t(a,A,s),u=e(r[a],A,s);o[c]=u}return o}let n=Reflect.ownKeys(r);for(let i of n)if(Reflect.getOwnPropertyDescriptor(r,i)?.enumerable){let c=t(i,A,s),u=e(r[i],A,s);o[c]=u}return o}};b.interfaceConverter=function(t){return(e,r,A,s)=>{if(s?.strict!==!1&&!(e instanceof t))throw b.errors.exception({header:r,message:`Expected ${A} ("${b.util.Stringify(e)}") to be an instance of ${t.name}.`});return e}};b.dictionaryConverter=function(t){return(e,r,A)=>{let s=b.util.Type(e),o={};if(s==="Null"||s==="Undefined")return o;if(s!=="Object")throw b.errors.exception({header:r,message:`Expected ${e} to be one of: Null, Undefined, Object.`});for(let n of t){let{key:i,defaultValue:a,required:c,converter:u}=n;if(c===!0&&!Object.hasOwn(e,i))throw b.errors.exception({header:r,message:`Missing required key "${i}".`});let g=e[i],E=Object.hasOwn(n,"defaultValue");if(E&&g!==null&&(g??=a()),c||E||g!==void 0){if(g=u(g,r,`${A}.${i}`),n.allowedValues&&!n.allowedValues.includes(g))throw b.errors.exception({header:r,message:`${g} is not an accepted type. Expected one of ${n.allowedValues.join(", ")}.`});o[i]=g}}return o}};b.nullableConverter=function(t){return(e,r,A)=>e===null?e:t(e,r,A)};b.converters.DOMString=function(t,e,r,A){if(t===null&&A?.legacyNullToEmptyString)return"";if(typeof t=="symbol")throw b.errors.exception({header:e,message:`${r} is a symbol, which cannot be converted to a DOMString.`});return String(t)};b.converters.ByteString=function(t,e,r){let A=b.converters.DOMString(t,e,r);for(let s=0;s255)throw new TypeError(`Cannot convert argument to a ByteString because the character at index ${s} has a value of ${A.charCodeAt(s)} which is greater than 255.`);return A};b.converters.USVString=Mw;b.converters.boolean=function(t){return!!t};b.converters.any=function(t){return t};b.converters["long long"]=function(t,e,r){return b.util.ConvertToInt(t,64,"signed",void 0,e,r)};b.converters["unsigned long long"]=function(t,e,r){return b.util.ConvertToInt(t,64,"unsigned",void 0,e,r)};b.converters["unsigned long"]=function(t,e,r){return b.util.ConvertToInt(t,32,"unsigned",void 0,e,r)};b.converters["unsigned short"]=function(t,e,r,A){return b.util.ConvertToInt(t,16,"unsigned",A,e,r)};b.converters.ArrayBuffer=function(t,e,r,A){if(b.util.Type(t)!=="Object"||!at.isAnyArrayBuffer(t))throw b.errors.conversionFailed({prefix:e,argument:`${r} ("${b.util.Stringify(t)}")`,types:["ArrayBuffer"]});if(A?.allowShared===!1&&at.isSharedArrayBuffer(t))throw b.errors.exception({header:"ArrayBuffer",message:"SharedArrayBuffer is not allowed."});if(t.resizable||t.growable)throw b.errors.exception({header:"ArrayBuffer",message:"Received a resizable ArrayBuffer."});return t};b.converters.TypedArray=function(t,e,r,A,s){if(b.util.Type(t)!=="Object"||!at.isTypedArray(t)||t.constructor.name!==e.name)throw b.errors.conversionFailed({prefix:r,argument:`${A} ("${b.util.Stringify(t)}")`,types:[e.name]});if(s?.allowShared===!1&&at.isSharedArrayBuffer(t.buffer))throw b.errors.exception({header:"ArrayBuffer",message:"SharedArrayBuffer is not allowed."});if(t.buffer.resizable||t.buffer.growable)throw b.errors.exception({header:"ArrayBuffer",message:"Received a resizable ArrayBuffer."});return t};b.converters.DataView=function(t,e,r,A){if(b.util.Type(t)!=="Object"||!at.isDataView(t))throw b.errors.exception({header:e,message:`${r} is not a DataView.`});if(A?.allowShared===!1&&at.isSharedArrayBuffer(t.buffer))throw b.errors.exception({header:"ArrayBuffer",message:"SharedArrayBuffer is not allowed."});if(t.buffer.resizable||t.buffer.growable)throw b.errors.exception({header:"ArrayBuffer",message:"Received a resizable ArrayBuffer."});return t};b.converters.BufferSource=function(t,e,r,A){if(at.isAnyArrayBuffer(t))return b.converters.ArrayBuffer(t,e,r,{...A,allowShared:!1});if(at.isTypedArray(t))return b.converters.TypedArray(t,t.constructor,e,r,{...A,allowShared:!1});if(at.isDataView(t))return b.converters.DataView(t,e,r,{...A,allowShared:!1});throw b.errors.conversionFailed({prefix:e,argument:`${r} ("${b.util.Stringify(t)}")`,types:["BufferSource"]})};b.converters["sequence"]=b.sequenceConverter(b.converters.ByteString);b.converters["sequence>"]=b.sequenceConverter(b.converters["sequence"]);b.converters["record"]=b.recordConverter(b.converters.ByteString,b.converters.ByteString);dE.exports={webidl:b}});var Fe=m((gL,FE)=>{"use strict";var{Transform:Lw}=require("node:stream"),BE=require("node:zlib"),{redirectStatusSet:vw,referrerPolicySet:_w,badPortsSet:xw}=JA(),{getGlobalOrigin:IE}=oa(),{collectASequenceOfCodePoints:ar,collectAnHTTPQuotedString:Yw,removeChars:Ow,parseMIMEType:Jw}=ye(),{performance:Hw}=require("node:perf_hooks"),{isBlobLike:Pw,ReadableStreamFrom:Vw,isValidHTTPToken:CE,normalizedMethodRecordsBase:qw}=O(),cr=require("node:assert"),{isUint8Array:Ww}=require("node:util/types"),{webidl:PA}=Be(),pE=[],Eo;try{Eo=require("node:crypto");let t=["sha256","sha384","sha512"];pE=Eo.getHashes().filter(e=>t.includes(e))}catch{}function fE(t){let e=t.urlList,r=e.length;return r===0?null:e[r-1].toString()}function zw(t,e){if(!vw.has(t.status))return null;let r=t.headersList.get("location",!0);return r!==null&&wE(r)&&(mE(r)||(r=Zw(r)),r=new URL(r,fE(t))),r&&!r.hash&&(r.hash=e),r}function mE(t){for(let e=0;e126||r<32)return!1}return!0}function Zw(t){return Buffer.from(t,"binary").toString("utf8")}function qA(t){return t.urlList[t.urlList.length-1]}function Kw(t){let e=qA(t);return RE(e)&&xw.has(e.port)?"blocked":"allowed"}function jw(t){return t instanceof Error||t?.constructor?.name==="Error"||t?.constructor?.name==="DOMException"}function Xw(t){for(let e=0;e=32&&r<=126||r>=128&&r<=255))return!1}return!0}var $w=CE;function wE(t){return(t[0]===" "||t[0]===" "||t[t.length-1]===" "||t[t.length-1]===" "||t.includes(` +`)||t.includes("\r")||t.includes("\0"))===!1}function ey(t,e){let{headersList:r}=e,A=(r.get("referrer-policy",!0)??"").split(","),s="";if(A.length>0)for(let o=A.length;o!==0;o--){let n=A[o-1].trim();if(_w.has(n)){s=n;break}}s!==""&&(t.referrerPolicy=s)}function ty(){return"allowed"}function ry(){return"success"}function Ay(){return"success"}function sy(t){let e=null;e=t.mode,t.headersList.set("sec-fetch-mode",e,!0)}function oy(t){let e=t.origin;if(!(e==="client"||e===void 0)){if(t.responseTainting==="cors"||t.mode==="websocket")t.headersList.append("origin",e,!0);else if(t.method!=="GET"&&t.method!=="HEAD"){switch(t.referrerPolicy){case"no-referrer":e=null;break;case"no-referrer-when-downgrade":case"strict-origin":case"strict-origin-when-cross-origin":t.origin&&ca(t.origin)&&!ca(qA(t))&&(e=null);break;case"same-origin":ho(t,qA(t))||(e=null);break;default:}t.headersList.append("origin",e,!0)}}}function Wr(t,e){return t}function ny(t,e,r){return!t?.startTime||t.startTime4096&&(A=s);let o=ho(t,A),n=VA(A)&&!VA(t.url);switch(e){case"origin":return s??aa(r,!0);case"unsafe-url":return A;case"same-origin":return o?s:"no-referrer";case"origin-when-cross-origin":return o?A:s;case"strict-origin-when-cross-origin":{let i=qA(t);return ho(A,i)?A:VA(A)&&!VA(i)?"no-referrer":s}default:return n?"no-referrer":s}}function aa(t,e){return cr(t instanceof URL),t=new URL(t),t.protocol==="file:"||t.protocol==="about:"||t.protocol==="blank:"?"no-referrer":(t.username="",t.password="",t.hash="",e&&(t.pathname="",t.search=""),t)}function VA(t){if(!(t instanceof URL))return!1;if(t.href==="about:blank"||t.href==="about:srcdoc"||t.protocol==="data:"||t.protocol==="file:")return!0;return e(t.origin);function e(r){if(r==null||r==="null")return!1;let A=new URL(r);return!!(A.protocol==="https:"||A.protocol==="wss:"||/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(A.hostname)||A.hostname==="localhost"||A.hostname.includes("localhost.")||A.hostname.endsWith(".localhost"))}}function uy(t,e){if(Eo===void 0)return!0;let r=bE(e);if(r==="no metadata"||r.length===0)return!0;let A=Ey(r),s=hy(r,A);for(let o of s){let n=o.algo,i=o.hash,a=Eo.createHash(n).update(t).digest("base64");if(a[a.length-1]==="="&&(a[a.length-2]==="="?a=a.slice(0,-2):a=a.slice(0,-1)),Qy(a,i))return!0}return!1}var ly=/(?sha256|sha384|sha512)-((?[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i;function bE(t){let e=[],r=!0;for(let A of t.split(" ")){r=!1;let s=ly.exec(A);if(s===null||s.groups===void 0||s.groups.algo===void 0)continue;let o=s.groups.algo.toLowerCase();pE.includes(o)&&e.push(s.groups)}return r===!0?"no metadata":e}function Ey(t){let e=t[0].algo;if(e[3]==="5")return e;for(let r=1;r{t=A,e=s}),resolve:t,reject:e}}function Iy(t){return t.controller.state==="aborted"}function Cy(t){return t.controller.state==="aborted"||t.controller.state==="terminated"}function py(t){return qw[t.toLowerCase()]??t}function fy(t){let e=JSON.stringify(t);if(e===void 0)throw new TypeError("Value is not JSON serializable");return cr(typeof e=="string"),e}var my=Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()));function DE(t,e,r=0,A=1){class s{#e;#t;#r;constructor(n,i){this.#e=n,this.#t=i,this.#r=0}next(){if(typeof this!="object"||this===null||!(#e in this))throw new TypeError(`'next' called on an object that does not implement interface ${t} Iterator.`);let n=this.#r,i=this.#e[e],a=i.length;if(n>=a)return{value:void 0,done:!0};let{[r]:c,[A]:u}=i[n];this.#r=n+1;let g;switch(this.#t){case"key":g=c;break;case"value":g=u;break;case"key+value":g=[c,u];break}return{value:g,done:!1}}}return delete s.prototype.constructor,Object.setPrototypeOf(s.prototype,my),Object.defineProperties(s.prototype,{[Symbol.toStringTag]:{writable:!1,enumerable:!1,configurable:!0,value:`${t} Iterator`},next:{writable:!0,enumerable:!0,configurable:!0}}),function(o,n){return new s(o,n)}}function wy(t,e,r,A=0,s=1){let o=DE(t,r,A,s),n={keys:{writable:!0,enumerable:!0,configurable:!0,value:function(){return PA.brandCheck(this,e),o(this,"key")}},values:{writable:!0,enumerable:!0,configurable:!0,value:function(){return PA.brandCheck(this,e),o(this,"value")}},entries:{writable:!0,enumerable:!0,configurable:!0,value:function(){return PA.brandCheck(this,e),o(this,"key+value")}},forEach:{writable:!0,enumerable:!0,configurable:!0,value:function(a,c=globalThis){if(PA.brandCheck(this,e),PA.argumentLengthCheck(arguments,1,`${t}.forEach`),typeof a!="function")throw new TypeError(`Failed to execute 'forEach' on '${t}': parameter 1 is not of type 'Function'.`);for(let{0:u,1:g}of o(this,"key+value"))a.call(c,g,u,this)}}};return Object.defineProperties(e.prototype,{...n,[Symbol.iterator]:{writable:!0,enumerable:!1,configurable:!0,value:n.entries.value}})}async function yy(t,e,r){let A=e,s=r,o;try{o=t.stream.getReader()}catch(n){s(n);return}try{A(await kE(o))}catch(n){s(n)}}function by(t){return t instanceof ReadableStream||t[Symbol.toStringTag]==="ReadableStream"&&typeof t.tee=="function"}function Dy(t){try{t.close(),t.byobRequest?.respond(0)}catch(e){if(!e.message.includes("Controller is already closed")&&!e.message.includes("ReadableStream is already closed"))throw e}}var ky=/[^\x00-\xFF]/;function lo(t){return cr(!ky.test(t)),t}async function kE(t){let e=[],r=0;for(;;){let{done:A,value:s}=await t.read();if(A)return Buffer.concat(e,r);if(!Ww(s))throw new TypeError("Received non-Uint8Array chunk");e.push(s),r+=s.length}}function Ry(t){cr("protocol"in t);let e=t.protocol;return e==="about:"||e==="blob:"||e==="data:"}function ca(t){return typeof t=="string"&&t[5]===":"&&t[0]==="h"&&t[1]==="t"&&t[2]==="t"&&t[3]==="p"&&t[4]==="s"||t.protocol==="https:"}function RE(t){cr("protocol"in t);let e=t.protocol;return e==="http:"||e==="https:"}function Ty(t,e){let r=t;if(!r.startsWith("bytes"))return"failure";let A={position:5};if(e&&ar(a=>a===" "||a===" ",r,A),r.charCodeAt(A.position)!==61)return"failure";A.position++,e&&ar(a=>a===" "||a===" ",r,A);let s=ar(a=>{let c=a.charCodeAt(0);return c>=48&&c<=57},r,A),o=s.length?Number(s):null;if(e&&ar(a=>a===" "||a===" ",r,A),r.charCodeAt(A.position)!==45)return"failure";A.position++,e&&ar(a=>a===" "||a===" ",r,A);let n=ar(a=>{let c=a.charCodeAt(0);return c>=48&&c<=57},r,A),i=n.length?Number(n):null;return A.positioni?"failure":{rangeStartValue:o,rangeEndValue:i}}function Fy(t,e,r){let A="bytes ";return A+=lo(`${t}`),A+="-",A+=lo(`${e}`),A+="/",A+=lo(`${r}`),A}var ga=class extends Lw{#e;constructor(e){super(),this.#e=e}_transform(e,r,A){if(!this._inflateStream){if(e.length===0){A();return}this._inflateStream=(e[0]&15)===8?BE.createInflate(this.#e):BE.createInflateRaw(this.#e),this._inflateStream.on("data",this.push.bind(this)),this._inflateStream.on("end",()=>this.push(null)),this._inflateStream.on("error",s=>this.destroy(s))}this._inflateStream.write(e,r,A)}_final(e){this._inflateStream&&(this._inflateStream.end(),this._inflateStream=null),e()}};function Sy(t){return new ga(t)}function Uy(t){let e=null,r=null,A=null,s=TE("content-type",t);if(s===null)return"failure";for(let o of s){let n=Jw(o);n==="failure"||n.essence==="*/*"||(A=n,A.essence!==r?(e=null,A.parameters.has("charset")&&(e=A.parameters.get("charset")),r=A.essence):!A.parameters.has("charset")&&e!==null&&A.parameters.set("charset",e))}return A??"failure"}function Ny(t){let e=t,r={position:0},A=[],s="";for(;r.positiono!=='"'&&o!==",",e,r),r.positiono===9||o===32),A.push(s),s=""}return A}function TE(t,e){let r=e.get(t,!0);return r===null?null:Ny(r)}var Gy=new TextDecoder;function My(t){return t.length===0?"":(t[0]===239&&t[1]===187&&t[2]===191&&(t=t.subarray(3)),Gy.decode(t))}var ua=class{get baseUrl(){return IE()}get origin(){return this.baseUrl?.origin}policyContainer=yE()},la=class{settingsObject=new ua},Ly=new la;FE.exports={isAborted:Iy,isCancelled:Cy,isValidEncodedURL:mE,createDeferredPromise:By,ReadableStreamFrom:Vw,tryUpgradeRequestToAPotentiallyTrustworthyURL:dy,clampAndCoarsenConnectionTimingInfo:ny,coarsenedSharedCurrentTime:iy,determineRequestsReferrer:gy,makePolicyContainer:yE,clonePolicyContainer:cy,appendFetchMetadata:sy,appendRequestOriginHeader:oy,TAOCheck:Ay,corsCheck:ry,crossOriginResourcePolicyCheck:ty,createOpaqueTimingInfo:ay,setRequestReferrerPolicyOnRedirect:ey,isValidHTTPToken:CE,requestBadPort:Kw,requestCurrentURL:qA,responseURL:fE,responseLocationURL:zw,isBlobLike:Pw,isURLPotentiallyTrustworthy:VA,isValidReasonPhrase:Xw,sameOrigin:ho,normalizeMethod:py,serializeJavascriptValueToJSONString:fy,iteratorMixin:wy,createIterator:DE,isValidHeaderName:$w,isValidHeaderValue:wE,isErrorLike:jw,fullyReadBody:yy,bytesMatch:uy,isReadableStreamLike:by,readableStreamClose:Dy,isomorphicEncode:lo,urlIsLocal:Ry,urlHasHttpsScheme:ca,urlIsHttpHttpsScheme:RE,readAllBytes:kE,simpleRangeHeaderValue:Ty,buildContentRange:Fy,parseMetadata:bE,createInflate:Sy,extractMimeType:Uy,getDecodeSplit:TE,utf8DecodeBytes:My,environmentSettingsObject:Ly}});var Yt=m((uL,SE)=>{"use strict";SE.exports={kUrl:Symbol("url"),kHeaders:Symbol("headers"),kSignal:Symbol("signal"),kState:Symbol("state"),kDispatcher:Symbol("dispatcher")}});var ha=m((lL,UE)=>{"use strict";var{Blob:vy,File:_y}=require("node:buffer"),{kState:Dt}=Yt(),{webidl:ct}=Be(),Ea=class t{constructor(e,r,A={}){let s=r,o=A.type,n=A.lastModified??Date.now();this[Dt]={blobLike:e,name:s,type:o,lastModified:n}}stream(...e){return ct.brandCheck(this,t),this[Dt].blobLike.stream(...e)}arrayBuffer(...e){return ct.brandCheck(this,t),this[Dt].blobLike.arrayBuffer(...e)}slice(...e){return ct.brandCheck(this,t),this[Dt].blobLike.slice(...e)}text(...e){return ct.brandCheck(this,t),this[Dt].blobLike.text(...e)}get size(){return ct.brandCheck(this,t),this[Dt].blobLike.size}get type(){return ct.brandCheck(this,t),this[Dt].blobLike.type}get name(){return ct.brandCheck(this,t),this[Dt].name}get lastModified(){return ct.brandCheck(this,t),this[Dt].lastModified}get[Symbol.toStringTag](){return"File"}};ct.converters.Blob=ct.interfaceConverter(vy);function xy(t){return t instanceof _y||t&&(typeof t.stream=="function"||typeof t.arrayBuffer=="function")&&t[Symbol.toStringTag]==="File"}UE.exports={FileLike:Ea,isFileLike:xy}});var zA=m((EL,vE)=>{"use strict";var{isBlobLike:Qo,iteratorMixin:Yy}=Fe(),{kState:fe}=Yt(),{kEnumerableProperty:zr}=O(),{FileLike:NE,isFileLike:Oy}=ha(),{webidl:te}=Be(),{File:LE}=require("node:buffer"),GE=require("node:util"),ME=globalThis.File??LE,WA=class t{constructor(e){if(te.util.markAsUncloneable(this),e!==void 0)throw te.errors.conversionFailed({prefix:"FormData constructor",argument:"Argument 1",types:["undefined"]});this[fe]=[]}append(e,r,A=void 0){te.brandCheck(this,t);let s="FormData.append";if(te.argumentLengthCheck(arguments,2,s),arguments.length===3&&!Qo(r))throw new TypeError("Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'");e=te.converters.USVString(e,s,"name"),r=Qo(r)?te.converters.Blob(r,s,"value",{strict:!1}):te.converters.USVString(r,s,"value"),A=arguments.length===3?te.converters.USVString(A,s,"filename"):void 0;let o=Qa(e,r,A);this[fe].push(o)}delete(e){te.brandCheck(this,t);let r="FormData.delete";te.argumentLengthCheck(arguments,1,r),e=te.converters.USVString(e,r,"name"),this[fe]=this[fe].filter(A=>A.name!==e)}get(e){te.brandCheck(this,t);let r="FormData.get";te.argumentLengthCheck(arguments,1,r),e=te.converters.USVString(e,r,"name");let A=this[fe].findIndex(s=>s.name===e);return A===-1?null:this[fe][A].value}getAll(e){te.brandCheck(this,t);let r="FormData.getAll";return te.argumentLengthCheck(arguments,1,r),e=te.converters.USVString(e,r,"name"),this[fe].filter(A=>A.name===e).map(A=>A.value)}has(e){te.brandCheck(this,t);let r="FormData.has";return te.argumentLengthCheck(arguments,1,r),e=te.converters.USVString(e,r,"name"),this[fe].findIndex(A=>A.name===e)!==-1}set(e,r,A=void 0){te.brandCheck(this,t);let s="FormData.set";if(te.argumentLengthCheck(arguments,2,s),arguments.length===3&&!Qo(r))throw new TypeError("Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'");e=te.converters.USVString(e,s,"name"),r=Qo(r)?te.converters.Blob(r,s,"name",{strict:!1}):te.converters.USVString(r,s,"name"),A=arguments.length===3?te.converters.USVString(A,s,"name"):void 0;let o=Qa(e,r,A),n=this[fe].findIndex(i=>i.name===e);n!==-1?this[fe]=[...this[fe].slice(0,n),o,...this[fe].slice(n+1).filter(i=>i.name!==e)]:this[fe].push(o)}[GE.inspect.custom](e,r){let A=this[fe].reduce((o,n)=>(o[n.name]?Array.isArray(o[n.name])?o[n.name].push(n.value):o[n.name]=[o[n.name],n.value]:o[n.name]=n.value,o),{__proto__:null});r.depth??=e,r.colors??=!0;let s=GE.formatWithOptions(r,A);return`FormData ${s.slice(s.indexOf("]")+2)}`}};Yy("FormData",WA,fe,"name","value");Object.defineProperties(WA.prototype,{append:zr,delete:zr,get:zr,getAll:zr,has:zr,set:zr,[Symbol.toStringTag]:{value:"FormData",configurable:!0}});function Qa(t,e,r){if(typeof e!="string"){if(Oy(e)||(e=e instanceof Blob?new ME([e],"blob",{type:e.type}):new NE(e,"blob",{type:e.type})),r!==void 0){let A={type:e.type,lastModified:e.lastModified};e=e instanceof LE?new ME([e],r,A):new NE(e,r,A)}}return{name:t,value:e}}vE.exports={FormData:WA,makeEntry:Qa}});var HE=m((hL,JE)=>{"use strict";var{isUSVString:_E,bufferToLowerCasedHeaderName:Jy}=O(),{utf8DecodeBytes:Hy}=Fe(),{HTTP_TOKEN_CODEPOINTS:Py,isomorphicDecode:xE}=ye(),{isFileLike:Vy}=ha(),{makeEntry:qy}=zA(),Bo=require("node:assert"),{File:Wy}=require("node:buffer"),zy=globalThis.File??Wy,Zy=Buffer.from('form-data; name="'),YE=Buffer.from("; filename"),Ky=Buffer.from("--"),jy=Buffer.from(`--\r +`);function Xy(t){for(let e=0;e70)return!1;for(let r=0;r=48&&A<=57||A>=65&&A<=90||A>=97&&A<=122||A===39||A===45||A===95))return!1}return!0}function eb(t,e){Bo(e!=="failure"&&e.essence==="multipart/form-data");let r=e.parameters.get("boundary");if(r===void 0)return"failure";let A=Buffer.from(`--${r}`,"utf8"),s=[],o={position:0};for(;t[o.position]===13&&t[o.position+1]===10;)o.position+=2;let n=t.length;for(;t[n-1]===10&&t[n-2]===13;)n-=2;for(n!==t.length&&(t=t.subarray(0,n));;){if(t.subarray(o.position,o.position+A.length).equals(A))o.position+=A.length;else return"failure";if(o.position===t.length-2&&Io(t,Ky,o)||o.position===t.length-4&&Io(t,jy,o))return s;if(t[o.position]!==13||t[o.position+1]!==10)return"failure";o.position+=2;let i=tb(t,o);if(i==="failure")return"failure";let{name:a,filename:c,contentType:u,encoding:g}=i;o.position+=2;let E;{let d=t.indexOf(A.subarray(2),o.position);if(d===-1)return"failure";E=t.subarray(o.position,d-4),o.position+=E.length,g==="base64"&&(E=Buffer.from(E.toString(),"base64"))}if(t[o.position]!==13||t[o.position+1]!==10)return"failure";o.position+=2;let I;c!==null?(u??="text/plain",Xy(u)||(u=""),I=new zy([E],c,{type:u})):I=Hy(Buffer.from(E)),Bo(_E(a)),Bo(typeof I=="string"&&_E(I)||Vy(I)),s.push(qy(a,I,c))}}function tb(t,e){let r=null,A=null,s=null,o=null;for(;;){if(t[e.position]===13&&t[e.position+1]===10)return r===null?"failure":{name:r,filename:A,contentType:s,encoding:o};let n=Zr(i=>i!==10&&i!==13&&i!==58,t,e);if(n=da(n,!0,!0,i=>i===9||i===32),!Py.test(n.toString())||t[e.position]!==58)return"failure";switch(e.position++,Zr(i=>i===32||i===9,t,e),Jy(n)){case"content-disposition":{if(r=A=null,!Io(t,Zy,e)||(e.position+=17,r=OE(t,e),r===null))return"failure";if(Io(t,YE,e)){let i=e.position+YE.length;if(t[i]===42&&(e.position+=1,i+=1),t[i]!==61||t[i+1]!==34||(e.position+=12,A=OE(t,e),A===null))return"failure"}break}case"content-type":{let i=Zr(a=>a!==10&&a!==13,t,e);i=da(i,!1,!0,a=>a===9||a===32),s=xE(i);break}case"content-transfer-encoding":{let i=Zr(a=>a!==10&&a!==13,t,e);i=da(i,!1,!0,a=>a===9||a===32),o=xE(i);break}default:Zr(i=>i!==10&&i!==13,t,e)}if(t[e.position]!==13&&t[e.position+1]!==10)return"failure";e.position+=2}}function OE(t,e){Bo(t[e.position-1]===34);let r=Zr(A=>A!==10&&A!==13&&A!==34,t,e);return t[e.position]!==34?null:(e.position++,r=new TextDecoder().decode(r).replace(/%0A/ig,` +`).replace(/%0D/ig,"\r").replace(/%22/g,'"'),r)}function Zr(t,e,r){let A=r.position;for(;A0&&A(t[o]);)o--;return s===0&&o===t.length-1?t:t.subarray(s,o+1)}function Io(t,e,r){if(t.length{"use strict";var ZA=O(),{ReadableStreamFrom:rb,isBlobLike:PE,isReadableStreamLike:Ab,readableStreamClose:sb,createDeferredPromise:ob,fullyReadBody:nb,extractMimeType:ib,utf8DecodeBytes:WE}=Fe(),{FormData:VE}=zA(),{kState:jr}=Yt(),{webidl:ab}=Be(),{Blob:cb}=require("node:buffer"),Ba=require("node:assert"),{isErrored:zE,isDisturbed:gb}=require("node:stream"),{isArrayBuffer:ub}=require("node:util/types"),{serializeAMimeType:lb}=ye(),{multipartFormDataParser:Eb}=HE(),Ia;try{let t=require("node:crypto");Ia=e=>t.randomInt(0,e)}catch{Ia=t=>Math.floor(Math.random(t))}var Co=new TextEncoder;function hb(){}var ZE=globalThis.FinalizationRegistry&&process.version.indexOf("v18")!==0,KE;ZE&&(KE=new FinalizationRegistry(t=>{let e=t.deref();e&&!e.locked&&!gb(e)&&!zE(e)&&e.cancel("Response object has been garbage collected").catch(hb)}));function jE(t,e=!1){let r=null;t instanceof ReadableStream?r=t:PE(t)?r=t.stream():r=new ReadableStream({async pull(a){let c=typeof s=="string"?Co.encode(s):s;c.byteLength&&a.enqueue(c),queueMicrotask(()=>sb(a))},start(){},type:"bytes"}),Ba(Ab(r));let A=null,s=null,o=null,n=null;if(typeof t=="string")s=t,n="text/plain;charset=UTF-8";else if(t instanceof URLSearchParams)s=t.toString(),n="application/x-www-form-urlencoded;charset=UTF-8";else if(ub(t))s=new Uint8Array(t.slice());else if(ArrayBuffer.isView(t))s=new Uint8Array(t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength));else if(ZA.isFormDataLike(t)){let a=`----formdata-undici-0${`${Ia(1e11)}`.padStart(11,"0")}`,c=`--${a}\r +Content-Disposition: form-data`;let u=y=>y.replace(/\n/g,"%0A").replace(/\r/g,"%0D").replace(/"/g,"%22"),g=y=>y.replace(/\r?\n|\r/g,`\r +`),E=[],I=new Uint8Array([13,10]);o=0;let d=!1;for(let[y,B]of t)if(typeof B=="string"){let w=Co.encode(c+`; name="${u(g(y))}"\r \r -${g(I)}\r -`);E.push(y),o+=y.byteLength}else{let y=Qo.encode(`${c}; name="${l(g(w))}"`+(I.name?`; filename="${l(I.name)}"`:"")+`\r -Content-Type: ${I.type||"application/octet-stream"}\r +${g(B)}\r +`);E.push(w),o+=w.byteLength}else{let w=Co.encode(`${c}; name="${u(g(y))}"`+(B.name?`; filename="${u(B.name)}"`:"")+`\r +Content-Type: ${B.type||"application/octet-stream"}\r \r -`);E.push(y,I,d),typeof I.size=="number"?o+=y.byteLength+I.size+d.byteLength:B=!0}let p=Qo.encode(`--${a}--\r -`);E.push(p),o+=p.byteLength,B&&(o=null),s=t,A=async function*(){for(let w of E)w.stream?yield*w.stream():yield w},n=`multipart/form-data; boundary=${a}`}else if(vE(t))s=t,o=t.size,t.type&&(n=t.type);else if(typeof t[Symbol.asyncIterator]=="function"){if(e)throw new TypeError("keepalive");if(WA.isDisturbed(t)||t.locked)throw new TypeError("Response body object should not be disturbed or locked");r=t instanceof ReadableStream?t:qy(t)}if((typeof s=="string"||WA.isBuffer(s))&&(o=Buffer.byteLength(s)),A!=null){let a;r=new ReadableStream({async start(){a=A(t)[Symbol.asyncIterator]()},async pull(c){let{value:l,done:g}=await a.next();if(g)queueMicrotask(()=>{c.close(),c.byobRequest?.respond(0)});else if(!JE(r)){let E=new Uint8Array(l);E.byteLength&&c.enqueue(E)}return c.desiredSize>0},async cancel(c){await a.return()},type:"bytes"})}return[{stream:r,source:s,length:o},n]}function ob(t,e=!1){return t instanceof ReadableStream&&(la(!WA.isDisturbed(t),"The body has already been consumed."),la(!t.locked,"The stream is locked.")),PE(t,e)}function nb(t,e){let[r,A]=e.stream.tee();return e.stream=r,{stream:A,length:e.length,source:e.source}}function ib(t){if(t.aborted)throw new DOMException("The operation was aborted.","AbortError")}function ab(t){return{blob(){return Wr(this,r=>{let A=xE(this);return A===null?A="":A&&(A=rb(A)),new $y([r],{type:A})},t)},arrayBuffer(){return Wr(this,r=>new Uint8Array(r).buffer,t)},text(){return Wr(this,YE,t)},json(){return Wr(this,gb,t)},formData(){return Wr(this,r=>{let A=xE(this);if(A!==null)switch(A.essence){case"multipart/form-data":{let s=Ab(r,A);if(s==="failure")throw new TypeError("Failed to parse body as FormData.");let o=new _E;return o[zr]=s,o}case"application/x-www-form-urlencoded":{let s=new URLSearchParams(r.toString()),o=new _E;for(let[n,i]of s)o.append(n,i);return o}}throw new TypeError('Content-Type was not one of "multipart/form-data" or "application/x-www-form-urlencoded".')},t)},bytes(){return Wr(this,r=>new Uint8Array(r),t)}}}function cb(t){Object.assign(t.prototype,ab(t))}async function Wr(t,e,r){if(Xy.brandCheck(t,r),VE(t))throw new TypeError("Body is unusable: Body has already been read");ib(t[zr]);let A=Zy(),s=n=>A.reject(n),o=n=>{try{A.resolve(e(n))}catch(i){s(i)}};return t[zr].body==null?(o(Buffer.allocUnsafe(0)),A.promise):(await Ky(t[zr].body,o,s),A.promise)}function VE(t){let e=t[zr].body;return e!=null&&(e.stream.locked||WA.isDisturbed(e.stream))}function gb(t){return JSON.parse(YE(t))}function xE(t){let e=t[zr].headersList,r=jy(e);return r==="failure"?null:r}qE.exports={extractBody:PE,safelyExtractBody:ob,cloneBody:nb,mixinBody:cb,streamRegistry:HE,hasFinalizationRegistry:OE,bodyUnusable:VE}});var ah=m((AL,ih)=>{"use strict";var G=require("node:assert"),L=J(),{channels:WE}=Lr(),ha=Zi(),{RequestContentLengthMismatchError:ir,ResponseContentLengthMismatchError:zE,RequestAbortedError:rh,HeadersTimeoutError:ub,HeadersOverflowError:lb,SocketError:Kr,InformationalError:jr,BodyTimeoutError:Eb,HTTPParserError:hb,ResponseExceededMaxSizeError:Qb}=q(),{kUrl:Ah,kReset:be,kClient:po,kParser:re,kBlocking:KA,kRunning:ge,kPending:sh,kSize:ZE,kWriting:Yt,kQueue:Ze,kNoRef:zA,kKeepAliveDefaultTimeout:Bb,kHostHeader:db,kPendingIdx:Ib,kRunningIdx:Pe,kError:me,kPipelining:fo,kSocket:cr,kKeepAliveTimeoutValue:wo,kMaxHeadersSize:Qa,kKeepAliveMaxTimeout:Cb,kKeepAliveTimeoutThreshold:pb,kHeadersTimeout:fb,kBodyTimeout:mb,kStrictContentLength:Ia,kMaxRequests:KE,kCounter:wb,kMaxResponseSize:yb,kOnError:jE,kResume:kt,kHTTPContext:oh}=se(),Se=Hl(),XE=Buffer.alloc(0),Bo=Buffer[Symbol.species],Io=L.addListener,bb=L.removeAllListeners,gr=Symbol("kIdleSocketValidation"),ar=Symbol("kIdleSocketValidationTimeout"),ma=Symbol("kSocketUsed"),Ba;async function kb(){let t=process.env.JEST_WORKER_ID?Xi():void 0,e;try{e=await WebAssembly.compile(ql())}catch{e=await WebAssembly.compile(t||Xi())}return await WebAssembly.instantiate(e,{env:{wasm_on_url:(r,A,s)=>0,wasm_on_status:(r,A,s)=>{G(ie.ptr===r);let o=A-ut+gt.byteOffset;return ie.onStatus(new Bo(gt.buffer,o,s))||0},wasm_on_message_begin:r=>(G(ie.ptr===r),ie.onMessageBegin()||0),wasm_on_header_field:(r,A,s)=>{G(ie.ptr===r);let o=A-ut+gt.byteOffset;return ie.onHeaderField(new Bo(gt.buffer,o,s))||0},wasm_on_header_value:(r,A,s)=>{G(ie.ptr===r);let o=A-ut+gt.byteOffset;return ie.onHeaderValue(new Bo(gt.buffer,o,s))||0},wasm_on_headers_complete:(r,A,s,o)=>(G(ie.ptr===r),ie.onHeadersComplete(A,!!s,!!o)||0),wasm_on_body:(r,A,s)=>{G(ie.ptr===r);let o=A-ut+gt.byteOffset;return ie.onBody(new Bo(gt.buffer,o,s))||0},wasm_on_message_complete:r=>(G(ie.ptr===r),ie.onMessageComplete()||0)}})}var da=null,Ca=kb();Ca.catch();var ie=null,gt=null,Co=0,ut=null,Db=0,ZA=1,Xr=2|ZA,mo=4|ZA,pa=8|Db,fa=class{constructor(e,r,{exports:A}){G(Number.isFinite(e[Qa])&&e[Qa]>0),this.llhttp=A,this.ptr=this.llhttp.llhttp_alloc(Se.TYPE.RESPONSE),this.client=e,this.socket=r,this.timeout=null,this.timeoutValue=null,this.timeoutType=null,this.statusCode=null,this.statusText="",this.upgrade=!1,this.headers=[],this.headersSize=0,this.headersMaxSize=e[Qa],this.shouldKeepAlive=!1,this.paused=!1,this.resume=this.resume.bind(this),this.bytesRead=0,this.keepAlive="",this.contentLength="",this.connection="",this.maxResponseSize=e[yb]}setTimeout(e,r){e!==this.timeoutValue||r&ZA^this.timeoutType&ZA?(this.timeout&&(ha.clearTimeout(this.timeout),this.timeout=null),e&&(r&ZA?this.timeout=ha.setFastTimeout($E,e,new WeakRef(this)):(this.timeout=setTimeout($E,e,new WeakRef(this)),this.timeout.unref())),this.timeoutValue=e):this.timeout&&this.timeout.refresh&&this.timeout.refresh(),this.timeoutType=r}resume(){this.socket.destroyed||!this.paused||(G(this.ptr!=null),G(ie==null),this.llhttp.llhttp_resume(this.ptr),G(this.timeoutType===mo),this.timeout&&this.timeout.refresh&&this.timeout.refresh(),this.paused=!1,this.execute(this.socket.read()||XE),this.readMore())}readMore(){for(;!this.paused&&this.ptr;){let e=this.socket.read();if(e===null)break;this.execute(e)}}execute(e){G(this.ptr!=null),G(ie==null),G(!this.paused);let{socket:r,llhttp:A}=this;e.length>Co&&(ut&&A.free(ut),Co=Math.ceil(e.length/4096)*4096,ut=A.malloc(Co)),new Uint8Array(A.memory.buffer,ut,Co).set(e);try{let s;try{gt=e,ie=this,s=A.llhttp_execute(this.ptr,ut,e.length)}catch(n){throw n}finally{ie=null,gt=null}let o=A.llhttp_get_error_pos(this.ptr)-ut;if(s!==Se.ERROR.OK){let n=e.subarray(o);if(s===Se.ERROR.PAUSED_UPGRADE)this.onUpgrade(n);else if(s===Se.ERROR.PAUSED)this.paused=!0,r.unshift(n);else throw this.createError(s,n)}}catch(s){L.destroy(r,s)}}finish(){G(ie===null),G(this.ptr!=null),G(!this.paused);let{llhttp:e}=this,r;try{ie=this,r=e.llhttp_finish(this.ptr)}finally{ie=null}return r===Se.ERROR.OK?null:r===Se.ERROR.PAUSED||r===Se.ERROR.PAUSED_UPGRADE?(this.paused=!0,null):this.createError(r,XE)}createError(e,r){let{llhttp:A,contentLength:s,bytesRead:o}=this;if(s&&o!==parseInt(s,10))return new zE;let n=A.llhttp_get_error_reason(this.ptr),i="";if(n){let a=new Uint8Array(A.memory.buffer,n).indexOf(0);i="Response does not match the HTTP/1.1 protocol ("+Buffer.from(A.memory.buffer,n,a).toString()+")"}return new hb(i,Se.ERROR[e],r)}destroy(){G(this.ptr!=null),G(ie==null),this.llhttp.llhttp_free(this.ptr),this.ptr=null,this.timeout&&ha.clearTimeout(this.timeout),this.timeout=null,this.timeoutValue=null,this.timeoutType=null,this.paused=!1}onStatus(e){this.statusText=e.toString()}onMessageBegin(){let{socket:e,client:r}=this;if(e.destroyed)return-1;if(r[ge]===0)return L.destroy(e,new Kr("bad response",L.getSocketInfo(e))),-1;let A=r[Ze][r[Pe]];if(!A)return-1;A.onResponseStarted()}onHeaderField(e){let r=this.headers.length;(r&1)===0?this.headers.push(e):this.headers[r-1]=Buffer.concat([this.headers[r-1],e]),this.trackHeader(e.length)}onHeaderValue(e){let r=this.headers.length;(r&1)===1?(this.headers.push(e),r+=1):this.headers[r-1]=Buffer.concat([this.headers[r-1],e]);let A=this.headers[r-2];if(A.length===10){let s=L.bufferToLowerCasedHeaderName(A);s==="keep-alive"?this.keepAlive+=e.toString():s==="connection"&&(this.connection+=e.toString())}else A.length===14&&L.bufferToLowerCasedHeaderName(A)==="content-length"&&(this.contentLength+=e.toString());this.trackHeader(e.length)}trackHeader(e){this.headersSize+=e,this.headersSize>=this.headersMaxSize&&L.destroy(this.socket,new lb)}onUpgrade(e){let{upgrade:r,client:A,socket:s,headers:o,statusCode:n}=this;G(r),G(A[cr]===s),G(!s.destroyed),G(!this.paused),G((o.length&1)===0);let i=A[Ze][A[Pe]];G(i),G(i.upgrade||i.method==="CONNECT"),this.statusCode=null,this.statusText="",this.shouldKeepAlive=null,this.headers=[],this.headersSize=0,s.unshift(e),s[re].destroy(),s[re]=null,s[po]=null,s[me]=null,bb(s),A[cr]=null,A[oh]=null,A[Ze][A[Pe]++]=null,A.emit("disconnect",A[Ah],[A],new jr("upgrade"));try{i.onUpgrade(n,o,s)}catch(a){L.destroy(s,a)}A[kt]()}onHeadersComplete(e,r,A){let{client:s,socket:o,headers:n,statusText:i}=this;if(o.destroyed)return-1;if(s[ge]===0)return L.destroy(o,new Kr("bad response",L.getSocketInfo(o))),-1;let a=s[Ze][s[Pe]];if(!a)return-1;if(G(!this.upgrade),G(this.statusCode<200),e===100)return L.destroy(o,new Kr("bad response",L.getSocketInfo(o))),-1;if(r&&!a.upgrade)return L.destroy(o,new Kr("bad upgrade",L.getSocketInfo(o))),-1;if(G(this.timeoutType===Xr),this.statusCode=e,this.shouldKeepAlive=A||a.method==="HEAD"&&!o[be]&&this.connection.toLowerCase()==="keep-alive",this.statusCode>=200){let l=a.bodyTimeout!=null?a.bodyTimeout:s[mb];this.setTimeout(l,mo)}else this.timeout&&this.timeout.refresh&&this.timeout.refresh();if(a.method==="CONNECT")return G(s[ge]===1),this.upgrade=!0,2;if(r)return G(s[ge]===1),this.upgrade=!0,2;if(G((this.headers.length&1)===0),this.headers=[],this.headersSize=0,this.shouldKeepAlive&&s[fo]){let l=this.keepAlive?L.parseKeepAliveTimeout(this.keepAlive):null;if(l!=null){let g=Math.min(l-s[pb],s[Cb]);g<=0?o[be]=!0:s[wo]=g}else s[wo]=s[Bb]}else o[be]=!0;let c=a.onHeaders(e,n,this.resume,i)===!1;return a.aborted?-1:a.method==="HEAD"||e<200?1:(o[KA]&&(o[KA]=!1,s[kt]()),c?Se.ERROR.PAUSED:0)}onBody(e){let{client:r,socket:A,statusCode:s,maxResponseSize:o}=this;if(A.destroyed)return-1;let n=r[Ze][r[Pe]];if(G(n),G(this.timeoutType===mo),this.timeout&&this.timeout.refresh&&this.timeout.refresh(),G(s>=200),o>-1&&this.bytesRead+e.length>o)return L.destroy(A,new Qb),-1;if(this.bytesRead+=e.length,n.onData(e)===!1)return Se.ERROR.PAUSED}onMessageComplete(){let{client:e,socket:r,statusCode:A,upgrade:s,headers:o,contentLength:n,bytesRead:i,shouldKeepAlive:a}=this;if(r.destroyed&&(!A||a))return-1;if(s)return;G(A>=100),G((this.headers.length&1)===0);let c=e[Ze][e[Pe]];if(G(c),this.statusCode=null,this.statusText="",this.bytesRead=0,this.contentLength="",this.keepAlive="",this.connection="",this.headers=[],this.headersSize=0,!(A<200)){if(c.method!=="HEAD"&&n&&i!==parseInt(n,10))return L.destroy(r,new zE),-1;if(c.onComplete(o),e[Ze][e[Pe]++]=null,r[ma]=!0,r[Yt])return G(e[ge]===0),L.destroy(r,new jr("reset")),Se.ERROR.PAUSED;if(a){if(r[be]&&e[ge]===0)return L.destroy(r,new jr("reset")),Se.ERROR.PAUSED;e[fo]==null||e[fo]===1?setImmediate(()=>e[kt]()):e[kt]()}else return L.destroy(r,new jr("reset")),Se.ERROR.PAUSED}}};function $E(t){let{socket:e,timeoutType:r,client:A,paused:s}=t.deref();r===Xr?(!e[Yt]||e.writableNeedDrain||A[ge]>1)&&(G(!s,"cannot be paused while waiting for headers"),L.destroy(e,new ub)):r===mo?s||L.destroy(e,new Eb):r===pa&&(G(A[ge]===0&&A[wo]),L.destroy(e,new jr("socket idle timeout")))}async function Rb(t,e){t[cr]=e,da||(da=await Ca,Ca=null),e[zA]=!1,e[Yt]=!1,e[be]=!1,e[KA]=!1,e[gr]=0,e[ar]=null,e[ma]=!1,e[re]=new fa(t,e,da),Io(e,"error",function(A){G(A.code!=="ERR_TLS_CERT_ALTNAME_INVALID");let s=this[re];if(A.code==="ECONNRESET"&&s.statusCode&&!s.shouldKeepAlive){let o=s.finish();o&&(this[me]=o,this[po][jE](o));return}this[me]=A,this[po][jE](A)}),Io(e,"readable",function(){let A=this[re];A&&A.readMore()}),Io(e,"end",function(){let A=this[re];if(A.statusCode&&!A.shouldKeepAlive){let s=A.finish();s&&L.destroy(this,s);return}L.destroy(this,new Kr("other side closed",L.getSocketInfo(this)))}),Io(e,"close",function(){let A=this[po],s=this[re];nh(this),s&&(!this[me]&&s.statusCode&&!s.shouldKeepAlive&&(this[me]=s.finish()||this[me]),this[re].destroy(),this[re]=null);let o=this[me]||new Kr("closed",L.getSocketInfo(this));if(A[cr]=null,A[oh]=null,A.destroyed){G(A[sh]===0);let n=A[Ze].splice(A[Pe]);for(let i=0;i0&&o.code!=="UND_ERR_INFO"){let n=A[Ze][A[Pe]];A[Ze][A[Pe]++]=null,L.errorRequest(A,n,o)}A[Ib]=A[Pe],G(A[ge]===0),A.emit("disconnect",A[Ah],[A],o),A[kt]()});let r=!1;return e.on("close",()=>{r=!0}),{version:"h1",defaultPipelining:1,write(...A){return Ub(t,...A)},resume(){Fb(t)},destroy(A,s){r?queueMicrotask(s):e.destroy(A).on("close",s)},get destroyed(){return e.destroyed},busy(A){return!!(e[Yt]||e[be]||e[KA]||e[gr]===1||A&&(t[ge]>0&&!A.idempotent||t[ge]>0&&(A.upgrade||A.method==="CONNECT")||t[ge]>0&&L.bodyLength(A.body)!==0&&(L.isStream(A.body)||L.isAsyncIterable(A.body)||L.isFormDataLike(A.body))))}}}function nh(t){t[ar]&&(clearTimeout(t[ar]),t[ar]=null),t[gr]=0}function Tb(t,e){e[gr]=1,e[ar]=setTimeout(()=>{e[ar]=null,e[gr]=2,t[cr]===e&&!e.destroyed&&t[kt]()},0),e[ar].unref?.()}function Fb(t){let e=t[cr];if(e&&!e.destroyed){if(t[ZE]===0?!e[zA]&&e.unref&&(e.unref(),e[zA]=!0):e[zA]&&e.ref&&(e.ref(),e[zA]=!1),t[ge]===0&&t[sh]>0&&e[ma]){if(e[gr]===0)return Tb(t,e),e[re].readMore(),e.destroyed,void 0;if(e[gr]===1)return e[re].readMore(),e.destroyed,void 0}if(t[ge]===0&&(e[re].readMore(),e.destroyed))return;if(t[ZE]===0)e[re].timeoutType!==pa&&e[re].setTimeout(t[wo],pa);else if(t[ge]>0&&e[re].statusCode<200&&e[re].timeoutType!==Xr){let r=t[Ze][t[Pe]],A=r.headersTimeout!=null?r.headersTimeout:t[fb];e[re].setTimeout(A,Xr)}}}function Sb(t){return t!=="GET"&&t!=="HEAD"&&t!=="OPTIONS"&&t!=="TRACE"&&t!=="CONNECT"}function Ub(t,e){let{method:r,path:A,host:s,upgrade:o,blocking:n,reset:i}=e,{body:a,headers:c,contentLength:l}=e,g=r==="PUT"||r==="POST"||r==="PATCH"||r==="QUERY"||r==="PROPFIND"||r==="PROPPATCH";if(L.isFormDataLike(a)){Ba||(Ba=Zr().extractBody);let[w,I]=Ba(a);e.contentType==null&&c.push("content-type",I),a=w.stream,l=w.length}else L.isBlobLike(a)&&e.contentType==null&&a.type&&c.push("content-type",a.type);a&&typeof a.read=="function"&&a.read(0);let E=L.bodyLength(a);if(l=E??l,l===null&&(l=e.contentLength),l===0&&!g&&(l=null),Sb(r)&&l>0&&e.contentLength!==null&&e.contentLength!==l){if(t[Ia])return L.errorRequest(t,e,new ir),!1;process.emitWarning(new ir)}let d=t[cr];nh(d);let B=w=>{e.aborted||e.completed||(L.errorRequest(t,e,w||new rh),L.destroy(a),L.destroy(d,new jr("aborted")))};try{e.onConnect(B)}catch(w){L.errorRequest(t,e,w)}if(e.aborted)return!1;r==="HEAD"&&(d[be]=!0),(o||r==="CONNECT")&&(d[be]=!0),i!=null&&(d[be]=i),t[KE]&&d[wb]++>=t[KE]&&(d[be]=!0),n&&(d[KA]=!0);let p=`${r} ${A} HTTP/1.1\r +`);E.push(w,B,I),typeof B.size=="number"?o+=w.byteLength+B.size+I.byteLength:d=!0}let p=Co.encode(`--${a}--\r +`);E.push(p),o+=p.byteLength,d&&(o=null),s=t,A=async function*(){for(let y of E)y.stream?yield*y.stream():yield y},n=`multipart/form-data; boundary=${a}`}else if(PE(t))s=t,o=t.size,t.type&&(n=t.type);else if(typeof t[Symbol.asyncIterator]=="function"){if(e)throw new TypeError("keepalive");if(ZA.isDisturbed(t)||t.locked)throw new TypeError("Response body object should not be disturbed or locked");r=t instanceof ReadableStream?t:rb(t)}if((typeof s=="string"||ZA.isBuffer(s))&&(o=Buffer.byteLength(s)),A!=null){let a;r=new ReadableStream({async start(){a=A(t)[Symbol.asyncIterator]()},async pull(c){let{value:u,done:g}=await a.next();if(g)queueMicrotask(()=>{c.close(),c.byobRequest?.respond(0)});else if(!zE(r)){let E=new Uint8Array(u);E.byteLength&&c.enqueue(E)}return c.desiredSize>0},async cancel(c){await a.return()},type:"bytes"})}return[{stream:r,source:s,length:o},n]}function Qb(t,e=!1){return t instanceof ReadableStream&&(Ba(!ZA.isDisturbed(t),"The body has already been consumed."),Ba(!t.locked,"The stream is locked.")),jE(t,e)}function db(t,e){let[r,A]=e.stream.tee();return e.stream=r,{stream:A,length:e.length,source:e.source}}function Bb(t){if(t.aborted)throw new DOMException("The operation was aborted.","AbortError")}function Ib(t){return{blob(){return Kr(this,r=>{let A=qE(this);return A===null?A="":A&&(A=lb(A)),new cb([r],{type:A})},t)},arrayBuffer(){return Kr(this,r=>new Uint8Array(r).buffer,t)},text(){return Kr(this,WE,t)},json(){return Kr(this,pb,t)},formData(){return Kr(this,r=>{let A=qE(this);if(A!==null)switch(A.essence){case"multipart/form-data":{let s=Eb(r,A);if(s==="failure")throw new TypeError("Failed to parse body as FormData.");let o=new VE;return o[jr]=s,o}case"application/x-www-form-urlencoded":{let s=new URLSearchParams(r.toString()),o=new VE;for(let[n,i]of s)o.append(n,i);return o}}throw new TypeError('Content-Type was not one of "multipart/form-data" or "application/x-www-form-urlencoded".')},t)},bytes(){return Kr(this,r=>new Uint8Array(r),t)}}}function Cb(t){Object.assign(t.prototype,Ib(t))}async function Kr(t,e,r){if(ab.brandCheck(t,r),XE(t))throw new TypeError("Body is unusable: Body has already been read");Bb(t[jr]);let A=ob(),s=n=>A.reject(n),o=n=>{try{A.resolve(e(n))}catch(i){s(i)}};return t[jr].body==null?(o(Buffer.allocUnsafe(0)),A.promise):(await nb(t[jr].body,o,s),A.promise)}function XE(t){let e=t[jr].body;return e!=null&&(e.stream.locked||ZA.isDisturbed(e.stream))}function pb(t){return JSON.parse(WE(t))}function qE(t){let e=t[jr].headersList,r=ib(e);return r==="failure"?null:r}$E.exports={extractBody:jE,safelyExtractBody:Qb,cloneBody:db,mixinBody:Cb,streamRegistry:KE,hasFinalizationRegistry:ZE,bodyUnusable:XE}});var Qh=m((dL,hh)=>{"use strict";var G=require("node:assert"),L=O(),{channels:eh}=xr(),Ca=ea(),{RequestContentLengthMismatchError:gr,ResponseContentLengthMismatchError:th,RequestAbortedError:ch,HeadersTimeoutError:fb,HeadersOverflowError:mb,SocketError:$r,InformationalError:eA,BodyTimeoutError:wb,HTTPParserError:yb,ResponseExceededMaxSizeError:bb}=q(),{kUrl:gh,kReset:be,kClient:wo,kParser:re,kBlocking:XA,kRunning:ge,kPending:uh,kSize:rh,kWriting:Ot,kQueue:Ze,kNoRef:KA,kKeepAliveDefaultTimeout:Db,kHostHeader:kb,kPendingIdx:Rb,kRunningIdx:Pe,kError:me,kPipelining:yo,kSocket:lr,kKeepAliveTimeoutValue:Do,kMaxHeadersSize:pa,kKeepAliveMaxTimeout:Tb,kKeepAliveTimeoutThreshold:Fb,kHeadersTimeout:Sb,kBodyTimeout:Ub,kStrictContentLength:wa,kMaxRequests:Ah,kCounter:Nb,kMaxResponseSize:Gb,kOnError:sh,kResume:kt,kHTTPContext:lh}=se(),Se=Kl(),oh=Buffer.alloc(0),po=Buffer[Symbol.species],fo=L.addListener,Mb=L.removeAllListeners,Er=Symbol("kIdleSocketValidation"),ur=Symbol("kIdleSocketValidationTimeout"),ka=Symbol("kSocketUsed"),fa;async function Lb(){let t=process.env.JEST_WORKER_ID?Aa():void 0,e;try{e=await WebAssembly.compile($l())}catch{e=await WebAssembly.compile(t||Aa())}return await WebAssembly.instantiate(e,{env:{wasm_on_url:(r,A,s)=>0,wasm_on_status:(r,A,s)=>{G(ie.ptr===r);let o=A-ut+gt.byteOffset;return ie.onStatus(new po(gt.buffer,o,s))||0},wasm_on_message_begin:r=>(G(ie.ptr===r),ie.onMessageBegin()||0),wasm_on_header_field:(r,A,s)=>{G(ie.ptr===r);let o=A-ut+gt.byteOffset;return ie.onHeaderField(new po(gt.buffer,o,s))||0},wasm_on_header_value:(r,A,s)=>{G(ie.ptr===r);let o=A-ut+gt.byteOffset;return ie.onHeaderValue(new po(gt.buffer,o,s))||0},wasm_on_headers_complete:(r,A,s,o)=>(G(ie.ptr===r),ie.onHeadersComplete(A,!!s,!!o)||0),wasm_on_body:(r,A,s)=>{G(ie.ptr===r);let o=A-ut+gt.byteOffset;return ie.onBody(new po(gt.buffer,o,s))||0},wasm_on_message_complete:r=>(G(ie.ptr===r),ie.onMessageComplete()||0)}})}var ma=null,ya=Lb();ya.catch();var ie=null,gt=null,mo=0,ut=null,vb=0,jA=1,tA=2|jA,bo=4|jA,ba=8|vb,Da=class{constructor(e,r,{exports:A}){G(Number.isFinite(e[pa])&&e[pa]>0),this.llhttp=A,this.ptr=this.llhttp.llhttp_alloc(Se.TYPE.RESPONSE),this.client=e,this.socket=r,this.timeout=null,this.timeoutValue=null,this.timeoutType=null,this.statusCode=null,this.statusText="",this.upgrade=!1,this.headers=[],this.headersSize=0,this.headersMaxSize=e[pa],this.shouldKeepAlive=!1,this.paused=!1,this.resume=this.resume.bind(this),this.bytesRead=0,this.keepAlive="",this.contentLength="",this.connection="",this.maxResponseSize=e[Gb]}setTimeout(e,r){e!==this.timeoutValue||r&jA^this.timeoutType&jA?(this.timeout&&(Ca.clearTimeout(this.timeout),this.timeout=null),e&&(r&jA?this.timeout=Ca.setFastTimeout(nh,e,new WeakRef(this)):(this.timeout=setTimeout(nh,e,new WeakRef(this)),this.timeout.unref())),this.timeoutValue=e):this.timeout&&this.timeout.refresh&&this.timeout.refresh(),this.timeoutType=r}resume(){this.socket.destroyed||!this.paused||(G(this.ptr!=null),G(ie==null),this.llhttp.llhttp_resume(this.ptr),G(this.timeoutType===bo),this.timeout&&this.timeout.refresh&&this.timeout.refresh(),this.paused=!1,this.execute(this.socket.read()||oh),this.readMore())}readMore(){for(;!this.paused&&this.ptr;){let e=this.socket.read();if(e===null)break;this.execute(e)}}execute(e){G(this.ptr!=null),G(ie==null),G(!this.paused);let{socket:r,llhttp:A}=this;e.length>mo&&(ut&&A.free(ut),mo=Math.ceil(e.length/4096)*4096,ut=A.malloc(mo)),new Uint8Array(A.memory.buffer,ut,mo).set(e);try{let s;try{gt=e,ie=this,s=A.llhttp_execute(this.ptr,ut,e.length)}catch(n){throw n}finally{ie=null,gt=null}let o=A.llhttp_get_error_pos(this.ptr)-ut;if(s!==Se.ERROR.OK){let n=e.subarray(o);if(s===Se.ERROR.PAUSED_UPGRADE)this.onUpgrade(n);else if(s===Se.ERROR.PAUSED)this.paused=!0,r.unshift(n);else throw this.createError(s,n)}}catch(s){L.destroy(r,s)}}finish(){G(ie===null),G(this.ptr!=null),G(!this.paused);let{llhttp:e}=this,r;try{ie=this,r=e.llhttp_finish(this.ptr)}finally{ie=null}return r===Se.ERROR.OK?null:r===Se.ERROR.PAUSED||r===Se.ERROR.PAUSED_UPGRADE?(this.paused=!0,null):this.createError(r,oh)}createError(e,r){let{llhttp:A,contentLength:s,bytesRead:o}=this;if(s&&o!==parseInt(s,10))return new th;let n=A.llhttp_get_error_reason(this.ptr),i="";if(n){let a=new Uint8Array(A.memory.buffer,n).indexOf(0);i="Response does not match the HTTP/1.1 protocol ("+Buffer.from(A.memory.buffer,n,a).toString()+")"}return new yb(i,Se.ERROR[e],r)}destroy(){G(this.ptr!=null),G(ie==null),this.llhttp.llhttp_free(this.ptr),this.ptr=null,this.timeout&&Ca.clearTimeout(this.timeout),this.timeout=null,this.timeoutValue=null,this.timeoutType=null,this.paused=!1}onStatus(e){this.statusText=e.toString()}onMessageBegin(){let{socket:e,client:r}=this;if(e.destroyed)return-1;if(r[ge]===0)return L.destroy(e,new $r("bad response",L.getSocketInfo(e))),-1;let A=r[Ze][r[Pe]];if(!A)return-1;A.onResponseStarted()}onHeaderField(e){let r=this.headers.length;(r&1)===0?this.headers.push(e):this.headers[r-1]=Buffer.concat([this.headers[r-1],e]),this.trackHeader(e.length)}onHeaderValue(e){let r=this.headers.length;(r&1)===1?(this.headers.push(e),r+=1):this.headers[r-1]=Buffer.concat([this.headers[r-1],e]);let A=this.headers[r-2];if(A.length===10){let s=L.bufferToLowerCasedHeaderName(A);s==="keep-alive"?this.keepAlive+=e.toString():s==="connection"&&(this.connection+=e.toString())}else A.length===14&&L.bufferToLowerCasedHeaderName(A)==="content-length"&&(this.contentLength+=e.toString());this.trackHeader(e.length)}trackHeader(e){this.headersSize+=e,this.headersSize>=this.headersMaxSize&&L.destroy(this.socket,new mb)}onUpgrade(e){let{upgrade:r,client:A,socket:s,headers:o,statusCode:n}=this;G(r),G(A[lr]===s),G(!s.destroyed),G(!this.paused),G((o.length&1)===0);let i=A[Ze][A[Pe]];G(i),G(i.upgrade||i.method==="CONNECT"),this.statusCode=null,this.statusText="",this.shouldKeepAlive=null,this.headers=[],this.headersSize=0,s.unshift(e),s[re].destroy(),s[re]=null,s[wo]=null,s[me]=null,Mb(s),A[lr]=null,A[lh]=null,A[Ze][A[Pe]++]=null,A.emit("disconnect",A[gh],[A],new eA("upgrade"));try{i.onUpgrade(n,o,s)}catch(a){L.destroy(s,a)}A[kt]()}onHeadersComplete(e,r,A){let{client:s,socket:o,headers:n,statusText:i}=this;if(o.destroyed)return-1;if(s[ge]===0)return L.destroy(o,new $r("bad response",L.getSocketInfo(o))),-1;let a=s[Ze][s[Pe]];if(!a)return-1;if(G(!this.upgrade),G(this.statusCode<200),e===100)return L.destroy(o,new $r("bad response",L.getSocketInfo(o))),-1;if(r&&!a.upgrade)return L.destroy(o,new $r("bad upgrade",L.getSocketInfo(o))),-1;if(G(this.timeoutType===tA),this.statusCode=e,this.shouldKeepAlive=A||a.method==="HEAD"&&!o[be]&&this.connection.toLowerCase()==="keep-alive",this.statusCode>=200){let u=a.bodyTimeout!=null?a.bodyTimeout:s[Ub];this.setTimeout(u,bo)}else this.timeout&&this.timeout.refresh&&this.timeout.refresh();if(a.method==="CONNECT")return G(s[ge]===1),this.upgrade=!0,2;if(r)return G(s[ge]===1),this.upgrade=!0,2;if(G((this.headers.length&1)===0),this.headers=[],this.headersSize=0,this.shouldKeepAlive&&s[yo]){let u=this.keepAlive?L.parseKeepAliveTimeout(this.keepAlive):null;if(u!=null){let g=Math.min(u-s[Fb],s[Tb]);g<=0?o[be]=!0:s[Do]=g}else s[Do]=s[Db]}else o[be]=!0;let c=a.onHeaders(e,n,this.resume,i)===!1;return a.aborted?-1:a.method==="HEAD"||e<200?1:(o[XA]&&(o[XA]=!1,s[kt]()),c?Se.ERROR.PAUSED:0)}onBody(e){let{client:r,socket:A,statusCode:s,maxResponseSize:o}=this;if(A.destroyed)return-1;let n=r[Ze][r[Pe]];if(G(n),G(this.timeoutType===bo),this.timeout&&this.timeout.refresh&&this.timeout.refresh(),G(s>=200),o>-1&&this.bytesRead+e.length>o)return L.destroy(A,new bb),-1;if(this.bytesRead+=e.length,n.onData(e)===!1)return Se.ERROR.PAUSED}onMessageComplete(){let{client:e,socket:r,statusCode:A,upgrade:s,headers:o,contentLength:n,bytesRead:i,shouldKeepAlive:a}=this;if(r.destroyed&&(!A||a))return-1;if(s)return;G(A>=100),G((this.headers.length&1)===0);let c=e[Ze][e[Pe]];if(G(c),this.statusCode=null,this.statusText="",this.bytesRead=0,this.contentLength="",this.keepAlive="",this.connection="",this.headers=[],this.headersSize=0,!(A<200)){if(c.method!=="HEAD"&&n&&i!==parseInt(n,10))return L.destroy(r,new th),-1;if(c.onComplete(o),e[Ze][e[Pe]++]=null,r[ka]=!0,r[Ot])return G(e[ge]===0),L.destroy(r,new eA("reset")),Se.ERROR.PAUSED;if(a){if(r[be]&&e[ge]===0)return L.destroy(r,new eA("reset")),Se.ERROR.PAUSED;e[yo]==null||e[yo]===1?setImmediate(()=>e[kt]()):e[kt]()}else return L.destroy(r,new eA("reset")),Se.ERROR.PAUSED}}};function nh(t){let{socket:e,timeoutType:r,client:A,paused:s}=t.deref();r===tA?(!e[Ot]||e.writableNeedDrain||A[ge]>1)&&(G(!s,"cannot be paused while waiting for headers"),L.destroy(e,new fb)):r===bo?s||L.destroy(e,new wb):r===ba&&(G(A[ge]===0&&A[Do]),L.destroy(e,new eA("socket idle timeout")))}async function _b(t,e){t[lr]=e,ma||(ma=await ya,ya=null),e[KA]=!1,e[Ot]=!1,e[be]=!1,e[XA]=!1,e[Er]=0,e[ur]=null,e[ka]=!1,e[re]=new Da(t,e,ma),fo(e,"error",function(A){G(A.code!=="ERR_TLS_CERT_ALTNAME_INVALID");let s=this[re];if(A.code==="ECONNRESET"&&s.statusCode&&!s.shouldKeepAlive){let o=s.finish();o&&(this[me]=o,this[wo][sh](o));return}this[me]=A,this[wo][sh](A)}),fo(e,"readable",function(){let A=this[re];A&&A.readMore()}),fo(e,"end",function(){let A=this[re];if(A.statusCode&&!A.shouldKeepAlive){let s=A.finish();s&&L.destroy(this,s);return}L.destroy(this,new $r("other side closed",L.getSocketInfo(this)))}),fo(e,"close",function(){let A=this[wo],s=this[re];Eh(this),s&&(!this[me]&&s.statusCode&&!s.shouldKeepAlive&&(this[me]=s.finish()||this[me]),this[re].destroy(),this[re]=null);let o=this[me]||new $r("closed",L.getSocketInfo(this));if(A[lr]=null,A[lh]=null,A.destroyed){G(A[uh]===0);let n=A[Ze].splice(A[Pe]);for(let i=0;i0&&o.code!=="UND_ERR_INFO"){let n=A[Ze][A[Pe]];A[Ze][A[Pe]++]=null,L.errorRequest(A,n,o)}A[Rb]=A[Pe],G(A[ge]===0),A.emit("disconnect",A[gh],[A],o),A[kt]()});let r=!1;return e.on("close",()=>{r=!0}),{version:"h1",defaultPipelining:1,write(...A){return Jb(t,...A)},resume(){Yb(t)},destroy(A,s){r?queueMicrotask(s):e.destroy(A).on("close",s)},get destroyed(){return e.destroyed},busy(A){return!!(e[Ot]||e[be]||e[XA]||e[Er]===1||A&&(t[ge]>0&&!A.idempotent||t[ge]>0&&(A.upgrade||A.method==="CONNECT")||t[ge]>0&&L.bodyLength(A.body)!==0&&(L.isStream(A.body)||L.isAsyncIterable(A.body)||L.isFormDataLike(A.body))))}}}function Eh(t){t[ur]&&(clearTimeout(t[ur]),t[ur]=null),t[Er]=0}function xb(t,e){e[Er]=1,e[ur]=setTimeout(()=>{e[ur]=null,e[Er]=2,t[lr]===e&&!e.destroyed&&t[kt]()},0),e[ur].unref?.()}function Yb(t){let e=t[lr];if(e&&!e.destroyed){if(t[rh]===0?!e[KA]&&e.unref&&(e.unref(),e[KA]=!0):e[KA]&&e.ref&&(e.ref(),e[KA]=!1),t[ge]===0&&t[uh]>0&&e[ka]){if(e[Er]===0)return xb(t,e),e[re].readMore(),e.destroyed,void 0;if(e[Er]===1)return e[re].readMore(),e.destroyed,void 0}if(t[ge]===0&&(e[re].readMore(),e.destroyed))return;if(t[rh]===0)e[re].timeoutType!==ba&&e[re].setTimeout(t[Do],ba);else if(t[ge]>0&&e[re].statusCode<200&&e[re].timeoutType!==tA){let r=t[Ze][t[Pe]],A=r.headersTimeout!=null?r.headersTimeout:t[Sb];e[re].setTimeout(A,tA)}}}function Ob(t){return t!=="GET"&&t!=="HEAD"&&t!=="OPTIONS"&&t!=="TRACE"&&t!=="CONNECT"}function Jb(t,e){let{method:r,path:A,host:s,upgrade:o,blocking:n,reset:i}=e,{body:a,headers:c,contentLength:u}=e,g=r==="PUT"||r==="POST"||r==="PATCH"||r==="QUERY"||r==="PROPFIND"||r==="PROPPATCH";if(L.isFormDataLike(a)){fa||(fa=Xr().extractBody);let[y,B]=fa(a);e.contentType==null&&c.push("content-type",B),a=y.stream,u=y.length}else L.isBlobLike(a)&&e.contentType==null&&a.type&&c.push("content-type",a.type);a&&typeof a.read=="function"&&a.read(0);let E=L.bodyLength(a);if(u=E??u,u===null&&(u=e.contentLength),u===0&&!g&&(u=null),Ob(r)&&u>0&&e.contentLength!==null&&e.contentLength!==u){if(t[wa])return L.errorRequest(t,e,new gr),!1;process.emitWarning(new gr)}let I=t[lr];Eh(I);let d=y=>{e.aborted||e.completed||(L.errorRequest(t,e,y||new ch),L.destroy(a),L.destroy(I,new eA("aborted")))};try{e.onConnect(d)}catch(y){L.errorRequest(t,e,y)}if(e.aborted)return!1;r==="HEAD"&&(I[be]=!0),(o||r==="CONNECT")&&(I[be]=!0),i!=null&&(I[be]=i),t[Ah]&&I[Nb]++>=t[Ah]&&(I[be]=!0),n&&(I[XA]=!0);let p=`${r} ${A} HTTP/1.1\r `;if(typeof s=="string"?p+=`host: ${s}\r -`:p+=t[db],o?p+=`connection: upgrade\r +`:p+=t[kb],o?p+=`connection: upgrade\r upgrade: ${o}\r -`:t[fo]&&!d[be]?p+=`connection: keep-alive\r +`:t[yo]&&!I[be]?p+=`connection: keep-alive\r `:p+=`connection: close\r -`,Array.isArray(c))for(let w=0;w{e.removeListener("error",d)}),!a){let B=new rh;queueMicrotask(()=>d(B))}},d=function(B){if(!a){if(a=!0,G(s.destroyed||s[Yt]&&r[ge]<=1),s.off("drain",g).off("error",d),e.removeListener("data",l).removeListener("end",d).removeListener("close",E),!B)try{c.end()}catch(p){B=p}c.destroy(B),B&&(B.code!=="UND_ERR_INFO"||B.message!=="reset")?L.destroy(e,B):L.destroy(e)}};e.on("data",l).on("end",d).on("error",d).on("close",E),e.resume&&e.resume(),s.on("drain",g).on("error",d),e.errorEmitted??e.errored?setImmediate(()=>d(e.errored)):(e.endEmitted??e.readableEnded)&&setImmediate(()=>d(null)),(e.closeEmitted??e.closed)&&setImmediate(E)}function eh(t,e,r,A,s,o,n,i){try{e?L.isBuffer(e)&&(G(o===e.byteLength,"buffer body must have content length"),s.cork(),s.write(`${n}content-length: ${o}\r +`,Array.isArray(c))for(let y=0;y{e.removeListener("error",I)}),!a){let d=new ch;queueMicrotask(()=>I(d))}},I=function(d){if(!a){if(a=!0,G(s.destroyed||s[Ot]&&r[ge]<=1),s.off("drain",g).off("error",I),e.removeListener("data",u).removeListener("end",I).removeListener("close",E),!d)try{c.end()}catch(p){d=p}c.destroy(d),d&&(d.code!=="UND_ERR_INFO"||d.message!=="reset")?L.destroy(e,d):L.destroy(e)}};e.on("data",u).on("end",I).on("error",I).on("close",E),e.resume&&e.resume(),s.on("drain",g).on("error",I),e.errorEmitted??e.errored?setImmediate(()=>I(e.errored)):(e.endEmitted??e.readableEnded)&&setImmediate(()=>I(null)),(e.closeEmitted??e.closed)&&setImmediate(E)}function ih(t,e,r,A,s,o,n,i){try{e?L.isBuffer(e)&&(G(o===e.byteLength,"buffer body must have content length"),s.cork(),s.write(`${n}content-length: ${o}\r \r `,"latin1"),s.write(e),s.uncork(),A.onBodySent(e),!i&&A.reset!==!1&&(s[be]=!0)):o===0?s.write(`${n}content-length: 0\r \r `,"latin1"):(G(o===null,"no body must not have content length"),s.write(`${n}\r -`,"latin1")),A.onRequestSent(),r[kt]()}catch(a){t(a)}}async function Gb(t,e,r,A,s,o,n,i){G(o===e.size,"blob body must have content length");try{if(o!=null&&o!==e.size)throw new ir;let a=Buffer.from(await e.arrayBuffer());s.cork(),s.write(`${n}content-length: ${o}\r +`,"latin1")),A.onRequestSent(),r[kt]()}catch(a){t(a)}}async function Pb(t,e,r,A,s,o,n,i){G(o===e.size,"blob body must have content length");try{if(o!=null&&o!==e.size)throw new gr;let a=Buffer.from(await e.arrayBuffer());s.cork(),s.write(`${n}content-length: ${o}\r \r -`,"latin1"),s.write(a),s.uncork(),A.onBodySent(a),A.onRequestSent(),!i&&A.reset!==!1&&(s[be]=!0),r[kt]()}catch(a){t(a)}}async function th(t,e,r,A,s,o,n,i){G(o!==0||r[ge]===0,"iterator body cannot be pipelined");let a=null;function c(){if(a){let E=a;a=null,E()}}let l=()=>new Promise((E,d)=>{G(a===null),s[me]?d(s[me]):a=E});s.on("close",c).on("drain",c);let g=new yo({abort:t,socket:s,request:A,contentLength:o,client:r,expectsPayload:i,header:n});try{for await(let E of e){if(s[me])throw s[me];g.write(E)||await l()}g.end()}catch(E){g.destroy(E)}finally{s.off("close",c).off("drain",c)}}var yo=class{constructor({abort:e,socket:r,request:A,contentLength:s,client:o,expectsPayload:n,header:i}){this.socket=r,this.request=A,this.contentLength=s,this.client=o,this.bytesWritten=0,this.expectsPayload=n,this.header=i,this.abort=e,r[Yt]=!0}write(e){let{socket:r,request:A,contentLength:s,client:o,bytesWritten:n,expectsPayload:i,header:a}=this;if(r[me])throw r[me];if(r.destroyed)return!1;let c=Buffer.byteLength(e);if(!c)return!0;if(s!==null&&n+c>s){if(o[Ia])throw new ir;process.emitWarning(new ir)}r.cork(),n===0&&(!i&&A.reset!==!1&&(r[be]=!0),s===null?r.write(`${a}transfer-encoding: chunked\r +`,"latin1"),s.write(a),s.uncork(),A.onBodySent(a),A.onRequestSent(),!i&&A.reset!==!1&&(s[be]=!0),r[kt]()}catch(a){t(a)}}async function ah(t,e,r,A,s,o,n,i){G(o!==0||r[ge]===0,"iterator body cannot be pipelined");let a=null;function c(){if(a){let E=a;a=null,E()}}let u=()=>new Promise((E,I)=>{G(a===null),s[me]?I(s[me]):a=E});s.on("close",c).on("drain",c);let g=new ko({abort:t,socket:s,request:A,contentLength:o,client:r,expectsPayload:i,header:n});try{for await(let E of e){if(s[me])throw s[me];g.write(E)||await u()}g.end()}catch(E){g.destroy(E)}finally{s.off("close",c).off("drain",c)}}var ko=class{constructor({abort:e,socket:r,request:A,contentLength:s,client:o,expectsPayload:n,header:i}){this.socket=r,this.request=A,this.contentLength=s,this.client=o,this.bytesWritten=0,this.expectsPayload=n,this.header=i,this.abort=e,r[Ot]=!0}write(e){let{socket:r,request:A,contentLength:s,client:o,bytesWritten:n,expectsPayload:i,header:a}=this;if(r[me])throw r[me];if(r.destroyed)return!1;let c=Buffer.byteLength(e);if(!c)return!0;if(s!==null&&n+c>s){if(o[wa])throw new gr;process.emitWarning(new gr)}r.cork(),n===0&&(!i&&A.reset!==!1&&(r[be]=!0),s===null?r.write(`${a}transfer-encoding: chunked\r `,"latin1"):r.write(`${a}content-length: ${s}\r \r `,"latin1")),s===null&&r.write(`\r ${c.toString(16)}\r -`,"latin1"),this.bytesWritten+=c;let l=r.write(e);return r.uncork(),A.onBodySent(e),l||r[re].timeout&&r[re].timeoutType===Xr&&r[re].timeout.refresh&&r[re].timeout.refresh(),l}end(){let{socket:e,contentLength:r,client:A,bytesWritten:s,expectsPayload:o,header:n,request:i}=this;if(i.onRequestSent(),e[Yt]=!1,e[me])throw e[me];if(!e.destroyed){if(s===0?o?e.write(`${n}content-length: 0\r +`,"latin1"),this.bytesWritten+=c;let u=r.write(e);return r.uncork(),A.onBodySent(e),u||r[re].timeout&&r[re].timeoutType===tA&&r[re].timeout.refresh&&r[re].timeout.refresh(),u}end(){let{socket:e,contentLength:r,client:A,bytesWritten:s,expectsPayload:o,header:n,request:i}=this;if(i.onRequestSent(),e[Ot]=!1,e[me])throw e[me];if(!e.destroyed){if(s===0?o?e.write(`${n}content-length: 0\r \r `,"latin1"):e.write(`${n}\r `,"latin1"):r===null&&e.write(`\r 0\r \r -`,"latin1"),r!==null&&s!==r){if(A[Ia])throw new ir;process.emitWarning(new ir)}e[re].timeout&&e[re].timeoutType===Xr&&e[re].timeout.refresh&&e[re].timeout.refresh(),A[kt]()}}destroy(e){let{socket:r,client:A,abort:s}=this;r[Yt]=!1,e&&(G(A[ge]<=1,"pipeline should only contain this request"),s(e))}};ih.exports=Rb});var Bh=m((sL,Qh)=>{"use strict";var Ve=require("node:assert"),{pipeline:Mb}=require("node:stream"),H=J(),{RequestContentLengthMismatchError:wa,RequestAbortedError:ch,SocketError:jA,InformationalError:ya}=q(),{kUrl:bo,kReset:Do,kClient:$r,kRunning:Ro,kPending:Lb,kQueue:Jt,kPendingIdx:ba,kRunningIdx:Ke,kError:Xe,kSocket:he,kStrictContentLength:vb,kOnError:ka,kMaxConcurrentStreams:hh,kHTTP2Session:je,kResume:Ot,kSize:_b,kHTTPContext:xb}=se(),Dt=Symbol("open streams"),gh,uh=!1,ko;try{ko=require("node:http2")}catch{ko={constants:{}}}var{constants:{HTTP2_HEADER_AUTHORITY:Yb,HTTP2_HEADER_METHOD:Jb,HTTP2_HEADER_PATH:Ob,HTTP2_HEADER_SCHEME:Hb,HTTP2_HEADER_CONTENT_LENGTH:Pb,HTTP2_HEADER_EXPECT:Vb,HTTP2_HEADER_STATUS:qb}}=ko;function Wb(t){let e=[];for(let[r,A]of Object.entries(t))if(Array.isArray(A))for(let s of A)e.push(Buffer.from(r),Buffer.from(s));else e.push(Buffer.from(r),Buffer.from(A));return e}async function zb(t,e){t[he]=e,uh||(uh=!0,process.emitWarning("H2 support is experimental, expect them to change at any time.",{code:"UNDICI-H2"}));let r=ko.connect(t[bo],{createConnection:()=>e,peerMaxConcurrentStreams:t[hh]});r[Dt]=0,r[$r]=t,r[he]=e,H.addListener(r,"error",Kb),H.addListener(r,"frameError",jb),H.addListener(r,"end",Xb),H.addListener(r,"goaway",$b),H.addListener(r,"close",function(){let{[$r]:s}=this,{[he]:o}=s,n=this[he][Xe]||this[Xe]||new jA("closed",H.getSocketInfo(o));if(s[je]=null,s.destroyed){Ve(s[Lb]===0);let i=s[Jt].splice(s[Ke]);for(let a=0;a{A=!0}),{version:"h2",defaultPipelining:1/0,write(...s){return tk(t,...s)},resume(){Zb(t)},destroy(s,o){A?queueMicrotask(o):e.destroy(s).on("close",o)},get destroyed(){return e.destroyed},busy(){return!1}}}function Zb(t){let e=t[he];e?.destroyed===!1&&(t[_b]===0&&t[hh]===0?(e.unref(),t[je].unref()):(e.ref(),t[je].ref()))}function Kb(t){Ve(t.code!=="ERR_TLS_CERT_ALTNAME_INVALID"),this[he][Xe]=t,this[$r][ka](t)}function jb(t,e,r){if(r===0){let A=new ya(`HTTP/2: "frameError" received - type ${t}, code ${e}`);this[he][Xe]=A,this[$r][ka](A)}}function Xb(){let t=new jA("other side closed",H.getSocketInfo(this[he]));this.destroy(t),H.destroy(this[he],t)}function $b(t){let e=this[Xe]||new jA(`HTTP/2: "GOAWAY" frame received with code ${t}`,H.getSocketInfo(this)),r=this[$r];if(r[he]=null,r[xb]=null,this[je]!=null&&(this[je].destroy(e),this[je]=null),H.destroy(this[he],e),r[Ke]{e.aborted||e.completed||(S=S||new ch,H.errorRequest(t,e,S),E!=null&&H.destroy(E,S),H.destroy(l,S),t[Jt][t[Ke]++]=null,t[Ot]())};try{e.onConnect(p)}catch(S){H.errorRequest(t,e,S)}if(e.aborted)return!1;if(A==="CONNECT")return r.ref(),E=r.request(g,{endStream:!1,signal:a}),E.id&&!E.pending?(e.onUpgrade(null,null,E),++r[Dt],t[Jt][t[Ke]++]=null):E.once("ready",()=>{e.onUpgrade(null,null,E),++r[Dt],t[Jt][t[Ke]++]=null}),E.once("close",()=>{r[Dt]-=1,r[Dt]===0&&r.unref()}),!0;g[Ob]=s,g[Hb]="https";let w=A==="PUT"||A==="POST"||A==="PATCH";l&&typeof l.read=="function"&&l.read(0);let I=H.bodyLength(l);if(H.isFormDataLike(l)){gh??=Zr().extractBody;let[S,O]=gh(l);g["content-type"]=O,l=S.stream,I=S.length}if(I==null&&(I=e.contentLength),(I===0||!w)&&(I=null),ek(A)&&I>0&&e.contentLength!=null&&e.contentLength!==I){if(t[vb])return H.errorRequest(t,e,new wa),!1;process.emitWarning(new wa)}I!=null&&(Ve(l,"no body must not have content length"),g[Pb]=`${I}`),r.ref();let y=A==="GET"||A==="HEAD"||l===null;return i?(g[Vb]="100-continue",E=r.request(g,{endStream:y,signal:a}),E.once("continue",T)):(E=r.request(g,{endStream:y,signal:a}),T()),++r[Dt],E.once("response",S=>{let{[qb]:O,...j}=S;if(e.onResponseStarted(),e.aborted){let X=new ch;H.errorRequest(t,e,X),H.destroy(E,X);return}e.onHeaders(Number(O),Wb(j),E.resume.bind(E),"")===!1&&E.pause(),E.on("data",X=>{e.onData(X)===!1&&E.pause()})}),E.once("end",()=>{(E.state?.state==null||E.state.state<6)&&e.onComplete([]),r[Dt]===0&&r.unref(),p(new ya("HTTP/2: stream half-closed (remote)")),t[Jt][t[Ke]++]=null,t[ba]=t[Ke],t[Ot]()}),E.once("close",()=>{r[Dt]-=1,r[Dt]===0&&r.unref()}),E.once("error",function(S){p(S)}),E.once("frameError",(S,O)=>{p(new ya(`HTTP/2: "frameError" received - type ${S}, code ${O}`))}),!0;function T(){!l||I===0?lh(p,E,null,t,e,t[he],I,w):H.isBuffer(l)?lh(p,E,l,t,e,t[he],I,w):H.isBlobLike(l)?typeof l.stream=="function"?Eh(p,E,l.stream(),t,e,t[he],I,w):Ak(p,E,l,t,e,t[he],I,w):H.isStream(l)?rk(p,t[he],w,E,l,t,e,I):H.isIterable(l)?Eh(p,E,l,t,e,t[he],I,w):Ve(!1)}}function lh(t,e,r,A,s,o,n,i){try{r!=null&&H.isBuffer(r)&&(Ve(n===r.byteLength,"buffer body must have content length"),e.cork(),e.write(r),e.uncork(),e.end(),s.onBodySent(r)),i||(o[Do]=!0),s.onRequestSent(),A[Ot]()}catch(a){t(a)}}function rk(t,e,r,A,s,o,n,i){Ve(i!==0||o[Ro]===0,"stream body cannot be pipelined");let a=Mb(s,A,l=>{l?(H.destroy(a,l),t(l)):(H.removeAllListeners(a),n.onRequestSent(),r||(e[Do]=!0),o[Ot]())});H.addListener(a,"data",c);function c(l){n.onBodySent(l)}}async function Ak(t,e,r,A,s,o,n,i){Ve(n===r.size,"blob body must have content length");try{if(n!=null&&n!==r.size)throw new wa;let a=Buffer.from(await r.arrayBuffer());e.cork(),e.write(a),e.uncork(),e.end(),s.onBodySent(a),s.onRequestSent(),i||(o[Do]=!0),A[Ot]()}catch(a){t(a)}}async function Eh(t,e,r,A,s,o,n,i){Ve(n!==0||A[Ro]===0,"iterator body cannot be pipelined");let a=null;function c(){if(a){let g=a;a=null,g()}}let l=()=>new Promise((g,E)=>{Ve(a===null),o[Xe]?E(o[Xe]):a=g});e.on("close",c).on("drain",c);try{for await(let g of r){if(o[Xe])throw o[Xe];let E=e.write(g);s.onBodySent(g),E||await l()}e.end(),s.onRequestSent(),i||(o[Do]=!0),A[Ot]()}catch(g){t(g)}finally{e.off("close",c).off("drain",c)}}Qh.exports=zb});var Fo=m((oL,Ch)=>{"use strict";var lt=J(),{kBodyUsed:XA}=se(),Ra=require("node:assert"),{InvalidArgumentError:sk}=q(),ok=require("node:events"),nk=[300,301,302,303,307,308],dh=Symbol("body"),To=class{constructor(e){this[dh]=e,this[XA]=!1}async*[Symbol.asyncIterator](){Ra(!this[XA],"disturbed"),this[XA]=!0,yield*this[dh]}},Da=class{constructor(e,r,A,s){if(r!=null&&(!Number.isInteger(r)||r<0))throw new sk("maxRedirections must be a positive number");lt.validateHandler(s,A.method,A.upgrade),this.dispatch=e,this.location=null,this.abort=null,this.opts={...A,maxRedirections:0},this.maxRedirections=r,this.handler=s,this.history=[],this.redirectionLimitReached=!1,lt.isStream(this.opts.body)?(lt.bodyLength(this.opts.body)===0&&this.opts.body.on("data",function(){Ra(!1)}),typeof this.opts.body.readableDidRead!="boolean"&&(this.opts.body[XA]=!1,ok.prototype.on.call(this.opts.body,"data",function(){this[XA]=!0}))):this.opts.body&&typeof this.opts.body.pipeTo=="function"?this.opts.body=new To(this.opts.body):this.opts.body&&typeof this.opts.body!="string"&&!ArrayBuffer.isView(this.opts.body)&<.isIterable(this.opts.body)&&(this.opts.body=new To(this.opts.body))}onConnect(e){this.abort=e,this.handler.onConnect(e,{history:this.history})}onUpgrade(e,r,A){this.handler.onUpgrade(e,r,A)}onError(e){this.handler.onError(e)}onHeaders(e,r,A,s){if(this.location=this.history.length>=this.maxRedirections||lt.isDisturbed(this.opts.body)?null:ik(e,r),this.opts.throwOnMaxRedirect&&this.history.length>=this.maxRedirections){this.request&&this.request.abort(new Error("max redirects")),this.redirectionLimitReached=!0,this.abort(new Error("max redirects"));return}if(this.opts.origin&&this.history.push(new URL(this.opts.path,this.opts.origin)),!this.location)return this.handler.onHeaders(e,r,A,s);let{origin:o,pathname:n,search:i}=lt.parseURL(new URL(this.location,this.opts.origin&&new URL(this.opts.path,this.opts.origin))),a=i?`${n}${i}`:n;this.opts.headers=ak(this.opts.headers,e===303,this.opts.origin!==o),this.opts.path=a,this.opts.origin=o,this.opts.maxRedirections=0,this.opts.query=null,e===303&&this.opts.method!=="HEAD"&&(this.opts.method="GET",this.opts.body=null)}onData(e){if(!this.location)return this.handler.onData(e)}onComplete(e){this.location?(this.location=null,this.abort=null,this.dispatch(this.opts,this)):this.handler.onComplete(e)}onBodySent(e){this.handler.onBodySent&&this.handler.onBodySent(e)}};function ik(t,e){if(nk.indexOf(t)===-1)return null;for(let r=0;r{"use strict";var ck=Fo();function gk({maxRedirections:t}){return e=>function(A,s){let{maxRedirections:o=t}=A;if(!o)return e(A,s);let n=new ck(e,o,A,s);return A={...A,maxRedirections:0},e(A,n)}}ph.exports=gk});var rA=m((iL,Fh)=>{"use strict";var Rt=require("node:assert"),kh=require("node:net"),uk=require("node:http"),ur=J(),{channels:eA}=Lr(),lk=Fl(),Ek=Yr(),{InvalidArgumentError:ae,InformationalError:hk,ClientDestroyedError:Qk}=q(),Bk=xA(),{kUrl:Et,kServerName:Ht,kClient:dk,kBusy:Ta,kConnect:Ik,kResuming:lr,kRunning:As,kPending:ss,kSize:rs,kQueue:$e,kConnected:Ck,kConnecting:tA,kNeedDrain:Vt,kKeepAliveDefaultTimeout:fh,kHostHeader:pk,kPendingIdx:et,kRunningIdx:Tt,kError:fk,kPipelining:Uo,kKeepAliveTimeoutValue:mk,kMaxHeadersSize:wk,kKeepAliveMaxTimeout:yk,kKeepAliveTimeoutThreshold:bk,kHeadersTimeout:kk,kBodyTimeout:Dk,kStrictContentLength:Rk,kConnector:$A,kMaxRedirections:Tk,kMaxRequests:Fa,kCounter:Fk,kClose:Sk,kDestroy:Uk,kDispatch:Nk,kInterceptors:mh,kLocalAddress:es,kMaxResponseSize:Gk,kOnError:Mk,kHTTPContext:ce,kMaxConcurrentStreams:Lk,kResume:ts}=se(),vk=ah(),_k=Bh(),wh=!1,Pt=Symbol("kClosedResolve"),yh=()=>{};function Dh(t){return t[Uo]??t[ce]?.defaultPipelining??1}var Sa=class extends Ek{constructor(e,{interceptors:r,maxHeaderSize:A,headersTimeout:s,socketTimeout:o,requestTimeout:n,connectTimeout:i,bodyTimeout:a,idleTimeout:c,keepAlive:l,keepAliveTimeout:g,maxKeepAliveTimeout:E,keepAliveMaxTimeout:d,keepAliveTimeoutThreshold:B,socketPath:p,pipelining:w,tls:I,strictContentLength:y,maxCachedSessions:T,maxRedirections:S,connect:O,maxRequestsPerClient:j,localAddress:X,maxResponseSize:Ye,autoSelectFamily:Je,autoSelectFamilyAttemptTimeout:It,maxConcurrentStreams:ot,allowH2:Qe,webSocket:Ct}={}){if(super({webSocket:Ct}),l!==void 0)throw new ae("unsupported keepAlive, use pipelining=0 instead");if(o!==void 0)throw new ae("unsupported socketTimeout, use headersTimeout & bodyTimeout instead");if(n!==void 0)throw new ae("unsupported requestTimeout, use headersTimeout & bodyTimeout instead");if(c!==void 0)throw new ae("unsupported idleTimeout, use keepAliveTimeout instead");if(E!==void 0)throw new ae("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead");if(A!=null&&!Number.isFinite(A))throw new ae("invalid maxHeaderSize");if(p!=null&&typeof p!="string")throw new ae("invalid socketPath");if(i!=null&&(!Number.isFinite(i)||i<0))throw new ae("invalid connectTimeout");if(g!=null&&(!Number.isFinite(g)||g<=0))throw new ae("invalid keepAliveTimeout");if(d!=null&&(!Number.isFinite(d)||d<=0))throw new ae("invalid keepAliveMaxTimeout");if(B!=null&&!Number.isFinite(B))throw new ae("invalid keepAliveTimeoutThreshold");if(s!=null&&(!Number.isInteger(s)||s<0))throw new ae("headersTimeout must be a positive integer or zero");if(a!=null&&(!Number.isInteger(a)||a<0))throw new ae("bodyTimeout must be a positive integer or zero");if(O!=null&&typeof O!="function"&&typeof O!="object")throw new ae("connect must be a function or an object");if(S!=null&&(!Number.isInteger(S)||S<0))throw new ae("maxRedirections must be a positive number");if(j!=null&&(!Number.isInteger(j)||j<0))throw new ae("maxRequestsPerClient must be a positive number");if(X!=null&&(typeof X!="string"||kh.isIP(X)===0))throw new ae("localAddress must be valid string IP address");if(Ye!=null&&(!Number.isInteger(Ye)||Ye<-1))throw new ae("maxResponseSize must be a positive number");if(It!=null&&(!Number.isInteger(It)||It<-1))throw new ae("autoSelectFamilyAttemptTimeout must be a positive number");if(Qe!=null&&typeof Qe!="boolean")throw new ae("allowH2 must be a valid boolean value");if(ot!=null&&(typeof ot!="number"||ot<1))throw new ae("maxConcurrentStreams must be a positive integer, greater than 0");typeof O!="function"&&(O=Bk({...I,maxCachedSessions:T,allowH2:Qe,socketPath:p,timeout:i,...Je?{autoSelectFamily:Je,autoSelectFamilyAttemptTimeout:It}:void 0,...O})),r?.Client&&Array.isArray(r.Client)?(this[mh]=r.Client,wh||(wh=!0,process.emitWarning("Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.",{code:"UNDICI-CLIENT-INTERCEPTOR-DEPRECATED"}))):this[mh]=[xk({maxRedirections:S})],this[Et]=ur.parseOrigin(e),this[$A]=O,this[Uo]=w??1,this[wk]=A||uk.maxHeaderSize,this[fh]=g??4e3,this[yk]=d??6e5,this[bk]=B??2e3,this[mk]=this[fh],this[Ht]=null,this[es]=X??null,this[lr]=0,this[Vt]=0,this[pk]=`host: ${this[Et].hostname}${this[Et].port?`:${this[Et].port}`:""}\r -`,this[Dk]=a??3e5,this[kk]=s??3e5,this[Rk]=y??!0,this[Tk]=S,this[Fa]=j,this[Pt]=null,this[Gk]=Ye>-1?Ye:-1,this[Lk]=ot??100,this[ce]=null,this[$e]=[],this[Tt]=0,this[et]=0,this[ts]=Lt=>Ua(this,Lt),this[Mk]=Lt=>Rh(this,Lt)}get pipelining(){return this[Uo]}set pipelining(e){this[Uo]=e,this[ts](!0)}get[ss](){return this[$e].length-this[et]}get[As](){return this[et]-this[Tt]}get[rs](){return this[$e].length-this[Tt]}get[Ck](){return!!this[ce]&&!this[tA]&&!this[ce].destroyed}get[Ta](){return!!(this[ce]?.busy(null)||this[rs]>=(Dh(this)||1)||this[ss]>0)}[Ik](e){Th(this),this.once("connect",e)}[Nk](e,r){let A=e.origin||this[Et].origin,s=new lk(A,e,r);return this[$e].push(s),this[lr]||(ur.bodyLength(s.body)==null&&ur.isIterable(s.body)?(this[lr]=1,queueMicrotask(()=>Ua(this))):this[ts](!0)),this[lr]&&this[Vt]!==2&&this[Ta]&&(this[Vt]=2),this[Vt]<2}async[Sk](){return new Promise(e=>{this[rs]?this[Pt]=e:e(null)})}async[Uk](e){return new Promise(r=>{let A=this[$e].splice(this[et]);for(let o=0;o{this[Pt]&&(this[Pt](),this[Pt]=null),r(null)};this[ce]?(this[ce].destroy(e,s),this[ce]=null):queueMicrotask(s),this[ts]()})}},xk=So();function Rh(t,e){if(t[As]===0&&e.code!=="UND_ERR_INFO"&&e.code!=="UND_ERR_SOCKET"){Rt(t[et]===t[Tt]);let r=t[$e].splice(t[Tt]);for(let A=0;A{t[$A]({host:e,hostname:r,protocol:A,port:s,servername:t[Ht],localAddress:t[es]},(a,c)=>{a?i(a):n(c)})});if(t.destroyed){ur.destroy(o.on("error",yh),new Qk);return}Rt(o);try{t[ce]=o.alpnProtocol==="h2"?await _k(t,o):await vk(t,o)}catch(n){throw o.destroy().on("error",yh),n}t[tA]=!1,o[Fk]=0,o[Fa]=t[Fa],o[dk]=t,o[fk]=null,eA.connected.hasSubscribers&&eA.connected.publish({connectParams:{host:e,hostname:r,protocol:A,port:s,version:t[ce]?.version,servername:t[Ht],localAddress:t[es]},connector:t[$A],socket:o}),t.emit("connect",t[Et],[t])}catch(o){if(t.destroyed)return;if(t[tA]=!1,eA.connectError.hasSubscribers&&eA.connectError.publish({connectParams:{host:e,hostname:r,protocol:A,port:s,version:t[ce]?.version,servername:t[Ht],localAddress:t[es]},connector:t[$A],error:o}),o.code==="ERR_TLS_CERT_ALTNAME_INVALID")for(Rt(t[As]===0);t[ss]>0&&t[$e][t[et]].servername===t[Ht];){let n=t[$e][t[et]++];ur.errorRequest(t,n,o)}else Rh(t,o);t.emit("connectionError",t[Et],[t],o)}t[ts]()}function bh(t){t[Vt]=0,t.emit("drain",t[Et],[t])}function Ua(t,e){t[lr]!==2&&(t[lr]=2,Yk(t,e),t[lr]=0,t[Tt]>256&&(t[$e].splice(0,t[Tt]),t[et]-=t[Tt],t[Tt]=0))}function Yk(t,e){for(;;){if(t.destroyed){Rt(t[ss]===0);return}if(t[Pt]&&!t[rs]){t[Pt](),t[Pt]=null;return}if(t[ce]&&t[ce].resume(),t[Ta])t[Vt]=2;else if(t[Vt]===2){e?(t[Vt]=1,queueMicrotask(()=>bh(t))):bh(t);continue}if(t[ss]===0||t[As]>=(Dh(t)||1))return;let r=t[$e][t[et]];if(t[Et].protocol==="https:"&&t[Ht]!==r.servername){if(t[As]>0)return;t[Ht]=r.servername,t[ce]?.destroy(new hk("servername changed"),()=>{t[ce]=null,Ua(t)})}if(t[tA])return;if(!t[ce]){Th(t);return}if(t[ce].destroyed||t[ce].busy(r))return;!r.aborted&&t[ce].write(r)?t[et]++:t[$e].splice(t[et],1)}}Fh.exports=Sa});var Na=m((cL,Sh)=>{"use strict";var No=class{constructor(){this.bottom=0,this.top=0,this.list=new Array(2048),this.next=null}isEmpty(){return this.top===this.bottom}isFull(){return(this.top+1&2047)===this.bottom}push(e){this.list[this.top]=e,this.top=this.top+1&2047}shift(){let e=this.list[this.bottom];return e===void 0?null:(this.list[this.bottom]=void 0,this.bottom=this.bottom+1&2047,e)}};Sh.exports=class{constructor(){this.head=this.tail=new No}isEmpty(){return this.head.isEmpty()}push(e){this.head.isFull()&&(this.head=this.head.next=new No),this.head.push(e)}shift(){let e=this.tail,r=e.shift();return e.isEmpty()&&e.next!==null&&(this.tail=e.next),r}}});var Nh=m((gL,Uh)=>{var{kFree:Jk,kConnected:Ok,kPending:Hk,kQueued:Pk,kRunning:Vk,kSize:qk}=se(),Er=Symbol("pool"),Ga=class{constructor(e){this[Er]=e}get connected(){return this[Er][Ok]}get free(){return this[Er][Jk]}get pending(){return this[Er][Hk]}get queued(){return this[Er][Pk]}get running(){return this[Er][Vk]}get size(){return this[Er][qk]}};Uh.exports=Ga});var Ya=m((uL,Hh)=>{"use strict";var Wk=Yr(),zk=Na(),{kConnected:Ma,kSize:Gh,kRunning:Mh,kPending:Lh,kQueued:os,kBusy:Zk,kFree:Kk,kUrl:jk,kClose:Xk,kDestroy:$k,kDispatch:eD}=se(),tD=Nh(),ke=Symbol("clients"),we=Symbol("needDrain"),ns=Symbol("queue"),La=Symbol("closed resolve"),va=Symbol("onDrain"),vh=Symbol("onConnect"),_h=Symbol("onDisconnect"),xh=Symbol("onConnectionError"),_a=Symbol("get dispatcher"),Jh=Symbol("add client"),Oh=Symbol("remove client"),Yh=Symbol("stats"),xa=class extends Wk{constructor(e){super(e),this[ns]=new zk,this[ke]=[],this[os]=0;let r=this;this[va]=function(s,o){let n=r[ns],i=!1;for(;!i;){let a=n.shift();if(!a)break;r[os]--,i=!this.dispatch(a.opts,a.handler)}this[we]=i,!this[we]&&r[we]&&(r[we]=!1,r.emit("drain",s,[r,...o])),r[La]&&n.isEmpty()&&Promise.all(r[ke].map(a=>a.close())).then(r[La])},this[vh]=(A,s)=>{r.emit("connect",A,[r,...s])},this[_h]=(A,s,o)=>{r.emit("disconnect",A,[r,...s],o)},this[xh]=(A,s,o)=>{r.emit("connectionError",A,[r,...s],o)},this[Yh]=new tD(this)}get[Zk](){return this[we]}get[Ma](){return this[ke].filter(e=>e[Ma]).length}get[Kk](){return this[ke].filter(e=>e[Ma]&&!e[we]).length}get[Lh](){let e=this[os];for(let{[Lh]:r}of this[ke])e+=r;return e}get[Mh](){let e=0;for(let{[Mh]:r}of this[ke])e+=r;return e}get[Gh](){let e=this[os];for(let{[Gh]:r}of this[ke])e+=r;return e}get stats(){return this[Yh]}async[Xk](){this[ns].isEmpty()?await Promise.all(this[ke].map(e=>e.close())):await new Promise(e=>{this[La]=e})}async[$k](e){for(;;){let r=this[ns].shift();if(!r)break;r.handler.onError(e)}await Promise.all(this[ke].map(r=>r.destroy(e)))}[eD](e,r){let A=this[_a]();return A?A.dispatch(e,r)||(A[we]=!0,this[we]=!this[_a]()):(this[we]=!0,this[ns].push({opts:e,handler:r}),this[os]++),!this[we]}[Jh](e){return e.on("drain",this[va]).on("connect",this[vh]).on("disconnect",this[_h]).on("connectionError",this[xh]),this[ke].push(e),this[we]&&queueMicrotask(()=>{this[we]&&this[va](e[jk],[this,e])}),this}[Oh](e){e.close(()=>{let r=this[ke].indexOf(e);r!==-1&&this[ke].splice(r,1)}),this[we]=this[ke].some(r=>!r[we]&&r.closed!==!0&&r.destroyed!==!0)}};Hh.exports={PoolBase:xa,kClients:ke,kNeedDrain:we,kAddClient:Jh,kRemoveClient:Oh,kGetDispatcher:_a}});var AA=m((lL,Wh)=>{"use strict";var{PoolBase:rD,kClients:Go,kNeedDrain:AD,kAddClient:sD,kGetDispatcher:oD}=Ya(),nD=rA(),{InvalidArgumentError:Ja}=q(),Ph=J(),{kUrl:Vh,kInterceptors:iD}=se(),aD=xA(),Oa=Symbol("options"),Ha=Symbol("connections"),qh=Symbol("factory");function cD(t,e){return new nD(t,e)}var Pa=class extends rD{constructor(e,{connections:r,factory:A=cD,connect:s,connectTimeout:o,tls:n,maxCachedSessions:i,socketPath:a,autoSelectFamily:c,autoSelectFamilyAttemptTimeout:l,allowH2:g,...E}={}){if(r!=null&&(!Number.isFinite(r)||r<0))throw new Ja("invalid connections");if(typeof A!="function")throw new Ja("factory must be a function.");if(s!=null&&typeof s!="function"&&typeof s!="object")throw new Ja("connect must be a function or an object");typeof s!="function"&&(s=aD({...n,maxCachedSessions:i,allowH2:g,socketPath:a,timeout:o,...c?{autoSelectFamily:c,autoSelectFamilyAttemptTimeout:l}:void 0,...s})),super(E),this[iD]=E.interceptors?.Pool&&Array.isArray(E.interceptors.Pool)?E.interceptors.Pool:[],this[Ha]=r||null,this[Vh]=Ph.parseOrigin(e),this[Oa]={...Ph.deepClone(E),connect:s,allowH2:g},this[Oa].interceptors=E.interceptors?{...E.interceptors}:void 0,this[qh]=A,this.on("connectionError",(d,B,p)=>{for(let w of B){let I=this[Go].indexOf(w);I!==-1&&this[Go].splice(I,1)}})}[oD](){for(let e of this[Go])if(!e[AD])return e;if(!this[Ha]||this[Go].length{"use strict";var{BalancedPoolMissingUpstreamError:gD,InvalidArgumentError:uD}=q(),{PoolBase:lD,kClients:Ce,kNeedDrain:is,kAddClient:ED,kRemoveClient:hD,kGetDispatcher:QD}=Ya(),BD=AA(),{kUrl:Va,kInterceptors:dD}=se(),{parseOrigin:zh}=J(),Zh=Symbol("factory"),Mo=Symbol("options"),Kh=Symbol("kGreatestCommonDivisor"),hr=Symbol("kCurrentWeight"),Qr=Symbol("kIndex"),qe=Symbol("kWeight"),Lo=Symbol("kMaxWeightPerServer"),vo=Symbol("kErrorPenalty");function ID(t,e){if(t===0)return e;for(;e!==0;){let r=e;e=t%e,t=r}return t}function CD(t,e){return new BD(t,e)}var qa=class extends lD{constructor(e=[],{factory:r=CD,...A}={}){if(super(),this[Mo]=A,this[Qr]=-1,this[hr]=0,this[Lo]=this[Mo].maxWeightPerServer||100,this[vo]=this[Mo].errorPenalty||15,Array.isArray(e)||(e=[e]),typeof r!="function")throw new uD("factory must be a function.");this[dD]=A.interceptors?.BalancedPool&&Array.isArray(A.interceptors.BalancedPool)?A.interceptors.BalancedPool:[],this[Zh]=r;for(let s of e)this.addUpstream(s);this._updateBalancedPoolStats()}addUpstream(e){let r=zh(e).origin;if(this[Ce].find(s=>s[Va].origin===r&&s.closed!==!0&&s.destroyed!==!0))return this;let A=this[Zh](r,Object.assign({},this[Mo]));this[ED](A),A.on("connect",()=>{A[qe]=Math.min(this[Lo],A[qe]+this[vo])}),A.on("connectionError",()=>{A[qe]=Math.max(1,A[qe]-this[vo]),this._updateBalancedPoolStats()}),A.on("disconnect",(...s)=>{let o=s[2];o&&o.code==="UND_ERR_SOCKET"&&(A[qe]=Math.max(1,A[qe]-this[vo]),this._updateBalancedPoolStats())});for(let s of this[Ce])s[qe]=this[Lo];return this._updateBalancedPoolStats(),this}_updateBalancedPoolStats(){let e=0;for(let r=0;rs[Va].origin===r&&s.closed!==!0&&s.destroyed!==!0);return A&&this[hD](A),this}get upstreams(){return this[Ce].filter(e=>e.closed!==!0&&e.destroyed!==!0).map(e=>e[Va].origin)}[QD](){if(this[Ce].length===0)throw new gD;if(!this[Ce].find(o=>!o[is]&&o.closed!==!0&&o.destroyed!==!0)||this[Ce].map(o=>o[is]).reduce((o,n)=>o&&n,!0))return;let A=0,s=this[Ce].findIndex(o=>!o[is]);for(;A++this[Ce][s][qe]&&!o[is]&&(s=this[Qr]),this[Qr]===0&&(this[hr]=this[hr]-this[Kh],this[hr]<=0&&(this[hr]=this[Lo])),o[qe]>=this[hr]&&!o[is])return o}return this[hr]=this[Ce][s][qe],this[Qr]=s,this[Ce][s]}};jh.exports=qa});var sA=m((hL,oQ)=>{"use strict";var{InvalidArgumentError:_o}=q(),{kClients:qt,kRunning:$h,kClose:pD,kDestroy:fD,kDispatch:mD,kInterceptors:wD}=se(),yD=Yr(),bD=AA(),kD=rA(),DD=J(),RD=So(),eQ=Symbol("onConnect"),tQ=Symbol("onDisconnect"),rQ=Symbol("onConnectionError"),TD=Symbol("maxRedirections"),AQ=Symbol("onDrain"),sQ=Symbol("factory"),Wa=Symbol("options");function FD(t,e){return e&&e.connections===1?new kD(t,e):new bD(t,e)}var za=class extends yD{constructor({factory:e=FD,maxRedirections:r=0,connect:A,...s}={}){if(typeof e!="function")throw new _o("factory must be a function.");if(A!=null&&typeof A!="function"&&typeof A!="object")throw new _o("connect must be a function or an object");if(!Number.isInteger(r)||r<0)throw new _o("maxRedirections must be a positive number");super(s),A&&typeof A!="function"&&(A={...A}),this[wD]=s.interceptors?.Agent&&Array.isArray(s.interceptors.Agent)?s.interceptors.Agent:[RD({maxRedirections:r})],this[Wa]={...DD.deepClone(s),connect:A},this[Wa].interceptors=s.interceptors?{...s.interceptors}:void 0,this[TD]=r,this[sQ]=e,this[qt]=new Map,this[AQ]=(o,n)=>{this.emit("drain",o,[this,...n])},this[eQ]=(o,n)=>{this.emit("connect",o,[this,...n])},this[tQ]=(o,n,i)=>{this.emit("disconnect",o,[this,...n],i)},this[rQ]=(o,n,i)=>{this.emit("connectionError",o,[this,...n],i)}}get[$h](){let e=0;for(let r of this[qt].values())e+=r[$h];return e}[mD](e,r){let A;if(e.origin&&(typeof e.origin=="string"||e.origin instanceof URL))A=String(e.origin);else throw new _o("opts.origin must be a non-empty string or URL.");let s=this[qt].get(A);return s||(s=this[sQ](e.origin,this[Wa]).on("drain",this[AQ]).on("connect",this[eQ]).on("disconnect",this[tQ]).on("connectionError",this[rQ]),this[qt].set(A,s)),s.dispatch(e,r)}async[pD](){let e=[];for(let r of this[qt].values())e.push(r.close());this[qt].clear(),await Promise.all(e)}async[fD](e){let r=[];for(let A of this[qt].values())r.push(A.destroy(e));this[qt].clear(),await Promise.all(r)}};oQ.exports=za});var $a=m((QL,BQ)=>{"use strict";var{kProxy:Za,kClose:uQ,kDestroy:lQ,kDispatch:nQ,kInterceptors:SD}=se(),{URL:Br}=require("node:url"),UD=sA(),EQ=AA(),hQ=Yr(),{InvalidArgumentError:oA,RequestAbortedError:ND,SecureProxyConnectionError:GD}=q(),iQ=xA(),QQ=rA(),xo=Symbol("proxy agent"),Yo=Symbol("proxy client"),Wt=Symbol("proxy headers"),Ka=Symbol("request tls settings"),aQ=Symbol("proxy tls settings"),cQ=Symbol("connect endpoint function"),gQ=Symbol("tunnel proxy");function MD(t){return t==="https:"?443:80}function LD(t,e){return new EQ(t,e)}var vD=()=>{};function _D(t,e){return e.connections===1?new QQ(t,e):new EQ(t,e)}var ja=class extends hQ{#e;constructor(e,{headers:r={},connect:A,factory:s}){if(super(),!e)throw new oA("Proxy URL is mandatory");this[Wt]=r,s?this.#e=s(e,{connect:A}):this.#e=new QQ(e,{connect:A})}[nQ](e,r){let A=r.onHeaders;r.onHeaders=function(i,a,c){if(i===407){typeof r.onError=="function"&&r.onError(new oA("Proxy Authentication Required (407)"));return}A&&A.call(this,i,a,c)};let{origin:s,path:o="/",headers:n={}}=e;if(e.path=s+o,!("host"in n)&&!("Host"in n)){let{host:i}=new Br(s);n.host=i}return e.headers={...this[Wt],...n},this.#e[nQ](e,r)}async[uQ](){return this.#e.close()}async[lQ](e){return this.#e.destroy(e)}},Xa=class extends hQ{constructor(e){if(super(),!e||typeof e=="object"&&!(e instanceof Br)&&!e.uri)throw new oA("Proxy uri is mandatory");let{clientFactory:r=LD}=e;if(typeof r!="function")throw new oA("Proxy opts.clientFactory must be a function.");let{proxyTunnel:A=!0}=e,s=this.#e(e),{href:o,origin:n,port:i,protocol:a,username:c,password:l,hostname:g}=s;if(this[Za]={uri:o,protocol:a},this[SD]=e.interceptors?.ProxyAgent&&Array.isArray(e.interceptors.ProxyAgent)?e.interceptors.ProxyAgent:[],this[Ka]=e.requestTls,this[aQ]=e.proxyTls,this[Wt]=e.headers||{},this[gQ]=A,e.auth&&e.token)throw new oA("opts.auth cannot be used in combination with opts.token");e.auth?this[Wt]["proxy-authorization"]=`Basic ${e.auth}`:e.token?this[Wt]["proxy-authorization"]=e.token:c&&l&&(this[Wt]["proxy-authorization"]=`Basic ${Buffer.from(`${decodeURIComponent(c)}:${decodeURIComponent(l)}`).toString("base64")}`);let E=iQ({...e.proxyTls});this[cQ]=iQ({...e.requestTls});let d=e.factory||_D,B=(p,w)=>{let{protocol:I}=new Br(p);return!this[gQ]&&I==="http:"&&this[Za].protocol==="http:"?new ja(this[Za].uri,{headers:this[Wt],connect:E,factory:d}):d(p,w)};this[Yo]=r(s,{connect:E}),this[xo]=new UD({...e,factory:B,connect:async(p,w)=>{let I=p.host;p.port||(I+=`:${MD(p.protocol)}`);try{let{socket:y,statusCode:T}=await this[Yo].connect({origin:n,port:i,path:I,signal:p.signal,headers:{...this[Wt],host:p.host},servername:this[aQ]?.servername||g});if(T!==200&&(y.on("error",vD).destroy(),w(new ND(`Proxy response (${T}) !== 200 when HTTP Tunneling`))),p.protocol!=="https:"){w(null,y);return}let S;this[Ka]?S=this[Ka].servername:S=p.servername,this[cQ]({...p,servername:S,httpSocket:y},w)}catch(y){y.code==="ERR_TLS_CERT_ALTNAME_INVALID"?w(new GD(y)):w(y)}}})}dispatch(e,r){let A=xD(e.headers);if(YD(A),A&&!("host"in A)&&!("Host"in A)){let{host:s}=new Br(e.origin);A.host=s}return this[xo].dispatch({...e,headers:A},r)}#e(e){return typeof e=="string"?new Br(e):e instanceof Br?e:new Br(e.uri)}async[uQ](){await this[xo].close(),await this[Yo].close()}async[lQ](){await this[xo].destroy(),await this[Yo].destroy()}};function xD(t){if(Array.isArray(t)){let e={};for(let r=0;rr.toLowerCase()==="proxy-authorization"))throw new oA("Proxy-Authorization should be sent in ProxyAgent constructor")}BQ.exports=Xa});var mQ=m((BL,fQ)=>{"use strict";var JD=Yr(),{kClose:OD,kDestroy:HD,kClosed:dQ,kDestroyed:IQ,kDispatch:PD,kNoProxyAgent:as,kHttpProxyAgent:zt,kHttpsProxyAgent:dr}=se(),CQ=$a(),VD=sA(),qD={"http:":80,"https:":443},pQ=!1,ec=class extends JD{#e=null;#t=null;#r=null;constructor(e={}){super(),this.#r=e,pQ||(pQ=!0,process.emitWarning("EnvHttpProxyAgent is experimental, expect them to change at any time.",{code:"UNDICI-EHPA"}));let{httpProxy:r,httpsProxy:A,noProxy:s,...o}=e;this[as]=new VD(o);let n=r??process.env.http_proxy??process.env.HTTP_PROXY;n?this[zt]=new CQ({...o,uri:n}):this[zt]=this[as];let i=A??process.env.https_proxy??process.env.HTTPS_PROXY;i?this[dr]=new CQ({...o,uri:i}):this[dr]=this[zt],this.#A()}[PD](e,r){let A=new URL(e.origin);return this.#o(A).dispatch(e,r)}async[OD](){await this[as].close(),this[zt][dQ]||await this[zt].close(),this[dr][dQ]||await this[dr].close()}async[HD](e){await this[as].destroy(e),this[zt][IQ]||await this[zt].destroy(e),this[dr][IQ]||await this[dr].destroy(e)}#o(e){let{protocol:r,host:A,port:s}=e;return A=A.replace(/:\d*$/,"").toLowerCase(),s=Number.parseInt(s,10)||qD[r]||0,this.#s(A,s)?r==="https:"?this[dr]:this[zt]:this[as]}#s(e,r){if(this.#n&&this.#A(),this.#t.length===0)return!0;if(this.#e==="*")return!1;for(let A=0;A{"use strict";var nA=require("node:assert"),{kRetryHandlerDefaultRetry:wQ}=se(),{RequestRetryError:cs}=q(),{isDisturbed:yQ,parseHeaders:WD,parseRangeHeader:bQ,wrapRequestBody:zD}=J();function ZD(t){let e=Date.now();return new Date(t).getTime()-e}var tc=class t{constructor(e,r){let{retryOptions:A,...s}=e,{retry:o,maxRetries:n,maxTimeout:i,minTimeout:a,timeoutFactor:c,methods:l,errorCodes:g,retryAfter:E,statusCodes:d}=A??{};this.dispatch=r.dispatch,this.handler=r.handler,this.opts={...s,body:zD(e.body)},this.abort=null,this.aborted=!1,this.retryOpts={retry:o??t[wQ],retryAfter:E??!0,maxTimeout:i??30*1e3,minTimeout:a??500,timeoutFactor:c??2,maxRetries:n??5,methods:l??["GET","HEAD","OPTIONS","PUT","DELETE","TRACE"],statusCodes:d??[500,502,503,504,429],errorCodes:g??["ECONNRESET","ECONNREFUSED","ENOTFOUND","ENETDOWN","ENETUNREACH","EHOSTDOWN","EHOSTUNREACH","EPIPE","UND_ERR_SOCKET"]},this.retryCount=0,this.retryCountCheckpoint=0,this.start=0,this.end=null,this.etag=null,this.resume=null,this.handler.onConnect(B=>{this.aborted=!0,this.abort?this.abort(B):this.reason=B})}onRequestSent(){this.handler.onRequestSent&&this.handler.onRequestSent()}onUpgrade(e,r,A){this.handler.onUpgrade&&this.handler.onUpgrade(e,r,A)}onConnect(e){this.aborted?e(this.reason):this.abort=e}onBodySent(e){if(this.handler.onBodySent)return this.handler.onBodySent(e)}static[wQ](e,{state:r,opts:A},s){let{statusCode:o,code:n,headers:i}=e,{method:a,retryOptions:c}=A,{maxRetries:l,minTimeout:g,maxTimeout:E,timeoutFactor:d,statusCodes:B,errorCodes:p,methods:w}=c,{counter:I}=r;if(n&&n!=="UND_ERR_REQ_RETRY"&&!p.includes(n)){s(e);return}if(Array.isArray(w)&&!w.includes(a)){s(e);return}if(o!=null&&Array.isArray(B)&&!B.includes(o)){s(e);return}if(I>l){s(e);return}let y=i?.["retry-after"];y&&(y=Number(y),y=Number.isNaN(y)?ZD(y):y*1e3);let T=y>0?Math.min(y,E):Math.min(g*d**(I-1),E);setTimeout(()=>s(null),T)}onHeaders(e,r,A,s){let o=WD(r);if(this.retryCount+=1,e>=300)return this.retryOpts.statusCodes.includes(e)===!1?this.handler.onHeaders(e,r,A,s):(this.abort(new cs("Request failed",e,{headers:o,data:{count:this.retryCount}})),!1);if(this.resume!=null){if(this.resume=null,e!==206&&(this.start>0||e!==200))return this.abort(new cs("server does not support the range header and the payload was partially consumed",e,{headers:o,data:{count:this.retryCount}})),!1;let i=bQ(o["content-range"]);if(!i)return this.abort(new cs("Content-Range mismatch",e,{headers:o,data:{count:this.retryCount}})),!1;if(this.etag!=null&&this.etag!==o.etag)return this.abort(new cs("ETag mismatch",e,{headers:o,data:{count:this.retryCount}})),!1;let{start:a,size:c,end:l=c-1}=i;return nA(this.start===a,"content-range mismatch"),nA(this.end==null||this.end===l,"content-range mismatch"),this.resume=A,!0}if(this.end==null){if(e===206){let i=bQ(o["content-range"]);if(i==null)return this.handler.onHeaders(e,r,A,s);let{start:a,size:c,end:l=c-1}=i;nA(a!=null&&Number.isFinite(a),"content-range mismatch"),nA(l!=null&&Number.isFinite(l),"invalid content-length"),this.start=a,this.end=l}if(this.end==null){let i=o["content-length"];this.end=i!=null?Number(i)-1:null}return nA(Number.isFinite(this.start)),nA(this.end==null||Number.isFinite(this.end),"invalid content-length"),this.resume=A,this.etag=o.etag!=null?o.etag:null,this.etag!=null&&this.etag.startsWith("W/")&&(this.etag=null),this.handler.onHeaders(e,r,A,s)}let n=new cs("Request failed",e,{headers:o,data:{count:this.retryCount}});return this.abort(n),!1}onData(e){return this.start+=e.length,this.handler.onData(e)}onComplete(e){return this.retryCount=0,this.handler.onComplete(e)}onError(e){if(this.aborted||yQ(this.opts.body))return this.handler.onError(e);this.retryCount-this.retryCountCheckpoint>0?this.retryCount=this.retryCountCheckpoint+(this.retryCount-this.retryCountCheckpoint):this.retryCount+=1,this.retryOpts.retry(e,{state:{counter:this.retryCount},opts:{retryOptions:this.retryOpts,...this.opts}},r.bind(this));function r(A){if(A!=null||this.aborted||yQ(this.opts.body))return this.handler.onError(A);if(this.start!==0){let s={range:`bytes=${this.start}-${this.end??""}`};this.etag!=null&&(s["if-match"]=this.etag),this.opts={...this.opts,headers:{...this.opts.headers,...s}}}try{this.retryCountCheckpoint=this.retryCount,this.dispatch(this.opts,this)}catch(s){this.handler.onError(s)}}}};kQ.exports=tc});var RQ=m((IL,DQ)=>{"use strict";var KD=vA(),jD=Jo(),rc=class extends KD{#e=null;#t=null;constructor(e,r={}){super(r),this.#e=e,this.#t=r}dispatch(e,r){let A=new jD({...e,retryOptions:this.#t},{dispatch:this.#e.dispatch.bind(this.#e),handler:r});return this.#e.dispatch(e,A)}close(){return this.#e.close()}destroy(){return this.#e.destroy()}};DQ.exports=rc});var ac=m((CL,vQ)=>{"use strict";var NQ=require("node:assert"),{Readable:XD}=require("node:stream"),{RequestAbortedError:GQ,NotSupportedError:$D,InvalidArgumentError:eR,AbortError:Ac}=q(),MQ=J(),{ReadableStreamFrom:tR}=J(),Ue=Symbol("kConsume"),gs=Symbol("kReading"),Zt=Symbol("kBody"),TQ=Symbol("kAbort"),LQ=Symbol("kContentType"),FQ=Symbol("kContentLength"),rR=()=>{},sc=class extends XD{constructor({resume:e,abort:r,contentType:A="",contentLength:s,highWaterMark:o=64*1024}){super({autoDestroy:!0,read:e,highWaterMark:o}),this._readableState.dataEmitted=!1,this[TQ]=r,this[Ue]=null,this[Zt]=null,this[LQ]=A,this[FQ]=s,this[gs]=!1}destroy(e){return!e&&!this._readableState.endEmitted&&(e=new GQ),e&&this[TQ](),super.destroy(e)}_destroy(e,r){this[gs]?r(e):setImmediate(()=>{r(e)})}on(e,...r){return(e==="data"||e==="readable")&&(this[gs]=!0),super.on(e,...r)}addListener(e,...r){return this.on(e,...r)}off(e,...r){let A=super.off(e,...r);return(e==="data"||e==="readable")&&(this[gs]=this.listenerCount("data")>0||this.listenerCount("readable")>0),A}removeListener(e,...r){return this.off(e,...r)}push(e){return this[Ue]&&e!==null?(nc(this[Ue],e),this[gs]?super.push(e):!0):super.push(e)}async text(){return us(this,"text")}async json(){return us(this,"json")}async blob(){return us(this,"blob")}async bytes(){return us(this,"bytes")}async arrayBuffer(){return us(this,"arrayBuffer")}async formData(){throw new $D}get bodyUsed(){return MQ.isDisturbed(this)}get body(){return this[Zt]||(this[Zt]=tR(this),this[Ue]&&(this[Zt].getReader(),NQ(this[Zt].locked))),this[Zt]}async dump(e){let r=Number.isFinite(e?.limit)?e.limit:131072,A=e?.signal;if(A!=null&&(typeof A!="object"||!("aborted"in A)))throw new eR("signal must be an AbortSignal");return A?.throwIfAborted(),this._readableState.closeEmitted?null:await new Promise((s,o)=>{this[FQ]>r&&this.destroy(new Ac);let n=()=>{this.destroy(A.reason??new Ac)};A?.addEventListener("abort",n),this.on("close",function(){A?.removeEventListener("abort",n),A?.aborted?o(A.reason??new Ac):s(null)}).on("error",rR).on("data",function(i){r-=i.length,r<=0&&this.destroy()}).resume()})}};function AR(t){return t[Zt]&&t[Zt].locked===!0||t[Ue]}function sR(t){return MQ.isDisturbed(t)||AR(t)}async function us(t,e){return NQ(!t[Ue]),new Promise((r,A)=>{if(sR(t)){let s=t._readableState;s.destroyed&&s.closeEmitted===!1?t.on("error",o=>{A(o)}).on("close",()=>{A(new TypeError("unusable"))}):A(s.errored??new TypeError("unusable"))}else queueMicrotask(()=>{t[Ue]={type:e,stream:t,resolve:r,reject:A,length:0,body:[]},t.on("error",function(s){ic(this[Ue],s)}).on("close",function(){this[Ue].body!==null&&ic(this[Ue],new GQ)}),oR(t[Ue])})})}function oR(t){if(t.body===null)return;let{_readableState:e}=t.stream;if(e.bufferIndex){let r=e.bufferIndex,A=e.buffer.length;for(let s=r;s2&&r[0]===239&&r[1]===187&&r[2]===191?3:0;return r.utf8Slice(s,A)}function SQ(t,e){if(t.length===0||e===0)return new Uint8Array(0);if(t.length===1)return new Uint8Array(t[0]);let r=new Uint8Array(Buffer.allocUnsafeSlow(e).buffer),A=0;for(let s=0;s{var nR=require("node:assert"),{ResponseStatusCodeError:_Q}=q(),{chunksDecode:xQ}=ac(),iR=128*1024;async function aR({callback:t,body:e,contentType:r,statusCode:A,statusMessage:s,headers:o}){nR(e);let n=[],i=0;try{for await(let g of e)if(n.push(g),i+=g.length,i>iR){n=[],i=0;break}}catch{n=[],i=0}let a=`Response status code ${A}${s?`: ${s}`:""}`;if(A===204||!r||!i){queueMicrotask(()=>t(new _Q(a,A,o)));return}let c=Error.stackTraceLimit;Error.stackTraceLimit=0;let l;try{YQ(r)?l=JSON.parse(xQ(n,i)):JQ(r)&&(l=xQ(n,i))}catch{}finally{Error.stackTraceLimit=c}queueMicrotask(()=>t(new _Q(a,A,o,l)))}var YQ=t=>t.length>15&&t[11]==="/"&&t[0]==="a"&&t[1]==="p"&&t[2]==="p"&&t[3]==="l"&&t[4]==="i"&&t[5]==="c"&&t[6]==="a"&&t[7]==="t"&&t[8]==="i"&&t[9]==="o"&&t[10]==="n"&&t[12]==="j"&&t[13]==="s"&&t[14]==="o"&&t[15]==="n",JQ=t=>t.length>4&&t[4]==="/"&&t[0]==="t"&&t[1]==="e"&&t[2]==="x"&&t[3]==="t";OQ.exports={getResolveErrorBodyCallback:aR,isContentTypeApplicationJson:YQ,isContentTypeText:JQ}});var VQ=m((fL,gc)=>{"use strict";var cR=require("node:assert"),{Readable:gR}=ac(),{InvalidArgumentError:iA,RequestAbortedError:HQ}=q(),Ne=J(),{getResolveErrorBodyCallback:uR}=cc(),{AsyncResource:lR}=require("node:async_hooks"),Oo=class extends lR{constructor(e,r){if(!e||typeof e!="object")throw new iA("invalid opts");let{signal:A,method:s,opaque:o,body:n,onInfo:i,responseHeaders:a,throwOnError:c,highWaterMark:l}=e;try{if(typeof r!="function")throw new iA("invalid callback");if(l&&(typeof l!="number"||l<0))throw new iA("invalid highWaterMark");if(A&&typeof A.on!="function"&&typeof A.addEventListener!="function")throw new iA("signal must be an EventEmitter or EventTarget");if(s==="CONNECT")throw new iA("invalid method");if(i&&typeof i!="function")throw new iA("invalid onInfo callback");super("UNDICI_REQUEST")}catch(g){throw Ne.isStream(n)&&Ne.destroy(n.on("error",Ne.nop),g),g}this.method=s,this.responseHeaders=a||null,this.opaque=o||null,this.callback=r,this.res=null,this.abort=null,this.body=n,this.trailers={},this.context=null,this.onInfo=i||null,this.throwOnError=c,this.highWaterMark=l,this.signal=A,this.reason=null,this.removeAbortListener=null,Ne.isStream(n)&&n.on("error",g=>{this.onError(g)}),this.signal&&(this.signal.aborted?this.reason=this.signal.reason??new HQ:this.removeAbortListener=Ne.addAbortListener(this.signal,()=>{this.reason=this.signal.reason??new HQ,this.res?Ne.destroy(this.res.on("error",Ne.nop),this.reason):this.abort&&this.abort(this.reason),this.removeAbortListener&&(this.res?.off("close",this.removeAbortListener),this.removeAbortListener(),this.removeAbortListener=null)}))}onConnect(e,r){if(this.reason){e(this.reason);return}cR(this.callback),this.abort=e,this.context=r}onHeaders(e,r,A,s){let{callback:o,opaque:n,abort:i,context:a,responseHeaders:c,highWaterMark:l}=this,g=c==="raw"?Ne.parseRawHeaders(r):Ne.parseHeaders(r);if(e<200){this.onInfo&&this.onInfo({statusCode:e,headers:g});return}let E=c==="raw"?Ne.parseHeaders(r):g,d=E["content-type"],B=E["content-length"],p=new gR({resume:A,abort:i,contentType:d,contentLength:this.method!=="HEAD"&&B?Number(B):null,highWaterMark:l});this.removeAbortListener&&p.on("close",this.removeAbortListener),this.callback=null,this.res=p,o!==null&&(this.throwOnError&&e>=400?this.runInAsyncScope(uR,null,{callback:o,body:p,contentType:d,statusCode:e,statusMessage:s,headers:g}):this.runInAsyncScope(o,null,null,{statusCode:e,headers:g,trailers:this.trailers,opaque:n,body:p,context:a}))}onData(e){return this.res.push(e)}onComplete(e){Ne.parseHeaders(e,this.trailers),this.res.push(null)}onError(e){let{res:r,callback:A,body:s,opaque:o}=this;A&&(this.callback=null,queueMicrotask(()=>{this.runInAsyncScope(A,null,e,{opaque:o})})),r&&(this.res=null,queueMicrotask(()=>{Ne.destroy(r,e)})),s&&(this.body=null,Ne.destroy(s,e)),this.removeAbortListener&&(r?.off("close",this.removeAbortListener),this.removeAbortListener(),this.removeAbortListener=null)}};function PQ(t,e){if(e===void 0)return new Promise((r,A)=>{PQ.call(this,t,(s,o)=>s?A(s):r(o))});try{this.dispatch(t,new Oo(t,e))}catch(r){if(typeof e!="function")throw r;let A=t?.opaque;queueMicrotask(()=>e(r,{opaque:A}))}}gc.exports=PQ;gc.exports.RequestHandler=Oo});var ls=m((mL,zQ)=>{var{addAbortListener:ER}=J(),{RequestAbortedError:hR}=q(),aA=Symbol("kListener"),ht=Symbol("kSignal");function qQ(t){t.abort?t.abort(t[ht]?.reason):t.reason=t[ht]?.reason??new hR,WQ(t)}function QR(t,e){if(t.reason=null,t[ht]=null,t[aA]=null,!!e){if(e.aborted){qQ(t);return}t[ht]=e,t[aA]=()=>{qQ(t)},ER(t[ht],t[aA])}}function WQ(t){t[ht]&&("removeEventListener"in t[ht]?t[ht].removeEventListener("abort",t[aA]):t[ht].removeListener("abort",t[aA]),t[ht]=null,t[aA]=null)}zQ.exports={addSignal:QR,removeSignal:WQ}});var XQ=m((wL,jQ)=>{"use strict";var BR=require("node:assert"),{finished:dR,PassThrough:IR}=require("node:stream"),{InvalidArgumentError:cA,InvalidReturnValueError:CR}=q(),tt=J(),{getResolveErrorBodyCallback:pR}=cc(),{AsyncResource:fR}=require("node:async_hooks"),{addSignal:mR,removeSignal:ZQ}=ls(),uc=class extends fR{constructor(e,r,A){if(!e||typeof e!="object")throw new cA("invalid opts");let{signal:s,method:o,opaque:n,body:i,onInfo:a,responseHeaders:c,throwOnError:l}=e;try{if(typeof A!="function")throw new cA("invalid callback");if(typeof r!="function")throw new cA("invalid factory");if(s&&typeof s.on!="function"&&typeof s.addEventListener!="function")throw new cA("signal must be an EventEmitter or EventTarget");if(o==="CONNECT")throw new cA("invalid method");if(a&&typeof a!="function")throw new cA("invalid onInfo callback");super("UNDICI_STREAM")}catch(g){throw tt.isStream(i)&&tt.destroy(i.on("error",tt.nop),g),g}this.responseHeaders=c||null,this.opaque=n||null,this.factory=r,this.callback=A,this.res=null,this.abort=null,this.context=null,this.trailers=null,this.body=i,this.onInfo=a||null,this.throwOnError=l||!1,tt.isStream(i)&&i.on("error",g=>{this.onError(g)}),mR(this,s)}onConnect(e,r){if(this.reason){e(this.reason);return}BR(this.callback),this.abort=e,this.context=r}onHeaders(e,r,A,s){let{factory:o,opaque:n,context:i,callback:a,responseHeaders:c}=this,l=c==="raw"?tt.parseRawHeaders(r):tt.parseHeaders(r);if(e<200){this.onInfo&&this.onInfo({statusCode:e,headers:l});return}this.factory=null;let g;if(this.throwOnError&&e>=400){let B=(c==="raw"?tt.parseHeaders(r):l)["content-type"];g=new IR,this.callback=null,this.runInAsyncScope(pR,null,{callback:a,body:g,contentType:B,statusCode:e,statusMessage:s,headers:l})}else{if(o===null)return;if(g=this.runInAsyncScope(o,null,{statusCode:e,headers:l,opaque:n,context:i}),!g||typeof g.write!="function"||typeof g.end!="function"||typeof g.on!="function")throw new CR("expected Writable");dR(g,{readable:!1},d=>{let{callback:B,res:p,opaque:w,trailers:I,abort:y}=this;this.res=null,(d||!p.readable)&&tt.destroy(p,d),this.callback=null,this.runInAsyncScope(B,null,d||null,{opaque:w,trailers:I}),d&&y()})}return g.on("drain",A),this.res=g,(g.writableNeedDrain!==void 0?g.writableNeedDrain:g._writableState?.needDrain)!==!0}onData(e){let{res:r}=this;return r?r.write(e):!0}onComplete(e){let{res:r}=this;ZQ(this),r&&(this.trailers=tt.parseHeaders(e),r.end())}onError(e){let{res:r,callback:A,opaque:s,body:o}=this;ZQ(this),this.factory=null,r?(this.res=null,tt.destroy(r,e)):A&&(this.callback=null,queueMicrotask(()=>{this.runInAsyncScope(A,null,e,{opaque:s})})),o&&(this.body=null,tt.destroy(o,e))}};function KQ(t,e,r){if(r===void 0)return new Promise((A,s)=>{KQ.call(this,t,e,(o,n)=>o?s(o):A(n))});try{this.dispatch(t,new uc(t,e,r))}catch(A){if(typeof r!="function")throw A;let s=t?.opaque;queueMicrotask(()=>r(A,{opaque:s}))}}jQ.exports=KQ});var rB=m((yL,tB)=>{"use strict";var{Readable:eB,Duplex:wR,PassThrough:yR}=require("node:stream"),{InvalidArgumentError:Es,InvalidReturnValueError:bR,RequestAbortedError:lc}=q(),We=J(),{AsyncResource:kR}=require("node:async_hooks"),{addSignal:DR,removeSignal:RR}=ls(),$Q=require("node:assert"),gA=Symbol("resume"),Ec=class extends eB{constructor(){super({autoDestroy:!0}),this[gA]=null}_read(){let{[gA]:e}=this;e&&(this[gA]=null,e())}_destroy(e,r){this._read(),r(e)}},hc=class extends eB{constructor(e){super({autoDestroy:!0}),this[gA]=e}_read(){this[gA]()}_destroy(e,r){!e&&!this._readableState.endEmitted&&(e=new lc),r(e)}},Qc=class extends kR{constructor(e,r){if(!e||typeof e!="object")throw new Es("invalid opts");if(typeof r!="function")throw new Es("invalid handler");let{signal:A,method:s,opaque:o,onInfo:n,responseHeaders:i}=e;if(A&&typeof A.on!="function"&&typeof A.addEventListener!="function")throw new Es("signal must be an EventEmitter or EventTarget");if(s==="CONNECT")throw new Es("invalid method");if(n&&typeof n!="function")throw new Es("invalid onInfo callback");super("UNDICI_PIPELINE"),this.opaque=o||null,this.responseHeaders=i||null,this.handler=r,this.abort=null,this.context=null,this.onInfo=n||null,this.req=new Ec().on("error",We.nop),this.ret=new wR({readableObjectMode:e.objectMode,autoDestroy:!0,read:()=>{let{body:a}=this;a?.resume&&a.resume()},write:(a,c,l)=>{let{req:g}=this;g.push(a,c)||g._readableState.destroyed?l():g[gA]=l},destroy:(a,c)=>{let{body:l,req:g,res:E,ret:d,abort:B}=this;!a&&!d._readableState.endEmitted&&(a=new lc),B&&a&&B(),We.destroy(l,a),We.destroy(g,a),We.destroy(E,a),RR(this),c(a)}}).on("prefinish",()=>{let{req:a}=this;a.push(null)}),this.res=null,DR(this,A)}onConnect(e,r){let{ret:A,res:s}=this;if(this.reason){e(this.reason);return}$Q(!s,"pipeline cannot be retried"),$Q(!A.destroyed),this.abort=e,this.context=r}onHeaders(e,r,A){let{opaque:s,handler:o,context:n}=this;if(e<200){if(this.onInfo){let a=this.responseHeaders==="raw"?We.parseRawHeaders(r):We.parseHeaders(r);this.onInfo({statusCode:e,headers:a})}return}this.res=new hc(A);let i;try{this.handler=null;let a=this.responseHeaders==="raw"?We.parseRawHeaders(r):We.parseHeaders(r);i=this.runInAsyncScope(o,null,{statusCode:e,headers:a,opaque:s,body:this.res,context:n})}catch(a){throw this.res.on("error",We.nop),a}if(!i||typeof i.on!="function")throw new bR("expected Readable");i.on("data",a=>{let{ret:c,body:l}=this;!c.push(a)&&l.pause&&l.pause()}).on("error",a=>{let{ret:c}=this;We.destroy(c,a)}).on("end",()=>{let{ret:a}=this;a.push(null)}).on("close",()=>{let{ret:a}=this;a._readableState.ended||We.destroy(a,new lc)}),this.body=i}onData(e){let{res:r}=this;return r.push(e)}onComplete(e){let{res:r}=this;r.push(null)}onError(e){let{ret:r}=this;this.handler=null,We.destroy(r,e)}};function TR(t,e){try{let r=new Qc(t,e);return this.dispatch({...t,body:r.req},r),r.ret}catch(r){return new yR().destroy(r)}}tB.exports=TR});var aB=m((bL,iB)=>{"use strict";var{InvalidArgumentError:Bc,SocketError:FR}=q(),{AsyncResource:SR}=require("node:async_hooks"),AB=J(),{addSignal:UR,removeSignal:sB}=ls(),oB=require("node:assert"),dc=class extends SR{constructor(e,r){if(!e||typeof e!="object")throw new Bc("invalid opts");if(typeof r!="function")throw new Bc("invalid callback");let{signal:A,opaque:s,responseHeaders:o}=e;if(A&&typeof A.on!="function"&&typeof A.addEventListener!="function")throw new Bc("signal must be an EventEmitter or EventTarget");super("UNDICI_UPGRADE"),this.responseHeaders=o||null,this.opaque=s||null,this.callback=r,this.abort=null,this.context=null,UR(this,A)}onConnect(e,r){if(this.reason){e(this.reason);return}oB(this.callback),this.abort=e,this.context=null}onHeaders(){throw new FR("bad upgrade",null)}onUpgrade(e,r,A){oB(e===101);let{callback:s,opaque:o,context:n}=this;sB(this),this.callback=null;let i=this.responseHeaders==="raw"?AB.parseRawHeaders(r):AB.parseHeaders(r);this.runInAsyncScope(s,null,null,{headers:i,socket:A,opaque:o,context:n})}onError(e){let{callback:r,opaque:A}=this;sB(this),r&&(this.callback=null,queueMicrotask(()=>{this.runInAsyncScope(r,null,e,{opaque:A})}))}};function nB(t,e){if(e===void 0)return new Promise((r,A)=>{nB.call(this,t,(s,o)=>s?A(s):r(o))});try{let r=new dc(t,e);this.dispatch({...t,method:t.method||"GET",upgrade:t.protocol||"Websocket"},r)}catch(r){if(typeof e!="function")throw r;let A=t?.opaque;queueMicrotask(()=>e(r,{opaque:A}))}}iB.exports=nB});var EB=m((kL,lB)=>{"use strict";var NR=require("node:assert"),{AsyncResource:GR}=require("node:async_hooks"),{InvalidArgumentError:Ic,SocketError:MR}=q(),cB=J(),{addSignal:LR,removeSignal:gB}=ls(),Cc=class extends GR{constructor(e,r){if(!e||typeof e!="object")throw new Ic("invalid opts");if(typeof r!="function")throw new Ic("invalid callback");let{signal:A,opaque:s,responseHeaders:o}=e;if(A&&typeof A.on!="function"&&typeof A.addEventListener!="function")throw new Ic("signal must be an EventEmitter or EventTarget");super("UNDICI_CONNECT"),this.opaque=s||null,this.responseHeaders=o||null,this.callback=r,this.abort=null,LR(this,A)}onConnect(e,r){if(this.reason){e(this.reason);return}NR(this.callback),this.abort=e,this.context=r}onHeaders(){throw new MR("bad connect",null)}onUpgrade(e,r,A){let{callback:s,opaque:o,context:n}=this;gB(this),this.callback=null;let i=r;i!=null&&(i=this.responseHeaders==="raw"?cB.parseRawHeaders(r):cB.parseHeaders(r)),this.runInAsyncScope(s,null,null,{statusCode:e,headers:i,socket:A,opaque:o,context:n})}onError(e){let{callback:r,opaque:A}=this;gB(this),r&&(this.callback=null,queueMicrotask(()=>{this.runInAsyncScope(r,null,e,{opaque:A})}))}};function uB(t,e){if(e===void 0)return new Promise((r,A)=>{uB.call(this,t,(s,o)=>s?A(s):r(o))});try{let r=new Cc(t,e);this.dispatch({...t,method:"CONNECT"},r)}catch(r){if(typeof e!="function")throw r;let A=t?.opaque;queueMicrotask(()=>e(r,{opaque:A}))}}lB.exports=uB});var hB=m((DL,uA)=>{"use strict";uA.exports.request=VQ();uA.exports.stream=XQ();uA.exports.pipeline=rB();uA.exports.upgrade=aB();uA.exports.connect=EB()});var fc=m((RL,BB)=>{"use strict";var{UndiciError:vR}=q(),QB=Symbol.for("undici.error.UND_MOCK_ERR_MOCK_NOT_MATCHED"),pc=class t extends vR{constructor(e){super(e),Error.captureStackTrace(this,t),this.name="MockNotMatchedError",this.message=e||"The request does not match any registered mock dispatches",this.code="UND_MOCK_ERR_MOCK_NOT_MATCHED"}static[Symbol.hasInstance](e){return e&&e[QB]===!0}[QB]=!0};BB.exports={MockNotMatchedError:pc}});var lA=m((TL,dB)=>{"use strict";dB.exports={kAgent:Symbol("agent"),kOptions:Symbol("options"),kFactory:Symbol("factory"),kDispatches:Symbol("dispatches"),kDispatchKey:Symbol("dispatch key"),kDefaultHeaders:Symbol("default headers"),kDefaultTrailers:Symbol("default trailers"),kContentLength:Symbol("content length"),kMockAgent:Symbol("mock agent"),kMockAgentSet:Symbol("mock agent set"),kMockAgentGet:Symbol("mock agent get"),kMockDispatch:Symbol("mock dispatch"),kClose:Symbol("close"),kOriginalClose:Symbol("original agent close"),kOrigin:Symbol("origin"),kIsMockActive:Symbol("is mock active"),kNetConnect:Symbol("net connect"),kGetNetConnect:Symbol("get net connect"),kConnected:Symbol("connected")}});var hs=m((FL,RB)=>{"use strict";var{MockNotMatchedError:Ir}=fc(),{kDispatches:Ho,kMockAgent:_R,kOriginalDispatch:xR,kOrigin:YR,kGetNetConnect:JR}=lA(),{buildURL:OR}=J(),{STATUS_CODES:HR}=require("node:http"),{types:{isPromise:PR}}=require("node:util");function Ft(t,e){return typeof t=="string"?t===e:t instanceof RegExp?t.test(e):typeof t=="function"?t(e)===!0:!1}function CB(t){return Object.fromEntries(Object.entries(t).map(([e,r])=>[e.toLocaleLowerCase(),r]))}function pB(t,e){if(Array.isArray(t)){for(let r=0;r"u")return!0;if(typeof e!="object"||typeof t.headers!="object")return!1;for(let[r,A]of Object.entries(t.headers)){let s=pB(e,r);if(!Ft(A,s))return!1}return!0}function IB(t){if(typeof t!="string")return t;let e=t.split("?");if(e.length!==2)return t;let r=new URLSearchParams(e.pop());return r.sort(),[...e,r.toString()].join("?")}function VR(t,{path:e,method:r,body:A,headers:s}){let o=Ft(t.path,e),n=Ft(t.method,r),i=typeof t.body<"u"?Ft(t.body,A):!0,a=fB(t,s);return o&&n&&i&&a}function mB(t){return Buffer.isBuffer(t)||t instanceof Uint8Array||t instanceof ArrayBuffer?t:typeof t=="object"?JSON.stringify(t):t.toString()}function wB(t,e){let r=e.query?OR(e.path,e.query):e.path,A=typeof r=="string"?IB(r):r,s=t.filter(({consumed:o})=>!o).filter(({path:o})=>Ft(IB(o),A));if(s.length===0)throw new Ir(`Mock dispatch not matched for path '${A}'`);if(s=s.filter(({method:o})=>Ft(o,e.method)),s.length===0)throw new Ir(`Mock dispatch not matched for method '${e.method}' on path '${A}'`);if(s=s.filter(({body:o})=>typeof o<"u"?Ft(o,e.body):!0),s.length===0)throw new Ir(`Mock dispatch not matched for body '${e.body}' on path '${A}'`);if(s=s.filter(o=>fB(o,e.headers)),s.length===0){let o=typeof e.headers=="object"?JSON.stringify(e.headers):e.headers;throw new Ir(`Mock dispatch not matched for headers '${o}' on path '${A}'`)}return s[0]}function qR(t,e,r){let A={timesInvoked:0,times:1,persist:!1,consumed:!1},s=typeof r=="function"?{callback:r}:{...r},o={...A,...e,pending:!0,data:{error:null,...s}};return t.push(o),o}function mc(t,e){let r=t.findIndex(A=>A.consumed?VR(A,e):!1);r!==-1&&t.splice(r,1)}function yB(t){let{path:e,method:r,body:A,headers:s,query:o}=t;return{path:e,method:r,body:A,headers:s,query:o}}function wc(t){let e=Object.keys(t),r=[];for(let A=0;A=E,A.pending=g0?setTimeout(()=>{d(this[Ho])},c):d(this[Ho]);function d(p,w=o){let I=Array.isArray(t.headers)?yc(t.headers):t.headers,y=typeof w=="function"?w({...t,headers:I}):w;if(PR(y)){y.then(j=>d(p,j));return}let T=mB(y),S=wc(n),O=wc(i);e.onConnect?.(j=>e.onError(j),null),e.onHeaders?.(s,S,B,bB(s)),e.onData?.(Buffer.from(T)),e.onComplete?.(O),mc(p,r)}function B(){}return!0}function zR(){let t=this[_R],e=this[YR],r=this[xR];return function(s,o){if(t.isMockActive)try{kB.call(this,s,o)}catch(n){if(n instanceof Ir){let i=t[JR]();if(i===!1)throw new Ir(`${n.message}: subsequent request to origin ${e} was not allowed (net.connect disabled)`);if(DB(i,e))r.call(this,s,o);else throw new Ir(`${n.message}: subsequent request to origin ${e} was not allowed (net.connect is not enabled for this origin)`)}else throw n}else r.call(this,s,o)}}function DB(t,e){let r=new URL(e);return t===!0?!0:!!(Array.isArray(t)&&t.some(A=>Ft(A,r.host)))}function ZR(t){if(t){let{agent:e,...r}=t;return r}}RB.exports={getResponseData:mB,getMockDispatch:wB,addMockDispatch:qR,deleteMockDispatch:mc,buildKey:yB,generateKeyValues:wc,matchValue:Ft,getResponse:WR,getStatusText:bB,mockDispatch:kB,buildMockDispatch:zR,checkNetConnect:DB,buildMockOptions:ZR,getHeaderByName:pB,buildHeadersFromArray:yc}});var Sc=m((SL,Fc)=>{"use strict";var{getResponseData:KR,buildKey:jR,addMockDispatch:bc}=hs(),{kDispatches:Po,kDispatchKey:Vo,kDefaultHeaders:kc,kDefaultTrailers:Dc,kContentLength:Rc,kMockDispatch:qo}=lA(),{InvalidArgumentError:Qt}=q(),{buildURL:XR}=J(),EA=class{constructor(e){this[qo]=e}delay(e){if(typeof e!="number"||!Number.isInteger(e)||e<=0)throw new Qt("waitInMs must be a valid integer > 0");return this[qo].delay=e,this}persist(){return this[qo].persist=!0,this}times(e){if(typeof e!="number"||!Number.isInteger(e)||e<=0)throw new Qt("repeatTimes must be a valid integer > 0");return this[qo].times=e,this}},Tc=class{constructor(e,r){if(typeof e!="object")throw new Qt("opts must be an object");if(typeof e.path>"u")throw new Qt("opts.path must be defined");if(typeof e.method>"u"&&(e.method="GET"),typeof e.path=="string")if(e.query)e.path=XR(e.path,e.query);else{let A=new URL(e.path,"data://");e.path=A.pathname+A.search}typeof e.method=="string"&&(e.method=e.method.toUpperCase()),this[Vo]=jR(e),this[Po]=r,this[kc]={},this[Dc]={},this[Rc]=!1}createMockScopeDispatchData({statusCode:e,data:r,responseOptions:A}){let s=KR(r),o=this[Rc]?{"content-length":s.length}:{},n={...this[kc],...o,...A.headers},i={...this[Dc],...A.trailers};return{statusCode:e,data:r,headers:n,trailers:i}}validateReplyParameters(e){if(typeof e.statusCode>"u")throw new Qt("statusCode must be defined");if(typeof e.responseOptions!="object"||e.responseOptions===null)throw new Qt("responseOptions must be an object")}reply(e){if(typeof e=="function"){let o=i=>{let a=e(i);if(typeof a!="object"||a===null)throw new Qt("reply options callback must return an object");let c={data:"",responseOptions:{},...a};return this.validateReplyParameters(c),{...this.createMockScopeDispatchData(c)}},n=bc(this[Po],this[Vo],o);return new EA(n)}let r={statusCode:e,data:arguments[1]===void 0?"":arguments[1],responseOptions:arguments[2]===void 0?{}:arguments[2]};this.validateReplyParameters(r);let A=this.createMockScopeDispatchData(r),s=bc(this[Po],this[Vo],A);return new EA(s)}replyWithError(e){if(typeof e>"u")throw new Qt("error must be defined");let r=bc(this[Po],this[Vo],{error:e});return new EA(r)}defaultReplyHeaders(e){if(typeof e>"u")throw new Qt("headers must be defined");return this[kc]=e,this}defaultReplyTrailers(e){if(typeof e>"u")throw new Qt("trailers must be defined");return this[Dc]=e,this}replyContentLength(){return this[Rc]=!0,this}};Fc.exports.MockInterceptor=Tc;Fc.exports.MockScope=EA});var Gc=m((UL,MB)=>{"use strict";var{promisify:$R}=require("node:util"),e0=rA(),{buildMockDispatch:t0}=hs(),{kDispatches:TB,kMockAgent:FB,kClose:SB,kOriginalClose:UB,kOrigin:NB,kOriginalDispatch:r0,kConnected:Uc}=lA(),{MockInterceptor:A0}=Sc(),GB=se(),{InvalidArgumentError:s0}=q(),Nc=class extends e0{constructor(e,r){if(super(e,r),!r||!r.agent||typeof r.agent.dispatch!="function")throw new s0("Argument opts.agent must implement Agent");this[FB]=r.agent,this[NB]=e,this[TB]=[],this[Uc]=1,this[r0]=this.dispatch,this[UB]=this.close.bind(this),this.dispatch=t0.call(this),this.close=this[SB]}get[GB.kConnected](){return this[Uc]}intercept(e){return new A0(e,this[TB])}async[SB](){await $R(this[UB])(),this[Uc]=0,this[FB][GB.kClients].delete(this[NB])}};MB.exports=Nc});var vc=m((NL,OB)=>{"use strict";var{promisify:o0}=require("node:util"),n0=AA(),{buildMockDispatch:i0}=hs(),{kDispatches:LB,kMockAgent:vB,kClose:_B,kOriginalClose:xB,kOrigin:YB,kOriginalDispatch:a0,kConnected:Mc}=lA(),{MockInterceptor:c0}=Sc(),JB=se(),{InvalidArgumentError:g0}=q(),Lc=class extends n0{constructor(e,r){if(super(e,r),!r||!r.agent||typeof r.agent.dispatch!="function")throw new g0("Argument opts.agent must implement Agent");this[vB]=r.agent,this[YB]=e,this[LB]=[],this[Mc]=1,this[a0]=this.dispatch,this[xB]=this.close.bind(this),this.dispatch=i0.call(this),this.close=this[_B]}get[JB.kConnected](){return this[Mc]}intercept(e){return new c0(e,this[LB])}async[_B](){await o0(this[xB])(),this[Mc]=0,this[vB][JB.kClients].delete(this[YB])}};OB.exports=Lc});var PB=m((ML,HB)=>{"use strict";var u0={pronoun:"it",is:"is",was:"was",this:"this"},l0={pronoun:"they",is:"are",was:"were",this:"these"};HB.exports=class{constructor(e,r){this.singular=e,this.plural=r}pluralize(e){let r=e===1,A=r?u0:l0,s=r?this.singular:this.plural;return{...A,count:e,noun:s}}}});var qB=m((vL,VB)=>{"use strict";var{Transform:E0}=require("node:stream"),{Console:h0}=require("node:console"),Q0=process.versions.icu?"\u2705":"Y ",B0=process.versions.icu?"\u274C":"N ";VB.exports=class{constructor({disableColors:e}={}){this.transform=new E0({transform(r,A,s){s(null,r)}}),this.logger=new h0({stdout:this.transform,inspectOptions:{colors:!e&&!process.env.CI}})}format(e){let r=e.map(({method:A,path:s,data:{statusCode:o},persist:n,times:i,timesInvoked:a,origin:c})=>({Method:A,Origin:c,Path:s,"Status code":o,Persistent:n?Q0:B0,Invocations:a,Remaining:n?1/0:i-a}));return this.logger.table(r),this.transform.read().toString()}}});var KB=m((_L,ZB)=>{"use strict";var{kClients:Cr}=se(),d0=sA(),{kAgent:_c,kMockAgentSet:Wo,kMockAgentGet:WB,kDispatches:xc,kIsMockActive:zo,kNetConnect:pr,kGetNetConnect:I0,kOptions:Zo,kFactory:Ko}=lA(),C0=Gc(),p0=vc(),{matchValue:f0,buildMockOptions:m0}=hs(),{InvalidArgumentError:zB,UndiciError:w0}=q(),y0=vA(),b0=PB(),k0=qB(),Yc=class extends y0{constructor(e){if(super(e),this[pr]=!0,this[zo]=!0,e?.agent&&typeof e.agent.dispatch!="function")throw new zB("Argument opts.agent must implement Agent");let r=e?.agent?e.agent:new d0(e);this[_c]=r,this[Cr]=r[Cr],this[Zo]=m0(e)}get(e){let r=this[WB](e);return r||(r=this[Ko](e),this[Wo](e,r)),r}dispatch(e,r){return this.get(e.origin),this[_c].dispatch(e,r)}async close(){await this[_c].close(),this[Cr].clear()}deactivate(){this[zo]=!1}activate(){this[zo]=!0}enableNetConnect(e){if(typeof e=="string"||typeof e=="function"||e instanceof RegExp)Array.isArray(this[pr])?this[pr].push(e):this[pr]=[e];else if(typeof e>"u")this[pr]=!0;else throw new zB("Unsupported matcher. Must be one of String|Function|RegExp.")}disableNetConnect(){this[pr]=!1}get isMockActive(){return this[zo]}[Wo](e,r){this[Cr].set(e,r)}[Ko](e){let r=Object.assign({agent:this},this[Zo]);return this[Zo]&&this[Zo].connections===1?new C0(e,r):new p0(e,r)}[WB](e){let r=this[Cr].get(e);if(r)return r;if(typeof e!="string"){let A=this[Ko]("http://localhost:9999");return this[Wo](e,A),A}for(let[A,s]of Array.from(this[Cr]))if(s&&typeof A!="string"&&f0(A,e)){let o=this[Ko](e);return this[Wo](e,o),o[xc]=s[xc],o}}[I0](){return this[pr]}pendingInterceptors(){let e=this[Cr];return Array.from(e.entries()).flatMap(([r,A])=>A[xc].map(s=>({...s,origin:r}))).filter(({pending:r})=>r)}assertNoPendingInterceptors({pendingInterceptorsFormatter:e=new k0}={}){let r=this.pendingInterceptors();if(r.length===0)return;let A=new b0("interceptor","interceptors").pluralize(r.length);throw new w0(` +`,"latin1"),r!==null&&s!==r){if(A[wa])throw new gr;process.emitWarning(new gr)}e[re].timeout&&e[re].timeoutType===tA&&e[re].timeout.refresh&&e[re].timeout.refresh(),A[kt]()}}destroy(e){let{socket:r,client:A,abort:s}=this;r[Ot]=!1,e&&(G(A[ge]<=1,"pipeline should only contain this request"),s(e))}};hh.exports=_b});var wh=m((BL,mh)=>{"use strict";var Ve=require("node:assert"),{pipeline:Vb}=require("node:stream"),H=O(),{RequestContentLengthMismatchError:Ra,RequestAbortedError:dh,SocketError:$A,InformationalError:Ta}=q(),{kUrl:Ro,kReset:Fo,kClient:rA,kRunning:So,kPending:qb,kQueue:Jt,kPendingIdx:Fa,kRunningIdx:Ke,kError:Xe,kSocket:he,kStrictContentLength:Wb,kOnError:Sa,kMaxConcurrentStreams:fh,kHTTP2Session:je,kResume:Ht,kSize:zb,kHTTPContext:Zb}=se(),Rt=Symbol("open streams"),Bh,Ih=!1,To;try{To=require("node:http2")}catch{To={constants:{}}}var{constants:{HTTP2_HEADER_AUTHORITY:Kb,HTTP2_HEADER_METHOD:jb,HTTP2_HEADER_PATH:Xb,HTTP2_HEADER_SCHEME:$b,HTTP2_HEADER_CONTENT_LENGTH:eD,HTTP2_HEADER_EXPECT:tD,HTTP2_HEADER_STATUS:rD}}=To;function AD(t){let e=[];for(let[r,A]of Object.entries(t))if(Array.isArray(A))for(let s of A)e.push(Buffer.from(r),Buffer.from(s));else e.push(Buffer.from(r),Buffer.from(A));return e}async function sD(t,e){t[he]=e,Ih||(Ih=!0,process.emitWarning("H2 support is experimental, expect them to change at any time.",{code:"UNDICI-H2"}));let r=To.connect(t[Ro],{createConnection:()=>e,peerMaxConcurrentStreams:t[fh]});r[Rt]=0,r[rA]=t,r[he]=e,H.addListener(r,"error",nD),H.addListener(r,"frameError",iD),H.addListener(r,"end",aD),H.addListener(r,"goaway",cD),H.addListener(r,"close",function(){let{[rA]:s}=this,{[he]:o}=s,n=this[he][Xe]||this[Xe]||new $A("closed",H.getSocketInfo(o));if(s[je]=null,s.destroyed){Ve(s[qb]===0);let i=s[Jt].splice(s[Ke]);for(let a=0;a{A=!0}),{version:"h2",defaultPipelining:1/0,write(...s){return uD(t,...s)},resume(){oD(t)},destroy(s,o){A?queueMicrotask(o):e.destroy(s).on("close",o)},get destroyed(){return e.destroyed},busy(){return!1}}}function oD(t){let e=t[he];e?.destroyed===!1&&(t[zb]===0&&t[fh]===0?(e.unref(),t[je].unref()):(e.ref(),t[je].ref()))}function nD(t){Ve(t.code!=="ERR_TLS_CERT_ALTNAME_INVALID"),this[he][Xe]=t,this[rA][Sa](t)}function iD(t,e,r){if(r===0){let A=new Ta(`HTTP/2: "frameError" received - type ${t}, code ${e}`);this[he][Xe]=A,this[rA][Sa](A)}}function aD(){let t=new $A("other side closed",H.getSocketInfo(this[he]));this.destroy(t),H.destroy(this[he],t)}function cD(t){let e=this[Xe]||new $A(`HTTP/2: "GOAWAY" frame received with code ${t}`,H.getSocketInfo(this)),r=this[rA];if(r[he]=null,r[Zb]=null,this[je]!=null&&(this[je].destroy(e),this[je]=null),H.destroy(this[he],e),r[Ke]{e.aborted||e.completed||(S=S||new dh,H.errorRequest(t,e,S),E!=null&&H.destroy(E,S),H.destroy(u,S),t[Jt][t[Ke]++]=null,t[Ht]())};try{e.onConnect(p)}catch(S){H.errorRequest(t,e,S)}if(e.aborted)return!1;if(A==="CONNECT")return r.ref(),E=r.request(g,{endStream:!1,signal:a}),E.id&&!E.pending?(e.onUpgrade(null,null,E),++r[Rt],t[Jt][t[Ke]++]=null):E.once("ready",()=>{e.onUpgrade(null,null,E),++r[Rt],t[Jt][t[Ke]++]=null}),E.once("close",()=>{r[Rt]-=1,r[Rt]===0&&r.unref()}),!0;g[Xb]=s,g[$b]="https";let y=A==="PUT"||A==="POST"||A==="PATCH";u&&typeof u.read=="function"&&u.read(0);let B=H.bodyLength(u);if(H.isFormDataLike(u)){Bh??=Xr().extractBody;let[S,J]=Bh(u);g["content-type"]=J,u=S.stream,B=S.length}if(B==null&&(B=e.contentLength),(B===0||!y)&&(B=null),gD(A)&&B>0&&e.contentLength!=null&&e.contentLength!==B){if(t[Wb])return H.errorRequest(t,e,new Ra),!1;process.emitWarning(new Ra)}B!=null&&(Ve(u,"no body must not have content length"),g[eD]=`${B}`),r.ref();let w=A==="GET"||A==="HEAD"||u===null;return i?(g[tD]="100-continue",E=r.request(g,{endStream:w,signal:a}),E.once("continue",T)):(E=r.request(g,{endStream:w,signal:a}),T()),++r[Rt],E.once("response",S=>{let{[rD]:J,...j}=S;if(e.onResponseStarted(),e.aborted){let X=new dh;H.errorRequest(t,e,X),H.destroy(E,X);return}e.onHeaders(Number(J),AD(j),E.resume.bind(E),"")===!1&&E.pause(),E.on("data",X=>{e.onData(X)===!1&&E.pause()})}),E.once("end",()=>{(E.state?.state==null||E.state.state<6)&&e.onComplete([]),r[Rt]===0&&r.unref(),p(new Ta("HTTP/2: stream half-closed (remote)")),t[Jt][t[Ke]++]=null,t[Fa]=t[Ke],t[Ht]()}),E.once("close",()=>{r[Rt]-=1,r[Rt]===0&&r.unref()}),E.once("error",function(S){p(S)}),E.once("frameError",(S,J)=>{p(new Ta(`HTTP/2: "frameError" received - type ${S}, code ${J}`))}),!0;function T(){!u||B===0?Ch(p,E,null,t,e,t[he],B,y):H.isBuffer(u)?Ch(p,E,u,t,e,t[he],B,y):H.isBlobLike(u)?typeof u.stream=="function"?ph(p,E,u.stream(),t,e,t[he],B,y):ED(p,E,u,t,e,t[he],B,y):H.isStream(u)?lD(p,t[he],y,E,u,t,e,B):H.isIterable(u)?ph(p,E,u,t,e,t[he],B,y):Ve(!1)}}function Ch(t,e,r,A,s,o,n,i){try{r!=null&&H.isBuffer(r)&&(Ve(n===r.byteLength,"buffer body must have content length"),e.cork(),e.write(r),e.uncork(),e.end(),s.onBodySent(r)),i||(o[Fo]=!0),s.onRequestSent(),A[Ht]()}catch(a){t(a)}}function lD(t,e,r,A,s,o,n,i){Ve(i!==0||o[So]===0,"stream body cannot be pipelined");let a=Vb(s,A,u=>{u?(H.destroy(a,u),t(u)):(H.removeAllListeners(a),n.onRequestSent(),r||(e[Fo]=!0),o[Ht]())});H.addListener(a,"data",c);function c(u){n.onBodySent(u)}}async function ED(t,e,r,A,s,o,n,i){Ve(n===r.size,"blob body must have content length");try{if(n!=null&&n!==r.size)throw new Ra;let a=Buffer.from(await r.arrayBuffer());e.cork(),e.write(a),e.uncork(),e.end(),s.onBodySent(a),s.onRequestSent(),i||(o[Fo]=!0),A[Ht]()}catch(a){t(a)}}async function ph(t,e,r,A,s,o,n,i){Ve(n!==0||A[So]===0,"iterator body cannot be pipelined");let a=null;function c(){if(a){let g=a;a=null,g()}}let u=()=>new Promise((g,E)=>{Ve(a===null),o[Xe]?E(o[Xe]):a=g});e.on("close",c).on("drain",c);try{for await(let g of r){if(o[Xe])throw o[Xe];let E=e.write(g);s.onBodySent(g),E||await u()}e.end(),s.onRequestSent(),i||(o[Fo]=!0),A[Ht]()}catch(g){t(g)}finally{e.off("close",c).off("drain",c)}}mh.exports=sD});var No=m((IL,Dh)=>{"use strict";var lt=O(),{kBodyUsed:es}=se(),Na=require("node:assert"),{InvalidArgumentError:hD}=q(),QD=require("node:events"),dD=[300,301,302,303,307,308],yh=Symbol("body"),Uo=class{constructor(e){this[yh]=e,this[es]=!1}async*[Symbol.asyncIterator](){Na(!this[es],"disturbed"),this[es]=!0,yield*this[yh]}},Ua=class{constructor(e,r,A,s){if(r!=null&&(!Number.isInteger(r)||r<0))throw new hD("maxRedirections must be a positive number");lt.validateHandler(s,A.method,A.upgrade),this.dispatch=e,this.location=null,this.abort=null,this.opts={...A,maxRedirections:0},this.maxRedirections=r,this.handler=s,this.history=[],this.redirectionLimitReached=!1,lt.isStream(this.opts.body)?(lt.bodyLength(this.opts.body)===0&&this.opts.body.on("data",function(){Na(!1)}),typeof this.opts.body.readableDidRead!="boolean"&&(this.opts.body[es]=!1,QD.prototype.on.call(this.opts.body,"data",function(){this[es]=!0}))):this.opts.body&&typeof this.opts.body.pipeTo=="function"?this.opts.body=new Uo(this.opts.body):this.opts.body&&typeof this.opts.body!="string"&&!ArrayBuffer.isView(this.opts.body)&<.isIterable(this.opts.body)&&(this.opts.body=new Uo(this.opts.body))}onConnect(e){this.abort=e,this.handler.onConnect(e,{history:this.history})}onUpgrade(e,r,A){this.handler.onUpgrade(e,r,A)}onError(e){this.handler.onError(e)}onHeaders(e,r,A,s){if(this.location=this.history.length>=this.maxRedirections||lt.isDisturbed(this.opts.body)?null:BD(e,r),this.opts.throwOnMaxRedirect&&this.history.length>=this.maxRedirections){this.request&&this.request.abort(new Error("max redirects")),this.redirectionLimitReached=!0,this.abort(new Error("max redirects"));return}if(this.opts.origin&&this.history.push(new URL(this.opts.path,this.opts.origin)),!this.location)return this.handler.onHeaders(e,r,A,s);let{origin:o,pathname:n,search:i}=lt.parseURL(new URL(this.location,this.opts.origin&&new URL(this.opts.path,this.opts.origin))),a=i?`${n}${i}`:n;this.opts.headers=ID(this.opts.headers,e===303,this.opts.origin!==o),this.opts.path=a,this.opts.origin=o,this.opts.maxRedirections=0,this.opts.query=null,e===303&&this.opts.method!=="HEAD"&&(this.opts.method="GET",this.opts.body=null)}onData(e){if(!this.location)return this.handler.onData(e)}onComplete(e){this.location?(this.location=null,this.abort=null,this.dispatch(this.opts,this)):this.handler.onComplete(e)}onBodySent(e){this.handler.onBodySent&&this.handler.onBodySent(e)}};function BD(t,e){if(dD.indexOf(t)===-1)return null;for(let r=0;r{"use strict";var CD=No();function pD({maxRedirections:t}){return e=>function(A,s){let{maxRedirections:o=t}=A;if(!o)return e(A,s);let n=new CD(e,o,A,s);return A={...A,maxRedirections:0},e(A,n)}}kh.exports=pD});var oA=m((pL,vh)=>{"use strict";var Tt=require("node:assert"),Nh=require("node:net"),fD=require("node:http"),hr=O(),{channels:AA}=xr(),mD=vl(),wD=Hr(),{InvalidArgumentError:ae,InformationalError:yD,ClientDestroyedError:bD}=q(),DD=OA(),{kUrl:Et,kServerName:Pt,kClient:kD,kBusy:Ga,kConnect:RD,kResuming:Qr,kRunning:os,kPending:ns,kSize:ss,kQueue:$e,kConnected:TD,kConnecting:sA,kNeedDrain:qt,kKeepAliveDefaultTimeout:Rh,kHostHeader:FD,kPendingIdx:et,kRunningIdx:Ft,kError:SD,kPipelining:Mo,kKeepAliveTimeoutValue:UD,kMaxHeadersSize:ND,kKeepAliveMaxTimeout:GD,kKeepAliveTimeoutThreshold:MD,kHeadersTimeout:LD,kBodyTimeout:vD,kStrictContentLength:_D,kConnector:ts,kMaxRedirections:xD,kMaxRequests:Ma,kCounter:YD,kClose:OD,kDestroy:JD,kDispatch:HD,kInterceptors:Th,kLocalAddress:rs,kMaxResponseSize:PD,kOnError:VD,kHTTPContext:ce,kMaxConcurrentStreams:qD,kResume:As}=se(),WD=Qh(),zD=wh(),Fh=!1,Vt=Symbol("kClosedResolve"),Sh=()=>{};function Gh(t){return t[Mo]??t[ce]?.defaultPipelining??1}var La=class extends wD{constructor(e,{interceptors:r,maxHeaderSize:A,headersTimeout:s,socketTimeout:o,requestTimeout:n,connectTimeout:i,bodyTimeout:a,idleTimeout:c,keepAlive:u,keepAliveTimeout:g,maxKeepAliveTimeout:E,keepAliveMaxTimeout:I,keepAliveTimeoutThreshold:d,socketPath:p,pipelining:y,tls:B,strictContentLength:w,maxCachedSessions:T,maxRedirections:S,connect:J,maxRequestsPerClient:j,localAddress:X,maxResponseSize:Ye,autoSelectFamily:Oe,autoSelectFamilyAttemptTimeout:Ct,maxConcurrentStreams:ot,allowH2:Qe,webSocket:pt}={}){if(super({webSocket:pt}),u!==void 0)throw new ae("unsupported keepAlive, use pipelining=0 instead");if(o!==void 0)throw new ae("unsupported socketTimeout, use headersTimeout & bodyTimeout instead");if(n!==void 0)throw new ae("unsupported requestTimeout, use headersTimeout & bodyTimeout instead");if(c!==void 0)throw new ae("unsupported idleTimeout, use keepAliveTimeout instead");if(E!==void 0)throw new ae("unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead");if(A!=null&&!Number.isFinite(A))throw new ae("invalid maxHeaderSize");if(p!=null&&typeof p!="string")throw new ae("invalid socketPath");if(i!=null&&(!Number.isFinite(i)||i<0))throw new ae("invalid connectTimeout");if(g!=null&&(!Number.isFinite(g)||g<=0))throw new ae("invalid keepAliveTimeout");if(I!=null&&(!Number.isFinite(I)||I<=0))throw new ae("invalid keepAliveMaxTimeout");if(d!=null&&!Number.isFinite(d))throw new ae("invalid keepAliveTimeoutThreshold");if(s!=null&&(!Number.isInteger(s)||s<0))throw new ae("headersTimeout must be a positive integer or zero");if(a!=null&&(!Number.isInteger(a)||a<0))throw new ae("bodyTimeout must be a positive integer or zero");if(J!=null&&typeof J!="function"&&typeof J!="object")throw new ae("connect must be a function or an object");if(S!=null&&(!Number.isInteger(S)||S<0))throw new ae("maxRedirections must be a positive number");if(j!=null&&(!Number.isInteger(j)||j<0))throw new ae("maxRequestsPerClient must be a positive number");if(X!=null&&(typeof X!="string"||Nh.isIP(X)===0))throw new ae("localAddress must be valid string IP address");if(Ye!=null&&(!Number.isInteger(Ye)||Ye<-1))throw new ae("maxResponseSize must be a positive number");if(Ct!=null&&(!Number.isInteger(Ct)||Ct<-1))throw new ae("autoSelectFamilyAttemptTimeout must be a positive number");if(Qe!=null&&typeof Qe!="boolean")throw new ae("allowH2 must be a valid boolean value");if(ot!=null&&(typeof ot!="number"||ot<1))throw new ae("maxConcurrentStreams must be a positive integer, greater than 0");typeof J!="function"&&(J=DD({...B,maxCachedSessions:T,allowH2:Qe,socketPath:p,timeout:i,...Oe?{autoSelectFamily:Oe,autoSelectFamilyAttemptTimeout:Ct}:void 0,...J})),r?.Client&&Array.isArray(r.Client)?(this[Th]=r.Client,Fh||(Fh=!0,process.emitWarning("Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.",{code:"UNDICI-CLIENT-INTERCEPTOR-DEPRECATED"}))):this[Th]=[ZD({maxRedirections:S})],this[Et]=hr.parseOrigin(e),this[ts]=J,this[Mo]=y??1,this[ND]=A||fD.maxHeaderSize,this[Rh]=g??4e3,this[GD]=I??6e5,this[MD]=d??2e3,this[UD]=this[Rh],this[Pt]=null,this[rs]=X??null,this[Qr]=0,this[qt]=0,this[FD]=`host: ${this[Et].hostname}${this[Et].port?`:${this[Et].port}`:""}\r +`,this[vD]=a??3e5,this[LD]=s??3e5,this[_D]=w??!0,this[xD]=S,this[Ma]=j,this[Vt]=null,this[PD]=Ye>-1?Ye:-1,this[qD]=ot??100,this[ce]=null,this[$e]=[],this[Ft]=0,this[et]=0,this[As]=vt=>va(this,vt),this[VD]=vt=>Mh(this,vt)}get pipelining(){return this[Mo]}set pipelining(e){this[Mo]=e,this[As](!0)}get[ns](){return this[$e].length-this[et]}get[os](){return this[et]-this[Ft]}get[ss](){return this[$e].length-this[Ft]}get[TD](){return!!this[ce]&&!this[sA]&&!this[ce].destroyed}get[Ga](){return!!(this[ce]?.busy(null)||this[ss]>=(Gh(this)||1)||this[ns]>0)}[RD](e){Lh(this),this.once("connect",e)}[HD](e,r){let A=e.origin||this[Et].origin,s=new mD(A,e,r);return this[$e].push(s),this[Qr]||(hr.bodyLength(s.body)==null&&hr.isIterable(s.body)?(this[Qr]=1,queueMicrotask(()=>va(this))):this[As](!0)),this[Qr]&&this[qt]!==2&&this[Ga]&&(this[qt]=2),this[qt]<2}async[OD](){return new Promise(e=>{this[ss]?this[Vt]=e:e(null)})}async[JD](e){return new Promise(r=>{let A=this[$e].splice(this[et]);for(let o=0;o{this[Vt]&&(this[Vt](),this[Vt]=null),r(null)};this[ce]?(this[ce].destroy(e,s),this[ce]=null):queueMicrotask(s),this[As]()})}},ZD=Go();function Mh(t,e){if(t[os]===0&&e.code!=="UND_ERR_INFO"&&e.code!=="UND_ERR_SOCKET"){Tt(t[et]===t[Ft]);let r=t[$e].splice(t[Ft]);for(let A=0;A{t[ts]({host:e,hostname:r,protocol:A,port:s,servername:t[Pt],localAddress:t[rs]},(a,c)=>{a?i(a):n(c)})});if(t.destroyed){hr.destroy(o.on("error",Sh),new bD);return}Tt(o);try{t[ce]=o.alpnProtocol==="h2"?await zD(t,o):await WD(t,o)}catch(n){throw o.destroy().on("error",Sh),n}t[sA]=!1,o[YD]=0,o[Ma]=t[Ma],o[kD]=t,o[SD]=null,AA.connected.hasSubscribers&&AA.connected.publish({connectParams:{host:e,hostname:r,protocol:A,port:s,version:t[ce]?.version,servername:t[Pt],localAddress:t[rs]},connector:t[ts],socket:o}),t.emit("connect",t[Et],[t])}catch(o){if(t.destroyed)return;if(t[sA]=!1,AA.connectError.hasSubscribers&&AA.connectError.publish({connectParams:{host:e,hostname:r,protocol:A,port:s,version:t[ce]?.version,servername:t[Pt],localAddress:t[rs]},connector:t[ts],error:o}),o.code==="ERR_TLS_CERT_ALTNAME_INVALID")for(Tt(t[os]===0);t[ns]>0&&t[$e][t[et]].servername===t[Pt];){let n=t[$e][t[et]++];hr.errorRequest(t,n,o)}else Mh(t,o);t.emit("connectionError",t[Et],[t],o)}t[As]()}function Uh(t){t[qt]=0,t.emit("drain",t[Et],[t])}function va(t,e){t[Qr]!==2&&(t[Qr]=2,KD(t,e),t[Qr]=0,t[Ft]>256&&(t[$e].splice(0,t[Ft]),t[et]-=t[Ft],t[Ft]=0))}function KD(t,e){for(;;){if(t.destroyed){Tt(t[ns]===0);return}if(t[Vt]&&!t[ss]){t[Vt](),t[Vt]=null;return}if(t[ce]&&t[ce].resume(),t[Ga])t[qt]=2;else if(t[qt]===2){e?(t[qt]=1,queueMicrotask(()=>Uh(t))):Uh(t);continue}if(t[ns]===0||t[os]>=(Gh(t)||1))return;let r=t[$e][t[et]];if(t[Et].protocol==="https:"&&t[Pt]!==r.servername){if(t[os]>0)return;t[Pt]=r.servername,t[ce]?.destroy(new yD("servername changed"),()=>{t[ce]=null,va(t)})}if(t[sA])return;if(!t[ce]){Lh(t);return}if(t[ce].destroyed||t[ce].busy(r))return;!r.aborted&&t[ce].write(r)?t[et]++:t[$e].splice(t[et],1)}}vh.exports=La});var _a=m((mL,_h)=>{"use strict";var Lo=class{constructor(){this.bottom=0,this.top=0,this.list=new Array(2048),this.next=null}isEmpty(){return this.top===this.bottom}isFull(){return(this.top+1&2047)===this.bottom}push(e){this.list[this.top]=e,this.top=this.top+1&2047}shift(){let e=this.list[this.bottom];return e===void 0?null:(this.list[this.bottom]=void 0,this.bottom=this.bottom+1&2047,e)}};_h.exports=class{constructor(){this.head=this.tail=new Lo}isEmpty(){return this.head.isEmpty()}push(e){this.head.isFull()&&(this.head=this.head.next=new Lo),this.head.push(e)}shift(){let e=this.tail,r=e.shift();return e.isEmpty()&&e.next!==null&&(this.tail=e.next),r}}});var Yh=m((wL,xh)=>{var{kFree:jD,kConnected:XD,kPending:$D,kQueued:ek,kRunning:tk,kSize:rk}=se(),dr=Symbol("pool"),xa=class{constructor(e){this[dr]=e}get connected(){return this[dr][XD]}get free(){return this[dr][jD]}get pending(){return this[dr][$D]}get queued(){return this[dr][ek]}get running(){return this[dr][tk]}get size(){return this[dr][rk]}};xh.exports=xa});var Va=m((yL,Kh)=>{"use strict";var Ak=Hr(),sk=_a(),{kConnected:Ya,kSize:Oh,kRunning:Jh,kPending:Hh,kQueued:is,kBusy:ok,kFree:nk,kUrl:ik,kClose:ak,kDestroy:ck,kDispatch:gk}=se(),uk=Yh(),De=Symbol("clients"),we=Symbol("needDrain"),as=Symbol("queue"),Oa=Symbol("closed resolve"),Ja=Symbol("onDrain"),Ph=Symbol("onConnect"),Vh=Symbol("onDisconnect"),qh=Symbol("onConnectionError"),Ha=Symbol("get dispatcher"),zh=Symbol("add client"),Zh=Symbol("remove client"),Wh=Symbol("stats"),Pa=class extends Ak{constructor(e){super(e),this[as]=new sk,this[De]=[],this[is]=0;let r=this;this[Ja]=function(s,o){let n=r[as],i=!1;for(;!i;){let a=n.shift();if(!a)break;r[is]--,i=!this.dispatch(a.opts,a.handler)}this[we]=i,!this[we]&&r[we]&&(r[we]=!1,r.emit("drain",s,[r,...o])),r[Oa]&&n.isEmpty()&&Promise.all(r[De].map(a=>a.close())).then(r[Oa])},this[Ph]=(A,s)=>{r.emit("connect",A,[r,...s])},this[Vh]=(A,s,o)=>{r.emit("disconnect",A,[r,...s],o)},this[qh]=(A,s,o)=>{r.emit("connectionError",A,[r,...s],o)},this[Wh]=new uk(this)}get[ok](){return this[we]}get[Ya](){return this[De].filter(e=>e[Ya]).length}get[nk](){return this[De].filter(e=>e[Ya]&&!e[we]).length}get[Hh](){let e=this[is];for(let{[Hh]:r}of this[De])e+=r;return e}get[Jh](){let e=0;for(let{[Jh]:r}of this[De])e+=r;return e}get[Oh](){let e=this[is];for(let{[Oh]:r}of this[De])e+=r;return e}get stats(){return this[Wh]}async[ak](){this[as].isEmpty()?await Promise.all(this[De].map(e=>e.close())):await new Promise(e=>{this[Oa]=e})}async[ck](e){for(;;){let r=this[as].shift();if(!r)break;r.handler.onError(e)}await Promise.all(this[De].map(r=>r.destroy(e)))}[gk](e,r){let A=this[Ha]();return A?A.dispatch(e,r)||(A[we]=!0,this[we]=!this[Ha]()):(this[we]=!0,this[as].push({opts:e,handler:r}),this[is]++),!this[we]}[zh](e){return e.on("drain",this[Ja]).on("connect",this[Ph]).on("disconnect",this[Vh]).on("connectionError",this[qh]),this[De].push(e),this[we]&&queueMicrotask(()=>{this[we]&&this[Ja](e[ik],[this,e])}),this}[Zh](e){e.close(()=>{let r=this[De].indexOf(e);r!==-1&&this[De].splice(r,1)}),this[we]=this[De].some(r=>!r[we]&&r.closed!==!0&&r.destroyed!==!0)}};Kh.exports={PoolBase:Pa,kClients:De,kNeedDrain:we,kAddClient:zh,kRemoveClient:Zh,kGetDispatcher:Ha}});var nA=m((bL,eQ)=>{"use strict";var{PoolBase:lk,kClients:vo,kNeedDrain:Ek,kAddClient:hk,kGetDispatcher:Qk}=Va(),dk=oA(),{InvalidArgumentError:qa}=q(),jh=O(),{kUrl:Xh,kInterceptors:Bk}=se(),Ik=OA(),Wa=Symbol("options"),za=Symbol("connections"),$h=Symbol("factory");function Ck(t,e){return new dk(t,e)}var Za=class extends lk{constructor(e,{connections:r,factory:A=Ck,connect:s,connectTimeout:o,tls:n,maxCachedSessions:i,socketPath:a,autoSelectFamily:c,autoSelectFamilyAttemptTimeout:u,allowH2:g,...E}={}){if(r!=null&&(!Number.isFinite(r)||r<0))throw new qa("invalid connections");if(typeof A!="function")throw new qa("factory must be a function.");if(s!=null&&typeof s!="function"&&typeof s!="object")throw new qa("connect must be a function or an object");typeof s!="function"&&(s=Ik({...n,maxCachedSessions:i,allowH2:g,socketPath:a,timeout:o,...c?{autoSelectFamily:c,autoSelectFamilyAttemptTimeout:u}:void 0,...s})),super(E),this[Bk]=E.interceptors?.Pool&&Array.isArray(E.interceptors.Pool)?E.interceptors.Pool:[],this[za]=r||null,this[Xh]=jh.parseOrigin(e),this[Wa]={...jh.deepClone(E),connect:s,allowH2:g},this[Wa].interceptors=E.interceptors?{...E.interceptors}:void 0,this[$h]=A,this.on("connectionError",(I,d,p)=>{for(let y of d){let B=this[vo].indexOf(y);B!==-1&&this[vo].splice(B,1)}})}[Qk](){for(let e of this[vo])if(!e[Ek])return e;if(!this[za]||this[vo].length{"use strict";var{BalancedPoolMissingUpstreamError:pk,InvalidArgumentError:fk}=q(),{PoolBase:mk,kClients:Ce,kNeedDrain:cs,kAddClient:wk,kRemoveClient:yk,kGetDispatcher:bk}=Va(),Dk=nA(),{kUrl:Ka,kInterceptors:kk}=se(),{parseOrigin:tQ}=O(),rQ=Symbol("factory"),_o=Symbol("options"),AQ=Symbol("kGreatestCommonDivisor"),Br=Symbol("kCurrentWeight"),Ir=Symbol("kIndex"),qe=Symbol("kWeight"),xo=Symbol("kMaxWeightPerServer"),Yo=Symbol("kErrorPenalty");function Rk(t,e){if(t===0)return e;for(;e!==0;){let r=e;e=t%e,t=r}return t}function Tk(t,e){return new Dk(t,e)}var ja=class extends mk{constructor(e=[],{factory:r=Tk,...A}={}){if(super(),this[_o]=A,this[Ir]=-1,this[Br]=0,this[xo]=this[_o].maxWeightPerServer||100,this[Yo]=this[_o].errorPenalty||15,Array.isArray(e)||(e=[e]),typeof r!="function")throw new fk("factory must be a function.");this[kk]=A.interceptors?.BalancedPool&&Array.isArray(A.interceptors.BalancedPool)?A.interceptors.BalancedPool:[],this[rQ]=r;for(let s of e)this.addUpstream(s);this._updateBalancedPoolStats()}addUpstream(e){let r=tQ(e).origin;if(this[Ce].find(s=>s[Ka].origin===r&&s.closed!==!0&&s.destroyed!==!0))return this;let A=this[rQ](r,Object.assign({},this[_o]));this[wk](A),A.on("connect",()=>{A[qe]=Math.min(this[xo],A[qe]+this[Yo])}),A.on("connectionError",()=>{A[qe]=Math.max(1,A[qe]-this[Yo]),this._updateBalancedPoolStats()}),A.on("disconnect",(...s)=>{let o=s[2];o&&o.code==="UND_ERR_SOCKET"&&(A[qe]=Math.max(1,A[qe]-this[Yo]),this._updateBalancedPoolStats())});for(let s of this[Ce])s[qe]=this[xo];return this._updateBalancedPoolStats(),this}_updateBalancedPoolStats(){let e=0;for(let r=0;rs[Ka].origin===r&&s.closed!==!0&&s.destroyed!==!0);return A&&this[yk](A),this}get upstreams(){return this[Ce].filter(e=>e.closed!==!0&&e.destroyed!==!0).map(e=>e[Ka].origin)}[bk](){if(this[Ce].length===0)throw new pk;if(!this[Ce].find(o=>!o[cs]&&o.closed!==!0&&o.destroyed!==!0)||this[Ce].map(o=>o[cs]).reduce((o,n)=>o&&n,!0))return;let A=0,s=this[Ce].findIndex(o=>!o[cs]);for(;A++this[Ce][s][qe]&&!o[cs]&&(s=this[Ir]),this[Ir]===0&&(this[Br]=this[Br]-this[AQ],this[Br]<=0&&(this[Br]=this[xo])),o[qe]>=this[Br]&&!o[cs])return o}return this[Br]=this[Ce][s][qe],this[Ir]=s,this[Ce][s]}};sQ.exports=ja});var iA=m((kL,lQ)=>{"use strict";var{InvalidArgumentError:Oo}=q(),{kClients:Wt,kRunning:nQ,kClose:Fk,kDestroy:Sk,kDispatch:Uk,kInterceptors:Nk}=se(),Gk=Hr(),Mk=nA(),Lk=oA(),vk=O(),_k=Go(),iQ=Symbol("onConnect"),aQ=Symbol("onDisconnect"),cQ=Symbol("onConnectionError"),xk=Symbol("maxRedirections"),gQ=Symbol("onDrain"),uQ=Symbol("factory"),Xa=Symbol("options");function Yk(t,e){return e&&e.connections===1?new Lk(t,e):new Mk(t,e)}var $a=class extends Gk{constructor({factory:e=Yk,maxRedirections:r=0,connect:A,...s}={}){if(typeof e!="function")throw new Oo("factory must be a function.");if(A!=null&&typeof A!="function"&&typeof A!="object")throw new Oo("connect must be a function or an object");if(!Number.isInteger(r)||r<0)throw new Oo("maxRedirections must be a positive number");super(s),A&&typeof A!="function"&&(A={...A}),this[Nk]=s.interceptors?.Agent&&Array.isArray(s.interceptors.Agent)?s.interceptors.Agent:[_k({maxRedirections:r})],this[Xa]={...vk.deepClone(s),connect:A},this[Xa].interceptors=s.interceptors?{...s.interceptors}:void 0,this[xk]=r,this[uQ]=e,this[Wt]=new Map,this[gQ]=(o,n)=>{this.emit("drain",o,[this,...n])},this[iQ]=(o,n)=>{this.emit("connect",o,[this,...n])},this[aQ]=(o,n,i)=>{this.emit("disconnect",o,[this,...n],i)},this[cQ]=(o,n,i)=>{this.emit("connectionError",o,[this,...n],i)}}get[nQ](){let e=0;for(let r of this[Wt].values())e+=r[nQ];return e}[Uk](e,r){let A;if(e.origin&&(typeof e.origin=="string"||e.origin instanceof URL))A=String(e.origin);else throw new Oo("opts.origin must be a non-empty string or URL.");let s=this[Wt].get(A);return s||(s=this[uQ](e.origin,this[Xa]).on("drain",this[gQ]).on("connect",this[iQ]).on("disconnect",this[aQ]).on("connectionError",this[cQ]),this[Wt].set(A,s)),s.dispatch(e,r)}async[Fk](){let e=[];for(let r of this[Wt].values())e.push(r.close());this[Wt].clear(),await Promise.all(e)}async[Sk](e){let r=[];for(let A of this[Wt].values())r.push(A.destroy(e));this[Wt].clear(),await Promise.all(r)}};lQ.exports=$a});var sc=m((RL,wQ)=>{"use strict";var{kProxy:ec,kClose:IQ,kDestroy:CQ,kDispatch:EQ,kInterceptors:Ok}=se(),{URL:Cr}=require("node:url"),Jk=iA(),pQ=nA(),fQ=Hr(),{InvalidArgumentError:aA,RequestAbortedError:Hk,SecureProxyConnectionError:Pk}=q(),hQ=OA(),mQ=oA(),Jo=Symbol("proxy agent"),Ho=Symbol("proxy client"),zt=Symbol("proxy headers"),tc=Symbol("request tls settings"),QQ=Symbol("proxy tls settings"),dQ=Symbol("connect endpoint function"),BQ=Symbol("tunnel proxy");function Vk(t){return t==="https:"?443:80}function qk(t,e){return new pQ(t,e)}var Wk=()=>{};function zk(t,e){return e.connections===1?new mQ(t,e):new pQ(t,e)}var rc=class extends fQ{#e;constructor(e,{headers:r={},connect:A,factory:s}){if(super(),!e)throw new aA("Proxy URL is mandatory");this[zt]=r,s?this.#e=s(e,{connect:A}):this.#e=new mQ(e,{connect:A})}[EQ](e,r){let A=r.onHeaders;r.onHeaders=function(i,a,c){if(i===407){typeof r.onError=="function"&&r.onError(new aA("Proxy Authentication Required (407)"));return}A&&A.call(this,i,a,c)};let{origin:s,path:o="/",headers:n={}}=e;if(e.path=s+o,!("host"in n)&&!("Host"in n)){let{host:i}=new Cr(s);n.host=i}return e.headers={...this[zt],...n},this.#e[EQ](e,r)}async[IQ](){return this.#e.close()}async[CQ](e){return this.#e.destroy(e)}},Ac=class extends fQ{constructor(e){if(super(),!e||typeof e=="object"&&!(e instanceof Cr)&&!e.uri)throw new aA("Proxy uri is mandatory");let{clientFactory:r=qk}=e;if(typeof r!="function")throw new aA("Proxy opts.clientFactory must be a function.");let{proxyTunnel:A=!0}=e,s=this.#e(e),{href:o,origin:n,port:i,protocol:a,username:c,password:u,hostname:g}=s;if(this[ec]={uri:o,protocol:a},this[Ok]=e.interceptors?.ProxyAgent&&Array.isArray(e.interceptors.ProxyAgent)?e.interceptors.ProxyAgent:[],this[tc]=e.requestTls,this[QQ]=e.proxyTls,this[zt]=e.headers||{},this[BQ]=A,e.auth&&e.token)throw new aA("opts.auth cannot be used in combination with opts.token");e.auth?this[zt]["proxy-authorization"]=`Basic ${e.auth}`:e.token?this[zt]["proxy-authorization"]=e.token:c&&u&&(this[zt]["proxy-authorization"]=`Basic ${Buffer.from(`${decodeURIComponent(c)}:${decodeURIComponent(u)}`).toString("base64")}`);let E=hQ({...e.proxyTls});this[dQ]=hQ({...e.requestTls});let I=e.factory||zk,d=(p,y)=>{let{protocol:B}=new Cr(p);return!this[BQ]&&B==="http:"&&this[ec].protocol==="http:"?new rc(this[ec].uri,{headers:this[zt],connect:E,factory:I}):I(p,y)};this[Ho]=r(s,{connect:E}),this[Jo]=new Jk({...e,factory:d,connect:async(p,y)=>{let B=p.host;p.port||(B+=`:${Vk(p.protocol)}`);try{let{socket:w,statusCode:T}=await this[Ho].connect({origin:n,port:i,path:B,signal:p.signal,headers:{...this[zt],host:p.host},servername:this[QQ]?.servername||g});if(T!==200&&(w.on("error",Wk).destroy(),y(new Hk(`Proxy response (${T}) !== 200 when HTTP Tunneling`))),p.protocol!=="https:"){y(null,w);return}let S;this[tc]?S=this[tc].servername:S=p.servername,this[dQ]({...p,servername:S,httpSocket:w},y)}catch(w){w.code==="ERR_TLS_CERT_ALTNAME_INVALID"?y(new Pk(w)):y(w)}}})}dispatch(e,r){let A=Zk(e.headers);if(Kk(A),A&&!("host"in A)&&!("Host"in A)){let{host:s}=new Cr(e.origin);A.host=s}return this[Jo].dispatch({...e,headers:A},r)}#e(e){return typeof e=="string"?new Cr(e):e instanceof Cr?e:new Cr(e.uri)}async[IQ](){await this[Jo].close(),await this[Ho].close()}async[CQ](){await this[Jo].destroy(),await this[Ho].destroy()}};function Zk(t){if(Array.isArray(t)){let e={};for(let r=0;rr.toLowerCase()==="proxy-authorization"))throw new aA("Proxy-Authorization should be sent in ProxyAgent constructor")}wQ.exports=Ac});var TQ=m((TL,RQ)=>{"use strict";var jk=Hr(),{kClose:Xk,kDestroy:$k,kClosed:yQ,kDestroyed:bQ,kDispatch:eR,kNoProxyAgent:gs,kHttpProxyAgent:Zt,kHttpsProxyAgent:pr}=se(),DQ=sc(),tR=iA(),rR={"http:":80,"https:":443},kQ=!1,oc=class extends jk{#e=null;#t=null;#r=null;constructor(e={}){super(),this.#r=e,kQ||(kQ=!0,process.emitWarning("EnvHttpProxyAgent is experimental, expect them to change at any time.",{code:"UNDICI-EHPA"}));let{httpProxy:r,httpsProxy:A,noProxy:s,...o}=e;this[gs]=new tR(o);let n=r??process.env.http_proxy??process.env.HTTP_PROXY;n?this[Zt]=new DQ({...o,uri:n}):this[Zt]=this[gs];let i=A??process.env.https_proxy??process.env.HTTPS_PROXY;i?this[pr]=new DQ({...o,uri:i}):this[pr]=this[Zt],this.#A()}[eR](e,r){let A=new URL(e.origin);return this.#o(A).dispatch(e,r)}async[Xk](){await this[gs].close(),this[Zt][yQ]||await this[Zt].close(),this[pr][yQ]||await this[pr].close()}async[$k](e){await this[gs].destroy(e),this[Zt][bQ]||await this[Zt].destroy(e),this[pr][bQ]||await this[pr].destroy(e)}#o(e){let{protocol:r,host:A,port:s}=e;return A=A.replace(/:\d*$/,"").toLowerCase(),s=Number.parseInt(s,10)||rR[r]||0,this.#s(A,s)?r==="https:"?this[pr]:this[Zt]:this[gs]}#s(e,r){if(this.#n&&this.#A(),this.#t.length===0)return!0;if(this.#e==="*")return!1;for(let A=0;A{"use strict";var cA=require("node:assert"),{kRetryHandlerDefaultRetry:FQ}=se(),{RequestRetryError:us}=q(),{isDisturbed:SQ,parseHeaders:AR,parseRangeHeader:UQ,wrapRequestBody:sR}=O();function oR(t){let e=Date.now();return new Date(t).getTime()-e}var nc=class t{constructor(e,r){let{retryOptions:A,...s}=e,{retry:o,maxRetries:n,maxTimeout:i,minTimeout:a,timeoutFactor:c,methods:u,errorCodes:g,retryAfter:E,statusCodes:I}=A??{};this.dispatch=r.dispatch,this.handler=r.handler,this.opts={...s,body:sR(e.body)},this.abort=null,this.aborted=!1,this.retryOpts={retry:o??t[FQ],retryAfter:E??!0,maxTimeout:i??30*1e3,minTimeout:a??500,timeoutFactor:c??2,maxRetries:n??5,methods:u??["GET","HEAD","OPTIONS","PUT","DELETE","TRACE"],statusCodes:I??[500,502,503,504,429],errorCodes:g??["ECONNRESET","ECONNREFUSED","ENOTFOUND","ENETDOWN","ENETUNREACH","EHOSTDOWN","EHOSTUNREACH","EPIPE","UND_ERR_SOCKET"]},this.retryCount=0,this.retryCountCheckpoint=0,this.start=0,this.end=null,this.etag=null,this.resume=null,this.handler.onConnect(d=>{this.aborted=!0,this.abort?this.abort(d):this.reason=d})}onRequestSent(){this.handler.onRequestSent&&this.handler.onRequestSent()}onUpgrade(e,r,A){this.handler.onUpgrade&&this.handler.onUpgrade(e,r,A)}onConnect(e){this.aborted?e(this.reason):this.abort=e}onBodySent(e){if(this.handler.onBodySent)return this.handler.onBodySent(e)}static[FQ](e,{state:r,opts:A},s){let{statusCode:o,code:n,headers:i}=e,{method:a,retryOptions:c}=A,{maxRetries:u,minTimeout:g,maxTimeout:E,timeoutFactor:I,statusCodes:d,errorCodes:p,methods:y}=c,{counter:B}=r;if(n&&n!=="UND_ERR_REQ_RETRY"&&!p.includes(n)){s(e);return}if(Array.isArray(y)&&!y.includes(a)){s(e);return}if(o!=null&&Array.isArray(d)&&!d.includes(o)){s(e);return}if(B>u){s(e);return}let w=i?.["retry-after"];w&&(w=Number(w),w=Number.isNaN(w)?oR(w):w*1e3);let T=w>0?Math.min(w,E):Math.min(g*I**(B-1),E);setTimeout(()=>s(null),T)}onHeaders(e,r,A,s){let o=AR(r);if(this.retryCount+=1,e>=300)return this.retryOpts.statusCodes.includes(e)===!1?this.handler.onHeaders(e,r,A,s):(this.abort(new us("Request failed",e,{headers:o,data:{count:this.retryCount}})),!1);if(this.resume!=null){if(this.resume=null,e!==206&&(this.start>0||e!==200))return this.abort(new us("server does not support the range header and the payload was partially consumed",e,{headers:o,data:{count:this.retryCount}})),!1;let i=UQ(o["content-range"]);if(!i)return this.abort(new us("Content-Range mismatch",e,{headers:o,data:{count:this.retryCount}})),!1;if(this.etag!=null&&this.etag!==o.etag)return this.abort(new us("ETag mismatch",e,{headers:o,data:{count:this.retryCount}})),!1;let{start:a,size:c,end:u=c-1}=i;return cA(this.start===a,"content-range mismatch"),cA(this.end==null||this.end===u,"content-range mismatch"),this.resume=A,!0}if(this.end==null){if(e===206){let i=UQ(o["content-range"]);if(i==null)return this.handler.onHeaders(e,r,A,s);let{start:a,size:c,end:u=c-1}=i;cA(a!=null&&Number.isFinite(a),"content-range mismatch"),cA(u!=null&&Number.isFinite(u),"invalid content-length"),this.start=a,this.end=u}if(this.end==null){let i=o["content-length"];this.end=i!=null?Number(i)-1:null}return cA(Number.isFinite(this.start)),cA(this.end==null||Number.isFinite(this.end),"invalid content-length"),this.resume=A,this.etag=o.etag!=null?o.etag:null,this.etag!=null&&this.etag.startsWith("W/")&&(this.etag=null),this.handler.onHeaders(e,r,A,s)}let n=new us("Request failed",e,{headers:o,data:{count:this.retryCount}});return this.abort(n),!1}onData(e){return this.start+=e.length,this.handler.onData(e)}onComplete(e){return this.retryCount=0,this.handler.onComplete(e)}onError(e){if(this.aborted||SQ(this.opts.body))return this.handler.onError(e);this.retryCount-this.retryCountCheckpoint>0?this.retryCount=this.retryCountCheckpoint+(this.retryCount-this.retryCountCheckpoint):this.retryCount+=1,this.retryOpts.retry(e,{state:{counter:this.retryCount},opts:{retryOptions:this.retryOpts,...this.opts}},r.bind(this));function r(A){if(A!=null||this.aborted||SQ(this.opts.body))return this.handler.onError(A);if(this.start!==0){let s={range:`bytes=${this.start}-${this.end??""}`};this.etag!=null&&(s["if-match"]=this.etag),this.opts={...this.opts,headers:{...this.opts.headers,...s}}}try{this.retryCountCheckpoint=this.retryCount,this.dispatch(this.opts,this)}catch(s){this.handler.onError(s)}}}};NQ.exports=nc});var MQ=m((SL,GQ)=>{"use strict";var nR=xA(),iR=Po(),ic=class extends nR{#e=null;#t=null;constructor(e,r={}){super(r),this.#e=e,this.#t=r}dispatch(e,r){let A=new iR({...e,retryOptions:this.#t},{dispatch:this.#e.dispatch.bind(this.#e),handler:r});return this.#e.dispatch(e,A)}close(){return this.#e.close()}destroy(){return this.#e.destroy()}};GQ.exports=ic});var Ec=m((UL,PQ)=>{"use strict";var YQ=require("node:assert"),{Readable:aR}=require("node:stream"),{RequestAbortedError:OQ,NotSupportedError:cR,InvalidArgumentError:gR,AbortError:ac}=q(),JQ=O(),{ReadableStreamFrom:uR}=O(),Ue=Symbol("kConsume"),ls=Symbol("kReading"),Kt=Symbol("kBody"),LQ=Symbol("kAbort"),HQ=Symbol("kContentType"),vQ=Symbol("kContentLength"),lR=()=>{},cc=class extends aR{constructor({resume:e,abort:r,contentType:A="",contentLength:s,highWaterMark:o=64*1024}){super({autoDestroy:!0,read:e,highWaterMark:o}),this._readableState.dataEmitted=!1,this[LQ]=r,this[Ue]=null,this[Kt]=null,this[HQ]=A,this[vQ]=s,this[ls]=!1}destroy(e){return!e&&!this._readableState.endEmitted&&(e=new OQ),e&&this[LQ](),super.destroy(e)}_destroy(e,r){this[ls]?r(e):setImmediate(()=>{r(e)})}on(e,...r){return(e==="data"||e==="readable")&&(this[ls]=!0),super.on(e,...r)}addListener(e,...r){return this.on(e,...r)}off(e,...r){let A=super.off(e,...r);return(e==="data"||e==="readable")&&(this[ls]=this.listenerCount("data")>0||this.listenerCount("readable")>0),A}removeListener(e,...r){return this.off(e,...r)}push(e){return this[Ue]&&e!==null?(uc(this[Ue],e),this[ls]?super.push(e):!0):super.push(e)}async text(){return Es(this,"text")}async json(){return Es(this,"json")}async blob(){return Es(this,"blob")}async bytes(){return Es(this,"bytes")}async arrayBuffer(){return Es(this,"arrayBuffer")}async formData(){throw new cR}get bodyUsed(){return JQ.isDisturbed(this)}get body(){return this[Kt]||(this[Kt]=uR(this),this[Ue]&&(this[Kt].getReader(),YQ(this[Kt].locked))),this[Kt]}async dump(e){let r=Number.isFinite(e?.limit)?e.limit:131072,A=e?.signal;if(A!=null&&(typeof A!="object"||!("aborted"in A)))throw new gR("signal must be an AbortSignal");return A?.throwIfAborted(),this._readableState.closeEmitted?null:await new Promise((s,o)=>{this[vQ]>r&&this.destroy(new ac);let n=()=>{this.destroy(A.reason??new ac)};A?.addEventListener("abort",n),this.on("close",function(){A?.removeEventListener("abort",n),A?.aborted?o(A.reason??new ac):s(null)}).on("error",lR).on("data",function(i){r-=i.length,r<=0&&this.destroy()}).resume()})}};function ER(t){return t[Kt]&&t[Kt].locked===!0||t[Ue]}function hR(t){return JQ.isDisturbed(t)||ER(t)}async function Es(t,e){return YQ(!t[Ue]),new Promise((r,A)=>{if(hR(t)){let s=t._readableState;s.destroyed&&s.closeEmitted===!1?t.on("error",o=>{A(o)}).on("close",()=>{A(new TypeError("unusable"))}):A(s.errored??new TypeError("unusable"))}else queueMicrotask(()=>{t[Ue]={type:e,stream:t,resolve:r,reject:A,length:0,body:[]},t.on("error",function(s){lc(this[Ue],s)}).on("close",function(){this[Ue].body!==null&&lc(this[Ue],new OQ)}),QR(t[Ue])})})}function QR(t){if(t.body===null)return;let{_readableState:e}=t.stream;if(e.bufferIndex){let r=e.bufferIndex,A=e.buffer.length;for(let s=r;s2&&r[0]===239&&r[1]===187&&r[2]===191?3:0;return r.utf8Slice(s,A)}function _Q(t,e){if(t.length===0||e===0)return new Uint8Array(0);if(t.length===1)return new Uint8Array(t[0]);let r=new Uint8Array(Buffer.allocUnsafeSlow(e).buffer),A=0;for(let s=0;s{var dR=require("node:assert"),{ResponseStatusCodeError:VQ}=q(),{chunksDecode:qQ}=Ec(),BR=128*1024;async function IR({callback:t,body:e,contentType:r,statusCode:A,statusMessage:s,headers:o}){dR(e);let n=[],i=0;try{for await(let g of e)if(n.push(g),i+=g.length,i>BR){n=[],i=0;break}}catch{n=[],i=0}let a=`Response status code ${A}${s?`: ${s}`:""}`;if(A===204||!r||!i){queueMicrotask(()=>t(new VQ(a,A,o)));return}let c=Error.stackTraceLimit;Error.stackTraceLimit=0;let u;try{WQ(r)?u=JSON.parse(qQ(n,i)):zQ(r)&&(u=qQ(n,i))}catch{}finally{Error.stackTraceLimit=c}queueMicrotask(()=>t(new VQ(a,A,o,u)))}var WQ=t=>t.length>15&&t[11]==="/"&&t[0]==="a"&&t[1]==="p"&&t[2]==="p"&&t[3]==="l"&&t[4]==="i"&&t[5]==="c"&&t[6]==="a"&&t[7]==="t"&&t[8]==="i"&&t[9]==="o"&&t[10]==="n"&&t[12]==="j"&&t[13]==="s"&&t[14]==="o"&&t[15]==="n",zQ=t=>t.length>4&&t[4]==="/"&&t[0]==="t"&&t[1]==="e"&&t[2]==="x"&&t[3]==="t";ZQ.exports={getResolveErrorBodyCallback:IR,isContentTypeApplicationJson:WQ,isContentTypeText:zQ}});var XQ=m((GL,Qc)=>{"use strict";var CR=require("node:assert"),{Readable:pR}=Ec(),{InvalidArgumentError:gA,RequestAbortedError:KQ}=q(),Ne=O(),{getResolveErrorBodyCallback:fR}=hc(),{AsyncResource:mR}=require("node:async_hooks"),Vo=class extends mR{constructor(e,r){if(!e||typeof e!="object")throw new gA("invalid opts");let{signal:A,method:s,opaque:o,body:n,onInfo:i,responseHeaders:a,throwOnError:c,highWaterMark:u}=e;try{if(typeof r!="function")throw new gA("invalid callback");if(u&&(typeof u!="number"||u<0))throw new gA("invalid highWaterMark");if(A&&typeof A.on!="function"&&typeof A.addEventListener!="function")throw new gA("signal must be an EventEmitter or EventTarget");if(s==="CONNECT")throw new gA("invalid method");if(i&&typeof i!="function")throw new gA("invalid onInfo callback");super("UNDICI_REQUEST")}catch(g){throw Ne.isStream(n)&&Ne.destroy(n.on("error",Ne.nop),g),g}this.method=s,this.responseHeaders=a||null,this.opaque=o||null,this.callback=r,this.res=null,this.abort=null,this.body=n,this.trailers={},this.context=null,this.onInfo=i||null,this.throwOnError=c,this.highWaterMark=u,this.signal=A,this.reason=null,this.removeAbortListener=null,Ne.isStream(n)&&n.on("error",g=>{this.onError(g)}),this.signal&&(this.signal.aborted?this.reason=this.signal.reason??new KQ:this.removeAbortListener=Ne.addAbortListener(this.signal,()=>{this.reason=this.signal.reason??new KQ,this.res?Ne.destroy(this.res.on("error",Ne.nop),this.reason):this.abort&&this.abort(this.reason),this.removeAbortListener&&(this.res?.off("close",this.removeAbortListener),this.removeAbortListener(),this.removeAbortListener=null)}))}onConnect(e,r){if(this.reason){e(this.reason);return}CR(this.callback),this.abort=e,this.context=r}onHeaders(e,r,A,s){let{callback:o,opaque:n,abort:i,context:a,responseHeaders:c,highWaterMark:u}=this,g=c==="raw"?Ne.parseRawHeaders(r):Ne.parseHeaders(r);if(e<200){this.onInfo&&this.onInfo({statusCode:e,headers:g});return}let E=c==="raw"?Ne.parseHeaders(r):g,I=E["content-type"],d=E["content-length"],p=new pR({resume:A,abort:i,contentType:I,contentLength:this.method!=="HEAD"&&d?Number(d):null,highWaterMark:u});this.removeAbortListener&&p.on("close",this.removeAbortListener),this.callback=null,this.res=p,o!==null&&(this.throwOnError&&e>=400?this.runInAsyncScope(fR,null,{callback:o,body:p,contentType:I,statusCode:e,statusMessage:s,headers:g}):this.runInAsyncScope(o,null,null,{statusCode:e,headers:g,trailers:this.trailers,opaque:n,body:p,context:a}))}onData(e){return this.res.push(e)}onComplete(e){Ne.parseHeaders(e,this.trailers),this.res.push(null)}onError(e){let{res:r,callback:A,body:s,opaque:o}=this;A&&(this.callback=null,queueMicrotask(()=>{this.runInAsyncScope(A,null,e,{opaque:o})})),r&&(this.res=null,queueMicrotask(()=>{Ne.destroy(r,e)})),s&&(this.body=null,Ne.destroy(s,e)),this.removeAbortListener&&(r?.off("close",this.removeAbortListener),this.removeAbortListener(),this.removeAbortListener=null)}};function jQ(t,e){if(e===void 0)return new Promise((r,A)=>{jQ.call(this,t,(s,o)=>s?A(s):r(o))});try{this.dispatch(t,new Vo(t,e))}catch(r){if(typeof e!="function")throw r;let A=t?.opaque;queueMicrotask(()=>e(r,{opaque:A}))}}Qc.exports=jQ;Qc.exports.RequestHandler=Vo});var hs=m((ML,td)=>{var{addAbortListener:wR}=O(),{RequestAbortedError:yR}=q(),uA=Symbol("kListener"),ht=Symbol("kSignal");function $Q(t){t.abort?t.abort(t[ht]?.reason):t.reason=t[ht]?.reason??new yR,ed(t)}function bR(t,e){if(t.reason=null,t[ht]=null,t[uA]=null,!!e){if(e.aborted){$Q(t);return}t[ht]=e,t[uA]=()=>{$Q(t)},wR(t[ht],t[uA])}}function ed(t){t[ht]&&("removeEventListener"in t[ht]?t[ht].removeEventListener("abort",t[uA]):t[ht].removeListener("abort",t[uA]),t[ht]=null,t[uA]=null)}td.exports={addSignal:bR,removeSignal:ed}});var od=m((LL,sd)=>{"use strict";var DR=require("node:assert"),{finished:kR,PassThrough:RR}=require("node:stream"),{InvalidArgumentError:lA,InvalidReturnValueError:TR}=q(),tt=O(),{getResolveErrorBodyCallback:FR}=hc(),{AsyncResource:SR}=require("node:async_hooks"),{addSignal:UR,removeSignal:rd}=hs(),dc=class extends SR{constructor(e,r,A){if(!e||typeof e!="object")throw new lA("invalid opts");let{signal:s,method:o,opaque:n,body:i,onInfo:a,responseHeaders:c,throwOnError:u}=e;try{if(typeof A!="function")throw new lA("invalid callback");if(typeof r!="function")throw new lA("invalid factory");if(s&&typeof s.on!="function"&&typeof s.addEventListener!="function")throw new lA("signal must be an EventEmitter or EventTarget");if(o==="CONNECT")throw new lA("invalid method");if(a&&typeof a!="function")throw new lA("invalid onInfo callback");super("UNDICI_STREAM")}catch(g){throw tt.isStream(i)&&tt.destroy(i.on("error",tt.nop),g),g}this.responseHeaders=c||null,this.opaque=n||null,this.factory=r,this.callback=A,this.res=null,this.abort=null,this.context=null,this.trailers=null,this.body=i,this.onInfo=a||null,this.throwOnError=u||!1,tt.isStream(i)&&i.on("error",g=>{this.onError(g)}),UR(this,s)}onConnect(e,r){if(this.reason){e(this.reason);return}DR(this.callback),this.abort=e,this.context=r}onHeaders(e,r,A,s){let{factory:o,opaque:n,context:i,callback:a,responseHeaders:c}=this,u=c==="raw"?tt.parseRawHeaders(r):tt.parseHeaders(r);if(e<200){this.onInfo&&this.onInfo({statusCode:e,headers:u});return}this.factory=null;let g;if(this.throwOnError&&e>=400){let d=(c==="raw"?tt.parseHeaders(r):u)["content-type"];g=new RR,this.callback=null,this.runInAsyncScope(FR,null,{callback:a,body:g,contentType:d,statusCode:e,statusMessage:s,headers:u})}else{if(o===null)return;if(g=this.runInAsyncScope(o,null,{statusCode:e,headers:u,opaque:n,context:i}),!g||typeof g.write!="function"||typeof g.end!="function"||typeof g.on!="function")throw new TR("expected Writable");kR(g,{readable:!1},I=>{let{callback:d,res:p,opaque:y,trailers:B,abort:w}=this;this.res=null,(I||!p.readable)&&tt.destroy(p,I),this.callback=null,this.runInAsyncScope(d,null,I||null,{opaque:y,trailers:B}),I&&w()})}return g.on("drain",A),this.res=g,(g.writableNeedDrain!==void 0?g.writableNeedDrain:g._writableState?.needDrain)!==!0}onData(e){let{res:r}=this;return r?r.write(e):!0}onComplete(e){let{res:r}=this;rd(this),r&&(this.trailers=tt.parseHeaders(e),r.end())}onError(e){let{res:r,callback:A,opaque:s,body:o}=this;rd(this),this.factory=null,r?(this.res=null,tt.destroy(r,e)):A&&(this.callback=null,queueMicrotask(()=>{this.runInAsyncScope(A,null,e,{opaque:s})})),o&&(this.body=null,tt.destroy(o,e))}};function Ad(t,e,r){if(r===void 0)return new Promise((A,s)=>{Ad.call(this,t,e,(o,n)=>o?s(o):A(n))});try{this.dispatch(t,new dc(t,e,r))}catch(A){if(typeof r!="function")throw A;let s=t?.opaque;queueMicrotask(()=>r(A,{opaque:s}))}}sd.exports=Ad});var cd=m((vL,ad)=>{"use strict";var{Readable:id,Duplex:NR,PassThrough:GR}=require("node:stream"),{InvalidArgumentError:Qs,InvalidReturnValueError:MR,RequestAbortedError:Bc}=q(),We=O(),{AsyncResource:LR}=require("node:async_hooks"),{addSignal:vR,removeSignal:_R}=hs(),nd=require("node:assert"),EA=Symbol("resume"),Ic=class extends id{constructor(){super({autoDestroy:!0}),this[EA]=null}_read(){let{[EA]:e}=this;e&&(this[EA]=null,e())}_destroy(e,r){this._read(),r(e)}},Cc=class extends id{constructor(e){super({autoDestroy:!0}),this[EA]=e}_read(){this[EA]()}_destroy(e,r){!e&&!this._readableState.endEmitted&&(e=new Bc),r(e)}},pc=class extends LR{constructor(e,r){if(!e||typeof e!="object")throw new Qs("invalid opts");if(typeof r!="function")throw new Qs("invalid handler");let{signal:A,method:s,opaque:o,onInfo:n,responseHeaders:i}=e;if(A&&typeof A.on!="function"&&typeof A.addEventListener!="function")throw new Qs("signal must be an EventEmitter or EventTarget");if(s==="CONNECT")throw new Qs("invalid method");if(n&&typeof n!="function")throw new Qs("invalid onInfo callback");super("UNDICI_PIPELINE"),this.opaque=o||null,this.responseHeaders=i||null,this.handler=r,this.abort=null,this.context=null,this.onInfo=n||null,this.req=new Ic().on("error",We.nop),this.ret=new NR({readableObjectMode:e.objectMode,autoDestroy:!0,read:()=>{let{body:a}=this;a?.resume&&a.resume()},write:(a,c,u)=>{let{req:g}=this;g.push(a,c)||g._readableState.destroyed?u():g[EA]=u},destroy:(a,c)=>{let{body:u,req:g,res:E,ret:I,abort:d}=this;!a&&!I._readableState.endEmitted&&(a=new Bc),d&&a&&d(),We.destroy(u,a),We.destroy(g,a),We.destroy(E,a),_R(this),c(a)}}).on("prefinish",()=>{let{req:a}=this;a.push(null)}),this.res=null,vR(this,A)}onConnect(e,r){let{ret:A,res:s}=this;if(this.reason){e(this.reason);return}nd(!s,"pipeline cannot be retried"),nd(!A.destroyed),this.abort=e,this.context=r}onHeaders(e,r,A){let{opaque:s,handler:o,context:n}=this;if(e<200){if(this.onInfo){let a=this.responseHeaders==="raw"?We.parseRawHeaders(r):We.parseHeaders(r);this.onInfo({statusCode:e,headers:a})}return}this.res=new Cc(A);let i;try{this.handler=null;let a=this.responseHeaders==="raw"?We.parseRawHeaders(r):We.parseHeaders(r);i=this.runInAsyncScope(o,null,{statusCode:e,headers:a,opaque:s,body:this.res,context:n})}catch(a){throw this.res.on("error",We.nop),a}if(!i||typeof i.on!="function")throw new MR("expected Readable");i.on("data",a=>{let{ret:c,body:u}=this;!c.push(a)&&u.pause&&u.pause()}).on("error",a=>{let{ret:c}=this;We.destroy(c,a)}).on("end",()=>{let{ret:a}=this;a.push(null)}).on("close",()=>{let{ret:a}=this;a._readableState.ended||We.destroy(a,new Bc)}),this.body=i}onData(e){let{res:r}=this;return r.push(e)}onComplete(e){let{res:r}=this;r.push(null)}onError(e){let{ret:r}=this;this.handler=null,We.destroy(r,e)}};function xR(t,e){try{let r=new pc(t,e);return this.dispatch({...t,body:r.req},r),r.ret}catch(r){return new GR().destroy(r)}}ad.exports=xR});var Qd=m((_L,hd)=>{"use strict";var{InvalidArgumentError:fc,SocketError:YR}=q(),{AsyncResource:OR}=require("node:async_hooks"),gd=O(),{addSignal:JR,removeSignal:ud}=hs(),ld=require("node:assert"),mc=class extends OR{constructor(e,r){if(!e||typeof e!="object")throw new fc("invalid opts");if(typeof r!="function")throw new fc("invalid callback");let{signal:A,opaque:s,responseHeaders:o}=e;if(A&&typeof A.on!="function"&&typeof A.addEventListener!="function")throw new fc("signal must be an EventEmitter or EventTarget");super("UNDICI_UPGRADE"),this.responseHeaders=o||null,this.opaque=s||null,this.callback=r,this.abort=null,this.context=null,JR(this,A)}onConnect(e,r){if(this.reason){e(this.reason);return}ld(this.callback),this.abort=e,this.context=null}onHeaders(){throw new YR("bad upgrade",null)}onUpgrade(e,r,A){ld(e===101);let{callback:s,opaque:o,context:n}=this;ud(this),this.callback=null;let i=this.responseHeaders==="raw"?gd.parseRawHeaders(r):gd.parseHeaders(r);this.runInAsyncScope(s,null,null,{headers:i,socket:A,opaque:o,context:n})}onError(e){let{callback:r,opaque:A}=this;ud(this),r&&(this.callback=null,queueMicrotask(()=>{this.runInAsyncScope(r,null,e,{opaque:A})}))}};function Ed(t,e){if(e===void 0)return new Promise((r,A)=>{Ed.call(this,t,(s,o)=>s?A(s):r(o))});try{let r=new mc(t,e);this.dispatch({...t,method:t.method||"GET",upgrade:t.protocol||"Websocket"},r)}catch(r){if(typeof e!="function")throw r;let A=t?.opaque;queueMicrotask(()=>e(r,{opaque:A}))}}hd.exports=Ed});var pd=m((xL,Cd)=>{"use strict";var HR=require("node:assert"),{AsyncResource:PR}=require("node:async_hooks"),{InvalidArgumentError:wc,SocketError:VR}=q(),dd=O(),{addSignal:qR,removeSignal:Bd}=hs(),yc=class extends PR{constructor(e,r){if(!e||typeof e!="object")throw new wc("invalid opts");if(typeof r!="function")throw new wc("invalid callback");let{signal:A,opaque:s,responseHeaders:o}=e;if(A&&typeof A.on!="function"&&typeof A.addEventListener!="function")throw new wc("signal must be an EventEmitter or EventTarget");super("UNDICI_CONNECT"),this.opaque=s||null,this.responseHeaders=o||null,this.callback=r,this.abort=null,qR(this,A)}onConnect(e,r){if(this.reason){e(this.reason);return}HR(this.callback),this.abort=e,this.context=r}onHeaders(){throw new VR("bad connect",null)}onUpgrade(e,r,A){let{callback:s,opaque:o,context:n}=this;Bd(this),this.callback=null;let i=r;i!=null&&(i=this.responseHeaders==="raw"?dd.parseRawHeaders(r):dd.parseHeaders(r)),this.runInAsyncScope(s,null,null,{statusCode:e,headers:i,socket:A,opaque:o,context:n})}onError(e){let{callback:r,opaque:A}=this;Bd(this),r&&(this.callback=null,queueMicrotask(()=>{this.runInAsyncScope(r,null,e,{opaque:A})}))}};function Id(t,e){if(e===void 0)return new Promise((r,A)=>{Id.call(this,t,(s,o)=>s?A(s):r(o))});try{let r=new yc(t,e);this.dispatch({...t,method:"CONNECT"},r)}catch(r){if(typeof e!="function")throw r;let A=t?.opaque;queueMicrotask(()=>e(r,{opaque:A}))}}Cd.exports=Id});var fd=m((YL,hA)=>{"use strict";hA.exports.request=XQ();hA.exports.stream=od();hA.exports.pipeline=cd();hA.exports.upgrade=Qd();hA.exports.connect=pd()});var Dc=m((OL,wd)=>{"use strict";var{UndiciError:WR}=q(),md=Symbol.for("undici.error.UND_MOCK_ERR_MOCK_NOT_MATCHED"),bc=class t extends WR{constructor(e){super(e),Error.captureStackTrace(this,t),this.name="MockNotMatchedError",this.message=e||"The request does not match any registered mock dispatches",this.code="UND_MOCK_ERR_MOCK_NOT_MATCHED"}static[Symbol.hasInstance](e){return e&&e[md]===!0}[md]=!0};wd.exports={MockNotMatchedError:bc}});var QA=m((JL,yd)=>{"use strict";yd.exports={kAgent:Symbol("agent"),kOptions:Symbol("options"),kFactory:Symbol("factory"),kDispatches:Symbol("dispatches"),kDispatchKey:Symbol("dispatch key"),kDefaultHeaders:Symbol("default headers"),kDefaultTrailers:Symbol("default trailers"),kContentLength:Symbol("content length"),kMockAgent:Symbol("mock agent"),kMockAgentSet:Symbol("mock agent set"),kMockAgentGet:Symbol("mock agent get"),kMockDispatch:Symbol("mock dispatch"),kClose:Symbol("close"),kOriginalClose:Symbol("original agent close"),kOrigin:Symbol("origin"),kIsMockActive:Symbol("is mock active"),kNetConnect:Symbol("net connect"),kGetNetConnect:Symbol("get net connect"),kConnected:Symbol("connected")}});var ds=m((HL,Md)=>{"use strict";var{MockNotMatchedError:fr}=Dc(),{kDispatches:qo,kMockAgent:zR,kOriginalDispatch:ZR,kOrigin:KR,kGetNetConnect:jR}=QA(),{buildURL:XR}=O(),{STATUS_CODES:$R}=require("node:http"),{types:{isPromise:eT}}=require("node:util");function St(t,e){return typeof t=="string"?t===e:t instanceof RegExp?t.test(e):typeof t=="function"?t(e)===!0:!1}function Dd(t){return Object.fromEntries(Object.entries(t).map(([e,r])=>[e.toLocaleLowerCase(),r]))}function kd(t,e){if(Array.isArray(t)){for(let r=0;r"u")return!0;if(typeof e!="object"||typeof t.headers!="object")return!1;for(let[r,A]of Object.entries(t.headers)){let s=kd(e,r);if(!St(A,s))return!1}return!0}function bd(t){if(typeof t!="string")return t;let e=t.split("?");if(e.length!==2)return t;let r=new URLSearchParams(e.pop());return r.sort(),[...e,r.toString()].join("?")}function tT(t,{path:e,method:r,body:A,headers:s}){let o=St(t.path,e),n=St(t.method,r),i=typeof t.body<"u"?St(t.body,A):!0,a=Rd(t,s);return o&&n&&i&&a}function Td(t){return Buffer.isBuffer(t)||t instanceof Uint8Array||t instanceof ArrayBuffer?t:typeof t=="object"?JSON.stringify(t):t.toString()}function Fd(t,e){let r=e.query?XR(e.path,e.query):e.path,A=typeof r=="string"?bd(r):r,s=t.filter(({consumed:o})=>!o).filter(({path:o})=>St(bd(o),A));if(s.length===0)throw new fr(`Mock dispatch not matched for path '${A}'`);if(s=s.filter(({method:o})=>St(o,e.method)),s.length===0)throw new fr(`Mock dispatch not matched for method '${e.method}' on path '${A}'`);if(s=s.filter(({body:o})=>typeof o<"u"?St(o,e.body):!0),s.length===0)throw new fr(`Mock dispatch not matched for body '${e.body}' on path '${A}'`);if(s=s.filter(o=>Rd(o,e.headers)),s.length===0){let o=typeof e.headers=="object"?JSON.stringify(e.headers):e.headers;throw new fr(`Mock dispatch not matched for headers '${o}' on path '${A}'`)}return s[0]}function rT(t,e,r){let A={timesInvoked:0,times:1,persist:!1,consumed:!1},s=typeof r=="function"?{callback:r}:{...r},o={...A,...e,pending:!0,data:{error:null,...s}};return t.push(o),o}function kc(t,e){let r=t.findIndex(A=>A.consumed?tT(A,e):!1);r!==-1&&t.splice(r,1)}function Sd(t){let{path:e,method:r,body:A,headers:s,query:o}=t;return{path:e,method:r,body:A,headers:s,query:o}}function Rc(t){let e=Object.keys(t),r=[];for(let A=0;A=E,A.pending=g0?setTimeout(()=>{I(this[qo])},c):I(this[qo]);function I(p,y=o){let B=Array.isArray(t.headers)?Tc(t.headers):t.headers,w=typeof y=="function"?y({...t,headers:B}):y;if(eT(w)){w.then(j=>I(p,j));return}let T=Td(w),S=Rc(n),J=Rc(i);e.onConnect?.(j=>e.onError(j),null),e.onHeaders?.(s,S,d,Ud(s)),e.onData?.(Buffer.from(T)),e.onComplete?.(J),kc(p,r)}function d(){}return!0}function sT(){let t=this[zR],e=this[KR],r=this[ZR];return function(s,o){if(t.isMockActive)try{Nd.call(this,s,o)}catch(n){if(n instanceof fr){let i=t[jR]();if(i===!1)throw new fr(`${n.message}: subsequent request to origin ${e} was not allowed (net.connect disabled)`);if(Gd(i,e))r.call(this,s,o);else throw new fr(`${n.message}: subsequent request to origin ${e} was not allowed (net.connect is not enabled for this origin)`)}else throw n}else r.call(this,s,o)}}function Gd(t,e){let r=new URL(e);return t===!0?!0:!!(Array.isArray(t)&&t.some(A=>St(A,r.host)))}function oT(t){if(t){let{agent:e,...r}=t;return r}}Md.exports={getResponseData:Td,getMockDispatch:Fd,addMockDispatch:rT,deleteMockDispatch:kc,buildKey:Sd,generateKeyValues:Rc,matchValue:St,getResponse:AT,getStatusText:Ud,mockDispatch:Nd,buildMockDispatch:sT,checkNetConnect:Gd,buildMockOptions:oT,getHeaderByName:kd,buildHeadersFromArray:Tc}});var Lc=m((PL,Mc)=>{"use strict";var{getResponseData:nT,buildKey:iT,addMockDispatch:Fc}=ds(),{kDispatches:Wo,kDispatchKey:zo,kDefaultHeaders:Sc,kDefaultTrailers:Uc,kContentLength:Nc,kMockDispatch:Zo}=QA(),{InvalidArgumentError:Qt}=q(),{buildURL:aT}=O(),dA=class{constructor(e){this[Zo]=e}delay(e){if(typeof e!="number"||!Number.isInteger(e)||e<=0)throw new Qt("waitInMs must be a valid integer > 0");return this[Zo].delay=e,this}persist(){return this[Zo].persist=!0,this}times(e){if(typeof e!="number"||!Number.isInteger(e)||e<=0)throw new Qt("repeatTimes must be a valid integer > 0");return this[Zo].times=e,this}},Gc=class{constructor(e,r){if(typeof e!="object")throw new Qt("opts must be an object");if(typeof e.path>"u")throw new Qt("opts.path must be defined");if(typeof e.method>"u"&&(e.method="GET"),typeof e.path=="string")if(e.query)e.path=aT(e.path,e.query);else{let A=new URL(e.path,"data://");e.path=A.pathname+A.search}typeof e.method=="string"&&(e.method=e.method.toUpperCase()),this[zo]=iT(e),this[Wo]=r,this[Sc]={},this[Uc]={},this[Nc]=!1}createMockScopeDispatchData({statusCode:e,data:r,responseOptions:A}){let s=nT(r),o=this[Nc]?{"content-length":s.length}:{},n={...this[Sc],...o,...A.headers},i={...this[Uc],...A.trailers};return{statusCode:e,data:r,headers:n,trailers:i}}validateReplyParameters(e){if(typeof e.statusCode>"u")throw new Qt("statusCode must be defined");if(typeof e.responseOptions!="object"||e.responseOptions===null)throw new Qt("responseOptions must be an object")}reply(e){if(typeof e=="function"){let o=i=>{let a=e(i);if(typeof a!="object"||a===null)throw new Qt("reply options callback must return an object");let c={data:"",responseOptions:{},...a};return this.validateReplyParameters(c),{...this.createMockScopeDispatchData(c)}},n=Fc(this[Wo],this[zo],o);return new dA(n)}let r={statusCode:e,data:arguments[1]===void 0?"":arguments[1],responseOptions:arguments[2]===void 0?{}:arguments[2]};this.validateReplyParameters(r);let A=this.createMockScopeDispatchData(r),s=Fc(this[Wo],this[zo],A);return new dA(s)}replyWithError(e){if(typeof e>"u")throw new Qt("error must be defined");let r=Fc(this[Wo],this[zo],{error:e});return new dA(r)}defaultReplyHeaders(e){if(typeof e>"u")throw new Qt("headers must be defined");return this[Sc]=e,this}defaultReplyTrailers(e){if(typeof e>"u")throw new Qt("trailers must be defined");return this[Uc]=e,this}replyContentLength(){return this[Nc]=!0,this}};Mc.exports.MockInterceptor=Gc;Mc.exports.MockScope=dA});var xc=m((VL,Jd)=>{"use strict";var{promisify:cT}=require("node:util"),gT=oA(),{buildMockDispatch:uT}=ds(),{kDispatches:Ld,kMockAgent:vd,kClose:_d,kOriginalClose:xd,kOrigin:Yd,kOriginalDispatch:lT,kConnected:vc}=QA(),{MockInterceptor:ET}=Lc(),Od=se(),{InvalidArgumentError:hT}=q(),_c=class extends gT{constructor(e,r){if(super(e,r),!r||!r.agent||typeof r.agent.dispatch!="function")throw new hT("Argument opts.agent must implement Agent");this[vd]=r.agent,this[Yd]=e,this[Ld]=[],this[vc]=1,this[lT]=this.dispatch,this[xd]=this.close.bind(this),this.dispatch=uT.call(this),this.close=this[_d]}get[Od.kConnected](){return this[vc]}intercept(e){return new ET(e,this[Ld])}async[_d](){await cT(this[xd])(),this[vc]=0,this[vd][Od.kClients].delete(this[Yd])}};Jd.exports=_c});var Jc=m((qL,Zd)=>{"use strict";var{promisify:QT}=require("node:util"),dT=nA(),{buildMockDispatch:BT}=ds(),{kDispatches:Hd,kMockAgent:Pd,kClose:Vd,kOriginalClose:qd,kOrigin:Wd,kOriginalDispatch:IT,kConnected:Yc}=QA(),{MockInterceptor:CT}=Lc(),zd=se(),{InvalidArgumentError:pT}=q(),Oc=class extends dT{constructor(e,r){if(super(e,r),!r||!r.agent||typeof r.agent.dispatch!="function")throw new pT("Argument opts.agent must implement Agent");this[Pd]=r.agent,this[Wd]=e,this[Hd]=[],this[Yc]=1,this[IT]=this.dispatch,this[qd]=this.close.bind(this),this.dispatch=BT.call(this),this.close=this[Vd]}get[zd.kConnected](){return this[Yc]}intercept(e){return new CT(e,this[Hd])}async[Vd](){await QT(this[qd])(),this[Yc]=0,this[Pd][zd.kClients].delete(this[Wd])}};Zd.exports=Oc});var jd=m((zL,Kd)=>{"use strict";var fT={pronoun:"it",is:"is",was:"was",this:"this"},mT={pronoun:"they",is:"are",was:"were",this:"these"};Kd.exports=class{constructor(e,r){this.singular=e,this.plural=r}pluralize(e){let r=e===1,A=r?fT:mT,s=r?this.singular:this.plural;return{...A,count:e,noun:s}}}});var $d=m((KL,Xd)=>{"use strict";var{Transform:wT}=require("node:stream"),{Console:yT}=require("node:console"),bT=process.versions.icu?"\u2705":"Y ",DT=process.versions.icu?"\u274C":"N ";Xd.exports=class{constructor({disableColors:e}={}){this.transform=new wT({transform(r,A,s){s(null,r)}}),this.logger=new yT({stdout:this.transform,inspectOptions:{colors:!e&&!process.env.CI}})}format(e){let r=e.map(({method:A,path:s,data:{statusCode:o},persist:n,times:i,timesInvoked:a,origin:c})=>({Method:A,Origin:c,Path:s,"Status code":o,Persistent:n?bT:DT,Invocations:a,Remaining:n?1/0:i-a}));return this.logger.table(r),this.transform.read().toString()}}});var AB=m((jL,rB)=>{"use strict";var{kClients:mr}=se(),kT=iA(),{kAgent:Hc,kMockAgentSet:Ko,kMockAgentGet:eB,kDispatches:Pc,kIsMockActive:jo,kNetConnect:wr,kGetNetConnect:RT,kOptions:Xo,kFactory:$o}=QA(),TT=xc(),FT=Jc(),{matchValue:ST,buildMockOptions:UT}=ds(),{InvalidArgumentError:tB,UndiciError:NT}=q(),GT=xA(),MT=jd(),LT=$d(),Vc=class extends GT{constructor(e){if(super(e),this[wr]=!0,this[jo]=!0,e?.agent&&typeof e.agent.dispatch!="function")throw new tB("Argument opts.agent must implement Agent");let r=e?.agent?e.agent:new kT(e);this[Hc]=r,this[mr]=r[mr],this[Xo]=UT(e)}get(e){let r=this[eB](e);return r||(r=this[$o](e),this[Ko](e,r)),r}dispatch(e,r){return this.get(e.origin),this[Hc].dispatch(e,r)}async close(){await this[Hc].close(),this[mr].clear()}deactivate(){this[jo]=!1}activate(){this[jo]=!0}enableNetConnect(e){if(typeof e=="string"||typeof e=="function"||e instanceof RegExp)Array.isArray(this[wr])?this[wr].push(e):this[wr]=[e];else if(typeof e>"u")this[wr]=!0;else throw new tB("Unsupported matcher. Must be one of String|Function|RegExp.")}disableNetConnect(){this[wr]=!1}get isMockActive(){return this[jo]}[Ko](e,r){this[mr].set(e,r)}[$o](e){let r=Object.assign({agent:this},this[Xo]);return this[Xo]&&this[Xo].connections===1?new TT(e,r):new FT(e,r)}[eB](e){let r=this[mr].get(e);if(r)return r;if(typeof e!="string"){let A=this[$o]("http://localhost:9999");return this[Ko](e,A),A}for(let[A,s]of Array.from(this[mr]))if(s&&typeof A!="string"&&ST(A,e)){let o=this[$o](e);return this[Ko](e,o),o[Pc]=s[Pc],o}}[RT](){return this[wr]}pendingInterceptors(){let e=this[mr];return Array.from(e.entries()).flatMap(([r,A])=>A[Pc].map(s=>({...s,origin:r}))).filter(({pending:r})=>r)}assertNoPendingInterceptors({pendingInterceptorsFormatter:e=new LT}={}){let r=this.pendingInterceptors();if(r.length===0)return;let A=new MT("interceptor","interceptors").pluralize(r.length);throw new NT(` ${A.count} ${A.noun} ${A.is} pending: ${e.format(r)} -`.trim())}};ZB.exports=Yc});var jo=m((xL,ed)=>{"use strict";var jB=Symbol.for("undici.globalDispatcher.1"),{InvalidArgumentError:D0}=q(),R0=sA();$B()===void 0&&XB(new R0);function XB(t){if(!t||typeof t.dispatch!="function")throw new D0("Argument agent must implement Agent");Object.defineProperty(globalThis,jB,{value:t,writable:!0,enumerable:!1,configurable:!1})}function $B(){return globalThis[jB]}ed.exports={setGlobalDispatcher:XB,getGlobalDispatcher:$B}});var Xo=m((JL,td)=>{"use strict";td.exports=class{#e;constructor(e){if(typeof e!="object"||e===null)throw new TypeError("handler must be an object");this.#e=e}onConnect(...e){return this.#e.onConnect?.(...e)}onError(...e){return this.#e.onError?.(...e)}onUpgrade(...e){return this.#e.onUpgrade?.(...e)}onResponseStarted(...e){return this.#e.onResponseStarted?.(...e)}onHeaders(...e){return this.#e.onHeaders?.(...e)}onData(...e){return this.#e.onData?.(...e)}onComplete(...e){return this.#e.onComplete?.(...e)}onBodySent(...e){return this.#e.onBodySent?.(...e)}}});var Ad=m((OL,rd)=>{"use strict";var T0=Fo();rd.exports=t=>{let e=t?.maxRedirections;return r=>function(s,o){let{maxRedirections:n=e,...i}=s;if(!n)return r(s,o);let a=new T0(r,n,s,o);return r(i,a)}}});var od=m((HL,sd)=>{"use strict";var F0=Jo();sd.exports=t=>e=>function(A,s){return e(A,new F0({...A,retryOptions:{...t,...A.retryOptions}},{handler:s,dispatch:e}))}});var id=m((PL,nd)=>{"use strict";var S0=J(),{InvalidArgumentError:U0,RequestAbortedError:N0}=q(),G0=Xo(),Jc=class extends G0{#e=1024*1024;#t=null;#r=!1;#o=!1;#s=0;#A=null;#n=null;constructor({maxSize:e},r){if(super(r),e!=null&&(!Number.isFinite(e)||e<1))throw new U0("maxSize must be a number greater than 0");this.#e=e??this.#e,this.#n=r}onConnect(e){this.#t=e,this.#n.onConnect(this.#i.bind(this))}#i(e){this.#o=!0,this.#A=e}onHeaders(e,r,A,s){let n=S0.parseHeaders(r)["content-length"];if(n!=null&&n>this.#e)throw new N0(`Response size (${n}) larger than maxSize (${this.#e})`);return this.#o?!0:this.#n.onHeaders(e,r,A,s)}onError(e){this.#r||(e=this.#A??e,this.#n.onError(e))}onData(e){return this.#s=this.#s+e.length,this.#s>=this.#e&&(this.#r=!0,this.#o?this.#n.onError(this.#A):this.#n.onComplete([])),!0}onComplete(e){if(!this.#r){if(this.#o){this.#n.onError(this.reason);return}this.#n.onComplete(e)}}};function M0({maxSize:t}={maxSize:1024*1024}){return e=>function(A,s){let{dumpMaxSize:o=t}=A,n=new Jc({maxSize:o},s);return e(A,n)}}nd.exports=M0});var gd=m((VL,cd)=>{"use strict";var{isIP:L0}=require("node:net"),{lookup:v0}=require("node:dns"),_0=Xo(),{InvalidArgumentError:hA,InformationalError:x0}=q(),ad=Math.pow(2,31)-1,Oc=class{#e=0;#t=0;#r=new Map;dualStack=!0;affinity=null;lookup=null;pick=null;constructor(e){this.#e=e.maxTTL,this.#t=e.maxItems,this.dualStack=e.dualStack,this.affinity=e.affinity,this.lookup=e.lookup??this.#o,this.pick=e.pick??this.#s}get full(){return this.#r.size===this.#t}runLookup(e,r,A){let s=this.#r.get(e.hostname);if(s==null&&this.full){A(null,e.origin);return}let o={affinity:this.affinity,dualStack:this.dualStack,lookup:this.lookup,pick:this.pick,...r.dns,maxTTL:this.#e,maxItems:this.#t};if(s==null)this.lookup(e,o,(n,i)=>{if(n||i==null||i.length===0){A(n??new x0("No DNS entries found"));return}this.setRecords(e,i);let a=this.#r.get(e.hostname),c=this.pick(e,a,o.affinity),l;typeof c.port=="number"?l=`:${c.port}`:e.port!==""?l=`:${e.port}`:l="",A(null,`${e.protocol}//${c.family===6?`[${c.address}]`:c.address}${l}`)});else{let n=this.pick(e,s,o.affinity);if(n==null){this.#r.delete(e.hostname),this.runLookup(e,r,A);return}let i;typeof n.port=="number"?i=`:${n.port}`:e.port!==""?i=`:${e.port}`:i="",A(null,`${e.protocol}//${n.family===6?`[${n.address}]`:n.address}${i}`)}}#o(e,r,A){v0(e.hostname,{all:!0,family:this.dualStack===!1?this.affinity:0,order:"ipv4first"},(s,o)=>{if(s)return A(s);let n=new Map;for(let i of o)n.set(`${i.address}:${i.family}`,i);A(null,n.values())})}#s(e,r,A){let s=null,{records:o,offset:n}=r,i;if(this.dualStack?(A==null&&(n==null||n===ad?(r.offset=0,A=4):(r.offset++,A=(r.offset&1)===1?6:4)),o[A]!=null&&o[A].ips.length>0?i=o[A]:i=o[A===4?6:4]):i=o[A],i==null||i.ips.length===0)return s;i.offset==null||i.offset===ad?i.offset=0:i.offset++;let a=i.offset%i.ips.length;return s=i.ips[a]??null,s==null?s:Date.now()-s.timestamp>s.ttl?(i.ips.splice(a,1),this.pick(e,r,A)):s}setRecords(e,r){let A=Date.now(),s={records:{4:null,6:null}};for(let o of r){o.timestamp=A,typeof o.ttl=="number"?o.ttl=Math.min(o.ttl,this.#e):o.ttl=this.#e;let n=s.records[o.family]??{ips:[]};n.ips.push(o),s.records[o.family]=n}this.#r.set(e.hostname,s)}getHandler(e,r){return new Hc(this,e,r)}},Hc=class extends _0{#e=null;#t=null;#r=null;#o=null;#s=null;constructor(e,{origin:r,handler:A,dispatch:s},o){super(A),this.#s=r,this.#o=A,this.#t={...o},this.#e=e,this.#r=s}onError(e){switch(e.code){case"ETIMEDOUT":case"ECONNREFUSED":{if(this.#e.dualStack){this.#e.runLookup(this.#s,this.#t,(r,A)=>{if(r)return this.#o.onError(r);let s={...this.#t,origin:A};this.#r(s,this)});return}this.#o.onError(e);return}case"ENOTFOUND":this.#e.deleteRecord(this.#s);default:this.#o.onError(e);break}}};cd.exports=t=>{if(t?.maxTTL!=null&&(typeof t?.maxTTL!="number"||t?.maxTTL<0))throw new hA("Invalid maxTTL. Must be a positive number");if(t?.maxItems!=null&&(typeof t?.maxItems!="number"||t?.maxItems<1))throw new hA("Invalid maxItems. Must be a positive number and greater than zero");if(t?.affinity!=null&&t?.affinity!==4&&t?.affinity!==6)throw new hA("Invalid affinity. Must be either 4 or 6");if(t?.dualStack!=null&&typeof t?.dualStack!="boolean")throw new hA("Invalid dualStack. Must be a boolean");if(t?.lookup!=null&&typeof t?.lookup!="function")throw new hA("Invalid lookup. Must be a function");if(t?.pick!=null&&typeof t?.pick!="function")throw new hA("Invalid pick. Must be a function");let e=t?.dualStack??!0,r;e?r=t?.affinity??null:r=t?.affinity??4;let A={maxTTL:t?.maxTTL??1e4,lookup:t?.lookup??null,pick:t?.pick??null,dualStack:e,affinity:r,maxItems:t?.maxItems??1/0},s=new Oc(A);return o=>function(i,a){let c=i.origin.constructor===URL?i.origin:new URL(i.origin);return L0(c.hostname)!==0?o(i,a):(s.runLookup(c,i,(l,g)=>{if(l)return a.onError(l);let E=null;E={...i,servername:c.hostname,origin:g,headers:{host:c.hostname,...i.headers}},o(E,s.getHandler({origin:c,dispatch:o,handler:a},i))}),!0)}}});var fr=m((qL,dd)=>{"use strict";var{kConstruct:Y0}=se(),{kEnumerableProperty:QA}=J(),{iteratorMixin:J0,isValidHeaderName:Qs,isValidHeaderValue:ld}=Fe(),{webidl:V}=de(),Pc=require("node:assert"),$o=require("node:util"),ue=Symbol("headers map"),Ge=Symbol("headers map sorted");function ud(t){return t===10||t===13||t===9||t===32}function Ed(t){let e=0,r=t.length;for(;r>e&&ud(t.charCodeAt(r-1));)--r;for(;r>e&&ud(t.charCodeAt(e));)++e;return e===0&&r===t.length?t:t.substring(e,r)}function hd(t,e){if(Array.isArray(e))for(let r=0;r>","record"]})}function Vc(t,e,r){if(r=Ed(r),Qs(e)){if(!ld(r))throw V.errors.invalidArgument({prefix:"Headers.append",value:r,type:"header value"})}else throw V.errors.invalidArgument({prefix:"Headers.append",value:e,type:"header name"});if(Bd(t)==="immutable")throw new TypeError("immutable");return qc(t).append(e,r,!1)}function Qd(t,e){return t[0]>1),r[c][0]<=l[0]?a=c+1:i=c;if(o!==c){for(n=o;n>a;)r[n]=r[--n];r[a]=l}}if(!A.next().done)throw new TypeError("Unreachable");return r}else{let A=0;for(let{0:s,1:{value:o}}of this[ue])r[A++]=[s,o],Pc(o!==null);return r.sort(Qd)}}},rt=class t{#e;#t;constructor(e=void 0){V.util.markAsUncloneable(this),e!==Y0&&(this.#t=new en,this.#e="none",e!==void 0&&(e=V.converters.HeadersInit(e,"Headers contructor","init"),hd(this,e)))}append(e,r){V.brandCheck(this,t),V.argumentLengthCheck(arguments,2,"Headers.append");let A="Headers.append";return e=V.converters.ByteString(e,A,"name"),r=V.converters.ByteString(r,A,"value"),Vc(this,e,r)}delete(e){if(V.brandCheck(this,t),V.argumentLengthCheck(arguments,1,"Headers.delete"),e=V.converters.ByteString(e,"Headers.delete","name"),!Qs(e))throw V.errors.invalidArgument({prefix:"Headers.delete",value:e,type:"header name"});if(this.#e==="immutable")throw new TypeError("immutable");this.#t.contains(e,!1)&&this.#t.delete(e,!1)}get(e){V.brandCheck(this,t),V.argumentLengthCheck(arguments,1,"Headers.get");let r="Headers.get";if(e=V.converters.ByteString(e,r,"name"),!Qs(e))throw V.errors.invalidArgument({prefix:r,value:e,type:"header name"});return this.#t.get(e,!1)}has(e){V.brandCheck(this,t),V.argumentLengthCheck(arguments,1,"Headers.has");let r="Headers.has";if(e=V.converters.ByteString(e,r,"name"),!Qs(e))throw V.errors.invalidArgument({prefix:r,value:e,type:"header name"});return this.#t.contains(e,!1)}set(e,r){V.brandCheck(this,t),V.argumentLengthCheck(arguments,2,"Headers.set");let A="Headers.set";if(e=V.converters.ByteString(e,A,"name"),r=V.converters.ByteString(r,A,"value"),r=Ed(r),Qs(e)){if(!ld(r))throw V.errors.invalidArgument({prefix:A,value:r,type:"header value"})}else throw V.errors.invalidArgument({prefix:A,value:e,type:"header name"});if(this.#e==="immutable")throw new TypeError("immutable");this.#t.set(e,r,!1)}getSetCookie(){V.brandCheck(this,t);let e=this.#t.cookies;return e?[...e]:[]}get[Ge](){if(this.#t[Ge])return this.#t[Ge];let e=[],r=this.#t.toSortedArray(),A=this.#t.cookies;if(A===null||A.length===1)return this.#t[Ge]=r;for(let s=0;s>"](t,e,r,A.bind(t)):V.converters["record"](t,e,r)}throw V.errors.conversionFailed({prefix:"Headers constructor",argument:"Argument 1",types:["sequence>","record"]})};dd.exports={fill:hd,compareHeaderName:Qd,Headers:rt,HeadersList:en,getHeadersGuard:Bd,setHeadersGuard:O0,setHeadersList:H0,getHeadersList:qc}});var ds=m((WL,Td)=>{"use strict";var{Headers:wd,HeadersList:Id,fill:P0,getHeadersGuard:V0,setHeadersGuard:yd,setHeadersList:bd}=fr(),{extractBody:Cd,cloneBody:q0,mixinBody:W0,hasFinalizationRegistry:kd,streamRegistry:Dd,bodyUnusable:z0}=Zr(),Wc=J(),pd=require("node:util"),{kEnumerableProperty:Me}=Wc,{isValidReasonPhrase:Z0,isCancelled:K0,isAborted:j0,isBlobLike:X0,serializeJavascriptValueToJSONString:$0,isErrorLike:eT,isomorphicEncode:tT,environmentSettingsObject:rT}=Fe(),{redirectStatusSet:AT,nullBodyStatus:sT}=YA(),{kState:ne,kHeaders:St}=xt(),{webidl:Y}=de(),{FormData:oT}=qA(),{URLSerializer:fd}=ye(),{kConstruct:rn}=se(),zc=require("node:assert"),{types:nT}=require("node:util"),iT=new TextEncoder("utf-8"),mr=class t{static error(){return Bs(An(),"immutable")}static json(e,r={}){Y.argumentLengthCheck(arguments,1,"Response.json"),r!==null&&(r=Y.converters.ResponseInit(r));let A=iT.encode($0(e)),s=Cd(A),o=Bs(BA({}),"response");return md(o,r,{body:s[0],type:"application/json"}),o}static redirect(e,r=302){Y.argumentLengthCheck(arguments,1,"Response.redirect"),e=Y.converters.USVString(e),r=Y.converters["unsigned short"](r);let A;try{A=new URL(e,rT.settingsObject.baseUrl)}catch(n){throw new TypeError(`Failed to parse URL from ${e}`,{cause:n})}if(!AT.has(r))throw new RangeError(`Invalid status code ${r}`);let s=Bs(BA({}),"immutable");s[ne].status=r;let o=tT(fd(A));return s[ne].headersList.append("location",o,!0),s}constructor(e=null,r={}){if(Y.util.markAsUncloneable(this),e===rn)return;e!==null&&(e=Y.converters.BodyInit(e)),r=Y.converters.ResponseInit(r),this[ne]=BA({}),this[St]=new wd(rn),yd(this[St],"response"),bd(this[St],this[ne].headersList);let A=null;if(e!=null){let[s,o]=Cd(e);A={body:s,type:o}}md(this,r,A)}get type(){return Y.brandCheck(this,t),this[ne].type}get url(){Y.brandCheck(this,t);let e=this[ne].urlList,r=e[e.length-1]??null;return r===null?"":fd(r,!0)}get redirected(){return Y.brandCheck(this,t),this[ne].urlList.length>1}get status(){return Y.brandCheck(this,t),this[ne].status}get ok(){return Y.brandCheck(this,t),this[ne].status>=200&&this[ne].status<=299}get statusText(){return Y.brandCheck(this,t),this[ne].statusText}get headers(){return Y.brandCheck(this,t),this[St]}get body(){return Y.brandCheck(this,t),this[ne].body?this[ne].body.stream:null}get bodyUsed(){return Y.brandCheck(this,t),!!this[ne].body&&Wc.isDisturbed(this[ne].body.stream)}clone(){if(Y.brandCheck(this,t),z0(this))throw Y.errors.exception({header:"Response.clone",message:"Body has already been consumed."});let e=Zc(this[ne]);return kd&&this[ne].body?.stream&&Dd.register(this,new WeakRef(this[ne].body.stream)),Bs(e,V0(this[St]))}[pd.inspect.custom](e,r){r.depth===null&&(r.depth=2),r.colors??=!0;let A={status:this.status,statusText:this.statusText,headers:this.headers,body:this.body,bodyUsed:this.bodyUsed,ok:this.ok,redirected:this.redirected,type:this.type,url:this.url};return`Response ${pd.formatWithOptions(r,A)}`}};W0(mr);Object.defineProperties(mr.prototype,{type:Me,url:Me,status:Me,ok:Me,redirected:Me,statusText:Me,headers:Me,clone:Me,body:Me,bodyUsed:Me,[Symbol.toStringTag]:{value:"Response",configurable:!0}});Object.defineProperties(mr,{json:Me,redirect:Me,error:Me});function Zc(t){if(t.internalResponse)return Rd(Zc(t.internalResponse),t.type);let e=BA({...t,body:null});return t.body!=null&&(e.body=q0(e,t.body)),e}function BA(t){return{aborted:!1,rangeRequested:!1,timingAllowPassed:!1,requestIncludesCredentials:!1,type:"default",status:200,timingInfo:null,cacheState:"",statusText:"",...t,headersList:t?.headersList?new Id(t?.headersList):new Id,urlList:t?.urlList?[...t.urlList]:[]}}function An(t){let e=eT(t);return BA({type:"error",status:0,error:e?t:new Error(t&&String(t)),aborted:t&&t.name==="AbortError"})}function aT(t){return t.type==="error"&&t.status===0}function tn(t,e){return e={internalResponse:t,...e},new Proxy(t,{get(r,A){return A in e?e[A]:r[A]},set(r,A,s){return zc(!(A in e)),r[A]=s,!0}})}function Rd(t,e){if(e==="basic")return tn(t,{type:"basic",headersList:t.headersList});if(e==="cors")return tn(t,{type:"cors",headersList:t.headersList});if(e==="opaque")return tn(t,{type:"opaque",urlList:Object.freeze([]),status:0,statusText:"",body:null});if(e==="opaqueredirect")return tn(t,{type:"opaqueredirect",status:0,statusText:"",headersList:[],body:null});zc(!1)}function cT(t,e=null){return zc(K0(t)),j0(t)?An(Object.assign(new DOMException("The operation was aborted.","AbortError"),{cause:e})):An(Object.assign(new DOMException("Request was cancelled."),{cause:e}))}function md(t,e,r){if(e.status!==null&&(e.status<200||e.status>599))throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.');if("statusText"in e&&e.statusText!=null&&!Z0(String(e.statusText)))throw new TypeError("Invalid statusText");if("status"in e&&e.status!=null&&(t[ne].status=e.status),"statusText"in e&&e.statusText!=null&&(t[ne].statusText=e.statusText),"headers"in e&&e.headers!=null&&P0(t[St],e.headers),r){if(sT.includes(t.status))throw Y.errors.exception({header:"Response constructor",message:`Invalid response status code ${t.status}`});t[ne].body=r.body,r.type!=null&&!t[ne].headersList.contains("content-type",!0)&&t[ne].headersList.append("content-type",r.type,!0)}}function Bs(t,e){let r=new mr(rn);return r[ne]=t,r[St]=new wd(rn),bd(r[St],t.headersList),yd(r[St],e),kd&&t.body?.stream&&Dd.register(r,new WeakRef(t.body.stream)),r}Y.converters.ReadableStream=Y.interfaceConverter(ReadableStream);Y.converters.FormData=Y.interfaceConverter(oT);Y.converters.URLSearchParams=Y.interfaceConverter(URLSearchParams);Y.converters.XMLHttpRequestBodyInit=function(t,e,r){return typeof t=="string"?Y.converters.USVString(t,e,r):X0(t)?Y.converters.Blob(t,e,r,{strict:!1}):ArrayBuffer.isView(t)||nT.isArrayBuffer(t)?Y.converters.BufferSource(t,e,r):Wc.isFormDataLike(t)?Y.converters.FormData(t,e,r,{strict:!1}):t instanceof URLSearchParams?Y.converters.URLSearchParams(t,e,r):Y.converters.DOMString(t,e,r)};Y.converters.BodyInit=function(t,e,r){return t instanceof ReadableStream?Y.converters.ReadableStream(t,e,r):t?.[Symbol.asyncIterator]?t:Y.converters.XMLHttpRequestBodyInit(t,e,r)};Y.converters.ResponseInit=Y.dictionaryConverter([{key:"status",converter:Y.converters["unsigned short"],defaultValue:()=>200},{key:"statusText",converter:Y.converters.ByteString,defaultValue:()=>""},{key:"headers",converter:Y.converters.HeadersInit}]);Td.exports={isNetworkError:aT,makeNetworkError:An,makeResponse:BA,makeAppropriateNetworkError:cT,filterResponse:Rd,Response:mr,cloneResponse:Zc,fromInnerResponse:Bs}});var Nd=m((zL,Ud)=>{"use strict";var{kConnected:Fd,kSize:Sd}=se(),Kc=class{constructor(e){this.value=e}deref(){return this.value[Fd]===0&&this.value[Sd]===0?void 0:this.value}},jc=class{constructor(e){this.finalizer=e}register(e,r){e.on&&e.on("disconnect",()=>{e[Fd]===0&&e[Sd]===0&&this.finalizer(r)})}unregister(e){}};Ud.exports=function(){return process.env.NODE_V8_COVERAGE&&process.version.startsWith("v18")?(process._rawDebug("Using compatibility WeakRef and FinalizationRegistry"),{WeakRef:Kc,FinalizationRegistry:jc}):{WeakRef,FinalizationRegistry}}});var dA=m((ZL,zd)=>{"use strict";var{extractBody:gT,mixinBody:uT,cloneBody:lT,bodyUnusable:Gd}=Zr(),{Headers:Hd,fill:ET,HeadersList:an,setHeadersGuard:$c,getHeadersGuard:hT,setHeadersList:Pd,getHeadersList:Md}=fr(),{FinalizationRegistry:QT}=Nd()(),on=J(),Ld=require("node:util"),{isValidHTTPToken:BT,sameOrigin:vd,environmentSettingsObject:sn}=Fe(),{forbiddenMethodsSet:dT,corsSafeListedMethodsSet:IT,referrerPolicy:CT,requestRedirect:pT,requestMode:fT,requestCredentials:mT,requestCache:wT,requestDuplex:yT}=YA(),{kEnumerableProperty:le,normalizedMethodRecordsBase:bT,normalizedMethodRecords:kT}=on,{kHeaders:Le,kSignal:nn,kState:Ae,kDispatcher:Xc}=xt(),{webidl:v}=de(),{URLSerializer:DT}=ye(),{kConstruct:cn}=se(),RT=require("node:assert"),{getMaxListeners:_d,setMaxListeners:xd,getEventListeners:TT,defaultMaxListeners:Yd}=require("node:events"),FT=Symbol("abortController"),Vd=new QT(({signal:t,abort:e})=>{t.removeEventListener("abort",e)}),gn=new WeakMap;function Jd(t){return e;function e(){let r=t.deref();if(r!==void 0){Vd.unregister(e),this.removeEventListener("abort",e),r.abort(this.reason);let A=gn.get(r.signal);if(A!==void 0){if(A.size!==0){for(let s of A){let o=s.deref();o!==void 0&&o.abort(this.reason)}A.clear()}gn.delete(r.signal)}}}}var Od=!1,Kt=class t{constructor(e,r={}){if(v.util.markAsUncloneable(this),e===cn)return;let A="Request constructor";v.argumentLengthCheck(arguments,1,A),e=v.converters.RequestInfo(e,A,"input"),r=v.converters.RequestInit(r,A,"init");let s=null,o=null,n=sn.settingsObject.baseUrl,i=null;if(typeof e=="string"){this[Xc]=r.dispatcher;let I;try{I=new URL(e,n)}catch(y){throw new TypeError("Failed to parse URL from "+e,{cause:y})}if(I.username||I.password)throw new TypeError("Request cannot be constructed from a URL that includes credentials: "+e);s=un({urlList:[I]}),o="cors"}else this[Xc]=r.dispatcher||e[Xc],RT(e instanceof t),s=e[Ae],i=e[nn];let a=sn.settingsObject.origin,c="client";if(s.window?.constructor?.name==="EnvironmentSettingsObject"&&vd(s.window,a)&&(c=s.window),r.window!=null)throw new TypeError(`'window' option '${c}' must be null`);"window"in r&&(c="no-window"),s=un({method:s.method,headersList:s.headersList,unsafeRequest:s.unsafeRequest,client:sn.settingsObject,window:c,priority:s.priority,origin:s.origin,referrer:s.referrer,referrerPolicy:s.referrerPolicy,mode:s.mode,credentials:s.credentials,cache:s.cache,redirect:s.redirect,integrity:s.integrity,keepalive:s.keepalive,reloadNavigation:s.reloadNavigation,historyNavigation:s.historyNavigation,urlList:[...s.urlList]});let l=Object.keys(r).length!==0;if(l&&(s.mode==="navigate"&&(s.mode="same-origin"),s.reloadNavigation=!1,s.historyNavigation=!1,s.origin="client",s.referrer="client",s.referrerPolicy="",s.url=s.urlList[s.urlList.length-1],s.urlList=[s.url]),r.referrer!==void 0){let I=r.referrer;if(I==="")s.referrer="no-referrer";else{let y;try{y=new URL(I,n)}catch(T){throw new TypeError(`Referrer "${I}" is not a valid URL.`,{cause:T})}y.protocol==="about:"&&y.hostname==="client"||a&&!vd(y,sn.settingsObject.baseUrl)?s.referrer="client":s.referrer=y}}r.referrerPolicy!==void 0&&(s.referrerPolicy=r.referrerPolicy);let g;if(r.mode!==void 0?g=r.mode:g=o,g==="navigate")throw v.errors.exception({header:"Request constructor",message:"invalid request mode navigate."});if(g!=null&&(s.mode=g),r.credentials!==void 0&&(s.credentials=r.credentials),r.cache!==void 0&&(s.cache=r.cache),s.cache==="only-if-cached"&&s.mode!=="same-origin")throw new TypeError("'only-if-cached' can be set only with 'same-origin' mode");if(r.redirect!==void 0&&(s.redirect=r.redirect),r.integrity!=null&&(s.integrity=String(r.integrity)),r.keepalive!==void 0&&(s.keepalive=!!r.keepalive),r.method!==void 0){let I=r.method,y=kT[I];if(y!==void 0)s.method=y;else{if(!BT(I))throw new TypeError(`'${I}' is not a valid HTTP method.`);let T=I.toUpperCase();if(dT.has(T))throw new TypeError(`'${I}' HTTP method is unsupported.`);I=bT[T]??I,s.method=I}!Od&&s.method==="patch"&&(process.emitWarning("Using `patch` is highly likely to result in a `405 Method Not Allowed`. `PATCH` is much more likely to succeed.",{code:"UNDICI-FETCH-patch"}),Od=!0)}r.signal!==void 0&&(i=r.signal),this[Ae]=s;let E=new AbortController;if(this[nn]=E.signal,i!=null){if(!i||typeof i.aborted!="boolean"||typeof i.addEventListener!="function")throw new TypeError("Failed to construct 'Request': member signal is not of type AbortSignal.");if(i.aborted)E.abort(i.reason);else{this[FT]=E;let I=new WeakRef(E),y=Jd(I);try{(typeof _d=="function"&&_d(i)===Yd||TT(i,"abort").length>=Yd)&&xd(1500,i)}catch{}on.addAbortListener(i,y),Vd.register(E,{signal:i,abort:y},y)}}if(this[Le]=new Hd(cn),Pd(this[Le],s.headersList),$c(this[Le],"request"),g==="no-cors"){if(!IT.has(s.method))throw new TypeError(`'${s.method} is unsupported in no-cors mode.`);$c(this[Le],"request-no-cors")}if(l){let I=Md(this[Le]),y=r.headers!==void 0?r.headers:new an(I);if(I.clear(),y instanceof an){for(let{name:T,value:S}of y.rawValues())I.append(T,S,!1);I.cookies=y.cookies}else ET(this[Le],y)}let d=e instanceof t?e[Ae].body:null;if((r.body!=null||d!=null)&&(s.method==="GET"||s.method==="HEAD"))throw new TypeError("Request with GET/HEAD method cannot have body.");let B=null;if(r.body!=null){let[I,y]=gT(r.body,s.keepalive);B=I,y&&!Md(this[Le]).contains("content-type",!0)&&this[Le].append("content-type",y)}let p=B??d;if(p!=null&&p.source==null){if(B!=null&&r.duplex==null)throw new TypeError("RequestInit: duplex option is required when sending a body.");if(s.mode!=="same-origin"&&s.mode!=="cors")throw new TypeError('If request is made from ReadableStream, mode should be "same-origin" or "cors"');s.useCORSPreflightFlag=!0}let w=p;if(B==null&&d!=null){if(Gd(e))throw new TypeError("Cannot construct a Request with a Request object that has already been used.");let I=new TransformStream;d.stream.pipeThrough(I),w={source:d.source,length:d.length,stream:I.readable}}this[Ae].body=w}get method(){return v.brandCheck(this,t),this[Ae].method}get url(){return v.brandCheck(this,t),DT(this[Ae].url)}get headers(){return v.brandCheck(this,t),this[Le]}get destination(){return v.brandCheck(this,t),this[Ae].destination}get referrer(){return v.brandCheck(this,t),this[Ae].referrer==="no-referrer"?"":this[Ae].referrer==="client"?"about:client":this[Ae].referrer.toString()}get referrerPolicy(){return v.brandCheck(this,t),this[Ae].referrerPolicy}get mode(){return v.brandCheck(this,t),this[Ae].mode}get credentials(){return this[Ae].credentials}get cache(){return v.brandCheck(this,t),this[Ae].cache}get redirect(){return v.brandCheck(this,t),this[Ae].redirect}get integrity(){return v.brandCheck(this,t),this[Ae].integrity}get keepalive(){return v.brandCheck(this,t),this[Ae].keepalive}get isReloadNavigation(){return v.brandCheck(this,t),this[Ae].reloadNavigation}get isHistoryNavigation(){return v.brandCheck(this,t),this[Ae].historyNavigation}get signal(){return v.brandCheck(this,t),this[nn]}get body(){return v.brandCheck(this,t),this[Ae].body?this[Ae].body.stream:null}get bodyUsed(){return v.brandCheck(this,t),!!this[Ae].body&&on.isDisturbed(this[Ae].body.stream)}get duplex(){return v.brandCheck(this,t),"half"}clone(){if(v.brandCheck(this,t),Gd(this))throw new TypeError("unusable");let e=qd(this[Ae]),r=new AbortController;if(this.signal.aborted)r.abort(this.signal.reason);else{let A=gn.get(this.signal);A===void 0&&(A=new Set,gn.set(this.signal,A));let s=new WeakRef(r);A.add(s),on.addAbortListener(r.signal,Jd(s))}return Wd(e,r.signal,hT(this[Le]))}[Ld.inspect.custom](e,r){r.depth===null&&(r.depth=2),r.colors??=!0;let A={method:this.method,url:this.url,headers:this.headers,destination:this.destination,referrer:this.referrer,referrerPolicy:this.referrerPolicy,mode:this.mode,credentials:this.credentials,cache:this.cache,redirect:this.redirect,integrity:this.integrity,keepalive:this.keepalive,isReloadNavigation:this.isReloadNavigation,isHistoryNavigation:this.isHistoryNavigation,signal:this.signal};return`Request ${Ld.formatWithOptions(r,A)}`}};uT(Kt);function un(t){return{method:t.method??"GET",localURLsOnly:t.localURLsOnly??!1,unsafeRequest:t.unsafeRequest??!1,body:t.body??null,client:t.client??null,reservedClient:t.reservedClient??null,replacesClientId:t.replacesClientId??"",window:t.window??"client",keepalive:t.keepalive??!1,serviceWorkers:t.serviceWorkers??"all",initiator:t.initiator??"",destination:t.destination??"",priority:t.priority??null,origin:t.origin??"client",policyContainer:t.policyContainer??"client",referrer:t.referrer??"client",referrerPolicy:t.referrerPolicy??"",mode:t.mode??"no-cors",useCORSPreflightFlag:t.useCORSPreflightFlag??!1,credentials:t.credentials??"same-origin",useCredentials:t.useCredentials??!1,cache:t.cache??"default",redirect:t.redirect??"follow",integrity:t.integrity??"",cryptoGraphicsNonceMetadata:t.cryptoGraphicsNonceMetadata??"",parserMetadata:t.parserMetadata??"",reloadNavigation:t.reloadNavigation??!1,historyNavigation:t.historyNavigation??!1,userActivation:t.userActivation??!1,taintedOrigin:t.taintedOrigin??!1,redirectCount:t.redirectCount??0,responseTainting:t.responseTainting??"basic",preventNoCacheCacheControlHeaderModification:t.preventNoCacheCacheControlHeaderModification??!1,done:t.done??!1,timingAllowFailed:t.timingAllowFailed??!1,urlList:t.urlList,url:t.urlList[0],headersList:t.headersList?new an(t.headersList):new an}}function qd(t){let e=un({...t,body:null});return t.body!=null&&(e.body=lT(e,t.body)),e}function Wd(t,e,r){let A=new Kt(cn);return A[Ae]=t,A[nn]=e,A[Le]=new Hd(cn),Pd(A[Le],t.headersList),$c(A[Le],r),A}Object.defineProperties(Kt.prototype,{method:le,url:le,headers:le,redirect:le,clone:le,signal:le,duplex:le,destination:le,body:le,bodyUsed:le,isHistoryNavigation:le,isReloadNavigation:le,keepalive:le,integrity:le,cache:le,credentials:le,attribute:le,referrerPolicy:le,referrer:le,mode:le,[Symbol.toStringTag]:{value:"Request",configurable:!0}});v.converters.Request=v.interfaceConverter(Kt);v.converters.RequestInfo=function(t,e,r){return typeof t=="string"?v.converters.USVString(t,e,r):t instanceof Kt?v.converters.Request(t,e,r):v.converters.USVString(t,e,r)};v.converters.AbortSignal=v.interfaceConverter(AbortSignal);v.converters.RequestInit=v.dictionaryConverter([{key:"method",converter:v.converters.ByteString},{key:"headers",converter:v.converters.HeadersInit},{key:"body",converter:v.nullableConverter(v.converters.BodyInit)},{key:"referrer",converter:v.converters.USVString},{key:"referrerPolicy",converter:v.converters.DOMString,allowedValues:CT},{key:"mode",converter:v.converters.DOMString,allowedValues:fT},{key:"credentials",converter:v.converters.DOMString,allowedValues:mT},{key:"cache",converter:v.converters.DOMString,allowedValues:wT},{key:"redirect",converter:v.converters.DOMString,allowedValues:pT},{key:"integrity",converter:v.converters.DOMString},{key:"keepalive",converter:v.converters.boolean},{key:"signal",converter:v.nullableConverter(t=>v.converters.AbortSignal(t,"RequestInit","signal",{strict:!1}))},{key:"window",converter:v.converters.any},{key:"duplex",converter:v.converters.DOMString,allowedValues:yT},{key:"dispatcher",converter:v.converters.any}]);zd.exports={Request:Kt,makeRequest:un,fromInnerRequest:Wd,cloneRequest:qd}});var Cs=m((KL,cI)=>{"use strict";var{makeNetworkError:K,makeAppropriateNetworkError:ln,filterResponse:eg,makeResponse:En,fromInnerResponse:ST}=ds(),{HeadersList:Zd}=fr(),{Request:UT,cloneRequest:NT}=dA(),jt=require("node:zlib"),{bytesMatch:GT,makePolicyContainer:MT,clonePolicyContainer:LT,requestBadPort:vT,TAOCheck:_T,appendRequestOriginHeader:xT,responseLocationURL:YT,requestCurrentURL:Bt,setRequestReferrerPolicyOnRedirect:JT,tryUpgradeRequestToAPotentiallyTrustworthyURL:OT,createOpaqueTimingInfo:og,appendFetchMetadata:HT,corsCheck:PT,crossOriginResourcePolicyCheck:VT,determineRequestsReferrer:qT,coarsenedSharedCurrentTime:Is,createDeferredPromise:WT,isBlobLike:zT,sameOrigin:sg,isCancelled:wr,isAborted:Kd,isErrorLike:ZT,fullyReadBody:KT,readableStreamClose:jT,isomorphicEncode:hn,urlIsLocal:XT,urlIsHttpHttpsScheme:ng,urlHasHttpsScheme:$T,clampAndCoarsenConnectionTimingInfo:eF,simpleRangeHeaderValue:tF,buildContentRange:rF,createInflate:AF,extractMimeType:sF}=Fe(),{kState:eI,kDispatcher:oF}=xt(),yr=require("node:assert"),{safelyExtractBody:ig,extractBody:jd}=Zr(),{redirectStatusSet:tI,nullBodyStatus:rI,safeMethodsSet:nF,requestBodyHeader:iF,subresourceSet:aF}=YA(),cF=require("node:events"),{Readable:gF,pipeline:uF,finished:lF}=require("node:stream"),{addAbortListener:EF,isErrored:hF,isReadable:Qn,bufferToLowerCasedHeaderName:Xd}=J(),{dataURLProcessor:QF,serializeAMimeType:BF,minimizeSupportedMimeType:dF}=ye(),{getGlobalDispatcher:IF}=jo(),{webidl:CF}=de(),{STATUS_CODES:pF}=require("node:http"),fF=["GET","HEAD"],mF=typeof __UNDICI_IS_NODE__<"u"||typeof esbuildDetection<"u"?"node":"undici",tg,Bn=class extends cF{constructor(e){super(),this.dispatcher=e,this.connection=null,this.dump=!1,this.state="ongoing"}terminate(e){this.state==="ongoing"&&(this.state="terminated",this.connection?.destroy(e),this.emit("terminated",e))}abort(e){this.state==="ongoing"&&(this.state="aborted",e||(e=new DOMException("The operation was aborted.","AbortError")),this.serializedAbortReason=e,this.connection?.destroy(e),this.emit("terminated",e))}};function wF(t){AI(t,"fetch")}function yF(t,e=void 0){CF.argumentLengthCheck(arguments,1,"globalThis.fetch");let r=WT(),A;try{A=new UT(t,e)}catch(l){return r.reject(l),r.promise}let s=A[eI];if(A.signal.aborted)return rg(r,s,null,A.signal.reason),r.promise;s.client.globalObject?.constructor?.name==="ServiceWorkerGlobalScope"&&(s.serviceWorkers="none");let n=null,i=!1,a=null;return EF(A.signal,()=>{i=!0,yr(a!=null),a.abort(A.signal.reason);let l=n?.deref();rg(r,s,l,A.signal.reason)}),a=oI({request:s,processResponseEndOfBody:wF,processResponse:l=>{if(!i){if(l.aborted){rg(r,s,n,a.serializedAbortReason);return}if(l.type==="error"){r.reject(new TypeError("fetch failed",{cause:l.error}));return}n=new WeakRef(ST(l,"immutable")),r.resolve(n.deref()),r=null}},dispatcher:A[oF]}),r.promise}function AI(t,e="other"){if(t.type==="error"&&t.aborted||!t.urlList?.length)return;let r=t.urlList[0],A=t.timingInfo,s=t.cacheState;ng(r)&&A!==null&&(t.timingAllowPassed||(A=og({startTime:A.startTime}),s=""),A.endTime=Is(),t.timingInfo=A,sI(A,r.href,e,globalThis,s))}var sI=performance.markResourceTiming;function rg(t,e,r,A){if(t&&t.reject(A),e.body!=null&&Qn(e.body?.stream)&&e.body.stream.cancel(A).catch(o=>{if(o.code!=="ERR_INVALID_STATE")throw o}),r==null)return;let s=r[eI];s.body!=null&&Qn(s.body?.stream)&&s.body.stream.cancel(A).catch(o=>{if(o.code!=="ERR_INVALID_STATE")throw o})}function oI({request:t,processRequestBodyChunkLength:e,processRequestEndOfBody:r,processResponse:A,processResponseEndOfBody:s,processResponseConsumeBody:o,useParallelQueue:n=!1,dispatcher:i=IF()}){yr(i);let a=null,c=!1;t.client!=null&&(a=t.client.globalObject,c=t.client.crossOriginIsolatedCapability);let l=Is(c),g=og({startTime:l}),E={controller:new Bn(i),request:t,timingInfo:g,processRequestBodyChunkLength:e,processRequestEndOfBody:r,processResponse:A,processResponseConsumeBody:o,processResponseEndOfBody:s,taskDestination:a,crossOriginIsolatedCapability:c};return yr(!t.body||t.body.stream),t.window==="client"&&(t.window=t.client?.globalObject?.constructor?.name==="Window"?t.client:"no-window"),t.origin==="client"&&(t.origin=t.client.origin),t.policyContainer==="client"&&(t.client!=null?t.policyContainer=LT(t.client.policyContainer):t.policyContainer=MT()),t.headersList.contains("accept",!0)||t.headersList.append("accept","*/*",!0),t.headersList.contains("accept-language",!0)||t.headersList.append("accept-language","*",!0),t.priority,aF.has(t.destination),nI(E).catch(d=>{E.controller.terminate(d)}),E.controller}async function nI(t,e=!1){let r=t.request,A=null;if(r.localURLsOnly&&!XT(Bt(r))&&(A=K("local URLs only")),OT(r),vT(r)==="blocked"&&(A=K("bad port")),r.referrerPolicy===""&&(r.referrerPolicy=r.policyContainer.referrerPolicy),r.referrer!=="no-referrer"&&(r.referrer=qT(r)),A===null&&(A=await(async()=>{let o=Bt(r);return sg(o,r.url)&&r.responseTainting==="basic"||o.protocol==="data:"||r.mode==="navigate"||r.mode==="websocket"?(r.responseTainting="basic",await $d(t)):r.mode==="same-origin"?K('request mode cannot be "same-origin"'):r.mode==="no-cors"?r.redirect!=="follow"?K('redirect mode cannot be "follow" for "no-cors" request'):(r.responseTainting="opaque",await $d(t)):ng(Bt(r))?(r.responseTainting="cors",await iI(t)):K("URL scheme must be a HTTP(S) scheme")})()),e)return A;A.status!==0&&!A.internalResponse&&(r.responseTainting,r.responseTainting==="basic"?A=eg(A,"basic"):r.responseTainting==="cors"?A=eg(A,"cors"):r.responseTainting==="opaque"?A=eg(A,"opaque"):yr(!1));let s=A.status===0?A:A.internalResponse;if(s.urlList.length===0&&s.urlList.push(...r.urlList),r.timingAllowFailed||(A.timingAllowPassed=!0),A.type==="opaque"&&s.status===206&&s.rangeRequested&&!r.headers.contains("range",!0)&&(A=s=K()),A.status!==0&&(r.method==="HEAD"||r.method==="CONNECT"||rI.includes(s.status))&&(s.body=null,t.controller.dump=!0),r.integrity){let o=i=>Ag(t,K(i));if(r.responseTainting==="opaque"||A.body==null){o(A.error);return}let n=i=>{if(!GT(i,r.integrity)){o("integrity mismatch");return}A.body=ig(i)[0],Ag(t,A)};await KT(A.body,n,o)}else Ag(t,A)}function $d(t){if(wr(t)&&t.request.redirectCount===0)return Promise.resolve(ln(t));let{request:e}=t,{protocol:r}=Bt(e);switch(r){case"about:":return Promise.resolve(K("about scheme is not supported"));case"blob:":{tg||(tg=require("node:buffer").resolveObjectURL);let A=Bt(e);if(A.search.length!==0)return Promise.resolve(K("NetworkError when attempting to fetch resource."));let s=tg(A.toString());if(e.method!=="GET"||!zT(s))return Promise.resolve(K("invalid method"));let o=En(),n=s.size,i=hn(`${n}`),a=s.type;if(e.headersList.contains("range",!0)){o.rangeRequested=!0;let c=e.headersList.get("range",!0),l=tF(c,!0);if(l==="failure")return Promise.resolve(K("failed to fetch the data URL"));let{rangeStartValue:g,rangeEndValue:E}=l;if(g===null)g=n-E,E=g+E-1;else{if(g>=n)return Promise.resolve(K("Range start is greater than the blob's size."));(E===null||E>=n)&&(E=n-1)}let d=s.slice(g,E,a),B=jd(d);o.body=B[0];let p=hn(`${d.size}`),w=rF(g,E,n);o.status=206,o.statusText="Partial Content",o.headersList.set("content-length",p,!0),o.headersList.set("content-type",a,!0),o.headersList.set("content-range",w,!0)}else{let c=jd(s);o.statusText="OK",o.body=c[0],o.headersList.set("content-length",i,!0),o.headersList.set("content-type",a,!0)}return Promise.resolve(o)}case"data:":{let A=Bt(e),s=QF(A);if(s==="failure")return Promise.resolve(K("failed to fetch the data URL"));let o=BF(s.mimeType);return Promise.resolve(En({statusText:"OK",headersList:[["content-type",{name:"Content-Type",value:o}]],body:ig(s.body)[0]}))}case"file:":return Promise.resolve(K("not implemented... yet..."));case"http:":case"https:":return iI(t).catch(A=>K(A));default:return Promise.resolve(K("unknown scheme"))}}function bF(t,e){t.request.done=!0,t.processResponseDone!=null&&queueMicrotask(()=>t.processResponseDone(e))}function Ag(t,e){let r=t.timingInfo,A=()=>{let o=Date.now();t.request.destination==="document"&&(t.controller.fullTimingInfo=r),t.controller.reportTimingSteps=()=>{if(t.request.url.protocol!=="https:")return;r.endTime=o;let i=e.cacheState,a=e.bodyInfo;e.timingAllowPassed||(r=og(r),i="");let c=0;if(t.request.mode!=="navigator"||!e.hasCrossOriginRedirects){c=e.status;let l=sF(e.headersList);l!=="failure"&&(a.contentType=dF(l))}t.request.initiatorType!=null&&sI(r,t.request.url.href,t.request.initiatorType,globalThis,i,a,c)};let n=()=>{t.request.done=!0,t.processResponseEndOfBody!=null&&queueMicrotask(()=>t.processResponseEndOfBody(e)),t.request.initiatorType!=null&&t.controller.reportTimingSteps()};queueMicrotask(()=>n())};t.processResponse!=null&&queueMicrotask(()=>{t.processResponse(e),t.processResponse=null});let s=e.type==="error"?e:e.internalResponse??e;s.body==null?A():lF(s.body.stream,()=>{A()})}async function iI(t){let e=t.request,r=null,A=null,s=t.timingInfo;if(e.serviceWorkers,r===null){if(e.redirect==="follow"&&(e.serviceWorkers="none"),A=r=await aI(t),e.responseTainting==="cors"&&PT(e,r)==="failure")return K("cors failure");_T(e,r)==="failure"&&(e.timingAllowFailed=!0)}return(e.responseTainting==="opaque"||r.type==="opaque")&&VT(e.origin,e.client,e.destination,A)==="blocked"?K("blocked"):(tI.has(A.status)&&(e.redirect!=="manual"&&t.controller.connection.destroy(void 0,!1),e.redirect==="error"?r=K("unexpected redirect"):e.redirect==="manual"?r=A:e.redirect==="follow"?r=await kF(t,r):yr(!1)),r.timingInfo=s,r)}function kF(t,e){let r=t.request,A=e.internalResponse?e.internalResponse:e,s;try{if(s=YT(A,Bt(r).hash),s==null)return e}catch(n){return Promise.resolve(K(n))}if(!ng(s))return Promise.resolve(K("URL scheme must be a HTTP(S) scheme"));if(r.redirectCount===20)return Promise.resolve(K("redirect count exceeded"));if(r.redirectCount+=1,r.mode==="cors"&&(s.username||s.password)&&!sg(r,s))return Promise.resolve(K('cross origin not allowed for request mode "cors"'));if(r.responseTainting==="cors"&&(s.username||s.password))return Promise.resolve(K('URL cannot contain credentials for request mode "cors"'));if(A.status!==303&&r.body!=null&&r.body.source==null)return Promise.resolve(K());if([301,302].includes(A.status)&&r.method==="POST"||A.status===303&&!fF.includes(r.method)){r.method="GET",r.body=null;for(let n of iF)r.headersList.delete(n)}sg(Bt(r),s)||(r.headersList.delete("authorization",!0),r.headersList.delete("proxy-authorization",!0),r.headersList.delete("cookie",!0),r.headersList.delete("host",!0)),r.body!=null&&(yr(r.body.source!=null),r.body=ig(r.body.source)[0]);let o=t.timingInfo;return o.redirectEndTime=o.postRedirectStartTime=Is(t.crossOriginIsolatedCapability),o.redirectStartTime===0&&(o.redirectStartTime=o.startTime),r.urlList.push(s),JT(r,A),nI(t,!0)}async function aI(t,e=!1,r=!1){let A=t.request,s=null,o=null,n=null,i=null,a=!1;A.window==="no-window"&&A.redirect==="error"?(s=t,o=A):(o=NT(A),s={...t},s.request=o);let c=A.credentials==="include"||A.credentials==="same-origin"&&A.responseTainting==="basic",l=o.body?o.body.length:null,g=null;if(o.body==null&&["POST","PUT"].includes(o.method)&&(g="0"),l!=null&&(g=hn(`${l}`)),g!=null&&o.headersList.append("content-length",g,!0),l!=null&&o.keepalive,o.referrer instanceof URL&&o.headersList.append("referer",hn(o.referrer.href),!0),xT(o),HT(o),o.headersList.contains("user-agent",!0)||o.headersList.append("user-agent",mF),o.cache==="default"&&(o.headersList.contains("if-modified-since",!0)||o.headersList.contains("if-none-match",!0)||o.headersList.contains("if-unmodified-since",!0)||o.headersList.contains("if-match",!0)||o.headersList.contains("if-range",!0))&&(o.cache="no-store"),o.cache==="no-cache"&&!o.preventNoCacheCacheControlHeaderModification&&!o.headersList.contains("cache-control",!0)&&o.headersList.append("cache-control","max-age=0",!0),(o.cache==="no-store"||o.cache==="reload")&&(o.headersList.contains("pragma",!0)||o.headersList.append("pragma","no-cache",!0),o.headersList.contains("cache-control",!0)||o.headersList.append("cache-control","no-cache",!0)),o.headersList.contains("range",!0)&&o.headersList.append("accept-encoding","identity",!0),o.headersList.contains("accept-encoding",!0)||($T(Bt(o))?o.headersList.append("accept-encoding","br, gzip, deflate",!0):o.headersList.append("accept-encoding","gzip, deflate",!0)),o.headersList.delete("host",!0),i==null&&(o.cache="no-store"),o.cache!=="no-store"&&o.cache,n==null){if(o.cache==="only-if-cached")return K("only if cached");let E=await DF(s,c,r);!nF.has(o.method)&&E.status>=200&&E.status<=399,a&&E.status,n==null&&(n=E)}if(n.urlList=[...o.urlList],o.headersList.contains("range",!0)&&(n.rangeRequested=!0),n.requestIncludesCredentials=c,n.status===407)return A.window==="no-window"?K():wr(t)?ln(t):K("proxy authentication required");if(n.status===421&&!r&&(A.body==null||A.body.source!=null)){if(wr(t))return ln(t);t.controller.connection.destroy(),n=await aI(t,e,!0)}return n}async function DF(t,e=!1,r=!1){yr(!t.controller.connection||t.controller.connection.destroyed),t.controller.connection={abort:null,destroyed:!1,destroy(B,p=!0){this.destroyed||(this.destroyed=!0,p&&this.abort?.(B??new DOMException("The operation was aborted.","AbortError")))}};let A=t.request,s=null,o=t.timingInfo;null==null&&(A.cache="no-store");let i=r?"yes":"no";A.mode;let a=null;if(A.body==null&&t.processRequestEndOfBody)queueMicrotask(()=>t.processRequestEndOfBody());else if(A.body!=null){let B=async function*(I){wr(t)||(yield I,t.processRequestBodyChunkLength?.(I.byteLength))},p=()=>{wr(t)||t.processRequestEndOfBody&&t.processRequestEndOfBody()},w=I=>{wr(t)||(I.name==="AbortError"?t.controller.abort():t.controller.terminate(I))};a=(async function*(){try{for await(let I of A.body.stream)yield*B(I);p()}catch(I){w(I)}})()}try{let{body:B,status:p,statusText:w,headersList:I,socket:y}=await d({body:a});if(y)s=En({status:p,statusText:w,headersList:I,socket:y});else{let T=B[Symbol.asyncIterator]();t.controller.next=()=>T.next(),s=En({status:p,statusText:w,headersList:I})}}catch(B){return B.name==="AbortError"?(t.controller.connection.destroy(),ln(t,B)):K(B)}let c=async()=>{await t.controller.resume()},l=B=>{wr(t)||t.controller.abort(B)},g=new ReadableStream({async start(B){t.controller.controller=B},async pull(B){await c(B)},async cancel(B){await l(B)},type:"bytes"});s.body={stream:g,source:null,length:null},t.controller.onAborted=E,t.controller.on("terminated",E),t.controller.resume=async()=>{for(;;){let B,p;try{let{done:I,value:y}=await t.controller.next();if(Kd(t))break;B=I?void 0:y}catch(I){t.controller.ended&&!o.encodedBodySize?B=void 0:(B=I,p=!0)}if(B===void 0){jT(t.controller.controller),bF(t,s);return}if(o.decodedBodySize+=B?.byteLength??0,p){t.controller.terminate(B);return}let w=new Uint8Array(B);if(w.byteLength&&t.controller.controller.enqueue(w),hF(g)){t.controller.terminate();return}if(t.controller.controller.desiredSize<=0)return}};function E(B){Kd(t)?(s.aborted=!0,Qn(g)&&t.controller.controller.error(t.controller.serializedAbortReason)):Qn(g)&&t.controller.controller.error(new TypeError("terminated",{cause:ZT(B)?B:void 0})),t.controller.connection.destroy()}return s;function d({body:B}){let p=Bt(A),w=t.controller.dispatcher;return new Promise((I,y)=>w.dispatch({path:p.pathname+p.search,origin:p.origin,method:A.method,body:w.isMockActive?A.body&&(A.body.source||A.body.stream):B,headers:A.headersList.entries,maxRedirections:0,upgrade:A.mode==="websocket"?"websocket":void 0},{body:null,abort:null,onConnect(T){let{connection:S}=t.controller;o.finalConnectionTimingInfo=eF(void 0,o.postRedirectStartTime,t.crossOriginIsolatedCapability),S.destroyed?T(new DOMException("The operation was aborted.","AbortError")):(t.controller.on("terminated",T),this.abort=S.abort=T),o.finalNetworkRequestStartTime=Is(t.crossOriginIsolatedCapability)},onResponseStarted(){o.finalNetworkResponseStartTime=Is(t.crossOriginIsolatedCapability)},onHeaders(T,S,O,j){if(T<200)return;let X="",Ye=new Zd;for(let Qe=0;QeLt)return y(new Error(`too many content-encodings in response: ${Ct.length}, maximum allowed is ${Lt}`)),!0;for(let Ur=Ct.length-1;Ur>=0;--Ur){let Nr=Ct[Ur].trim();if(Nr==="x-gzip"||Nr==="gzip")Je.push(jt.createGunzip({flush:jt.constants.Z_SYNC_FLUSH,finishFlush:jt.constants.Z_SYNC_FLUSH}));else if(Nr==="deflate")Je.push(AF({flush:jt.constants.Z_SYNC_FLUSH,finishFlush:jt.constants.Z_SYNC_FLUSH}));else if(Nr==="br")Je.push(jt.createBrotliDecompress({flush:jt.constants.BROTLI_OPERATION_FLUSH,finishFlush:jt.constants.BROTLI_OPERATION_FLUSH}));else{Je.length=0;break}}}let ot=this.onError.bind(this);return I({status:T,statusText:j,headersList:Ye,body:Je.length?uF(this.body,...Je,Qe=>{Qe&&this.onError(Qe)}).on("error",ot):this.body.on("error",ot)}),!0},onData(T){if(t.controller.dump)return;let S=T;return o.encodedBodySize+=S.byteLength,this.body.push(S)},onComplete(){this.abort&&t.controller.off("terminated",this.abort),t.controller.onAborted&&t.controller.off("terminated",t.controller.onAborted),t.controller.ended=!0,this.body.push(null)},onError(T){this.abort&&t.controller.off("terminated",this.abort),this.body?.destroy(T),t.controller.terminate(T),y(T)},onUpgrade(T,S,O){if(T!==101)return;let j=new Zd;for(let X=0;X{"use strict";gI.exports={kState:Symbol("FileReader state"),kResult:Symbol("FileReader result"),kError:Symbol("FileReader error"),kLastProgressEventFired:Symbol("FileReader last progress event fired timestamp"),kEvents:Symbol("FileReader events"),kAborted:Symbol("FileReader aborted")}});var lI=m((XL,uI)=>{"use strict";var{webidl:ve}=de(),dn=Symbol("ProgressEvent state"),cg=class t extends Event{constructor(e,r={}){e=ve.converters.DOMString(e,"ProgressEvent constructor","type"),r=ve.converters.ProgressEventInit(r??{}),super(e,r),this[dn]={lengthComputable:r.lengthComputable,loaded:r.loaded,total:r.total}}get lengthComputable(){return ve.brandCheck(this,t),this[dn].lengthComputable}get loaded(){return ve.brandCheck(this,t),this[dn].loaded}get total(){return ve.brandCheck(this,t),this[dn].total}};ve.converters.ProgressEventInit=ve.dictionaryConverter([{key:"lengthComputable",converter:ve.converters.boolean,defaultValue:()=>!1},{key:"loaded",converter:ve.converters["unsigned long long"],defaultValue:()=>0},{key:"total",converter:ve.converters["unsigned long long"],defaultValue:()=>0},{key:"bubbles",converter:ve.converters.boolean,defaultValue:()=>!1},{key:"cancelable",converter:ve.converters.boolean,defaultValue:()=>!1},{key:"composed",converter:ve.converters.boolean,defaultValue:()=>!1}]);uI.exports={ProgressEvent:cg}});var hI=m(($L,EI)=>{"use strict";function RF(t){if(!t)return"failure";switch(t.trim().toLowerCase()){case"unicode-1-1-utf-8":case"unicode11utf8":case"unicode20utf8":case"utf-8":case"utf8":case"x-unicode20utf8":return"UTF-8";case"866":case"cp866":case"csibm866":case"ibm866":return"IBM866";case"csisolatin2":case"iso-8859-2":case"iso-ir-101":case"iso8859-2":case"iso88592":case"iso_8859-2":case"iso_8859-2:1987":case"l2":case"latin2":return"ISO-8859-2";case"csisolatin3":case"iso-8859-3":case"iso-ir-109":case"iso8859-3":case"iso88593":case"iso_8859-3":case"iso_8859-3:1988":case"l3":case"latin3":return"ISO-8859-3";case"csisolatin4":case"iso-8859-4":case"iso-ir-110":case"iso8859-4":case"iso88594":case"iso_8859-4":case"iso_8859-4:1988":case"l4":case"latin4":return"ISO-8859-4";case"csisolatincyrillic":case"cyrillic":case"iso-8859-5":case"iso-ir-144":case"iso8859-5":case"iso88595":case"iso_8859-5":case"iso_8859-5:1988":return"ISO-8859-5";case"arabic":case"asmo-708":case"csiso88596e":case"csiso88596i":case"csisolatinarabic":case"ecma-114":case"iso-8859-6":case"iso-8859-6-e":case"iso-8859-6-i":case"iso-ir-127":case"iso8859-6":case"iso88596":case"iso_8859-6":case"iso_8859-6:1987":return"ISO-8859-6";case"csisolatingreek":case"ecma-118":case"elot_928":case"greek":case"greek8":case"iso-8859-7":case"iso-ir-126":case"iso8859-7":case"iso88597":case"iso_8859-7":case"iso_8859-7:1987":case"sun_eu_greek":return"ISO-8859-7";case"csiso88598e":case"csisolatinhebrew":case"hebrew":case"iso-8859-8":case"iso-8859-8-e":case"iso-ir-138":case"iso8859-8":case"iso88598":case"iso_8859-8":case"iso_8859-8:1988":case"visual":return"ISO-8859-8";case"csiso88598i":case"iso-8859-8-i":case"logical":return"ISO-8859-8-I";case"csisolatin6":case"iso-8859-10":case"iso-ir-157":case"iso8859-10":case"iso885910":case"l6":case"latin6":return"ISO-8859-10";case"iso-8859-13":case"iso8859-13":case"iso885913":return"ISO-8859-13";case"iso-8859-14":case"iso8859-14":case"iso885914":return"ISO-8859-14";case"csisolatin9":case"iso-8859-15":case"iso8859-15":case"iso885915":case"iso_8859-15":case"l9":return"ISO-8859-15";case"iso-8859-16":return"ISO-8859-16";case"cskoi8r":case"koi":case"koi8":case"koi8-r":case"koi8_r":return"KOI8-R";case"koi8-ru":case"koi8-u":return"KOI8-U";case"csmacintosh":case"mac":case"macintosh":case"x-mac-roman":return"macintosh";case"iso-8859-11":case"iso8859-11":case"iso885911":case"tis-620":case"windows-874":return"windows-874";case"cp1250":case"windows-1250":case"x-cp1250":return"windows-1250";case"cp1251":case"windows-1251":case"x-cp1251":return"windows-1251";case"ansi_x3.4-1968":case"ascii":case"cp1252":case"cp819":case"csisolatin1":case"ibm819":case"iso-8859-1":case"iso-ir-100":case"iso8859-1":case"iso88591":case"iso_8859-1":case"iso_8859-1:1987":case"l1":case"latin1":case"us-ascii":case"windows-1252":case"x-cp1252":return"windows-1252";case"cp1253":case"windows-1253":case"x-cp1253":return"windows-1253";case"cp1254":case"csisolatin5":case"iso-8859-9":case"iso-ir-148":case"iso8859-9":case"iso88599":case"iso_8859-9":case"iso_8859-9:1989":case"l5":case"latin5":case"windows-1254":case"x-cp1254":return"windows-1254";case"cp1255":case"windows-1255":case"x-cp1255":return"windows-1255";case"cp1256":case"windows-1256":case"x-cp1256":return"windows-1256";case"cp1257":case"windows-1257":case"x-cp1257":return"windows-1257";case"cp1258":case"windows-1258":case"x-cp1258":return"windows-1258";case"x-mac-cyrillic":case"x-mac-ukrainian":return"x-mac-cyrillic";case"chinese":case"csgb2312":case"csiso58gb231280":case"gb2312":case"gb_2312":case"gb_2312-80":case"gbk":case"iso-ir-58":case"x-gbk":return"GBK";case"gb18030":return"gb18030";case"big5":case"big5-hkscs":case"cn-big5":case"csbig5":case"x-x-big5":return"Big5";case"cseucpkdfmtjapanese":case"euc-jp":case"x-euc-jp":return"EUC-JP";case"csiso2022jp":case"iso-2022-jp":return"ISO-2022-JP";case"csshiftjis":case"ms932":case"ms_kanji":case"shift-jis":case"shift_jis":case"sjis":case"windows-31j":case"x-sjis":return"Shift_JIS";case"cseuckr":case"csksc56011987":case"euc-kr":case"iso-ir-149":case"korean":case"ks_c_5601-1987":case"ks_c_5601-1989":case"ksc5601":case"ksc_5601":case"windows-949":return"EUC-KR";case"csiso2022kr":case"hz-gb-2312":case"iso-2022-cn":case"iso-2022-cn-ext":case"iso-2022-kr":case"replacement":return"replacement";case"unicodefffe":case"utf-16be":return"UTF-16BE";case"csunicode":case"iso-10646-ucs-2":case"ucs-2":case"unicode":case"unicodefeff":case"utf-16":case"utf-16le":return"UTF-16LE";case"x-user-defined":return"x-user-defined";default:return"failure"}}EI.exports={getEncoding:RF}});var mI=m((ev,fI)=>{"use strict";var{kState:IA,kError:gg,kResult:QI,kAborted:ps,kLastProgressEventFired:ug}=ag(),{ProgressEvent:TF}=lI(),{getEncoding:BI}=hI(),{serializeAMimeType:FF,parseMIMEType:dI}=ye(),{types:SF}=require("node:util"),{StringDecoder:II}=require("string_decoder"),{btoa:CI}=require("node:buffer"),UF={enumerable:!0,writable:!1,configurable:!1};function NF(t,e,r,A){if(t[IA]==="loading")throw new DOMException("Invalid state","InvalidStateError");t[IA]="loading",t[QI]=null,t[gg]=null;let o=e.stream().getReader(),n=[],i=o.read(),a=!0;(async()=>{for(;!t[ps];)try{let{done:c,value:l}=await i;if(a&&!t[ps]&&queueMicrotask(()=>{Xt("loadstart",t)}),a=!1,!c&&SF.isUint8Array(l))n.push(l),(t[ug]===void 0||Date.now()-t[ug]>=50)&&!t[ps]&&(t[ug]=Date.now(),queueMicrotask(()=>{Xt("progress",t)})),i=o.read();else if(c){queueMicrotask(()=>{t[IA]="done";try{let g=GF(n,r,e.type,A);if(t[ps])return;t[QI]=g,Xt("load",t)}catch(g){t[gg]=g,Xt("error",t)}t[IA]!=="loading"&&Xt("loadend",t)});break}}catch(c){if(t[ps])return;queueMicrotask(()=>{t[IA]="done",t[gg]=c,Xt("error",t),t[IA]!=="loading"&&Xt("loadend",t)});break}})()}function Xt(t,e){let r=new TF(t,{bubbles:!1,cancelable:!1});e.dispatchEvent(r)}function GF(t,e,r,A){switch(e){case"DataURL":{let s="data:",o=dI(r||"application/octet-stream");o!=="failure"&&(s+=FF(o)),s+=";base64,";let n=new II("latin1");for(let i of t)s+=CI(n.write(i));return s+=CI(n.end()),s}case"Text":{let s="failure";if(A&&(s=BI(A)),s==="failure"&&r){let o=dI(r);o!=="failure"&&(s=BI(o.parameters.get("charset")))}return s==="failure"&&(s="UTF-8"),MF(t,s)}case"ArrayBuffer":return pI(t).buffer;case"BinaryString":{let s="",o=new II("latin1");for(let n of t)s+=o.write(n);return s+=o.end(),s}}}function MF(t,e){let r=pI(t),A=LF(r),s=0;A!==null&&(e=A,s=A==="UTF-8"?3:2);let o=r.slice(s);return new TextDecoder(e).decode(o)}function LF(t){let[e,r,A]=t;return e===239&&r===187&&A===191?"UTF-8":e===254&&r===255?"UTF-16BE":e===255&&r===254?"UTF-16LE":null}function pI(t){let e=t.reduce((A,s)=>A+s.byteLength,0),r=0;return t.reduce((A,s)=>(A.set(s,r),r+=s.byteLength,A),new Uint8Array(e))}fI.exports={staticPropertyDescriptors:UF,readOperation:NF,fireAProgressEvent:Xt}});var kI=m((tv,bI)=>{"use strict";var{staticPropertyDescriptors:CA,readOperation:In,fireAProgressEvent:wI}=mI(),{kState:br,kError:yI,kResult:Cn,kEvents:W,kAborted:vF}=ag(),{webidl:$}=de(),{kEnumerableProperty:De}=J(),At=class t extends EventTarget{constructor(){super(),this[br]="empty",this[Cn]=null,this[yI]=null,this[W]={loadend:null,error:null,abort:null,load:null,progress:null,loadstart:null}}readAsArrayBuffer(e){$.brandCheck(this,t),$.argumentLengthCheck(arguments,1,"FileReader.readAsArrayBuffer"),e=$.converters.Blob(e,{strict:!1}),In(this,e,"ArrayBuffer")}readAsBinaryString(e){$.brandCheck(this,t),$.argumentLengthCheck(arguments,1,"FileReader.readAsBinaryString"),e=$.converters.Blob(e,{strict:!1}),In(this,e,"BinaryString")}readAsText(e,r=void 0){$.brandCheck(this,t),$.argumentLengthCheck(arguments,1,"FileReader.readAsText"),e=$.converters.Blob(e,{strict:!1}),r!==void 0&&(r=$.converters.DOMString(r,"FileReader.readAsText","encoding")),In(this,e,"Text",r)}readAsDataURL(e){$.brandCheck(this,t),$.argumentLengthCheck(arguments,1,"FileReader.readAsDataURL"),e=$.converters.Blob(e,{strict:!1}),In(this,e,"DataURL")}abort(){if(this[br]==="empty"||this[br]==="done"){this[Cn]=null;return}this[br]==="loading"&&(this[br]="done",this[Cn]=null),this[vF]=!0,wI("abort",this),this[br]!=="loading"&&wI("loadend",this)}get readyState(){switch($.brandCheck(this,t),this[br]){case"empty":return this.EMPTY;case"loading":return this.LOADING;case"done":return this.DONE}}get result(){return $.brandCheck(this,t),this[Cn]}get error(){return $.brandCheck(this,t),this[yI]}get onloadend(){return $.brandCheck(this,t),this[W].loadend}set onloadend(e){$.brandCheck(this,t),this[W].loadend&&this.removeEventListener("loadend",this[W].loadend),typeof e=="function"?(this[W].loadend=e,this.addEventListener("loadend",e)):this[W].loadend=null}get onerror(){return $.brandCheck(this,t),this[W].error}set onerror(e){$.brandCheck(this,t),this[W].error&&this.removeEventListener("error",this[W].error),typeof e=="function"?(this[W].error=e,this.addEventListener("error",e)):this[W].error=null}get onloadstart(){return $.brandCheck(this,t),this[W].loadstart}set onloadstart(e){$.brandCheck(this,t),this[W].loadstart&&this.removeEventListener("loadstart",this[W].loadstart),typeof e=="function"?(this[W].loadstart=e,this.addEventListener("loadstart",e)):this[W].loadstart=null}get onprogress(){return $.brandCheck(this,t),this[W].progress}set onprogress(e){$.brandCheck(this,t),this[W].progress&&this.removeEventListener("progress",this[W].progress),typeof e=="function"?(this[W].progress=e,this.addEventListener("progress",e)):this[W].progress=null}get onload(){return $.brandCheck(this,t),this[W].load}set onload(e){$.brandCheck(this,t),this[W].load&&this.removeEventListener("load",this[W].load),typeof e=="function"?(this[W].load=e,this.addEventListener("load",e)):this[W].load=null}get onabort(){return $.brandCheck(this,t),this[W].abort}set onabort(e){$.brandCheck(this,t),this[W].abort&&this.removeEventListener("abort",this[W].abort),typeof e=="function"?(this[W].abort=e,this.addEventListener("abort",e)):this[W].abort=null}};At.EMPTY=At.prototype.EMPTY=0;At.LOADING=At.prototype.LOADING=1;At.DONE=At.prototype.DONE=2;Object.defineProperties(At.prototype,{EMPTY:CA,LOADING:CA,DONE:CA,readAsArrayBuffer:De,readAsBinaryString:De,readAsText:De,readAsDataURL:De,abort:De,readyState:De,result:De,error:De,onloadstart:De,onprogress:De,onload:De,onabort:De,onerror:De,onloadend:De,[Symbol.toStringTag]:{value:"FileReader",writable:!1,enumerable:!1,configurable:!0}});Object.defineProperties(At,{EMPTY:CA,LOADING:CA,DONE:CA});bI.exports={FileReader:At}});var pn=m((rv,DI)=>{"use strict";DI.exports={kConstruct:se().kConstruct}});var FI=m((Av,TI)=>{"use strict";var _F=require("node:assert"),{URLSerializer:RI}=ye(),{isValidHeaderName:xF}=Fe();function YF(t,e,r=!1){let A=RI(t,r),s=RI(e,r);return A===s}function JF(t){_F(t!==null);let e=[];for(let r of t.split(","))r=r.trim(),xF(r)&&e.push(r);return e}TI.exports={urlEquals:YF,getFieldValues:JF}});var NI=m((sv,UI)=>{"use strict";var{kConstruct:OF}=pn(),{urlEquals:HF,getFieldValues:lg}=FI(),{kEnumerableProperty:kr,isDisturbed:PF}=J(),{webidl:N}=de(),{Response:VF,cloneResponse:qF,fromInnerResponse:WF}=ds(),{Request:Ut,fromInnerRequest:zF}=dA(),{kState:st}=xt(),{fetching:ZF}=Cs(),{urlIsHttpHttpsScheme:fn,createDeferredPromise:pA,readAllBytes:KF}=Fe(),Eg=require("node:assert"),mn=class t{#e;constructor(){arguments[0]!==OF&&N.illegalConstructor(),N.util.markAsUncloneable(this),this.#e=arguments[1]}async match(e,r={}){N.brandCheck(this,t);let A="Cache.match";N.argumentLengthCheck(arguments,1,A),e=N.converters.RequestInfo(e,A,"request"),r=N.converters.CacheQueryOptions(r,A,"options");let s=this.#s(e,r,1);if(s.length!==0)return s[0]}async matchAll(e=void 0,r={}){N.brandCheck(this,t);let A="Cache.matchAll";return e!==void 0&&(e=N.converters.RequestInfo(e,A,"request")),r=N.converters.CacheQueryOptions(r,A,"options"),this.#s(e,r)}async add(e){N.brandCheck(this,t);let r="Cache.add";N.argumentLengthCheck(arguments,1,r),e=N.converters.RequestInfo(e,r,"request");let A=[e];return await this.addAll(A)}async addAll(e){N.brandCheck(this,t);let r="Cache.addAll";N.argumentLengthCheck(arguments,1,r);let A=[],s=[];for(let E of e){if(E===void 0)throw N.errors.conversionFailed({prefix:r,argument:"Argument 1",types:["undefined is not allowed"]});if(E=N.converters.RequestInfo(E),typeof E=="string")continue;let d=E[st];if(!fn(d.url)||d.method!=="GET")throw N.errors.exception({header:r,message:"Expected http/s scheme when method is not GET."})}let o=[];for(let E of e){let d=new Ut(E)[st];if(!fn(d.url))throw N.errors.exception({header:r,message:"Expected http/s scheme."});d.initiator="fetch",d.destination="subresource",s.push(d);let B=pA();o.push(ZF({request:d,processResponse(p){if(p.type==="error"||p.status===206||p.status<200||p.status>299)B.reject(N.errors.exception({header:"Cache.addAll",message:"Received an invalid status code or the request failed."}));else if(p.headersList.contains("vary")){let w=lg(p.headersList.get("vary"));for(let I of w)if(I==="*"){B.reject(N.errors.exception({header:"Cache.addAll",message:"invalid vary field value"}));for(let y of o)y.abort();return}}},processResponseEndOfBody(p){if(p.aborted){B.reject(new DOMException("aborted","AbortError"));return}B.resolve(p)}})),A.push(B.promise)}let i=await Promise.all(A),a=[],c=0;for(let E of i){let d={type:"put",request:s[c],response:E};a.push(d),c++}let l=pA(),g=null;try{this.#t(a)}catch(E){g=E}return queueMicrotask(()=>{g===null?l.resolve(void 0):l.reject(g)}),l.promise}async put(e,r){N.brandCheck(this,t);let A="Cache.put";N.argumentLengthCheck(arguments,2,A),e=N.converters.RequestInfo(e,A,"request"),r=N.converters.Response(r,A,"response");let s=null;if(e instanceof Ut?s=e[st]:s=new Ut(e)[st],!fn(s.url)||s.method!=="GET")throw N.errors.exception({header:A,message:"Expected an http/s scheme when method is not GET"});let o=r[st];if(o.status===206)throw N.errors.exception({header:A,message:"Got 206 status"});if(o.headersList.contains("vary")){let d=lg(o.headersList.get("vary"));for(let B of d)if(B==="*")throw N.errors.exception({header:A,message:"Got * vary field value"})}if(o.body&&(PF(o.body.stream)||o.body.stream.locked))throw N.errors.exception({header:A,message:"Response body is locked or disturbed"});let n=qF(o),i=pA();if(o.body!=null){let B=o.body.stream.getReader();KF(B).then(i.resolve,i.reject)}else i.resolve(void 0);let a=[],c={type:"put",request:s,response:n};a.push(c);let l=await i.promise;n.body!=null&&(n.body.source=l);let g=pA(),E=null;try{this.#t(a)}catch(d){E=d}return queueMicrotask(()=>{E===null?g.resolve():g.reject(E)}),g.promise}async delete(e,r={}){N.brandCheck(this,t);let A="Cache.delete";N.argumentLengthCheck(arguments,1,A),e=N.converters.RequestInfo(e,A,"request"),r=N.converters.CacheQueryOptions(r,A,"options");let s=null;if(e instanceof Ut){if(s=e[st],s.method!=="GET"&&!r.ignoreMethod)return!1}else Eg(typeof e=="string"),s=new Ut(e)[st];let o=[],n={type:"delete",request:s,options:r};o.push(n);let i=pA(),a=null,c;try{c=this.#t(o)}catch(l){a=l}return queueMicrotask(()=>{a===null?i.resolve(!!c?.length):i.reject(a)}),i.promise}async keys(e=void 0,r={}){N.brandCheck(this,t);let A="Cache.keys";e!==void 0&&(e=N.converters.RequestInfo(e,A,"request")),r=N.converters.CacheQueryOptions(r,A,"options");let s=null;if(e!==void 0)if(e instanceof Ut){if(s=e[st],s.method!=="GET"&&!r.ignoreMethod)return[]}else typeof e=="string"&&(s=new Ut(e)[st]);let o=pA(),n=[];if(e===void 0)for(let i of this.#e)n.push(i[0]);else{let i=this.#r(s,r);for(let a of i)n.push(a[0])}return queueMicrotask(()=>{let i=[];for(let a of n){let c=zF(a,new AbortController().signal,"immutable");i.push(c)}o.resolve(Object.freeze(i))}),o.promise}#t(e){let r=this.#e,A=[...r],s=[],o=[];try{for(let n of e){if(n.type!=="delete"&&n.type!=="put")throw N.errors.exception({header:"Cache.#batchCacheOperations",message:'operation type does not match "delete" or "put"'});if(n.type==="delete"&&n.response!=null)throw N.errors.exception({header:"Cache.#batchCacheOperations",message:"delete operation should not have an associated response"});if(this.#r(n.request,n.options,s).length)throw new DOMException("???","InvalidStateError");let i;if(n.type==="delete"){if(i=this.#r(n.request,n.options),i.length===0)return[];for(let a of i){let c=r.indexOf(a);Eg(c!==-1),r.splice(c,1)}}else if(n.type==="put"){if(n.response==null)throw N.errors.exception({header:"Cache.#batchCacheOperations",message:"put operation should have an associated response"});let a=n.request;if(!fn(a.url))throw N.errors.exception({header:"Cache.#batchCacheOperations",message:"expected http or https scheme"});if(a.method!=="GET")throw N.errors.exception({header:"Cache.#batchCacheOperations",message:"not get method"});if(n.options!=null)throw N.errors.exception({header:"Cache.#batchCacheOperations",message:"options must not be defined"});i=this.#r(n.request);for(let c of i){let l=r.indexOf(c);Eg(l!==-1),r.splice(l,1)}r.push([n.request,n.response]),s.push([n.request,n.response])}o.push([n.request,n.response])}return o}catch(n){throw this.#e.length=0,this.#e=A,n}}#r(e,r,A){let s=[],o=A??this.#e;for(let n of o){let[i,a]=n;this.#o(e,i,a,r)&&s.push(n)}return s}#o(e,r,A=null,s){let o=new URL(e.url),n=new URL(r.url);if(s?.ignoreSearch&&(n.search="",o.search=""),!HF(o,n,!0))return!1;if(A==null||s?.ignoreVary||!A.headersList.contains("vary"))return!0;let i=lg(A.headersList.get("vary"));for(let a of i){if(a==="*")return!1;let c=r.headersList.get(a),l=e.headersList.get(a);if(c!==l)return!1}return!0}#s(e,r,A=1/0){let s=null;if(e!==void 0)if(e instanceof Ut){if(s=e[st],s.method!=="GET"&&!r.ignoreMethod)return[]}else typeof e=="string"&&(s=new Ut(e)[st]);let o=[];if(e===void 0)for(let i of this.#e)o.push(i[1]);else{let i=this.#r(s,r);for(let a of i)o.push(a[1])}let n=[];for(let i of o){let a=WF(i,"immutable");if(n.push(a.clone()),n.length>=A)break}return Object.freeze(n)}};Object.defineProperties(mn.prototype,{[Symbol.toStringTag]:{value:"Cache",configurable:!0},match:kr,matchAll:kr,add:kr,addAll:kr,put:kr,delete:kr,keys:kr});var SI=[{key:"ignoreSearch",converter:N.converters.boolean,defaultValue:()=>!1},{key:"ignoreMethod",converter:N.converters.boolean,defaultValue:()=>!1},{key:"ignoreVary",converter:N.converters.boolean,defaultValue:()=>!1}];N.converters.CacheQueryOptions=N.dictionaryConverter(SI);N.converters.MultiCacheQueryOptions=N.dictionaryConverter([...SI,{key:"cacheName",converter:N.converters.DOMString}]);N.converters.Response=N.interfaceConverter(VF);N.converters["sequence"]=N.sequenceConverter(N.converters.RequestInfo);UI.exports={Cache:mn}});var MI=m((ov,GI)=>{"use strict";var{kConstruct:fs}=pn(),{Cache:wn}=NI(),{webidl:pe}=de(),{kEnumerableProperty:ms}=J(),yn=class t{#e=new Map;constructor(){arguments[0]!==fs&&pe.illegalConstructor(),pe.util.markAsUncloneable(this)}async match(e,r={}){if(pe.brandCheck(this,t),pe.argumentLengthCheck(arguments,1,"CacheStorage.match"),e=pe.converters.RequestInfo(e),r=pe.converters.MultiCacheQueryOptions(r),r.cacheName!=null){if(this.#e.has(r.cacheName)){let A=this.#e.get(r.cacheName);return await new wn(fs,A).match(e,r)}}else for(let A of this.#e.values()){let o=await new wn(fs,A).match(e,r);if(o!==void 0)return o}}async has(e){pe.brandCheck(this,t);let r="CacheStorage.has";return pe.argumentLengthCheck(arguments,1,r),e=pe.converters.DOMString(e,r,"cacheName"),this.#e.has(e)}async open(e){pe.brandCheck(this,t);let r="CacheStorage.open";if(pe.argumentLengthCheck(arguments,1,r),e=pe.converters.DOMString(e,r,"cacheName"),this.#e.has(e)){let s=this.#e.get(e);return new wn(fs,s)}let A=[];return this.#e.set(e,A),new wn(fs,A)}async delete(e){pe.brandCheck(this,t);let r="CacheStorage.delete";return pe.argumentLengthCheck(arguments,1,r),e=pe.converters.DOMString(e,r,"cacheName"),this.#e.delete(e)}async keys(){return pe.brandCheck(this,t),[...this.#e.keys()]}};Object.defineProperties(yn.prototype,{[Symbol.toStringTag]:{value:"CacheStorage",configurable:!0},match:ms,has:ms,open:ms,delete:ms,keys:ms});GI.exports={CacheStorage:yn}});var vI=m((nv,LI)=>{"use strict";LI.exports={maxAttributeValueSize:1024,maxNameValuePairSize:4096}});var hg=m((iv,OI)=>{"use strict";function jF(t){for(let e=0;e=0&&r<=8||r>=10&&r<=31||r===127)return!0}return!1}function _I(t){for(let e=0;e126||r===34||r===40||r===41||r===60||r===62||r===64||r===44||r===59||r===58||r===92||r===47||r===91||r===93||r===63||r===61||r===123||r===125)throw new Error("Invalid cookie name")}}function xI(t){let e=t.length,r=0;if(t[0]==='"'){if(e===1||t[e-1]!=='"')throw new Error("Invalid cookie value");--e,++r}for(;r126||A===34||A===44||A===59||A===92)throw new Error("Invalid cookie value")}}function YI(t){for(let e=0;ee.toString().padStart(2,"0"));function JI(t){return typeof t=="number"&&(t=new Date(t)),`${$F[t.getUTCDay()]}, ${bn[t.getUTCDate()]} ${eS[t.getUTCMonth()]} ${t.getUTCFullYear()} ${bn[t.getUTCHours()]}:${bn[t.getUTCMinutes()]}:${bn[t.getUTCSeconds()]} GMT`}function tS(t){if(t<0)throw new Error("Invalid cookie max-age")}function rS(t){if(t.name.length===0)return null;_I(t.name),xI(t.value);let e=[`${t.name}=${t.value}`];t.name.startsWith("__Secure-")&&(t.secure=!0),t.name.startsWith("__Host-")&&(t.secure=!0,t.domain=null,t.path="/"),t.secure&&e.push("Secure"),t.httpOnly&&e.push("HttpOnly"),typeof t.maxAge=="number"&&(tS(t.maxAge),e.push(`Max-Age=${t.maxAge}`)),t.domain&&(XF(t.domain),e.push(`Domain=${t.domain}`)),t.path&&(YI(t.path),e.push(`Path=${t.path}`)),t.expires&&t.expires.toString()!=="Invalid Date"&&e.push(`Expires=${JI(t.expires)}`),t.sameSite&&e.push(`SameSite=${t.sameSite}`);for(let r of t.unparsed){if(!r.includes("="))throw new Error("Invalid unparsed");let[A,...s]=r.split("=");e.push(`${A.trim()}=${s.join("=")}`)}return e.join("; ")}OI.exports={isCTLExcludingHtab:jF,validateCookieName:_I,validateCookiePath:YI,validateCookieValue:xI,toIMFDate:JI,stringify:rS}});var PI=m((av,HI)=>{"use strict";var{maxNameValuePairSize:AS,maxAttributeValueSize:sS}=vI(),{isCTLExcludingHtab:oS}=hg(),{collectASequenceOfCodePointsFast:kn}=ye(),nS=require("node:assert");function iS(t){if(oS(t))return null;let e="",r="",A="",s="";if(t.includes(";")){let o={position:0};e=kn(";",t,o),r=t.slice(o.position)}else e=t;if(!e.includes("="))s=e;else{let o={position:0};A=kn("=",e,o),s=e.slice(o.position+1)}return A=A.trim(),s=s.trim(),A.length+s.length>AS?null:{name:A,value:s,...fA(r)}}function fA(t,e={}){if(t.length===0)return e;nS(t[0]===";"),t=t.slice(1);let r="";t.includes(";")?(r=kn(";",t,{position:0}),t=t.slice(r.length)):(r=t,t="");let A="",s="";if(r.includes("=")){let n={position:0};A=kn("=",r,n),s=r.slice(n.position+1)}else A=r;if(A=A.trim(),s=s.trim(),s.length>sS)return fA(t,e);let o=A.toLowerCase();if(o==="expires"){let n=new Date(s);e.expires=n}else if(o==="max-age"){let n=s.charCodeAt(0);if((n<48||n>57)&&s[0]!=="-"||!/^\d+$/.test(s))return fA(t,e);let i=Number(s);e.maxAge=i}else if(o==="domain"){let n=s;n[0]==="."&&(n=n.slice(1)),n=n.toLowerCase(),e.domain=n}else if(o==="path"){let n="";s.length===0||s[0]!=="/"?n="/":n=s,e.path=n}else if(o==="secure")e.secure=!0;else if(o==="httponly")e.httpOnly=!0;else if(o==="samesite"){let n=s.toLowerCase();n==="none"?e.sameSite="None":n==="strict"?e.sameSite="Strict":n==="lax"&&(e.sameSite="Lax")}else e.unparsed??=[],e.unparsed.push(`${A}=${s}`);return fA(t,e)}HI.exports={parseSetCookie:iS,parseUnparsedAttributes:fA}});var WI=m((cv,qI)=>{"use strict";var{parseSetCookie:aS}=PI(),{stringify:cS}=hg(),{webidl:P}=de(),{Headers:Dn}=fr();function gS(t){P.argumentLengthCheck(arguments,1,"getCookies"),P.brandCheck(t,Dn,{strict:!1});let e=t.get("cookie"),r={};if(!e)return r;for(let A of e.split(";")){let[s,...o]=A.split("=");r[s.trim()]=o.join("=")}return r}function uS(t,e,r){P.brandCheck(t,Dn,{strict:!1});let A="deleteCookie";P.argumentLengthCheck(arguments,2,A),e=P.converters.DOMString(e,A,"name"),r=P.converters.DeleteCookieAttributes(r),VI(t,{name:e,value:"",expires:new Date(0),...r})}function lS(t){P.argumentLengthCheck(arguments,1,"getSetCookies"),P.brandCheck(t,Dn,{strict:!1});let e=t.getSetCookie();return e?e.map(r=>aS(r)):[]}function VI(t,e){P.argumentLengthCheck(arguments,2,"setCookie"),P.brandCheck(t,Dn,{strict:!1}),e=P.converters.Cookie(e);let r=cS(e);r&&t.append("Set-Cookie",r)}P.converters.DeleteCookieAttributes=P.dictionaryConverter([{converter:P.nullableConverter(P.converters.DOMString),key:"path",defaultValue:()=>null},{converter:P.nullableConverter(P.converters.DOMString),key:"domain",defaultValue:()=>null}]);P.converters.Cookie=P.dictionaryConverter([{converter:P.converters.DOMString,key:"name"},{converter:P.converters.DOMString,key:"value"},{converter:P.nullableConverter(t=>typeof t=="number"?P.converters["unsigned long long"](t):new Date(t)),key:"expires",defaultValue:()=>null},{converter:P.nullableConverter(P.converters["long long"]),key:"maxAge",defaultValue:()=>null},{converter:P.nullableConverter(P.converters.DOMString),key:"domain",defaultValue:()=>null},{converter:P.nullableConverter(P.converters.DOMString),key:"path",defaultValue:()=>null},{converter:P.nullableConverter(P.converters.boolean),key:"secure",defaultValue:()=>null},{converter:P.nullableConverter(P.converters.boolean),key:"httpOnly",defaultValue:()=>null},{converter:P.converters.USVString,key:"sameSite",allowedValues:["Strict","Lax","None"]},{converter:P.sequenceConverter(P.converters.DOMString),key:"unparsed",defaultValue:()=>new Array(0)}]);qI.exports={getCookies:gS,deleteCookie:uS,getSetCookies:lS,setCookie:VI}});var wA=m((gv,ZI)=>{"use strict";var{webidl:U}=de(),{kEnumerableProperty:Re}=J(),{kConstruct:zI}=se(),{MessagePort:ES}=require("node:worker_threads"),mA=class t extends Event{#e;constructor(e,r={}){if(e===zI){super(arguments[1],arguments[2]),U.util.markAsUncloneable(this);return}let A="MessageEvent constructor";U.argumentLengthCheck(arguments,1,A),e=U.converters.DOMString(e,A,"type"),r=U.converters.MessageEventInit(r,A,"eventInitDict"),super(e,r),this.#e=r,U.util.markAsUncloneable(this)}get data(){return U.brandCheck(this,t),this.#e.data}get origin(){return U.brandCheck(this,t),this.#e.origin}get lastEventId(){return U.brandCheck(this,t),this.#e.lastEventId}get source(){return U.brandCheck(this,t),this.#e.source}get ports(){return U.brandCheck(this,t),Object.isFrozen(this.#e.ports)||Object.freeze(this.#e.ports),this.#e.ports}initMessageEvent(e,r=!1,A=!1,s=null,o="",n="",i=null,a=[]){return U.brandCheck(this,t),U.argumentLengthCheck(arguments,1,"MessageEvent.initMessageEvent"),new t(e,{bubbles:r,cancelable:A,data:s,origin:o,lastEventId:n,source:i,ports:a})}static createFastMessageEvent(e,r){let A=new t(zI,e,r);return A.#e=r,A.#e.data??=null,A.#e.origin??="",A.#e.lastEventId??="",A.#e.source??=null,A.#e.ports??=[],A}},{createFastMessageEvent:hS}=mA;delete mA.createFastMessageEvent;var Rn=class t extends Event{#e;constructor(e,r={}){let A="CloseEvent constructor";U.argumentLengthCheck(arguments,1,A),e=U.converters.DOMString(e,A,"type"),r=U.converters.CloseEventInit(r),super(e,r),this.#e=r,U.util.markAsUncloneable(this)}get wasClean(){return U.brandCheck(this,t),this.#e.wasClean}get code(){return U.brandCheck(this,t),this.#e.code}get reason(){return U.brandCheck(this,t),this.#e.reason}},Tn=class t extends Event{#e;constructor(e,r){let A="ErrorEvent constructor";U.argumentLengthCheck(arguments,1,A),super(e,r),U.util.markAsUncloneable(this),e=U.converters.DOMString(e,A,"type"),r=U.converters.ErrorEventInit(r??{}),this.#e=r}get message(){return U.brandCheck(this,t),this.#e.message}get filename(){return U.brandCheck(this,t),this.#e.filename}get lineno(){return U.brandCheck(this,t),this.#e.lineno}get colno(){return U.brandCheck(this,t),this.#e.colno}get error(){return U.brandCheck(this,t),this.#e.error}};Object.defineProperties(mA.prototype,{[Symbol.toStringTag]:{value:"MessageEvent",configurable:!0},data:Re,origin:Re,lastEventId:Re,source:Re,ports:Re,initMessageEvent:Re});Object.defineProperties(Rn.prototype,{[Symbol.toStringTag]:{value:"CloseEvent",configurable:!0},reason:Re,code:Re,wasClean:Re});Object.defineProperties(Tn.prototype,{[Symbol.toStringTag]:{value:"ErrorEvent",configurable:!0},message:Re,filename:Re,lineno:Re,colno:Re,error:Re});U.converters.MessagePort=U.interfaceConverter(ES);U.converters["sequence"]=U.sequenceConverter(U.converters.MessagePort);var Qg=[{key:"bubbles",converter:U.converters.boolean,defaultValue:()=>!1},{key:"cancelable",converter:U.converters.boolean,defaultValue:()=>!1},{key:"composed",converter:U.converters.boolean,defaultValue:()=>!1}];U.converters.MessageEventInit=U.dictionaryConverter([...Qg,{key:"data",converter:U.converters.any,defaultValue:()=>null},{key:"origin",converter:U.converters.USVString,defaultValue:()=>""},{key:"lastEventId",converter:U.converters.DOMString,defaultValue:()=>""},{key:"source",converter:U.nullableConverter(U.converters.MessagePort),defaultValue:()=>null},{key:"ports",converter:U.converters["sequence"],defaultValue:()=>new Array(0)}]);U.converters.CloseEventInit=U.dictionaryConverter([...Qg,{key:"wasClean",converter:U.converters.boolean,defaultValue:()=>!1},{key:"code",converter:U.converters["unsigned short"],defaultValue:()=>0},{key:"reason",converter:U.converters.USVString,defaultValue:()=>""}]);U.converters.ErrorEventInit=U.dictionaryConverter([...Qg,{key:"message",converter:U.converters.DOMString,defaultValue:()=>""},{key:"filename",converter:U.converters.USVString,defaultValue:()=>""},{key:"lineno",converter:U.converters["unsigned long"],defaultValue:()=>0},{key:"colno",converter:U.converters["unsigned long"],defaultValue:()=>0},{key:"error",converter:U.converters.any}]);ZI.exports={MessageEvent:mA,CloseEvent:Rn,ErrorEvent:Tn,createFastMessageEvent:hS}});var Dr=m((uv,KI)=>{"use strict";var QS="258EAFA5-E914-47DA-95CA-C5AB0DC85B11",BS={enumerable:!0,writable:!1,configurable:!1},dS={CONNECTING:0,OPEN:1,CLOSING:2,CLOSED:3},IS={NOT_SENT:0,PROCESSING:1,SENT:2},CS={CONTINUATION:0,TEXT:1,BINARY:2,CLOSE:8,PING:9,PONG:10},pS=2**16-1,fS={INFO:0,PAYLOADLENGTH_16:2,PAYLOADLENGTH_64:3,READ_DATA:4},mS=Buffer.allocUnsafe(0),wS={string:1,typedArray:2,arrayBuffer:3,blob:4};KI.exports={uid:QS,sentCloseFrameState:IS,staticPropertyDescriptors:BS,states:dS,opcodes:CS,maxUnsigned16Bit:pS,parserStates:fS,emptyBuffer:mS,sendHints:wS}});var ws=m((lv,jI)=>{"use strict";jI.exports={kWebSocketURL:Symbol("url"),kReadyState:Symbol("ready state"),kController:Symbol("controller"),kResponse:Symbol("response"),kBinaryType:Symbol("binary type"),kSentClose:Symbol("sent close"),kReceivedClose:Symbol("received close"),kByteParser:Symbol("byte parser")}});var ks=m((Ev,nC)=>{"use strict";var{kReadyState:ys,kController:yS,kResponse:bS,kBinaryType:kS,kWebSocketURL:DS}=ws(),{states:bs,opcodes:$t}=Dr(),{ErrorEvent:RS,createFastMessageEvent:TS}=wA(),{isUtf8:FS}=require("node:buffer"),{collectASequenceOfCodePointsFast:SS,removeHTTPWhitespace:XI}=ye();function US(t){return t[ys]===bs.CONNECTING}function NS(t){return t[ys]===bs.OPEN}function GS(t){return t[ys]===bs.CLOSING}function MS(t){return t[ys]===bs.CLOSED}function Bg(t,e,r=(s,o)=>new Event(s,o),A={}){let s=r(t,A);e.dispatchEvent(s)}function LS(t,e,r){if(t[ys]!==bs.OPEN)return;let A;if(e===$t.TEXT)try{A=oC(r)}catch{eC(t,"Received invalid UTF-8 in text frame.");return}else e===$t.BINARY&&(t[kS]==="blob"?A=new Blob([r]):A=vS(r));Bg("message",t,TS,{origin:t[DS].origin,data:A})}function vS(t){return t.byteLength===t.buffer.byteLength?t.buffer:t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength)}function _S(t){if(t.length===0)return!1;for(let e=0;e126||r===34||r===40||r===41||r===44||r===47||r===58||r===59||r===60||r===61||r===62||r===63||r===64||r===91||r===92||r===93||r===123||r===125)return!1}return!0}function xS(t){return t>=1e3&&t<1015?t!==1004&&t!==1005&&t!==1006:t>=3e3&&t<=4999}function eC(t,e){let{[yS]:r,[bS]:A}=t;r.abort(),A?.socket&&!A.socket.destroyed&&A.socket.destroy(),e&&Bg("error",t,(s,o)=>new RS(s,o),{error:new Error(e),message:e})}function tC(t){return t===$t.CLOSE||t===$t.PING||t===$t.PONG}function rC(t){return t===$t.CONTINUATION}function AC(t){return t===$t.TEXT||t===$t.BINARY}function YS(t){return AC(t)||rC(t)||tC(t)}function JS(t){let e={position:0},r=new Map;for(;e.position57)return!1}let e=Number.parseInt(t,10);return e>=8&&e<=15}var sC=typeof process.versions.icu=="string",$I=sC?new TextDecoder("utf-8",{fatal:!0}):void 0,oC=sC?$I.decode.bind($I):function(t){if(FS(t))return t.toString("utf-8");throw new TypeError("Invalid utf-8 received.")};nC.exports={isConnecting:US,isEstablished:NS,isClosing:GS,isClosed:MS,fireEvent:Bg,isValidSubprotocol:_S,isValidStatusCode:xS,failWebsocketConnection:eC,websocketMessageReceived:LS,utf8Decode:oC,isControlFrame:tC,isContinuationFrame:rC,isTextBinaryFrame:AC,isValidOpcode:YS,parseExtensions:JS,isValidClientWindowBits:OS}});var Sn=m((hv,iC)=>{"use strict";var{maxUnsigned16Bit:HS}=Dr(),Fn=16386,dg,Ds=null,yA=Fn;try{dg=require("node:crypto")}catch{dg={randomFillSync:function(e,r,A){for(let s=0;sHS?(n+=8,o=127):s>125&&(n+=2,o=126);let i=Buffer.allocUnsafe(s+n);i[0]=i[1]=0,i[0]|=128,i[0]=(i[0]&240)+e;i[n-4]=A[0],i[n-3]=A[1],i[n-2]=A[2],i[n-1]=A[3],i[1]=o,o===126?i.writeUInt16BE(s,2):o===127&&(i[2]=i[3]=0,i.writeUIntBE(s,4,6)),i[1]|=128;for(let a=0;a{"use strict";var{uid:VS,states:Rs,sentCloseFrameState:Un,emptyBuffer:qS,opcodes:WS}=Dr(),{kReadyState:Ts,kSentClose:Nn,kByteParser:cC,kReceivedClose:aC,kResponse:gC}=ws(),{fireEvent:zS,failWebsocketConnection:er,isClosing:ZS,isClosed:KS,isEstablished:jS,parseExtensions:XS}=ks(),{channels:bA}=Lr(),{CloseEvent:$S}=wA(),{makeRequest:eU}=dA(),{fetching:tU}=Cs(),{Headers:rU,getHeadersList:AU}=fr(),{getDecodeSplit:sU}=Fe(),{WebsocketFrameSend:oU}=Sn(),Cg;try{Cg=require("node:crypto")}catch{}function nU(t,e,r,A,s,o){let n=t;n.protocol=t.protocol==="ws:"?"http:":"https:";let i=eU({urlList:[n],client:r,serviceWorkers:"none",referrer:"no-referrer",mode:"websocket",credentials:"include",cache:"no-store",redirect:"error"});if(o.headers){let g=AU(new rU(o.headers));i.headersList=g}let a=Cg.randomBytes(16).toString("base64");i.headersList.append("sec-websocket-key",a),i.headersList.append("sec-websocket-version","13");for(let g of e)i.headersList.append("sec-websocket-protocol",g);return i.headersList.append("sec-websocket-extensions","permessage-deflate; client_max_window_bits"),tU({request:i,useParallelQueue:!0,dispatcher:o.dispatcher,processResponse(g){if(g.type==="error"||g.status!==101){er(A,"Received network error or non-101 status code.");return}if(e.length!==0&&!g.headersList.get("Sec-WebSocket-Protocol")){er(A,"Server did not respond with sent protocols.");return}if(g.headersList.get("Upgrade")?.toLowerCase()!=="websocket"){er(A,'Server did not set Upgrade header to "websocket".');return}if(g.headersList.get("Connection")?.toLowerCase()!=="upgrade"){er(A,'Server did not set Connection header to "upgrade".');return}let E=g.headersList.get("Sec-WebSocket-Accept"),d=Cg.createHash("sha1").update(a+VS).digest("base64");if(E!==d){er(A,"Incorrect hash received in Sec-WebSocket-Accept header.");return}let B=g.headersList.get("Sec-WebSocket-Extensions"),p;if(B!==null&&(p=XS(B),!p.has("permessage-deflate"))){er(A,"Sec-WebSocket-Extensions header does not match.");return}let w=g.headersList.get("Sec-WebSocket-Protocol");if(w!==null&&!sU("sec-websocket-protocol",i.headersList).includes(w)){er(A,"Protocol was not set in the opening handshake.");return}g.socket.on("data",uC),g.socket.on("close",lC),g.socket.on("error",EC),bA.open.hasSubscribers&&bA.open.publish({address:g.socket.address(),protocol:w,extensions:B}),s(g,p)}})}function iU(t,e,r,A){if(!(ZS(t)||KS(t)))if(!jS(t))er(t,"Connection was closed before it was established."),t[Ts]=Rs.CLOSING;else if(t[Nn]===Un.NOT_SENT){t[Nn]=Un.PROCESSING;let s=new oU;e!==void 0&&r===void 0?(s.frameData=Buffer.allocUnsafe(2),s.frameData.writeUInt16BE(e,0)):e!==void 0&&r!==void 0?(s.frameData=Buffer.allocUnsafe(2+A),s.frameData.writeUInt16BE(e,0),s.frameData.write(r,2,"utf-8")):s.frameData=qS,t[gC].socket.write(s.createFrame(WS.CLOSE)),t[Nn]=Un.SENT,t[Ts]=Rs.CLOSING}else t[Ts]=Rs.CLOSING}function uC(t){this.ws[cC].write(t)||this.pause()}function lC(){let{ws:t}=this,{[gC]:e}=t;e.socket.off("data",uC),e.socket.off("close",lC),e.socket.off("error",EC);let r=t[Nn]===Un.SENT&&t[aC],A=1005,s="",o=t[cC].closingInfo;o&&!o.error?(A=o.code??1005,s=o.reason):t[aC]||(A=1006),t[Ts]=Rs.CLOSED,zS("close",t,(n,i)=>new $S(n,i),{wasClean:r,code:A,reason:s}),bA.close.hasSubscribers&&bA.close.publish({websocket:t,code:A,reason:s})}function EC(t){let{ws:e}=this;e[Ts]=Rs.CLOSING,bA.socketError.hasSubscribers&&bA.socketError.publish(t),this.destroy()}hC.exports={establishWebSocketConnection:nU,closeWebSocketConnection:iU}});var BC=m((Bv,QC)=>{"use strict";var{createInflateRaw:aU,Z_DEFAULT_WINDOWBITS:cU}=require("node:zlib"),{isValidClientWindowBits:gU}=ks(),{MessageSizeExceededError:uU}=q(),lU=Buffer.from([0,0,255,255]),Gn=Symbol("kBuffer"),Fs=Symbol("kLength"),fg=class{#e;#t={};#r=0;constructor(e,r){this.#t.serverNoContextTakeover=e.has("server_no_context_takeover"),this.#t.serverMaxWindowBits=e.get("server_max_window_bits"),this.#r=r.maxPayloadSize}decompress(e,r,A){if(!this.#e){let s=cU;if(this.#t.serverMaxWindowBits){if(!gU(this.#t.serverMaxWindowBits)){A(new Error("Invalid server_max_window_bits"));return}s=Number.parseInt(this.#t.serverMaxWindowBits)}try{this.#e=aU({windowBits:s})}catch(o){A(o);return}this.#e[Gn]=[],this.#e[Fs]=0,this.#e.on("data",o=>{if(this.#e[Fs]+=o.length,this.#r>0&&this.#e[Fs]>this.#r){A(new uU),this.#e.removeAllListeners(),this.#e=null;return}this.#e[Gn].push(o)}),this.#e.on("error",o=>{this.#e=null,A(o)})}this.#e.write(e),r&&this.#e.write(lU),this.#e.flush(()=>{if(!this.#e)return;let s=Buffer.concat(this.#e[Gn],this.#e[Fs]);this.#e[Gn].length=0,this.#e[Fs]=0,A(null,s)})}};QC.exports={PerMessageDeflate:fg}});var kC=m((dv,bC)=>{"use strict";var{Writable:EU}=require("node:stream"),hU=require("node:assert"),{parserStates:Te,opcodes:kA,states:QU,emptyBuffer:dC,sentCloseFrameState:IC}=Dr(),{kReadyState:BU,kSentClose:CC,kResponse:pC,kReceivedClose:fC}=ws(),{channels:Mn}=Lr(),{isValidStatusCode:dU,isValidOpcode:IU,failWebsocketConnection:_e,websocketMessageReceived:mC,utf8Decode:CU,isControlFrame:mg,isTextBinaryFrame:wg,isContinuationFrame:pU}=ks(),{WebsocketFrameSend:wC}=Sn(),{closeWebSocketConnection:yC}=pg(),{PerMessageDeflate:fU}=BC(),{MessageSizeExceededError:yg}=q();function Ss(t,e,r){yC(t,e,r,Buffer.byteLength(r)),_e(t,r)}var bg=class extends EU{#e=[];#t=0;#r=0;#o=!1;#s=Te.INFO;#A={};#n=[];#i;#c;#a;constructor(e,r,A={}){super(),this.ws=e,this.#i=r??new Map,this.#c=A.maxFragments??0,this.#a=A.maxPayloadSize??0,this.#i.has("permessage-deflate")&&this.#i.set("permessage-deflate",new fU(r,A))}_write(e,r,A){this.#e.push(e),this.#r+=e.length,this.#o=!0,this.run(A)}#g(){return this.#a>0&&!mg(this.#A.opcode)&&this.#A.payloadLength+this.#t>this.#a?(Ss(this.ws,1009,"Payload size exceeds maximum allowed size"),!1):!0}run(e){for(;this.#o;)if(this.#s===Te.INFO){if(this.#r<2)return e();let r=this.consume(2),A=(r[0]&128)!==0,s=r[0]&15,o=(r[1]&128)===128,n=!A&&s!==kA.CONTINUATION,i=r[1]&127,a=r[0]&64,c=r[0]&32,l=r[0]&16;if(!IU(s))return _e(this.ws,"Invalid opcode received"),e();if(o)return _e(this.ws,"Frame cannot be masked"),e();if(a!==0&&!this.#i.has("permessage-deflate")){_e(this.ws,"Expected RSV1 to be clear.");return}if(c!==0||l!==0){_e(this.ws,"RSV1, RSV2, RSV3 must be clear");return}if(n&&!wg(s)){_e(this.ws,"Invalid frame type was fragmented.");return}if(wg(s)&&this.#n.length>0){_e(this.ws,"Expected continuation frame");return}if(this.#A.fragmented&&n){_e(this.ws,"Fragmented frame exceeded 125 bytes.");return}if((i>125||n)&&mg(s)){_e(this.ws,"Control frame either too large or fragmented");return}if(pU(s)&&this.#n.length===0&&!this.#A.compressed){_e(this.ws,"Unexpected continuation frame");return}if(i<=125){if(this.#A.payloadLength=i,this.#s=Te.READ_DATA,!this.#g())return}else i===126?this.#s=Te.PAYLOADLENGTH_16:i===127&&(this.#s=Te.PAYLOADLENGTH_64);wg(s)&&(this.#A.binaryType=s,this.#A.compressed=a!==0),this.#A.opcode=s,this.#A.masked=o,this.#A.fin=A,this.#A.fragmented=n}else if(this.#s===Te.PAYLOADLENGTH_16){if(this.#r<2)return e();let r=this.consume(2);if(this.#A.payloadLength=r.readUInt16BE(0),this.#s=Te.READ_DATA,!this.#g())return}else if(this.#s===Te.PAYLOADLENGTH_64){if(this.#r<8)return e();let r=this.consume(8),A=r.readUInt32BE(0),s=r.readUInt32BE(4);if(A!==0||s>2**31-1){_e(this.ws,"Received payload length > 2^31 bytes.");return}if(this.#A.payloadLength=s,this.#s=Te.READ_DATA,!this.#g())return}else if(this.#s===Te.READ_DATA){if(this.#r{if(A){let o=A instanceof yg?1009:1007;Ss(this.ws,o,A.message);return}if(this.writeFragments(s)){if(this.#a>0&&this.#t>this.#a){Ss(this.ws,1009,new yg().message);return}if(!this.#A.fin){this.#s=Te.INFO,this.#o=!0,this.run(e);return}mC(this.ws,this.#A.binaryType,this.consumeFragments()),this.#o=!0,this.#s=Te.INFO,this.run(e)}}),this.#o=!1;break}else{if(!this.writeFragments(r))return;if(this.#a>0&&this.#t>this.#a){Ss(this.ws,1009,new yg().message);return}!this.#A.fragmented&&this.#A.fin&&mC(this.ws,this.#A.binaryType,this.consumeFragments()),this.#s=Te.INFO}}}consume(e){if(e>this.#r)throw new Error("Called consume() before buffers satiated.");if(e===0)return dC;if(this.#e[0].length===e)return this.#r-=this.#e[0].length,this.#e.shift();let r=Buffer.allocUnsafe(e),A=0;for(;A!==e;){let s=this.#e[0],{length:o}=s;if(o+A===e){r.set(this.#e.shift(),A);break}else if(o+A>e){r.set(s.subarray(0,e-A),A),this.#e[0]=s.subarray(e-A);break}else r.set(this.#e.shift(),A),A+=s.length}return this.#r-=e,r}writeFragments(e){return this.#c>0&&this.#n.length===this.#c?(Ss(this.ws,1008,"Too many message fragments"),!1):(this.#t+=e.length,this.#n.push(e),!0)}consumeFragments(){let e=this.#n;if(e.length===1)return this.#t=0,e.shift();let r=Buffer.concat(e,this.#t);return this.#n=[],this.#t=0,r}parseCloseBody(e){hU(e.length!==1);let r;if(e.length>=2&&(r=e.readUInt16BE(0)),r!==void 0&&!dU(r))return{code:1002,reason:"Invalid status code",error:!0};let A=e.subarray(2);A[0]===239&&A[1]===187&&A[2]===191&&(A=A.subarray(3));try{A=CU(A)}catch{return{code:1007,reason:"Invalid UTF-8",error:!0}}return{code:r,reason:A,error:!1}}parseControlFrame(e){let{opcode:r,payloadLength:A}=this.#A;if(r===kA.CLOSE){if(A===1)return _e(this.ws,"Received close frame with a 1-byte body."),!1;if(this.#A.closeInfo=this.parseCloseBody(e),this.#A.closeInfo.error){let{code:s,reason:o}=this.#A.closeInfo;return yC(this.ws,s,o,o.length),_e(this.ws,o),!1}if(this.ws[CC]!==IC.SENT){let s=dC;this.#A.closeInfo.code&&(s=Buffer.allocUnsafe(2),s.writeUInt16BE(this.#A.closeInfo.code,0));let o=new wC(s);this.ws[pC].socket.write(o.createFrame(kA.CLOSE),n=>{n||(this.ws[CC]=IC.SENT)})}return this.ws[BU]=QU.CLOSING,this.ws[fC]=!0,!1}else if(r===kA.PING){if(!this.ws[fC]){let s=new wC(e);this.ws[pC].socket.write(s.createFrame(kA.PONG)),Mn.ping.hasSubscribers&&Mn.ping.publish({payload:e})}}else r===kA.PONG&&Mn.pong.hasSubscribers&&Mn.pong.publish({payload:e});return!0}get closingInfo(){return this.#A.closeInfo}};bC.exports={ByteParser:bg}});var SC=m((Iv,FC)=>{"use strict";var{WebsocketFrameSend:mU}=Sn(),{opcodes:DC,sendHints:DA}=Dr(),wU=Na(),RC=Buffer[Symbol.species],kg=class{#e=new wU;#t=!1;#r;constructor(e){this.#r=e}add(e,r,A){if(A!==DA.blob){let o=TC(e,A);if(!this.#t)this.#r.write(o,r);else{let n={promise:null,callback:r,frame:o};this.#e.push(n)}return}let s={promise:e.arrayBuffer().then(o=>{s.promise=null,s.frame=TC(o,A)}),callback:r,frame:null};this.#e.push(s),this.#t||this.#o()}async#o(){this.#t=!0;let e=this.#e;for(;!e.isEmpty();){let r=e.shift();r.promise!==null&&await r.promise,this.#r.write(r.frame,r.callback),r.callback=r.frame=null}this.#t=!1}};function TC(t,e){return new mU(yU(t,e)).createFrame(e===DA.string?DC.TEXT:DC.BINARY)}function yU(t,e){switch(e){case DA.string:return Buffer.from(t);case DA.arrayBuffer:case DA.blob:return new RC(t);case DA.typedArray:return new RC(t.buffer,t.byteOffset,t.byteLength)}}FC.exports={SendQueue:kg}});var JC=m((Cv,YC)=>{"use strict";var{webidl:x}=de(),{URLSerializer:bU}=ye(),{environmentSettingsObject:UC}=Fe(),{staticPropertyDescriptors:tr,states:Us,sentCloseFrameState:kU,sendHints:Ln}=Dr(),{kWebSocketURL:NC,kReadyState:Dg,kController:GC,kBinaryType:vn,kResponse:MC,kSentClose:DU,kByteParser:RU}=ws(),{isConnecting:TU,isEstablished:FU,isClosing:SU,isValidSubprotocol:UU,fireEvent:LC}=ks(),{establishWebSocketConnection:NU,closeWebSocketConnection:vC}=pg(),{ByteParser:GU}=kC(),{kEnumerableProperty:ze,isBlobLike:_C}=J(),{getGlobalDispatcher:MU}=jo(),{types:xC}=require("node:util"),{ErrorEvent:LU,CloseEvent:vU}=wA(),{SendQueue:_U}=SC(),xe=class t extends EventTarget{#e={open:null,error:null,close:null,message:null};#t=0;#r="";#o="";#s;constructor(e,r=[]){super(),x.util.markAsUncloneable(this);let A="WebSocket constructor";x.argumentLengthCheck(arguments,1,A);let s=x.converters["DOMString or sequence or WebSocketInit"](r,A,"options");e=x.converters.USVString(e,A,"url"),r=s.protocols;let o=UC.settingsObject.baseUrl,n;try{n=new URL(e,o)}catch(a){throw new DOMException(a,"SyntaxError")}if(n.protocol==="http:"?n.protocol="ws:":n.protocol==="https:"&&(n.protocol="wss:"),n.protocol!=="ws:"&&n.protocol!=="wss:")throw new DOMException(`Expected a ws: or wss: protocol, got ${n.protocol}`,"SyntaxError");if(n.hash||n.href.endsWith("#"))throw new DOMException("Got fragment","SyntaxError");if(typeof r=="string"&&(r=[r]),r.length!==new Set(r.map(a=>a.toLowerCase())).size)throw new DOMException("Invalid Sec-WebSocket-Protocol value","SyntaxError");if(r.length>0&&!r.every(a=>UU(a)))throw new DOMException("Invalid Sec-WebSocket-Protocol value","SyntaxError");this[NC]=new URL(n.href);let i=UC.settingsObject;this[GC]=NU(n,r,i,this,(a,c)=>this.#A(a,c),s),this[Dg]=t.CONNECTING,this[DU]=kU.NOT_SENT,this[vn]="blob"}close(e=void 0,r=void 0){x.brandCheck(this,t);let A="WebSocket.close";if(e!==void 0&&(e=x.converters["unsigned short"](e,A,"code",{clamp:!0})),r!==void 0&&(r=x.converters.USVString(r,A,"reason")),e!==void 0&&e!==1e3&&(e<3e3||e>4999))throw new DOMException("invalid code","InvalidAccessError");let s=0;if(r!==void 0&&(s=Buffer.byteLength(r),s>123))throw new DOMException(`Reason must be less than 123 bytes; received ${s}`,"SyntaxError");vC(this,e,r,s)}send(e){x.brandCheck(this,t);let r="WebSocket.send";if(x.argumentLengthCheck(arguments,1,r),e=x.converters.WebSocketSendData(e,r,"data"),TU(this))throw new DOMException("Sent before connected.","InvalidStateError");if(!(!FU(this)||SU(this)))if(typeof e=="string"){let A=Buffer.byteLength(e);this.#t+=A,this.#s.add(e,()=>{this.#t-=A},Ln.string)}else xC.isArrayBuffer(e)?(this.#t+=e.byteLength,this.#s.add(e,()=>{this.#t-=e.byteLength},Ln.arrayBuffer)):ArrayBuffer.isView(e)?(this.#t+=e.byteLength,this.#s.add(e,()=>{this.#t-=e.byteLength},Ln.typedArray)):_C(e)&&(this.#t+=e.size,this.#s.add(e,()=>{this.#t-=e.size},Ln.blob))}get readyState(){return x.brandCheck(this,t),this[Dg]}get bufferedAmount(){return x.brandCheck(this,t),this.#t}get url(){return x.brandCheck(this,t),bU(this[NC])}get extensions(){return x.brandCheck(this,t),this.#o}get protocol(){return x.brandCheck(this,t),this.#r}get onopen(){return x.brandCheck(this,t),this.#e.open}set onopen(e){x.brandCheck(this,t),this.#e.open&&this.removeEventListener("open",this.#e.open),typeof e=="function"?(this.#e.open=e,this.addEventListener("open",e)):this.#e.open=null}get onerror(){return x.brandCheck(this,t),this.#e.error}set onerror(e){x.brandCheck(this,t),this.#e.error&&this.removeEventListener("error",this.#e.error),typeof e=="function"?(this.#e.error=e,this.addEventListener("error",e)):this.#e.error=null}get onclose(){return x.brandCheck(this,t),this.#e.close}set onclose(e){x.brandCheck(this,t),this.#e.close&&this.removeEventListener("close",this.#e.close),typeof e=="function"?(this.#e.close=e,this.addEventListener("close",e)):this.#e.close=null}get onmessage(){return x.brandCheck(this,t),this.#e.message}set onmessage(e){x.brandCheck(this,t),this.#e.message&&this.removeEventListener("message",this.#e.message),typeof e=="function"?(this.#e.message=e,this.addEventListener("message",e)):this.#e.message=null}get binaryType(){return x.brandCheck(this,t),this[vn]}set binaryType(e){x.brandCheck(this,t),e!=="blob"&&e!=="arraybuffer"?this[vn]="blob":this[vn]=e}#A(e,r){this[MC]=e;let A=this[GC]?.dispatcher?.webSocketOptions,s=A?.maxFragments,o=A?.maxPayloadSize,n=new GU(this,r,{maxFragments:s,maxPayloadSize:o});n.on("drain",xU),n.on("error",YU.bind(this)),e.socket.ws=this,this[RU]=n,this.#s=new _U(e.socket),this[Dg]=Us.OPEN;let i=e.headersList.get("sec-websocket-extensions");i!==null&&(this.#o=i);let a=e.headersList.get("sec-websocket-protocol");a!==null&&(this.#r=a),LC("open",this)}};xe.CONNECTING=xe.prototype.CONNECTING=Us.CONNECTING;xe.OPEN=xe.prototype.OPEN=Us.OPEN;xe.CLOSING=xe.prototype.CLOSING=Us.CLOSING;xe.CLOSED=xe.prototype.CLOSED=Us.CLOSED;Object.defineProperties(xe.prototype,{CONNECTING:tr,OPEN:tr,CLOSING:tr,CLOSED:tr,url:ze,readyState:ze,bufferedAmount:ze,onopen:ze,onerror:ze,onclose:ze,close:ze,onmessage:ze,binaryType:ze,send:ze,extensions:ze,protocol:ze,[Symbol.toStringTag]:{value:"WebSocket",writable:!1,enumerable:!1,configurable:!0}});Object.defineProperties(xe,{CONNECTING:tr,OPEN:tr,CLOSING:tr,CLOSED:tr});x.converters["sequence"]=x.sequenceConverter(x.converters.DOMString);x.converters["DOMString or sequence"]=function(t,e,r){return x.util.Type(t)==="Object"&&Symbol.iterator in t?x.converters["sequence"](t):x.converters.DOMString(t,e,r)};x.converters.WebSocketInit=x.dictionaryConverter([{key:"protocols",converter:x.converters["DOMString or sequence"],defaultValue:()=>new Array(0)},{key:"dispatcher",converter:x.converters.any,defaultValue:()=>MU()},{key:"headers",converter:x.nullableConverter(x.converters.HeadersInit)}]);x.converters["DOMString or sequence or WebSocketInit"]=function(t){return x.util.Type(t)==="Object"&&!(Symbol.iterator in t)?x.converters.WebSocketInit(t):{protocols:x.converters["DOMString or sequence"](t)}};x.converters.WebSocketSendData=function(t){if(x.util.Type(t)==="Object"){if(_C(t))return x.converters.Blob(t,{strict:!1});if(ArrayBuffer.isView(t)||xC.isArrayBuffer(t))return x.converters.BufferSource(t)}return x.converters.USVString(t)};function xU(){this.ws[MC].socket.resume()}function YU(t){let e,r;t instanceof vU?(e=t.reason,r=t.code):e=t.message,LC("error",this,()=>new LU("error",{error:t,message:e})),vC(this,r)}YC.exports={WebSocket:xe}});var Rg=m((pv,OC)=>{"use strict";function JU(t){return t.indexOf("\0")===-1}function OU(t){if(t.length===0)return!1;for(let e=0;e57)return!1;return!0}function HU(t){return new Promise(e=>{setTimeout(e,t).unref()})}OC.exports={isValidLastEventId:JU,isASCIINumber:OU,delay:HU}});var qC=m((fv,VC)=>{"use strict";var{Transform:PU}=require("node:stream"),{isASCIINumber:HC,isValidLastEventId:PC}=Rg(),Nt=[239,187,191],Tg=10,_n=13,VU=58,qU=32,Fg=class extends PU{state=null;checkBOM=!0;crlfCheck=!1;eventEndCheck=!1;buffer=null;pos=0;event={data:void 0,event:void 0,id:void 0,retry:void 0};constructor(e={}){e.readableObjectMode=!0,super(e),this.state=e.eventSourceSettings||{},e.push&&(this.push=e.push)}_transform(e,r,A){if(e.length===0){A();return}if(this.buffer?this.buffer=Buffer.concat([this.buffer,e]):this.buffer=e,this.checkBOM)switch(this.buffer.length){case 1:if(this.buffer[0]===Nt[0]){A();return}this.checkBOM=!1,A();return;case 2:if(this.buffer[0]===Nt[0]&&this.buffer[1]===Nt[1]){A();return}this.checkBOM=!1;break;case 3:if(this.buffer[0]===Nt[0]&&this.buffer[1]===Nt[1]&&this.buffer[2]===Nt[2]){this.buffer=Buffer.alloc(0),this.checkBOM=!1,A();return}this.checkBOM=!1;break;default:this.buffer[0]===Nt[0]&&this.buffer[1]===Nt[1]&&this.buffer[2]===Nt[2]&&(this.buffer=this.buffer.subarray(3)),this.checkBOM=!1;break}for(;this.pos0&&(r[s]=o);break}}processEvent(e){e.retry&&HC(e.retry)&&(this.state.reconnectionTime=parseInt(e.retry,10)),e.id&&PC(e.id)&&(this.state.lastEventId=e.id),e.data!==void 0&&this.push({type:e.event||"message",options:{data:e.data,lastEventId:this.state.lastEventId,origin:this.state.origin}})}clearEvent(){this.event={data:void 0,event:void 0,id:void 0,retry:void 0}}};VC.exports={EventSourceStream:Fg}});var ep=m((mv,$C)=>{"use strict";var{pipeline:WU}=require("node:stream"),{fetching:zU}=Cs(),{makeRequest:ZU}=dA(),{webidl:Gt}=de(),{EventSourceStream:KU}=qC(),{parseMIMEType:jU}=ye(),{createFastMessageEvent:XU}=wA(),{isNetworkError:WC}=ds(),{delay:$U}=Rg(),{kEnumerableProperty:Rr}=J(),{environmentSettingsObject:zC}=Fe(),ZC=!1,KC=3e3,Ns=0,jC=1,Gs=2,eN="anonymous",tN="use-credentials",RA=class t extends EventTarget{#e={open:null,error:null,message:null};#t=null;#r=!1;#o=Ns;#s=null;#A=null;#n;#i;constructor(e,r={}){super(),Gt.util.markAsUncloneable(this);let A="EventSource constructor";Gt.argumentLengthCheck(arguments,1,A),ZC||(ZC=!0,process.emitWarning("EventSource is experimental, expect them to change at any time.",{code:"UNDICI-ES"})),e=Gt.converters.USVString(e,A,"url"),r=Gt.converters.EventSourceInitDict(r,A,"eventSourceInitDict"),this.#n=r.dispatcher,this.#i={lastEventId:"",reconnectionTime:KC};let s=zC,o;try{o=new URL(e,s.settingsObject.baseUrl),this.#i.origin=o.origin}catch(a){throw new DOMException(a,"SyntaxError")}this.#t=o.href;let n=eN;r.withCredentials&&(n=tN,this.#r=!0);let i={redirect:"follow",keepalive:!0,mode:"cors",credentials:n==="anonymous"?"same-origin":"omit",referrer:"no-referrer"};i.client=zC.settingsObject,i.headersList=[["accept",{name:"accept",value:"text/event-stream"}]],i.cache="no-store",i.initiator="other",i.urlList=[new URL(this.#t)],this.#s=ZU(i),this.#c()}get readyState(){return this.#o}get url(){return this.#t}get withCredentials(){return this.#r}#c(){if(this.#o===Gs)return;this.#o=Ns;let e={request:this.#s,dispatcher:this.#n},r=A=>{WC(A)&&(this.dispatchEvent(new Event("error")),this.close()),this.#a()};e.processResponseEndOfBody=r,e.processResponse=A=>{if(WC(A))if(A.aborted){this.close(),this.dispatchEvent(new Event("error"));return}else{this.#a();return}let s=A.headersList.get("content-type",!0),o=s!==null?jU(s):"failure",n=o!=="failure"&&o.essence==="text/event-stream";if(A.status!==200||n===!1){this.close(),this.dispatchEvent(new Event("error"));return}this.#o=jC,this.dispatchEvent(new Event("open")),this.#i.origin=A.urlList[A.urlList.length-1].origin;let i=new KU({eventSourceSettings:this.#i,push:a=>{this.dispatchEvent(XU(a.type,a.options))}});WU(A.body.stream,i,a=>{a?.aborted===!1&&(this.close(),this.dispatchEvent(new Event("error")))})},this.#A=zU(e)}async#a(){this.#o!==Gs&&(this.#o=Ns,this.dispatchEvent(new Event("error")),await $U(this.#i.reconnectionTime),this.#o===Ns&&(this.#i.lastEventId.length&&this.#s.headersList.set("last-event-id",this.#i.lastEventId,!0),this.#c()))}close(){Gt.brandCheck(this,t),this.#o!==Gs&&(this.#o=Gs,this.#A.abort(),this.#s=null)}get onopen(){return this.#e.open}set onopen(e){this.#e.open&&this.removeEventListener("open",this.#e.open),typeof e=="function"?(this.#e.open=e,this.addEventListener("open",e)):this.#e.open=null}get onmessage(){return this.#e.message}set onmessage(e){this.#e.message&&this.removeEventListener("message",this.#e.message),typeof e=="function"?(this.#e.message=e,this.addEventListener("message",e)):this.#e.message=null}get onerror(){return this.#e.error}set onerror(e){this.#e.error&&this.removeEventListener("error",this.#e.error),typeof e=="function"?(this.#e.error=e,this.addEventListener("error",e)):this.#e.error=null}},XC={CONNECTING:{__proto__:null,configurable:!1,enumerable:!0,value:Ns,writable:!1},OPEN:{__proto__:null,configurable:!1,enumerable:!0,value:jC,writable:!1},CLOSED:{__proto__:null,configurable:!1,enumerable:!0,value:Gs,writable:!1}};Object.defineProperties(RA,XC);Object.defineProperties(RA.prototype,XC);Object.defineProperties(RA.prototype,{close:Rr,onerror:Rr,onmessage:Rr,onopen:Rr,readyState:Rr,url:Rr,withCredentials:Rr});Gt.converters.EventSourceInitDict=Gt.dictionaryConverter([{key:"withCredentials",converter:Gt.converters.boolean,defaultValue:()=>!1},{key:"dispatcher",converter:Gt.converters.any}]);$C.exports={EventSource:RA,defaultReconnectionTime:KC}});var sp=m((wv,_)=>{"use strict";var rN=rA(),tp=vA(),AN=AA(),sN=Xh(),oN=sA(),nN=$a(),iN=mQ(),aN=RQ(),rp=q(),Yn=J(),{InvalidArgumentError:xn}=rp,TA=hB(),cN=xA(),gN=Gc(),uN=KB(),lN=vc(),EN=fc(),hN=Jo(),{getGlobalDispatcher:Ap,setGlobalDispatcher:QN}=jo(),BN=Xo(),dN=Fo(),IN=So();Object.assign(tp.prototype,TA);_.exports.Dispatcher=tp;_.exports.Client=rN;_.exports.Pool=AN;_.exports.BalancedPool=sN;_.exports.Agent=oN;_.exports.ProxyAgent=nN;_.exports.EnvHttpProxyAgent=iN;_.exports.RetryAgent=aN;_.exports.RetryHandler=hN;_.exports.DecoratorHandler=BN;_.exports.RedirectHandler=dN;_.exports.createRedirectInterceptor=IN;_.exports.interceptors={redirect:Ad(),retry:od(),dump:id(),dns:gd()};_.exports.buildConnector=cN;_.exports.errors=rp;_.exports.util={parseHeaders:Yn.parseHeaders,headerNameToString:Yn.headerNameToString};function Ms(t){return(e,r,A)=>{if(typeof r=="function"&&(A=r,r=null),!e||typeof e!="string"&&typeof e!="object"&&!(e instanceof URL))throw new xn("invalid url");if(r!=null&&typeof r!="object")throw new xn("invalid opts");if(r&&r.path!=null){if(typeof r.path!="string")throw new xn("invalid opts.path");let n=r.path;r.path.startsWith("/")||(n=`/${n}`),e=new URL(Yn.parseOrigin(e).origin+n)}else r||(r=typeof e=="object"?e:{}),e=Yn.parseURL(e);let{agent:s,dispatcher:o=Ap()}=r;if(s)throw new xn("unsupported opts.agent. Did you mean opts.client?");return t.call(o,{...r,origin:e.origin,path:e.search?`${e.pathname}${e.search}`:e.pathname,method:r.method||(r.body?"PUT":"GET")},A)}}_.exports.setGlobalDispatcher=QN;_.exports.getGlobalDispatcher=Ap;var CN=Cs().fetch;_.exports.fetch=async function(e,r=void 0){try{return await CN(e,r)}catch(A){throw A&&typeof A=="object"&&Error.captureStackTrace(A),A}};_.exports.Headers=fr().Headers;_.exports.Response=ds().Response;_.exports.Request=dA().Request;_.exports.FormData=qA().FormData;_.exports.File=globalThis.File??require("node:buffer").File;_.exports.FileReader=kI().FileReader;var{setGlobalOrigin:pN,getGlobalOrigin:fN}=ea();_.exports.setGlobalOrigin=pN;_.exports.getGlobalOrigin=fN;var{CacheStorage:mN}=MI(),{kConstruct:wN}=pn();_.exports.caches=new mN(wN);var{deleteCookie:yN,getCookies:bN,getSetCookies:kN,setCookie:DN}=WI();_.exports.deleteCookie=yN;_.exports.getCookies=bN;_.exports.getSetCookies=kN;_.exports.setCookie=DN;var{parseMIMEType:RN,serializeAMimeType:TN}=ye();_.exports.parseMIMEType=RN;_.exports.serializeAMimeType=TN;var{CloseEvent:FN,ErrorEvent:SN,MessageEvent:UN}=wA();_.exports.WebSocket=JC().WebSocket;_.exports.CloseEvent=FN;_.exports.ErrorEvent=SN;_.exports.MessageEvent=UN;_.exports.request=Ms(TA.request);_.exports.stream=Ms(TA.stream);_.exports.pipeline=Ms(TA.pipeline);_.exports.connect=Ms(TA.connect);_.exports.upgrade=Ms(TA.upgrade);_.exports.MockClient=gN;_.exports.MockPool=lN;_.exports.MockAgent=uN;_.exports.mockErrors=EN;var{EventSource:NN}=ep();_.exports.EventSource=NN});var xg=m((vg,_g)=>{(function(t,e){typeof vg=="object"&&typeof _g<"u"?_g.exports=e():typeof define=="function"&&define.amd?define(e):t.Bottleneck=e()})(vg,(function(){"use strict";var t=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{};function e(F){return F&&F.default||F}var r=function(F,h,u={}){var Q,C,f;for(Q in h)f=h[Q],u[Q]=(C=F[Q])!=null?C:f;return u},A=function(F,h,u={}){var Q,C;for(Q in F)C=F[Q],h[Q]!==void 0&&(u[Q]=C);return u},s={load:r,overwrite:A},o;o=class{constructor(h,u){this.incr=h,this.decr=u,this._first=null,this._last=null,this.length=0}push(h){var u;this.length++,typeof this.incr=="function"&&this.incr(),u={value:h,prev:this._last,next:null},this._last!=null?(this._last.next=u,this._last=u):this._first=this._last=u}shift(){var h;if(this._first!=null)return this.length--,typeof this.decr=="function"&&this.decr(),h=this._first.value,(this._first=this._first.next)!=null?this._first.prev=null:this._last=null,h}first(){if(this._first!=null)return this._first.value}getArray(){var h,u,Q;for(h=this._first,Q=[];h!=null;)Q.push((u=h,h=h.next,u.value));return Q}forEachShift(h){var u;for(u=this.shift();u!=null;)h(u),u=this.shift()}debug(){var h,u,Q,C,f;for(h=this._first,f=[];h!=null;)f.push((u=h,h=h.next,{value:u.value,prev:(Q=u.prev)!=null?Q.value:void 0,next:(C=u.next)!=null?C.value:void 0}));return f}};var n=o,i;i=class{constructor(h){if(this.instance=h,this._events={},this.instance.on!=null||this.instance.once!=null||this.instance.removeAllListeners!=null)throw new Error("An Emitter already exists for this object");this.instance.on=(u,Q)=>this._addListener(u,"many",Q),this.instance.once=(u,Q)=>this._addListener(u,"once",Q),this.instance.removeAllListeners=(u=null)=>u!=null?delete this._events[u]:this._events={}}_addListener(h,u,Q){var C;return(C=this._events)[h]==null&&(C[h]=[]),this._events[h].push({cb:Q,status:u}),this.instance}listenerCount(h){return this._events[h]!=null?this._events[h].length:0}async trigger(h,...u){var Q,C;try{return h!=="debug"&&this.trigger("debug",`Event triggered: ${h}`,u),this._events[h]==null?void 0:(this._events[h]=this._events[h].filter(function(f){return f.status!=="none"}),C=this._events[h].map(async f=>{var D,R;if(f.status!=="none"){f.status==="once"&&(f.status="none");try{return R=typeof f.cb=="function"?f.cb(...u):void 0,typeof R?.then=="function"?await R:R}catch(Z){return D=Z,this.trigger("error",D),null}}}),(await Promise.all(C)).find(function(f){return f!=null}))}catch(f){return Q=f,this.trigger("error",Q),null}}};var a=i,c,l,g;c=n,l=a,g=class{constructor(h){var u;this.Events=new l(this),this._length=0,this._lists=(function(){var Q,C,f;for(f=[],u=Q=1,C=h;1<=C?Q<=C:Q>=C;u=1<=C?++Q:--Q)f.push(new c((()=>this.incr()),(()=>this.decr())));return f}).call(this)}incr(){if(this._length++===0)return this.Events.trigger("leftzero")}decr(){if(--this._length===0)return this.Events.trigger("zero")}push(h){return this._lists[h.options.priority].push(h)}queued(h){return h!=null?this._lists[h].length:this._length}shiftAll(h){return this._lists.forEach(function(u){return u.forEachShift(h)})}getFirst(h=this._lists){var u,Q,C;for(u=0,Q=h.length;u0)return C;return[]}shiftLastFrom(h){return this.getFirst(this._lists.slice(h).reverse()).shift()}};var E=g,d;d=class extends Error{};var B=d,p,w,I,y,T;y=10,w=5,T=s,p=B,I=class{constructor(h,u,Q,C,f,D,R,Z){this.task=h,this.args=u,this.rejectOnDrop=f,this.Events=D,this._states=R,this.Promise=Z,this.options=T.load(Q,C),this.options.priority=this._sanitizePriority(this.options.priority),this.options.id===C.id&&(this.options.id=`${this.options.id}-${this._randomIndex()}`),this.promise=new this.Promise((Be,Ie)=>{this._resolve=Be,this._reject=Ie}),this.retryCount=0}_sanitizePriority(h){var u;return u=~~h!==h?w:h,u<0?0:u>y-1?y-1:u}_randomIndex(){return Math.random().toString(36).slice(2)}doDrop({error:h,message:u="This job has been dropped by Bottleneck"}={}){return this._states.remove(this.options.id)?(this.rejectOnDrop&&this._reject(h??new p(u)),this.Events.trigger("dropped",{args:this.args,options:this.options,task:this.task,promise:this.promise}),!0):!1}_assertStatus(h){var u;if(u=this._states.jobStatus(this.options.id),!(u===h||h==="DONE"&&u===null))throw new p(`Invalid job status ${u}, expected ${h}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`)}doReceive(){return this._states.start(this.options.id),this.Events.trigger("received",{args:this.args,options:this.options})}doQueue(h,u){return this._assertStatus("RECEIVED"),this._states.next(this.options.id),this.Events.trigger("queued",{args:this.args,options:this.options,reachedHWM:h,blocked:u})}doRun(){return this.retryCount===0?(this._assertStatus("QUEUED"),this._states.next(this.options.id)):this._assertStatus("EXECUTING"),this.Events.trigger("scheduled",{args:this.args,options:this.options})}async doExecute(h,u,Q,C){var f,D,R;this.retryCount===0?(this._assertStatus("RUNNING"),this._states.next(this.options.id)):this._assertStatus("EXECUTING"),D={args:this.args,options:this.options,retryCount:this.retryCount},this.Events.trigger("executing",D);try{if(R=await(h!=null?h.schedule(this.options,this.task,...this.args):this.task(...this.args)),u())return this.doDone(D),await C(this.options,D),this._assertStatus("DONE"),this._resolve(R)}catch(Z){return f=Z,this._onFailure(f,D,u,Q,C)}}doExpire(h,u,Q){var C,f;return this._states.jobStatus(this.options.id==="RUNNING")&&this._states.next(this.options.id),this._assertStatus("EXECUTING"),f={args:this.args,options:this.options,retryCount:this.retryCount},C=new p(`This job timed out after ${this.options.expiration} ms.`),this._onFailure(C,f,h,u,Q)}async _onFailure(h,u,Q,C,f){var D,R;if(Q())return D=await this.Events.trigger("failed",h,u),D!=null?(R=~~D,this.Events.trigger("retry",`Retrying ${this.options.id} after ${R} ms`,u),this.retryCount++,C(R)):(this.doDone(u),await f(this.options,u),this._assertStatus("DONE"),this._reject(h))}doDone(h){return this._assertStatus("EXECUTING"),this._states.next(this.options.id),this.Events.trigger("done",h)}};var S=I,O,j,X;X=s,O=B,j=class{constructor(h,u,Q){this.instance=h,this.storeOptions=u,this.clientId=this.instance._randomIndex(),X.load(Q,Q,this),this._nextRequest=this._lastReservoirRefresh=this._lastReservoirIncrease=Date.now(),this._running=0,this._done=0,this._unblockTime=0,this.ready=this.Promise.resolve(),this.clients={},this._startHeartbeat()}_startHeartbeat(){var h;return this.heartbeat==null&&(this.storeOptions.reservoirRefreshInterval!=null&&this.storeOptions.reservoirRefreshAmount!=null||this.storeOptions.reservoirIncreaseInterval!=null&&this.storeOptions.reservoirIncreaseAmount!=null)?typeof(h=this.heartbeat=setInterval(()=>{var u,Q,C,f,D;if(f=Date.now(),this.storeOptions.reservoirRefreshInterval!=null&&f>=this._lastReservoirRefresh+this.storeOptions.reservoirRefreshInterval&&(this._lastReservoirRefresh=f,this.storeOptions.reservoir=this.storeOptions.reservoirRefreshAmount,this.instance._drainAll(this.computeCapacity())),this.storeOptions.reservoirIncreaseInterval!=null&&f>=this._lastReservoirIncrease+this.storeOptions.reservoirIncreaseInterval&&({reservoirIncreaseAmount:u,reservoirIncreaseMaximum:C,reservoir:D}=this.storeOptions,this._lastReservoirIncrease=f,Q=C!=null?Math.min(u,C-D):u,Q>0))return this.storeOptions.reservoir+=Q,this.instance._drainAll(this.computeCapacity())},this.heartbeatInterval)).unref=="function"?h.unref():void 0:clearInterval(this.heartbeat)}async __publish__(h){return await this.yieldLoop(),this.instance.Events.trigger("message",h.toString())}async __disconnect__(h){return await this.yieldLoop(),clearInterval(this.heartbeat),this.Promise.resolve()}yieldLoop(h=0){return new this.Promise(function(u,Q){return setTimeout(u,h)})}computePenalty(){var h;return(h=this.storeOptions.penalty)!=null?h:15*this.storeOptions.minTime||5e3}async __updateSettings__(h){return await this.yieldLoop(),X.overwrite(h,h,this.storeOptions),this._startHeartbeat(),this.instance._drainAll(this.computeCapacity()),!0}async __running__(){return await this.yieldLoop(),this._running}async __queued__(){return await this.yieldLoop(),this.instance.queued()}async __done__(){return await this.yieldLoop(),this._done}async __groupCheck__(h){return await this.yieldLoop(),this._nextRequest+this.timeout=h}check(h,u){return this.conditionsCheck(h)&&this._nextRequest-u<=0}async __check__(h){var u;return await this.yieldLoop(),u=Date.now(),this.check(h,u)}async __register__(h,u,Q){var C,f;return await this.yieldLoop(),C=Date.now(),this.conditionsCheck(u)?(this._running+=u,this.storeOptions.reservoir!=null&&(this.storeOptions.reservoir-=u),f=Math.max(this._nextRequest-C,0),this._nextRequest=C+f+this.storeOptions.minTime,{success:!0,wait:f,reservoir:this.storeOptions.reservoir}):{success:!1}}strategyIsBlock(){return this.storeOptions.strategy===3}async __submit__(h,u){var Q,C,f;if(await this.yieldLoop(),this.storeOptions.maxConcurrent!=null&&u>this.storeOptions.maxConcurrent)throw new O(`Impossible to add a job having a weight of ${u} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`);return C=Date.now(),f=this.storeOptions.highWater!=null&&h===this.storeOptions.highWater&&!this.check(u,C),Q=this.strategyIsBlock()&&(f||this.isBlocked(C)),Q&&(this._unblockTime=C+this.computePenalty(),this._nextRequest=this._unblockTime+this.storeOptions.minTime,this.instance._dropAllQueued()),{reachedHWM:f,blocked:Q,strategy:this.storeOptions.strategy}}async __free__(h,u){return await this.yieldLoop(),this._running-=u,this._done+=u,this.instance._drainAll(this.computeCapacity()),{running:this._running}}};var Ye=j,Je,It;Je=B,It=class{constructor(h){this.status=h,this._jobs={},this.counts=this.status.map(function(){return 0})}next(h){var u,Q;if(u=this._jobs[h],Q=u+1,u!=null&&Q(h[this.status[Q]]=u,h)),{})}};var ot=It,Qe,Ct;Qe=n,Ct=class{constructor(h,u){this.schedule=this.schedule.bind(this),this.name=h,this.Promise=u,this._running=0,this._queue=new Qe}isEmpty(){return this._queue.length===0}async _tryToRun(){var h,u,Q,C,f,D,R;if(this._running<1&&this._queue.length>0)return this._running++,{task:R,args:h,resolve:f,reject:C}=this._queue.shift(),u=await(async function(){try{return D=await R(...h),function(){return f(D)}}catch(Z){return Q=Z,function(){return C(Q)}}})(),this._running--,this._tryToRun(),u()}schedule(h,...u){var Q,C,f;return f=C=null,Q=new this.Promise(function(D,R){return f=D,C=R}),this._queue.push({task:h,args:u,resolve:f,reject:C}),this._tryToRun(),Q}};var Lt=Ct,Ur="2.19.5",Nr={version:Ur},Af=Object.freeze({version:Ur,default:Nr}),tu=()=>console.log("You must import the full version of Bottleneck in order to use this feature."),ru=()=>console.log("You must import the full version of Bottleneck in order to use this feature."),sf=()=>console.log("You must import the full version of Bottleneck in order to use this feature."),Au,su,ou,nu,iu,Js;Js=s,Au=a,nu=tu,ou=ru,iu=sf,su=(function(){class F{constructor(u={}){this.deleteKey=this.deleteKey.bind(this),this.limiterOptions=u,Js.load(this.limiterOptions,this.defaults,this),this.Events=new Au(this),this.instances={},this.Bottleneck=Iu,this._startAutoCleanup(),this.sharedConnection=this.connection!=null,this.connection==null&&(this.limiterOptions.datastore==="redis"?this.connection=new nu(Object.assign({},this.limiterOptions,{Events:this.Events})):this.limiterOptions.datastore==="ioredis"&&(this.connection=new ou(Object.assign({},this.limiterOptions,{Events:this.Events}))))}key(u=""){var Q;return(Q=this.instances[u])!=null?Q:(()=>{var C;return C=this.instances[u]=new this.Bottleneck(Object.assign(this.limiterOptions,{id:`${this.id}-${u}`,timeout:this.timeout,connection:this.connection})),this.Events.trigger("created",C,u),C})()}async deleteKey(u=""){var Q,C;return C=this.instances[u],this.connection&&(Q=await this.connection.__runCommand__(["del",...iu.allKeys(`${this.id}-${u}`)])),C!=null&&(delete this.instances[u],await C.disconnect()),C!=null||Q>0}limiters(){var u,Q,C,f;Q=this.instances,C=[];for(u in Q)f=Q[u],C.push({key:u,limiter:f});return C}keys(){return Object.keys(this.instances)}async clusterKeys(){var u,Q,C,f,D,R,Z,Be,Ie;if(this.connection==null)return this.Promise.resolve(this.keys());for(R=[],u=null,Ie=`b_${this.id}-`.length,Q=9;u!==0;)for([Be,C]=await this.connection.__runCommand__(["scan",u??0,"match",`b_${this.id}-*_settings`,"count",1e4]),u=~~Be,f=0,Z=C.length;f{var Q,C,f,D,R,Z;R=Date.now(),f=this.instances,D=[];for(C in f){Z=f[C];try{await Z._store.__groupCheck__(R)?D.push(this.deleteKey(C)):D.push(void 0)}catch(Be){Q=Be,D.push(Z.Events.trigger("error",Q))}}return D},this.timeout/2)).unref=="function"?u.unref():void 0}updateSettings(u={}){if(Js.overwrite(u,this.defaults,this),Js.overwrite(u,u,this.limiterOptions),u.timeout!=null)return this._startAutoCleanup()}disconnect(u=!0){var Q;if(!this.sharedConnection)return(Q=this.connection)!=null?Q.disconnect(u):void 0}}return F.prototype.defaults={timeout:1e3*60*5,connection:null,Promise,id:"group-key"},F}).call(t);var of=su,au,cu,gu;gu=s,cu=a,au=(function(){class F{constructor(u={}){this.options=u,gu.load(this.options,this.defaults,this),this.Events=new cu(this),this._arr=[],this._resetPromise(),this._lastFlush=Date.now()}_resetPromise(){return this._promise=new this.Promise((u,Q)=>this._resolve=u)}_flush(){return clearTimeout(this._timeout),this._lastFlush=Date.now(),this._resolve(),this.Events.trigger("batch",this._arr),this._arr=[],this._resetPromise()}add(u){var Q;return this._arr.push(u),Q=this._promise,this._arr.length===this.maxSize?this._flush():this.maxTime!=null&&this._arr.length===1&&(this._timeout=setTimeout(()=>this._flush(),this.maxTime)),Q}}return F.prototype.defaults={maxTime:null,maxSize:null,Promise},F}).call(t);var nf=au,af=()=>console.log("You must import the full version of Bottleneck in order to use this feature."),cf=e(Af),uu,lu,ei,ti,Eu,ri,hu,Qu,Bu,Ai,nt,du=[].splice;ri=10,lu=5,nt=s,hu=E,ti=S,Eu=Ye,Qu=af,ei=a,Bu=ot,Ai=Lt,uu=(function(){class F{constructor(u={},...Q){var C,f;this._addToQueue=this._addToQueue.bind(this),this._validateOptions(u,Q),nt.load(u,this.instanceDefaults,this),this._queues=new hu(ri),this._scheduled={},this._states=new Bu(["RECEIVED","QUEUED","RUNNING","EXECUTING"].concat(this.trackDoneStatus?["DONE"]:[])),this._limiter=null,this.Events=new ei(this),this._submitLock=new Ai("submit",this.Promise),this._registerLock=new Ai("register",this.Promise),f=nt.load(u,this.storeDefaults,{}),this._store=(function(){if(this.datastore==="redis"||this.datastore==="ioredis"||this.connection!=null)return C=nt.load(u,this.redisStoreDefaults,{}),new Qu(this,f,C);if(this.datastore==="local")return C=nt.load(u,this.localStoreDefaults,{}),new Eu(this,f,C);throw new F.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`)}).call(this),this._queues.on("leftzero",()=>{var D;return(D=this._store.heartbeat)!=null&&typeof D.ref=="function"?D.ref():void 0}),this._queues.on("zero",()=>{var D;return(D=this._store.heartbeat)!=null&&typeof D.unref=="function"?D.unref():void 0})}_validateOptions(u,Q){if(!(u!=null&&typeof u=="object"&&Q.length===0))throw new F.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1.")}ready(){return this._store.ready}clients(){return this._store.clients}channel(){return`b_${this.id}`}channel_client(){return`b_${this.id}_${this._store.clientId}`}publish(u){return this._store.__publish__(u)}disconnect(u=!0){return this._store.__disconnect__(u)}chain(u){return this._limiter=u,this}queued(u){return this._queues.queued(u)}clusterQueued(){return this._store.__queued__()}empty(){return this.queued()===0&&this._submitLock.isEmpty()}running(){return this._store.__running__()}done(){return this._store.__done__()}jobStatus(u){return this._states.jobStatus(u)}jobs(u){return this._states.statusJobs(u)}counts(){return this._states.statusCounts()}_randomIndex(){return Math.random().toString(36).slice(2)}check(u=1){return this._store.__check__(u)}_clearGlobalState(u){return this._scheduled[u]!=null?(clearTimeout(this._scheduled[u].expiration),delete this._scheduled[u],!0):!1}async _free(u,Q,C,f){var D,R;try{if({running:R}=await this._store.__free__(u,C.weight),this.Events.trigger("debug",`Freed ${C.id}`,f),R===0&&this.empty())return this.Events.trigger("idle")}catch(Z){return D=Z,this.Events.trigger("error",D)}}_run(u,Q,C){var f,D,R;return Q.doRun(),f=this._clearGlobalState.bind(this,u),R=this._run.bind(this,u,Q),D=this._free.bind(this,u,Q),this._scheduled[u]={timeout:setTimeout(()=>Q.doExecute(this._limiter,f,R,D),C),expiration:Q.options.expiration!=null?setTimeout(function(){return Q.doExpire(f,R,D)},C+Q.options.expiration):void 0,job:Q}}_drainOne(u){return this._registerLock.schedule(()=>{var Q,C,f,D,R;return this.queued()===0?this.Promise.resolve(null):(R=this._queues.getFirst(),{options:D,args:Q}=f=R.first(),u!=null&&D.weight>u?this.Promise.resolve(null):(this.Events.trigger("debug",`Draining ${D.id}`,{args:Q,options:D}),C=this._randomIndex(),this._store.__register__(C,D.weight,D.expiration).then(({success:Z,wait:Be,reservoir:Ie})=>{var GA;return this.Events.trigger("debug",`Drained ${D.id}`,{success:Z,args:Q,options:D}),Z?(R.shift(),GA=this.empty(),GA&&this.Events.trigger("empty"),Ie===0&&this.Events.trigger("depleted",GA),this._run(C,f,Be),this.Promise.resolve(D.weight)):this.Promise.resolve(null)})))})}_drainAll(u,Q=0){return this._drainOne(u).then(C=>{var f;return C!=null?(f=u!=null?u-C:u,this._drainAll(f,Q+C)):this.Promise.resolve(Q)}).catch(C=>this.Events.trigger("error",C))}_dropAllQueued(u){return this._queues.shiftAll(function(Q){return Q.doDrop({message:u})})}stop(u={}){var Q,C;return u=nt.load(u,this.stopDefaults),C=f=>{var D;return D=()=>{var R;return R=this._states.counts,R[0]+R[1]+R[2]+R[3]===f},new this.Promise((R,Z)=>D()?R():this.on("done",()=>{if(D())return this.removeAllListeners("done"),R()}))},Q=u.dropWaitingJobs?(this._run=function(f,D){return D.doDrop({message:u.dropErrorMessage})},this._drainOne=()=>this.Promise.resolve(null),this._registerLock.schedule(()=>this._submitLock.schedule(()=>{var f,D,R;D=this._scheduled;for(f in D)R=D[f],this.jobStatus(R.job.options.id)==="RUNNING"&&(clearTimeout(R.timeout),clearTimeout(R.expiration),R.job.doDrop({message:u.dropErrorMessage}));return this._dropAllQueued(u.dropErrorMessage),C(0)}))):this.schedule({priority:ri-1,weight:0},()=>C(1)),this._receive=function(f){return f._reject(new F.prototype.BottleneckError(u.enqueueErrorMessage))},this.stop=()=>this.Promise.reject(new F.prototype.BottleneckError("stop() has already been called")),Q}async _addToQueue(u){var Q,C,f,D,R,Z,Be;({args:Q,options:D}=u);try{({reachedHWM:R,blocked:C,strategy:Be}=await this._store.__submit__(this.queued(),D.weight))}catch(Ie){return f=Ie,this.Events.trigger("debug",`Could not queue ${D.id}`,{args:Q,options:D,error:f}),u.doDrop({error:f}),!1}return C?(u.doDrop(),!0):R&&(Z=Be===F.prototype.strategy.LEAK?this._queues.shiftLastFrom(D.priority):Be===F.prototype.strategy.OVERFLOW_PRIORITY?this._queues.shiftLastFrom(D.priority+1):Be===F.prototype.strategy.OVERFLOW?u:void 0,Z?.doDrop(),Z==null||Be===F.prototype.strategy.OVERFLOW)?(Z==null&&u.doDrop(),R):(u.doQueue(R,C),this._queues.push(u),await this._drainAll(),R)}_receive(u){return this._states.jobStatus(u.options.id)!=null?(u._reject(new F.prototype.BottleneckError(`A job with the same id already exists (id=${u.options.id})`)),!1):(u.doReceive(),this._submitLock.schedule(this._addToQueue,u))}submit(...u){var Q,C,f,D,R,Z,Be;return typeof u[0]=="function"?(R=u,[C,...u]=R,[Q]=du.call(u,-1),D=nt.load({},this.jobDefaults)):(Z=u,[D,C,...u]=Z,[Q]=du.call(u,-1),D=nt.load(D,this.jobDefaults)),Be=(...Ie)=>new this.Promise(function(GA,uf){return C(...Ie,function(...Cu){return(Cu[0]!=null?uf:GA)(Cu)})}),f=new ti(Be,u,D,this.jobDefaults,this.rejectOnDrop,this.Events,this._states,this.Promise),f.promise.then(function(Ie){return typeof Q=="function"?Q(...Ie):void 0}).catch(function(Ie){return Array.isArray(Ie)?typeof Q=="function"?Q(...Ie):void 0:typeof Q=="function"?Q(Ie):void 0}),this._receive(f)}schedule(...u){var Q,C,f;return typeof u[0]=="function"?([f,...u]=u,C={}):[C,f,...u]=u,Q=new ti(f,u,C,this.jobDefaults,this.rejectOnDrop,this.Events,this._states,this.Promise),this._receive(Q),Q.promise}wrap(u){var Q,C;return Q=this.schedule.bind(this),C=function(...f){return Q(u.bind(this),...f)},C.withOptions=function(f,...D){return Q(f,u,...D)},C}async updateSettings(u={}){return await this._store.__updateSettings__(nt.overwrite(u,this.storeDefaults)),nt.overwrite(u,this.instanceDefaults,this),this}currentReservoir(){return this._store.__currentReservoir__()}incrementReservoir(u=0){return this._store.__incrementReservoir__(u)}}return F.default=F,F.Events=ei,F.version=F.prototype.version=cf.version,F.strategy=F.prototype.strategy={LEAK:1,OVERFLOW:2,OVERFLOW_PRIORITY:4,BLOCK:3},F.BottleneckError=F.prototype.BottleneckError=B,F.Group=F.prototype.Group=of,F.RedisConnection=F.prototype.RedisConnection=tu,F.IORedisConnection=F.prototype.IORedisConnection=ru,F.Batcher=F.prototype.Batcher=nf,F.prototype.jobDefaults={priority:lu,weight:1,expiration:null,id:""},F.prototype.storeDefaults={maxConcurrent:null,minTime:0,highWater:null,strategy:F.prototype.strategy.LEAK,penalty:null,reservoir:null,reservoirRefreshInterval:null,reservoirRefreshAmount:null,reservoirIncreaseInterval:null,reservoirIncreaseAmount:null,reservoirIncreaseMaximum:null},F.prototype.localStoreDefaults={Promise,timeout:null,heartbeatInterval:250},F.prototype.redisStoreDefaults={Promise,timeout:null,heartbeatInterval:5e3,clientTimeout:1e4,Redis:null,clientOptions:{},clusterNodes:null,clearDatastore:!1,connection:null},F.prototype.instanceDefaults={datastore:"local",connection:null,id:"",rejectOnDrop:!0,trackDoneStatus:!1,Promise},F.prototype.stopDefaults={enqueueErrorMessage:"This limiter has been stopped and cannot accept new jobs.",dropWaitingJobs:!0,dropErrorMessage:"This limiter has been stopped."},F}).call(t);var Iu=uu,gf=Iu;return gf}))});var Up=m((M_,_s)=>{"use strict";var zn=function(){};zn.prototype=Object.create(null);var qn=/; *([!#$%&'*+.^\w`|~-]+)=("(?:[\v\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\v\u0020-\u00ff])*"|[!#$%&'*+.^\w`|~-]+) */gu,Wn=/\\([\v\u0020-\u00ff])/gu,Tp=/^[!#$%&'*+.^\w|~-]+\/[!#$%&'*+.^\w|~-]+$/u,Fr={type:"",parameters:new zn};Object.freeze(Fr.parameters);Object.freeze(Fr);function Fp(t){if(typeof t!="string")throw new TypeError("argument header is required and must be a string");let e=t.indexOf(";"),r=e!==-1?t.slice(0,e).trim():t.trim();if(Tp.test(r)===!1)throw new TypeError("invalid media type");let A={type:r.toLowerCase(),parameters:new zn};if(e===-1)return A;let s,o,n;for(qn.lastIndex=e;o=qn.exec(t);){if(o.index!==e)throw new TypeError("invalid parameter format");e+=o[0].length,s=o[1].toLowerCase(),n=o[2],n[0]==='"'&&(n=n.slice(1,n.length-1),Wn.test(n)&&(n=n.replace(Wn,"$1"))),A.parameters[s]=n}if(e!==t.length)throw new TypeError("invalid parameter format");return A}function Sp(t){if(typeof t!="string")return Fr;let e=t.indexOf(";"),r=e!==-1?t.slice(0,e).trim():t.trim();if(Tp.test(r)===!1)return Fr;let A={type:r.toLowerCase(),parameters:new zn};if(e===-1)return A;let s,o,n;for(qn.lastIndex=e;o=qn.exec(t);){if(o.index!==e)return Fr;e+=o[0].length,s=o[1].toLowerCase(),n=o[2],n[0]==='"'&&(n=n.slice(1,n.length-1),Wn.test(n)&&(n=n.replace(Wn,"$1"))),A.parameters[s]=n}return e!==t.length?Fr:A}_s.exports.default={parse:Fp,safeParse:Sp};_s.exports.parse=Fp;_s.exports.safeParse=Sp;_s.exports.defaultContentType=Fr});var CM={};df(CM,{run:()=>rf});module.exports=If(CM);var mu=Oe(require("os"),1);function vt(t){return t==null?"":typeof t=="string"||t instanceof String?t:JSON.stringify(t)}function si(t){return Object.keys(t).length?{title:t.title,file:t.file,line:t.startLine,endLine:t.endLine,col:t.startColumn,endColumn:t.endColumn}:{}}function MA(t,e,r){let A=new oi(t,e,r);process.stdout.write(A.toString()+mu.EOL)}var fu="::",oi=class{constructor(e,r,A){e||(e="missing.command"),this.command=e,this.properties=r,this.message=A}toString(){let e=fu+this.command;if(this.properties&&Object.keys(this.properties).length>0){e+=" ";let r=!0;for(let A in this.properties)if(this.properties.hasOwnProperty(A)){let s=this.properties[A];s&&(r?r=!1:e+=",",e+=`${A}=${pf(s)}`)}}return e+=`${fu}${Cf(this.message)}`,e}};function Cf(t){return vt(t).replace(/%/g,"%25").replace(/\r/g,"%0D").replace(/\n/g,"%0A")}function pf(t){return vt(t).replace(/%/g,"%25").replace(/\r/g,"%0D").replace(/\n/g,"%0A").replace(/:/g,"%3A").replace(/,/g,"%2C")}var wu=Oe(require("crypto"),1),Ps=Oe(require("fs"),1),Hs=Oe(require("os"),1);function yu(t,e){let r=process.env[`GITHUB_${t}`];if(!r)throw new Error(`Unable to find environment variable for file command ${t}`);if(!Ps.existsSync(r))throw new Error(`Missing file at path: ${r}`);Ps.appendFileSync(r,`${vt(e)}${Hs.EOL}`,{encoding:"utf8"})}function bu(t,e){let r=`ghadelimiter_${wu.randomUUID()}`,A=vt(e);if(t.includes(r))throw new Error(`Unexpected input: name should not contain the delimiter "${r}"`);if(A.includes(r))throw new Error(`Unexpected input: value should not contain the delimiter "${r}"`);return`${t}<<${r}${Hs.EOL}${A}${Hs.EOL}${r}`}var Mg=Oe(require("os"),1);var Jn=Oe(Su(),1),GN=Oe(sp(),1);var dt;(function(t){t[t.OK=200]="OK",t[t.MultipleChoices=300]="MultipleChoices",t[t.MovedPermanently=301]="MovedPermanently",t[t.ResourceMoved=302]="ResourceMoved",t[t.SeeOther=303]="SeeOther",t[t.NotModified=304]="NotModified",t[t.UseProxy=305]="UseProxy",t[t.SwitchProxy=306]="SwitchProxy",t[t.TemporaryRedirect=307]="TemporaryRedirect",t[t.PermanentRedirect=308]="PermanentRedirect",t[t.BadRequest=400]="BadRequest",t[t.Unauthorized=401]="Unauthorized",t[t.PaymentRequired=402]="PaymentRequired",t[t.Forbidden=403]="Forbidden",t[t.NotFound=404]="NotFound",t[t.MethodNotAllowed=405]="MethodNotAllowed",t[t.NotAcceptable=406]="NotAcceptable",t[t.ProxyAuthenticationRequired=407]="ProxyAuthenticationRequired",t[t.RequestTimeout=408]="RequestTimeout",t[t.Conflict=409]="Conflict",t[t.Gone=410]="Gone",t[t.TooManyRequests=429]="TooManyRequests",t[t.InternalServerError=500]="InternalServerError",t[t.NotImplemented=501]="NotImplemented",t[t.BadGateway=502]="BadGateway",t[t.ServiceUnavailable=503]="ServiceUnavailable",t[t.GatewayTimeout=504]="GatewayTimeout"})(dt||(dt={}));var op;(function(t){t.Accept="accept",t.ContentType="content-type"})(op||(op={}));var np;(function(t){t.ApplicationJson="application/json"})(np||(np={}));var bv=[dt.MovedPermanently,dt.ResourceMoved,dt.SeeOther,dt.TemporaryRedirect,dt.PermanentRedirect],kv=[dt.BadGateway,dt.ServiceUnavailable,dt.GatewayTimeout];var ap=require("os"),Ls=require("fs"),Sg=function(t,e,r,A){function s(o){return o instanceof r?o:new r(function(n){n(o)})}return new(r||(r=Promise))(function(o,n){function i(l){try{c(A.next(l))}catch(g){n(g)}}function a(l){try{c(A.throw(l))}catch(g){n(g)}}function c(l){l.done?o(l.value):s(l.value).then(i,a)}c((A=A.apply(t,e||[])).next())})},{access:MN,appendFile:LN,writeFile:vN}=Ls.promises,ip="GITHUB_STEP_SUMMARY";var Ug=class{constructor(){this._buffer=""}filePath(){return Sg(this,void 0,void 0,function*(){if(this._filePath)return this._filePath;let e=process.env[ip];if(!e)throw new Error(`Unable to find environment variable for $${ip}. Check if your runtime environment supports job summaries.`);try{yield MN(e,Ls.constants.R_OK|Ls.constants.W_OK)}catch{throw new Error(`Unable to access summary file: '${e}'. Check if the file has correct read/write permissions.`)}return this._filePath=e,this._filePath})}wrap(e,r,A={}){let s=Object.entries(A).map(([o,n])=>` ${o}="${n}"`).join("");return r?`<${e}${s}>${r}`:`<${e}${s}>`}write(e){return Sg(this,void 0,void 0,function*(){let r=!!e?.overwrite,A=yield this.filePath();return yield(r?vN:LN)(A,this._buffer,{encoding:"utf8"}),this.emptyBuffer()})}clear(){return Sg(this,void 0,void 0,function*(){return this.emptyBuffer().write({overwrite:!0})})}stringify(){return this._buffer}isEmptyBuffer(){return this._buffer.length===0}emptyBuffer(){return this._buffer="",this}addRaw(e,r=!1){return this._buffer+=e,r?this.addEOL():this}addEOL(){return this.addRaw(ap.EOL)}addCodeBlock(e,r){let A=Object.assign({},r&&{lang:r}),s=this.wrap("pre",this.wrap("code",e),A);return this.addRaw(s).addEOL()}addList(e,r=!1){let A=r?"ol":"ul",s=e.map(n=>this.wrap("li",n)).join(""),o=this.wrap(A,s);return this.addRaw(o).addEOL()}addTable(e){let r=e.map(s=>{let o=s.map(n=>{if(typeof n=="string")return this.wrap("td",n);let{header:i,data:a,colspan:c,rowspan:l}=n,g=i?"th":"td",E=Object.assign(Object.assign({},c&&{colspan:c}),l&&{rowspan:l});return this.wrap(g,a,E)}).join("");return this.wrap("tr",o)}).join(""),A=this.wrap("table",r);return this.addRaw(A).addEOL()}addDetails(e,r){let A=this.wrap("details",this.wrap("summary",e)+r);return this.addRaw(A).addEOL()}addImage(e,r,A){let{width:s,height:o}=A||{},n=Object.assign(Object.assign({},s&&{width:s}),o&&{height:o}),i=this.wrap("img",null,Object.assign({src:e,alt:r},n));return this.addRaw(i).addEOL()}addHeading(e,r){let A=`h${r}`,s=["h1","h2","h3","h4","h5","h6"].includes(A)?A:"h1",o=this.wrap(s,e);return this.addRaw(o).addEOL()}addSeparator(){let e=this.wrap("hr",null);return this.addRaw(e).addEOL()}addBreak(){let e=this.wrap("br",null);return this.addRaw(e).addEOL()}addQuote(e,r){let A=Object.assign({},r&&{cite:r}),s=this.wrap("blockquote",e,A);return this.addRaw(s).addEOL()}addLink(e,r){let A=this.wrap("a",e,{href:r});return this.addRaw(A).addEOL()}},Lv=new Ug;var Ng=Oe(require("os"),1);var On=Oe(require("fs"),1);var{chmod:_N,copyFile:xN,lstat:YN,mkdir:JN,open:xv,readdir:ON,rename:HN,rm:PN,rmdir:Yv,stat:VN,symlink:qN,unlink:WN}=On.promises,zN=process.platform==="win32";var Jv=On.constants.O_RDONLY;var qv=process.platform==="win32";var Kv=Ng.default.platform(),jv=Ng.default.arch();var Gg;(function(t){t[t.Success=0]="Success",t[t.Failure=1]="Failure"})(Gg||(Gg={}));function SA(t,e){if(process.env.GITHUB_OUTPUT||"")return yu("OUTPUT",bu(t,e));process.stdout.write(Mg.EOL),MA("set-output",{name:t},vt(e))}function Lg(t){process.exitCode=Gg.Failure,tG(t)}function FA(t){MA("debug",{},t)}function tG(t,e={}){MA("error",si(e),t instanceof Error?t.toString():t)}function Hn(t,e={}){MA("warning",si(e),t instanceof Error?t.toString():t)}function gp(t){process.stdout.write(t+Mg.EOL)}var tf=require("process");var lp=Oe(xg(),1);var Mt=class extends Error{name;status;request;response;constructor(e,r,A){super(e),this.name="HttpError",this.status=Number.parseInt(r),Number.isNaN(this.status)&&(this.status=0),"response"in A&&(this.response=A.response);let s=Object.assign({},A.request);A.request.headers.authorization&&(s.headers=Object.assign({},A.request.headers,{authorization:A.request.headers.authorization.replace(/(?=400&&!t.doNotRetry.includes(r.status)){let s=A.request.retries!=null?A.request.retries:t.retries,o=Math.pow((A.request.retryCount||0)+1,2);throw e.retry.retryRequest(r,s,o)}throw r}async function sG(t,e,r,A){let s=new lp.default;return s.on("failed",function(o,n){let i=~~o.request.request?.retries,a=~~o.request.request?.retryAfter;if(A.request.retryCount=n.retryCount+1,i>n.retryCount)return a*t.retryAfterBaseValue}),s.schedule(oG.bind(null,t,e,r),A)}async function oG(t,e,r,A){let s=await r(A);if(s.data&&s.data.errors&&s.data.errors.length>0&&/Something went wrong while executing your query/.test(s.data.errors[0].message)){let o=new Mt(s.data.errors[0].message,500,{request:A,response:s});return up(t,e,o,A)}return s}function Yg(t,e){let r=Object.assign({enabled:!0,retryAfterBaseValue:1e3,doNotRetry:[400,401,403,404,410,422,451],retries:3},e.retry),A={retry:{retryRequest:(s,o,n)=>(s.request.request=Object.assign({},s.request.request,{retries:o,retryAfter:n}),s)}};return r.enabled&&(t.hook.error("request",up.bind(null,r,A)),t.hook.wrap("request",sG.bind(null,r,A))),A}Yg.VERSION=rG;var hp=Oe(xg(),1),nG="0.0.0-development",Jg=()=>Promise.resolve();function iG(t,e,r){return t.retryLimiter.schedule(aG,t,e,r)}async function aG(t,e,r){let{pathname:A}=new URL(r.url,"http://github.test"),s=cG(r.method,A),o=!s&&r.method!=="GET"&&r.method!=="HEAD",n=r.method==="GET"&&A.startsWith("/search/"),i=A.startsWith("/graphql"),c=~~e.retryCount>0?{priority:0,weight:0}:{};t.clustering&&(c.expiration=1e3*60),(o||i)&&await t.write.key(t.id).schedule(c,Jg),o&&t.triggersNotification(A)&&await t.notifications.key(t.id).schedule(c,Jg),n&&await t.search.key(t.id).schedule(c,Jg);let l=(s?t.auth:t.global).key(t.id).schedule(c,e,r);if(i){let g=await l;if(g.data.errors!=null&&g.data.errors.some(E=>E.type==="RATE_LIMITED"))throw Object.assign(new Error("GraphQL Rate Limit Exceeded"),{response:g,data:g.data})}return l}function cG(t,e){return t==="PATCH"&&/^\/applications\/[^/]+\/token\/scoped$/.test(e)||t==="POST"&&(/^\/applications\/[^/]+\/token$/.test(e)||/^\/app\/installations\/[^/]+\/access_tokens$/.test(e)||e==="/login/oauth/access_token")}var gG=["/orgs/{org}/invitations","/orgs/{org}/invitations/{invitation_id}","/orgs/{org}/teams/{team_slug}/discussions","/orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments","/repos/{owner}/{repo}/collaborators/{username}","/repos/{owner}/{repo}/commits/{commit_sha}/comments","/repos/{owner}/{repo}/issues","/repos/{owner}/{repo}/issues/{issue_number}/comments","/repos/{owner}/{repo}/issues/{issue_number}/sub_issue","/repos/{owner}/{repo}/issues/{issue_number}/sub_issues/priority","/repos/{owner}/{repo}/pulls","/repos/{owner}/{repo}/pulls/{pull_number}/comments","/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies","/repos/{owner}/{repo}/pulls/{pull_number}/merge","/repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers","/repos/{owner}/{repo}/pulls/{pull_number}/reviews","/repos/{owner}/{repo}/releases","/teams/{team_id}/discussions","/teams/{team_id}/discussions/{discussion_number}/comments"];function uG(t){let r=`^(?:${t.map(A=>A.split("/").map(s=>s.startsWith("{")?"(?:.+?)":s).join("/")).map(A=>`(?:${A})`).join("|")})[^/]*$`;return new RegExp(r,"i")}var Ep=uG(gG),Qp=Ep.test.bind(Ep),Tr={},lG=function(t,e){Tr.global=new t.Group({id:"octokit-global",maxConcurrent:10,...e}),Tr.auth=new t.Group({id:"octokit-auth",maxConcurrent:1,...e}),Tr.search=new t.Group({id:"octokit-search",maxConcurrent:1,minTime:2e3,...e}),Tr.write=new t.Group({id:"octokit-write",maxConcurrent:1,minTime:1e3,...e}),Tr.notifications=new t.Group({id:"octokit-notifications",maxConcurrent:1,minTime:3e3,...e})};function Pn(t,e){let{enabled:r=!0,Bottleneck:A=hp.default,id:s="no-id",timeout:o=1e3*60*2,connection:n}=e.throttle||{};if(!r)return{};let i={timeout:o};typeof n<"u"&&(i.connection=n),Tr.global==null&&lG(A,i);let a=Object.assign({clustering:n!=null,triggersNotification:Qp,fallbackSecondaryRateRetryAfter:60,retryAfterBaseValue:1e3,retryLimiter:new A,id:s,...Tr},e.throttle);if(typeof a.onSecondaryRateLimit!="function"||typeof a.onRateLimit!="function")throw new Error(`octokit/plugin-throttling error: +`.trim())}};rB.exports=Vc});var en=m((XL,iB)=>{"use strict";var sB=Symbol.for("undici.globalDispatcher.1"),{InvalidArgumentError:vT}=q(),_T=iA();nB()===void 0&&oB(new _T);function oB(t){if(!t||typeof t.dispatch!="function")throw new vT("Argument agent must implement Agent");Object.defineProperty(globalThis,sB,{value:t,writable:!0,enumerable:!1,configurable:!1})}function nB(){return globalThis[sB]}iB.exports={setGlobalDispatcher:oB,getGlobalDispatcher:nB}});var tn=m((ev,aB)=>{"use strict";aB.exports=class{#e;constructor(e){if(typeof e!="object"||e===null)throw new TypeError("handler must be an object");this.#e=e}onConnect(...e){return this.#e.onConnect?.(...e)}onError(...e){return this.#e.onError?.(...e)}onUpgrade(...e){return this.#e.onUpgrade?.(...e)}onResponseStarted(...e){return this.#e.onResponseStarted?.(...e)}onHeaders(...e){return this.#e.onHeaders?.(...e)}onData(...e){return this.#e.onData?.(...e)}onComplete(...e){return this.#e.onComplete?.(...e)}onBodySent(...e){return this.#e.onBodySent?.(...e)}}});var gB=m((tv,cB)=>{"use strict";var xT=No();cB.exports=t=>{let e=t?.maxRedirections;return r=>function(s,o){let{maxRedirections:n=e,...i}=s;if(!n)return r(s,o);let a=new xT(r,n,s,o);return r(i,a)}}});var lB=m((rv,uB)=>{"use strict";var YT=Po();uB.exports=t=>e=>function(A,s){return e(A,new YT({...A,retryOptions:{...t,...A.retryOptions}},{handler:s,dispatch:e}))}});var hB=m((Av,EB)=>{"use strict";var OT=O(),{InvalidArgumentError:JT,RequestAbortedError:HT}=q(),PT=tn(),qc=class extends PT{#e=1024*1024;#t=null;#r=!1;#o=!1;#s=0;#A=null;#n=null;constructor({maxSize:e},r){if(super(r),e!=null&&(!Number.isFinite(e)||e<1))throw new JT("maxSize must be a number greater than 0");this.#e=e??this.#e,this.#n=r}onConnect(e){this.#t=e,this.#n.onConnect(this.#i.bind(this))}#i(e){this.#o=!0,this.#A=e}onHeaders(e,r,A,s){let n=OT.parseHeaders(r)["content-length"];if(n!=null&&n>this.#e)throw new HT(`Response size (${n}) larger than maxSize (${this.#e})`);return this.#o?!0:this.#n.onHeaders(e,r,A,s)}onError(e){this.#r||(e=this.#A??e,this.#n.onError(e))}onData(e){return this.#s=this.#s+e.length,this.#s>=this.#e&&(this.#r=!0,this.#o?this.#n.onError(this.#A):this.#n.onComplete([])),!0}onComplete(e){if(!this.#r){if(this.#o){this.#n.onError(this.reason);return}this.#n.onComplete(e)}}};function VT({maxSize:t}={maxSize:1024*1024}){return e=>function(A,s){let{dumpMaxSize:o=t}=A,n=new qc({maxSize:o},s);return e(A,n)}}EB.exports=VT});var BB=m((sv,dB)=>{"use strict";var{isIP:qT}=require("node:net"),{lookup:WT}=require("node:dns"),zT=tn(),{InvalidArgumentError:BA,InformationalError:ZT}=q(),QB=Math.pow(2,31)-1,Wc=class{#e=0;#t=0;#r=new Map;dualStack=!0;affinity=null;lookup=null;pick=null;constructor(e){this.#e=e.maxTTL,this.#t=e.maxItems,this.dualStack=e.dualStack,this.affinity=e.affinity,this.lookup=e.lookup??this.#o,this.pick=e.pick??this.#s}get full(){return this.#r.size===this.#t}runLookup(e,r,A){let s=this.#r.get(e.hostname);if(s==null&&this.full){A(null,e.origin);return}let o={affinity:this.affinity,dualStack:this.dualStack,lookup:this.lookup,pick:this.pick,...r.dns,maxTTL:this.#e,maxItems:this.#t};if(s==null)this.lookup(e,o,(n,i)=>{if(n||i==null||i.length===0){A(n??new ZT("No DNS entries found"));return}this.setRecords(e,i);let a=this.#r.get(e.hostname),c=this.pick(e,a,o.affinity),u;typeof c.port=="number"?u=`:${c.port}`:e.port!==""?u=`:${e.port}`:u="",A(null,`${e.protocol}//${c.family===6?`[${c.address}]`:c.address}${u}`)});else{let n=this.pick(e,s,o.affinity);if(n==null){this.#r.delete(e.hostname),this.runLookup(e,r,A);return}let i;typeof n.port=="number"?i=`:${n.port}`:e.port!==""?i=`:${e.port}`:i="",A(null,`${e.protocol}//${n.family===6?`[${n.address}]`:n.address}${i}`)}}#o(e,r,A){WT(e.hostname,{all:!0,family:this.dualStack===!1?this.affinity:0,order:"ipv4first"},(s,o)=>{if(s)return A(s);let n=new Map;for(let i of o)n.set(`${i.address}:${i.family}`,i);A(null,n.values())})}#s(e,r,A){let s=null,{records:o,offset:n}=r,i;if(this.dualStack?(A==null&&(n==null||n===QB?(r.offset=0,A=4):(r.offset++,A=(r.offset&1)===1?6:4)),o[A]!=null&&o[A].ips.length>0?i=o[A]:i=o[A===4?6:4]):i=o[A],i==null||i.ips.length===0)return s;i.offset==null||i.offset===QB?i.offset=0:i.offset++;let a=i.offset%i.ips.length;return s=i.ips[a]??null,s==null?s:Date.now()-s.timestamp>s.ttl?(i.ips.splice(a,1),this.pick(e,r,A)):s}setRecords(e,r){let A=Date.now(),s={records:{4:null,6:null}};for(let o of r){o.timestamp=A,typeof o.ttl=="number"?o.ttl=Math.min(o.ttl,this.#e):o.ttl=this.#e;let n=s.records[o.family]??{ips:[]};n.ips.push(o),s.records[o.family]=n}this.#r.set(e.hostname,s)}getHandler(e,r){return new zc(this,e,r)}},zc=class extends zT{#e=null;#t=null;#r=null;#o=null;#s=null;constructor(e,{origin:r,handler:A,dispatch:s},o){super(A),this.#s=r,this.#o=A,this.#t={...o},this.#e=e,this.#r=s}onError(e){switch(e.code){case"ETIMEDOUT":case"ECONNREFUSED":{if(this.#e.dualStack){this.#e.runLookup(this.#s,this.#t,(r,A)=>{if(r)return this.#o.onError(r);let s={...this.#t,origin:A};this.#r(s,this)});return}this.#o.onError(e);return}case"ENOTFOUND":this.#e.deleteRecord(this.#s);default:this.#o.onError(e);break}}};dB.exports=t=>{if(t?.maxTTL!=null&&(typeof t?.maxTTL!="number"||t?.maxTTL<0))throw new BA("Invalid maxTTL. Must be a positive number");if(t?.maxItems!=null&&(typeof t?.maxItems!="number"||t?.maxItems<1))throw new BA("Invalid maxItems. Must be a positive number and greater than zero");if(t?.affinity!=null&&t?.affinity!==4&&t?.affinity!==6)throw new BA("Invalid affinity. Must be either 4 or 6");if(t?.dualStack!=null&&typeof t?.dualStack!="boolean")throw new BA("Invalid dualStack. Must be a boolean");if(t?.lookup!=null&&typeof t?.lookup!="function")throw new BA("Invalid lookup. Must be a function");if(t?.pick!=null&&typeof t?.pick!="function")throw new BA("Invalid pick. Must be a function");let e=t?.dualStack??!0,r;e?r=t?.affinity??null:r=t?.affinity??4;let A={maxTTL:t?.maxTTL??1e4,lookup:t?.lookup??null,pick:t?.pick??null,dualStack:e,affinity:r,maxItems:t?.maxItems??1/0},s=new Wc(A);return o=>function(i,a){let c=i.origin.constructor===URL?i.origin:new URL(i.origin);return qT(c.hostname)!==0?o(i,a):(s.runLookup(c,i,(u,g)=>{if(u)return a.onError(u);let E=null;E={...i,servername:c.hostname,origin:g,headers:{host:c.hostname,...i.headers}},o(E,s.getHandler({origin:c,dispatch:o,handler:a},i))}),!0)}}});var yr=m((ov,yB)=>{"use strict";var{kConstruct:KT}=se(),{kEnumerableProperty:IA}=O(),{iteratorMixin:jT,isValidHeaderName:Bs,isValidHeaderValue:CB}=Fe(),{webidl:V}=Be(),Zc=require("node:assert"),rn=require("node:util"),ue=Symbol("headers map"),Ge=Symbol("headers map sorted");function IB(t){return t===10||t===13||t===9||t===32}function pB(t){let e=0,r=t.length;for(;r>e&&IB(t.charCodeAt(r-1));)--r;for(;r>e&&IB(t.charCodeAt(e));)++e;return e===0&&r===t.length?t:t.substring(e,r)}function fB(t,e){if(Array.isArray(e))for(let r=0;r>","record"]})}function Kc(t,e,r){if(r=pB(r),Bs(e)){if(!CB(r))throw V.errors.invalidArgument({prefix:"Headers.append",value:r,type:"header value"})}else throw V.errors.invalidArgument({prefix:"Headers.append",value:e,type:"header name"});if(wB(t)==="immutable")throw new TypeError("immutable");return jc(t).append(e,r,!1)}function mB(t,e){return t[0]>1),r[c][0]<=u[0]?a=c+1:i=c;if(o!==c){for(n=o;n>a;)r[n]=r[--n];r[a]=u}}if(!A.next().done)throw new TypeError("Unreachable");return r}else{let A=0;for(let{0:s,1:{value:o}}of this[ue])r[A++]=[s,o],Zc(o!==null);return r.sort(mB)}}},rt=class t{#e;#t;constructor(e=void 0){V.util.markAsUncloneable(this),e!==KT&&(this.#t=new An,this.#e="none",e!==void 0&&(e=V.converters.HeadersInit(e,"Headers contructor","init"),fB(this,e)))}append(e,r){V.brandCheck(this,t),V.argumentLengthCheck(arguments,2,"Headers.append");let A="Headers.append";return e=V.converters.ByteString(e,A,"name"),r=V.converters.ByteString(r,A,"value"),Kc(this,e,r)}delete(e){if(V.brandCheck(this,t),V.argumentLengthCheck(arguments,1,"Headers.delete"),e=V.converters.ByteString(e,"Headers.delete","name"),!Bs(e))throw V.errors.invalidArgument({prefix:"Headers.delete",value:e,type:"header name"});if(this.#e==="immutable")throw new TypeError("immutable");this.#t.contains(e,!1)&&this.#t.delete(e,!1)}get(e){V.brandCheck(this,t),V.argumentLengthCheck(arguments,1,"Headers.get");let r="Headers.get";if(e=V.converters.ByteString(e,r,"name"),!Bs(e))throw V.errors.invalidArgument({prefix:r,value:e,type:"header name"});return this.#t.get(e,!1)}has(e){V.brandCheck(this,t),V.argumentLengthCheck(arguments,1,"Headers.has");let r="Headers.has";if(e=V.converters.ByteString(e,r,"name"),!Bs(e))throw V.errors.invalidArgument({prefix:r,value:e,type:"header name"});return this.#t.contains(e,!1)}set(e,r){V.brandCheck(this,t),V.argumentLengthCheck(arguments,2,"Headers.set");let A="Headers.set";if(e=V.converters.ByteString(e,A,"name"),r=V.converters.ByteString(r,A,"value"),r=pB(r),Bs(e)){if(!CB(r))throw V.errors.invalidArgument({prefix:A,value:r,type:"header value"})}else throw V.errors.invalidArgument({prefix:A,value:e,type:"header name"});if(this.#e==="immutable")throw new TypeError("immutable");this.#t.set(e,r,!1)}getSetCookie(){V.brandCheck(this,t);let e=this.#t.cookies;return e?[...e]:[]}get[Ge](){if(this.#t[Ge])return this.#t[Ge];let e=[],r=this.#t.toSortedArray(),A=this.#t.cookies;if(A===null||A.length===1)return this.#t[Ge]=r;for(let s=0;s>"](t,e,r,A.bind(t)):V.converters["record"](t,e,r)}throw V.errors.conversionFailed({prefix:"Headers constructor",argument:"Argument 1",types:["sequence>","record"]})};yB.exports={fill:fB,compareHeaderName:mB,Headers:rt,HeadersList:An,getHeadersGuard:wB,setHeadersGuard:XT,setHeadersList:$T,getHeadersList:jc}});var Cs=m((nv,LB)=>{"use strict";var{Headers:FB,HeadersList:bB,fill:e0,getHeadersGuard:t0,setHeadersGuard:SB,setHeadersList:UB}=yr(),{extractBody:DB,cloneBody:r0,mixinBody:A0,hasFinalizationRegistry:NB,streamRegistry:GB,bodyUnusable:s0}=Xr(),Xc=O(),kB=require("node:util"),{kEnumerableProperty:Me}=Xc,{isValidReasonPhrase:o0,isCancelled:n0,isAborted:i0,isBlobLike:a0,serializeJavascriptValueToJSONString:c0,isErrorLike:g0,isomorphicEncode:u0,environmentSettingsObject:l0}=Fe(),{redirectStatusSet:E0,nullBodyStatus:h0}=JA(),{kState:ne,kHeaders:Ut}=Yt(),{webidl:Y}=Be(),{FormData:Q0}=zA(),{URLSerializer:RB}=ye(),{kConstruct:on}=se(),$c=require("node:assert"),{types:d0}=require("node:util"),B0=new TextEncoder("utf-8"),br=class t{static error(){return Is(nn(),"immutable")}static json(e,r={}){Y.argumentLengthCheck(arguments,1,"Response.json"),r!==null&&(r=Y.converters.ResponseInit(r));let A=B0.encode(c0(e)),s=DB(A),o=Is(CA({}),"response");return TB(o,r,{body:s[0],type:"application/json"}),o}static redirect(e,r=302){Y.argumentLengthCheck(arguments,1,"Response.redirect"),e=Y.converters.USVString(e),r=Y.converters["unsigned short"](r);let A;try{A=new URL(e,l0.settingsObject.baseUrl)}catch(n){throw new TypeError(`Failed to parse URL from ${e}`,{cause:n})}if(!E0.has(r))throw new RangeError(`Invalid status code ${r}`);let s=Is(CA({}),"immutable");s[ne].status=r;let o=u0(RB(A));return s[ne].headersList.append("location",o,!0),s}constructor(e=null,r={}){if(Y.util.markAsUncloneable(this),e===on)return;e!==null&&(e=Y.converters.BodyInit(e)),r=Y.converters.ResponseInit(r),this[ne]=CA({}),this[Ut]=new FB(on),SB(this[Ut],"response"),UB(this[Ut],this[ne].headersList);let A=null;if(e!=null){let[s,o]=DB(e);A={body:s,type:o}}TB(this,r,A)}get type(){return Y.brandCheck(this,t),this[ne].type}get url(){Y.brandCheck(this,t);let e=this[ne].urlList,r=e[e.length-1]??null;return r===null?"":RB(r,!0)}get redirected(){return Y.brandCheck(this,t),this[ne].urlList.length>1}get status(){return Y.brandCheck(this,t),this[ne].status}get ok(){return Y.brandCheck(this,t),this[ne].status>=200&&this[ne].status<=299}get statusText(){return Y.brandCheck(this,t),this[ne].statusText}get headers(){return Y.brandCheck(this,t),this[Ut]}get body(){return Y.brandCheck(this,t),this[ne].body?this[ne].body.stream:null}get bodyUsed(){return Y.brandCheck(this,t),!!this[ne].body&&Xc.isDisturbed(this[ne].body.stream)}clone(){if(Y.brandCheck(this,t),s0(this))throw Y.errors.exception({header:"Response.clone",message:"Body has already been consumed."});let e=eg(this[ne]);return NB&&this[ne].body?.stream&&GB.register(this,new WeakRef(this[ne].body.stream)),Is(e,t0(this[Ut]))}[kB.inspect.custom](e,r){r.depth===null&&(r.depth=2),r.colors??=!0;let A={status:this.status,statusText:this.statusText,headers:this.headers,body:this.body,bodyUsed:this.bodyUsed,ok:this.ok,redirected:this.redirected,type:this.type,url:this.url};return`Response ${kB.formatWithOptions(r,A)}`}};A0(br);Object.defineProperties(br.prototype,{type:Me,url:Me,status:Me,ok:Me,redirected:Me,statusText:Me,headers:Me,clone:Me,body:Me,bodyUsed:Me,[Symbol.toStringTag]:{value:"Response",configurable:!0}});Object.defineProperties(br,{json:Me,redirect:Me,error:Me});function eg(t){if(t.internalResponse)return MB(eg(t.internalResponse),t.type);let e=CA({...t,body:null});return t.body!=null&&(e.body=r0(e,t.body)),e}function CA(t){return{aborted:!1,rangeRequested:!1,timingAllowPassed:!1,requestIncludesCredentials:!1,type:"default",status:200,timingInfo:null,cacheState:"",statusText:"",...t,headersList:t?.headersList?new bB(t?.headersList):new bB,urlList:t?.urlList?[...t.urlList]:[]}}function nn(t){let e=g0(t);return CA({type:"error",status:0,error:e?t:new Error(t&&String(t)),aborted:t&&t.name==="AbortError"})}function I0(t){return t.type==="error"&&t.status===0}function sn(t,e){return e={internalResponse:t,...e},new Proxy(t,{get(r,A){return A in e?e[A]:r[A]},set(r,A,s){return $c(!(A in e)),r[A]=s,!0}})}function MB(t,e){if(e==="basic")return sn(t,{type:"basic",headersList:t.headersList});if(e==="cors")return sn(t,{type:"cors",headersList:t.headersList});if(e==="opaque")return sn(t,{type:"opaque",urlList:Object.freeze([]),status:0,statusText:"",body:null});if(e==="opaqueredirect")return sn(t,{type:"opaqueredirect",status:0,statusText:"",headersList:[],body:null});$c(!1)}function C0(t,e=null){return $c(n0(t)),i0(t)?nn(Object.assign(new DOMException("The operation was aborted.","AbortError"),{cause:e})):nn(Object.assign(new DOMException("Request was cancelled."),{cause:e}))}function TB(t,e,r){if(e.status!==null&&(e.status<200||e.status>599))throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.');if("statusText"in e&&e.statusText!=null&&!o0(String(e.statusText)))throw new TypeError("Invalid statusText");if("status"in e&&e.status!=null&&(t[ne].status=e.status),"statusText"in e&&e.statusText!=null&&(t[ne].statusText=e.statusText),"headers"in e&&e.headers!=null&&e0(t[Ut],e.headers),r){if(h0.includes(t.status))throw Y.errors.exception({header:"Response constructor",message:`Invalid response status code ${t.status}`});t[ne].body=r.body,r.type!=null&&!t[ne].headersList.contains("content-type",!0)&&t[ne].headersList.append("content-type",r.type,!0)}}function Is(t,e){let r=new br(on);return r[ne]=t,r[Ut]=new FB(on),UB(r[Ut],t.headersList),SB(r[Ut],e),NB&&t.body?.stream&&GB.register(r,new WeakRef(t.body.stream)),r}Y.converters.ReadableStream=Y.interfaceConverter(ReadableStream);Y.converters.FormData=Y.interfaceConverter(Q0);Y.converters.URLSearchParams=Y.interfaceConverter(URLSearchParams);Y.converters.XMLHttpRequestBodyInit=function(t,e,r){return typeof t=="string"?Y.converters.USVString(t,e,r):a0(t)?Y.converters.Blob(t,e,r,{strict:!1}):ArrayBuffer.isView(t)||d0.isArrayBuffer(t)?Y.converters.BufferSource(t,e,r):Xc.isFormDataLike(t)?Y.converters.FormData(t,e,r,{strict:!1}):t instanceof URLSearchParams?Y.converters.URLSearchParams(t,e,r):Y.converters.DOMString(t,e,r)};Y.converters.BodyInit=function(t,e,r){return t instanceof ReadableStream?Y.converters.ReadableStream(t,e,r):t?.[Symbol.asyncIterator]?t:Y.converters.XMLHttpRequestBodyInit(t,e,r)};Y.converters.ResponseInit=Y.dictionaryConverter([{key:"status",converter:Y.converters["unsigned short"],defaultValue:()=>200},{key:"statusText",converter:Y.converters.ByteString,defaultValue:()=>""},{key:"headers",converter:Y.converters.HeadersInit}]);LB.exports={isNetworkError:I0,makeNetworkError:nn,makeResponse:CA,makeAppropriateNetworkError:C0,filterResponse:MB,Response:br,cloneResponse:eg,fromInnerResponse:Is}});var YB=m((iv,xB)=>{"use strict";var{kConnected:vB,kSize:_B}=se(),tg=class{constructor(e){this.value=e}deref(){return this.value[vB]===0&&this.value[_B]===0?void 0:this.value}},rg=class{constructor(e){this.finalizer=e}register(e,r){e.on&&e.on("disconnect",()=>{e[vB]===0&&e[_B]===0&&this.finalizer(r)})}unregister(e){}};xB.exports=function(){return process.env.NODE_V8_COVERAGE&&process.version.startsWith("v18")?(process._rawDebug("Using compatibility WeakRef and FinalizationRegistry"),{WeakRef:tg,FinalizationRegistry:rg}):{WeakRef,FinalizationRegistry}}});var pA=m((av,tI)=>{"use strict";var{extractBody:p0,mixinBody:f0,cloneBody:m0,bodyUnusable:OB}=Xr(),{Headers:KB,fill:w0,HeadersList:un,setHeadersGuard:sg,getHeadersGuard:y0,setHeadersList:jB,getHeadersList:JB}=yr(),{FinalizationRegistry:b0}=YB()(),cn=O(),HB=require("node:util"),{isValidHTTPToken:D0,sameOrigin:PB,environmentSettingsObject:an}=Fe(),{forbiddenMethodsSet:k0,corsSafeListedMethodsSet:R0,referrerPolicy:T0,requestRedirect:F0,requestMode:S0,requestCredentials:U0,requestCache:N0,requestDuplex:G0}=JA(),{kEnumerableProperty:le,normalizedMethodRecordsBase:M0,normalizedMethodRecords:L0}=cn,{kHeaders:Le,kSignal:gn,kState:Ae,kDispatcher:Ag}=Yt(),{webidl:v}=Be(),{URLSerializer:v0}=ye(),{kConstruct:ln}=se(),_0=require("node:assert"),{getMaxListeners:VB,setMaxListeners:qB,getEventListeners:x0,defaultMaxListeners:WB}=require("node:events"),Y0=Symbol("abortController"),XB=new b0(({signal:t,abort:e})=>{t.removeEventListener("abort",e)}),En=new WeakMap;function zB(t){return e;function e(){let r=t.deref();if(r!==void 0){XB.unregister(e),this.removeEventListener("abort",e),r.abort(this.reason);let A=En.get(r.signal);if(A!==void 0){if(A.size!==0){for(let s of A){let o=s.deref();o!==void 0&&o.abort(this.reason)}A.clear()}En.delete(r.signal)}}}}var ZB=!1,jt=class t{constructor(e,r={}){if(v.util.markAsUncloneable(this),e===ln)return;let A="Request constructor";v.argumentLengthCheck(arguments,1,A),e=v.converters.RequestInfo(e,A,"input"),r=v.converters.RequestInit(r,A,"init");let s=null,o=null,n=an.settingsObject.baseUrl,i=null;if(typeof e=="string"){this[Ag]=r.dispatcher;let B;try{B=new URL(e,n)}catch(w){throw new TypeError("Failed to parse URL from "+e,{cause:w})}if(B.username||B.password)throw new TypeError("Request cannot be constructed from a URL that includes credentials: "+e);s=hn({urlList:[B]}),o="cors"}else this[Ag]=r.dispatcher||e[Ag],_0(e instanceof t),s=e[Ae],i=e[gn];let a=an.settingsObject.origin,c="client";if(s.window?.constructor?.name==="EnvironmentSettingsObject"&&PB(s.window,a)&&(c=s.window),r.window!=null)throw new TypeError(`'window' option '${c}' must be null`);"window"in r&&(c="no-window"),s=hn({method:s.method,headersList:s.headersList,unsafeRequest:s.unsafeRequest,client:an.settingsObject,window:c,priority:s.priority,origin:s.origin,referrer:s.referrer,referrerPolicy:s.referrerPolicy,mode:s.mode,credentials:s.credentials,cache:s.cache,redirect:s.redirect,integrity:s.integrity,keepalive:s.keepalive,reloadNavigation:s.reloadNavigation,historyNavigation:s.historyNavigation,urlList:[...s.urlList]});let u=Object.keys(r).length!==0;if(u&&(s.mode==="navigate"&&(s.mode="same-origin"),s.reloadNavigation=!1,s.historyNavigation=!1,s.origin="client",s.referrer="client",s.referrerPolicy="",s.url=s.urlList[s.urlList.length-1],s.urlList=[s.url]),r.referrer!==void 0){let B=r.referrer;if(B==="")s.referrer="no-referrer";else{let w;try{w=new URL(B,n)}catch(T){throw new TypeError(`Referrer "${B}" is not a valid URL.`,{cause:T})}w.protocol==="about:"&&w.hostname==="client"||a&&!PB(w,an.settingsObject.baseUrl)?s.referrer="client":s.referrer=w}}r.referrerPolicy!==void 0&&(s.referrerPolicy=r.referrerPolicy);let g;if(r.mode!==void 0?g=r.mode:g=o,g==="navigate")throw v.errors.exception({header:"Request constructor",message:"invalid request mode navigate."});if(g!=null&&(s.mode=g),r.credentials!==void 0&&(s.credentials=r.credentials),r.cache!==void 0&&(s.cache=r.cache),s.cache==="only-if-cached"&&s.mode!=="same-origin")throw new TypeError("'only-if-cached' can be set only with 'same-origin' mode");if(r.redirect!==void 0&&(s.redirect=r.redirect),r.integrity!=null&&(s.integrity=String(r.integrity)),r.keepalive!==void 0&&(s.keepalive=!!r.keepalive),r.method!==void 0){let B=r.method,w=L0[B];if(w!==void 0)s.method=w;else{if(!D0(B))throw new TypeError(`'${B}' is not a valid HTTP method.`);let T=B.toUpperCase();if(k0.has(T))throw new TypeError(`'${B}' HTTP method is unsupported.`);B=M0[T]??B,s.method=B}!ZB&&s.method==="patch"&&(process.emitWarning("Using `patch` is highly likely to result in a `405 Method Not Allowed`. `PATCH` is much more likely to succeed.",{code:"UNDICI-FETCH-patch"}),ZB=!0)}r.signal!==void 0&&(i=r.signal),this[Ae]=s;let E=new AbortController;if(this[gn]=E.signal,i!=null){if(!i||typeof i.aborted!="boolean"||typeof i.addEventListener!="function")throw new TypeError("Failed to construct 'Request': member signal is not of type AbortSignal.");if(i.aborted)E.abort(i.reason);else{this[Y0]=E;let B=new WeakRef(E),w=zB(B);try{(typeof VB=="function"&&VB(i)===WB||x0(i,"abort").length>=WB)&&qB(1500,i)}catch{}cn.addAbortListener(i,w),XB.register(E,{signal:i,abort:w},w)}}if(this[Le]=new KB(ln),jB(this[Le],s.headersList),sg(this[Le],"request"),g==="no-cors"){if(!R0.has(s.method))throw new TypeError(`'${s.method} is unsupported in no-cors mode.`);sg(this[Le],"request-no-cors")}if(u){let B=JB(this[Le]),w=r.headers!==void 0?r.headers:new un(B);if(B.clear(),w instanceof un){for(let{name:T,value:S}of w.rawValues())B.append(T,S,!1);B.cookies=w.cookies}else w0(this[Le],w)}let I=e instanceof t?e[Ae].body:null;if((r.body!=null||I!=null)&&(s.method==="GET"||s.method==="HEAD"))throw new TypeError("Request with GET/HEAD method cannot have body.");let d=null;if(r.body!=null){let[B,w]=p0(r.body,s.keepalive);d=B,w&&!JB(this[Le]).contains("content-type",!0)&&this[Le].append("content-type",w)}let p=d??I;if(p!=null&&p.source==null){if(d!=null&&r.duplex==null)throw new TypeError("RequestInit: duplex option is required when sending a body.");if(s.mode!=="same-origin"&&s.mode!=="cors")throw new TypeError('If request is made from ReadableStream, mode should be "same-origin" or "cors"');s.useCORSPreflightFlag=!0}let y=p;if(d==null&&I!=null){if(OB(e))throw new TypeError("Cannot construct a Request with a Request object that has already been used.");let B=new TransformStream;I.stream.pipeThrough(B),y={source:I.source,length:I.length,stream:B.readable}}this[Ae].body=y}get method(){return v.brandCheck(this,t),this[Ae].method}get url(){return v.brandCheck(this,t),v0(this[Ae].url)}get headers(){return v.brandCheck(this,t),this[Le]}get destination(){return v.brandCheck(this,t),this[Ae].destination}get referrer(){return v.brandCheck(this,t),this[Ae].referrer==="no-referrer"?"":this[Ae].referrer==="client"?"about:client":this[Ae].referrer.toString()}get referrerPolicy(){return v.brandCheck(this,t),this[Ae].referrerPolicy}get mode(){return v.brandCheck(this,t),this[Ae].mode}get credentials(){return this[Ae].credentials}get cache(){return v.brandCheck(this,t),this[Ae].cache}get redirect(){return v.brandCheck(this,t),this[Ae].redirect}get integrity(){return v.brandCheck(this,t),this[Ae].integrity}get keepalive(){return v.brandCheck(this,t),this[Ae].keepalive}get isReloadNavigation(){return v.brandCheck(this,t),this[Ae].reloadNavigation}get isHistoryNavigation(){return v.brandCheck(this,t),this[Ae].historyNavigation}get signal(){return v.brandCheck(this,t),this[gn]}get body(){return v.brandCheck(this,t),this[Ae].body?this[Ae].body.stream:null}get bodyUsed(){return v.brandCheck(this,t),!!this[Ae].body&&cn.isDisturbed(this[Ae].body.stream)}get duplex(){return v.brandCheck(this,t),"half"}clone(){if(v.brandCheck(this,t),OB(this))throw new TypeError("unusable");let e=$B(this[Ae]),r=new AbortController;if(this.signal.aborted)r.abort(this.signal.reason);else{let A=En.get(this.signal);A===void 0&&(A=new Set,En.set(this.signal,A));let s=new WeakRef(r);A.add(s),cn.addAbortListener(r.signal,zB(s))}return eI(e,r.signal,y0(this[Le]))}[HB.inspect.custom](e,r){r.depth===null&&(r.depth=2),r.colors??=!0;let A={method:this.method,url:this.url,headers:this.headers,destination:this.destination,referrer:this.referrer,referrerPolicy:this.referrerPolicy,mode:this.mode,credentials:this.credentials,cache:this.cache,redirect:this.redirect,integrity:this.integrity,keepalive:this.keepalive,isReloadNavigation:this.isReloadNavigation,isHistoryNavigation:this.isHistoryNavigation,signal:this.signal};return`Request ${HB.formatWithOptions(r,A)}`}};f0(jt);function hn(t){return{method:t.method??"GET",localURLsOnly:t.localURLsOnly??!1,unsafeRequest:t.unsafeRequest??!1,body:t.body??null,client:t.client??null,reservedClient:t.reservedClient??null,replacesClientId:t.replacesClientId??"",window:t.window??"client",keepalive:t.keepalive??!1,serviceWorkers:t.serviceWorkers??"all",initiator:t.initiator??"",destination:t.destination??"",priority:t.priority??null,origin:t.origin??"client",policyContainer:t.policyContainer??"client",referrer:t.referrer??"client",referrerPolicy:t.referrerPolicy??"",mode:t.mode??"no-cors",useCORSPreflightFlag:t.useCORSPreflightFlag??!1,credentials:t.credentials??"same-origin",useCredentials:t.useCredentials??!1,cache:t.cache??"default",redirect:t.redirect??"follow",integrity:t.integrity??"",cryptoGraphicsNonceMetadata:t.cryptoGraphicsNonceMetadata??"",parserMetadata:t.parserMetadata??"",reloadNavigation:t.reloadNavigation??!1,historyNavigation:t.historyNavigation??!1,userActivation:t.userActivation??!1,taintedOrigin:t.taintedOrigin??!1,redirectCount:t.redirectCount??0,responseTainting:t.responseTainting??"basic",preventNoCacheCacheControlHeaderModification:t.preventNoCacheCacheControlHeaderModification??!1,done:t.done??!1,timingAllowFailed:t.timingAllowFailed??!1,urlList:t.urlList,url:t.urlList[0],headersList:t.headersList?new un(t.headersList):new un}}function $B(t){let e=hn({...t,body:null});return t.body!=null&&(e.body=m0(e,t.body)),e}function eI(t,e,r){let A=new jt(ln);return A[Ae]=t,A[gn]=e,A[Le]=new KB(ln),jB(A[Le],t.headersList),sg(A[Le],r),A}Object.defineProperties(jt.prototype,{method:le,url:le,headers:le,redirect:le,clone:le,signal:le,duplex:le,destination:le,body:le,bodyUsed:le,isHistoryNavigation:le,isReloadNavigation:le,keepalive:le,integrity:le,cache:le,credentials:le,attribute:le,referrerPolicy:le,referrer:le,mode:le,[Symbol.toStringTag]:{value:"Request",configurable:!0}});v.converters.Request=v.interfaceConverter(jt);v.converters.RequestInfo=function(t,e,r){return typeof t=="string"?v.converters.USVString(t,e,r):t instanceof jt?v.converters.Request(t,e,r):v.converters.USVString(t,e,r)};v.converters.AbortSignal=v.interfaceConverter(AbortSignal);v.converters.RequestInit=v.dictionaryConverter([{key:"method",converter:v.converters.ByteString},{key:"headers",converter:v.converters.HeadersInit},{key:"body",converter:v.nullableConverter(v.converters.BodyInit)},{key:"referrer",converter:v.converters.USVString},{key:"referrerPolicy",converter:v.converters.DOMString,allowedValues:T0},{key:"mode",converter:v.converters.DOMString,allowedValues:S0},{key:"credentials",converter:v.converters.DOMString,allowedValues:U0},{key:"cache",converter:v.converters.DOMString,allowedValues:N0},{key:"redirect",converter:v.converters.DOMString,allowedValues:F0},{key:"integrity",converter:v.converters.DOMString},{key:"keepalive",converter:v.converters.boolean},{key:"signal",converter:v.nullableConverter(t=>v.converters.AbortSignal(t,"RequestInit","signal",{strict:!1}))},{key:"window",converter:v.converters.any},{key:"duplex",converter:v.converters.DOMString,allowedValues:G0},{key:"dispatcher",converter:v.converters.any}]);tI.exports={Request:jt,makeRequest:hn,fromInnerRequest:eI,cloneRequest:$B}});var fs=m((cv,dI)=>{"use strict";var{makeNetworkError:K,makeAppropriateNetworkError:Qn,filterResponse:og,makeResponse:dn,fromInnerResponse:O0}=Cs(),{HeadersList:rI}=yr(),{Request:J0,cloneRequest:H0}=pA(),Xt=require("node:zlib"),{bytesMatch:P0,makePolicyContainer:V0,clonePolicyContainer:q0,requestBadPort:W0,TAOCheck:z0,appendRequestOriginHeader:Z0,responseLocationURL:K0,requestCurrentURL:dt,setRequestReferrerPolicyOnRedirect:j0,tryUpgradeRequestToAPotentiallyTrustworthyURL:X0,createOpaqueTimingInfo:gg,appendFetchMetadata:$0,corsCheck:eF,crossOriginResourcePolicyCheck:tF,determineRequestsReferrer:rF,coarsenedSharedCurrentTime:ps,createDeferredPromise:AF,isBlobLike:sF,sameOrigin:cg,isCancelled:Dr,isAborted:AI,isErrorLike:oF,fullyReadBody:nF,readableStreamClose:iF,isomorphicEncode:Bn,urlIsLocal:aF,urlIsHttpHttpsScheme:ug,urlHasHttpsScheme:cF,clampAndCoarsenConnectionTimingInfo:gF,simpleRangeHeaderValue:uF,buildContentRange:lF,createInflate:EF,extractMimeType:hF}=Fe(),{kState:iI,kDispatcher:QF}=Yt(),kr=require("node:assert"),{safelyExtractBody:lg,extractBody:sI}=Xr(),{redirectStatusSet:aI,nullBodyStatus:cI,safeMethodsSet:dF,requestBodyHeader:BF,subresourceSet:IF}=JA(),CF=require("node:events"),{Readable:pF,pipeline:fF,finished:mF}=require("node:stream"),{addAbortListener:wF,isErrored:yF,isReadable:In,bufferToLowerCasedHeaderName:oI}=O(),{dataURLProcessor:bF,serializeAMimeType:DF,minimizeSupportedMimeType:kF}=ye(),{getGlobalDispatcher:RF}=en(),{webidl:TF}=Be(),{STATUS_CODES:FF}=require("node:http"),SF=["GET","HEAD"],UF=typeof __UNDICI_IS_NODE__<"u"||typeof esbuildDetection<"u"?"node":"undici",ng,Cn=class extends CF{constructor(e){super(),this.dispatcher=e,this.connection=null,this.dump=!1,this.state="ongoing"}terminate(e){this.state==="ongoing"&&(this.state="terminated",this.connection?.destroy(e),this.emit("terminated",e))}abort(e){this.state==="ongoing"&&(this.state="aborted",e||(e=new DOMException("The operation was aborted.","AbortError")),this.serializedAbortReason=e,this.connection?.destroy(e),this.emit("terminated",e))}};function NF(t){gI(t,"fetch")}function GF(t,e=void 0){TF.argumentLengthCheck(arguments,1,"globalThis.fetch");let r=AF(),A;try{A=new J0(t,e)}catch(u){return r.reject(u),r.promise}let s=A[iI];if(A.signal.aborted)return ig(r,s,null,A.signal.reason),r.promise;s.client.globalObject?.constructor?.name==="ServiceWorkerGlobalScope"&&(s.serviceWorkers="none");let n=null,i=!1,a=null;return wF(A.signal,()=>{i=!0,kr(a!=null),a.abort(A.signal.reason);let u=n?.deref();ig(r,s,u,A.signal.reason)}),a=lI({request:s,processResponseEndOfBody:NF,processResponse:u=>{if(!i){if(u.aborted){ig(r,s,n,a.serializedAbortReason);return}if(u.type==="error"){r.reject(new TypeError("fetch failed",{cause:u.error}));return}n=new WeakRef(O0(u,"immutable")),r.resolve(n.deref()),r=null}},dispatcher:A[QF]}),r.promise}function gI(t,e="other"){if(t.type==="error"&&t.aborted||!t.urlList?.length)return;let r=t.urlList[0],A=t.timingInfo,s=t.cacheState;ug(r)&&A!==null&&(t.timingAllowPassed||(A=gg({startTime:A.startTime}),s=""),A.endTime=ps(),t.timingInfo=A,uI(A,r.href,e,globalThis,s))}var uI=performance.markResourceTiming;function ig(t,e,r,A){if(t&&t.reject(A),e.body!=null&&In(e.body?.stream)&&e.body.stream.cancel(A).catch(o=>{if(o.code!=="ERR_INVALID_STATE")throw o}),r==null)return;let s=r[iI];s.body!=null&&In(s.body?.stream)&&s.body.stream.cancel(A).catch(o=>{if(o.code!=="ERR_INVALID_STATE")throw o})}function lI({request:t,processRequestBodyChunkLength:e,processRequestEndOfBody:r,processResponse:A,processResponseEndOfBody:s,processResponseConsumeBody:o,useParallelQueue:n=!1,dispatcher:i=RF()}){kr(i);let a=null,c=!1;t.client!=null&&(a=t.client.globalObject,c=t.client.crossOriginIsolatedCapability);let u=ps(c),g=gg({startTime:u}),E={controller:new Cn(i),request:t,timingInfo:g,processRequestBodyChunkLength:e,processRequestEndOfBody:r,processResponse:A,processResponseConsumeBody:o,processResponseEndOfBody:s,taskDestination:a,crossOriginIsolatedCapability:c};return kr(!t.body||t.body.stream),t.window==="client"&&(t.window=t.client?.globalObject?.constructor?.name==="Window"?t.client:"no-window"),t.origin==="client"&&(t.origin=t.client.origin),t.policyContainer==="client"&&(t.client!=null?t.policyContainer=q0(t.client.policyContainer):t.policyContainer=V0()),t.headersList.contains("accept",!0)||t.headersList.append("accept","*/*",!0),t.headersList.contains("accept-language",!0)||t.headersList.append("accept-language","*",!0),t.priority,IF.has(t.destination),EI(E).catch(I=>{E.controller.terminate(I)}),E.controller}async function EI(t,e=!1){let r=t.request,A=null;if(r.localURLsOnly&&!aF(dt(r))&&(A=K("local URLs only")),X0(r),W0(r)==="blocked"&&(A=K("bad port")),r.referrerPolicy===""&&(r.referrerPolicy=r.policyContainer.referrerPolicy),r.referrer!=="no-referrer"&&(r.referrer=rF(r)),A===null&&(A=await(async()=>{let o=dt(r);return cg(o,r.url)&&r.responseTainting==="basic"||o.protocol==="data:"||r.mode==="navigate"||r.mode==="websocket"?(r.responseTainting="basic",await nI(t)):r.mode==="same-origin"?K('request mode cannot be "same-origin"'):r.mode==="no-cors"?r.redirect!=="follow"?K('redirect mode cannot be "follow" for "no-cors" request'):(r.responseTainting="opaque",await nI(t)):ug(dt(r))?(r.responseTainting="cors",await hI(t)):K("URL scheme must be a HTTP(S) scheme")})()),e)return A;A.status!==0&&!A.internalResponse&&(r.responseTainting,r.responseTainting==="basic"?A=og(A,"basic"):r.responseTainting==="cors"?A=og(A,"cors"):r.responseTainting==="opaque"?A=og(A,"opaque"):kr(!1));let s=A.status===0?A:A.internalResponse;if(s.urlList.length===0&&s.urlList.push(...r.urlList),r.timingAllowFailed||(A.timingAllowPassed=!0),A.type==="opaque"&&s.status===206&&s.rangeRequested&&!r.headers.contains("range",!0)&&(A=s=K()),A.status!==0&&(r.method==="HEAD"||r.method==="CONNECT"||cI.includes(s.status))&&(s.body=null,t.controller.dump=!0),r.integrity){let o=i=>ag(t,K(i));if(r.responseTainting==="opaque"||A.body==null){o(A.error);return}let n=i=>{if(!P0(i,r.integrity)){o("integrity mismatch");return}A.body=lg(i)[0],ag(t,A)};await nF(A.body,n,o)}else ag(t,A)}function nI(t){if(Dr(t)&&t.request.redirectCount===0)return Promise.resolve(Qn(t));let{request:e}=t,{protocol:r}=dt(e);switch(r){case"about:":return Promise.resolve(K("about scheme is not supported"));case"blob:":{ng||(ng=require("node:buffer").resolveObjectURL);let A=dt(e);if(A.search.length!==0)return Promise.resolve(K("NetworkError when attempting to fetch resource."));let s=ng(A.toString());if(e.method!=="GET"||!sF(s))return Promise.resolve(K("invalid method"));let o=dn(),n=s.size,i=Bn(`${n}`),a=s.type;if(e.headersList.contains("range",!0)){o.rangeRequested=!0;let c=e.headersList.get("range",!0),u=uF(c,!0);if(u==="failure")return Promise.resolve(K("failed to fetch the data URL"));let{rangeStartValue:g,rangeEndValue:E}=u;if(g===null)g=n-E,E=g+E-1;else{if(g>=n)return Promise.resolve(K("Range start is greater than the blob's size."));(E===null||E>=n)&&(E=n-1)}let I=s.slice(g,E,a),d=sI(I);o.body=d[0];let p=Bn(`${I.size}`),y=lF(g,E,n);o.status=206,o.statusText="Partial Content",o.headersList.set("content-length",p,!0),o.headersList.set("content-type",a,!0),o.headersList.set("content-range",y,!0)}else{let c=sI(s);o.statusText="OK",o.body=c[0],o.headersList.set("content-length",i,!0),o.headersList.set("content-type",a,!0)}return Promise.resolve(o)}case"data:":{let A=dt(e),s=bF(A);if(s==="failure")return Promise.resolve(K("failed to fetch the data URL"));let o=DF(s.mimeType);return Promise.resolve(dn({statusText:"OK",headersList:[["content-type",{name:"Content-Type",value:o}]],body:lg(s.body)[0]}))}case"file:":return Promise.resolve(K("not implemented... yet..."));case"http:":case"https:":return hI(t).catch(A=>K(A));default:return Promise.resolve(K("unknown scheme"))}}function MF(t,e){t.request.done=!0,t.processResponseDone!=null&&queueMicrotask(()=>t.processResponseDone(e))}function ag(t,e){let r=t.timingInfo,A=()=>{let o=Date.now();t.request.destination==="document"&&(t.controller.fullTimingInfo=r),t.controller.reportTimingSteps=()=>{if(t.request.url.protocol!=="https:")return;r.endTime=o;let i=e.cacheState,a=e.bodyInfo;e.timingAllowPassed||(r=gg(r),i="");let c=0;if(t.request.mode!=="navigator"||!e.hasCrossOriginRedirects){c=e.status;let u=hF(e.headersList);u!=="failure"&&(a.contentType=kF(u))}t.request.initiatorType!=null&&uI(r,t.request.url.href,t.request.initiatorType,globalThis,i,a,c)};let n=()=>{t.request.done=!0,t.processResponseEndOfBody!=null&&queueMicrotask(()=>t.processResponseEndOfBody(e)),t.request.initiatorType!=null&&t.controller.reportTimingSteps()};queueMicrotask(()=>n())};t.processResponse!=null&&queueMicrotask(()=>{t.processResponse(e),t.processResponse=null});let s=e.type==="error"?e:e.internalResponse??e;s.body==null?A():mF(s.body.stream,()=>{A()})}async function hI(t){let e=t.request,r=null,A=null,s=t.timingInfo;if(e.serviceWorkers,r===null){if(e.redirect==="follow"&&(e.serviceWorkers="none"),A=r=await QI(t),e.responseTainting==="cors"&&eF(e,r)==="failure")return K("cors failure");z0(e,r)==="failure"&&(e.timingAllowFailed=!0)}return(e.responseTainting==="opaque"||r.type==="opaque")&&tF(e.origin,e.client,e.destination,A)==="blocked"?K("blocked"):(aI.has(A.status)&&(e.redirect!=="manual"&&t.controller.connection.destroy(void 0,!1),e.redirect==="error"?r=K("unexpected redirect"):e.redirect==="manual"?r=A:e.redirect==="follow"?r=await LF(t,r):kr(!1)),r.timingInfo=s,r)}function LF(t,e){let r=t.request,A=e.internalResponse?e.internalResponse:e,s;try{if(s=K0(A,dt(r).hash),s==null)return e}catch(n){return Promise.resolve(K(n))}if(!ug(s))return Promise.resolve(K("URL scheme must be a HTTP(S) scheme"));if(r.redirectCount===20)return Promise.resolve(K("redirect count exceeded"));if(r.redirectCount+=1,r.mode==="cors"&&(s.username||s.password)&&!cg(r,s))return Promise.resolve(K('cross origin not allowed for request mode "cors"'));if(r.responseTainting==="cors"&&(s.username||s.password))return Promise.resolve(K('URL cannot contain credentials for request mode "cors"'));if(A.status!==303&&r.body!=null&&r.body.source==null)return Promise.resolve(K());if([301,302].includes(A.status)&&r.method==="POST"||A.status===303&&!SF.includes(r.method)){r.method="GET",r.body=null;for(let n of BF)r.headersList.delete(n)}cg(dt(r),s)||(r.headersList.delete("authorization",!0),r.headersList.delete("proxy-authorization",!0),r.headersList.delete("cookie",!0),r.headersList.delete("host",!0)),r.body!=null&&(kr(r.body.source!=null),r.body=lg(r.body.source)[0]);let o=t.timingInfo;return o.redirectEndTime=o.postRedirectStartTime=ps(t.crossOriginIsolatedCapability),o.redirectStartTime===0&&(o.redirectStartTime=o.startTime),r.urlList.push(s),j0(r,A),EI(t,!0)}async function QI(t,e=!1,r=!1){let A=t.request,s=null,o=null,n=null,i=null,a=!1;A.window==="no-window"&&A.redirect==="error"?(s=t,o=A):(o=H0(A),s={...t},s.request=o);let c=A.credentials==="include"||A.credentials==="same-origin"&&A.responseTainting==="basic",u=o.body?o.body.length:null,g=null;if(o.body==null&&["POST","PUT"].includes(o.method)&&(g="0"),u!=null&&(g=Bn(`${u}`)),g!=null&&o.headersList.append("content-length",g,!0),u!=null&&o.keepalive,o.referrer instanceof URL&&o.headersList.append("referer",Bn(o.referrer.href),!0),Z0(o),$0(o),o.headersList.contains("user-agent",!0)||o.headersList.append("user-agent",UF),o.cache==="default"&&(o.headersList.contains("if-modified-since",!0)||o.headersList.contains("if-none-match",!0)||o.headersList.contains("if-unmodified-since",!0)||o.headersList.contains("if-match",!0)||o.headersList.contains("if-range",!0))&&(o.cache="no-store"),o.cache==="no-cache"&&!o.preventNoCacheCacheControlHeaderModification&&!o.headersList.contains("cache-control",!0)&&o.headersList.append("cache-control","max-age=0",!0),(o.cache==="no-store"||o.cache==="reload")&&(o.headersList.contains("pragma",!0)||o.headersList.append("pragma","no-cache",!0),o.headersList.contains("cache-control",!0)||o.headersList.append("cache-control","no-cache",!0)),o.headersList.contains("range",!0)&&o.headersList.append("accept-encoding","identity",!0),o.headersList.contains("accept-encoding",!0)||(cF(dt(o))?o.headersList.append("accept-encoding","br, gzip, deflate",!0):o.headersList.append("accept-encoding","gzip, deflate",!0)),o.headersList.delete("host",!0),i==null&&(o.cache="no-store"),o.cache!=="no-store"&&o.cache,n==null){if(o.cache==="only-if-cached")return K("only if cached");let E=await vF(s,c,r);!dF.has(o.method)&&E.status>=200&&E.status<=399,a&&E.status,n==null&&(n=E)}if(n.urlList=[...o.urlList],o.headersList.contains("range",!0)&&(n.rangeRequested=!0),n.requestIncludesCredentials=c,n.status===407)return A.window==="no-window"?K():Dr(t)?Qn(t):K("proxy authentication required");if(n.status===421&&!r&&(A.body==null||A.body.source!=null)){if(Dr(t))return Qn(t);t.controller.connection.destroy(),n=await QI(t,e,!0)}return n}async function vF(t,e=!1,r=!1){kr(!t.controller.connection||t.controller.connection.destroyed),t.controller.connection={abort:null,destroyed:!1,destroy(d,p=!0){this.destroyed||(this.destroyed=!0,p&&this.abort?.(d??new DOMException("The operation was aborted.","AbortError")))}};let A=t.request,s=null,o=t.timingInfo;null==null&&(A.cache="no-store");let i=r?"yes":"no";A.mode;let a=null;if(A.body==null&&t.processRequestEndOfBody)queueMicrotask(()=>t.processRequestEndOfBody());else if(A.body!=null){let d=async function*(B){Dr(t)||(yield B,t.processRequestBodyChunkLength?.(B.byteLength))},p=()=>{Dr(t)||t.processRequestEndOfBody&&t.processRequestEndOfBody()},y=B=>{Dr(t)||(B.name==="AbortError"?t.controller.abort():t.controller.terminate(B))};a=(async function*(){try{for await(let B of A.body.stream)yield*d(B);p()}catch(B){y(B)}})()}try{let{body:d,status:p,statusText:y,headersList:B,socket:w}=await I({body:a});if(w)s=dn({status:p,statusText:y,headersList:B,socket:w});else{let T=d[Symbol.asyncIterator]();t.controller.next=()=>T.next(),s=dn({status:p,statusText:y,headersList:B})}}catch(d){return d.name==="AbortError"?(t.controller.connection.destroy(),Qn(t,d)):K(d)}let c=async()=>{await t.controller.resume()},u=d=>{Dr(t)||t.controller.abort(d)},g=new ReadableStream({async start(d){t.controller.controller=d},async pull(d){await c(d)},async cancel(d){await u(d)},type:"bytes"});s.body={stream:g,source:null,length:null},t.controller.onAborted=E,t.controller.on("terminated",E),t.controller.resume=async()=>{for(;;){let d,p;try{let{done:B,value:w}=await t.controller.next();if(AI(t))break;d=B?void 0:w}catch(B){t.controller.ended&&!o.encodedBodySize?d=void 0:(d=B,p=!0)}if(d===void 0){iF(t.controller.controller),MF(t,s);return}if(o.decodedBodySize+=d?.byteLength??0,p){t.controller.terminate(d);return}let y=new Uint8Array(d);if(y.byteLength&&t.controller.controller.enqueue(y),yF(g)){t.controller.terminate();return}if(t.controller.controller.desiredSize<=0)return}};function E(d){AI(t)?(s.aborted=!0,In(g)&&t.controller.controller.error(t.controller.serializedAbortReason)):In(g)&&t.controller.controller.error(new TypeError("terminated",{cause:oF(d)?d:void 0})),t.controller.connection.destroy()}return s;function I({body:d}){let p=dt(A),y=t.controller.dispatcher;return new Promise((B,w)=>y.dispatch({path:p.pathname+p.search,origin:p.origin,method:A.method,body:y.isMockActive?A.body&&(A.body.source||A.body.stream):d,headers:A.headersList.entries,maxRedirections:0,upgrade:A.mode==="websocket"?"websocket":void 0},{body:null,abort:null,onConnect(T){let{connection:S}=t.controller;o.finalConnectionTimingInfo=gF(void 0,o.postRedirectStartTime,t.crossOriginIsolatedCapability),S.destroyed?T(new DOMException("The operation was aborted.","AbortError")):(t.controller.on("terminated",T),this.abort=S.abort=T),o.finalNetworkRequestStartTime=ps(t.crossOriginIsolatedCapability)},onResponseStarted(){o.finalNetworkResponseStartTime=ps(t.crossOriginIsolatedCapability)},onHeaders(T,S,J,j){if(T<200)return;let X="",Ye=new rI;for(let Qe=0;Qevt)return w(new Error(`too many content-encodings in response: ${pt.length}, maximum allowed is ${vt}`)),!0;for(let Mr=pt.length-1;Mr>=0;--Mr){let Lr=pt[Mr].trim();if(Lr==="x-gzip"||Lr==="gzip")Oe.push(Xt.createGunzip({flush:Xt.constants.Z_SYNC_FLUSH,finishFlush:Xt.constants.Z_SYNC_FLUSH}));else if(Lr==="deflate")Oe.push(EF({flush:Xt.constants.Z_SYNC_FLUSH,finishFlush:Xt.constants.Z_SYNC_FLUSH}));else if(Lr==="br")Oe.push(Xt.createBrotliDecompress({flush:Xt.constants.BROTLI_OPERATION_FLUSH,finishFlush:Xt.constants.BROTLI_OPERATION_FLUSH}));else{Oe.length=0;break}}}let ot=this.onError.bind(this);return B({status:T,statusText:j,headersList:Ye,body:Oe.length?fF(this.body,...Oe,Qe=>{Qe&&this.onError(Qe)}).on("error",ot):this.body.on("error",ot)}),!0},onData(T){if(t.controller.dump)return;let S=T;return o.encodedBodySize+=S.byteLength,this.body.push(S)},onComplete(){this.abort&&t.controller.off("terminated",this.abort),t.controller.onAborted&&t.controller.off("terminated",t.controller.onAborted),t.controller.ended=!0,this.body.push(null)},onError(T){this.abort&&t.controller.off("terminated",this.abort),this.body?.destroy(T),t.controller.terminate(T),w(T)},onUpgrade(T,S,J){if(T!==101)return;let j=new rI;for(let X=0;X{"use strict";BI.exports={kState:Symbol("FileReader state"),kResult:Symbol("FileReader result"),kError:Symbol("FileReader error"),kLastProgressEventFired:Symbol("FileReader last progress event fired timestamp"),kEvents:Symbol("FileReader events"),kAborted:Symbol("FileReader aborted")}});var CI=m((uv,II)=>{"use strict";var{webidl:ve}=Be(),pn=Symbol("ProgressEvent state"),hg=class t extends Event{constructor(e,r={}){e=ve.converters.DOMString(e,"ProgressEvent constructor","type"),r=ve.converters.ProgressEventInit(r??{}),super(e,r),this[pn]={lengthComputable:r.lengthComputable,loaded:r.loaded,total:r.total}}get lengthComputable(){return ve.brandCheck(this,t),this[pn].lengthComputable}get loaded(){return ve.brandCheck(this,t),this[pn].loaded}get total(){return ve.brandCheck(this,t),this[pn].total}};ve.converters.ProgressEventInit=ve.dictionaryConverter([{key:"lengthComputable",converter:ve.converters.boolean,defaultValue:()=>!1},{key:"loaded",converter:ve.converters["unsigned long long"],defaultValue:()=>0},{key:"total",converter:ve.converters["unsigned long long"],defaultValue:()=>0},{key:"bubbles",converter:ve.converters.boolean,defaultValue:()=>!1},{key:"cancelable",converter:ve.converters.boolean,defaultValue:()=>!1},{key:"composed",converter:ve.converters.boolean,defaultValue:()=>!1}]);II.exports={ProgressEvent:hg}});var fI=m((lv,pI)=>{"use strict";function _F(t){if(!t)return"failure";switch(t.trim().toLowerCase()){case"unicode-1-1-utf-8":case"unicode11utf8":case"unicode20utf8":case"utf-8":case"utf8":case"x-unicode20utf8":return"UTF-8";case"866":case"cp866":case"csibm866":case"ibm866":return"IBM866";case"csisolatin2":case"iso-8859-2":case"iso-ir-101":case"iso8859-2":case"iso88592":case"iso_8859-2":case"iso_8859-2:1987":case"l2":case"latin2":return"ISO-8859-2";case"csisolatin3":case"iso-8859-3":case"iso-ir-109":case"iso8859-3":case"iso88593":case"iso_8859-3":case"iso_8859-3:1988":case"l3":case"latin3":return"ISO-8859-3";case"csisolatin4":case"iso-8859-4":case"iso-ir-110":case"iso8859-4":case"iso88594":case"iso_8859-4":case"iso_8859-4:1988":case"l4":case"latin4":return"ISO-8859-4";case"csisolatincyrillic":case"cyrillic":case"iso-8859-5":case"iso-ir-144":case"iso8859-5":case"iso88595":case"iso_8859-5":case"iso_8859-5:1988":return"ISO-8859-5";case"arabic":case"asmo-708":case"csiso88596e":case"csiso88596i":case"csisolatinarabic":case"ecma-114":case"iso-8859-6":case"iso-8859-6-e":case"iso-8859-6-i":case"iso-ir-127":case"iso8859-6":case"iso88596":case"iso_8859-6":case"iso_8859-6:1987":return"ISO-8859-6";case"csisolatingreek":case"ecma-118":case"elot_928":case"greek":case"greek8":case"iso-8859-7":case"iso-ir-126":case"iso8859-7":case"iso88597":case"iso_8859-7":case"iso_8859-7:1987":case"sun_eu_greek":return"ISO-8859-7";case"csiso88598e":case"csisolatinhebrew":case"hebrew":case"iso-8859-8":case"iso-8859-8-e":case"iso-ir-138":case"iso8859-8":case"iso88598":case"iso_8859-8":case"iso_8859-8:1988":case"visual":return"ISO-8859-8";case"csiso88598i":case"iso-8859-8-i":case"logical":return"ISO-8859-8-I";case"csisolatin6":case"iso-8859-10":case"iso-ir-157":case"iso8859-10":case"iso885910":case"l6":case"latin6":return"ISO-8859-10";case"iso-8859-13":case"iso8859-13":case"iso885913":return"ISO-8859-13";case"iso-8859-14":case"iso8859-14":case"iso885914":return"ISO-8859-14";case"csisolatin9":case"iso-8859-15":case"iso8859-15":case"iso885915":case"iso_8859-15":case"l9":return"ISO-8859-15";case"iso-8859-16":return"ISO-8859-16";case"cskoi8r":case"koi":case"koi8":case"koi8-r":case"koi8_r":return"KOI8-R";case"koi8-ru":case"koi8-u":return"KOI8-U";case"csmacintosh":case"mac":case"macintosh":case"x-mac-roman":return"macintosh";case"iso-8859-11":case"iso8859-11":case"iso885911":case"tis-620":case"windows-874":return"windows-874";case"cp1250":case"windows-1250":case"x-cp1250":return"windows-1250";case"cp1251":case"windows-1251":case"x-cp1251":return"windows-1251";case"ansi_x3.4-1968":case"ascii":case"cp1252":case"cp819":case"csisolatin1":case"ibm819":case"iso-8859-1":case"iso-ir-100":case"iso8859-1":case"iso88591":case"iso_8859-1":case"iso_8859-1:1987":case"l1":case"latin1":case"us-ascii":case"windows-1252":case"x-cp1252":return"windows-1252";case"cp1253":case"windows-1253":case"x-cp1253":return"windows-1253";case"cp1254":case"csisolatin5":case"iso-8859-9":case"iso-ir-148":case"iso8859-9":case"iso88599":case"iso_8859-9":case"iso_8859-9:1989":case"l5":case"latin5":case"windows-1254":case"x-cp1254":return"windows-1254";case"cp1255":case"windows-1255":case"x-cp1255":return"windows-1255";case"cp1256":case"windows-1256":case"x-cp1256":return"windows-1256";case"cp1257":case"windows-1257":case"x-cp1257":return"windows-1257";case"cp1258":case"windows-1258":case"x-cp1258":return"windows-1258";case"x-mac-cyrillic":case"x-mac-ukrainian":return"x-mac-cyrillic";case"chinese":case"csgb2312":case"csiso58gb231280":case"gb2312":case"gb_2312":case"gb_2312-80":case"gbk":case"iso-ir-58":case"x-gbk":return"GBK";case"gb18030":return"gb18030";case"big5":case"big5-hkscs":case"cn-big5":case"csbig5":case"x-x-big5":return"Big5";case"cseucpkdfmtjapanese":case"euc-jp":case"x-euc-jp":return"EUC-JP";case"csiso2022jp":case"iso-2022-jp":return"ISO-2022-JP";case"csshiftjis":case"ms932":case"ms_kanji":case"shift-jis":case"shift_jis":case"sjis":case"windows-31j":case"x-sjis":return"Shift_JIS";case"cseuckr":case"csksc56011987":case"euc-kr":case"iso-ir-149":case"korean":case"ks_c_5601-1987":case"ks_c_5601-1989":case"ksc5601":case"ksc_5601":case"windows-949":return"EUC-KR";case"csiso2022kr":case"hz-gb-2312":case"iso-2022-cn":case"iso-2022-cn-ext":case"iso-2022-kr":case"replacement":return"replacement";case"unicodefffe":case"utf-16be":return"UTF-16BE";case"csunicode":case"iso-10646-ucs-2":case"ucs-2":case"unicode":case"unicodefeff":case"utf-16":case"utf-16le":return"UTF-16LE";case"x-user-defined":return"x-user-defined";default:return"failure"}}pI.exports={getEncoding:_F}});var TI=m((Ev,RI)=>{"use strict";var{kState:fA,kError:Qg,kResult:mI,kAborted:ms,kLastProgressEventFired:dg}=Eg(),{ProgressEvent:xF}=CI(),{getEncoding:wI}=fI(),{serializeAMimeType:YF,parseMIMEType:yI}=ye(),{types:OF}=require("node:util"),{StringDecoder:bI}=require("string_decoder"),{btoa:DI}=require("node:buffer"),JF={enumerable:!0,writable:!1,configurable:!1};function HF(t,e,r,A){if(t[fA]==="loading")throw new DOMException("Invalid state","InvalidStateError");t[fA]="loading",t[mI]=null,t[Qg]=null;let o=e.stream().getReader(),n=[],i=o.read(),a=!0;(async()=>{for(;!t[ms];)try{let{done:c,value:u}=await i;if(a&&!t[ms]&&queueMicrotask(()=>{$t("loadstart",t)}),a=!1,!c&&OF.isUint8Array(u))n.push(u),(t[dg]===void 0||Date.now()-t[dg]>=50)&&!t[ms]&&(t[dg]=Date.now(),queueMicrotask(()=>{$t("progress",t)})),i=o.read();else if(c){queueMicrotask(()=>{t[fA]="done";try{let g=PF(n,r,e.type,A);if(t[ms])return;t[mI]=g,$t("load",t)}catch(g){t[Qg]=g,$t("error",t)}t[fA]!=="loading"&&$t("loadend",t)});break}}catch(c){if(t[ms])return;queueMicrotask(()=>{t[fA]="done",t[Qg]=c,$t("error",t),t[fA]!=="loading"&&$t("loadend",t)});break}})()}function $t(t,e){let r=new xF(t,{bubbles:!1,cancelable:!1});e.dispatchEvent(r)}function PF(t,e,r,A){switch(e){case"DataURL":{let s="data:",o=yI(r||"application/octet-stream");o!=="failure"&&(s+=YF(o)),s+=";base64,";let n=new bI("latin1");for(let i of t)s+=DI(n.write(i));return s+=DI(n.end()),s}case"Text":{let s="failure";if(A&&(s=wI(A)),s==="failure"&&r){let o=yI(r);o!=="failure"&&(s=wI(o.parameters.get("charset")))}return s==="failure"&&(s="UTF-8"),VF(t,s)}case"ArrayBuffer":return kI(t).buffer;case"BinaryString":{let s="",o=new bI("latin1");for(let n of t)s+=o.write(n);return s+=o.end(),s}}}function VF(t,e){let r=kI(t),A=qF(r),s=0;A!==null&&(e=A,s=A==="UTF-8"?3:2);let o=r.slice(s);return new TextDecoder(e).decode(o)}function qF(t){let[e,r,A]=t;return e===239&&r===187&&A===191?"UTF-8":e===254&&r===255?"UTF-16BE":e===255&&r===254?"UTF-16LE":null}function kI(t){let e=t.reduce((A,s)=>A+s.byteLength,0),r=0;return t.reduce((A,s)=>(A.set(s,r),r+=s.byteLength,A),new Uint8Array(e))}RI.exports={staticPropertyDescriptors:JF,readOperation:HF,fireAProgressEvent:$t}});var NI=m((hv,UI)=>{"use strict";var{staticPropertyDescriptors:mA,readOperation:fn,fireAProgressEvent:FI}=TI(),{kState:Rr,kError:SI,kResult:mn,kEvents:W,kAborted:WF}=Eg(),{webidl:$}=Be(),{kEnumerableProperty:ke}=O(),At=class t extends EventTarget{constructor(){super(),this[Rr]="empty",this[mn]=null,this[SI]=null,this[W]={loadend:null,error:null,abort:null,load:null,progress:null,loadstart:null}}readAsArrayBuffer(e){$.brandCheck(this,t),$.argumentLengthCheck(arguments,1,"FileReader.readAsArrayBuffer"),e=$.converters.Blob(e,{strict:!1}),fn(this,e,"ArrayBuffer")}readAsBinaryString(e){$.brandCheck(this,t),$.argumentLengthCheck(arguments,1,"FileReader.readAsBinaryString"),e=$.converters.Blob(e,{strict:!1}),fn(this,e,"BinaryString")}readAsText(e,r=void 0){$.brandCheck(this,t),$.argumentLengthCheck(arguments,1,"FileReader.readAsText"),e=$.converters.Blob(e,{strict:!1}),r!==void 0&&(r=$.converters.DOMString(r,"FileReader.readAsText","encoding")),fn(this,e,"Text",r)}readAsDataURL(e){$.brandCheck(this,t),$.argumentLengthCheck(arguments,1,"FileReader.readAsDataURL"),e=$.converters.Blob(e,{strict:!1}),fn(this,e,"DataURL")}abort(){if(this[Rr]==="empty"||this[Rr]==="done"){this[mn]=null;return}this[Rr]==="loading"&&(this[Rr]="done",this[mn]=null),this[WF]=!0,FI("abort",this),this[Rr]!=="loading"&&FI("loadend",this)}get readyState(){switch($.brandCheck(this,t),this[Rr]){case"empty":return this.EMPTY;case"loading":return this.LOADING;case"done":return this.DONE}}get result(){return $.brandCheck(this,t),this[mn]}get error(){return $.brandCheck(this,t),this[SI]}get onloadend(){return $.brandCheck(this,t),this[W].loadend}set onloadend(e){$.brandCheck(this,t),this[W].loadend&&this.removeEventListener("loadend",this[W].loadend),typeof e=="function"?(this[W].loadend=e,this.addEventListener("loadend",e)):this[W].loadend=null}get onerror(){return $.brandCheck(this,t),this[W].error}set onerror(e){$.brandCheck(this,t),this[W].error&&this.removeEventListener("error",this[W].error),typeof e=="function"?(this[W].error=e,this.addEventListener("error",e)):this[W].error=null}get onloadstart(){return $.brandCheck(this,t),this[W].loadstart}set onloadstart(e){$.brandCheck(this,t),this[W].loadstart&&this.removeEventListener("loadstart",this[W].loadstart),typeof e=="function"?(this[W].loadstart=e,this.addEventListener("loadstart",e)):this[W].loadstart=null}get onprogress(){return $.brandCheck(this,t),this[W].progress}set onprogress(e){$.brandCheck(this,t),this[W].progress&&this.removeEventListener("progress",this[W].progress),typeof e=="function"?(this[W].progress=e,this.addEventListener("progress",e)):this[W].progress=null}get onload(){return $.brandCheck(this,t),this[W].load}set onload(e){$.brandCheck(this,t),this[W].load&&this.removeEventListener("load",this[W].load),typeof e=="function"?(this[W].load=e,this.addEventListener("load",e)):this[W].load=null}get onabort(){return $.brandCheck(this,t),this[W].abort}set onabort(e){$.brandCheck(this,t),this[W].abort&&this.removeEventListener("abort",this[W].abort),typeof e=="function"?(this[W].abort=e,this.addEventListener("abort",e)):this[W].abort=null}};At.EMPTY=At.prototype.EMPTY=0;At.LOADING=At.prototype.LOADING=1;At.DONE=At.prototype.DONE=2;Object.defineProperties(At.prototype,{EMPTY:mA,LOADING:mA,DONE:mA,readAsArrayBuffer:ke,readAsBinaryString:ke,readAsText:ke,readAsDataURL:ke,abort:ke,readyState:ke,result:ke,error:ke,onloadstart:ke,onprogress:ke,onload:ke,onabort:ke,onerror:ke,onloadend:ke,[Symbol.toStringTag]:{value:"FileReader",writable:!1,enumerable:!1,configurable:!0}});Object.defineProperties(At,{EMPTY:mA,LOADING:mA,DONE:mA});UI.exports={FileReader:At}});var wn=m((Qv,GI)=>{"use strict";GI.exports={kConstruct:se().kConstruct}});var vI=m((dv,LI)=>{"use strict";var zF=require("node:assert"),{URLSerializer:MI}=ye(),{isValidHeaderName:ZF}=Fe();function KF(t,e,r=!1){let A=MI(t,r),s=MI(e,r);return A===s}function jF(t){zF(t!==null);let e=[];for(let r of t.split(","))r=r.trim(),ZF(r)&&e.push(r);return e}LI.exports={urlEquals:KF,getFieldValues:jF}});var YI=m((Bv,xI)=>{"use strict";var{kConstruct:XF}=wn(),{urlEquals:$F,getFieldValues:Bg}=vI(),{kEnumerableProperty:Tr,isDisturbed:eS}=O(),{webidl:N}=Be(),{Response:tS,cloneResponse:rS,fromInnerResponse:AS}=Cs(),{Request:Nt,fromInnerRequest:sS}=pA(),{kState:st}=Yt(),{fetching:oS}=fs(),{urlIsHttpHttpsScheme:yn,createDeferredPromise:wA,readAllBytes:nS}=Fe(),Ig=require("node:assert"),bn=class t{#e;constructor(){arguments[0]!==XF&&N.illegalConstructor(),N.util.markAsUncloneable(this),this.#e=arguments[1]}async match(e,r={}){N.brandCheck(this,t);let A="Cache.match";N.argumentLengthCheck(arguments,1,A),e=N.converters.RequestInfo(e,A,"request"),r=N.converters.CacheQueryOptions(r,A,"options");let s=this.#s(e,r,1);if(s.length!==0)return s[0]}async matchAll(e=void 0,r={}){N.brandCheck(this,t);let A="Cache.matchAll";return e!==void 0&&(e=N.converters.RequestInfo(e,A,"request")),r=N.converters.CacheQueryOptions(r,A,"options"),this.#s(e,r)}async add(e){N.brandCheck(this,t);let r="Cache.add";N.argumentLengthCheck(arguments,1,r),e=N.converters.RequestInfo(e,r,"request");let A=[e];return await this.addAll(A)}async addAll(e){N.brandCheck(this,t);let r="Cache.addAll";N.argumentLengthCheck(arguments,1,r);let A=[],s=[];for(let E of e){if(E===void 0)throw N.errors.conversionFailed({prefix:r,argument:"Argument 1",types:["undefined is not allowed"]});if(E=N.converters.RequestInfo(E),typeof E=="string")continue;let I=E[st];if(!yn(I.url)||I.method!=="GET")throw N.errors.exception({header:r,message:"Expected http/s scheme when method is not GET."})}let o=[];for(let E of e){let I=new Nt(E)[st];if(!yn(I.url))throw N.errors.exception({header:r,message:"Expected http/s scheme."});I.initiator="fetch",I.destination="subresource",s.push(I);let d=wA();o.push(oS({request:I,processResponse(p){if(p.type==="error"||p.status===206||p.status<200||p.status>299)d.reject(N.errors.exception({header:"Cache.addAll",message:"Received an invalid status code or the request failed."}));else if(p.headersList.contains("vary")){let y=Bg(p.headersList.get("vary"));for(let B of y)if(B==="*"){d.reject(N.errors.exception({header:"Cache.addAll",message:"invalid vary field value"}));for(let w of o)w.abort();return}}},processResponseEndOfBody(p){if(p.aborted){d.reject(new DOMException("aborted","AbortError"));return}d.resolve(p)}})),A.push(d.promise)}let i=await Promise.all(A),a=[],c=0;for(let E of i){let I={type:"put",request:s[c],response:E};a.push(I),c++}let u=wA(),g=null;try{this.#t(a)}catch(E){g=E}return queueMicrotask(()=>{g===null?u.resolve(void 0):u.reject(g)}),u.promise}async put(e,r){N.brandCheck(this,t);let A="Cache.put";N.argumentLengthCheck(arguments,2,A),e=N.converters.RequestInfo(e,A,"request"),r=N.converters.Response(r,A,"response");let s=null;if(e instanceof Nt?s=e[st]:s=new Nt(e)[st],!yn(s.url)||s.method!=="GET")throw N.errors.exception({header:A,message:"Expected an http/s scheme when method is not GET"});let o=r[st];if(o.status===206)throw N.errors.exception({header:A,message:"Got 206 status"});if(o.headersList.contains("vary")){let I=Bg(o.headersList.get("vary"));for(let d of I)if(d==="*")throw N.errors.exception({header:A,message:"Got * vary field value"})}if(o.body&&(eS(o.body.stream)||o.body.stream.locked))throw N.errors.exception({header:A,message:"Response body is locked or disturbed"});let n=rS(o),i=wA();if(o.body!=null){let d=o.body.stream.getReader();nS(d).then(i.resolve,i.reject)}else i.resolve(void 0);let a=[],c={type:"put",request:s,response:n};a.push(c);let u=await i.promise;n.body!=null&&(n.body.source=u);let g=wA(),E=null;try{this.#t(a)}catch(I){E=I}return queueMicrotask(()=>{E===null?g.resolve():g.reject(E)}),g.promise}async delete(e,r={}){N.brandCheck(this,t);let A="Cache.delete";N.argumentLengthCheck(arguments,1,A),e=N.converters.RequestInfo(e,A,"request"),r=N.converters.CacheQueryOptions(r,A,"options");let s=null;if(e instanceof Nt){if(s=e[st],s.method!=="GET"&&!r.ignoreMethod)return!1}else Ig(typeof e=="string"),s=new Nt(e)[st];let o=[],n={type:"delete",request:s,options:r};o.push(n);let i=wA(),a=null,c;try{c=this.#t(o)}catch(u){a=u}return queueMicrotask(()=>{a===null?i.resolve(!!c?.length):i.reject(a)}),i.promise}async keys(e=void 0,r={}){N.brandCheck(this,t);let A="Cache.keys";e!==void 0&&(e=N.converters.RequestInfo(e,A,"request")),r=N.converters.CacheQueryOptions(r,A,"options");let s=null;if(e!==void 0)if(e instanceof Nt){if(s=e[st],s.method!=="GET"&&!r.ignoreMethod)return[]}else typeof e=="string"&&(s=new Nt(e)[st]);let o=wA(),n=[];if(e===void 0)for(let i of this.#e)n.push(i[0]);else{let i=this.#r(s,r);for(let a of i)n.push(a[0])}return queueMicrotask(()=>{let i=[];for(let a of n){let c=sS(a,new AbortController().signal,"immutable");i.push(c)}o.resolve(Object.freeze(i))}),o.promise}#t(e){let r=this.#e,A=[...r],s=[],o=[];try{for(let n of e){if(n.type!=="delete"&&n.type!=="put")throw N.errors.exception({header:"Cache.#batchCacheOperations",message:'operation type does not match "delete" or "put"'});if(n.type==="delete"&&n.response!=null)throw N.errors.exception({header:"Cache.#batchCacheOperations",message:"delete operation should not have an associated response"});if(this.#r(n.request,n.options,s).length)throw new DOMException("???","InvalidStateError");let i;if(n.type==="delete"){if(i=this.#r(n.request,n.options),i.length===0)return[];for(let a of i){let c=r.indexOf(a);Ig(c!==-1),r.splice(c,1)}}else if(n.type==="put"){if(n.response==null)throw N.errors.exception({header:"Cache.#batchCacheOperations",message:"put operation should have an associated response"});let a=n.request;if(!yn(a.url))throw N.errors.exception({header:"Cache.#batchCacheOperations",message:"expected http or https scheme"});if(a.method!=="GET")throw N.errors.exception({header:"Cache.#batchCacheOperations",message:"not get method"});if(n.options!=null)throw N.errors.exception({header:"Cache.#batchCacheOperations",message:"options must not be defined"});i=this.#r(n.request);for(let c of i){let u=r.indexOf(c);Ig(u!==-1),r.splice(u,1)}r.push([n.request,n.response]),s.push([n.request,n.response])}o.push([n.request,n.response])}return o}catch(n){throw this.#e.length=0,this.#e=A,n}}#r(e,r,A){let s=[],o=A??this.#e;for(let n of o){let[i,a]=n;this.#o(e,i,a,r)&&s.push(n)}return s}#o(e,r,A=null,s){let o=new URL(e.url),n=new URL(r.url);if(s?.ignoreSearch&&(n.search="",o.search=""),!$F(o,n,!0))return!1;if(A==null||s?.ignoreVary||!A.headersList.contains("vary"))return!0;let i=Bg(A.headersList.get("vary"));for(let a of i){if(a==="*")return!1;let c=r.headersList.get(a),u=e.headersList.get(a);if(c!==u)return!1}return!0}#s(e,r,A=1/0){let s=null;if(e!==void 0)if(e instanceof Nt){if(s=e[st],s.method!=="GET"&&!r.ignoreMethod)return[]}else typeof e=="string"&&(s=new Nt(e)[st]);let o=[];if(e===void 0)for(let i of this.#e)o.push(i[1]);else{let i=this.#r(s,r);for(let a of i)o.push(a[1])}let n=[];for(let i of o){let a=AS(i,"immutable");if(n.push(a.clone()),n.length>=A)break}return Object.freeze(n)}};Object.defineProperties(bn.prototype,{[Symbol.toStringTag]:{value:"Cache",configurable:!0},match:Tr,matchAll:Tr,add:Tr,addAll:Tr,put:Tr,delete:Tr,keys:Tr});var _I=[{key:"ignoreSearch",converter:N.converters.boolean,defaultValue:()=>!1},{key:"ignoreMethod",converter:N.converters.boolean,defaultValue:()=>!1},{key:"ignoreVary",converter:N.converters.boolean,defaultValue:()=>!1}];N.converters.CacheQueryOptions=N.dictionaryConverter(_I);N.converters.MultiCacheQueryOptions=N.dictionaryConverter([..._I,{key:"cacheName",converter:N.converters.DOMString}]);N.converters.Response=N.interfaceConverter(tS);N.converters["sequence"]=N.sequenceConverter(N.converters.RequestInfo);xI.exports={Cache:bn}});var JI=m((Iv,OI)=>{"use strict";var{kConstruct:ws}=wn(),{Cache:Dn}=YI(),{webidl:pe}=Be(),{kEnumerableProperty:ys}=O(),kn=class t{#e=new Map;constructor(){arguments[0]!==ws&&pe.illegalConstructor(),pe.util.markAsUncloneable(this)}async match(e,r={}){if(pe.brandCheck(this,t),pe.argumentLengthCheck(arguments,1,"CacheStorage.match"),e=pe.converters.RequestInfo(e),r=pe.converters.MultiCacheQueryOptions(r),r.cacheName!=null){if(this.#e.has(r.cacheName)){let A=this.#e.get(r.cacheName);return await new Dn(ws,A).match(e,r)}}else for(let A of this.#e.values()){let o=await new Dn(ws,A).match(e,r);if(o!==void 0)return o}}async has(e){pe.brandCheck(this,t);let r="CacheStorage.has";return pe.argumentLengthCheck(arguments,1,r),e=pe.converters.DOMString(e,r,"cacheName"),this.#e.has(e)}async open(e){pe.brandCheck(this,t);let r="CacheStorage.open";if(pe.argumentLengthCheck(arguments,1,r),e=pe.converters.DOMString(e,r,"cacheName"),this.#e.has(e)){let s=this.#e.get(e);return new Dn(ws,s)}let A=[];return this.#e.set(e,A),new Dn(ws,A)}async delete(e){pe.brandCheck(this,t);let r="CacheStorage.delete";return pe.argumentLengthCheck(arguments,1,r),e=pe.converters.DOMString(e,r,"cacheName"),this.#e.delete(e)}async keys(){return pe.brandCheck(this,t),[...this.#e.keys()]}};Object.defineProperties(kn.prototype,{[Symbol.toStringTag]:{value:"CacheStorage",configurable:!0},match:ys,has:ys,open:ys,delete:ys,keys:ys});OI.exports={CacheStorage:kn}});var PI=m((Cv,HI)=>{"use strict";HI.exports={maxAttributeValueSize:1024,maxNameValuePairSize:4096}});var Cg=m((pv,ZI)=>{"use strict";function iS(t){for(let e=0;e=0&&r<=8||r>=10&&r<=31||r===127)return!0}return!1}function VI(t){for(let e=0;e126||r===34||r===40||r===41||r===60||r===62||r===64||r===44||r===59||r===58||r===92||r===47||r===91||r===93||r===63||r===61||r===123||r===125)throw new Error("Invalid cookie name")}}function qI(t){let e=t.length,r=0;if(t[0]==='"'){if(e===1||t[e-1]!=='"')throw new Error("Invalid cookie value");--e,++r}for(;r126||A===34||A===44||A===59||A===92)throw new Error("Invalid cookie value")}}function WI(t){for(let e=0;ee.toString().padStart(2,"0"));function zI(t){return typeof t=="number"&&(t=new Date(t)),`${cS[t.getUTCDay()]}, ${Rn[t.getUTCDate()]} ${gS[t.getUTCMonth()]} ${t.getUTCFullYear()} ${Rn[t.getUTCHours()]}:${Rn[t.getUTCMinutes()]}:${Rn[t.getUTCSeconds()]} GMT`}function uS(t){if(t<0)throw new Error("Invalid cookie max-age")}function lS(t){if(t.name.length===0)return null;VI(t.name),qI(t.value);let e=[`${t.name}=${t.value}`];t.name.startsWith("__Secure-")&&(t.secure=!0),t.name.startsWith("__Host-")&&(t.secure=!0,t.domain=null,t.path="/"),t.secure&&e.push("Secure"),t.httpOnly&&e.push("HttpOnly"),typeof t.maxAge=="number"&&(uS(t.maxAge),e.push(`Max-Age=${t.maxAge}`)),t.domain&&(aS(t.domain),e.push(`Domain=${t.domain}`)),t.path&&(WI(t.path),e.push(`Path=${t.path}`)),t.expires&&t.expires.toString()!=="Invalid Date"&&e.push(`Expires=${zI(t.expires)}`),t.sameSite&&e.push(`SameSite=${t.sameSite}`);for(let r of t.unparsed){if(!r.includes("="))throw new Error("Invalid unparsed");let[A,...s]=r.split("=");e.push(`${A.trim()}=${s.join("=")}`)}return e.join("; ")}ZI.exports={isCTLExcludingHtab:iS,validateCookieName:VI,validateCookiePath:WI,validateCookieValue:qI,toIMFDate:zI,stringify:lS}});var jI=m((fv,KI)=>{"use strict";var{maxNameValuePairSize:ES,maxAttributeValueSize:hS}=PI(),{isCTLExcludingHtab:QS}=Cg(),{collectASequenceOfCodePointsFast:Tn}=ye(),dS=require("node:assert");function BS(t){if(QS(t))return null;let e="",r="",A="",s="";if(t.includes(";")){let o={position:0};e=Tn(";",t,o),r=t.slice(o.position)}else e=t;if(!e.includes("="))s=e;else{let o={position:0};A=Tn("=",e,o),s=e.slice(o.position+1)}return A=A.trim(),s=s.trim(),A.length+s.length>ES?null:{name:A,value:s,...yA(r)}}function yA(t,e={}){if(t.length===0)return e;dS(t[0]===";"),t=t.slice(1);let r="";t.includes(";")?(r=Tn(";",t,{position:0}),t=t.slice(r.length)):(r=t,t="");let A="",s="";if(r.includes("=")){let n={position:0};A=Tn("=",r,n),s=r.slice(n.position+1)}else A=r;if(A=A.trim(),s=s.trim(),s.length>hS)return yA(t,e);let o=A.toLowerCase();if(o==="expires"){let n=new Date(s);e.expires=n}else if(o==="max-age"){let n=s.charCodeAt(0);if((n<48||n>57)&&s[0]!=="-"||!/^\d+$/.test(s))return yA(t,e);let i=Number(s);e.maxAge=i}else if(o==="domain"){let n=s;n[0]==="."&&(n=n.slice(1)),n=n.toLowerCase(),e.domain=n}else if(o==="path"){let n="";s.length===0||s[0]!=="/"?n="/":n=s,e.path=n}else if(o==="secure")e.secure=!0;else if(o==="httponly")e.httpOnly=!0;else if(o==="samesite"){let n=s.toLowerCase();n==="none"?e.sameSite="None":n==="strict"?e.sameSite="Strict":n==="lax"&&(e.sameSite="Lax")}else e.unparsed??=[],e.unparsed.push(`${A}=${s}`);return yA(t,e)}KI.exports={parseSetCookie:BS,parseUnparsedAttributes:yA}});var eC=m((mv,$I)=>{"use strict";var{parseSetCookie:IS}=jI(),{stringify:CS}=Cg(),{webidl:P}=Be(),{Headers:Fn}=yr();function pS(t){P.argumentLengthCheck(arguments,1,"getCookies"),P.brandCheck(t,Fn,{strict:!1});let e=t.get("cookie"),r={};if(!e)return r;for(let A of e.split(";")){let[s,...o]=A.split("=");r[s.trim()]=o.join("=")}return r}function fS(t,e,r){P.brandCheck(t,Fn,{strict:!1});let A="deleteCookie";P.argumentLengthCheck(arguments,2,A),e=P.converters.DOMString(e,A,"name"),r=P.converters.DeleteCookieAttributes(r),XI(t,{name:e,value:"",expires:new Date(0),...r})}function mS(t){P.argumentLengthCheck(arguments,1,"getSetCookies"),P.brandCheck(t,Fn,{strict:!1});let e=t.getSetCookie();return e?e.map(r=>IS(r)):[]}function XI(t,e){P.argumentLengthCheck(arguments,2,"setCookie"),P.brandCheck(t,Fn,{strict:!1}),e=P.converters.Cookie(e);let r=CS(e);r&&t.append("Set-Cookie",r)}P.converters.DeleteCookieAttributes=P.dictionaryConverter([{converter:P.nullableConverter(P.converters.DOMString),key:"path",defaultValue:()=>null},{converter:P.nullableConverter(P.converters.DOMString),key:"domain",defaultValue:()=>null}]);P.converters.Cookie=P.dictionaryConverter([{converter:P.converters.DOMString,key:"name"},{converter:P.converters.DOMString,key:"value"},{converter:P.nullableConverter(t=>typeof t=="number"?P.converters["unsigned long long"](t):new Date(t)),key:"expires",defaultValue:()=>null},{converter:P.nullableConverter(P.converters["long long"]),key:"maxAge",defaultValue:()=>null},{converter:P.nullableConverter(P.converters.DOMString),key:"domain",defaultValue:()=>null},{converter:P.nullableConverter(P.converters.DOMString),key:"path",defaultValue:()=>null},{converter:P.nullableConverter(P.converters.boolean),key:"secure",defaultValue:()=>null},{converter:P.nullableConverter(P.converters.boolean),key:"httpOnly",defaultValue:()=>null},{converter:P.converters.USVString,key:"sameSite",allowedValues:["Strict","Lax","None"]},{converter:P.sequenceConverter(P.converters.DOMString),key:"unparsed",defaultValue:()=>new Array(0)}]);$I.exports={getCookies:pS,deleteCookie:fS,getSetCookies:mS,setCookie:XI}});var DA=m((wv,rC)=>{"use strict";var{webidl:U}=Be(),{kEnumerableProperty:Re}=O(),{kConstruct:tC}=se(),{MessagePort:wS}=require("node:worker_threads"),bA=class t extends Event{#e;constructor(e,r={}){if(e===tC){super(arguments[1],arguments[2]),U.util.markAsUncloneable(this);return}let A="MessageEvent constructor";U.argumentLengthCheck(arguments,1,A),e=U.converters.DOMString(e,A,"type"),r=U.converters.MessageEventInit(r,A,"eventInitDict"),super(e,r),this.#e=r,U.util.markAsUncloneable(this)}get data(){return U.brandCheck(this,t),this.#e.data}get origin(){return U.brandCheck(this,t),this.#e.origin}get lastEventId(){return U.brandCheck(this,t),this.#e.lastEventId}get source(){return U.brandCheck(this,t),this.#e.source}get ports(){return U.brandCheck(this,t),Object.isFrozen(this.#e.ports)||Object.freeze(this.#e.ports),this.#e.ports}initMessageEvent(e,r=!1,A=!1,s=null,o="",n="",i=null,a=[]){return U.brandCheck(this,t),U.argumentLengthCheck(arguments,1,"MessageEvent.initMessageEvent"),new t(e,{bubbles:r,cancelable:A,data:s,origin:o,lastEventId:n,source:i,ports:a})}static createFastMessageEvent(e,r){let A=new t(tC,e,r);return A.#e=r,A.#e.data??=null,A.#e.origin??="",A.#e.lastEventId??="",A.#e.source??=null,A.#e.ports??=[],A}},{createFastMessageEvent:yS}=bA;delete bA.createFastMessageEvent;var Sn=class t extends Event{#e;constructor(e,r={}){let A="CloseEvent constructor";U.argumentLengthCheck(arguments,1,A),e=U.converters.DOMString(e,A,"type"),r=U.converters.CloseEventInit(r),super(e,r),this.#e=r,U.util.markAsUncloneable(this)}get wasClean(){return U.brandCheck(this,t),this.#e.wasClean}get code(){return U.brandCheck(this,t),this.#e.code}get reason(){return U.brandCheck(this,t),this.#e.reason}},Un=class t extends Event{#e;constructor(e,r){let A="ErrorEvent constructor";U.argumentLengthCheck(arguments,1,A),super(e,r),U.util.markAsUncloneable(this),e=U.converters.DOMString(e,A,"type"),r=U.converters.ErrorEventInit(r??{}),this.#e=r}get message(){return U.brandCheck(this,t),this.#e.message}get filename(){return U.brandCheck(this,t),this.#e.filename}get lineno(){return U.brandCheck(this,t),this.#e.lineno}get colno(){return U.brandCheck(this,t),this.#e.colno}get error(){return U.brandCheck(this,t),this.#e.error}};Object.defineProperties(bA.prototype,{[Symbol.toStringTag]:{value:"MessageEvent",configurable:!0},data:Re,origin:Re,lastEventId:Re,source:Re,ports:Re,initMessageEvent:Re});Object.defineProperties(Sn.prototype,{[Symbol.toStringTag]:{value:"CloseEvent",configurable:!0},reason:Re,code:Re,wasClean:Re});Object.defineProperties(Un.prototype,{[Symbol.toStringTag]:{value:"ErrorEvent",configurable:!0},message:Re,filename:Re,lineno:Re,colno:Re,error:Re});U.converters.MessagePort=U.interfaceConverter(wS);U.converters["sequence"]=U.sequenceConverter(U.converters.MessagePort);var pg=[{key:"bubbles",converter:U.converters.boolean,defaultValue:()=>!1},{key:"cancelable",converter:U.converters.boolean,defaultValue:()=>!1},{key:"composed",converter:U.converters.boolean,defaultValue:()=>!1}];U.converters.MessageEventInit=U.dictionaryConverter([...pg,{key:"data",converter:U.converters.any,defaultValue:()=>null},{key:"origin",converter:U.converters.USVString,defaultValue:()=>""},{key:"lastEventId",converter:U.converters.DOMString,defaultValue:()=>""},{key:"source",converter:U.nullableConverter(U.converters.MessagePort),defaultValue:()=>null},{key:"ports",converter:U.converters["sequence"],defaultValue:()=>new Array(0)}]);U.converters.CloseEventInit=U.dictionaryConverter([...pg,{key:"wasClean",converter:U.converters.boolean,defaultValue:()=>!1},{key:"code",converter:U.converters["unsigned short"],defaultValue:()=>0},{key:"reason",converter:U.converters.USVString,defaultValue:()=>""}]);U.converters.ErrorEventInit=U.dictionaryConverter([...pg,{key:"message",converter:U.converters.DOMString,defaultValue:()=>""},{key:"filename",converter:U.converters.USVString,defaultValue:()=>""},{key:"lineno",converter:U.converters["unsigned long"],defaultValue:()=>0},{key:"colno",converter:U.converters["unsigned long"],defaultValue:()=>0},{key:"error",converter:U.converters.any}]);rC.exports={MessageEvent:bA,CloseEvent:Sn,ErrorEvent:Un,createFastMessageEvent:yS}});var Fr=m((yv,AC)=>{"use strict";var bS="258EAFA5-E914-47DA-95CA-C5AB0DC85B11",DS={enumerable:!0,writable:!1,configurable:!1},kS={CONNECTING:0,OPEN:1,CLOSING:2,CLOSED:3},RS={NOT_SENT:0,PROCESSING:1,SENT:2},TS={CONTINUATION:0,TEXT:1,BINARY:2,CLOSE:8,PING:9,PONG:10},FS=2**16-1,SS={INFO:0,PAYLOADLENGTH_16:2,PAYLOADLENGTH_64:3,READ_DATA:4},US=Buffer.allocUnsafe(0),NS={string:1,typedArray:2,arrayBuffer:3,blob:4};AC.exports={uid:bS,sentCloseFrameState:RS,staticPropertyDescriptors:DS,states:kS,opcodes:TS,maxUnsigned16Bit:FS,parserStates:SS,emptyBuffer:US,sendHints:NS}});var bs=m((bv,sC)=>{"use strict";sC.exports={kWebSocketURL:Symbol("url"),kReadyState:Symbol("ready state"),kController:Symbol("controller"),kResponse:Symbol("response"),kBinaryType:Symbol("binary type"),kSentClose:Symbol("sent close"),kReceivedClose:Symbol("received close"),kByteParser:Symbol("byte parser")}});var Rs=m((Dv,EC)=>{"use strict";var{kReadyState:Ds,kController:GS,kResponse:MS,kBinaryType:LS,kWebSocketURL:vS}=bs(),{states:ks,opcodes:er}=Fr(),{ErrorEvent:_S,createFastMessageEvent:xS}=DA(),{isUtf8:YS}=require("node:buffer"),{collectASequenceOfCodePointsFast:OS,removeHTTPWhitespace:oC}=ye();function JS(t){return t[Ds]===ks.CONNECTING}function HS(t){return t[Ds]===ks.OPEN}function PS(t){return t[Ds]===ks.CLOSING}function VS(t){return t[Ds]===ks.CLOSED}function fg(t,e,r=(s,o)=>new Event(s,o),A={}){let s=r(t,A);e.dispatchEvent(s)}function qS(t,e,r){if(t[Ds]!==ks.OPEN)return;let A;if(e===er.TEXT)try{A=lC(r)}catch{iC(t,"Received invalid UTF-8 in text frame.");return}else e===er.BINARY&&(t[LS]==="blob"?A=new Blob([r]):A=WS(r));fg("message",t,xS,{origin:t[vS].origin,data:A})}function WS(t){return t.byteLength===t.buffer.byteLength?t.buffer:t.buffer.slice(t.byteOffset,t.byteOffset+t.byteLength)}function zS(t){if(t.length===0)return!1;for(let e=0;e126||r===34||r===40||r===41||r===44||r===47||r===58||r===59||r===60||r===61||r===62||r===63||r===64||r===91||r===92||r===93||r===123||r===125)return!1}return!0}function ZS(t){return t>=1e3&&t<1015?t!==1004&&t!==1005&&t!==1006:t>=3e3&&t<=4999}function iC(t,e){let{[GS]:r,[MS]:A}=t;r.abort(),A?.socket&&!A.socket.destroyed&&A.socket.destroy(),e&&fg("error",t,(s,o)=>new _S(s,o),{error:new Error(e),message:e})}function aC(t){return t===er.CLOSE||t===er.PING||t===er.PONG}function cC(t){return t===er.CONTINUATION}function gC(t){return t===er.TEXT||t===er.BINARY}function KS(t){return gC(t)||cC(t)||aC(t)}function jS(t){let e={position:0},r=new Map;for(;e.position57)return!1}let e=Number.parseInt(t,10);return e>=8&&e<=15}var uC=typeof process.versions.icu=="string",nC=uC?new TextDecoder("utf-8",{fatal:!0}):void 0,lC=uC?nC.decode.bind(nC):function(t){if(YS(t))return t.toString("utf-8");throw new TypeError("Invalid utf-8 received.")};EC.exports={isConnecting:JS,isEstablished:HS,isClosing:PS,isClosed:VS,fireEvent:fg,isValidSubprotocol:zS,isValidStatusCode:ZS,failWebsocketConnection:iC,websocketMessageReceived:qS,utf8Decode:lC,isControlFrame:aC,isContinuationFrame:cC,isTextBinaryFrame:gC,isValidOpcode:KS,parseExtensions:jS,isValidClientWindowBits:XS}});var Gn=m((kv,hC)=>{"use strict";var{maxUnsigned16Bit:$S}=Fr(),Nn=16386,mg,Ts=null,kA=Nn;try{mg=require("node:crypto")}catch{mg={randomFillSync:function(e,r,A){for(let s=0;s$S?(n+=8,o=127):s>125&&(n+=2,o=126);let i=Buffer.allocUnsafe(s+n);i[0]=i[1]=0,i[0]|=128,i[0]=(i[0]&240)+e;i[n-4]=A[0],i[n-3]=A[1],i[n-2]=A[2],i[n-1]=A[3],i[1]=o,o===126?i.writeUInt16BE(s,2):o===127&&(i[2]=i[3]=0,i.writeUIntBE(s,4,6)),i[1]|=128;for(let a=0;a{"use strict";var{uid:tU,states:Fs,sentCloseFrameState:Mn,emptyBuffer:rU,opcodes:AU}=Fr(),{kReadyState:Ss,kSentClose:Ln,kByteParser:dC,kReceivedClose:QC,kResponse:BC}=bs(),{fireEvent:sU,failWebsocketConnection:tr,isClosing:oU,isClosed:nU,isEstablished:iU,parseExtensions:aU}=Rs(),{channels:RA}=xr(),{CloseEvent:cU}=DA(),{makeRequest:gU}=pA(),{fetching:uU}=fs(),{Headers:lU,getHeadersList:EU}=yr(),{getDecodeSplit:hU}=Fe(),{WebsocketFrameSend:QU}=Gn(),yg;try{yg=require("node:crypto")}catch{}function dU(t,e,r,A,s,o){let n=t;n.protocol=t.protocol==="ws:"?"http:":"https:";let i=gU({urlList:[n],client:r,serviceWorkers:"none",referrer:"no-referrer",mode:"websocket",credentials:"include",cache:"no-store",redirect:"error"});if(o.headers){let g=EU(new lU(o.headers));i.headersList=g}let a=yg.randomBytes(16).toString("base64");i.headersList.append("sec-websocket-key",a),i.headersList.append("sec-websocket-version","13");for(let g of e)i.headersList.append("sec-websocket-protocol",g);return i.headersList.append("sec-websocket-extensions","permessage-deflate; client_max_window_bits"),uU({request:i,useParallelQueue:!0,dispatcher:o.dispatcher,processResponse(g){if(g.type==="error"||g.status!==101){tr(A,"Received network error or non-101 status code.");return}if(e.length!==0&&!g.headersList.get("Sec-WebSocket-Protocol")){tr(A,"Server did not respond with sent protocols.");return}if(g.headersList.get("Upgrade")?.toLowerCase()!=="websocket"){tr(A,'Server did not set Upgrade header to "websocket".');return}if(g.headersList.get("Connection")?.toLowerCase()!=="upgrade"){tr(A,'Server did not set Connection header to "upgrade".');return}let E=g.headersList.get("Sec-WebSocket-Accept"),I=yg.createHash("sha1").update(a+tU).digest("base64");if(E!==I){tr(A,"Incorrect hash received in Sec-WebSocket-Accept header.");return}let d=g.headersList.get("Sec-WebSocket-Extensions"),p;if(d!==null&&(p=aU(d),!p.has("permessage-deflate"))){tr(A,"Sec-WebSocket-Extensions header does not match.");return}let y=g.headersList.get("Sec-WebSocket-Protocol");if(y!==null&&!hU("sec-websocket-protocol",i.headersList).includes(y)){tr(A,"Protocol was not set in the opening handshake.");return}g.socket.on("data",IC),g.socket.on("close",CC),g.socket.on("error",pC),RA.open.hasSubscribers&&RA.open.publish({address:g.socket.address(),protocol:y,extensions:d}),s(g,p)}})}function BU(t,e,r,A){if(!(oU(t)||nU(t)))if(!iU(t))tr(t,"Connection was closed before it was established."),t[Ss]=Fs.CLOSING;else if(t[Ln]===Mn.NOT_SENT){t[Ln]=Mn.PROCESSING;let s=new QU;e!==void 0&&r===void 0?(s.frameData=Buffer.allocUnsafe(2),s.frameData.writeUInt16BE(e,0)):e!==void 0&&r!==void 0?(s.frameData=Buffer.allocUnsafe(2+A),s.frameData.writeUInt16BE(e,0),s.frameData.write(r,2,"utf-8")):s.frameData=rU,t[BC].socket.write(s.createFrame(AU.CLOSE)),t[Ln]=Mn.SENT,t[Ss]=Fs.CLOSING}else t[Ss]=Fs.CLOSING}function IC(t){this.ws[dC].write(t)||this.pause()}function CC(){let{ws:t}=this,{[BC]:e}=t;e.socket.off("data",IC),e.socket.off("close",CC),e.socket.off("error",pC);let r=t[Ln]===Mn.SENT&&t[QC],A=1005,s="",o=t[dC].closingInfo;o&&!o.error?(A=o.code??1005,s=o.reason):t[QC]||(A=1006),t[Ss]=Fs.CLOSED,sU("close",t,(n,i)=>new cU(n,i),{wasClean:r,code:A,reason:s}),RA.close.hasSubscribers&&RA.close.publish({websocket:t,code:A,reason:s})}function pC(t){let{ws:e}=this;e[Ss]=Fs.CLOSING,RA.socketError.hasSubscribers&&RA.socketError.publish(t),this.destroy()}fC.exports={establishWebSocketConnection:dU,closeWebSocketConnection:BU}});var wC=m((Tv,mC)=>{"use strict";var{createInflateRaw:IU,Z_DEFAULT_WINDOWBITS:CU}=require("node:zlib"),{isValidClientWindowBits:pU}=Rs(),{MessageSizeExceededError:fU}=q(),mU=Buffer.from([0,0,255,255]),vn=Symbol("kBuffer"),Us=Symbol("kLength"),Dg=class{#e;#t={};#r=0;constructor(e,r){this.#t.serverNoContextTakeover=e.has("server_no_context_takeover"),this.#t.serverMaxWindowBits=e.get("server_max_window_bits"),this.#r=r.maxPayloadSize}decompress(e,r,A){if(!this.#e){let s=CU;if(this.#t.serverMaxWindowBits){if(!pU(this.#t.serverMaxWindowBits)){A(new Error("Invalid server_max_window_bits"));return}s=Number.parseInt(this.#t.serverMaxWindowBits)}try{this.#e=IU({windowBits:s})}catch(o){A(o);return}this.#e[vn]=[],this.#e[Us]=0,this.#e.on("data",o=>{if(this.#e[Us]+=o.length,this.#r>0&&this.#e[Us]>this.#r){A(new fU),this.#e.removeAllListeners(),this.#e=null;return}this.#e[vn].push(o)}),this.#e.on("error",o=>{this.#e=null,A(o)})}this.#e.write(e),r&&this.#e.write(mU),this.#e.flush(()=>{if(!this.#e)return;let s=Buffer.concat(this.#e[vn],this.#e[Us]);this.#e[vn].length=0,this.#e[Us]=0,A(null,s)})}};mC.exports={PerMessageDeflate:Dg}});var NC=m((Fv,UC)=>{"use strict";var{Writable:wU}=require("node:stream"),yU=require("node:assert"),{parserStates:Te,opcodes:TA,states:bU,emptyBuffer:yC,sentCloseFrameState:bC}=Fr(),{kReadyState:DU,kSentClose:DC,kResponse:kC,kReceivedClose:RC}=bs(),{channels:_n}=xr(),{isValidStatusCode:kU,isValidOpcode:RU,failWebsocketConnection:_e,websocketMessageReceived:TC,utf8Decode:TU,isControlFrame:kg,isTextBinaryFrame:Rg,isContinuationFrame:FU}=Rs(),{WebsocketFrameSend:FC}=Gn(),{closeWebSocketConnection:SC}=bg(),{PerMessageDeflate:SU}=wC(),{MessageSizeExceededError:Tg}=q();function Ns(t,e,r){SC(t,e,r,Buffer.byteLength(r)),_e(t,r)}var Fg=class extends wU{#e=[];#t=0;#r=0;#o=!1;#s=Te.INFO;#A={};#n=[];#i;#c;#a;constructor(e,r,A={}){super(),this.ws=e,this.#i=r??new Map,this.#c=A.maxFragments??0,this.#a=A.maxPayloadSize??0,this.#i.has("permessage-deflate")&&this.#i.set("permessage-deflate",new SU(r,A))}_write(e,r,A){this.#e.push(e),this.#r+=e.length,this.#o=!0,this.run(A)}#g(){return this.#a>0&&!kg(this.#A.opcode)&&this.#A.payloadLength+this.#t>this.#a?(Ns(this.ws,1009,"Payload size exceeds maximum allowed size"),!1):!0}run(e){for(;this.#o;)if(this.#s===Te.INFO){if(this.#r<2)return e();let r=this.consume(2),A=(r[0]&128)!==0,s=r[0]&15,o=(r[1]&128)===128,n=!A&&s!==TA.CONTINUATION,i=r[1]&127,a=r[0]&64,c=r[0]&32,u=r[0]&16;if(!RU(s))return _e(this.ws,"Invalid opcode received"),e();if(o)return _e(this.ws,"Frame cannot be masked"),e();if(a!==0&&!this.#i.has("permessage-deflate")){_e(this.ws,"Expected RSV1 to be clear.");return}if(c!==0||u!==0){_e(this.ws,"RSV1, RSV2, RSV3 must be clear");return}if(n&&!Rg(s)){_e(this.ws,"Invalid frame type was fragmented.");return}if(Rg(s)&&this.#n.length>0){_e(this.ws,"Expected continuation frame");return}if(this.#A.fragmented&&n){_e(this.ws,"Fragmented frame exceeded 125 bytes.");return}if((i>125||n)&&kg(s)){_e(this.ws,"Control frame either too large or fragmented");return}if(FU(s)&&this.#n.length===0&&!this.#A.compressed){_e(this.ws,"Unexpected continuation frame");return}if(i<=125){if(this.#A.payloadLength=i,this.#s=Te.READ_DATA,!this.#g())return}else i===126?this.#s=Te.PAYLOADLENGTH_16:i===127&&(this.#s=Te.PAYLOADLENGTH_64);Rg(s)&&(this.#A.binaryType=s,this.#A.compressed=a!==0),this.#A.opcode=s,this.#A.masked=o,this.#A.fin=A,this.#A.fragmented=n}else if(this.#s===Te.PAYLOADLENGTH_16){if(this.#r<2)return e();let r=this.consume(2);if(this.#A.payloadLength=r.readUInt16BE(0),this.#s=Te.READ_DATA,!this.#g())return}else if(this.#s===Te.PAYLOADLENGTH_64){if(this.#r<8)return e();let r=this.consume(8),A=r.readUInt32BE(0),s=r.readUInt32BE(4);if(A!==0||s>2**31-1){_e(this.ws,"Received payload length > 2^31 bytes.");return}if(this.#A.payloadLength=s,this.#s=Te.READ_DATA,!this.#g())return}else if(this.#s===Te.READ_DATA){if(this.#r{if(A){let o=A instanceof Tg?1009:1007;Ns(this.ws,o,A.message);return}if(this.writeFragments(s)){if(this.#a>0&&this.#t>this.#a){Ns(this.ws,1009,new Tg().message);return}if(!this.#A.fin){this.#s=Te.INFO,this.#o=!0,this.run(e);return}TC(this.ws,this.#A.binaryType,this.consumeFragments()),this.#o=!0,this.#s=Te.INFO,this.run(e)}}),this.#o=!1;break}else{if(!this.writeFragments(r))return;if(this.#a>0&&this.#t>this.#a){Ns(this.ws,1009,new Tg().message);return}!this.#A.fragmented&&this.#A.fin&&TC(this.ws,this.#A.binaryType,this.consumeFragments()),this.#s=Te.INFO}}}consume(e){if(e>this.#r)throw new Error("Called consume() before buffers satiated.");if(e===0)return yC;if(this.#e[0].length===e)return this.#r-=this.#e[0].length,this.#e.shift();let r=Buffer.allocUnsafe(e),A=0;for(;A!==e;){let s=this.#e[0],{length:o}=s;if(o+A===e){r.set(this.#e.shift(),A);break}else if(o+A>e){r.set(s.subarray(0,e-A),A),this.#e[0]=s.subarray(e-A);break}else r.set(this.#e.shift(),A),A+=s.length}return this.#r-=e,r}writeFragments(e){return this.#c>0&&this.#n.length===this.#c?(Ns(this.ws,1008,"Too many message fragments"),!1):(this.#t+=e.length,this.#n.push(e),!0)}consumeFragments(){let e=this.#n;if(e.length===1)return this.#t=0,e.shift();let r=Buffer.concat(e,this.#t);return this.#n=[],this.#t=0,r}parseCloseBody(e){yU(e.length!==1);let r;if(e.length>=2&&(r=e.readUInt16BE(0)),r!==void 0&&!kU(r))return{code:1002,reason:"Invalid status code",error:!0};let A=e.subarray(2);A[0]===239&&A[1]===187&&A[2]===191&&(A=A.subarray(3));try{A=TU(A)}catch{return{code:1007,reason:"Invalid UTF-8",error:!0}}return{code:r,reason:A,error:!1}}parseControlFrame(e){let{opcode:r,payloadLength:A}=this.#A;if(r===TA.CLOSE){if(A===1)return _e(this.ws,"Received close frame with a 1-byte body."),!1;if(this.#A.closeInfo=this.parseCloseBody(e),this.#A.closeInfo.error){let{code:s,reason:o}=this.#A.closeInfo;return SC(this.ws,s,o,o.length),_e(this.ws,o),!1}if(this.ws[DC]!==bC.SENT){let s=yC;this.#A.closeInfo.code&&(s=Buffer.allocUnsafe(2),s.writeUInt16BE(this.#A.closeInfo.code,0));let o=new FC(s);this.ws[kC].socket.write(o.createFrame(TA.CLOSE),n=>{n||(this.ws[DC]=bC.SENT)})}return this.ws[DU]=bU.CLOSING,this.ws[RC]=!0,!1}else if(r===TA.PING){if(!this.ws[RC]){let s=new FC(e);this.ws[kC].socket.write(s.createFrame(TA.PONG)),_n.ping.hasSubscribers&&_n.ping.publish({payload:e})}}else r===TA.PONG&&_n.pong.hasSubscribers&&_n.pong.publish({payload:e});return!0}get closingInfo(){return this.#A.closeInfo}};UC.exports={ByteParser:Fg}});var _C=m((Sv,vC)=>{"use strict";var{WebsocketFrameSend:UU}=Gn(),{opcodes:GC,sendHints:FA}=Fr(),NU=_a(),MC=Buffer[Symbol.species],Sg=class{#e=new NU;#t=!1;#r;constructor(e){this.#r=e}add(e,r,A){if(A!==FA.blob){let o=LC(e,A);if(!this.#t)this.#r.write(o,r);else{let n={promise:null,callback:r,frame:o};this.#e.push(n)}return}let s={promise:e.arrayBuffer().then(o=>{s.promise=null,s.frame=LC(o,A)}),callback:r,frame:null};this.#e.push(s),this.#t||this.#o()}async#o(){this.#t=!0;let e=this.#e;for(;!e.isEmpty();){let r=e.shift();r.promise!==null&&await r.promise,this.#r.write(r.frame,r.callback),r.callback=r.frame=null}this.#t=!1}};function LC(t,e){return new UU(GU(t,e)).createFrame(e===FA.string?GC.TEXT:GC.BINARY)}function GU(t,e){switch(e){case FA.string:return Buffer.from(t);case FA.arrayBuffer:case FA.blob:return new MC(t);case FA.typedArray:return new MC(t.buffer,t.byteOffset,t.byteLength)}}vC.exports={SendQueue:Sg}});var zC=m((Uv,WC)=>{"use strict";var{webidl:x}=Be(),{URLSerializer:MU}=ye(),{environmentSettingsObject:xC}=Fe(),{staticPropertyDescriptors:rr,states:Gs,sentCloseFrameState:LU,sendHints:xn}=Fr(),{kWebSocketURL:YC,kReadyState:Ug,kController:OC,kBinaryType:Yn,kResponse:JC,kSentClose:vU,kByteParser:_U}=bs(),{isConnecting:xU,isEstablished:YU,isClosing:OU,isValidSubprotocol:JU,fireEvent:HC}=Rs(),{establishWebSocketConnection:HU,closeWebSocketConnection:PC}=bg(),{ByteParser:PU}=NC(),{kEnumerableProperty:ze,isBlobLike:VC}=O(),{getGlobalDispatcher:VU}=en(),{types:qC}=require("node:util"),{ErrorEvent:qU,CloseEvent:WU}=DA(),{SendQueue:zU}=_C(),xe=class t extends EventTarget{#e={open:null,error:null,close:null,message:null};#t=0;#r="";#o="";#s;constructor(e,r=[]){super(),x.util.markAsUncloneable(this);let A="WebSocket constructor";x.argumentLengthCheck(arguments,1,A);let s=x.converters["DOMString or sequence or WebSocketInit"](r,A,"options");e=x.converters.USVString(e,A,"url"),r=s.protocols;let o=xC.settingsObject.baseUrl,n;try{n=new URL(e,o)}catch(a){throw new DOMException(a,"SyntaxError")}if(n.protocol==="http:"?n.protocol="ws:":n.protocol==="https:"&&(n.protocol="wss:"),n.protocol!=="ws:"&&n.protocol!=="wss:")throw new DOMException(`Expected a ws: or wss: protocol, got ${n.protocol}`,"SyntaxError");if(n.hash||n.href.endsWith("#"))throw new DOMException("Got fragment","SyntaxError");if(typeof r=="string"&&(r=[r]),r.length!==new Set(r.map(a=>a.toLowerCase())).size)throw new DOMException("Invalid Sec-WebSocket-Protocol value","SyntaxError");if(r.length>0&&!r.every(a=>JU(a)))throw new DOMException("Invalid Sec-WebSocket-Protocol value","SyntaxError");this[YC]=new URL(n.href);let i=xC.settingsObject;this[OC]=HU(n,r,i,this,(a,c)=>this.#A(a,c),s),this[Ug]=t.CONNECTING,this[vU]=LU.NOT_SENT,this[Yn]="blob"}close(e=void 0,r=void 0){x.brandCheck(this,t);let A="WebSocket.close";if(e!==void 0&&(e=x.converters["unsigned short"](e,A,"code",{clamp:!0})),r!==void 0&&(r=x.converters.USVString(r,A,"reason")),e!==void 0&&e!==1e3&&(e<3e3||e>4999))throw new DOMException("invalid code","InvalidAccessError");let s=0;if(r!==void 0&&(s=Buffer.byteLength(r),s>123))throw new DOMException(`Reason must be less than 123 bytes; received ${s}`,"SyntaxError");PC(this,e,r,s)}send(e){x.brandCheck(this,t);let r="WebSocket.send";if(x.argumentLengthCheck(arguments,1,r),e=x.converters.WebSocketSendData(e,r,"data"),xU(this))throw new DOMException("Sent before connected.","InvalidStateError");if(!(!YU(this)||OU(this)))if(typeof e=="string"){let A=Buffer.byteLength(e);this.#t+=A,this.#s.add(e,()=>{this.#t-=A},xn.string)}else qC.isArrayBuffer(e)?(this.#t+=e.byteLength,this.#s.add(e,()=>{this.#t-=e.byteLength},xn.arrayBuffer)):ArrayBuffer.isView(e)?(this.#t+=e.byteLength,this.#s.add(e,()=>{this.#t-=e.byteLength},xn.typedArray)):VC(e)&&(this.#t+=e.size,this.#s.add(e,()=>{this.#t-=e.size},xn.blob))}get readyState(){return x.brandCheck(this,t),this[Ug]}get bufferedAmount(){return x.brandCheck(this,t),this.#t}get url(){return x.brandCheck(this,t),MU(this[YC])}get extensions(){return x.brandCheck(this,t),this.#o}get protocol(){return x.brandCheck(this,t),this.#r}get onopen(){return x.brandCheck(this,t),this.#e.open}set onopen(e){x.brandCheck(this,t),this.#e.open&&this.removeEventListener("open",this.#e.open),typeof e=="function"?(this.#e.open=e,this.addEventListener("open",e)):this.#e.open=null}get onerror(){return x.brandCheck(this,t),this.#e.error}set onerror(e){x.brandCheck(this,t),this.#e.error&&this.removeEventListener("error",this.#e.error),typeof e=="function"?(this.#e.error=e,this.addEventListener("error",e)):this.#e.error=null}get onclose(){return x.brandCheck(this,t),this.#e.close}set onclose(e){x.brandCheck(this,t),this.#e.close&&this.removeEventListener("close",this.#e.close),typeof e=="function"?(this.#e.close=e,this.addEventListener("close",e)):this.#e.close=null}get onmessage(){return x.brandCheck(this,t),this.#e.message}set onmessage(e){x.brandCheck(this,t),this.#e.message&&this.removeEventListener("message",this.#e.message),typeof e=="function"?(this.#e.message=e,this.addEventListener("message",e)):this.#e.message=null}get binaryType(){return x.brandCheck(this,t),this[Yn]}set binaryType(e){x.brandCheck(this,t),e!=="blob"&&e!=="arraybuffer"?this[Yn]="blob":this[Yn]=e}#A(e,r){this[JC]=e;let A=this[OC]?.dispatcher?.webSocketOptions,s=A?.maxFragments,o=A?.maxPayloadSize,n=new PU(this,r,{maxFragments:s,maxPayloadSize:o});n.on("drain",ZU),n.on("error",KU.bind(this)),e.socket.ws=this,this[_U]=n,this.#s=new zU(e.socket),this[Ug]=Gs.OPEN;let i=e.headersList.get("sec-websocket-extensions");i!==null&&(this.#o=i);let a=e.headersList.get("sec-websocket-protocol");a!==null&&(this.#r=a),HC("open",this)}};xe.CONNECTING=xe.prototype.CONNECTING=Gs.CONNECTING;xe.OPEN=xe.prototype.OPEN=Gs.OPEN;xe.CLOSING=xe.prototype.CLOSING=Gs.CLOSING;xe.CLOSED=xe.prototype.CLOSED=Gs.CLOSED;Object.defineProperties(xe.prototype,{CONNECTING:rr,OPEN:rr,CLOSING:rr,CLOSED:rr,url:ze,readyState:ze,bufferedAmount:ze,onopen:ze,onerror:ze,onclose:ze,close:ze,onmessage:ze,binaryType:ze,send:ze,extensions:ze,protocol:ze,[Symbol.toStringTag]:{value:"WebSocket",writable:!1,enumerable:!1,configurable:!0}});Object.defineProperties(xe,{CONNECTING:rr,OPEN:rr,CLOSING:rr,CLOSED:rr});x.converters["sequence"]=x.sequenceConverter(x.converters.DOMString);x.converters["DOMString or sequence"]=function(t,e,r){return x.util.Type(t)==="Object"&&Symbol.iterator in t?x.converters["sequence"](t):x.converters.DOMString(t,e,r)};x.converters.WebSocketInit=x.dictionaryConverter([{key:"protocols",converter:x.converters["DOMString or sequence"],defaultValue:()=>new Array(0)},{key:"dispatcher",converter:x.converters.any,defaultValue:()=>VU()},{key:"headers",converter:x.nullableConverter(x.converters.HeadersInit)}]);x.converters["DOMString or sequence or WebSocketInit"]=function(t){return x.util.Type(t)==="Object"&&!(Symbol.iterator in t)?x.converters.WebSocketInit(t):{protocols:x.converters["DOMString or sequence"](t)}};x.converters.WebSocketSendData=function(t){if(x.util.Type(t)==="Object"){if(VC(t))return x.converters.Blob(t,{strict:!1});if(ArrayBuffer.isView(t)||qC.isArrayBuffer(t))return x.converters.BufferSource(t)}return x.converters.USVString(t)};function ZU(){this.ws[JC].socket.resume()}function KU(t){let e,r;t instanceof WU?(e=t.reason,r=t.code):e=t.message,HC("error",this,()=>new qU("error",{error:t,message:e})),PC(this,r)}WC.exports={WebSocket:xe}});var Ng=m((Nv,ZC)=>{"use strict";function jU(t){return t.indexOf("\0")===-1}function XU(t){if(t.length===0)return!1;for(let e=0;e57)return!1;return!0}function $U(t){return new Promise(e=>{setTimeout(e,t).unref()})}ZC.exports={isValidLastEventId:jU,isASCIINumber:XU,delay:$U}});var $C=m((Gv,XC)=>{"use strict";var{Transform:eN}=require("node:stream"),{isASCIINumber:KC,isValidLastEventId:jC}=Ng(),Gt=[239,187,191],Gg=10,On=13,tN=58,rN=32,Mg=class extends eN{state=null;checkBOM=!0;crlfCheck=!1;eventEndCheck=!1;buffer=null;pos=0;event={data:void 0,event:void 0,id:void 0,retry:void 0};constructor(e={}){e.readableObjectMode=!0,super(e),this.state=e.eventSourceSettings||{},e.push&&(this.push=e.push)}_transform(e,r,A){if(e.length===0){A();return}if(this.buffer?this.buffer=Buffer.concat([this.buffer,e]):this.buffer=e,this.checkBOM)switch(this.buffer.length){case 1:if(this.buffer[0]===Gt[0]){A();return}this.checkBOM=!1,A();return;case 2:if(this.buffer[0]===Gt[0]&&this.buffer[1]===Gt[1]){A();return}this.checkBOM=!1;break;case 3:if(this.buffer[0]===Gt[0]&&this.buffer[1]===Gt[1]&&this.buffer[2]===Gt[2]){this.buffer=Buffer.alloc(0),this.checkBOM=!1,A();return}this.checkBOM=!1;break;default:this.buffer[0]===Gt[0]&&this.buffer[1]===Gt[1]&&this.buffer[2]===Gt[2]&&(this.buffer=this.buffer.subarray(3)),this.checkBOM=!1;break}for(;this.pos0&&(r[s]=o);break}}processEvent(e){e.retry&&KC(e.retry)&&(this.state.reconnectionTime=parseInt(e.retry,10)),e.id&&jC(e.id)&&(this.state.lastEventId=e.id),e.data!==void 0&&this.push({type:e.event||"message",options:{data:e.data,lastEventId:this.state.lastEventId,origin:this.state.origin}})}clearEvent(){this.event={data:void 0,event:void 0,id:void 0,retry:void 0}}};XC.exports={EventSourceStream:Mg}});var ip=m((Mv,np)=>{"use strict";var{pipeline:AN}=require("node:stream"),{fetching:sN}=fs(),{makeRequest:oN}=pA(),{webidl:Mt}=Be(),{EventSourceStream:nN}=$C(),{parseMIMEType:iN}=ye(),{createFastMessageEvent:aN}=DA(),{isNetworkError:ep}=Cs(),{delay:cN}=Ng(),{kEnumerableProperty:Sr}=O(),{environmentSettingsObject:tp}=Fe(),rp=!1,Ap=3e3,Ms=0,sp=1,Ls=2,gN="anonymous",uN="use-credentials",SA=class t extends EventTarget{#e={open:null,error:null,message:null};#t=null;#r=!1;#o=Ms;#s=null;#A=null;#n;#i;constructor(e,r={}){super(),Mt.util.markAsUncloneable(this);let A="EventSource constructor";Mt.argumentLengthCheck(arguments,1,A),rp||(rp=!0,process.emitWarning("EventSource is experimental, expect them to change at any time.",{code:"UNDICI-ES"})),e=Mt.converters.USVString(e,A,"url"),r=Mt.converters.EventSourceInitDict(r,A,"eventSourceInitDict"),this.#n=r.dispatcher,this.#i={lastEventId:"",reconnectionTime:Ap};let s=tp,o;try{o=new URL(e,s.settingsObject.baseUrl),this.#i.origin=o.origin}catch(a){throw new DOMException(a,"SyntaxError")}this.#t=o.href;let n=gN;r.withCredentials&&(n=uN,this.#r=!0);let i={redirect:"follow",keepalive:!0,mode:"cors",credentials:n==="anonymous"?"same-origin":"omit",referrer:"no-referrer"};i.client=tp.settingsObject,i.headersList=[["accept",{name:"accept",value:"text/event-stream"}]],i.cache="no-store",i.initiator="other",i.urlList=[new URL(this.#t)],this.#s=oN(i),this.#c()}get readyState(){return this.#o}get url(){return this.#t}get withCredentials(){return this.#r}#c(){if(this.#o===Ls)return;this.#o=Ms;let e={request:this.#s,dispatcher:this.#n},r=A=>{ep(A)&&(this.dispatchEvent(new Event("error")),this.close()),this.#a()};e.processResponseEndOfBody=r,e.processResponse=A=>{if(ep(A))if(A.aborted){this.close(),this.dispatchEvent(new Event("error"));return}else{this.#a();return}let s=A.headersList.get("content-type",!0),o=s!==null?iN(s):"failure",n=o!=="failure"&&o.essence==="text/event-stream";if(A.status!==200||n===!1){this.close(),this.dispatchEvent(new Event("error"));return}this.#o=sp,this.dispatchEvent(new Event("open")),this.#i.origin=A.urlList[A.urlList.length-1].origin;let i=new nN({eventSourceSettings:this.#i,push:a=>{this.dispatchEvent(aN(a.type,a.options))}});AN(A.body.stream,i,a=>{a?.aborted===!1&&(this.close(),this.dispatchEvent(new Event("error")))})},this.#A=sN(e)}async#a(){this.#o!==Ls&&(this.#o=Ms,this.dispatchEvent(new Event("error")),await cN(this.#i.reconnectionTime),this.#o===Ms&&(this.#i.lastEventId.length&&this.#s.headersList.set("last-event-id",this.#i.lastEventId,!0),this.#c()))}close(){Mt.brandCheck(this,t),this.#o!==Ls&&(this.#o=Ls,this.#A.abort(),this.#s=null)}get onopen(){return this.#e.open}set onopen(e){this.#e.open&&this.removeEventListener("open",this.#e.open),typeof e=="function"?(this.#e.open=e,this.addEventListener("open",e)):this.#e.open=null}get onmessage(){return this.#e.message}set onmessage(e){this.#e.message&&this.removeEventListener("message",this.#e.message),typeof e=="function"?(this.#e.message=e,this.addEventListener("message",e)):this.#e.message=null}get onerror(){return this.#e.error}set onerror(e){this.#e.error&&this.removeEventListener("error",this.#e.error),typeof e=="function"?(this.#e.error=e,this.addEventListener("error",e)):this.#e.error=null}},op={CONNECTING:{__proto__:null,configurable:!1,enumerable:!0,value:Ms,writable:!1},OPEN:{__proto__:null,configurable:!1,enumerable:!0,value:sp,writable:!1},CLOSED:{__proto__:null,configurable:!1,enumerable:!0,value:Ls,writable:!1}};Object.defineProperties(SA,op);Object.defineProperties(SA.prototype,op);Object.defineProperties(SA.prototype,{close:Sr,onerror:Sr,onmessage:Sr,onopen:Sr,readyState:Sr,url:Sr,withCredentials:Sr});Mt.converters.EventSourceInitDict=Mt.dictionaryConverter([{key:"withCredentials",converter:Mt.converters.boolean,defaultValue:()=>!1},{key:"dispatcher",converter:Mt.converters.any}]);np.exports={EventSource:SA,defaultReconnectionTime:Ap}});var up=m((Lv,_)=>{"use strict";var lN=oA(),ap=xA(),EN=nA(),hN=oQ(),QN=iA(),dN=sc(),BN=TQ(),IN=MQ(),cp=q(),Hn=O(),{InvalidArgumentError:Jn}=cp,UA=fd(),CN=OA(),pN=xc(),fN=AB(),mN=Jc(),wN=Dc(),yN=Po(),{getGlobalDispatcher:gp,setGlobalDispatcher:bN}=en(),DN=tn(),kN=No(),RN=Go();Object.assign(ap.prototype,UA);_.exports.Dispatcher=ap;_.exports.Client=lN;_.exports.Pool=EN;_.exports.BalancedPool=hN;_.exports.Agent=QN;_.exports.ProxyAgent=dN;_.exports.EnvHttpProxyAgent=BN;_.exports.RetryAgent=IN;_.exports.RetryHandler=yN;_.exports.DecoratorHandler=DN;_.exports.RedirectHandler=kN;_.exports.createRedirectInterceptor=RN;_.exports.interceptors={redirect:gB(),retry:lB(),dump:hB(),dns:BB()};_.exports.buildConnector=CN;_.exports.errors=cp;_.exports.util={parseHeaders:Hn.parseHeaders,headerNameToString:Hn.headerNameToString};function vs(t){return(e,r,A)=>{if(typeof r=="function"&&(A=r,r=null),!e||typeof e!="string"&&typeof e!="object"&&!(e instanceof URL))throw new Jn("invalid url");if(r!=null&&typeof r!="object")throw new Jn("invalid opts");if(r&&r.path!=null){if(typeof r.path!="string")throw new Jn("invalid opts.path");let n=r.path;r.path.startsWith("/")||(n=`/${n}`),e=new URL(Hn.parseOrigin(e).origin+n)}else r||(r=typeof e=="object"?e:{}),e=Hn.parseURL(e);let{agent:s,dispatcher:o=gp()}=r;if(s)throw new Jn("unsupported opts.agent. Did you mean opts.client?");return t.call(o,{...r,origin:e.origin,path:e.search?`${e.pathname}${e.search}`:e.pathname,method:r.method||(r.body?"PUT":"GET")},A)}}_.exports.setGlobalDispatcher=bN;_.exports.getGlobalDispatcher=gp;var TN=fs().fetch;_.exports.fetch=async function(e,r=void 0){try{return await TN(e,r)}catch(A){throw A&&typeof A=="object"&&Error.captureStackTrace(A),A}};_.exports.Headers=yr().Headers;_.exports.Response=Cs().Response;_.exports.Request=pA().Request;_.exports.FormData=zA().FormData;_.exports.File=globalThis.File??require("node:buffer").File;_.exports.FileReader=NI().FileReader;var{setGlobalOrigin:FN,getGlobalOrigin:SN}=oa();_.exports.setGlobalOrigin=FN;_.exports.getGlobalOrigin=SN;var{CacheStorage:UN}=JI(),{kConstruct:NN}=wn();_.exports.caches=new UN(NN);var{deleteCookie:GN,getCookies:MN,getSetCookies:LN,setCookie:vN}=eC();_.exports.deleteCookie=GN;_.exports.getCookies=MN;_.exports.getSetCookies=LN;_.exports.setCookie=vN;var{parseMIMEType:_N,serializeAMimeType:xN}=ye();_.exports.parseMIMEType=_N;_.exports.serializeAMimeType=xN;var{CloseEvent:YN,ErrorEvent:ON,MessageEvent:JN}=DA();_.exports.WebSocket=zC().WebSocket;_.exports.CloseEvent=YN;_.exports.ErrorEvent=ON;_.exports.MessageEvent=JN;_.exports.request=vs(UA.request);_.exports.stream=vs(UA.stream);_.exports.pipeline=vs(UA.pipeline);_.exports.connect=vs(UA.connect);_.exports.upgrade=vs(UA.upgrade);_.exports.MockClient=pN;_.exports.MockPool=mN;_.exports.MockAgent=fN;_.exports.mockErrors=wN;var{EventSource:HN}=ip();_.exports.EventSource=HN});var Pg=m((Jg,Hg)=>{(function(t,e){typeof Jg=="object"&&typeof Hg<"u"?Hg.exports=e():typeof define=="function"&&define.amd?define(e):t.Bottleneck=e()})(Jg,(function(){"use strict";var t=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{};function e(F){return F&&F.default||F}var r=function(F,h,l={}){var Q,C,f;for(Q in h)f=h[Q],l[Q]=(C=F[Q])!=null?C:f;return l},A=function(F,h,l={}){var Q,C;for(Q in F)C=F[Q],h[Q]!==void 0&&(l[Q]=C);return l},s={load:r,overwrite:A},o;o=class{constructor(h,l){this.incr=h,this.decr=l,this._first=null,this._last=null,this.length=0}push(h){var l;this.length++,typeof this.incr=="function"&&this.incr(),l={value:h,prev:this._last,next:null},this._last!=null?(this._last.next=l,this._last=l):this._first=this._last=l}shift(){var h;if(this._first!=null)return this.length--,typeof this.decr=="function"&&this.decr(),h=this._first.value,(this._first=this._first.next)!=null?this._first.prev=null:this._last=null,h}first(){if(this._first!=null)return this._first.value}getArray(){var h,l,Q;for(h=this._first,Q=[];h!=null;)Q.push((l=h,h=h.next,l.value));return Q}forEachShift(h){var l;for(l=this.shift();l!=null;)h(l),l=this.shift()}debug(){var h,l,Q,C,f;for(h=this._first,f=[];h!=null;)f.push((l=h,h=h.next,{value:l.value,prev:(Q=l.prev)!=null?Q.value:void 0,next:(C=l.next)!=null?C.value:void 0}));return f}};var n=o,i;i=class{constructor(h){if(this.instance=h,this._events={},this.instance.on!=null||this.instance.once!=null||this.instance.removeAllListeners!=null)throw new Error("An Emitter already exists for this object");this.instance.on=(l,Q)=>this._addListener(l,"many",Q),this.instance.once=(l,Q)=>this._addListener(l,"once",Q),this.instance.removeAllListeners=(l=null)=>l!=null?delete this._events[l]:this._events={}}_addListener(h,l,Q){var C;return(C=this._events)[h]==null&&(C[h]=[]),this._events[h].push({cb:Q,status:l}),this.instance}listenerCount(h){return this._events[h]!=null?this._events[h].length:0}async trigger(h,...l){var Q,C;try{return h!=="debug"&&this.trigger("debug",`Event triggered: ${h}`,l),this._events[h]==null?void 0:(this._events[h]=this._events[h].filter(function(f){return f.status!=="none"}),C=this._events[h].map(async f=>{var k,R;if(f.status!=="none"){f.status==="once"&&(f.status="none");try{return R=typeof f.cb=="function"?f.cb(...l):void 0,typeof R?.then=="function"?await R:R}catch(Z){return k=Z,this.trigger("error",k),null}}}),(await Promise.all(C)).find(function(f){return f!=null}))}catch(f){return Q=f,this.trigger("error",Q),null}}};var a=i,c,u,g;c=n,u=a,g=class{constructor(h){var l;this.Events=new u(this),this._length=0,this._lists=(function(){var Q,C,f;for(f=[],l=Q=1,C=h;1<=C?Q<=C:Q>=C;l=1<=C?++Q:--Q)f.push(new c((()=>this.incr()),(()=>this.decr())));return f}).call(this)}incr(){if(this._length++===0)return this.Events.trigger("leftzero")}decr(){if(--this._length===0)return this.Events.trigger("zero")}push(h){return this._lists[h.options.priority].push(h)}queued(h){return h!=null?this._lists[h].length:this._length}shiftAll(h){return this._lists.forEach(function(l){return l.forEachShift(h)})}getFirst(h=this._lists){var l,Q,C;for(l=0,Q=h.length;l0)return C;return[]}shiftLastFrom(h){return this.getFirst(this._lists.slice(h).reverse()).shift()}};var E=g,I;I=class extends Error{};var d=I,p,y,B,w,T;w=10,y=5,T=s,p=d,B=class{constructor(h,l,Q,C,f,k,R,Z){this.task=h,this.args=l,this.rejectOnDrop=f,this.Events=k,this._states=R,this.Promise=Z,this.options=T.load(Q,C),this.options.priority=this._sanitizePriority(this.options.priority),this.options.id===C.id&&(this.options.id=`${this.options.id}-${this._randomIndex()}`),this.promise=new this.Promise((de,Ie)=>{this._resolve=de,this._reject=Ie}),this.retryCount=0}_sanitizePriority(h){var l;return l=~~h!==h?y:h,l<0?0:l>w-1?w-1:l}_randomIndex(){return Math.random().toString(36).slice(2)}doDrop({error:h,message:l="This job has been dropped by Bottleneck"}={}){return this._states.remove(this.options.id)?(this.rejectOnDrop&&this._reject(h??new p(l)),this.Events.trigger("dropped",{args:this.args,options:this.options,task:this.task,promise:this.promise}),!0):!1}_assertStatus(h){var l;if(l=this._states.jobStatus(this.options.id),!(l===h||h==="DONE"&&l===null))throw new p(`Invalid job status ${l}, expected ${h}. Please open an issue at https://github.com/SGrondin/bottleneck/issues`)}doReceive(){return this._states.start(this.options.id),this.Events.trigger("received",{args:this.args,options:this.options})}doQueue(h,l){return this._assertStatus("RECEIVED"),this._states.next(this.options.id),this.Events.trigger("queued",{args:this.args,options:this.options,reachedHWM:h,blocked:l})}doRun(){return this.retryCount===0?(this._assertStatus("QUEUED"),this._states.next(this.options.id)):this._assertStatus("EXECUTING"),this.Events.trigger("scheduled",{args:this.args,options:this.options})}async doExecute(h,l,Q,C){var f,k,R;this.retryCount===0?(this._assertStatus("RUNNING"),this._states.next(this.options.id)):this._assertStatus("EXECUTING"),k={args:this.args,options:this.options,retryCount:this.retryCount},this.Events.trigger("executing",k);try{if(R=await(h!=null?h.schedule(this.options,this.task,...this.args):this.task(...this.args)),l())return this.doDone(k),await C(this.options,k),this._assertStatus("DONE"),this._resolve(R)}catch(Z){return f=Z,this._onFailure(f,k,l,Q,C)}}doExpire(h,l,Q){var C,f;return this._states.jobStatus(this.options.id==="RUNNING")&&this._states.next(this.options.id),this._assertStatus("EXECUTING"),f={args:this.args,options:this.options,retryCount:this.retryCount},C=new p(`This job timed out after ${this.options.expiration} ms.`),this._onFailure(C,f,h,l,Q)}async _onFailure(h,l,Q,C,f){var k,R;if(Q())return k=await this.Events.trigger("failed",h,l),k!=null?(R=~~k,this.Events.trigger("retry",`Retrying ${this.options.id} after ${R} ms`,l),this.retryCount++,C(R)):(this.doDone(l),await f(this.options,l),this._assertStatus("DONE"),this._reject(h))}doDone(h){return this._assertStatus("EXECUTING"),this._states.next(this.options.id),this.Events.trigger("done",h)}};var S=B,J,j,X;X=s,J=d,j=class{constructor(h,l,Q){this.instance=h,this.storeOptions=l,this.clientId=this.instance._randomIndex(),X.load(Q,Q,this),this._nextRequest=this._lastReservoirRefresh=this._lastReservoirIncrease=Date.now(),this._running=0,this._done=0,this._unblockTime=0,this.ready=this.Promise.resolve(),this.clients={},this._startHeartbeat()}_startHeartbeat(){var h;return this.heartbeat==null&&(this.storeOptions.reservoirRefreshInterval!=null&&this.storeOptions.reservoirRefreshAmount!=null||this.storeOptions.reservoirIncreaseInterval!=null&&this.storeOptions.reservoirIncreaseAmount!=null)?typeof(h=this.heartbeat=setInterval(()=>{var l,Q,C,f,k;if(f=Date.now(),this.storeOptions.reservoirRefreshInterval!=null&&f>=this._lastReservoirRefresh+this.storeOptions.reservoirRefreshInterval&&(this._lastReservoirRefresh=f,this.storeOptions.reservoir=this.storeOptions.reservoirRefreshAmount,this.instance._drainAll(this.computeCapacity())),this.storeOptions.reservoirIncreaseInterval!=null&&f>=this._lastReservoirIncrease+this.storeOptions.reservoirIncreaseInterval&&({reservoirIncreaseAmount:l,reservoirIncreaseMaximum:C,reservoir:k}=this.storeOptions,this._lastReservoirIncrease=f,Q=C!=null?Math.min(l,C-k):l,Q>0))return this.storeOptions.reservoir+=Q,this.instance._drainAll(this.computeCapacity())},this.heartbeatInterval)).unref=="function"?h.unref():void 0:clearInterval(this.heartbeat)}async __publish__(h){return await this.yieldLoop(),this.instance.Events.trigger("message",h.toString())}async __disconnect__(h){return await this.yieldLoop(),clearInterval(this.heartbeat),this.Promise.resolve()}yieldLoop(h=0){return new this.Promise(function(l,Q){return setTimeout(l,h)})}computePenalty(){var h;return(h=this.storeOptions.penalty)!=null?h:15*this.storeOptions.minTime||5e3}async __updateSettings__(h){return await this.yieldLoop(),X.overwrite(h,h,this.storeOptions),this._startHeartbeat(),this.instance._drainAll(this.computeCapacity()),!0}async __running__(){return await this.yieldLoop(),this._running}async __queued__(){return await this.yieldLoop(),this.instance.queued()}async __done__(){return await this.yieldLoop(),this._done}async __groupCheck__(h){return await this.yieldLoop(),this._nextRequest+this.timeout=h}check(h,l){return this.conditionsCheck(h)&&this._nextRequest-l<=0}async __check__(h){var l;return await this.yieldLoop(),l=Date.now(),this.check(h,l)}async __register__(h,l,Q){var C,f;return await this.yieldLoop(),C=Date.now(),this.conditionsCheck(l)?(this._running+=l,this.storeOptions.reservoir!=null&&(this.storeOptions.reservoir-=l),f=Math.max(this._nextRequest-C,0),this._nextRequest=C+f+this.storeOptions.minTime,{success:!0,wait:f,reservoir:this.storeOptions.reservoir}):{success:!1}}strategyIsBlock(){return this.storeOptions.strategy===3}async __submit__(h,l){var Q,C,f;if(await this.yieldLoop(),this.storeOptions.maxConcurrent!=null&&l>this.storeOptions.maxConcurrent)throw new J(`Impossible to add a job having a weight of ${l} to a limiter having a maxConcurrent setting of ${this.storeOptions.maxConcurrent}`);return C=Date.now(),f=this.storeOptions.highWater!=null&&h===this.storeOptions.highWater&&!this.check(l,C),Q=this.strategyIsBlock()&&(f||this.isBlocked(C)),Q&&(this._unblockTime=C+this.computePenalty(),this._nextRequest=this._unblockTime+this.storeOptions.minTime,this.instance._dropAllQueued()),{reachedHWM:f,blocked:Q,strategy:this.storeOptions.strategy}}async __free__(h,l){return await this.yieldLoop(),this._running-=l,this._done+=l,this.instance._drainAll(this.computeCapacity()),{running:this._running}}};var Ye=j,Oe,Ct;Oe=d,Ct=class{constructor(h){this.status=h,this._jobs={},this.counts=this.status.map(function(){return 0})}next(h){var l,Q;if(l=this._jobs[h],Q=l+1,l!=null&&Q(h[this.status[Q]]=l,h)),{})}};var ot=Ct,Qe,pt;Qe=n,pt=class{constructor(h,l){this.schedule=this.schedule.bind(this),this.name=h,this.Promise=l,this._running=0,this._queue=new Qe}isEmpty(){return this._queue.length===0}async _tryToRun(){var h,l,Q,C,f,k,R;if(this._running<1&&this._queue.length>0)return this._running++,{task:R,args:h,resolve:f,reject:C}=this._queue.shift(),l=await(async function(){try{return k=await R(...h),function(){return f(k)}}catch(Z){return Q=Z,function(){return C(Q)}}})(),this._running--,this._tryToRun(),l()}schedule(h,...l){var Q,C,f;return f=C=null,Q=new this.Promise(function(k,R){return f=k,C=R}),this._queue.push({task:h,args:l,resolve:f,reject:C}),this._tryToRun(),Q}};var vt=pt,Mr="2.19.5",Lr={version:Mr},hf=Object.freeze({version:Mr,default:Lr}),au=()=>console.log("You must import the full version of Bottleneck in order to use this feature."),cu=()=>console.log("You must import the full version of Bottleneck in order to use this feature."),Qf=()=>console.log("You must import the full version of Bottleneck in order to use this feature."),gu,uu,lu,Eu,hu,Ps;Ps=s,gu=a,Eu=au,lu=cu,hu=Qf,uu=(function(){class F{constructor(l={}){this.deleteKey=this.deleteKey.bind(this),this.limiterOptions=l,Ps.load(this.limiterOptions,this.defaults,this),this.Events=new gu(this),this.instances={},this.Bottleneck=bu,this._startAutoCleanup(),this.sharedConnection=this.connection!=null,this.connection==null&&(this.limiterOptions.datastore==="redis"?this.connection=new Eu(Object.assign({},this.limiterOptions,{Events:this.Events})):this.limiterOptions.datastore==="ioredis"&&(this.connection=new lu(Object.assign({},this.limiterOptions,{Events:this.Events}))))}key(l=""){var Q;return(Q=this.instances[l])!=null?Q:(()=>{var C;return C=this.instances[l]=new this.Bottleneck(Object.assign(this.limiterOptions,{id:`${this.id}-${l}`,timeout:this.timeout,connection:this.connection})),this.Events.trigger("created",C,l),C})()}async deleteKey(l=""){var Q,C;return C=this.instances[l],this.connection&&(Q=await this.connection.__runCommand__(["del",...hu.allKeys(`${this.id}-${l}`)])),C!=null&&(delete this.instances[l],await C.disconnect()),C!=null||Q>0}limiters(){var l,Q,C,f;Q=this.instances,C=[];for(l in Q)f=Q[l],C.push({key:l,limiter:f});return C}keys(){return Object.keys(this.instances)}async clusterKeys(){var l,Q,C,f,k,R,Z,de,Ie;if(this.connection==null)return this.Promise.resolve(this.keys());for(R=[],l=null,Ie=`b_${this.id}-`.length,Q=9;l!==0;)for([de,C]=await this.connection.__runCommand__(["scan",l??0,"match",`b_${this.id}-*_settings`,"count",1e4]),l=~~de,f=0,Z=C.length;f{var Q,C,f,k,R,Z;R=Date.now(),f=this.instances,k=[];for(C in f){Z=f[C];try{await Z._store.__groupCheck__(R)?k.push(this.deleteKey(C)):k.push(void 0)}catch(de){Q=de,k.push(Z.Events.trigger("error",Q))}}return k},this.timeout/2)).unref=="function"?l.unref():void 0}updateSettings(l={}){if(Ps.overwrite(l,this.defaults,this),Ps.overwrite(l,l,this.limiterOptions),l.timeout!=null)return this._startAutoCleanup()}disconnect(l=!0){var Q;if(!this.sharedConnection)return(Q=this.connection)!=null?Q.disconnect(l):void 0}}return F.prototype.defaults={timeout:1e3*60*5,connection:null,Promise,id:"group-key"},F}).call(t);var df=uu,Qu,du,Bu;Bu=s,du=a,Qu=(function(){class F{constructor(l={}){this.options=l,Bu.load(this.options,this.defaults,this),this.Events=new du(this),this._arr=[],this._resetPromise(),this._lastFlush=Date.now()}_resetPromise(){return this._promise=new this.Promise((l,Q)=>this._resolve=l)}_flush(){return clearTimeout(this._timeout),this._lastFlush=Date.now(),this._resolve(),this.Events.trigger("batch",this._arr),this._arr=[],this._resetPromise()}add(l){var Q;return this._arr.push(l),Q=this._promise,this._arr.length===this.maxSize?this._flush():this.maxTime!=null&&this._arr.length===1&&(this._timeout=setTimeout(()=>this._flush(),this.maxTime)),Q}}return F.prototype.defaults={maxTime:null,maxSize:null,Promise},F}).call(t);var Bf=Qu,If=()=>console.log("You must import the full version of Bottleneck in order to use this feature."),Cf=e(hf),Iu,Cu,oi,ni,pu,ii,fu,mu,wu,ai,nt,yu=[].splice;ii=10,Cu=5,nt=s,fu=E,ni=S,pu=Ye,mu=If,oi=a,wu=ot,ai=vt,Iu=(function(){class F{constructor(l={},...Q){var C,f;this._addToQueue=this._addToQueue.bind(this),this._validateOptions(l,Q),nt.load(l,this.instanceDefaults,this),this._queues=new fu(ii),this._scheduled={},this._states=new wu(["RECEIVED","QUEUED","RUNNING","EXECUTING"].concat(this.trackDoneStatus?["DONE"]:[])),this._limiter=null,this.Events=new oi(this),this._submitLock=new ai("submit",this.Promise),this._registerLock=new ai("register",this.Promise),f=nt.load(l,this.storeDefaults,{}),this._store=(function(){if(this.datastore==="redis"||this.datastore==="ioredis"||this.connection!=null)return C=nt.load(l,this.redisStoreDefaults,{}),new mu(this,f,C);if(this.datastore==="local")return C=nt.load(l,this.localStoreDefaults,{}),new pu(this,f,C);throw new F.prototype.BottleneckError(`Invalid datastore type: ${this.datastore}`)}).call(this),this._queues.on("leftzero",()=>{var k;return(k=this._store.heartbeat)!=null&&typeof k.ref=="function"?k.ref():void 0}),this._queues.on("zero",()=>{var k;return(k=this._store.heartbeat)!=null&&typeof k.unref=="function"?k.unref():void 0})}_validateOptions(l,Q){if(!(l!=null&&typeof l=="object"&&Q.length===0))throw new F.prototype.BottleneckError("Bottleneck v2 takes a single object argument. Refer to https://github.com/SGrondin/bottleneck#upgrading-to-v2 if you're upgrading from Bottleneck v1.")}ready(){return this._store.ready}clients(){return this._store.clients}channel(){return`b_${this.id}`}channel_client(){return`b_${this.id}_${this._store.clientId}`}publish(l){return this._store.__publish__(l)}disconnect(l=!0){return this._store.__disconnect__(l)}chain(l){return this._limiter=l,this}queued(l){return this._queues.queued(l)}clusterQueued(){return this._store.__queued__()}empty(){return this.queued()===0&&this._submitLock.isEmpty()}running(){return this._store.__running__()}done(){return this._store.__done__()}jobStatus(l){return this._states.jobStatus(l)}jobs(l){return this._states.statusJobs(l)}counts(){return this._states.statusCounts()}_randomIndex(){return Math.random().toString(36).slice(2)}check(l=1){return this._store.__check__(l)}_clearGlobalState(l){return this._scheduled[l]!=null?(clearTimeout(this._scheduled[l].expiration),delete this._scheduled[l],!0):!1}async _free(l,Q,C,f){var k,R;try{if({running:R}=await this._store.__free__(l,C.weight),this.Events.trigger("debug",`Freed ${C.id}`,f),R===0&&this.empty())return this.Events.trigger("idle")}catch(Z){return k=Z,this.Events.trigger("error",k)}}_run(l,Q,C){var f,k,R;return Q.doRun(),f=this._clearGlobalState.bind(this,l),R=this._run.bind(this,l,Q),k=this._free.bind(this,l,Q),this._scheduled[l]={timeout:setTimeout(()=>Q.doExecute(this._limiter,f,R,k),C),expiration:Q.options.expiration!=null?setTimeout(function(){return Q.doExpire(f,R,k)},C+Q.options.expiration):void 0,job:Q}}_drainOne(l){return this._registerLock.schedule(()=>{var Q,C,f,k,R;return this.queued()===0?this.Promise.resolve(null):(R=this._queues.getFirst(),{options:k,args:Q}=f=R.first(),l!=null&&k.weight>l?this.Promise.resolve(null):(this.Events.trigger("debug",`Draining ${k.id}`,{args:Q,options:k}),C=this._randomIndex(),this._store.__register__(C,k.weight,k.expiration).then(({success:Z,wait:de,reservoir:Ie})=>{var LA;return this.Events.trigger("debug",`Drained ${k.id}`,{success:Z,args:Q,options:k}),Z?(R.shift(),LA=this.empty(),LA&&this.Events.trigger("empty"),Ie===0&&this.Events.trigger("depleted",LA),this._run(C,f,de),this.Promise.resolve(k.weight)):this.Promise.resolve(null)})))})}_drainAll(l,Q=0){return this._drainOne(l).then(C=>{var f;return C!=null?(f=l!=null?l-C:l,this._drainAll(f,Q+C)):this.Promise.resolve(Q)}).catch(C=>this.Events.trigger("error",C))}_dropAllQueued(l){return this._queues.shiftAll(function(Q){return Q.doDrop({message:l})})}stop(l={}){var Q,C;return l=nt.load(l,this.stopDefaults),C=f=>{var k;return k=()=>{var R;return R=this._states.counts,R[0]+R[1]+R[2]+R[3]===f},new this.Promise((R,Z)=>k()?R():this.on("done",()=>{if(k())return this.removeAllListeners("done"),R()}))},Q=l.dropWaitingJobs?(this._run=function(f,k){return k.doDrop({message:l.dropErrorMessage})},this._drainOne=()=>this.Promise.resolve(null),this._registerLock.schedule(()=>this._submitLock.schedule(()=>{var f,k,R;k=this._scheduled;for(f in k)R=k[f],this.jobStatus(R.job.options.id)==="RUNNING"&&(clearTimeout(R.timeout),clearTimeout(R.expiration),R.job.doDrop({message:l.dropErrorMessage}));return this._dropAllQueued(l.dropErrorMessage),C(0)}))):this.schedule({priority:ii-1,weight:0},()=>C(1)),this._receive=function(f){return f._reject(new F.prototype.BottleneckError(l.enqueueErrorMessage))},this.stop=()=>this.Promise.reject(new F.prototype.BottleneckError("stop() has already been called")),Q}async _addToQueue(l){var Q,C,f,k,R,Z,de;({args:Q,options:k}=l);try{({reachedHWM:R,blocked:C,strategy:de}=await this._store.__submit__(this.queued(),k.weight))}catch(Ie){return f=Ie,this.Events.trigger("debug",`Could not queue ${k.id}`,{args:Q,options:k,error:f}),l.doDrop({error:f}),!1}return C?(l.doDrop(),!0):R&&(Z=de===F.prototype.strategy.LEAK?this._queues.shiftLastFrom(k.priority):de===F.prototype.strategy.OVERFLOW_PRIORITY?this._queues.shiftLastFrom(k.priority+1):de===F.prototype.strategy.OVERFLOW?l:void 0,Z?.doDrop(),Z==null||de===F.prototype.strategy.OVERFLOW)?(Z==null&&l.doDrop(),R):(l.doQueue(R,C),this._queues.push(l),await this._drainAll(),R)}_receive(l){return this._states.jobStatus(l.options.id)!=null?(l._reject(new F.prototype.BottleneckError(`A job with the same id already exists (id=${l.options.id})`)),!1):(l.doReceive(),this._submitLock.schedule(this._addToQueue,l))}submit(...l){var Q,C,f,k,R,Z,de;return typeof l[0]=="function"?(R=l,[C,...l]=R,[Q]=yu.call(l,-1),k=nt.load({},this.jobDefaults)):(Z=l,[k,C,...l]=Z,[Q]=yu.call(l,-1),k=nt.load(k,this.jobDefaults)),de=(...Ie)=>new this.Promise(function(LA,ff){return C(...Ie,function(...Du){return(Du[0]!=null?ff:LA)(Du)})}),f=new ni(de,l,k,this.jobDefaults,this.rejectOnDrop,this.Events,this._states,this.Promise),f.promise.then(function(Ie){return typeof Q=="function"?Q(...Ie):void 0}).catch(function(Ie){return Array.isArray(Ie)?typeof Q=="function"?Q(...Ie):void 0:typeof Q=="function"?Q(Ie):void 0}),this._receive(f)}schedule(...l){var Q,C,f;return typeof l[0]=="function"?([f,...l]=l,C={}):[C,f,...l]=l,Q=new ni(f,l,C,this.jobDefaults,this.rejectOnDrop,this.Events,this._states,this.Promise),this._receive(Q),Q.promise}wrap(l){var Q,C;return Q=this.schedule.bind(this),C=function(...f){return Q(l.bind(this),...f)},C.withOptions=function(f,...k){return Q(f,l,...k)},C}async updateSettings(l={}){return await this._store.__updateSettings__(nt.overwrite(l,this.storeDefaults)),nt.overwrite(l,this.instanceDefaults,this),this}currentReservoir(){return this._store.__currentReservoir__()}incrementReservoir(l=0){return this._store.__incrementReservoir__(l)}}return F.default=F,F.Events=oi,F.version=F.prototype.version=Cf.version,F.strategy=F.prototype.strategy={LEAK:1,OVERFLOW:2,OVERFLOW_PRIORITY:4,BLOCK:3},F.BottleneckError=F.prototype.BottleneckError=d,F.Group=F.prototype.Group=df,F.RedisConnection=F.prototype.RedisConnection=au,F.IORedisConnection=F.prototype.IORedisConnection=cu,F.Batcher=F.prototype.Batcher=Bf,F.prototype.jobDefaults={priority:Cu,weight:1,expiration:null,id:""},F.prototype.storeDefaults={maxConcurrent:null,minTime:0,highWater:null,strategy:F.prototype.strategy.LEAK,penalty:null,reservoir:null,reservoirRefreshInterval:null,reservoirRefreshAmount:null,reservoirIncreaseInterval:null,reservoirIncreaseAmount:null,reservoirIncreaseMaximum:null},F.prototype.localStoreDefaults={Promise,timeout:null,heartbeatInterval:250},F.prototype.redisStoreDefaults={Promise,timeout:null,heartbeatInterval:5e3,clientTimeout:1e4,Redis:null,clientOptions:{},clusterNodes:null,clearDatastore:!1,connection:null},F.prototype.instanceDefaults={datastore:"local",connection:null,id:"",rejectOnDrop:!0,trackDoneStatus:!1,Promise},F.prototype.stopDefaults={enqueueErrorMessage:"This limiter has been stopped and cannot accept new jobs.",dropWaitingJobs:!0,dropErrorMessage:"This limiter has been stopped."},F}).call(t);var bu=Iu,pf=bu;return pf}))});var xp=m((K_,Os)=>{"use strict";var $n=function(){};$n.prototype=Object.create(null);var jn=/; *([!#$%&'*+.^\w`|~-]+)=("(?:[\v\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\v\u0020-\u00ff])*"|[!#$%&'*+.^\w`|~-]+) */gu,Xn=/\\([\v\u0020-\u00ff])/gu,Lp=/^[!#$%&'*+.^\w|~-]+\/[!#$%&'*+.^\w|~-]+$/u,Nr={type:"",parameters:new $n};Object.freeze(Nr.parameters);Object.freeze(Nr);function vp(t){if(typeof t!="string")throw new TypeError("argument header is required and must be a string");let e=t.indexOf(";"),r=e!==-1?t.slice(0,e).trim():t.trim();if(Lp.test(r)===!1)throw new TypeError("invalid media type");let A={type:r.toLowerCase(),parameters:new $n};if(e===-1)return A;let s,o,n;for(jn.lastIndex=e;o=jn.exec(t);){if(o.index!==e)throw new TypeError("invalid parameter format");e+=o[0].length,s=o[1].toLowerCase(),n=o[2],n[0]==='"'&&(n=n.slice(1,n.length-1),Xn.test(n)&&(n=n.replace(Xn,"$1"))),A.parameters[s]=n}if(e!==t.length)throw new TypeError("invalid parameter format");return A}function _p(t){if(typeof t!="string")return Nr;let e=t.indexOf(";"),r=e!==-1?t.slice(0,e).trim():t.trim();if(Lp.test(r)===!1)return Nr;let A={type:r.toLowerCase(),parameters:new $n};if(e===-1)return A;let s,o,n;for(jn.lastIndex=e;o=jn.exec(t);){if(o.index!==e)return Nr;e+=o[0].length,s=o[1].toLowerCase(),n=o[2],n[0]==='"'&&(n=n.slice(1,n.length-1),Xn.test(n)&&(n=n.replace(Xn,"$1"))),A.parameters[s]=n}return e!==t.length?Nr:A}Os.exports.default={parse:vp,safeParse:_p};Os.exports.parse=vp;Os.exports.safeParse=_p;Os.exports.defaultContentType=Nr});var UM={};kf(UM,{run:()=>Ef});module.exports=Rf(UM);var Tu=Je(require("os"),1);function _t(t){return t==null?"":typeof t=="string"||t instanceof String?t:JSON.stringify(t)}function ci(t){return Object.keys(t).length?{title:t.title,file:t.file,line:t.startLine,endLine:t.endLine,col:t.startColumn,endColumn:t.endColumn}:{}}function vA(t,e,r){let A=new gi(t,e,r);process.stdout.write(A.toString()+Tu.EOL)}var Ru="::",gi=class{constructor(e,r,A){e||(e="missing.command"),this.command=e,this.properties=r,this.message=A}toString(){let e=Ru+this.command;if(this.properties&&Object.keys(this.properties).length>0){e+=" ";let r=!0;for(let A in this.properties)if(this.properties.hasOwnProperty(A)){let s=this.properties[A];s&&(r?r=!1:e+=",",e+=`${A}=${Ff(s)}`)}}return e+=`${Ru}${Tf(this.message)}`,e}};function Tf(t){return _t(t).replace(/%/g,"%25").replace(/\r/g,"%0D").replace(/\n/g,"%0A")}function Ff(t){return _t(t).replace(/%/g,"%25").replace(/\r/g,"%0D").replace(/\n/g,"%0A").replace(/:/g,"%3A").replace(/,/g,"%2C")}var Fu=Je(require("crypto"),1),Ws=Je(require("fs"),1),qs=Je(require("os"),1);function Su(t,e){let r=process.env[`GITHUB_${t}`];if(!r)throw new Error(`Unable to find environment variable for file command ${t}`);if(!Ws.existsSync(r))throw new Error(`Missing file at path: ${r}`);Ws.appendFileSync(r,`${_t(e)}${qs.EOL}`,{encoding:"utf8"})}function Uu(t,e){let r=`ghadelimiter_${Fu.randomUUID()}`,A=_t(e);if(t.includes(r))throw new Error(`Unexpected input: name should not contain the delimiter "${r}"`);if(A.includes(r))throw new Error(`Unexpected input: value should not contain the delimiter "${r}"`);return`${t}<<${r}${qs.EOL}${A}${qs.EOL}${r}`}var Yg=Je(require("os"),1);var Pn=Je(_u(),1),PN=Je(up(),1);var Bt;(function(t){t[t.OK=200]="OK",t[t.MultipleChoices=300]="MultipleChoices",t[t.MovedPermanently=301]="MovedPermanently",t[t.ResourceMoved=302]="ResourceMoved",t[t.SeeOther=303]="SeeOther",t[t.NotModified=304]="NotModified",t[t.UseProxy=305]="UseProxy",t[t.SwitchProxy=306]="SwitchProxy",t[t.TemporaryRedirect=307]="TemporaryRedirect",t[t.PermanentRedirect=308]="PermanentRedirect",t[t.BadRequest=400]="BadRequest",t[t.Unauthorized=401]="Unauthorized",t[t.PaymentRequired=402]="PaymentRequired",t[t.Forbidden=403]="Forbidden",t[t.NotFound=404]="NotFound",t[t.MethodNotAllowed=405]="MethodNotAllowed",t[t.NotAcceptable=406]="NotAcceptable",t[t.ProxyAuthenticationRequired=407]="ProxyAuthenticationRequired",t[t.RequestTimeout=408]="RequestTimeout",t[t.Conflict=409]="Conflict",t[t.Gone=410]="Gone",t[t.TooManyRequests=429]="TooManyRequests",t[t.InternalServerError=500]="InternalServerError",t[t.NotImplemented=501]="NotImplemented",t[t.BadGateway=502]="BadGateway",t[t.ServiceUnavailable=503]="ServiceUnavailable",t[t.GatewayTimeout=504]="GatewayTimeout"})(Bt||(Bt={}));var lp;(function(t){t.Accept="accept",t.ContentType="content-type"})(lp||(lp={}));var Ep;(function(t){t.ApplicationJson="application/json"})(Ep||(Ep={}));var _v=[Bt.MovedPermanently,Bt.ResourceMoved,Bt.SeeOther,Bt.TemporaryRedirect,Bt.PermanentRedirect],xv=[Bt.BadGateway,Bt.ServiceUnavailable,Bt.GatewayTimeout];var Qp=require("os"),_s=require("fs"),Lg=function(t,e,r,A){function s(o){return o instanceof r?o:new r(function(n){n(o)})}return new(r||(r=Promise))(function(o,n){function i(u){try{c(A.next(u))}catch(g){n(g)}}function a(u){try{c(A.throw(u))}catch(g){n(g)}}function c(u){u.done?o(u.value):s(u.value).then(i,a)}c((A=A.apply(t,e||[])).next())})},{access:VN,appendFile:qN,writeFile:WN}=_s.promises,hp="GITHUB_STEP_SUMMARY";var vg=class{constructor(){this._buffer=""}filePath(){return Lg(this,void 0,void 0,function*(){if(this._filePath)return this._filePath;let e=process.env[hp];if(!e)throw new Error(`Unable to find environment variable for $${hp}. Check if your runtime environment supports job summaries.`);try{yield VN(e,_s.constants.R_OK|_s.constants.W_OK)}catch{throw new Error(`Unable to access summary file: '${e}'. Check if the file has correct read/write permissions.`)}return this._filePath=e,this._filePath})}wrap(e,r,A={}){let s=Object.entries(A).map(([o,n])=>` ${o}="${n}"`).join("");return r?`<${e}${s}>${r}`:`<${e}${s}>`}write(e){return Lg(this,void 0,void 0,function*(){let r=!!e?.overwrite,A=yield this.filePath();return yield(r?WN:qN)(A,this._buffer,{encoding:"utf8"}),this.emptyBuffer()})}clear(){return Lg(this,void 0,void 0,function*(){return this.emptyBuffer().write({overwrite:!0})})}stringify(){return this._buffer}isEmptyBuffer(){return this._buffer.length===0}emptyBuffer(){return this._buffer="",this}addRaw(e,r=!1){return this._buffer+=e,r?this.addEOL():this}addEOL(){return this.addRaw(Qp.EOL)}addCodeBlock(e,r){let A=Object.assign({},r&&{lang:r}),s=this.wrap("pre",this.wrap("code",e),A);return this.addRaw(s).addEOL()}addList(e,r=!1){let A=r?"ol":"ul",s=e.map(n=>this.wrap("li",n)).join(""),o=this.wrap(A,s);return this.addRaw(o).addEOL()}addTable(e){let r=e.map(s=>{let o=s.map(n=>{if(typeof n=="string")return this.wrap("td",n);let{header:i,data:a,colspan:c,rowspan:u}=n,g=i?"th":"td",E=Object.assign(Object.assign({},c&&{colspan:c}),u&&{rowspan:u});return this.wrap(g,a,E)}).join("");return this.wrap("tr",o)}).join(""),A=this.wrap("table",r);return this.addRaw(A).addEOL()}addDetails(e,r){let A=this.wrap("details",this.wrap("summary",e)+r);return this.addRaw(A).addEOL()}addImage(e,r,A){let{width:s,height:o}=A||{},n=Object.assign(Object.assign({},s&&{width:s}),o&&{height:o}),i=this.wrap("img",null,Object.assign({src:e,alt:r},n));return this.addRaw(i).addEOL()}addHeading(e,r){let A=`h${r}`,s=["h1","h2","h3","h4","h5","h6"].includes(A)?A:"h1",o=this.wrap(s,e);return this.addRaw(o).addEOL()}addSeparator(){let e=this.wrap("hr",null);return this.addRaw(e).addEOL()}addBreak(){let e=this.wrap("br",null);return this.addRaw(e).addEOL()}addQuote(e,r){let A=Object.assign({},r&&{cite:r}),s=this.wrap("blockquote",e,A);return this.addRaw(s).addEOL()}addLink(e,r){let A=this.wrap("a",e,{href:r});return this.addRaw(A).addEOL()}},Zv=new vg;var _g=Je(require("os"),1);var Vn=Je(require("fs"),1);var{chmod:zN,copyFile:ZN,lstat:KN,mkdir:jN,open:Xv,readdir:XN,rename:$N,rm:eG,rmdir:$v,stat:tG,symlink:rG,unlink:AG}=Vn.promises,sG=process.platform==="win32";var e_=Vn.constants.O_RDONLY;var o_=process.platform==="win32";var c_=_g.default.platform(),g_=_g.default.arch();var xg;(function(t){t[t.Success=0]="Success",t[t.Failure=1]="Failure"})(xg||(xg={}));function It(t,e){if(process.env.GITHUB_OUTPUT||"")return Su("OUTPUT",Uu(t,e));process.stdout.write(Yg.EOL),vA("set-output",{name:t},_t(e))}function qn(t){process.exitCode=xg.Failure,uG(t)}function NA(t){vA("debug",{},t)}function uG(t,e={}){vA("error",ci(e),t instanceof Error?t.toString():t)}function xs(t,e={}){vA("warning",ci(e),t instanceof Error?t.toString():t)}function Og(t){process.stdout.write(t+Yg.EOL)}var lf=require("process");var Bp=2147483647,Wn={now:()=>performance.now(),setTimeout:(t,e)=>setTimeout(t,e),clearTimeout:t=>clearTimeout(t)},Ar=class extends Error{constructor(r,A){super(`Wait ${r} deadline reached`);this.mode=r;this.seconds=A}mode;seconds},sr=class t{constructor(e,r=Wn,A=0){this.config=e;this.timing=r,this.startedAtSeconds=r.now()/1e3-A,this.deadlineAtSeconds=e===void 0?void 0:this.startedAtSeconds+e.seconds,this.controller=new AbortController,this.signal=this.controller.signal;let s;this.reached=new Promise(o=>{s=o}),this.resolveReached=s,this.scheduleDeadlineChunk()}config;signal;controller;deadlineAtSeconds;reached;resolveReached;startedAtSeconds;timing;expired=!1;timer;static fromInput(e,r=Wn,A=0){let s=e.continueAfterSeconds!==void 0?{mode:"continue",seconds:e.continueAfterSeconds}:e.abortAfterSeconds!==void 0?{mode:"abort",seconds:e.abortAfterSeconds}:void 0;return new t(s,r,A)}delayUntil=e=>{let r=e-this.timing.now()/1e3;if(r<=0)return 0;let A=Bp/1e3;return r>A?Bp:Math.max(1,Math.round(r*1e3))};deadlineReached=()=>this.expired||this.deadlineAtSeconds!==void 0&&this.timing.now()/1e3>=this.deadlineAtSeconds;expire=()=>{this.expired||!this.config||(this.expired=!0,this.resolveReached({kind:"deadline"}),this.controller.abort())};scheduleDeadlineChunk=()=>{if(this.deadlineAtSeconds===void 0||this.expired)return;let e=this.delayUntil(this.deadlineAtSeconds);if(e===0){this.expire();return}this.timer=this.timing.setTimeout(()=>{this.timer=void 0,this.deadlineReached()?this.expire():this.scheduleDeadlineChunk()},e)};throwIfReached=()=>{let e=this.config;if(e&&this.deadlineReached())throw this.expire(),new Ar(e.mode,e.seconds)};race=async e=>{this.throwIfReached(),this.signal.throwIfAborted();let r=this.config;if(!r)return e(this.signal);let A=Promise.resolve().then(()=>e(this.signal)).then(o=>({kind:"value",value:o}),o=>({kind:"error",error:o})),s=await Promise.race([A,this.reached]);if(s.kind==="deadline")throw new Ar(r.mode,r.seconds);if(this.throwIfReached(),s.kind==="error")throw s.error;return s.value};sleepUntilSeconds=async(e,r)=>{for(r?.throwIfAborted(),this.throwIfReached();;){this.throwIfReached();let A=this.delayUntil(e);if(A===0)return;let s,o=new Promise(c=>{s=this.timing.setTimeout(c,A)}),n,i=new Promise((c,u)=>{n=u}),a=()=>{s!==void 0&&(this.timing.clearTimeout(s),s=void 0),n(r?.reason)};r?.addEventListener("abort",a,{once:!0});try{await this.race(()=>r?Promise.race([o,i]):o)}finally{r?.removeEventListener("abort",a),s!==void 0&&this.timing.clearTimeout(s)}}};sleepSeconds=async(e,r)=>this.sleepUntilSeconds(this.timing.now()/1e3+e,r);cancel=e=>{this.controller.abort(e)};dispose=()=>{this.timer!==void 0&&(this.timing.clearTimeout(this.timer),this.timer=void 0)}},zn=(t,e,r)=>{if(t.mode==="continue")return e("\u{1F919}Exceeded wait seconds. Continuing..."),It("force_continued","1"),r(),t.seconds;throw e("\u{1F6D1}Exceeded wait seconds. Aborting..."),It("force_continued",""),r(),new Error(`Aborted after waiting ${t.seconds} seconds`)};var Cp=Je(Pg(),1);var Lt=class extends Error{name;status;request;response;constructor(e,r,A){super(e),this.name="HttpError",this.status=Number.parseInt(r),Number.isNaN(this.status)&&(this.status=0),"response"in A&&(this.response=A.response);let s=Object.assign({},A.request);A.request.headers.authorization&&(s.headers=Object.assign({},A.request.headers,{authorization:A.request.headers.authorization.replace(/(?=400&&!t.doNotRetry.includes(r.status)){let s=A.request.retries!=null?A.request.retries:t.retries,o=Math.pow((A.request.retryCount||0)+1,2);throw e.retry.retryRequest(r,s,o)}throw r}async function hG(t,e,r,A){let s=new Cp.default;return s.on("failed",function(o,n){let i=~~o.request.request?.retries,a=~~o.request.request?.retryAfter;if(A.request.retryCount=n.retryCount+1,i>n.retryCount)return a*t.retryAfterBaseValue}),s.schedule(QG.bind(null,t,e,r),A)}async function QG(t,e,r,A){let s=await r(A);if(s.data&&s.data.errors&&s.data.errors.length>0&&/Something went wrong while executing your query/.test(s.data.errors[0].message)){let o=new Lt(s.data.errors[0].message,500,{request:A,response:s});return Ip(t,e,o,A)}return s}function Vg(t,e){let r=Object.assign({enabled:!0,retryAfterBaseValue:1e3,doNotRetry:[400,401,403,404,410,422,451],retries:3},e.retry),A={retry:{retryRequest:(s,o,n)=>(s.request.request=Object.assign({},s.request.request,{retries:o,retryAfter:n}),s)}};return r.enabled&&(t.hook.error("request",Ip.bind(null,r,A)),t.hook.wrap("request",hG.bind(null,r,A))),A}Vg.VERSION=lG;var fp=Je(Pg(),1),dG="0.0.0-development",qg=()=>Promise.resolve();function BG(t,e,r){return t.retryLimiter.schedule(IG,t,e,r)}async function IG(t,e,r){let{pathname:A}=new URL(r.url,"http://github.test"),s=CG(r.method,A),o=!s&&r.method!=="GET"&&r.method!=="HEAD",n=r.method==="GET"&&A.startsWith("/search/"),i=A.startsWith("/graphql"),c=~~e.retryCount>0?{priority:0,weight:0}:{};t.clustering&&(c.expiration=1e3*60),(o||i)&&await t.write.key(t.id).schedule(c,qg),o&&t.triggersNotification(A)&&await t.notifications.key(t.id).schedule(c,qg),n&&await t.search.key(t.id).schedule(c,qg);let u=(s?t.auth:t.global).key(t.id).schedule(c,e,r);if(i){let g=await u;if(g.data.errors!=null&&g.data.errors.some(E=>E.type==="RATE_LIMITED"))throw Object.assign(new Error("GraphQL Rate Limit Exceeded"),{response:g,data:g.data})}return u}function CG(t,e){return t==="PATCH"&&/^\/applications\/[^/]+\/token\/scoped$/.test(e)||t==="POST"&&(/^\/applications\/[^/]+\/token$/.test(e)||/^\/app\/installations\/[^/]+\/access_tokens$/.test(e)||e==="/login/oauth/access_token")}var pG=["/orgs/{org}/invitations","/orgs/{org}/invitations/{invitation_id}","/orgs/{org}/teams/{team_slug}/discussions","/orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments","/repos/{owner}/{repo}/collaborators/{username}","/repos/{owner}/{repo}/commits/{commit_sha}/comments","/repos/{owner}/{repo}/issues","/repos/{owner}/{repo}/issues/{issue_number}/comments","/repos/{owner}/{repo}/issues/{issue_number}/sub_issue","/repos/{owner}/{repo}/issues/{issue_number}/sub_issues/priority","/repos/{owner}/{repo}/pulls","/repos/{owner}/{repo}/pulls/{pull_number}/comments","/repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies","/repos/{owner}/{repo}/pulls/{pull_number}/merge","/repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers","/repos/{owner}/{repo}/pulls/{pull_number}/reviews","/repos/{owner}/{repo}/releases","/teams/{team_id}/discussions","/teams/{team_id}/discussions/{discussion_number}/comments"];function fG(t){let r=`^(?:${t.map(A=>A.split("/").map(s=>s.startsWith("{")?"(?:.+?)":s).join("/")).map(A=>`(?:${A})`).join("|")})[^/]*$`;return new RegExp(r,"i")}var pp=fG(pG),mp=pp.test.bind(pp),Ur={},mG=function(t,e){Ur.global=new t.Group({id:"octokit-global",maxConcurrent:10,...e}),Ur.auth=new t.Group({id:"octokit-auth",maxConcurrent:1,...e}),Ur.search=new t.Group({id:"octokit-search",maxConcurrent:1,minTime:2e3,...e}),Ur.write=new t.Group({id:"octokit-write",maxConcurrent:1,minTime:1e3,...e}),Ur.notifications=new t.Group({id:"octokit-notifications",maxConcurrent:1,minTime:3e3,...e})};function Zn(t,e){let{enabled:r=!0,Bottleneck:A=fp.default,id:s="no-id",timeout:o=1e3*60*2,connection:n}=e.throttle||{};if(!r)return{};let i={timeout:o};typeof n<"u"&&(i.connection=n),Ur.global==null&&mG(A,i);let a=Object.assign({clustering:n!=null,triggersNotification:mp,fallbackSecondaryRateRetryAfter:60,retryAfterBaseValue:1e3,retryLimiter:new A,id:s,...Ur},e.throttle);if(typeof a.onSecondaryRateLimit!="function"||typeof a.onRateLimit!="function")throw new Error(`octokit/plugin-throttling error: You must pass the onSecondaryRateLimit and onRateLimit error handlers. See https://octokit.github.io/rest.js/#throttling @@ -53,9 +53,9 @@ ${o}`;break;case"retry":HC(o)&&(r[s]=o);break;case"id":PC(o)&&(r[s]=o);break;cas onRateLimit: (retryAfter, options) => {/* ... */} } }) - `);let c={},l=new A.Events(c);return c.on("secondary-limit",a.onSecondaryRateLimit),c.on("rate-limit",a.onRateLimit),c.on("error",g=>t.log.warn("Error in throttling-plugin limit handler",g)),a.retryLimiter.on("failed",async function(g,E){let[d,B,p]=E.args,{pathname:w}=new URL(p.url,"http://github.test");if(!(w.startsWith("/graphql")&&g.status!==401||g.status===403||g.status===429))return;let y=~~B.retryCount;B.retryCount=y,p.request.retryCount=y;let{wantRetry:T,retryAfter:S=0}=await(async function(){if(/\bsecondary rate\b/i.test(g.message)){let O=Number(g.response.headers["retry-after"])||d.fallbackSecondaryRateRetryAfter;return{wantRetry:await l.trigger("secondary-limit",O,p,t,y),retryAfter:O}}if(g.response.headers!=null&&g.response.headers["x-ratelimit-remaining"]==="0"||(g.response.data?.errors??[]).some(O=>O.type==="RATE_LIMITED")){let O=new Date(~~g.response.headers["x-ratelimit-reset"]*1e3).getTime(),j=Math.max(Math.ceil((O-Date.now())/1e3)+1,0);return{wantRetry:await l.trigger("rate-limit",j,p,t,y),retryAfter:j}}return{}})();if(T)return B.retryCount++,S*d.retryAfterBaseValue}),t.hook.wrap("request",iG.bind(null,a)),{}}Pn.VERSION=nG;Pn.triggersNotification=Qp;function rr(){return typeof navigator=="object"&&"userAgent"in navigator?navigator.userAgent:typeof process=="object"&&process.version!==void 0?`Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`:""}function Vn(t,e,r,A){if(typeof r!="function")throw new Error("method for before hook must be a function");return A||(A={}),Array.isArray(e)?e.reverse().reduce((s,o)=>Vn.bind(null,t,o,s,A),r)():Promise.resolve().then(()=>t.registry[e]?t.registry[e].reduce((s,o)=>o.hook.bind(null,s,A),r)():r(A))}function Bp(t,e,r,A){let s=A;t.registry[r]||(t.registry[r]=[]),e==="before"&&(A=(o,n)=>Promise.resolve().then(s.bind(null,n)).then(o.bind(null,n))),e==="after"&&(A=(o,n)=>{let i;return Promise.resolve().then(o.bind(null,n)).then(a=>(i=a,s(i,n))).then(()=>i)}),e==="error"&&(A=(o,n)=>Promise.resolve().then(o.bind(null,n)).catch(i=>s(i,n))),t.registry[r].push({hook:A,orig:s})}function dp(t,e,r){if(!t.registry[e])return;let A=t.registry[e].map(s=>s.orig).indexOf(r);A!==-1&&t.registry[e].splice(A,1)}var Ip=Function.bind,Cp=Ip.bind(Ip);function pp(t,e,r){let A=Cp(dp,null).apply(null,r?[e,r]:[e]);t.api={remove:A},t.remove=A,["before","error","after","wrap"].forEach(s=>{let o=r?[e,s,r]:[e,s];t[s]=t.api[s]=Cp(Bp,null).apply(null,o)})}function EG(){let t=Symbol("Singular"),e={registry:{}},r=Vn.bind(null,e,t);return pp(r,e,t),r}function hG(){let t={registry:{}},e=Vn.bind(null,t);return pp(e,t),e}var fp={Singular:EG,Collection:hG};var QG="0.0.0-development",BG=`octokit-endpoint.js/${QG} ${rr()}`,dG={method:"GET",baseUrl:"https://api.github.com",headers:{accept:"application/vnd.github.v3+json","user-agent":BG},mediaType:{format:""}};function IG(t){return t?Object.keys(t).reduce((e,r)=>(e[r.toLowerCase()]=t[r],e),{}):{}}function CG(t){if(typeof t!="object"||t===null||Object.prototype.toString.call(t)!=="[object Object]")return!1;let e=Object.getPrototypeOf(t);if(e===null)return!0;let r=Object.prototype.hasOwnProperty.call(e,"constructor")&&e.constructor;return typeof r=="function"&&r instanceof r&&Function.prototype.call(r)===Function.prototype.call(t)}function yp(t,e){let r=Object.assign({},t);return Object.keys(e).forEach(A=>{CG(e[A])?A in t?r[A]=yp(t[A],e[A]):Object.assign(r,{[A]:e[A]}):Object.assign(r,{[A]:e[A]})}),r}function mp(t){for(let e in t)t[e]===void 0&&delete t[e];return t}function Hg(t,e,r){if(typeof e=="string"){let[s,o]=e.split(" ");r=Object.assign(o?{method:s,url:o}:{url:s},r)}else r=Object.assign({},e);r.headers=IG(r.headers),mp(r),mp(r.headers);let A=yp(t||{},r);return r.url==="/graphql"&&(t&&t.mediaType.previews?.length&&(A.mediaType.previews=t.mediaType.previews.filter(s=>!A.mediaType.previews.includes(s)).concat(A.mediaType.previews)),A.mediaType.previews=(A.mediaType.previews||[]).map(s=>s.replace(/-preview/,""))),A}function pG(t,e){let r=/\?/.test(t)?"&":"?",A=Object.keys(e);return A.length===0?t:t+r+A.map(s=>s==="q"?"q="+e.q.split("+").map(encodeURIComponent).join("+"):`${s}=${encodeURIComponent(e[s])}`).join("&")}var fG=/\{[^{}}]+\}/g;function mG(t){return t.replace(/(?:^\W+)|(?:(?r.concat(A),[]):[]}function wp(t,e){let r={__proto__:null};for(let A of Object.keys(t))e.indexOf(A)===-1&&(r[A]=t[A]);return r}function bp(t){return t.split(/(%[0-9A-Fa-f]{2})/g).map(function(e){return/%[0-9A-Fa-f]/.test(e)||(e=encodeURI(e).replace(/%5B/g,"[").replace(/%5D/g,"]")),e}).join("")}function NA(t){return encodeURIComponent(t).replace(/[!'()*]/g,function(e){return"%"+e.charCodeAt(0).toString(16).toUpperCase()})}function vs(t,e,r){return e=t==="+"||t==="#"?bp(e):NA(e),r?NA(r)+"="+e:e}function UA(t){return t!=null}function Og(t){return t===";"||t==="&"||t==="?"}function yG(t,e,r,A){var s=t[r],o=[];if(UA(s)&&s!=="")if(typeof s=="string"||typeof s=="number"||typeof s=="boolean")s=s.toString(),A&&A!=="*"&&(s=s.substring(0,parseInt(A,10))),o.push(vs(e,s,Og(e)?r:""));else if(A==="*")Array.isArray(s)?s.filter(UA).forEach(function(n){o.push(vs(e,n,Og(e)?r:""))}):Object.keys(s).forEach(function(n){UA(s[n])&&o.push(vs(e,s[n],n))});else{let n=[];Array.isArray(s)?s.filter(UA).forEach(function(i){n.push(vs(e,i))}):Object.keys(s).forEach(function(i){UA(s[i])&&(n.push(NA(i)),n.push(vs(e,s[i].toString())))}),Og(e)?o.push(NA(r)+"="+n.join(",")):n.length!==0&&o.push(n.join(","))}else e===";"?UA(s)&&o.push(NA(r)):s===""&&(e==="&"||e==="?")?o.push(NA(r)+"="):s===""&&o.push("");return o}function bG(t){return{expand:kG.bind(null,t)}}function kG(t,e){var r=["+","#",".","/",";","?","&"];return t=t.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g,function(A,s,o){if(s){let i="",a=[];if(r.indexOf(s.charAt(0))!==-1&&(i=s.charAt(0),s=s.substr(1)),s.split(/,/g).forEach(function(c){var l=/([^:\*]*)(?::(\d+)|(\*))?/.exec(c);a.push(yG(e,i,l[1],l[2]||l[3]))}),i&&i!=="+"){var n=",";return i==="?"?n="&":i!=="#"&&(n=i),(a.length!==0?i:"")+a.join(n)}else return a.join(",")}else return bp(o)}),t==="/"?t:t.replace(/\/$/,"")}function kp(t){let e=t.method.toUpperCase(),r=(t.url||"/").replace(/:([a-z]\w+)/g,"{$1}"),A=Object.assign({},t.headers),s,o=wp(t,["method","baseUrl","url","headers","request","mediaType"]),n=wG(r);r=bG(r).expand(o),/^http/.test(r)||(r=t.baseUrl+r);let i=Object.keys(t).filter(l=>n.includes(l)).concat("baseUrl"),a=wp(o,i);if(!/application\/octet-stream/i.test(A.accept)&&(t.mediaType.format&&(A.accept=A.accept.split(/,/).map(l=>l.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/,`application/vnd$1$2.${t.mediaType.format}`)).join(",")),r.endsWith("/graphql")&&t.mediaType.previews?.length)){let l=A.accept.match(/(?{let E=t.mediaType.format?`.${t.mediaType.format}`:"+json";return`application/vnd.github.${g}-preview${E}`}).join(",")}return["GET","HEAD"].includes(e)?r=pG(r,a):"data"in a?s=a.data:Object.keys(a).length&&(s=a),!A["content-type"]&&typeof s<"u"&&(A["content-type"]="application/json; charset=utf-8"),["PATCH","PUT"].includes(e)&&typeof s>"u"&&(s=""),Object.assign({method:e,url:r,headers:A},typeof s<"u"?{body:s}:null,t.request?{request:t.request}:null)}function DG(t,e,r){return kp(Hg(t,e,r))}function Dp(t,e){let r=Hg(t,e),A=DG.bind(null,r);return Object.assign(A,{DEFAULTS:r,defaults:Dp.bind(null,r),merge:Hg.bind(null,r),parse:kp})}var Rp=Dp(null,dG);var Gp=Oe(Up(),1);var RG="10.0.6",TG={headers:{"user-agent":`octokit-request.js/${RG} ${rr()}`}};function FG(t){if(typeof t!="object"||t===null||Object.prototype.toString.call(t)!=="[object Object]")return!1;let e=Object.getPrototypeOf(t);if(e===null)return!0;let r=Object.prototype.hasOwnProperty.call(e,"constructor")&&e.constructor;return typeof r=="function"&&r instanceof r&&Function.prototype.call(r)===Function.prototype.call(t)}async function Np(t){let e=t.request?.fetch||globalThis.fetch;if(!e)throw new Error("fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing");let r=t.request?.log||console,A=t.request?.parseSuccessResponseBody!==!1,s=FG(t.body)||Array.isArray(t.body)?JSON.stringify(t.body):t.body,o=Object.fromEntries(Object.entries(t.headers).map(([g,E])=>[g,String(E)])),n;try{n=await e(t.url,{method:t.method,body:s,redirect:t.request?.redirect,headers:o,signal:t.request?.signal,...t.body&&{duplex:"half"}})}catch(g){let E="Unknown Error";if(g instanceof Error){if(g.name==="AbortError")throw g.status=500,g;E=g.message,g.name==="TypeError"&&"cause"in g&&(g.cause instanceof Error?E=g.cause.message:typeof g.cause=="string"&&(E=g.cause))}let d=new Mt(E,500,{request:t});throw d.cause=g,d}let i=n.status,a=n.url,c={};for(let[g,E]of n.headers)c[g]=E;let l={url:a,status:i,headers:c,data:""};if("deprecation"in c){let g=c.link&&c.link.match(/<([^<>]+)>; rel="deprecation"/),E=g&&g.pop();r.warn(`[@octokit/request] "${t.method} ${t.url}" is deprecated. It is scheduled to be removed on ${c.sunset}${E?`. See ${E}`:""}`)}if(i===204||i===205)return l;if(t.method==="HEAD"){if(i<400)return l;throw new Mt(n.statusText,i,{response:l,request:t})}if(i===304)throw l.data=await Pg(n),new Mt("Not modified",i,{response:l,request:t});if(i>=400)throw l.data=await Pg(n),new Mt(UG(l.data),i,{response:l,request:t});return l.data=A?await Pg(n):n.body,l}async function Pg(t){let e=t.headers.get("content-type");if(!e)return t.text().catch(()=>"");let r=(0,Gp.safeParse)(e);if(SG(r)){let A="";try{return A=await t.text(),JSON.parse(A)}catch{return A}}else return r.type.startsWith("text/")||r.parameters.charset?.toLowerCase()==="utf-8"?t.text().catch(()=>""):t.arrayBuffer().catch(()=>new ArrayBuffer(0))}function SG(t){return t.type==="application/json"||t.type==="application/scim+json"}function UG(t){if(typeof t=="string")return t;if(t instanceof ArrayBuffer)return"Unknown error";if("message"in t){let e="documentation_url"in t?` - ${t.documentation_url}`:"";return Array.isArray(t.errors)?`${t.message}: ${t.errors.map(r=>JSON.stringify(r)).join(", ")}${e}`:`${t.message}${e}`}return`Unknown error: ${JSON.stringify(t)}`}function Vg(t,e){let r=t.defaults(e);return Object.assign(function(s,o){let n=r.merge(s,o);if(!n.request||!n.request.hook)return Np(r.parse(n));let i=(a,c)=>Np(r.parse(r.merge(a,c)));return Object.assign(i,{endpoint:r,defaults:Vg.bind(null,r)}),n.request.hook(i,n)},{endpoint:r,defaults:Vg.bind(null,r)})}var xs=Vg(Rp,TG);var NG="0.0.0-development";function GG(t){return`Request failed due to following response errors: + `);let c={},u=new A.Events(c);return c.on("secondary-limit",a.onSecondaryRateLimit),c.on("rate-limit",a.onRateLimit),c.on("error",g=>t.log.warn("Error in throttling-plugin limit handler",g)),a.retryLimiter.on("failed",async function(g,E){let[I,d,p]=E.args,{pathname:y}=new URL(p.url,"http://github.test");if(!(y.startsWith("/graphql")&&g.status!==401||g.status===403||g.status===429))return;let w=~~d.retryCount;d.retryCount=w,p.request.retryCount=w;let{wantRetry:T,retryAfter:S=0}=await(async function(){if(/\bsecondary rate\b/i.test(g.message)){let J=Number(g.response.headers["retry-after"])||I.fallbackSecondaryRateRetryAfter;return{wantRetry:await u.trigger("secondary-limit",J,p,t,w),retryAfter:J}}if(g.response.headers!=null&&g.response.headers["x-ratelimit-remaining"]==="0"||(g.response.data?.errors??[]).some(J=>J.type==="RATE_LIMITED")){let J=new Date(~~g.response.headers["x-ratelimit-reset"]*1e3).getTime(),j=Math.max(Math.ceil((J-Date.now())/1e3)+1,0);return{wantRetry:await u.trigger("rate-limit",j,p,t,w),retryAfter:j}}return{}})();if(T)return d.retryCount++,S*I.retryAfterBaseValue}),t.hook.wrap("request",BG.bind(null,a)),{}}Zn.VERSION=dG;Zn.triggersNotification=mp;function or(){return typeof navigator=="object"&&"userAgent"in navigator?navigator.userAgent:typeof process=="object"&&process.version!==void 0?`Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`:""}function Kn(t,e,r,A){if(typeof r!="function")throw new Error("method for before hook must be a function");return A||(A={}),Array.isArray(e)?e.reverse().reduce((s,o)=>Kn.bind(null,t,o,s,A),r)():Promise.resolve().then(()=>t.registry[e]?t.registry[e].reduce((s,o)=>o.hook.bind(null,s,A),r)():r(A))}function wp(t,e,r,A){let s=A;t.registry[r]||(t.registry[r]=[]),e==="before"&&(A=(o,n)=>Promise.resolve().then(s.bind(null,n)).then(o.bind(null,n))),e==="after"&&(A=(o,n)=>{let i;return Promise.resolve().then(o.bind(null,n)).then(a=>(i=a,s(i,n))).then(()=>i)}),e==="error"&&(A=(o,n)=>Promise.resolve().then(o.bind(null,n)).catch(i=>s(i,n))),t.registry[r].push({hook:A,orig:s})}function yp(t,e,r){if(!t.registry[e])return;let A=t.registry[e].map(s=>s.orig).indexOf(r);A!==-1&&t.registry[e].splice(A,1)}var bp=Function.bind,Dp=bp.bind(bp);function kp(t,e,r){let A=Dp(yp,null).apply(null,r?[e,r]:[e]);t.api={remove:A},t.remove=A,["before","error","after","wrap"].forEach(s=>{let o=r?[e,s,r]:[e,s];t[s]=t.api[s]=Dp(wp,null).apply(null,o)})}function wG(){let t=Symbol("Singular"),e={registry:{}},r=Kn.bind(null,e,t);return kp(r,e,t),r}function yG(){let t={registry:{}},e=Kn.bind(null,t);return kp(e,t),e}var Rp={Singular:wG,Collection:yG};var bG="0.0.0-development",DG=`octokit-endpoint.js/${bG} ${or()}`,kG={method:"GET",baseUrl:"https://api.github.com",headers:{accept:"application/vnd.github.v3+json","user-agent":DG},mediaType:{format:""}};function RG(t){return t?Object.keys(t).reduce((e,r)=>(e[r.toLowerCase()]=t[r],e),{}):{}}function TG(t){if(typeof t!="object"||t===null||Object.prototype.toString.call(t)!=="[object Object]")return!1;let e=Object.getPrototypeOf(t);if(e===null)return!0;let r=Object.prototype.hasOwnProperty.call(e,"constructor")&&e.constructor;return typeof r=="function"&&r instanceof r&&Function.prototype.call(r)===Function.prototype.call(t)}function Sp(t,e){let r=Object.assign({},t);return Object.keys(e).forEach(A=>{TG(e[A])?A in t?r[A]=Sp(t[A],e[A]):Object.assign(r,{[A]:e[A]}):Object.assign(r,{[A]:e[A]})}),r}function Tp(t){for(let e in t)t[e]===void 0&&delete t[e];return t}function zg(t,e,r){if(typeof e=="string"){let[s,o]=e.split(" ");r=Object.assign(o?{method:s,url:o}:{url:s},r)}else r=Object.assign({},e);r.headers=RG(r.headers),Tp(r),Tp(r.headers);let A=Sp(t||{},r);return r.url==="/graphql"&&(t&&t.mediaType.previews?.length&&(A.mediaType.previews=t.mediaType.previews.filter(s=>!A.mediaType.previews.includes(s)).concat(A.mediaType.previews)),A.mediaType.previews=(A.mediaType.previews||[]).map(s=>s.replace(/-preview/,""))),A}function FG(t,e){let r=/\?/.test(t)?"&":"?",A=Object.keys(e);return A.length===0?t:t+r+A.map(s=>s==="q"?"q="+e.q.split("+").map(encodeURIComponent).join("+"):`${s}=${encodeURIComponent(e[s])}`).join("&")}var SG=/\{[^{}}]+\}/g;function UG(t){return t.replace(/(?:^\W+)|(?:(?r.concat(A),[]):[]}function Fp(t,e){let r={__proto__:null};for(let A of Object.keys(t))e.indexOf(A)===-1&&(r[A]=t[A]);return r}function Up(t){return t.split(/(%[0-9A-Fa-f]{2})/g).map(function(e){return/%[0-9A-Fa-f]/.test(e)||(e=encodeURI(e).replace(/%5B/g,"[").replace(/%5D/g,"]")),e}).join("")}function MA(t){return encodeURIComponent(t).replace(/[!'()*]/g,function(e){return"%"+e.charCodeAt(0).toString(16).toUpperCase()})}function Ys(t,e,r){return e=t==="+"||t==="#"?Up(e):MA(e),r?MA(r)+"="+e:e}function GA(t){return t!=null}function Wg(t){return t===";"||t==="&"||t==="?"}function GG(t,e,r,A){var s=t[r],o=[];if(GA(s)&&s!=="")if(typeof s=="string"||typeof s=="number"||typeof s=="boolean")s=s.toString(),A&&A!=="*"&&(s=s.substring(0,parseInt(A,10))),o.push(Ys(e,s,Wg(e)?r:""));else if(A==="*")Array.isArray(s)?s.filter(GA).forEach(function(n){o.push(Ys(e,n,Wg(e)?r:""))}):Object.keys(s).forEach(function(n){GA(s[n])&&o.push(Ys(e,s[n],n))});else{let n=[];Array.isArray(s)?s.filter(GA).forEach(function(i){n.push(Ys(e,i))}):Object.keys(s).forEach(function(i){GA(s[i])&&(n.push(MA(i)),n.push(Ys(e,s[i].toString())))}),Wg(e)?o.push(MA(r)+"="+n.join(",")):n.length!==0&&o.push(n.join(","))}else e===";"?GA(s)&&o.push(MA(r)):s===""&&(e==="&"||e==="?")?o.push(MA(r)+"="):s===""&&o.push("");return o}function MG(t){return{expand:LG.bind(null,t)}}function LG(t,e){var r=["+","#",".","/",";","?","&"];return t=t.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g,function(A,s,o){if(s){let i="",a=[];if(r.indexOf(s.charAt(0))!==-1&&(i=s.charAt(0),s=s.substr(1)),s.split(/,/g).forEach(function(c){var u=/([^:\*]*)(?::(\d+)|(\*))?/.exec(c);a.push(GG(e,i,u[1],u[2]||u[3]))}),i&&i!=="+"){var n=",";return i==="?"?n="&":i!=="#"&&(n=i),(a.length!==0?i:"")+a.join(n)}else return a.join(",")}else return Up(o)}),t==="/"?t:t.replace(/\/$/,"")}function Np(t){let e=t.method.toUpperCase(),r=(t.url||"/").replace(/:([a-z]\w+)/g,"{$1}"),A=Object.assign({},t.headers),s,o=Fp(t,["method","baseUrl","url","headers","request","mediaType"]),n=NG(r);r=MG(r).expand(o),/^http/.test(r)||(r=t.baseUrl+r);let i=Object.keys(t).filter(u=>n.includes(u)).concat("baseUrl"),a=Fp(o,i);if(!/application\/octet-stream/i.test(A.accept)&&(t.mediaType.format&&(A.accept=A.accept.split(/,/).map(u=>u.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/,`application/vnd$1$2.${t.mediaType.format}`)).join(",")),r.endsWith("/graphql")&&t.mediaType.previews?.length)){let u=A.accept.match(/(?{let E=t.mediaType.format?`.${t.mediaType.format}`:"+json";return`application/vnd.github.${g}-preview${E}`}).join(",")}return["GET","HEAD"].includes(e)?r=FG(r,a):"data"in a?s=a.data:Object.keys(a).length&&(s=a),!A["content-type"]&&typeof s<"u"&&(A["content-type"]="application/json; charset=utf-8"),["PATCH","PUT"].includes(e)&&typeof s>"u"&&(s=""),Object.assign({method:e,url:r,headers:A},typeof s<"u"?{body:s}:null,t.request?{request:t.request}:null)}function vG(t,e,r){return Np(zg(t,e,r))}function Gp(t,e){let r=zg(t,e),A=vG.bind(null,r);return Object.assign(A,{DEFAULTS:r,defaults:Gp.bind(null,r),merge:zg.bind(null,r),parse:Np})}var Mp=Gp(null,kG);var Op=Je(xp(),1);var _G="10.0.6",xG={headers:{"user-agent":`octokit-request.js/${_G} ${or()}`}};function YG(t){if(typeof t!="object"||t===null||Object.prototype.toString.call(t)!=="[object Object]")return!1;let e=Object.getPrototypeOf(t);if(e===null)return!0;let r=Object.prototype.hasOwnProperty.call(e,"constructor")&&e.constructor;return typeof r=="function"&&r instanceof r&&Function.prototype.call(r)===Function.prototype.call(t)}async function Yp(t){let e=t.request?.fetch||globalThis.fetch;if(!e)throw new Error("fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing");let r=t.request?.log||console,A=t.request?.parseSuccessResponseBody!==!1,s=YG(t.body)||Array.isArray(t.body)?JSON.stringify(t.body):t.body,o=Object.fromEntries(Object.entries(t.headers).map(([g,E])=>[g,String(E)])),n;try{n=await e(t.url,{method:t.method,body:s,redirect:t.request?.redirect,headers:o,signal:t.request?.signal,...t.body&&{duplex:"half"}})}catch(g){let E="Unknown Error";if(g instanceof Error){if(g.name==="AbortError")throw g.status=500,g;E=g.message,g.name==="TypeError"&&"cause"in g&&(g.cause instanceof Error?E=g.cause.message:typeof g.cause=="string"&&(E=g.cause))}let I=new Lt(E,500,{request:t});throw I.cause=g,I}let i=n.status,a=n.url,c={};for(let[g,E]of n.headers)c[g]=E;let u={url:a,status:i,headers:c,data:""};if("deprecation"in c){let g=c.link&&c.link.match(/<([^<>]+)>; rel="deprecation"/),E=g&&g.pop();r.warn(`[@octokit/request] "${t.method} ${t.url}" is deprecated. It is scheduled to be removed on ${c.sunset}${E?`. See ${E}`:""}`)}if(i===204||i===205)return u;if(t.method==="HEAD"){if(i<400)return u;throw new Lt(n.statusText,i,{response:u,request:t})}if(i===304)throw u.data=await Zg(n),new Lt("Not modified",i,{response:u,request:t});if(i>=400)throw u.data=await Zg(n),new Lt(JG(u.data),i,{response:u,request:t});return u.data=A?await Zg(n):n.body,u}async function Zg(t){let e=t.headers.get("content-type");if(!e)return t.text().catch(()=>"");let r=(0,Op.safeParse)(e);if(OG(r)){let A="";try{return A=await t.text(),JSON.parse(A)}catch{return A}}else return r.type.startsWith("text/")||r.parameters.charset?.toLowerCase()==="utf-8"?t.text().catch(()=>""):t.arrayBuffer().catch(()=>new ArrayBuffer(0))}function OG(t){return t.type==="application/json"||t.type==="application/scim+json"}function JG(t){if(typeof t=="string")return t;if(t instanceof ArrayBuffer)return"Unknown error";if("message"in t){let e="documentation_url"in t?` - ${t.documentation_url}`:"";return Array.isArray(t.errors)?`${t.message}: ${t.errors.map(r=>JSON.stringify(r)).join(", ")}${e}`:`${t.message}${e}`}return`Unknown error: ${JSON.stringify(t)}`}function Kg(t,e){let r=t.defaults(e);return Object.assign(function(s,o){let n=r.merge(s,o);if(!n.request||!n.request.hook)return Yp(r.parse(n));let i=(a,c)=>Yp(r.parse(r.merge(a,c)));return Object.assign(i,{endpoint:r,defaults:Kg.bind(null,r)}),n.request.hook(i,n)},{endpoint:r,defaults:Kg.bind(null,r)})}var Js=Kg(Mp,xG);var HG="0.0.0-development";function PG(t){return`Request failed due to following response errors: `+t.errors.map(e=>` - ${e.message}`).join(` -`)}var MG=class extends Error{constructor(t,e,r){super(GG(r)),this.request=t,this.headers=e,this.response=r,this.errors=r.errors,this.data=r.data,Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)}name="GraphqlResponseError";errors;data},LG=["method","baseUrl","url","headers","request","query","mediaType","operationName"],vG=["query","method","url"],Mp=/\/api\/v3\/?$/;function _G(t,e,r){if(r){if(typeof e=="string"&&"query"in r)return Promise.reject(new Error('[@octokit/graphql] "query" cannot be used as variable name'));for(let n in r)if(vG.includes(n))return Promise.reject(new Error(`[@octokit/graphql] "${n}" cannot be used as variable name`))}let A=typeof e=="string"?Object.assign({query:e},r):e,s=Object.keys(A).reduce((n,i)=>LG.includes(i)?(n[i]=A[i],n):(n.variables||(n.variables={}),n.variables[i]=A[i],n),{}),o=A.baseUrl||t.endpoint.DEFAULTS.baseUrl;return Mp.test(o)&&(s.url=o.replace(Mp,"/api/graphql")),t(s).then(n=>{if(n.data.errors){let i={};for(let a of Object.keys(n.headers))i[a]=n.headers[a];throw new MG(s,i,n.data)}return n.data.data})}function qg(t,e){let r=t.defaults(e);return Object.assign((s,o)=>_G(r,s,o),{defaults:qg.bind(null,r),endpoint:r.endpoint})}var O_=qg(xs,{headers:{"user-agent":`octokit-graphql.js/${NG} ${rr()}`},method:"POST",url:"/graphql"});function Lp(t){return qg(t,{method:"POST",url:"/graphql"})}var Wg="(?:[a-zA-Z0-9_-]+)",vp="\\.",_p=new RegExp(`^${Wg}${vp}${Wg}${vp}${Wg}$`),xG=_p.test.bind(_p);async function YG(t){let e=xG(t),r=t.startsWith("v1.")||t.startsWith("ghs_"),A=t.startsWith("ghu_");return{type:"token",token:t,tokenType:e?"app":r?"installation":A?"user-to-server":"oauth"}}function JG(t){return t.split(/\./).length===3?`bearer ${t}`:`token ${t}`}async function OG(t,e,r,A){let s=e.endpoint.merge(r,A);return s.headers.authorization=JG(t),e(s)}var xp=function(e){if(!e)throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");if(typeof e!="string")throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string");return e=e.replace(/^(token|bearer) +/i,""),Object.assign(YG.bind(null,e),{hook:OG.bind(null,e)})};var zg="7.0.6";var Yp=()=>{},HG=console.warn.bind(console),PG=console.error.bind(console);function VG(t={}){return typeof t.debug!="function"&&(t.debug=Yp),typeof t.info!="function"&&(t.info=Yp),typeof t.warn!="function"&&(t.warn=HG),typeof t.error!="function"&&(t.error=PG),t}var Jp=`octokit-core.js/${zg} ${rr()}`,Zn=class{static VERSION=zg;static defaults(e){return class extends this{constructor(...A){let s=A[0]||{};if(typeof e=="function"){super(e(s));return}super(Object.assign({},e,s,s.userAgent&&e.userAgent?{userAgent:`${s.userAgent} ${e.userAgent}`}:null))}}}static plugins=[];static plugin(...e){let r=this.plugins;return class extends this{static plugins=r.concat(e.filter(s=>!r.includes(s)))}}constructor(e={}){let r=new fp.Collection,A={baseUrl:xs.endpoint.DEFAULTS.baseUrl,headers:{},request:Object.assign({},e.request,{hook:r.bind(null,"request")}),mediaType:{previews:[],format:""}};if(A.headers["user-agent"]=e.userAgent?`${e.userAgent} ${Jp}`:Jp,e.baseUrl&&(A.baseUrl=e.baseUrl),e.previews&&(A.mediaType.previews=e.previews),e.timeZone&&(A.headers["time-zone"]=e.timeZone),this.request=xs.defaults(A),this.graphql=Lp(this.request).defaults(A),this.log=VG(e.log),this.hook=r,e.authStrategy){let{authStrategy:o,...n}=e,i=o(Object.assign({request:this.request,log:this.log,octokit:this,octokitOptions:n},e.auth));r.wrap("request",i.hook),this.auth=i}else if(!e.auth)this.auth=async()=>({type:"unauthenticated"});else{let o=xp(e.auth);r.wrap("request",o.hook),this.auth=o}let s=this.constructor;for(let o=0;o{t.log.debug("request",r);let A=Date.now(),s=t.request.endpoint.parse(r),o=s.url.replace(r.baseUrl,"");return e(r).then(n=>{let i=n.headers["x-github-request-id"];return t.log.info(`${s.method} ${o} - ${n.status} with id ${i} in ${Date.now()-A}ms`),n}).catch(n=>{let i=n.response?.headers["x-github-request-id"]||"UNKNOWN";throw t.log.error(`${s.method} ${o} - ${n.status} with id ${i} in ${Date.now()-A}ms`),n})})}Zg.VERSION=Op;var qG="0.0.0-development";function WG(t){if(!t.data)return{...t,data:[]};if(!(("total_count"in t.data||"total_commits"in t.data)&&!("url"in t.data)))return t;let r=t.data.incomplete_results,A=t.data.repository_selection,s=t.data.total_count,o=t.data.total_commits;delete t.data.incomplete_results,delete t.data.repository_selection,delete t.data.total_count,delete t.data.total_commits;let n=Object.keys(t.data)[0],i=t.data[n];return t.data=i,typeof r<"u"&&(t.data.incomplete_results=r),typeof A<"u"&&(t.data.repository_selection=A),t.data.total_count=s,t.data.total_commits=o,t}function Kg(t,e,r){let A=typeof e=="function"?e.endpoint(r):t.request.endpoint(e,r),s=typeof e=="function"?e:t.request,o=A.method,n=A.headers,i=A.url;return{[Symbol.asyncIterator]:()=>({async next(){if(!i)return{done:!0};try{let a=await s({method:o,url:i,headers:n}),c=WG(a);if(i=((c.headers.link||"").match(/<([^<>]+)>;\s*rel="next"/)||[])[1],!i&&"total_commits"in c.data){let l=new URL(c.url),g=l.searchParams,E=parseInt(g.get("page")||"1",10),d=parseInt(g.get("per_page")||"250",10);E*d{if(s.done)return e;let o=!1;function n(){o=!0}return e=e.concat(A?A(s.value,n):s.value.data),o?e:Pp(t,e,r,A)})}var ox=Object.assign(Hp,{iterator:Kg});function jg(t){return{paginate:Object.assign(Hp.bind(null,t),{iterator:Kg.bind(null,t)})}}jg.VERSION=qG;var Xg="17.0.0";var zG={actions:{addCustomLabelsToSelfHostedRunnerForOrg:["POST /orgs/{org}/actions/runners/{runner_id}/labels"],addCustomLabelsToSelfHostedRunnerForRepo:["POST /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],addRepoAccessToSelfHostedRunnerGroupInOrg:["PUT /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories/{repository_id}"],addSelectedRepoToOrgSecret:["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],addSelectedRepoToOrgVariable:["PUT /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"],approveWorkflowRun:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve"],cancelWorkflowRun:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"],createEnvironmentVariable:["POST /repos/{owner}/{repo}/environments/{environment_name}/variables"],createHostedRunnerForOrg:["POST /orgs/{org}/actions/hosted-runners"],createOrUpdateEnvironmentSecret:["PUT /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"],createOrUpdateOrgSecret:["PUT /orgs/{org}/actions/secrets/{secret_name}"],createOrUpdateRepoSecret:["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"],createOrgVariable:["POST /orgs/{org}/actions/variables"],createRegistrationTokenForOrg:["POST /orgs/{org}/actions/runners/registration-token"],createRegistrationTokenForRepo:["POST /repos/{owner}/{repo}/actions/runners/registration-token"],createRemoveTokenForOrg:["POST /orgs/{org}/actions/runners/remove-token"],createRemoveTokenForRepo:["POST /repos/{owner}/{repo}/actions/runners/remove-token"],createRepoVariable:["POST /repos/{owner}/{repo}/actions/variables"],createWorkflowDispatch:["POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"],deleteActionsCacheById:["DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}"],deleteActionsCacheByKey:["DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}"],deleteArtifact:["DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],deleteCustomImageFromOrg:["DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}"],deleteCustomImageVersionFromOrg:["DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}"],deleteEnvironmentSecret:["DELETE /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"],deleteEnvironmentVariable:["DELETE /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"],deleteHostedRunnerForOrg:["DELETE /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"],deleteOrgSecret:["DELETE /orgs/{org}/actions/secrets/{secret_name}"],deleteOrgVariable:["DELETE /orgs/{org}/actions/variables/{name}"],deleteRepoSecret:["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"],deleteRepoVariable:["DELETE /repos/{owner}/{repo}/actions/variables/{name}"],deleteSelfHostedRunnerFromOrg:["DELETE /orgs/{org}/actions/runners/{runner_id}"],deleteSelfHostedRunnerFromRepo:["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"],deleteWorkflowRun:["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"],deleteWorkflowRunLogs:["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],disableSelectedRepositoryGithubActionsOrganization:["DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"],disableWorkflow:["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"],downloadArtifact:["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"],downloadJobLogsForWorkflowRun:["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"],downloadWorkflowRunAttemptLogs:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs"],downloadWorkflowRunLogs:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],enableSelectedRepositoryGithubActionsOrganization:["PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"],enableWorkflow:["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"],forceCancelWorkflowRun:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/force-cancel"],generateRunnerJitconfigForOrg:["POST /orgs/{org}/actions/runners/generate-jitconfig"],generateRunnerJitconfigForRepo:["POST /repos/{owner}/{repo}/actions/runners/generate-jitconfig"],getActionsCacheList:["GET /repos/{owner}/{repo}/actions/caches"],getActionsCacheUsage:["GET /repos/{owner}/{repo}/actions/cache/usage"],getActionsCacheUsageByRepoForOrg:["GET /orgs/{org}/actions/cache/usage-by-repository"],getActionsCacheUsageForOrg:["GET /orgs/{org}/actions/cache/usage"],getAllowedActionsOrganization:["GET /orgs/{org}/actions/permissions/selected-actions"],getAllowedActionsRepository:["GET /repos/{owner}/{repo}/actions/permissions/selected-actions"],getArtifact:["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],getCustomImageForOrg:["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}"],getCustomImageVersionForOrg:["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}"],getCustomOidcSubClaimForRepo:["GET /repos/{owner}/{repo}/actions/oidc/customization/sub"],getEnvironmentPublicKey:["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/public-key"],getEnvironmentSecret:["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"],getEnvironmentVariable:["GET /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"],getGithubActionsDefaultWorkflowPermissionsOrganization:["GET /orgs/{org}/actions/permissions/workflow"],getGithubActionsDefaultWorkflowPermissionsRepository:["GET /repos/{owner}/{repo}/actions/permissions/workflow"],getGithubActionsPermissionsOrganization:["GET /orgs/{org}/actions/permissions"],getGithubActionsPermissionsRepository:["GET /repos/{owner}/{repo}/actions/permissions"],getHostedRunnerForOrg:["GET /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"],getHostedRunnersGithubOwnedImagesForOrg:["GET /orgs/{org}/actions/hosted-runners/images/github-owned"],getHostedRunnersLimitsForOrg:["GET /orgs/{org}/actions/hosted-runners/limits"],getHostedRunnersMachineSpecsForOrg:["GET /orgs/{org}/actions/hosted-runners/machine-sizes"],getHostedRunnersPartnerImagesForOrg:["GET /orgs/{org}/actions/hosted-runners/images/partner"],getHostedRunnersPlatformsForOrg:["GET /orgs/{org}/actions/hosted-runners/platforms"],getJobForWorkflowRun:["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"],getOrgPublicKey:["GET /orgs/{org}/actions/secrets/public-key"],getOrgSecret:["GET /orgs/{org}/actions/secrets/{secret_name}"],getOrgVariable:["GET /orgs/{org}/actions/variables/{name}"],getPendingDeploymentsForRun:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"],getRepoPermissions:["GET /repos/{owner}/{repo}/actions/permissions",{},{renamed:["actions","getGithubActionsPermissionsRepository"]}],getRepoPublicKey:["GET /repos/{owner}/{repo}/actions/secrets/public-key"],getRepoSecret:["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"],getRepoVariable:["GET /repos/{owner}/{repo}/actions/variables/{name}"],getReviewsForRun:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/approvals"],getSelfHostedRunnerForOrg:["GET /orgs/{org}/actions/runners/{runner_id}"],getSelfHostedRunnerForRepo:["GET /repos/{owner}/{repo}/actions/runners/{runner_id}"],getWorkflow:["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"],getWorkflowAccessToRepository:["GET /repos/{owner}/{repo}/actions/permissions/access"],getWorkflowRun:["GET /repos/{owner}/{repo}/actions/runs/{run_id}"],getWorkflowRunAttempt:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}"],getWorkflowRunUsage:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"],getWorkflowUsage:["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"],listArtifactsForRepo:["GET /repos/{owner}/{repo}/actions/artifacts"],listCustomImageVersionsForOrg:["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions"],listCustomImagesForOrg:["GET /orgs/{org}/actions/hosted-runners/images/custom"],listEnvironmentSecrets:["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets"],listEnvironmentVariables:["GET /repos/{owner}/{repo}/environments/{environment_name}/variables"],listGithubHostedRunnersInGroupForOrg:["GET /orgs/{org}/actions/runner-groups/{runner_group_id}/hosted-runners"],listHostedRunnersForOrg:["GET /orgs/{org}/actions/hosted-runners"],listJobsForWorkflowRun:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"],listJobsForWorkflowRunAttempt:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs"],listLabelsForSelfHostedRunnerForOrg:["GET /orgs/{org}/actions/runners/{runner_id}/labels"],listLabelsForSelfHostedRunnerForRepo:["GET /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],listOrgSecrets:["GET /orgs/{org}/actions/secrets"],listOrgVariables:["GET /orgs/{org}/actions/variables"],listRepoOrganizationSecrets:["GET /repos/{owner}/{repo}/actions/organization-secrets"],listRepoOrganizationVariables:["GET /repos/{owner}/{repo}/actions/organization-variables"],listRepoSecrets:["GET /repos/{owner}/{repo}/actions/secrets"],listRepoVariables:["GET /repos/{owner}/{repo}/actions/variables"],listRepoWorkflows:["GET /repos/{owner}/{repo}/actions/workflows"],listRunnerApplicationsForOrg:["GET /orgs/{org}/actions/runners/downloads"],listRunnerApplicationsForRepo:["GET /repos/{owner}/{repo}/actions/runners/downloads"],listSelectedReposForOrgSecret:["GET /orgs/{org}/actions/secrets/{secret_name}/repositories"],listSelectedReposForOrgVariable:["GET /orgs/{org}/actions/variables/{name}/repositories"],listSelectedRepositoriesEnabledGithubActionsOrganization:["GET /orgs/{org}/actions/permissions/repositories"],listSelfHostedRunnersForOrg:["GET /orgs/{org}/actions/runners"],listSelfHostedRunnersForRepo:["GET /repos/{owner}/{repo}/actions/runners"],listWorkflowRunArtifacts:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"],listWorkflowRuns:["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"],listWorkflowRunsForRepo:["GET /repos/{owner}/{repo}/actions/runs"],reRunJobForWorkflowRun:["POST /repos/{owner}/{repo}/actions/jobs/{job_id}/rerun"],reRunWorkflow:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"],reRunWorkflowFailedJobs:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs"],removeAllCustomLabelsFromSelfHostedRunnerForOrg:["DELETE /orgs/{org}/actions/runners/{runner_id}/labels"],removeAllCustomLabelsFromSelfHostedRunnerForRepo:["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],removeCustomLabelFromSelfHostedRunnerForOrg:["DELETE /orgs/{org}/actions/runners/{runner_id}/labels/{name}"],removeCustomLabelFromSelfHostedRunnerForRepo:["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels/{name}"],removeSelectedRepoFromOrgSecret:["DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],removeSelectedRepoFromOrgVariable:["DELETE /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"],reviewCustomGatesForRun:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/deployment_protection_rule"],reviewPendingDeploymentsForRun:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"],setAllowedActionsOrganization:["PUT /orgs/{org}/actions/permissions/selected-actions"],setAllowedActionsRepository:["PUT /repos/{owner}/{repo}/actions/permissions/selected-actions"],setCustomLabelsForSelfHostedRunnerForOrg:["PUT /orgs/{org}/actions/runners/{runner_id}/labels"],setCustomLabelsForSelfHostedRunnerForRepo:["PUT /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],setCustomOidcSubClaimForRepo:["PUT /repos/{owner}/{repo}/actions/oidc/customization/sub"],setGithubActionsDefaultWorkflowPermissionsOrganization:["PUT /orgs/{org}/actions/permissions/workflow"],setGithubActionsDefaultWorkflowPermissionsRepository:["PUT /repos/{owner}/{repo}/actions/permissions/workflow"],setGithubActionsPermissionsOrganization:["PUT /orgs/{org}/actions/permissions"],setGithubActionsPermissionsRepository:["PUT /repos/{owner}/{repo}/actions/permissions"],setSelectedReposForOrgSecret:["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"],setSelectedReposForOrgVariable:["PUT /orgs/{org}/actions/variables/{name}/repositories"],setSelectedRepositoriesEnabledGithubActionsOrganization:["PUT /orgs/{org}/actions/permissions/repositories"],setWorkflowAccessToRepository:["PUT /repos/{owner}/{repo}/actions/permissions/access"],updateEnvironmentVariable:["PATCH /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"],updateHostedRunnerForOrg:["PATCH /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"],updateOrgVariable:["PATCH /orgs/{org}/actions/variables/{name}"],updateRepoVariable:["PATCH /repos/{owner}/{repo}/actions/variables/{name}"]},activity:{checkRepoIsStarredByAuthenticatedUser:["GET /user/starred/{owner}/{repo}"],deleteRepoSubscription:["DELETE /repos/{owner}/{repo}/subscription"],deleteThreadSubscription:["DELETE /notifications/threads/{thread_id}/subscription"],getFeeds:["GET /feeds"],getRepoSubscription:["GET /repos/{owner}/{repo}/subscription"],getThread:["GET /notifications/threads/{thread_id}"],getThreadSubscriptionForAuthenticatedUser:["GET /notifications/threads/{thread_id}/subscription"],listEventsForAuthenticatedUser:["GET /users/{username}/events"],listNotificationsForAuthenticatedUser:["GET /notifications"],listOrgEventsForAuthenticatedUser:["GET /users/{username}/events/orgs/{org}"],listPublicEvents:["GET /events"],listPublicEventsForRepoNetwork:["GET /networks/{owner}/{repo}/events"],listPublicEventsForUser:["GET /users/{username}/events/public"],listPublicOrgEvents:["GET /orgs/{org}/events"],listReceivedEventsForUser:["GET /users/{username}/received_events"],listReceivedPublicEventsForUser:["GET /users/{username}/received_events/public"],listRepoEvents:["GET /repos/{owner}/{repo}/events"],listRepoNotificationsForAuthenticatedUser:["GET /repos/{owner}/{repo}/notifications"],listReposStarredByAuthenticatedUser:["GET /user/starred"],listReposStarredByUser:["GET /users/{username}/starred"],listReposWatchedByUser:["GET /users/{username}/subscriptions"],listStargazersForRepo:["GET /repos/{owner}/{repo}/stargazers"],listWatchedReposForAuthenticatedUser:["GET /user/subscriptions"],listWatchersForRepo:["GET /repos/{owner}/{repo}/subscribers"],markNotificationsAsRead:["PUT /notifications"],markRepoNotificationsAsRead:["PUT /repos/{owner}/{repo}/notifications"],markThreadAsDone:["DELETE /notifications/threads/{thread_id}"],markThreadAsRead:["PATCH /notifications/threads/{thread_id}"],setRepoSubscription:["PUT /repos/{owner}/{repo}/subscription"],setThreadSubscription:["PUT /notifications/threads/{thread_id}/subscription"],starRepoForAuthenticatedUser:["PUT /user/starred/{owner}/{repo}"],unstarRepoForAuthenticatedUser:["DELETE /user/starred/{owner}/{repo}"]},apps:{addRepoToInstallation:["PUT /user/installations/{installation_id}/repositories/{repository_id}",{},{renamed:["apps","addRepoToInstallationForAuthenticatedUser"]}],addRepoToInstallationForAuthenticatedUser:["PUT /user/installations/{installation_id}/repositories/{repository_id}"],checkToken:["POST /applications/{client_id}/token"],createFromManifest:["POST /app-manifests/{code}/conversions"],createInstallationAccessToken:["POST /app/installations/{installation_id}/access_tokens"],deleteAuthorization:["DELETE /applications/{client_id}/grant"],deleteInstallation:["DELETE /app/installations/{installation_id}"],deleteToken:["DELETE /applications/{client_id}/token"],getAuthenticated:["GET /app"],getBySlug:["GET /apps/{app_slug}"],getInstallation:["GET /app/installations/{installation_id}"],getOrgInstallation:["GET /orgs/{org}/installation"],getRepoInstallation:["GET /repos/{owner}/{repo}/installation"],getSubscriptionPlanForAccount:["GET /marketplace_listing/accounts/{account_id}"],getSubscriptionPlanForAccountStubbed:["GET /marketplace_listing/stubbed/accounts/{account_id}"],getUserInstallation:["GET /users/{username}/installation"],getWebhookConfigForApp:["GET /app/hook/config"],getWebhookDelivery:["GET /app/hook/deliveries/{delivery_id}"],listAccountsForPlan:["GET /marketplace_listing/plans/{plan_id}/accounts"],listAccountsForPlanStubbed:["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"],listInstallationReposForAuthenticatedUser:["GET /user/installations/{installation_id}/repositories"],listInstallationRequestsForAuthenticatedApp:["GET /app/installation-requests"],listInstallations:["GET /app/installations"],listInstallationsForAuthenticatedUser:["GET /user/installations"],listPlans:["GET /marketplace_listing/plans"],listPlansStubbed:["GET /marketplace_listing/stubbed/plans"],listReposAccessibleToInstallation:["GET /installation/repositories"],listSubscriptionsForAuthenticatedUser:["GET /user/marketplace_purchases"],listSubscriptionsForAuthenticatedUserStubbed:["GET /user/marketplace_purchases/stubbed"],listWebhookDeliveries:["GET /app/hook/deliveries"],redeliverWebhookDelivery:["POST /app/hook/deliveries/{delivery_id}/attempts"],removeRepoFromInstallation:["DELETE /user/installations/{installation_id}/repositories/{repository_id}",{},{renamed:["apps","removeRepoFromInstallationForAuthenticatedUser"]}],removeRepoFromInstallationForAuthenticatedUser:["DELETE /user/installations/{installation_id}/repositories/{repository_id}"],resetToken:["PATCH /applications/{client_id}/token"],revokeInstallationAccessToken:["DELETE /installation/token"],scopeToken:["POST /applications/{client_id}/token/scoped"],suspendInstallation:["PUT /app/installations/{installation_id}/suspended"],unsuspendInstallation:["DELETE /app/installations/{installation_id}/suspended"],updateWebhookConfigForApp:["PATCH /app/hook/config"]},billing:{getGithubActionsBillingOrg:["GET /orgs/{org}/settings/billing/actions"],getGithubActionsBillingUser:["GET /users/{username}/settings/billing/actions"],getGithubBillingPremiumRequestUsageReportOrg:["GET /organizations/{org}/settings/billing/premium_request/usage"],getGithubBillingPremiumRequestUsageReportUser:["GET /users/{username}/settings/billing/premium_request/usage"],getGithubBillingUsageReportOrg:["GET /organizations/{org}/settings/billing/usage"],getGithubBillingUsageReportUser:["GET /users/{username}/settings/billing/usage"],getGithubPackagesBillingOrg:["GET /orgs/{org}/settings/billing/packages"],getGithubPackagesBillingUser:["GET /users/{username}/settings/billing/packages"],getSharedStorageBillingOrg:["GET /orgs/{org}/settings/billing/shared-storage"],getSharedStorageBillingUser:["GET /users/{username}/settings/billing/shared-storage"]},campaigns:{createCampaign:["POST /orgs/{org}/campaigns"],deleteCampaign:["DELETE /orgs/{org}/campaigns/{campaign_number}"],getCampaignSummary:["GET /orgs/{org}/campaigns/{campaign_number}"],listOrgCampaigns:["GET /orgs/{org}/campaigns"],updateCampaign:["PATCH /orgs/{org}/campaigns/{campaign_number}"]},checks:{create:["POST /repos/{owner}/{repo}/check-runs"],createSuite:["POST /repos/{owner}/{repo}/check-suites"],get:["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"],getSuite:["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"],listAnnotations:["GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations"],listForRef:["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"],listForSuite:["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs"],listSuitesForRef:["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"],rerequestRun:["POST /repos/{owner}/{repo}/check-runs/{check_run_id}/rerequest"],rerequestSuite:["POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest"],setSuitesPreferences:["PATCH /repos/{owner}/{repo}/check-suites/preferences"],update:["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"]},codeScanning:{commitAutofix:["POST /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix/commits"],createAutofix:["POST /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix"],createVariantAnalysis:["POST /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses"],deleteAnalysis:["DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}{?confirm_delete}"],deleteCodeqlDatabase:["DELETE /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"],getAlert:["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}",{},{renamedParameters:{alert_id:"alert_number"}}],getAnalysis:["GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}"],getAutofix:["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix"],getCodeqlDatabase:["GET /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"],getDefaultSetup:["GET /repos/{owner}/{repo}/code-scanning/default-setup"],getSarif:["GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}"],getVariantAnalysis:["GET /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses/{codeql_variant_analysis_id}"],getVariantAnalysisRepoTask:["GET /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses/{codeql_variant_analysis_id}/repos/{repo_owner}/{repo_name}"],listAlertInstances:["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances"],listAlertsForOrg:["GET /orgs/{org}/code-scanning/alerts"],listAlertsForRepo:["GET /repos/{owner}/{repo}/code-scanning/alerts"],listAlertsInstances:["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances",{},{renamed:["codeScanning","listAlertInstances"]}],listCodeqlDatabases:["GET /repos/{owner}/{repo}/code-scanning/codeql/databases"],listRecentAnalyses:["GET /repos/{owner}/{repo}/code-scanning/analyses"],updateAlert:["PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"],updateDefaultSetup:["PATCH /repos/{owner}/{repo}/code-scanning/default-setup"],uploadSarif:["POST /repos/{owner}/{repo}/code-scanning/sarifs"]},codeSecurity:{attachConfiguration:["POST /orgs/{org}/code-security/configurations/{configuration_id}/attach"],attachEnterpriseConfiguration:["POST /enterprises/{enterprise}/code-security/configurations/{configuration_id}/attach"],createConfiguration:["POST /orgs/{org}/code-security/configurations"],createConfigurationForEnterprise:["POST /enterprises/{enterprise}/code-security/configurations"],deleteConfiguration:["DELETE /orgs/{org}/code-security/configurations/{configuration_id}"],deleteConfigurationForEnterprise:["DELETE /enterprises/{enterprise}/code-security/configurations/{configuration_id}"],detachConfiguration:["DELETE /orgs/{org}/code-security/configurations/detach"],getConfiguration:["GET /orgs/{org}/code-security/configurations/{configuration_id}"],getConfigurationForRepository:["GET /repos/{owner}/{repo}/code-security-configuration"],getConfigurationsForEnterprise:["GET /enterprises/{enterprise}/code-security/configurations"],getConfigurationsForOrg:["GET /orgs/{org}/code-security/configurations"],getDefaultConfigurations:["GET /orgs/{org}/code-security/configurations/defaults"],getDefaultConfigurationsForEnterprise:["GET /enterprises/{enterprise}/code-security/configurations/defaults"],getRepositoriesForConfiguration:["GET /orgs/{org}/code-security/configurations/{configuration_id}/repositories"],getRepositoriesForEnterpriseConfiguration:["GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}/repositories"],getSingleConfigurationForEnterprise:["GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}"],setConfigurationAsDefault:["PUT /orgs/{org}/code-security/configurations/{configuration_id}/defaults"],setConfigurationAsDefaultForEnterprise:["PUT /enterprises/{enterprise}/code-security/configurations/{configuration_id}/defaults"],updateConfiguration:["PATCH /orgs/{org}/code-security/configurations/{configuration_id}"],updateEnterpriseConfiguration:["PATCH /enterprises/{enterprise}/code-security/configurations/{configuration_id}"]},codesOfConduct:{getAllCodesOfConduct:["GET /codes_of_conduct"],getConductCode:["GET /codes_of_conduct/{key}"]},codespaces:{addRepositoryForSecretForAuthenticatedUser:["PUT /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"],addSelectedRepoToOrgSecret:["PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"],checkPermissionsForDevcontainer:["GET /repos/{owner}/{repo}/codespaces/permissions_check"],codespaceMachinesForAuthenticatedUser:["GET /user/codespaces/{codespace_name}/machines"],createForAuthenticatedUser:["POST /user/codespaces"],createOrUpdateOrgSecret:["PUT /orgs/{org}/codespaces/secrets/{secret_name}"],createOrUpdateRepoSecret:["PUT /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"],createOrUpdateSecretForAuthenticatedUser:["PUT /user/codespaces/secrets/{secret_name}"],createWithPrForAuthenticatedUser:["POST /repos/{owner}/{repo}/pulls/{pull_number}/codespaces"],createWithRepoForAuthenticatedUser:["POST /repos/{owner}/{repo}/codespaces"],deleteForAuthenticatedUser:["DELETE /user/codespaces/{codespace_name}"],deleteFromOrganization:["DELETE /orgs/{org}/members/{username}/codespaces/{codespace_name}"],deleteOrgSecret:["DELETE /orgs/{org}/codespaces/secrets/{secret_name}"],deleteRepoSecret:["DELETE /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"],deleteSecretForAuthenticatedUser:["DELETE /user/codespaces/secrets/{secret_name}"],exportForAuthenticatedUser:["POST /user/codespaces/{codespace_name}/exports"],getCodespacesForUserInOrg:["GET /orgs/{org}/members/{username}/codespaces"],getExportDetailsForAuthenticatedUser:["GET /user/codespaces/{codespace_name}/exports/{export_id}"],getForAuthenticatedUser:["GET /user/codespaces/{codespace_name}"],getOrgPublicKey:["GET /orgs/{org}/codespaces/secrets/public-key"],getOrgSecret:["GET /orgs/{org}/codespaces/secrets/{secret_name}"],getPublicKeyForAuthenticatedUser:["GET /user/codespaces/secrets/public-key"],getRepoPublicKey:["GET /repos/{owner}/{repo}/codespaces/secrets/public-key"],getRepoSecret:["GET /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"],getSecretForAuthenticatedUser:["GET /user/codespaces/secrets/{secret_name}"],listDevcontainersInRepositoryForAuthenticatedUser:["GET /repos/{owner}/{repo}/codespaces/devcontainers"],listForAuthenticatedUser:["GET /user/codespaces"],listInOrganization:["GET /orgs/{org}/codespaces",{},{renamedParameters:{org_id:"org"}}],listInRepositoryForAuthenticatedUser:["GET /repos/{owner}/{repo}/codespaces"],listOrgSecrets:["GET /orgs/{org}/codespaces/secrets"],listRepoSecrets:["GET /repos/{owner}/{repo}/codespaces/secrets"],listRepositoriesForSecretForAuthenticatedUser:["GET /user/codespaces/secrets/{secret_name}/repositories"],listSecretsForAuthenticatedUser:["GET /user/codespaces/secrets"],listSelectedReposForOrgSecret:["GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories"],preFlightWithRepoForAuthenticatedUser:["GET /repos/{owner}/{repo}/codespaces/new"],publishForAuthenticatedUser:["POST /user/codespaces/{codespace_name}/publish"],removeRepositoryForSecretForAuthenticatedUser:["DELETE /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"],removeSelectedRepoFromOrgSecret:["DELETE /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"],repoMachinesForAuthenticatedUser:["GET /repos/{owner}/{repo}/codespaces/machines"],setRepositoriesForSecretForAuthenticatedUser:["PUT /user/codespaces/secrets/{secret_name}/repositories"],setSelectedReposForOrgSecret:["PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories"],startForAuthenticatedUser:["POST /user/codespaces/{codespace_name}/start"],stopForAuthenticatedUser:["POST /user/codespaces/{codespace_name}/stop"],stopInOrganization:["POST /orgs/{org}/members/{username}/codespaces/{codespace_name}/stop"],updateForAuthenticatedUser:["PATCH /user/codespaces/{codespace_name}"]},copilot:{addCopilotSeatsForTeams:["POST /orgs/{org}/copilot/billing/selected_teams"],addCopilotSeatsForUsers:["POST /orgs/{org}/copilot/billing/selected_users"],cancelCopilotSeatAssignmentForTeams:["DELETE /orgs/{org}/copilot/billing/selected_teams"],cancelCopilotSeatAssignmentForUsers:["DELETE /orgs/{org}/copilot/billing/selected_users"],copilotMetricsForOrganization:["GET /orgs/{org}/copilot/metrics"],copilotMetricsForTeam:["GET /orgs/{org}/team/{team_slug}/copilot/metrics"],getCopilotOrganizationDetails:["GET /orgs/{org}/copilot/billing"],getCopilotSeatDetailsForUser:["GET /orgs/{org}/members/{username}/copilot"],listCopilotSeats:["GET /orgs/{org}/copilot/billing/seats"]},credentials:{revoke:["POST /credentials/revoke"]},dependabot:{addSelectedRepoToOrgSecret:["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"],createOrUpdateOrgSecret:["PUT /orgs/{org}/dependabot/secrets/{secret_name}"],createOrUpdateRepoSecret:["PUT /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"],deleteOrgSecret:["DELETE /orgs/{org}/dependabot/secrets/{secret_name}"],deleteRepoSecret:["DELETE /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"],getAlert:["GET /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"],getOrgPublicKey:["GET /orgs/{org}/dependabot/secrets/public-key"],getOrgSecret:["GET /orgs/{org}/dependabot/secrets/{secret_name}"],getRepoPublicKey:["GET /repos/{owner}/{repo}/dependabot/secrets/public-key"],getRepoSecret:["GET /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"],listAlertsForEnterprise:["GET /enterprises/{enterprise}/dependabot/alerts"],listAlertsForOrg:["GET /orgs/{org}/dependabot/alerts"],listAlertsForRepo:["GET /repos/{owner}/{repo}/dependabot/alerts"],listOrgSecrets:["GET /orgs/{org}/dependabot/secrets"],listRepoSecrets:["GET /repos/{owner}/{repo}/dependabot/secrets"],listSelectedReposForOrgSecret:["GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories"],removeSelectedRepoFromOrgSecret:["DELETE /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"],repositoryAccessForOrg:["GET /organizations/{org}/dependabot/repository-access"],setRepositoryAccessDefaultLevel:["PUT /organizations/{org}/dependabot/repository-access/default-level"],setSelectedReposForOrgSecret:["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories"],updateAlert:["PATCH /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"],updateRepositoryAccessForOrg:["PATCH /organizations/{org}/dependabot/repository-access"]},dependencyGraph:{createRepositorySnapshot:["POST /repos/{owner}/{repo}/dependency-graph/snapshots"],diffRange:["GET /repos/{owner}/{repo}/dependency-graph/compare/{basehead}"],exportSbom:["GET /repos/{owner}/{repo}/dependency-graph/sbom"]},emojis:{get:["GET /emojis"]},enterpriseTeamMemberships:{add:["PUT /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"],bulkAdd:["POST /enterprises/{enterprise}/teams/{enterprise-team}/memberships/add"],bulkRemove:["POST /enterprises/{enterprise}/teams/{enterprise-team}/memberships/remove"],get:["GET /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"],list:["GET /enterprises/{enterprise}/teams/{enterprise-team}/memberships"],remove:["DELETE /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"]},enterpriseTeamOrganizations:{add:["PUT /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"],bulkAdd:["POST /enterprises/{enterprise}/teams/{enterprise-team}/organizations/add"],bulkRemove:["POST /enterprises/{enterprise}/teams/{enterprise-team}/organizations/remove"],delete:["DELETE /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"],getAssignment:["GET /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"],getAssignments:["GET /enterprises/{enterprise}/teams/{enterprise-team}/organizations"]},enterpriseTeams:{create:["POST /enterprises/{enterprise}/teams"],delete:["DELETE /enterprises/{enterprise}/teams/{team_slug}"],get:["GET /enterprises/{enterprise}/teams/{team_slug}"],list:["GET /enterprises/{enterprise}/teams"],update:["PATCH /enterprises/{enterprise}/teams/{team_slug}"]},gists:{checkIsStarred:["GET /gists/{gist_id}/star"],create:["POST /gists"],createComment:["POST /gists/{gist_id}/comments"],delete:["DELETE /gists/{gist_id}"],deleteComment:["DELETE /gists/{gist_id}/comments/{comment_id}"],fork:["POST /gists/{gist_id}/forks"],get:["GET /gists/{gist_id}"],getComment:["GET /gists/{gist_id}/comments/{comment_id}"],getRevision:["GET /gists/{gist_id}/{sha}"],list:["GET /gists"],listComments:["GET /gists/{gist_id}/comments"],listCommits:["GET /gists/{gist_id}/commits"],listForUser:["GET /users/{username}/gists"],listForks:["GET /gists/{gist_id}/forks"],listPublic:["GET /gists/public"],listStarred:["GET /gists/starred"],star:["PUT /gists/{gist_id}/star"],unstar:["DELETE /gists/{gist_id}/star"],update:["PATCH /gists/{gist_id}"],updateComment:["PATCH /gists/{gist_id}/comments/{comment_id}"]},git:{createBlob:["POST /repos/{owner}/{repo}/git/blobs"],createCommit:["POST /repos/{owner}/{repo}/git/commits"],createRef:["POST /repos/{owner}/{repo}/git/refs"],createTag:["POST /repos/{owner}/{repo}/git/tags"],createTree:["POST /repos/{owner}/{repo}/git/trees"],deleteRef:["DELETE /repos/{owner}/{repo}/git/refs/{ref}"],getBlob:["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"],getCommit:["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"],getRef:["GET /repos/{owner}/{repo}/git/ref/{ref}"],getTag:["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"],getTree:["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"],listMatchingRefs:["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"],updateRef:["PATCH /repos/{owner}/{repo}/git/refs/{ref}"]},gitignore:{getAllTemplates:["GET /gitignore/templates"],getTemplate:["GET /gitignore/templates/{name}"]},hostedCompute:{createNetworkConfigurationForOrg:["POST /orgs/{org}/settings/network-configurations"],deleteNetworkConfigurationFromOrg:["DELETE /orgs/{org}/settings/network-configurations/{network_configuration_id}"],getNetworkConfigurationForOrg:["GET /orgs/{org}/settings/network-configurations/{network_configuration_id}"],getNetworkSettingsForOrg:["GET /orgs/{org}/settings/network-settings/{network_settings_id}"],listNetworkConfigurationsForOrg:["GET /orgs/{org}/settings/network-configurations"],updateNetworkConfigurationForOrg:["PATCH /orgs/{org}/settings/network-configurations/{network_configuration_id}"]},interactions:{getRestrictionsForAuthenticatedUser:["GET /user/interaction-limits"],getRestrictionsForOrg:["GET /orgs/{org}/interaction-limits"],getRestrictionsForRepo:["GET /repos/{owner}/{repo}/interaction-limits"],getRestrictionsForYourPublicRepos:["GET /user/interaction-limits",{},{renamed:["interactions","getRestrictionsForAuthenticatedUser"]}],removeRestrictionsForAuthenticatedUser:["DELETE /user/interaction-limits"],removeRestrictionsForOrg:["DELETE /orgs/{org}/interaction-limits"],removeRestrictionsForRepo:["DELETE /repos/{owner}/{repo}/interaction-limits"],removeRestrictionsForYourPublicRepos:["DELETE /user/interaction-limits",{},{renamed:["interactions","removeRestrictionsForAuthenticatedUser"]}],setRestrictionsForAuthenticatedUser:["PUT /user/interaction-limits"],setRestrictionsForOrg:["PUT /orgs/{org}/interaction-limits"],setRestrictionsForRepo:["PUT /repos/{owner}/{repo}/interaction-limits"],setRestrictionsForYourPublicRepos:["PUT /user/interaction-limits",{},{renamed:["interactions","setRestrictionsForAuthenticatedUser"]}]},issues:{addAssignees:["POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"],addBlockedByDependency:["POST /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by"],addLabels:["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"],addSubIssue:["POST /repos/{owner}/{repo}/issues/{issue_number}/sub_issues"],checkUserCanBeAssigned:["GET /repos/{owner}/{repo}/assignees/{assignee}"],checkUserCanBeAssignedToIssue:["GET /repos/{owner}/{repo}/issues/{issue_number}/assignees/{assignee}"],create:["POST /repos/{owner}/{repo}/issues"],createComment:["POST /repos/{owner}/{repo}/issues/{issue_number}/comments"],createLabel:["POST /repos/{owner}/{repo}/labels"],createMilestone:["POST /repos/{owner}/{repo}/milestones"],deleteComment:["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"],deleteLabel:["DELETE /repos/{owner}/{repo}/labels/{name}"],deleteMilestone:["DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"],get:["GET /repos/{owner}/{repo}/issues/{issue_number}"],getComment:["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"],getEvent:["GET /repos/{owner}/{repo}/issues/events/{event_id}"],getLabel:["GET /repos/{owner}/{repo}/labels/{name}"],getMilestone:["GET /repos/{owner}/{repo}/milestones/{milestone_number}"],getParent:["GET /repos/{owner}/{repo}/issues/{issue_number}/parent"],list:["GET /issues"],listAssignees:["GET /repos/{owner}/{repo}/assignees"],listComments:["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"],listCommentsForRepo:["GET /repos/{owner}/{repo}/issues/comments"],listDependenciesBlockedBy:["GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by"],listDependenciesBlocking:["GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocking"],listEvents:["GET /repos/{owner}/{repo}/issues/{issue_number}/events"],listEventsForRepo:["GET /repos/{owner}/{repo}/issues/events"],listEventsForTimeline:["GET /repos/{owner}/{repo}/issues/{issue_number}/timeline"],listForAuthenticatedUser:["GET /user/issues"],listForOrg:["GET /orgs/{org}/issues"],listForRepo:["GET /repos/{owner}/{repo}/issues"],listLabelsForMilestone:["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"],listLabelsForRepo:["GET /repos/{owner}/{repo}/labels"],listLabelsOnIssue:["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"],listMilestones:["GET /repos/{owner}/{repo}/milestones"],listSubIssues:["GET /repos/{owner}/{repo}/issues/{issue_number}/sub_issues"],lock:["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"],removeAllLabels:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"],removeAssignees:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"],removeDependencyBlockedBy:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by/{issue_id}"],removeLabel:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"],removeSubIssue:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/sub_issue"],reprioritizeSubIssue:["PATCH /repos/{owner}/{repo}/issues/{issue_number}/sub_issues/priority"],setLabels:["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"],unlock:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"],update:["PATCH /repos/{owner}/{repo}/issues/{issue_number}"],updateComment:["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"],updateLabel:["PATCH /repos/{owner}/{repo}/labels/{name}"],updateMilestone:["PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"]},licenses:{get:["GET /licenses/{license}"],getAllCommonlyUsed:["GET /licenses"],getForRepo:["GET /repos/{owner}/{repo}/license"]},markdown:{render:["POST /markdown"],renderRaw:["POST /markdown/raw",{headers:{"content-type":"text/plain; charset=utf-8"}}]},meta:{get:["GET /meta"],getAllVersions:["GET /versions"],getOctocat:["GET /octocat"],getZen:["GET /zen"],root:["GET /"]},migrations:{deleteArchiveForAuthenticatedUser:["DELETE /user/migrations/{migration_id}/archive"],deleteArchiveForOrg:["DELETE /orgs/{org}/migrations/{migration_id}/archive"],downloadArchiveForOrg:["GET /orgs/{org}/migrations/{migration_id}/archive"],getArchiveForAuthenticatedUser:["GET /user/migrations/{migration_id}/archive"],getStatusForAuthenticatedUser:["GET /user/migrations/{migration_id}"],getStatusForOrg:["GET /orgs/{org}/migrations/{migration_id}"],listForAuthenticatedUser:["GET /user/migrations"],listForOrg:["GET /orgs/{org}/migrations"],listReposForAuthenticatedUser:["GET /user/migrations/{migration_id}/repositories"],listReposForOrg:["GET /orgs/{org}/migrations/{migration_id}/repositories"],listReposForUser:["GET /user/migrations/{migration_id}/repositories",{},{renamed:["migrations","listReposForAuthenticatedUser"]}],startForAuthenticatedUser:["POST /user/migrations"],startForOrg:["POST /orgs/{org}/migrations"],unlockRepoForAuthenticatedUser:["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock"],unlockRepoForOrg:["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock"]},oidc:{getOidcCustomSubTemplateForOrg:["GET /orgs/{org}/actions/oidc/customization/sub"],updateOidcCustomSubTemplateForOrg:["PUT /orgs/{org}/actions/oidc/customization/sub"]},orgs:{addSecurityManagerTeam:["PUT /orgs/{org}/security-managers/teams/{team_slug}",{},{deprecated:"octokit.rest.orgs.addSecurityManagerTeam() is deprecated, see https://docs.github.com/rest/orgs/security-managers#add-a-security-manager-team"}],assignTeamToOrgRole:["PUT /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"],assignUserToOrgRole:["PUT /orgs/{org}/organization-roles/users/{username}/{role_id}"],blockUser:["PUT /orgs/{org}/blocks/{username}"],cancelInvitation:["DELETE /orgs/{org}/invitations/{invitation_id}"],checkBlockedUser:["GET /orgs/{org}/blocks/{username}"],checkMembershipForUser:["GET /orgs/{org}/members/{username}"],checkPublicMembershipForUser:["GET /orgs/{org}/public_members/{username}"],convertMemberToOutsideCollaborator:["PUT /orgs/{org}/outside_collaborators/{username}"],createArtifactStorageRecord:["POST /orgs/{org}/artifacts/metadata/storage-record"],createInvitation:["POST /orgs/{org}/invitations"],createIssueType:["POST /orgs/{org}/issue-types"],createWebhook:["POST /orgs/{org}/hooks"],customPropertiesForOrgsCreateOrUpdateOrganizationValues:["PATCH /organizations/{org}/org-properties/values"],customPropertiesForOrgsGetOrganizationValues:["GET /organizations/{org}/org-properties/values"],customPropertiesForReposCreateOrUpdateOrganizationDefinition:["PUT /orgs/{org}/properties/schema/{custom_property_name}"],customPropertiesForReposCreateOrUpdateOrganizationDefinitions:["PATCH /orgs/{org}/properties/schema"],customPropertiesForReposCreateOrUpdateOrganizationValues:["PATCH /orgs/{org}/properties/values"],customPropertiesForReposDeleteOrganizationDefinition:["DELETE /orgs/{org}/properties/schema/{custom_property_name}"],customPropertiesForReposGetOrganizationDefinition:["GET /orgs/{org}/properties/schema/{custom_property_name}"],customPropertiesForReposGetOrganizationDefinitions:["GET /orgs/{org}/properties/schema"],customPropertiesForReposGetOrganizationValues:["GET /orgs/{org}/properties/values"],delete:["DELETE /orgs/{org}"],deleteAttestationsBulk:["POST /orgs/{org}/attestations/delete-request"],deleteAttestationsById:["DELETE /orgs/{org}/attestations/{attestation_id}"],deleteAttestationsBySubjectDigest:["DELETE /orgs/{org}/attestations/digest/{subject_digest}"],deleteIssueType:["DELETE /orgs/{org}/issue-types/{issue_type_id}"],deleteWebhook:["DELETE /orgs/{org}/hooks/{hook_id}"],disableSelectedRepositoryImmutableReleasesOrganization:["DELETE /orgs/{org}/settings/immutable-releases/repositories/{repository_id}"],enableSelectedRepositoryImmutableReleasesOrganization:["PUT /orgs/{org}/settings/immutable-releases/repositories/{repository_id}"],get:["GET /orgs/{org}"],getImmutableReleasesSettings:["GET /orgs/{org}/settings/immutable-releases"],getImmutableReleasesSettingsRepositories:["GET /orgs/{org}/settings/immutable-releases/repositories"],getMembershipForAuthenticatedUser:["GET /user/memberships/orgs/{org}"],getMembershipForUser:["GET /orgs/{org}/memberships/{username}"],getOrgRole:["GET /orgs/{org}/organization-roles/{role_id}"],getOrgRulesetHistory:["GET /orgs/{org}/rulesets/{ruleset_id}/history"],getOrgRulesetVersion:["GET /orgs/{org}/rulesets/{ruleset_id}/history/{version_id}"],getWebhook:["GET /orgs/{org}/hooks/{hook_id}"],getWebhookConfigForOrg:["GET /orgs/{org}/hooks/{hook_id}/config"],getWebhookDelivery:["GET /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}"],list:["GET /organizations"],listAppInstallations:["GET /orgs/{org}/installations"],listArtifactStorageRecords:["GET /orgs/{org}/artifacts/{subject_digest}/metadata/storage-records"],listAttestationRepositories:["GET /orgs/{org}/attestations/repositories"],listAttestations:["GET /orgs/{org}/attestations/{subject_digest}"],listAttestationsBulk:["POST /orgs/{org}/attestations/bulk-list{?per_page,before,after}"],listBlockedUsers:["GET /orgs/{org}/blocks"],listFailedInvitations:["GET /orgs/{org}/failed_invitations"],listForAuthenticatedUser:["GET /user/orgs"],listForUser:["GET /users/{username}/orgs"],listInvitationTeams:["GET /orgs/{org}/invitations/{invitation_id}/teams"],listIssueTypes:["GET /orgs/{org}/issue-types"],listMembers:["GET /orgs/{org}/members"],listMembershipsForAuthenticatedUser:["GET /user/memberships/orgs"],listOrgRoleTeams:["GET /orgs/{org}/organization-roles/{role_id}/teams"],listOrgRoleUsers:["GET /orgs/{org}/organization-roles/{role_id}/users"],listOrgRoles:["GET /orgs/{org}/organization-roles"],listOrganizationFineGrainedPermissions:["GET /orgs/{org}/organization-fine-grained-permissions"],listOutsideCollaborators:["GET /orgs/{org}/outside_collaborators"],listPatGrantRepositories:["GET /orgs/{org}/personal-access-tokens/{pat_id}/repositories"],listPatGrantRequestRepositories:["GET /orgs/{org}/personal-access-token-requests/{pat_request_id}/repositories"],listPatGrantRequests:["GET /orgs/{org}/personal-access-token-requests"],listPatGrants:["GET /orgs/{org}/personal-access-tokens"],listPendingInvitations:["GET /orgs/{org}/invitations"],listPublicMembers:["GET /orgs/{org}/public_members"],listSecurityManagerTeams:["GET /orgs/{org}/security-managers",{},{deprecated:"octokit.rest.orgs.listSecurityManagerTeams() is deprecated, see https://docs.github.com/rest/orgs/security-managers#list-security-manager-teams"}],listWebhookDeliveries:["GET /orgs/{org}/hooks/{hook_id}/deliveries"],listWebhooks:["GET /orgs/{org}/hooks"],pingWebhook:["POST /orgs/{org}/hooks/{hook_id}/pings"],redeliverWebhookDelivery:["POST /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"],removeMember:["DELETE /orgs/{org}/members/{username}"],removeMembershipForUser:["DELETE /orgs/{org}/memberships/{username}"],removeOutsideCollaborator:["DELETE /orgs/{org}/outside_collaborators/{username}"],removePublicMembershipForAuthenticatedUser:["DELETE /orgs/{org}/public_members/{username}"],removeSecurityManagerTeam:["DELETE /orgs/{org}/security-managers/teams/{team_slug}",{},{deprecated:"octokit.rest.orgs.removeSecurityManagerTeam() is deprecated, see https://docs.github.com/rest/orgs/security-managers#remove-a-security-manager-team"}],reviewPatGrantRequest:["POST /orgs/{org}/personal-access-token-requests/{pat_request_id}"],reviewPatGrantRequestsInBulk:["POST /orgs/{org}/personal-access-token-requests"],revokeAllOrgRolesTeam:["DELETE /orgs/{org}/organization-roles/teams/{team_slug}"],revokeAllOrgRolesUser:["DELETE /orgs/{org}/organization-roles/users/{username}"],revokeOrgRoleTeam:["DELETE /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"],revokeOrgRoleUser:["DELETE /orgs/{org}/organization-roles/users/{username}/{role_id}"],setImmutableReleasesSettings:["PUT /orgs/{org}/settings/immutable-releases"],setImmutableReleasesSettingsRepositories:["PUT /orgs/{org}/settings/immutable-releases/repositories"],setMembershipForUser:["PUT /orgs/{org}/memberships/{username}"],setPublicMembershipForAuthenticatedUser:["PUT /orgs/{org}/public_members/{username}"],unblockUser:["DELETE /orgs/{org}/blocks/{username}"],update:["PATCH /orgs/{org}"],updateIssueType:["PUT /orgs/{org}/issue-types/{issue_type_id}"],updateMembershipForAuthenticatedUser:["PATCH /user/memberships/orgs/{org}"],updatePatAccess:["POST /orgs/{org}/personal-access-tokens/{pat_id}"],updatePatAccesses:["POST /orgs/{org}/personal-access-tokens"],updateWebhook:["PATCH /orgs/{org}/hooks/{hook_id}"],updateWebhookConfigForOrg:["PATCH /orgs/{org}/hooks/{hook_id}/config"]},packages:{deletePackageForAuthenticatedUser:["DELETE /user/packages/{package_type}/{package_name}"],deletePackageForOrg:["DELETE /orgs/{org}/packages/{package_type}/{package_name}"],deletePackageForUser:["DELETE /users/{username}/packages/{package_type}/{package_name}"],deletePackageVersionForAuthenticatedUser:["DELETE /user/packages/{package_type}/{package_name}/versions/{package_version_id}"],deletePackageVersionForOrg:["DELETE /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"],deletePackageVersionForUser:["DELETE /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"],getAllPackageVersionsForAPackageOwnedByAnOrg:["GET /orgs/{org}/packages/{package_type}/{package_name}/versions",{},{renamed:["packages","getAllPackageVersionsForPackageOwnedByOrg"]}],getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser:["GET /user/packages/{package_type}/{package_name}/versions",{},{renamed:["packages","getAllPackageVersionsForPackageOwnedByAuthenticatedUser"]}],getAllPackageVersionsForPackageOwnedByAuthenticatedUser:["GET /user/packages/{package_type}/{package_name}/versions"],getAllPackageVersionsForPackageOwnedByOrg:["GET /orgs/{org}/packages/{package_type}/{package_name}/versions"],getAllPackageVersionsForPackageOwnedByUser:["GET /users/{username}/packages/{package_type}/{package_name}/versions"],getPackageForAuthenticatedUser:["GET /user/packages/{package_type}/{package_name}"],getPackageForOrganization:["GET /orgs/{org}/packages/{package_type}/{package_name}"],getPackageForUser:["GET /users/{username}/packages/{package_type}/{package_name}"],getPackageVersionForAuthenticatedUser:["GET /user/packages/{package_type}/{package_name}/versions/{package_version_id}"],getPackageVersionForOrganization:["GET /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"],getPackageVersionForUser:["GET /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"],listDockerMigrationConflictingPackagesForAuthenticatedUser:["GET /user/docker/conflicts"],listDockerMigrationConflictingPackagesForOrganization:["GET /orgs/{org}/docker/conflicts"],listDockerMigrationConflictingPackagesForUser:["GET /users/{username}/docker/conflicts"],listPackagesForAuthenticatedUser:["GET /user/packages"],listPackagesForOrganization:["GET /orgs/{org}/packages"],listPackagesForUser:["GET /users/{username}/packages"],restorePackageForAuthenticatedUser:["POST /user/packages/{package_type}/{package_name}/restore{?token}"],restorePackageForOrg:["POST /orgs/{org}/packages/{package_type}/{package_name}/restore{?token}"],restorePackageForUser:["POST /users/{username}/packages/{package_type}/{package_name}/restore{?token}"],restorePackageVersionForAuthenticatedUser:["POST /user/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"],restorePackageVersionForOrg:["POST /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"],restorePackageVersionForUser:["POST /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"]},privateRegistries:{createOrgPrivateRegistry:["POST /orgs/{org}/private-registries"],deleteOrgPrivateRegistry:["DELETE /orgs/{org}/private-registries/{secret_name}"],getOrgPrivateRegistry:["GET /orgs/{org}/private-registries/{secret_name}"],getOrgPublicKey:["GET /orgs/{org}/private-registries/public-key"],listOrgPrivateRegistries:["GET /orgs/{org}/private-registries"],updateOrgPrivateRegistry:["PATCH /orgs/{org}/private-registries/{secret_name}"]},projects:{addItemForOrg:["POST /orgs/{org}/projectsV2/{project_number}/items"],addItemForUser:["POST /users/{username}/projectsV2/{project_number}/items"],deleteItemForOrg:["DELETE /orgs/{org}/projectsV2/{project_number}/items/{item_id}"],deleteItemForUser:["DELETE /users/{username}/projectsV2/{project_number}/items/{item_id}"],getFieldForOrg:["GET /orgs/{org}/projectsV2/{project_number}/fields/{field_id}"],getFieldForUser:["GET /users/{username}/projectsV2/{project_number}/fields/{field_id}"],getForOrg:["GET /orgs/{org}/projectsV2/{project_number}"],getForUser:["GET /users/{username}/projectsV2/{project_number}"],getOrgItem:["GET /orgs/{org}/projectsV2/{project_number}/items/{item_id}"],getUserItem:["GET /users/{username}/projectsV2/{project_number}/items/{item_id}"],listFieldsForOrg:["GET /orgs/{org}/projectsV2/{project_number}/fields"],listFieldsForUser:["GET /users/{username}/projectsV2/{project_number}/fields"],listForOrg:["GET /orgs/{org}/projectsV2"],listForUser:["GET /users/{username}/projectsV2"],listItemsForOrg:["GET /orgs/{org}/projectsV2/{project_number}/items"],listItemsForUser:["GET /users/{username}/projectsV2/{project_number}/items"],updateItemForOrg:["PATCH /orgs/{org}/projectsV2/{project_number}/items/{item_id}"],updateItemForUser:["PATCH /users/{username}/projectsV2/{project_number}/items/{item_id}"]},pulls:{checkIfMerged:["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"],create:["POST /repos/{owner}/{repo}/pulls"],createReplyForReviewComment:["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"],createReview:["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],createReviewComment:["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"],deletePendingReview:["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],deleteReviewComment:["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"],dismissReview:["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"],get:["GET /repos/{owner}/{repo}/pulls/{pull_number}"],getReview:["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],getReviewComment:["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"],list:["GET /repos/{owner}/{repo}/pulls"],listCommentsForReview:["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"],listCommits:["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"],listFiles:["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"],listRequestedReviewers:["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],listReviewComments:["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"],listReviewCommentsForRepo:["GET /repos/{owner}/{repo}/pulls/comments"],listReviews:["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],merge:["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"],removeRequestedReviewers:["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],requestReviewers:["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],submitReview:["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"],update:["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"],updateBranch:["PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch"],updateReview:["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],updateReviewComment:["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"]},rateLimit:{get:["GET /rate_limit"]},reactions:{createForCommitComment:["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions"],createForIssue:["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions"],createForIssueComment:["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"],createForPullRequestReviewComment:["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"],createForRelease:["POST /repos/{owner}/{repo}/releases/{release_id}/reactions"],createForTeamDiscussionCommentInOrg:["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"],createForTeamDiscussionInOrg:["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"],deleteForCommitComment:["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}"],deleteForIssue:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}"],deleteForIssueComment:["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}"],deleteForPullRequestComment:["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}"],deleteForRelease:["DELETE /repos/{owner}/{repo}/releases/{release_id}/reactions/{reaction_id}"],deleteForTeamDiscussion:["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}"],deleteForTeamDiscussionComment:["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}"],listForCommitComment:["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions"],listForIssue:["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions"],listForIssueComment:["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"],listForPullRequestReviewComment:["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"],listForRelease:["GET /repos/{owner}/{repo}/releases/{release_id}/reactions"],listForTeamDiscussionCommentInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"],listForTeamDiscussionInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"]},repos:{acceptInvitation:["PATCH /user/repository_invitations/{invitation_id}",{},{renamed:["repos","acceptInvitationForAuthenticatedUser"]}],acceptInvitationForAuthenticatedUser:["PATCH /user/repository_invitations/{invitation_id}"],addAppAccessRestrictions:["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",{},{mapToData:"apps"}],addCollaborator:["PUT /repos/{owner}/{repo}/collaborators/{username}"],addStatusCheckContexts:["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",{},{mapToData:"contexts"}],addTeamAccessRestrictions:["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",{},{mapToData:"teams"}],addUserAccessRestrictions:["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",{},{mapToData:"users"}],cancelPagesDeployment:["POST /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}/cancel"],checkAutomatedSecurityFixes:["GET /repos/{owner}/{repo}/automated-security-fixes"],checkCollaborator:["GET /repos/{owner}/{repo}/collaborators/{username}"],checkImmutableReleases:["GET /repos/{owner}/{repo}/immutable-releases"],checkPrivateVulnerabilityReporting:["GET /repos/{owner}/{repo}/private-vulnerability-reporting"],checkVulnerabilityAlerts:["GET /repos/{owner}/{repo}/vulnerability-alerts"],codeownersErrors:["GET /repos/{owner}/{repo}/codeowners/errors"],compareCommits:["GET /repos/{owner}/{repo}/compare/{base}...{head}"],compareCommitsWithBasehead:["GET /repos/{owner}/{repo}/compare/{basehead}"],createAttestation:["POST /repos/{owner}/{repo}/attestations"],createAutolink:["POST /repos/{owner}/{repo}/autolinks"],createCommitComment:["POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"],createCommitSignatureProtection:["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"],createCommitStatus:["POST /repos/{owner}/{repo}/statuses/{sha}"],createDeployKey:["POST /repos/{owner}/{repo}/keys"],createDeployment:["POST /repos/{owner}/{repo}/deployments"],createDeploymentBranchPolicy:["POST /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"],createDeploymentProtectionRule:["POST /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"],createDeploymentStatus:["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],createDispatchEvent:["POST /repos/{owner}/{repo}/dispatches"],createForAuthenticatedUser:["POST /user/repos"],createFork:["POST /repos/{owner}/{repo}/forks"],createInOrg:["POST /orgs/{org}/repos"],createOrUpdateEnvironment:["PUT /repos/{owner}/{repo}/environments/{environment_name}"],createOrUpdateFileContents:["PUT /repos/{owner}/{repo}/contents/{path}"],createOrgRuleset:["POST /orgs/{org}/rulesets"],createPagesDeployment:["POST /repos/{owner}/{repo}/pages/deployments"],createPagesSite:["POST /repos/{owner}/{repo}/pages"],createRelease:["POST /repos/{owner}/{repo}/releases"],createRepoRuleset:["POST /repos/{owner}/{repo}/rulesets"],createUsingTemplate:["POST /repos/{template_owner}/{template_repo}/generate"],createWebhook:["POST /repos/{owner}/{repo}/hooks"],customPropertiesForReposCreateOrUpdateRepositoryValues:["PATCH /repos/{owner}/{repo}/properties/values"],customPropertiesForReposGetRepositoryValues:["GET /repos/{owner}/{repo}/properties/values"],declineInvitation:["DELETE /user/repository_invitations/{invitation_id}",{},{renamed:["repos","declineInvitationForAuthenticatedUser"]}],declineInvitationForAuthenticatedUser:["DELETE /user/repository_invitations/{invitation_id}"],delete:["DELETE /repos/{owner}/{repo}"],deleteAccessRestrictions:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],deleteAdminBranchProtection:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],deleteAnEnvironment:["DELETE /repos/{owner}/{repo}/environments/{environment_name}"],deleteAutolink:["DELETE /repos/{owner}/{repo}/autolinks/{autolink_id}"],deleteBranchProtection:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection"],deleteCommitComment:["DELETE /repos/{owner}/{repo}/comments/{comment_id}"],deleteCommitSignatureProtection:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"],deleteDeployKey:["DELETE /repos/{owner}/{repo}/keys/{key_id}"],deleteDeployment:["DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"],deleteDeploymentBranchPolicy:["DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"],deleteFile:["DELETE /repos/{owner}/{repo}/contents/{path}"],deleteInvitation:["DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"],deleteOrgRuleset:["DELETE /orgs/{org}/rulesets/{ruleset_id}"],deletePagesSite:["DELETE /repos/{owner}/{repo}/pages"],deletePullRequestReviewProtection:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],deleteRelease:["DELETE /repos/{owner}/{repo}/releases/{release_id}"],deleteReleaseAsset:["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"],deleteRepoRuleset:["DELETE /repos/{owner}/{repo}/rulesets/{ruleset_id}"],deleteWebhook:["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"],disableAutomatedSecurityFixes:["DELETE /repos/{owner}/{repo}/automated-security-fixes"],disableDeploymentProtectionRule:["DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"],disableImmutableReleases:["DELETE /repos/{owner}/{repo}/immutable-releases"],disablePrivateVulnerabilityReporting:["DELETE /repos/{owner}/{repo}/private-vulnerability-reporting"],disableVulnerabilityAlerts:["DELETE /repos/{owner}/{repo}/vulnerability-alerts"],downloadArchive:["GET /repos/{owner}/{repo}/zipball/{ref}",{},{renamed:["repos","downloadZipballArchive"]}],downloadTarballArchive:["GET /repos/{owner}/{repo}/tarball/{ref}"],downloadZipballArchive:["GET /repos/{owner}/{repo}/zipball/{ref}"],enableAutomatedSecurityFixes:["PUT /repos/{owner}/{repo}/automated-security-fixes"],enableImmutableReleases:["PUT /repos/{owner}/{repo}/immutable-releases"],enablePrivateVulnerabilityReporting:["PUT /repos/{owner}/{repo}/private-vulnerability-reporting"],enableVulnerabilityAlerts:["PUT /repos/{owner}/{repo}/vulnerability-alerts"],generateReleaseNotes:["POST /repos/{owner}/{repo}/releases/generate-notes"],get:["GET /repos/{owner}/{repo}"],getAccessRestrictions:["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],getAdminBranchProtection:["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],getAllDeploymentProtectionRules:["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"],getAllEnvironments:["GET /repos/{owner}/{repo}/environments"],getAllStatusCheckContexts:["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"],getAllTopics:["GET /repos/{owner}/{repo}/topics"],getAppsWithAccessToProtectedBranch:["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"],getAutolink:["GET /repos/{owner}/{repo}/autolinks/{autolink_id}"],getBranch:["GET /repos/{owner}/{repo}/branches/{branch}"],getBranchProtection:["GET /repos/{owner}/{repo}/branches/{branch}/protection"],getBranchRules:["GET /repos/{owner}/{repo}/rules/branches/{branch}"],getClones:["GET /repos/{owner}/{repo}/traffic/clones"],getCodeFrequencyStats:["GET /repos/{owner}/{repo}/stats/code_frequency"],getCollaboratorPermissionLevel:["GET /repos/{owner}/{repo}/collaborators/{username}/permission"],getCombinedStatusForRef:["GET /repos/{owner}/{repo}/commits/{ref}/status"],getCommit:["GET /repos/{owner}/{repo}/commits/{ref}"],getCommitActivityStats:["GET /repos/{owner}/{repo}/stats/commit_activity"],getCommitComment:["GET /repos/{owner}/{repo}/comments/{comment_id}"],getCommitSignatureProtection:["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"],getCommunityProfileMetrics:["GET /repos/{owner}/{repo}/community/profile"],getContent:["GET /repos/{owner}/{repo}/contents/{path}"],getContributorsStats:["GET /repos/{owner}/{repo}/stats/contributors"],getCustomDeploymentProtectionRule:["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"],getDeployKey:["GET /repos/{owner}/{repo}/keys/{key_id}"],getDeployment:["GET /repos/{owner}/{repo}/deployments/{deployment_id}"],getDeploymentBranchPolicy:["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"],getDeploymentStatus:["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"],getEnvironment:["GET /repos/{owner}/{repo}/environments/{environment_name}"],getLatestPagesBuild:["GET /repos/{owner}/{repo}/pages/builds/latest"],getLatestRelease:["GET /repos/{owner}/{repo}/releases/latest"],getOrgRuleSuite:["GET /orgs/{org}/rulesets/rule-suites/{rule_suite_id}"],getOrgRuleSuites:["GET /orgs/{org}/rulesets/rule-suites"],getOrgRuleset:["GET /orgs/{org}/rulesets/{ruleset_id}"],getOrgRulesets:["GET /orgs/{org}/rulesets"],getPages:["GET /repos/{owner}/{repo}/pages"],getPagesBuild:["GET /repos/{owner}/{repo}/pages/builds/{build_id}"],getPagesDeployment:["GET /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}"],getPagesHealthCheck:["GET /repos/{owner}/{repo}/pages/health"],getParticipationStats:["GET /repos/{owner}/{repo}/stats/participation"],getPullRequestReviewProtection:["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],getPunchCardStats:["GET /repos/{owner}/{repo}/stats/punch_card"],getReadme:["GET /repos/{owner}/{repo}/readme"],getReadmeInDirectory:["GET /repos/{owner}/{repo}/readme/{dir}"],getRelease:["GET /repos/{owner}/{repo}/releases/{release_id}"],getReleaseAsset:["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"],getReleaseByTag:["GET /repos/{owner}/{repo}/releases/tags/{tag}"],getRepoRuleSuite:["GET /repos/{owner}/{repo}/rulesets/rule-suites/{rule_suite_id}"],getRepoRuleSuites:["GET /repos/{owner}/{repo}/rulesets/rule-suites"],getRepoRuleset:["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}"],getRepoRulesetHistory:["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}/history"],getRepoRulesetVersion:["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}/history/{version_id}"],getRepoRulesets:["GET /repos/{owner}/{repo}/rulesets"],getStatusChecksProtection:["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],getTeamsWithAccessToProtectedBranch:["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"],getTopPaths:["GET /repos/{owner}/{repo}/traffic/popular/paths"],getTopReferrers:["GET /repos/{owner}/{repo}/traffic/popular/referrers"],getUsersWithAccessToProtectedBranch:["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"],getViews:["GET /repos/{owner}/{repo}/traffic/views"],getWebhook:["GET /repos/{owner}/{repo}/hooks/{hook_id}"],getWebhookConfigForRepo:["GET /repos/{owner}/{repo}/hooks/{hook_id}/config"],getWebhookDelivery:["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}"],listActivities:["GET /repos/{owner}/{repo}/activity"],listAttestations:["GET /repos/{owner}/{repo}/attestations/{subject_digest}"],listAutolinks:["GET /repos/{owner}/{repo}/autolinks"],listBranches:["GET /repos/{owner}/{repo}/branches"],listBranchesForHeadCommit:["GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head"],listCollaborators:["GET /repos/{owner}/{repo}/collaborators"],listCommentsForCommit:["GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"],listCommitCommentsForRepo:["GET /repos/{owner}/{repo}/comments"],listCommitStatusesForRef:["GET /repos/{owner}/{repo}/commits/{ref}/statuses"],listCommits:["GET /repos/{owner}/{repo}/commits"],listContributors:["GET /repos/{owner}/{repo}/contributors"],listCustomDeploymentRuleIntegrations:["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/apps"],listDeployKeys:["GET /repos/{owner}/{repo}/keys"],listDeploymentBranchPolicies:["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"],listDeploymentStatuses:["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],listDeployments:["GET /repos/{owner}/{repo}/deployments"],listForAuthenticatedUser:["GET /user/repos"],listForOrg:["GET /orgs/{org}/repos"],listForUser:["GET /users/{username}/repos"],listForks:["GET /repos/{owner}/{repo}/forks"],listInvitations:["GET /repos/{owner}/{repo}/invitations"],listInvitationsForAuthenticatedUser:["GET /user/repository_invitations"],listLanguages:["GET /repos/{owner}/{repo}/languages"],listPagesBuilds:["GET /repos/{owner}/{repo}/pages/builds"],listPublic:["GET /repositories"],listPullRequestsAssociatedWithCommit:["GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls"],listReleaseAssets:["GET /repos/{owner}/{repo}/releases/{release_id}/assets"],listReleases:["GET /repos/{owner}/{repo}/releases"],listTags:["GET /repos/{owner}/{repo}/tags"],listTeams:["GET /repos/{owner}/{repo}/teams"],listWebhookDeliveries:["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries"],listWebhooks:["GET /repos/{owner}/{repo}/hooks"],merge:["POST /repos/{owner}/{repo}/merges"],mergeUpstream:["POST /repos/{owner}/{repo}/merge-upstream"],pingWebhook:["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"],redeliverWebhookDelivery:["POST /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"],removeAppAccessRestrictions:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",{},{mapToData:"apps"}],removeCollaborator:["DELETE /repos/{owner}/{repo}/collaborators/{username}"],removeStatusCheckContexts:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",{},{mapToData:"contexts"}],removeStatusCheckProtection:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],removeTeamAccessRestrictions:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",{},{mapToData:"teams"}],removeUserAccessRestrictions:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",{},{mapToData:"users"}],renameBranch:["POST /repos/{owner}/{repo}/branches/{branch}/rename"],replaceAllTopics:["PUT /repos/{owner}/{repo}/topics"],requestPagesBuild:["POST /repos/{owner}/{repo}/pages/builds"],setAdminBranchProtection:["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],setAppAccessRestrictions:["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",{},{mapToData:"apps"}],setStatusCheckContexts:["PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",{},{mapToData:"contexts"}],setTeamAccessRestrictions:["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",{},{mapToData:"teams"}],setUserAccessRestrictions:["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",{},{mapToData:"users"}],testPushWebhook:["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"],transfer:["POST /repos/{owner}/{repo}/transfer"],update:["PATCH /repos/{owner}/{repo}"],updateBranchProtection:["PUT /repos/{owner}/{repo}/branches/{branch}/protection"],updateCommitComment:["PATCH /repos/{owner}/{repo}/comments/{comment_id}"],updateDeploymentBranchPolicy:["PUT /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"],updateInformationAboutPagesSite:["PUT /repos/{owner}/{repo}/pages"],updateInvitation:["PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"],updateOrgRuleset:["PUT /orgs/{org}/rulesets/{ruleset_id}"],updatePullRequestReviewProtection:["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],updateRelease:["PATCH /repos/{owner}/{repo}/releases/{release_id}"],updateReleaseAsset:["PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"],updateRepoRuleset:["PUT /repos/{owner}/{repo}/rulesets/{ruleset_id}"],updateStatusCheckPotection:["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks",{},{renamed:["repos","updateStatusCheckProtection"]}],updateStatusCheckProtection:["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],updateWebhook:["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"],updateWebhookConfigForRepo:["PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config"],uploadReleaseAsset:["POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}",{baseUrl:"https://uploads.github.com"}]},search:{code:["GET /search/code"],commits:["GET /search/commits"],issuesAndPullRequests:["GET /search/issues"],labels:["GET /search/labels"],repos:["GET /search/repositories"],topics:["GET /search/topics"],users:["GET /search/users"]},secretScanning:{createPushProtectionBypass:["POST /repos/{owner}/{repo}/secret-scanning/push-protection-bypasses"],getAlert:["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"],getScanHistory:["GET /repos/{owner}/{repo}/secret-scanning/scan-history"],listAlertsForOrg:["GET /orgs/{org}/secret-scanning/alerts"],listAlertsForRepo:["GET /repos/{owner}/{repo}/secret-scanning/alerts"],listLocationsForAlert:["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations"],listOrgPatternConfigs:["GET /orgs/{org}/secret-scanning/pattern-configurations"],updateAlert:["PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"],updateOrgPatternConfigs:["PATCH /orgs/{org}/secret-scanning/pattern-configurations"]},securityAdvisories:{createFork:["POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/forks"],createPrivateVulnerabilityReport:["POST /repos/{owner}/{repo}/security-advisories/reports"],createRepositoryAdvisory:["POST /repos/{owner}/{repo}/security-advisories"],createRepositoryAdvisoryCveRequest:["POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/cve"],getGlobalAdvisory:["GET /advisories/{ghsa_id}"],getRepositoryAdvisory:["GET /repos/{owner}/{repo}/security-advisories/{ghsa_id}"],listGlobalAdvisories:["GET /advisories"],listOrgRepositoryAdvisories:["GET /orgs/{org}/security-advisories"],listRepositoryAdvisories:["GET /repos/{owner}/{repo}/security-advisories"],updateRepositoryAdvisory:["PATCH /repos/{owner}/{repo}/security-advisories/{ghsa_id}"]},teams:{addOrUpdateMembershipForUserInOrg:["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"],addOrUpdateRepoPermissionsInOrg:["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],checkPermissionsForRepoInOrg:["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],create:["POST /orgs/{org}/teams"],createDiscussionCommentInOrg:["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],createDiscussionInOrg:["POST /orgs/{org}/teams/{team_slug}/discussions"],deleteDiscussionCommentInOrg:["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],deleteDiscussionInOrg:["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],deleteInOrg:["DELETE /orgs/{org}/teams/{team_slug}"],getByName:["GET /orgs/{org}/teams/{team_slug}"],getDiscussionCommentInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],getDiscussionInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],getMembershipForUserInOrg:["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"],list:["GET /orgs/{org}/teams"],listChildInOrg:["GET /orgs/{org}/teams/{team_slug}/teams"],listDiscussionCommentsInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],listDiscussionsInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions"],listForAuthenticatedUser:["GET /user/teams"],listMembersInOrg:["GET /orgs/{org}/teams/{team_slug}/members"],listPendingInvitationsInOrg:["GET /orgs/{org}/teams/{team_slug}/invitations"],listReposInOrg:["GET /orgs/{org}/teams/{team_slug}/repos"],removeMembershipForUserInOrg:["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"],removeRepoInOrg:["DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],updateDiscussionCommentInOrg:["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],updateDiscussionInOrg:["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],updateInOrg:["PATCH /orgs/{org}/teams/{team_slug}"]},users:{addEmailForAuthenticated:["POST /user/emails",{},{renamed:["users","addEmailForAuthenticatedUser"]}],addEmailForAuthenticatedUser:["POST /user/emails"],addSocialAccountForAuthenticatedUser:["POST /user/social_accounts"],block:["PUT /user/blocks/{username}"],checkBlocked:["GET /user/blocks/{username}"],checkFollowingForUser:["GET /users/{username}/following/{target_user}"],checkPersonIsFollowedByAuthenticated:["GET /user/following/{username}"],createGpgKeyForAuthenticated:["POST /user/gpg_keys",{},{renamed:["users","createGpgKeyForAuthenticatedUser"]}],createGpgKeyForAuthenticatedUser:["POST /user/gpg_keys"],createPublicSshKeyForAuthenticated:["POST /user/keys",{},{renamed:["users","createPublicSshKeyForAuthenticatedUser"]}],createPublicSshKeyForAuthenticatedUser:["POST /user/keys"],createSshSigningKeyForAuthenticatedUser:["POST /user/ssh_signing_keys"],deleteAttestationsBulk:["POST /users/{username}/attestations/delete-request"],deleteAttestationsById:["DELETE /users/{username}/attestations/{attestation_id}"],deleteAttestationsBySubjectDigest:["DELETE /users/{username}/attestations/digest/{subject_digest}"],deleteEmailForAuthenticated:["DELETE /user/emails",{},{renamed:["users","deleteEmailForAuthenticatedUser"]}],deleteEmailForAuthenticatedUser:["DELETE /user/emails"],deleteGpgKeyForAuthenticated:["DELETE /user/gpg_keys/{gpg_key_id}",{},{renamed:["users","deleteGpgKeyForAuthenticatedUser"]}],deleteGpgKeyForAuthenticatedUser:["DELETE /user/gpg_keys/{gpg_key_id}"],deletePublicSshKeyForAuthenticated:["DELETE /user/keys/{key_id}",{},{renamed:["users","deletePublicSshKeyForAuthenticatedUser"]}],deletePublicSshKeyForAuthenticatedUser:["DELETE /user/keys/{key_id}"],deleteSocialAccountForAuthenticatedUser:["DELETE /user/social_accounts"],deleteSshSigningKeyForAuthenticatedUser:["DELETE /user/ssh_signing_keys/{ssh_signing_key_id}"],follow:["PUT /user/following/{username}"],getAuthenticated:["GET /user"],getById:["GET /user/{account_id}"],getByUsername:["GET /users/{username}"],getContextForUser:["GET /users/{username}/hovercard"],getGpgKeyForAuthenticated:["GET /user/gpg_keys/{gpg_key_id}",{},{renamed:["users","getGpgKeyForAuthenticatedUser"]}],getGpgKeyForAuthenticatedUser:["GET /user/gpg_keys/{gpg_key_id}"],getPublicSshKeyForAuthenticated:["GET /user/keys/{key_id}",{},{renamed:["users","getPublicSshKeyForAuthenticatedUser"]}],getPublicSshKeyForAuthenticatedUser:["GET /user/keys/{key_id}"],getSshSigningKeyForAuthenticatedUser:["GET /user/ssh_signing_keys/{ssh_signing_key_id}"],list:["GET /users"],listAttestations:["GET /users/{username}/attestations/{subject_digest}"],listAttestationsBulk:["POST /users/{username}/attestations/bulk-list{?per_page,before,after}"],listBlockedByAuthenticated:["GET /user/blocks",{},{renamed:["users","listBlockedByAuthenticatedUser"]}],listBlockedByAuthenticatedUser:["GET /user/blocks"],listEmailsForAuthenticated:["GET /user/emails",{},{renamed:["users","listEmailsForAuthenticatedUser"]}],listEmailsForAuthenticatedUser:["GET /user/emails"],listFollowedByAuthenticated:["GET /user/following",{},{renamed:["users","listFollowedByAuthenticatedUser"]}],listFollowedByAuthenticatedUser:["GET /user/following"],listFollowersForAuthenticatedUser:["GET /user/followers"],listFollowersForUser:["GET /users/{username}/followers"],listFollowingForUser:["GET /users/{username}/following"],listGpgKeysForAuthenticated:["GET /user/gpg_keys",{},{renamed:["users","listGpgKeysForAuthenticatedUser"]}],listGpgKeysForAuthenticatedUser:["GET /user/gpg_keys"],listGpgKeysForUser:["GET /users/{username}/gpg_keys"],listPublicEmailsForAuthenticated:["GET /user/public_emails",{},{renamed:["users","listPublicEmailsForAuthenticatedUser"]}],listPublicEmailsForAuthenticatedUser:["GET /user/public_emails"],listPublicKeysForUser:["GET /users/{username}/keys"],listPublicSshKeysForAuthenticated:["GET /user/keys",{},{renamed:["users","listPublicSshKeysForAuthenticatedUser"]}],listPublicSshKeysForAuthenticatedUser:["GET /user/keys"],listSocialAccountsForAuthenticatedUser:["GET /user/social_accounts"],listSocialAccountsForUser:["GET /users/{username}/social_accounts"],listSshSigningKeysForAuthenticatedUser:["GET /user/ssh_signing_keys"],listSshSigningKeysForUser:["GET /users/{username}/ssh_signing_keys"],setPrimaryEmailVisibilityForAuthenticated:["PATCH /user/email/visibility",{},{renamed:["users","setPrimaryEmailVisibilityForAuthenticatedUser"]}],setPrimaryEmailVisibilityForAuthenticatedUser:["PATCH /user/email/visibility"],unblock:["DELETE /user/blocks/{username}"],unfollow:["DELETE /user/following/{username}"],updateAuthenticated:["PATCH /user"]}},Vp=zG;var Sr=new Map;for(let[t,e]of Object.entries(Vp))for(let[r,A]of Object.entries(e)){let[s,o,n]=A,[i,a]=s.split(/ /),c=Object.assign({method:i,url:a},o);Sr.has(t)||Sr.set(t,new Map),Sr.get(t).set(r,{scope:t,methodName:r,endpointDefaults:c,decorations:n})}var ZG={has({scope:t},e){return Sr.get(t).has(e)},getOwnPropertyDescriptor(t,e){return{value:this.get(t,e),configurable:!0,writable:!0,enumerable:!0}},defineProperty(t,e,r){return Object.defineProperty(t.cache,e,r),!0},deleteProperty(t,e){return delete t.cache[e],!0},ownKeys({scope:t}){return[...Sr.get(t).keys()]},set(t,e,r){return t.cache[e]=r},get({octokit:t,scope:e,cache:r},A){if(r[A])return r[A];let s=Sr.get(e).get(A);if(!s)return;let{endpointDefaults:o,decorations:n}=s;return n?r[A]=KG(t,e,A,o,n):r[A]=t.request.defaults(o),r[A]}};function $g(t){let e={};for(let r of Sr.keys())e[r]=new Proxy({octokit:t,scope:r,cache:{}},ZG);return e}function KG(t,e,r,A,s){let o=t.request.defaults(A);function n(...i){let a=o.endpoint.merge(...i);if(s.mapToData)return a=Object.assign({},a,{data:a[s.mapToData],[s.mapToData]:void 0}),o(a);if(s.renamed){let[c,l]=s.renamed;t.log.warn(`octokit.${e}.${r}() has been renamed to octokit.${c}.${l}()`)}if(s.deprecated&&t.log.warn(s.deprecated),s.renamedParameters){let c=o.endpoint.merge(...i);for(let[l,g]of Object.entries(s.renamedParameters))l in c&&(t.log.warn(`"${l}" parameter is deprecated for "octokit.${e}.${r}()". Use "${g}" instead`),g in c||(c[g]=c[l]),delete c[l]);return o(c)}return o(...i)}return Object.assign(n,o)}function jG(t){return{rest:$g(t)}}jG.VERSION=Xg;function eu(t){let e=$g(t);return{...e,rest:e}}eu.VERSION=Xg;var qp="22.0.1";var Wp=Zn.plugin(Zg,eu,jg).defaults({userAgent:`octokit-rest.js/${qp}`});var XG=Wp.plugin(Pn,Yg),$G=50,zp=["in_progress","queued","waiting"],eM=new Set(zp),tM=Array.from({length:100},(t,e)=>400+e),rM=()=>({onRateLimit:(t,e,r,A)=>{if(Hn(`Request quota exhausted for request ${e.method} ${e.url}`),A<1)return Hn(`Retrying after ${t} seconds!`),!0},onSecondaryRateLimit:(t,e)=>{Hn(`Secondary rate limit detected for request ${e.method} ${e.url}`)}}),AM=(t,e)=>!(!eM.has(t.status||"")||e.branch&&t.head_branch!==e.branch||e.queueName&&!t.display_title?.includes(e.queueName)&&!t.name?.includes(e.queueName)),Kn=class{octokit;constructor(e,r=0){this.octokit=new XG({baseUrl:process.env.GITHUB_API_URL||"https://api.github.com",auth:e,retry:{enabled:r>0,retries:r,doNotRetry:tM},throttle:rM()})}workflows=async(e,r)=>this.octokit.paginate(this.octokit.actions.listRepoWorkflows,{owner:e,repo:r,per_page:100});run=async(e,r,A,s={})=>{let{data:o}=await this.octokit.actions.getWorkflowRun({owner:e,repo:r,run_id:A,...s.signal?{request:{signal:s.signal}}:{}});return o};listActiveRuns=async(e,r,A,s={})=>{let o=new Map,n=this.octokit.paginate;return await Promise.all(zp.map(async i=>{let a=0,c=await n(e,{...r,...A.branch?{branch:A.branch}:{},status:i,...s.signal?{request:{signal:s.signal}}:{}},(l,g)=>{a+=1;let E=l.data.filter(d=>AM(d,A));return a>=$G&&g(),E});for(let l of c)o.set(l.id,l)})),[...o.values()]};runs=async(e,r,A,s={},o={})=>{let n={owner:e,repo:r,workflow_id:A,per_page:100};return this.listActiveRuns(this.octokit.actions.listWorkflowRuns,n,s,o)};activeRunsForRepo=async(e,r,A={},s={})=>{let o={owner:e,repo:r,per_page:100};return this.listActiveRuns(this.octokit.actions.listWorkflowRunsForRepo,o,A,s)};jobs=async(e,r,A)=>{let s={owner:e,repo:r,run_id:A,per_page:100};return this.octokit.paginate(this.octokit.actions.listJobsForWorkflowRun,s)};steps=async(e,r,A)=>{let s={owner:e,repo:r,job_id:A},{data:o}=await this.octokit.actions.getJobForWorkflowRun(s);return o.steps||[]}};var Ys=(t,e,r,A)=>{let s=t[e];if(s===void 0||s.trim()==="")return r;let o=e.replace(/^INPUT_/,"").toLowerCase();if(!/^\d+$/.test(s.trim()))throw new Error(`${o} must be an integer greater than or equal to ${A}`);let n=Number(s);if(!Number.isSafeInteger(n)||n{if(!t)return;let r=["refs/heads/","refs/tags/"].find(A=>t.startsWith(A));return r?t.substring(r.length):t},oM=(t,e,r)=>{if(!t||!e||!r)return;let A=t.split("@")[0],s=`${e}/${r}/`;if(A.startsWith(s))return A.substring(s.length)},nM=t=>{let e=Number(t||"1");return Number.isSafeInteger(e)&&e>0?e:1},Zp=t=>{let e=t.INPUT_TOKEN||"",[r,A]=(t.GITHUB_REPOSITORY||"").split("/"),s=t.GITHUB_WORKFLOW||"",o=oM(t.GITHUB_WORKFLOW_REF,r,A),i=t.INPUT_BRANCH?.trim()||t.GITHUB_HEAD_REF||t.GITHUB_REF_NAME||sM(t.GITHUB_REF)||"master",a=parseInt(t.GITHUB_RUN_ID||"0",10),c=nM(t.GITHUB_RUN_ATTEMPT),l=Ys(t,"INPUT_POLL-INTERVAL-SECONDS",60,1)??60,g=Ys(t,"INPUT_CONTINUE-AFTER-SECONDS",void 0,0),E=Ys(t,"INPUT_ABORT-AFTER-SECONDS",void 0,0);if(g!==void 0&&E!==void 0)throw new Error("Only one of continue-after-seconds and abort-after-seconds may be defined");let d=Ys(t,"INPUT_INITIAL-WAIT-SECONDS",0,0)??0,B=t["INPUT_SAME-BRANCH-ONLY"]==="true"||!t["INPUT_SAME-BRANCH-ONLY"],p=t["INPUT_JOB-TO-WAIT-FOR"],w=t["INPUT_STEP-TO-WAIT-FOR"],I=t["INPUT_QUEUE-NAME"],y=Ys(t,"INPUT_RETRIES",0,0)??0;if(w&&!p)throw new Error("step-to-wait-for requires job-to-wait-for to be defined");return{githubToken:e,owner:r,repo:A,branch:i,workflowName:s,workflowPath:o,runId:a,runAttempt:c,pollIntervalSeconds:l,continueAfterSeconds:g,abortAfterSeconds:E,sameBranchOnly:B,jobToWaitFor:p,stepToWaitFor:w,initialWaitSeconds:d,queueName:I,retries:y}};var iM=new Set(["in_progress","queued","waiting"]),aM=500,jn=t=>{if(!t)return;let e=Date.parse(t);return Number.isNaN(e)?void 0:e},Xn=t=>jn(t.run_started_at)||jn(t.created_at),cM=t=>jn(t.run_started_at),gM=t=>jn(t.created_at),uM=t=>(t.run_attempt||1)>1,lM=t=>iM.has(t.status||""),EM=(t,e)=>!e.sameBranchOnly||t.head_branch===e.branch,Kp=(t,e)=>t.filter(lM).filter(r=>EM(r,e)),jp=(t,e)=>t.find(r=>r.id===e.runId&&r.run_attempt===e.runAttempt)||t.find(r=>r.id===e.runId),hM=(t,e,r)=>{if(t.id===e.runId)return!1;if(uM(t)){let o=cM(t);return r===void 0||o===void 0?!1:o{let r=Xn(t),A=Xn(e);return r!==void 0&&A!==void 0&&r!==A?A-r:e.id-t.id},$p=t=>{SA("previous_run_id",t?String(t.id):""),SA("previous_run_url",t?.html_url||"")},QM=t=>t instanceof Error?t.message:String(t),$n=class{info;debug;input;githubClient;workflowId;previousRunOutput;constructor(e,r,A,s,o){this.workflowId=e,this.input=A,this.githubClient=r,this.info=s,this.debug=o}setPreviousRunOutput=e=>{this.previousRunOutput&&Xp(e,this.previousRunOutput)>=0||(this.previousRunOutput=e,$p(e))};clearPreviousRunOutput=()=>{this.previousRunOutput||$p(void 0)};abortError=e=>(this.info("\u{1F6D1}Exceeded wait seconds. Aborting..."),SA("force_continued",""),this.clearPreviousRunOutput(),new Error(`Aborted after waiting ${e} seconds`));abort=e=>{throw this.abortError(e)};withAbortTimeout=async(e,r)=>{if(this.input.abortAfterSeconds===void 0)return r(void 0);let A=this.input.abortAfterSeconds;e>=A&&this.abort(e);let s=(A-e)*1e3,o=new AbortController,n,i=new Promise((a,c)=>{n=setTimeout(()=>{o.abort(),c(this.abortError(A))},s)});try{return await Promise.race([r(o.signal),i])}finally{n&&clearTimeout(n)}};wait=async e=>{let r=e||0;if(this.input.continueAfterSeconds!==void 0&&r>=this.input.continueAfterSeconds)return this.info("\u{1F919}Exceeded wait seconds. Continuing..."),SA("force_continued","1"),this.clearPreviousRunOutput(),r;this.input.abortAfterSeconds!==void 0&&r>=this.input.abortAfterSeconds&&this.abort(r),this.debug(`Fetching workflow runs for workflow ID: ${this.workflowId}`);let A=this.input.queueName,{currentRun:s,filteredRuns:o}=await this.withAbortTimeout(r,async c=>{let l=c?{signal:c}:void 0,g;try{g=l?await this.githubClient.run(this.input.owner,this.input.repo,this.input.runId,l):await this.githubClient.run(this.input.owner,this.input.repo,this.input.runId)}catch(p){this.debug(`Failed to fetch current run ${this.input.runId}: ${QM(p)}`)}let E={branch:this.input.sameBranchOnly?this.input.branch:void 0},d=l?await this.githubClient.runs(this.input.owner,this.input.repo,this.workflowId,E,l):await this.githubClient.runs(this.input.owner,this.input.repo,this.workflowId,E);this.debug(`Found ${d.length} ${this.workflowId} runs`),g=g||jp(d,this.input);let B=Kp(d,this.input);if(A){this.debug(`Searching active workflow runs across repository for queue name: ${A}`);let p=l?await this.githubClient.activeRunsForRepo(this.input.owner,this.input.repo,E,l):await this.githubClient.activeRunsForRepo(this.input.owner,this.input.repo,E);g=g||jp(p,this.input),B=Kp(p,this.input).filter(w=>{let I=w.display_title?.includes(A)||w.name?.includes(A);return I&&this.debug(`Run ${w.id} (${w.display_title||w.name}) matches queue: "${A}"`),I}),this.debug(`After queue filtering: ${B.length} runs match queue "${A}"`)}return{currentRun:g,filteredRuns:B}}),n=s?Xn(s):void 0;n!==void 0&&this.debug("Found current run "+this.input.runId+" attempt "+this.input.runAttempt+" at "+new Date(n).toISOString());let i=o.filter(c=>hM(c,this.input,n)).filter(c=>{let l=c.conclusion==="success";return l&&this.debug(`Skipping run ${c.id}, status: ${c.status}, conclusion: ${c.conclusion}`),!l}).sort(Xp).slice(0,aM);if(!i||!i.length)return SA("force_continued",""),this.clearPreviousRunOutput(),this.input.initialWaitSeconds>0&&rsetTimeout(c,this.input.initialWaitSeconds*1e3)),this.wait(r+this.input.initialWaitSeconds)):void 0;if(this.debug(`Found ${i.length} previous runs`),this.input.jobToWaitFor){for(let c of i){this.debug(`Fetching jobs for run ${c.id}`);let g=(await this.githubClient.jobs(this.input.owner,this.input.repo,c.id)).find(E=>E.name===this.input.jobToWaitFor);if(this.input.stepToWaitFor&&g){this.debug(`Fetching steps for job ${g.id}`);let d=(await this.githubClient.steps(this.input.owner,this.input.repo,g.id)).find(B=>B.name===this.input.stepToWaitFor);if(d&&d.status!=="completed")return this.setPreviousRunOutput(c),this.info(`\u270BAwaiting step completion from job ${g.html_url} ...`),this.pollAndWait(e);if(d){this.info(`Step ${this.input.stepToWaitFor} completed from run ${c.html_url}`);continue}else this.info(`Step ${this.input.stepToWaitFor} not found in job ${g.id}, awaiting full run for safety`)}if(g&&g.status!=="completed")return this.setPreviousRunOutput(c),this.info(`\u270BAwaiting job run completion from job ${g.html_url} ...`),this.pollAndWait(e);if(g){this.info(`Job ${this.input.jobToWaitFor} completed from run ${c.html_url}`);continue}else this.info(`Job ${this.input.jobToWaitFor} not found in run ${c.id}, awaiting full run for safety`);return this.setPreviousRunOutput(c),this.info(`\u270BAwaiting run ${c.html_url} ...`),this.pollAndWait(e)}this.clearPreviousRunOutput();return}let a=i[0];return this.setPreviousRunOutput(a),this.info(`\u270BAwaiting run ${a.html_url} ...`),this.pollAndWait(e)};pollAndWait=async e=>(await new Promise(r=>setTimeout(r,this.input.pollIntervalSeconds*1e3)),this.wait((e||0)+this.input.pollIntervalSeconds))};var ef=(t,e)=>((e.workflowPath?t.find(A=>A.path===e.workflowPath):void 0)||t.find(A=>A.name===e.workflowName))?.id;var BM=(t,e)=>new Kn(t,e),dM=(t,e,r)=>new $n(t,e,r,gp,FA),IM=t=>t instanceof Error?t.message:String(t);async function rf(t=tf.env,e=BM,r=dM){try{let A=Zp(t);FA(`Parsed inputs (w/o token): ${(({githubToken:i,...a})=>JSON.stringify(a))(A)}`);let s=e(A.githubToken,A.retries);FA(`Fetching workflows for ${A.owner}/${A.repo}...`);let o=await s.workflows(A.owner,A.repo);FA(`Found ${o.length} workflows in ${A.owner}/${A.repo}`);let n=ef(o,A);n!==void 0?await r(n,s,A).wait():Lg(`No workflow found matching workflow path or name: ${A.workflowPath||A.workflowName}`)}catch(A){Lg(IM(A))}}require.main===module&&rf();0&&(module.exports={run}); +`)}var VG=class extends Error{constructor(t,e,r){super(PG(r)),this.request=t,this.headers=e,this.response=r,this.errors=r.errors,this.data=r.data,Error.captureStackTrace&&Error.captureStackTrace(this,this.constructor)}name="GraphqlResponseError";errors;data},qG=["method","baseUrl","url","headers","request","query","mediaType","operationName"],WG=["query","method","url"],Jp=/\/api\/v3\/?$/;function zG(t,e,r){if(r){if(typeof e=="string"&&"query"in r)return Promise.reject(new Error('[@octokit/graphql] "query" cannot be used as variable name'));for(let n in r)if(WG.includes(n))return Promise.reject(new Error(`[@octokit/graphql] "${n}" cannot be used as variable name`))}let A=typeof e=="string"?Object.assign({query:e},r):e,s=Object.keys(A).reduce((n,i)=>qG.includes(i)?(n[i]=A[i],n):(n.variables||(n.variables={}),n.variables[i]=A[i],n),{}),o=A.baseUrl||t.endpoint.DEFAULTS.baseUrl;return Jp.test(o)&&(s.url=o.replace(Jp,"/api/graphql")),t(s).then(n=>{if(n.data.errors){let i={};for(let a of Object.keys(n.headers))i[a]=n.headers[a];throw new VG(s,i,n.data)}return n.data.data})}function jg(t,e){let r=t.defaults(e);return Object.assign((s,o)=>zG(r,s,o),{defaults:jg.bind(null,r),endpoint:r.endpoint})}var Ax=jg(Js,{headers:{"user-agent":`octokit-graphql.js/${HG} ${or()}`},method:"POST",url:"/graphql"});function Hp(t){return jg(t,{method:"POST",url:"/graphql"})}var Xg="(?:[a-zA-Z0-9_-]+)",Pp="\\.",Vp=new RegExp(`^${Xg}${Pp}${Xg}${Pp}${Xg}$`),ZG=Vp.test.bind(Vp);async function KG(t){let e=ZG(t),r=t.startsWith("v1.")||t.startsWith("ghs_"),A=t.startsWith("ghu_");return{type:"token",token:t,tokenType:e?"app":r?"installation":A?"user-to-server":"oauth"}}function jG(t){return t.split(/\./).length===3?`bearer ${t}`:`token ${t}`}async function XG(t,e,r,A){let s=e.endpoint.merge(r,A);return s.headers.authorization=jG(t),e(s)}var qp=function(e){if(!e)throw new Error("[@octokit/auth-token] No token passed to createTokenAuth");if(typeof e!="string")throw new Error("[@octokit/auth-token] Token passed to createTokenAuth is not a string");return e=e.replace(/^(token|bearer) +/i,""),Object.assign(KG.bind(null,e),{hook:XG.bind(null,e)})};var $g="7.0.6";var Wp=()=>{},$G=console.warn.bind(console),eM=console.error.bind(console);function tM(t={}){return typeof t.debug!="function"&&(t.debug=Wp),typeof t.info!="function"&&(t.info=Wp),typeof t.warn!="function"&&(t.warn=$G),typeof t.error!="function"&&(t.error=eM),t}var zp=`octokit-core.js/${$g} ${or()}`,ei=class{static VERSION=$g;static defaults(e){return class extends this{constructor(...A){let s=A[0]||{};if(typeof e=="function"){super(e(s));return}super(Object.assign({},e,s,s.userAgent&&e.userAgent?{userAgent:`${s.userAgent} ${e.userAgent}`}:null))}}}static plugins=[];static plugin(...e){let r=this.plugins;return class extends this{static plugins=r.concat(e.filter(s=>!r.includes(s)))}}constructor(e={}){let r=new Rp.Collection,A={baseUrl:Js.endpoint.DEFAULTS.baseUrl,headers:{},request:Object.assign({},e.request,{hook:r.bind(null,"request")}),mediaType:{previews:[],format:""}};if(A.headers["user-agent"]=e.userAgent?`${e.userAgent} ${zp}`:zp,e.baseUrl&&(A.baseUrl=e.baseUrl),e.previews&&(A.mediaType.previews=e.previews),e.timeZone&&(A.headers["time-zone"]=e.timeZone),this.request=Js.defaults(A),this.graphql=Hp(this.request).defaults(A),this.log=tM(e.log),this.hook=r,e.authStrategy){let{authStrategy:o,...n}=e,i=o(Object.assign({request:this.request,log:this.log,octokit:this,octokitOptions:n},e.auth));r.wrap("request",i.hook),this.auth=i}else if(!e.auth)this.auth=async()=>({type:"unauthenticated"});else{let o=qp(e.auth);r.wrap("request",o.hook),this.auth=o}let s=this.constructor;for(let o=0;o{t.log.debug("request",r);let A=Date.now(),s=t.request.endpoint.parse(r),o=s.url.replace(r.baseUrl,"");return e(r).then(n=>{let i=n.headers["x-github-request-id"];return t.log.info(`${s.method} ${o} - ${n.status} with id ${i} in ${Date.now()-A}ms`),n}).catch(n=>{let i=n.response?.headers["x-github-request-id"]||"UNKNOWN";throw t.log.error(`${s.method} ${o} - ${n.status} with id ${i} in ${Date.now()-A}ms`),n})})}eu.VERSION=Zp;var rM="0.0.0-development";function AM(t){if(!t.data)return{...t,data:[]};if(!(("total_count"in t.data||"total_commits"in t.data)&&!("url"in t.data)))return t;let r=t.data.incomplete_results,A=t.data.repository_selection,s=t.data.total_count,o=t.data.total_commits;delete t.data.incomplete_results,delete t.data.repository_selection,delete t.data.total_count,delete t.data.total_commits;let n=Object.keys(t.data)[0],i=t.data[n];return t.data=i,typeof r<"u"&&(t.data.incomplete_results=r),typeof A<"u"&&(t.data.repository_selection=A),t.data.total_count=s,t.data.total_commits=o,t}function tu(t,e,r){let A=typeof e=="function"?e.endpoint(r):t.request.endpoint(e,r),s=typeof e=="function"?e:t.request,o=A.method,n=A.headers,i=A.url;return{[Symbol.asyncIterator]:()=>({async next(){if(!i)return{done:!0};try{let a=await s({method:o,url:i,headers:n}),c=AM(a);if(i=((c.headers.link||"").match(/<([^<>]+)>;\s*rel="next"/)||[])[1],!i&&"total_commits"in c.data){let u=new URL(c.url),g=u.searchParams,E=parseInt(g.get("page")||"1",10),I=parseInt(g.get("per_page")||"250",10);E*I{if(s.done)return e;let o=!1;function n(){o=!0}return e=e.concat(A?A(s.value,n):s.value.data),o?e:jp(t,e,r,A)})}var px=Object.assign(Kp,{iterator:tu});function ru(t){return{paginate:Object.assign(Kp.bind(null,t),{iterator:tu.bind(null,t)})}}ru.VERSION=rM;var Au="17.0.0";var sM={actions:{addCustomLabelsToSelfHostedRunnerForOrg:["POST /orgs/{org}/actions/runners/{runner_id}/labels"],addCustomLabelsToSelfHostedRunnerForRepo:["POST /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],addRepoAccessToSelfHostedRunnerGroupInOrg:["PUT /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories/{repository_id}"],addSelectedRepoToOrgSecret:["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],addSelectedRepoToOrgVariable:["PUT /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"],approveWorkflowRun:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/approve"],cancelWorkflowRun:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel"],createEnvironmentVariable:["POST /repos/{owner}/{repo}/environments/{environment_name}/variables"],createHostedRunnerForOrg:["POST /orgs/{org}/actions/hosted-runners"],createOrUpdateEnvironmentSecret:["PUT /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"],createOrUpdateOrgSecret:["PUT /orgs/{org}/actions/secrets/{secret_name}"],createOrUpdateRepoSecret:["PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}"],createOrgVariable:["POST /orgs/{org}/actions/variables"],createRegistrationTokenForOrg:["POST /orgs/{org}/actions/runners/registration-token"],createRegistrationTokenForRepo:["POST /repos/{owner}/{repo}/actions/runners/registration-token"],createRemoveTokenForOrg:["POST /orgs/{org}/actions/runners/remove-token"],createRemoveTokenForRepo:["POST /repos/{owner}/{repo}/actions/runners/remove-token"],createRepoVariable:["POST /repos/{owner}/{repo}/actions/variables"],createWorkflowDispatch:["POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches"],deleteActionsCacheById:["DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}"],deleteActionsCacheByKey:["DELETE /repos/{owner}/{repo}/actions/caches{?key,ref}"],deleteArtifact:["DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],deleteCustomImageFromOrg:["DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}"],deleteCustomImageVersionFromOrg:["DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}"],deleteEnvironmentSecret:["DELETE /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"],deleteEnvironmentVariable:["DELETE /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"],deleteHostedRunnerForOrg:["DELETE /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"],deleteOrgSecret:["DELETE /orgs/{org}/actions/secrets/{secret_name}"],deleteOrgVariable:["DELETE /orgs/{org}/actions/variables/{name}"],deleteRepoSecret:["DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}"],deleteRepoVariable:["DELETE /repos/{owner}/{repo}/actions/variables/{name}"],deleteSelfHostedRunnerFromOrg:["DELETE /orgs/{org}/actions/runners/{runner_id}"],deleteSelfHostedRunnerFromRepo:["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}"],deleteWorkflowRun:["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}"],deleteWorkflowRunLogs:["DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],disableSelectedRepositoryGithubActionsOrganization:["DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}"],disableWorkflow:["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable"],downloadArtifact:["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}"],downloadJobLogsForWorkflowRun:["GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs"],downloadWorkflowRunAttemptLogs:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs"],downloadWorkflowRunLogs:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs"],enableSelectedRepositoryGithubActionsOrganization:["PUT /orgs/{org}/actions/permissions/repositories/{repository_id}"],enableWorkflow:["PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable"],forceCancelWorkflowRun:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/force-cancel"],generateRunnerJitconfigForOrg:["POST /orgs/{org}/actions/runners/generate-jitconfig"],generateRunnerJitconfigForRepo:["POST /repos/{owner}/{repo}/actions/runners/generate-jitconfig"],getActionsCacheList:["GET /repos/{owner}/{repo}/actions/caches"],getActionsCacheUsage:["GET /repos/{owner}/{repo}/actions/cache/usage"],getActionsCacheUsageByRepoForOrg:["GET /orgs/{org}/actions/cache/usage-by-repository"],getActionsCacheUsageForOrg:["GET /orgs/{org}/actions/cache/usage"],getAllowedActionsOrganization:["GET /orgs/{org}/actions/permissions/selected-actions"],getAllowedActionsRepository:["GET /repos/{owner}/{repo}/actions/permissions/selected-actions"],getArtifact:["GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}"],getCustomImageForOrg:["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}"],getCustomImageVersionForOrg:["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}"],getCustomOidcSubClaimForRepo:["GET /repos/{owner}/{repo}/actions/oidc/customization/sub"],getEnvironmentPublicKey:["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/public-key"],getEnvironmentSecret:["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}"],getEnvironmentVariable:["GET /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"],getGithubActionsDefaultWorkflowPermissionsOrganization:["GET /orgs/{org}/actions/permissions/workflow"],getGithubActionsDefaultWorkflowPermissionsRepository:["GET /repos/{owner}/{repo}/actions/permissions/workflow"],getGithubActionsPermissionsOrganization:["GET /orgs/{org}/actions/permissions"],getGithubActionsPermissionsRepository:["GET /repos/{owner}/{repo}/actions/permissions"],getHostedRunnerForOrg:["GET /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"],getHostedRunnersGithubOwnedImagesForOrg:["GET /orgs/{org}/actions/hosted-runners/images/github-owned"],getHostedRunnersLimitsForOrg:["GET /orgs/{org}/actions/hosted-runners/limits"],getHostedRunnersMachineSpecsForOrg:["GET /orgs/{org}/actions/hosted-runners/machine-sizes"],getHostedRunnersPartnerImagesForOrg:["GET /orgs/{org}/actions/hosted-runners/images/partner"],getHostedRunnersPlatformsForOrg:["GET /orgs/{org}/actions/hosted-runners/platforms"],getJobForWorkflowRun:["GET /repos/{owner}/{repo}/actions/jobs/{job_id}"],getOrgPublicKey:["GET /orgs/{org}/actions/secrets/public-key"],getOrgSecret:["GET /orgs/{org}/actions/secrets/{secret_name}"],getOrgVariable:["GET /orgs/{org}/actions/variables/{name}"],getPendingDeploymentsForRun:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"],getRepoPermissions:["GET /repos/{owner}/{repo}/actions/permissions",{},{renamed:["actions","getGithubActionsPermissionsRepository"]}],getRepoPublicKey:["GET /repos/{owner}/{repo}/actions/secrets/public-key"],getRepoSecret:["GET /repos/{owner}/{repo}/actions/secrets/{secret_name}"],getRepoVariable:["GET /repos/{owner}/{repo}/actions/variables/{name}"],getReviewsForRun:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/approvals"],getSelfHostedRunnerForOrg:["GET /orgs/{org}/actions/runners/{runner_id}"],getSelfHostedRunnerForRepo:["GET /repos/{owner}/{repo}/actions/runners/{runner_id}"],getWorkflow:["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}"],getWorkflowAccessToRepository:["GET /repos/{owner}/{repo}/actions/permissions/access"],getWorkflowRun:["GET /repos/{owner}/{repo}/actions/runs/{run_id}"],getWorkflowRunAttempt:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}"],getWorkflowRunUsage:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing"],getWorkflowUsage:["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing"],listArtifactsForRepo:["GET /repos/{owner}/{repo}/actions/artifacts"],listCustomImageVersionsForOrg:["GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions"],listCustomImagesForOrg:["GET /orgs/{org}/actions/hosted-runners/images/custom"],listEnvironmentSecrets:["GET /repos/{owner}/{repo}/environments/{environment_name}/secrets"],listEnvironmentVariables:["GET /repos/{owner}/{repo}/environments/{environment_name}/variables"],listGithubHostedRunnersInGroupForOrg:["GET /orgs/{org}/actions/runner-groups/{runner_group_id}/hosted-runners"],listHostedRunnersForOrg:["GET /orgs/{org}/actions/hosted-runners"],listJobsForWorkflowRun:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs"],listJobsForWorkflowRunAttempt:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs"],listLabelsForSelfHostedRunnerForOrg:["GET /orgs/{org}/actions/runners/{runner_id}/labels"],listLabelsForSelfHostedRunnerForRepo:["GET /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],listOrgSecrets:["GET /orgs/{org}/actions/secrets"],listOrgVariables:["GET /orgs/{org}/actions/variables"],listRepoOrganizationSecrets:["GET /repos/{owner}/{repo}/actions/organization-secrets"],listRepoOrganizationVariables:["GET /repos/{owner}/{repo}/actions/organization-variables"],listRepoSecrets:["GET /repos/{owner}/{repo}/actions/secrets"],listRepoVariables:["GET /repos/{owner}/{repo}/actions/variables"],listRepoWorkflows:["GET /repos/{owner}/{repo}/actions/workflows"],listRunnerApplicationsForOrg:["GET /orgs/{org}/actions/runners/downloads"],listRunnerApplicationsForRepo:["GET /repos/{owner}/{repo}/actions/runners/downloads"],listSelectedReposForOrgSecret:["GET /orgs/{org}/actions/secrets/{secret_name}/repositories"],listSelectedReposForOrgVariable:["GET /orgs/{org}/actions/variables/{name}/repositories"],listSelectedRepositoriesEnabledGithubActionsOrganization:["GET /orgs/{org}/actions/permissions/repositories"],listSelfHostedRunnersForOrg:["GET /orgs/{org}/actions/runners"],listSelfHostedRunnersForRepo:["GET /repos/{owner}/{repo}/actions/runners"],listWorkflowRunArtifacts:["GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts"],listWorkflowRuns:["GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs"],listWorkflowRunsForRepo:["GET /repos/{owner}/{repo}/actions/runs"],reRunJobForWorkflowRun:["POST /repos/{owner}/{repo}/actions/jobs/{job_id}/rerun"],reRunWorkflow:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun"],reRunWorkflowFailedJobs:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs"],removeAllCustomLabelsFromSelfHostedRunnerForOrg:["DELETE /orgs/{org}/actions/runners/{runner_id}/labels"],removeAllCustomLabelsFromSelfHostedRunnerForRepo:["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],removeCustomLabelFromSelfHostedRunnerForOrg:["DELETE /orgs/{org}/actions/runners/{runner_id}/labels/{name}"],removeCustomLabelFromSelfHostedRunnerForRepo:["DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}/labels/{name}"],removeSelectedRepoFromOrgSecret:["DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}"],removeSelectedRepoFromOrgVariable:["DELETE /orgs/{org}/actions/variables/{name}/repositories/{repository_id}"],reviewCustomGatesForRun:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/deployment_protection_rule"],reviewPendingDeploymentsForRun:["POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments"],setAllowedActionsOrganization:["PUT /orgs/{org}/actions/permissions/selected-actions"],setAllowedActionsRepository:["PUT /repos/{owner}/{repo}/actions/permissions/selected-actions"],setCustomLabelsForSelfHostedRunnerForOrg:["PUT /orgs/{org}/actions/runners/{runner_id}/labels"],setCustomLabelsForSelfHostedRunnerForRepo:["PUT /repos/{owner}/{repo}/actions/runners/{runner_id}/labels"],setCustomOidcSubClaimForRepo:["PUT /repos/{owner}/{repo}/actions/oidc/customization/sub"],setGithubActionsDefaultWorkflowPermissionsOrganization:["PUT /orgs/{org}/actions/permissions/workflow"],setGithubActionsDefaultWorkflowPermissionsRepository:["PUT /repos/{owner}/{repo}/actions/permissions/workflow"],setGithubActionsPermissionsOrganization:["PUT /orgs/{org}/actions/permissions"],setGithubActionsPermissionsRepository:["PUT /repos/{owner}/{repo}/actions/permissions"],setSelectedReposForOrgSecret:["PUT /orgs/{org}/actions/secrets/{secret_name}/repositories"],setSelectedReposForOrgVariable:["PUT /orgs/{org}/actions/variables/{name}/repositories"],setSelectedRepositoriesEnabledGithubActionsOrganization:["PUT /orgs/{org}/actions/permissions/repositories"],setWorkflowAccessToRepository:["PUT /repos/{owner}/{repo}/actions/permissions/access"],updateEnvironmentVariable:["PATCH /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}"],updateHostedRunnerForOrg:["PATCH /orgs/{org}/actions/hosted-runners/{hosted_runner_id}"],updateOrgVariable:["PATCH /orgs/{org}/actions/variables/{name}"],updateRepoVariable:["PATCH /repos/{owner}/{repo}/actions/variables/{name}"]},activity:{checkRepoIsStarredByAuthenticatedUser:["GET /user/starred/{owner}/{repo}"],deleteRepoSubscription:["DELETE /repos/{owner}/{repo}/subscription"],deleteThreadSubscription:["DELETE /notifications/threads/{thread_id}/subscription"],getFeeds:["GET /feeds"],getRepoSubscription:["GET /repos/{owner}/{repo}/subscription"],getThread:["GET /notifications/threads/{thread_id}"],getThreadSubscriptionForAuthenticatedUser:["GET /notifications/threads/{thread_id}/subscription"],listEventsForAuthenticatedUser:["GET /users/{username}/events"],listNotificationsForAuthenticatedUser:["GET /notifications"],listOrgEventsForAuthenticatedUser:["GET /users/{username}/events/orgs/{org}"],listPublicEvents:["GET /events"],listPublicEventsForRepoNetwork:["GET /networks/{owner}/{repo}/events"],listPublicEventsForUser:["GET /users/{username}/events/public"],listPublicOrgEvents:["GET /orgs/{org}/events"],listReceivedEventsForUser:["GET /users/{username}/received_events"],listReceivedPublicEventsForUser:["GET /users/{username}/received_events/public"],listRepoEvents:["GET /repos/{owner}/{repo}/events"],listRepoNotificationsForAuthenticatedUser:["GET /repos/{owner}/{repo}/notifications"],listReposStarredByAuthenticatedUser:["GET /user/starred"],listReposStarredByUser:["GET /users/{username}/starred"],listReposWatchedByUser:["GET /users/{username}/subscriptions"],listStargazersForRepo:["GET /repos/{owner}/{repo}/stargazers"],listWatchedReposForAuthenticatedUser:["GET /user/subscriptions"],listWatchersForRepo:["GET /repos/{owner}/{repo}/subscribers"],markNotificationsAsRead:["PUT /notifications"],markRepoNotificationsAsRead:["PUT /repos/{owner}/{repo}/notifications"],markThreadAsDone:["DELETE /notifications/threads/{thread_id}"],markThreadAsRead:["PATCH /notifications/threads/{thread_id}"],setRepoSubscription:["PUT /repos/{owner}/{repo}/subscription"],setThreadSubscription:["PUT /notifications/threads/{thread_id}/subscription"],starRepoForAuthenticatedUser:["PUT /user/starred/{owner}/{repo}"],unstarRepoForAuthenticatedUser:["DELETE /user/starred/{owner}/{repo}"]},apps:{addRepoToInstallation:["PUT /user/installations/{installation_id}/repositories/{repository_id}",{},{renamed:["apps","addRepoToInstallationForAuthenticatedUser"]}],addRepoToInstallationForAuthenticatedUser:["PUT /user/installations/{installation_id}/repositories/{repository_id}"],checkToken:["POST /applications/{client_id}/token"],createFromManifest:["POST /app-manifests/{code}/conversions"],createInstallationAccessToken:["POST /app/installations/{installation_id}/access_tokens"],deleteAuthorization:["DELETE /applications/{client_id}/grant"],deleteInstallation:["DELETE /app/installations/{installation_id}"],deleteToken:["DELETE /applications/{client_id}/token"],getAuthenticated:["GET /app"],getBySlug:["GET /apps/{app_slug}"],getInstallation:["GET /app/installations/{installation_id}"],getOrgInstallation:["GET /orgs/{org}/installation"],getRepoInstallation:["GET /repos/{owner}/{repo}/installation"],getSubscriptionPlanForAccount:["GET /marketplace_listing/accounts/{account_id}"],getSubscriptionPlanForAccountStubbed:["GET /marketplace_listing/stubbed/accounts/{account_id}"],getUserInstallation:["GET /users/{username}/installation"],getWebhookConfigForApp:["GET /app/hook/config"],getWebhookDelivery:["GET /app/hook/deliveries/{delivery_id}"],listAccountsForPlan:["GET /marketplace_listing/plans/{plan_id}/accounts"],listAccountsForPlanStubbed:["GET /marketplace_listing/stubbed/plans/{plan_id}/accounts"],listInstallationReposForAuthenticatedUser:["GET /user/installations/{installation_id}/repositories"],listInstallationRequestsForAuthenticatedApp:["GET /app/installation-requests"],listInstallations:["GET /app/installations"],listInstallationsForAuthenticatedUser:["GET /user/installations"],listPlans:["GET /marketplace_listing/plans"],listPlansStubbed:["GET /marketplace_listing/stubbed/plans"],listReposAccessibleToInstallation:["GET /installation/repositories"],listSubscriptionsForAuthenticatedUser:["GET /user/marketplace_purchases"],listSubscriptionsForAuthenticatedUserStubbed:["GET /user/marketplace_purchases/stubbed"],listWebhookDeliveries:["GET /app/hook/deliveries"],redeliverWebhookDelivery:["POST /app/hook/deliveries/{delivery_id}/attempts"],removeRepoFromInstallation:["DELETE /user/installations/{installation_id}/repositories/{repository_id}",{},{renamed:["apps","removeRepoFromInstallationForAuthenticatedUser"]}],removeRepoFromInstallationForAuthenticatedUser:["DELETE /user/installations/{installation_id}/repositories/{repository_id}"],resetToken:["PATCH /applications/{client_id}/token"],revokeInstallationAccessToken:["DELETE /installation/token"],scopeToken:["POST /applications/{client_id}/token/scoped"],suspendInstallation:["PUT /app/installations/{installation_id}/suspended"],unsuspendInstallation:["DELETE /app/installations/{installation_id}/suspended"],updateWebhookConfigForApp:["PATCH /app/hook/config"]},billing:{getGithubActionsBillingOrg:["GET /orgs/{org}/settings/billing/actions"],getGithubActionsBillingUser:["GET /users/{username}/settings/billing/actions"],getGithubBillingPremiumRequestUsageReportOrg:["GET /organizations/{org}/settings/billing/premium_request/usage"],getGithubBillingPremiumRequestUsageReportUser:["GET /users/{username}/settings/billing/premium_request/usage"],getGithubBillingUsageReportOrg:["GET /organizations/{org}/settings/billing/usage"],getGithubBillingUsageReportUser:["GET /users/{username}/settings/billing/usage"],getGithubPackagesBillingOrg:["GET /orgs/{org}/settings/billing/packages"],getGithubPackagesBillingUser:["GET /users/{username}/settings/billing/packages"],getSharedStorageBillingOrg:["GET /orgs/{org}/settings/billing/shared-storage"],getSharedStorageBillingUser:["GET /users/{username}/settings/billing/shared-storage"]},campaigns:{createCampaign:["POST /orgs/{org}/campaigns"],deleteCampaign:["DELETE /orgs/{org}/campaigns/{campaign_number}"],getCampaignSummary:["GET /orgs/{org}/campaigns/{campaign_number}"],listOrgCampaigns:["GET /orgs/{org}/campaigns"],updateCampaign:["PATCH /orgs/{org}/campaigns/{campaign_number}"]},checks:{create:["POST /repos/{owner}/{repo}/check-runs"],createSuite:["POST /repos/{owner}/{repo}/check-suites"],get:["GET /repos/{owner}/{repo}/check-runs/{check_run_id}"],getSuite:["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}"],listAnnotations:["GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations"],listForRef:["GET /repos/{owner}/{repo}/commits/{ref}/check-runs"],listForSuite:["GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs"],listSuitesForRef:["GET /repos/{owner}/{repo}/commits/{ref}/check-suites"],rerequestRun:["POST /repos/{owner}/{repo}/check-runs/{check_run_id}/rerequest"],rerequestSuite:["POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest"],setSuitesPreferences:["PATCH /repos/{owner}/{repo}/check-suites/preferences"],update:["PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}"]},codeScanning:{commitAutofix:["POST /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix/commits"],createAutofix:["POST /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix"],createVariantAnalysis:["POST /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses"],deleteAnalysis:["DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}{?confirm_delete}"],deleteCodeqlDatabase:["DELETE /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"],getAlert:["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}",{},{renamedParameters:{alert_id:"alert_number"}}],getAnalysis:["GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}"],getAutofix:["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/autofix"],getCodeqlDatabase:["GET /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}"],getDefaultSetup:["GET /repos/{owner}/{repo}/code-scanning/default-setup"],getSarif:["GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}"],getVariantAnalysis:["GET /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses/{codeql_variant_analysis_id}"],getVariantAnalysisRepoTask:["GET /repos/{owner}/{repo}/code-scanning/codeql/variant-analyses/{codeql_variant_analysis_id}/repos/{repo_owner}/{repo_name}"],listAlertInstances:["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances"],listAlertsForOrg:["GET /orgs/{org}/code-scanning/alerts"],listAlertsForRepo:["GET /repos/{owner}/{repo}/code-scanning/alerts"],listAlertsInstances:["GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances",{},{renamed:["codeScanning","listAlertInstances"]}],listCodeqlDatabases:["GET /repos/{owner}/{repo}/code-scanning/codeql/databases"],listRecentAnalyses:["GET /repos/{owner}/{repo}/code-scanning/analyses"],updateAlert:["PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}"],updateDefaultSetup:["PATCH /repos/{owner}/{repo}/code-scanning/default-setup"],uploadSarif:["POST /repos/{owner}/{repo}/code-scanning/sarifs"]},codeSecurity:{attachConfiguration:["POST /orgs/{org}/code-security/configurations/{configuration_id}/attach"],attachEnterpriseConfiguration:["POST /enterprises/{enterprise}/code-security/configurations/{configuration_id}/attach"],createConfiguration:["POST /orgs/{org}/code-security/configurations"],createConfigurationForEnterprise:["POST /enterprises/{enterprise}/code-security/configurations"],deleteConfiguration:["DELETE /orgs/{org}/code-security/configurations/{configuration_id}"],deleteConfigurationForEnterprise:["DELETE /enterprises/{enterprise}/code-security/configurations/{configuration_id}"],detachConfiguration:["DELETE /orgs/{org}/code-security/configurations/detach"],getConfiguration:["GET /orgs/{org}/code-security/configurations/{configuration_id}"],getConfigurationForRepository:["GET /repos/{owner}/{repo}/code-security-configuration"],getConfigurationsForEnterprise:["GET /enterprises/{enterprise}/code-security/configurations"],getConfigurationsForOrg:["GET /orgs/{org}/code-security/configurations"],getDefaultConfigurations:["GET /orgs/{org}/code-security/configurations/defaults"],getDefaultConfigurationsForEnterprise:["GET /enterprises/{enterprise}/code-security/configurations/defaults"],getRepositoriesForConfiguration:["GET /orgs/{org}/code-security/configurations/{configuration_id}/repositories"],getRepositoriesForEnterpriseConfiguration:["GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}/repositories"],getSingleConfigurationForEnterprise:["GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}"],setConfigurationAsDefault:["PUT /orgs/{org}/code-security/configurations/{configuration_id}/defaults"],setConfigurationAsDefaultForEnterprise:["PUT /enterprises/{enterprise}/code-security/configurations/{configuration_id}/defaults"],updateConfiguration:["PATCH /orgs/{org}/code-security/configurations/{configuration_id}"],updateEnterpriseConfiguration:["PATCH /enterprises/{enterprise}/code-security/configurations/{configuration_id}"]},codesOfConduct:{getAllCodesOfConduct:["GET /codes_of_conduct"],getConductCode:["GET /codes_of_conduct/{key}"]},codespaces:{addRepositoryForSecretForAuthenticatedUser:["PUT /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"],addSelectedRepoToOrgSecret:["PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"],checkPermissionsForDevcontainer:["GET /repos/{owner}/{repo}/codespaces/permissions_check"],codespaceMachinesForAuthenticatedUser:["GET /user/codespaces/{codespace_name}/machines"],createForAuthenticatedUser:["POST /user/codespaces"],createOrUpdateOrgSecret:["PUT /orgs/{org}/codespaces/secrets/{secret_name}"],createOrUpdateRepoSecret:["PUT /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"],createOrUpdateSecretForAuthenticatedUser:["PUT /user/codespaces/secrets/{secret_name}"],createWithPrForAuthenticatedUser:["POST /repos/{owner}/{repo}/pulls/{pull_number}/codespaces"],createWithRepoForAuthenticatedUser:["POST /repos/{owner}/{repo}/codespaces"],deleteForAuthenticatedUser:["DELETE /user/codespaces/{codespace_name}"],deleteFromOrganization:["DELETE /orgs/{org}/members/{username}/codespaces/{codespace_name}"],deleteOrgSecret:["DELETE /orgs/{org}/codespaces/secrets/{secret_name}"],deleteRepoSecret:["DELETE /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"],deleteSecretForAuthenticatedUser:["DELETE /user/codespaces/secrets/{secret_name}"],exportForAuthenticatedUser:["POST /user/codespaces/{codespace_name}/exports"],getCodespacesForUserInOrg:["GET /orgs/{org}/members/{username}/codespaces"],getExportDetailsForAuthenticatedUser:["GET /user/codespaces/{codespace_name}/exports/{export_id}"],getForAuthenticatedUser:["GET /user/codespaces/{codespace_name}"],getOrgPublicKey:["GET /orgs/{org}/codespaces/secrets/public-key"],getOrgSecret:["GET /orgs/{org}/codespaces/secrets/{secret_name}"],getPublicKeyForAuthenticatedUser:["GET /user/codespaces/secrets/public-key"],getRepoPublicKey:["GET /repos/{owner}/{repo}/codespaces/secrets/public-key"],getRepoSecret:["GET /repos/{owner}/{repo}/codespaces/secrets/{secret_name}"],getSecretForAuthenticatedUser:["GET /user/codespaces/secrets/{secret_name}"],listDevcontainersInRepositoryForAuthenticatedUser:["GET /repos/{owner}/{repo}/codespaces/devcontainers"],listForAuthenticatedUser:["GET /user/codespaces"],listInOrganization:["GET /orgs/{org}/codespaces",{},{renamedParameters:{org_id:"org"}}],listInRepositoryForAuthenticatedUser:["GET /repos/{owner}/{repo}/codespaces"],listOrgSecrets:["GET /orgs/{org}/codespaces/secrets"],listRepoSecrets:["GET /repos/{owner}/{repo}/codespaces/secrets"],listRepositoriesForSecretForAuthenticatedUser:["GET /user/codespaces/secrets/{secret_name}/repositories"],listSecretsForAuthenticatedUser:["GET /user/codespaces/secrets"],listSelectedReposForOrgSecret:["GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories"],preFlightWithRepoForAuthenticatedUser:["GET /repos/{owner}/{repo}/codespaces/new"],publishForAuthenticatedUser:["POST /user/codespaces/{codespace_name}/publish"],removeRepositoryForSecretForAuthenticatedUser:["DELETE /user/codespaces/secrets/{secret_name}/repositories/{repository_id}"],removeSelectedRepoFromOrgSecret:["DELETE /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}"],repoMachinesForAuthenticatedUser:["GET /repos/{owner}/{repo}/codespaces/machines"],setRepositoriesForSecretForAuthenticatedUser:["PUT /user/codespaces/secrets/{secret_name}/repositories"],setSelectedReposForOrgSecret:["PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories"],startForAuthenticatedUser:["POST /user/codespaces/{codespace_name}/start"],stopForAuthenticatedUser:["POST /user/codespaces/{codespace_name}/stop"],stopInOrganization:["POST /orgs/{org}/members/{username}/codespaces/{codespace_name}/stop"],updateForAuthenticatedUser:["PATCH /user/codespaces/{codespace_name}"]},copilot:{addCopilotSeatsForTeams:["POST /orgs/{org}/copilot/billing/selected_teams"],addCopilotSeatsForUsers:["POST /orgs/{org}/copilot/billing/selected_users"],cancelCopilotSeatAssignmentForTeams:["DELETE /orgs/{org}/copilot/billing/selected_teams"],cancelCopilotSeatAssignmentForUsers:["DELETE /orgs/{org}/copilot/billing/selected_users"],copilotMetricsForOrganization:["GET /orgs/{org}/copilot/metrics"],copilotMetricsForTeam:["GET /orgs/{org}/team/{team_slug}/copilot/metrics"],getCopilotOrganizationDetails:["GET /orgs/{org}/copilot/billing"],getCopilotSeatDetailsForUser:["GET /orgs/{org}/members/{username}/copilot"],listCopilotSeats:["GET /orgs/{org}/copilot/billing/seats"]},credentials:{revoke:["POST /credentials/revoke"]},dependabot:{addSelectedRepoToOrgSecret:["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"],createOrUpdateOrgSecret:["PUT /orgs/{org}/dependabot/secrets/{secret_name}"],createOrUpdateRepoSecret:["PUT /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"],deleteOrgSecret:["DELETE /orgs/{org}/dependabot/secrets/{secret_name}"],deleteRepoSecret:["DELETE /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"],getAlert:["GET /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"],getOrgPublicKey:["GET /orgs/{org}/dependabot/secrets/public-key"],getOrgSecret:["GET /orgs/{org}/dependabot/secrets/{secret_name}"],getRepoPublicKey:["GET /repos/{owner}/{repo}/dependabot/secrets/public-key"],getRepoSecret:["GET /repos/{owner}/{repo}/dependabot/secrets/{secret_name}"],listAlertsForEnterprise:["GET /enterprises/{enterprise}/dependabot/alerts"],listAlertsForOrg:["GET /orgs/{org}/dependabot/alerts"],listAlertsForRepo:["GET /repos/{owner}/{repo}/dependabot/alerts"],listOrgSecrets:["GET /orgs/{org}/dependabot/secrets"],listRepoSecrets:["GET /repos/{owner}/{repo}/dependabot/secrets"],listSelectedReposForOrgSecret:["GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories"],removeSelectedRepoFromOrgSecret:["DELETE /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}"],repositoryAccessForOrg:["GET /organizations/{org}/dependabot/repository-access"],setRepositoryAccessDefaultLevel:["PUT /organizations/{org}/dependabot/repository-access/default-level"],setSelectedReposForOrgSecret:["PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories"],updateAlert:["PATCH /repos/{owner}/{repo}/dependabot/alerts/{alert_number}"],updateRepositoryAccessForOrg:["PATCH /organizations/{org}/dependabot/repository-access"]},dependencyGraph:{createRepositorySnapshot:["POST /repos/{owner}/{repo}/dependency-graph/snapshots"],diffRange:["GET /repos/{owner}/{repo}/dependency-graph/compare/{basehead}"],exportSbom:["GET /repos/{owner}/{repo}/dependency-graph/sbom"]},emojis:{get:["GET /emojis"]},enterpriseTeamMemberships:{add:["PUT /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"],bulkAdd:["POST /enterprises/{enterprise}/teams/{enterprise-team}/memberships/add"],bulkRemove:["POST /enterprises/{enterprise}/teams/{enterprise-team}/memberships/remove"],get:["GET /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"],list:["GET /enterprises/{enterprise}/teams/{enterprise-team}/memberships"],remove:["DELETE /enterprises/{enterprise}/teams/{enterprise-team}/memberships/{username}"]},enterpriseTeamOrganizations:{add:["PUT /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"],bulkAdd:["POST /enterprises/{enterprise}/teams/{enterprise-team}/organizations/add"],bulkRemove:["POST /enterprises/{enterprise}/teams/{enterprise-team}/organizations/remove"],delete:["DELETE /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"],getAssignment:["GET /enterprises/{enterprise}/teams/{enterprise-team}/organizations/{org}"],getAssignments:["GET /enterprises/{enterprise}/teams/{enterprise-team}/organizations"]},enterpriseTeams:{create:["POST /enterprises/{enterprise}/teams"],delete:["DELETE /enterprises/{enterprise}/teams/{team_slug}"],get:["GET /enterprises/{enterprise}/teams/{team_slug}"],list:["GET /enterprises/{enterprise}/teams"],update:["PATCH /enterprises/{enterprise}/teams/{team_slug}"]},gists:{checkIsStarred:["GET /gists/{gist_id}/star"],create:["POST /gists"],createComment:["POST /gists/{gist_id}/comments"],delete:["DELETE /gists/{gist_id}"],deleteComment:["DELETE /gists/{gist_id}/comments/{comment_id}"],fork:["POST /gists/{gist_id}/forks"],get:["GET /gists/{gist_id}"],getComment:["GET /gists/{gist_id}/comments/{comment_id}"],getRevision:["GET /gists/{gist_id}/{sha}"],list:["GET /gists"],listComments:["GET /gists/{gist_id}/comments"],listCommits:["GET /gists/{gist_id}/commits"],listForUser:["GET /users/{username}/gists"],listForks:["GET /gists/{gist_id}/forks"],listPublic:["GET /gists/public"],listStarred:["GET /gists/starred"],star:["PUT /gists/{gist_id}/star"],unstar:["DELETE /gists/{gist_id}/star"],update:["PATCH /gists/{gist_id}"],updateComment:["PATCH /gists/{gist_id}/comments/{comment_id}"]},git:{createBlob:["POST /repos/{owner}/{repo}/git/blobs"],createCommit:["POST /repos/{owner}/{repo}/git/commits"],createRef:["POST /repos/{owner}/{repo}/git/refs"],createTag:["POST /repos/{owner}/{repo}/git/tags"],createTree:["POST /repos/{owner}/{repo}/git/trees"],deleteRef:["DELETE /repos/{owner}/{repo}/git/refs/{ref}"],getBlob:["GET /repos/{owner}/{repo}/git/blobs/{file_sha}"],getCommit:["GET /repos/{owner}/{repo}/git/commits/{commit_sha}"],getRef:["GET /repos/{owner}/{repo}/git/ref/{ref}"],getTag:["GET /repos/{owner}/{repo}/git/tags/{tag_sha}"],getTree:["GET /repos/{owner}/{repo}/git/trees/{tree_sha}"],listMatchingRefs:["GET /repos/{owner}/{repo}/git/matching-refs/{ref}"],updateRef:["PATCH /repos/{owner}/{repo}/git/refs/{ref}"]},gitignore:{getAllTemplates:["GET /gitignore/templates"],getTemplate:["GET /gitignore/templates/{name}"]},hostedCompute:{createNetworkConfigurationForOrg:["POST /orgs/{org}/settings/network-configurations"],deleteNetworkConfigurationFromOrg:["DELETE /orgs/{org}/settings/network-configurations/{network_configuration_id}"],getNetworkConfigurationForOrg:["GET /orgs/{org}/settings/network-configurations/{network_configuration_id}"],getNetworkSettingsForOrg:["GET /orgs/{org}/settings/network-settings/{network_settings_id}"],listNetworkConfigurationsForOrg:["GET /orgs/{org}/settings/network-configurations"],updateNetworkConfigurationForOrg:["PATCH /orgs/{org}/settings/network-configurations/{network_configuration_id}"]},interactions:{getRestrictionsForAuthenticatedUser:["GET /user/interaction-limits"],getRestrictionsForOrg:["GET /orgs/{org}/interaction-limits"],getRestrictionsForRepo:["GET /repos/{owner}/{repo}/interaction-limits"],getRestrictionsForYourPublicRepos:["GET /user/interaction-limits",{},{renamed:["interactions","getRestrictionsForAuthenticatedUser"]}],removeRestrictionsForAuthenticatedUser:["DELETE /user/interaction-limits"],removeRestrictionsForOrg:["DELETE /orgs/{org}/interaction-limits"],removeRestrictionsForRepo:["DELETE /repos/{owner}/{repo}/interaction-limits"],removeRestrictionsForYourPublicRepos:["DELETE /user/interaction-limits",{},{renamed:["interactions","removeRestrictionsForAuthenticatedUser"]}],setRestrictionsForAuthenticatedUser:["PUT /user/interaction-limits"],setRestrictionsForOrg:["PUT /orgs/{org}/interaction-limits"],setRestrictionsForRepo:["PUT /repos/{owner}/{repo}/interaction-limits"],setRestrictionsForYourPublicRepos:["PUT /user/interaction-limits",{},{renamed:["interactions","setRestrictionsForAuthenticatedUser"]}]},issues:{addAssignees:["POST /repos/{owner}/{repo}/issues/{issue_number}/assignees"],addBlockedByDependency:["POST /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by"],addLabels:["POST /repos/{owner}/{repo}/issues/{issue_number}/labels"],addSubIssue:["POST /repos/{owner}/{repo}/issues/{issue_number}/sub_issues"],checkUserCanBeAssigned:["GET /repos/{owner}/{repo}/assignees/{assignee}"],checkUserCanBeAssignedToIssue:["GET /repos/{owner}/{repo}/issues/{issue_number}/assignees/{assignee}"],create:["POST /repos/{owner}/{repo}/issues"],createComment:["POST /repos/{owner}/{repo}/issues/{issue_number}/comments"],createLabel:["POST /repos/{owner}/{repo}/labels"],createMilestone:["POST /repos/{owner}/{repo}/milestones"],deleteComment:["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}"],deleteLabel:["DELETE /repos/{owner}/{repo}/labels/{name}"],deleteMilestone:["DELETE /repos/{owner}/{repo}/milestones/{milestone_number}"],get:["GET /repos/{owner}/{repo}/issues/{issue_number}"],getComment:["GET /repos/{owner}/{repo}/issues/comments/{comment_id}"],getEvent:["GET /repos/{owner}/{repo}/issues/events/{event_id}"],getLabel:["GET /repos/{owner}/{repo}/labels/{name}"],getMilestone:["GET /repos/{owner}/{repo}/milestones/{milestone_number}"],getParent:["GET /repos/{owner}/{repo}/issues/{issue_number}/parent"],list:["GET /issues"],listAssignees:["GET /repos/{owner}/{repo}/assignees"],listComments:["GET /repos/{owner}/{repo}/issues/{issue_number}/comments"],listCommentsForRepo:["GET /repos/{owner}/{repo}/issues/comments"],listDependenciesBlockedBy:["GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by"],listDependenciesBlocking:["GET /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocking"],listEvents:["GET /repos/{owner}/{repo}/issues/{issue_number}/events"],listEventsForRepo:["GET /repos/{owner}/{repo}/issues/events"],listEventsForTimeline:["GET /repos/{owner}/{repo}/issues/{issue_number}/timeline"],listForAuthenticatedUser:["GET /user/issues"],listForOrg:["GET /orgs/{org}/issues"],listForRepo:["GET /repos/{owner}/{repo}/issues"],listLabelsForMilestone:["GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels"],listLabelsForRepo:["GET /repos/{owner}/{repo}/labels"],listLabelsOnIssue:["GET /repos/{owner}/{repo}/issues/{issue_number}/labels"],listMilestones:["GET /repos/{owner}/{repo}/milestones"],listSubIssues:["GET /repos/{owner}/{repo}/issues/{issue_number}/sub_issues"],lock:["PUT /repos/{owner}/{repo}/issues/{issue_number}/lock"],removeAllLabels:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels"],removeAssignees:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees"],removeDependencyBlockedBy:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/dependencies/blocked_by/{issue_id}"],removeLabel:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}"],removeSubIssue:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/sub_issue"],reprioritizeSubIssue:["PATCH /repos/{owner}/{repo}/issues/{issue_number}/sub_issues/priority"],setLabels:["PUT /repos/{owner}/{repo}/issues/{issue_number}/labels"],unlock:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock"],update:["PATCH /repos/{owner}/{repo}/issues/{issue_number}"],updateComment:["PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}"],updateLabel:["PATCH /repos/{owner}/{repo}/labels/{name}"],updateMilestone:["PATCH /repos/{owner}/{repo}/milestones/{milestone_number}"]},licenses:{get:["GET /licenses/{license}"],getAllCommonlyUsed:["GET /licenses"],getForRepo:["GET /repos/{owner}/{repo}/license"]},markdown:{render:["POST /markdown"],renderRaw:["POST /markdown/raw",{headers:{"content-type":"text/plain; charset=utf-8"}}]},meta:{get:["GET /meta"],getAllVersions:["GET /versions"],getOctocat:["GET /octocat"],getZen:["GET /zen"],root:["GET /"]},migrations:{deleteArchiveForAuthenticatedUser:["DELETE /user/migrations/{migration_id}/archive"],deleteArchiveForOrg:["DELETE /orgs/{org}/migrations/{migration_id}/archive"],downloadArchiveForOrg:["GET /orgs/{org}/migrations/{migration_id}/archive"],getArchiveForAuthenticatedUser:["GET /user/migrations/{migration_id}/archive"],getStatusForAuthenticatedUser:["GET /user/migrations/{migration_id}"],getStatusForOrg:["GET /orgs/{org}/migrations/{migration_id}"],listForAuthenticatedUser:["GET /user/migrations"],listForOrg:["GET /orgs/{org}/migrations"],listReposForAuthenticatedUser:["GET /user/migrations/{migration_id}/repositories"],listReposForOrg:["GET /orgs/{org}/migrations/{migration_id}/repositories"],listReposForUser:["GET /user/migrations/{migration_id}/repositories",{},{renamed:["migrations","listReposForAuthenticatedUser"]}],startForAuthenticatedUser:["POST /user/migrations"],startForOrg:["POST /orgs/{org}/migrations"],unlockRepoForAuthenticatedUser:["DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock"],unlockRepoForOrg:["DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock"]},oidc:{getOidcCustomSubTemplateForOrg:["GET /orgs/{org}/actions/oidc/customization/sub"],updateOidcCustomSubTemplateForOrg:["PUT /orgs/{org}/actions/oidc/customization/sub"]},orgs:{addSecurityManagerTeam:["PUT /orgs/{org}/security-managers/teams/{team_slug}",{},{deprecated:"octokit.rest.orgs.addSecurityManagerTeam() is deprecated, see https://docs.github.com/rest/orgs/security-managers#add-a-security-manager-team"}],assignTeamToOrgRole:["PUT /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"],assignUserToOrgRole:["PUT /orgs/{org}/organization-roles/users/{username}/{role_id}"],blockUser:["PUT /orgs/{org}/blocks/{username}"],cancelInvitation:["DELETE /orgs/{org}/invitations/{invitation_id}"],checkBlockedUser:["GET /orgs/{org}/blocks/{username}"],checkMembershipForUser:["GET /orgs/{org}/members/{username}"],checkPublicMembershipForUser:["GET /orgs/{org}/public_members/{username}"],convertMemberToOutsideCollaborator:["PUT /orgs/{org}/outside_collaborators/{username}"],createArtifactStorageRecord:["POST /orgs/{org}/artifacts/metadata/storage-record"],createInvitation:["POST /orgs/{org}/invitations"],createIssueType:["POST /orgs/{org}/issue-types"],createWebhook:["POST /orgs/{org}/hooks"],customPropertiesForOrgsCreateOrUpdateOrganizationValues:["PATCH /organizations/{org}/org-properties/values"],customPropertiesForOrgsGetOrganizationValues:["GET /organizations/{org}/org-properties/values"],customPropertiesForReposCreateOrUpdateOrganizationDefinition:["PUT /orgs/{org}/properties/schema/{custom_property_name}"],customPropertiesForReposCreateOrUpdateOrganizationDefinitions:["PATCH /orgs/{org}/properties/schema"],customPropertiesForReposCreateOrUpdateOrganizationValues:["PATCH /orgs/{org}/properties/values"],customPropertiesForReposDeleteOrganizationDefinition:["DELETE /orgs/{org}/properties/schema/{custom_property_name}"],customPropertiesForReposGetOrganizationDefinition:["GET /orgs/{org}/properties/schema/{custom_property_name}"],customPropertiesForReposGetOrganizationDefinitions:["GET /orgs/{org}/properties/schema"],customPropertiesForReposGetOrganizationValues:["GET /orgs/{org}/properties/values"],delete:["DELETE /orgs/{org}"],deleteAttestationsBulk:["POST /orgs/{org}/attestations/delete-request"],deleteAttestationsById:["DELETE /orgs/{org}/attestations/{attestation_id}"],deleteAttestationsBySubjectDigest:["DELETE /orgs/{org}/attestations/digest/{subject_digest}"],deleteIssueType:["DELETE /orgs/{org}/issue-types/{issue_type_id}"],deleteWebhook:["DELETE /orgs/{org}/hooks/{hook_id}"],disableSelectedRepositoryImmutableReleasesOrganization:["DELETE /orgs/{org}/settings/immutable-releases/repositories/{repository_id}"],enableSelectedRepositoryImmutableReleasesOrganization:["PUT /orgs/{org}/settings/immutable-releases/repositories/{repository_id}"],get:["GET /orgs/{org}"],getImmutableReleasesSettings:["GET /orgs/{org}/settings/immutable-releases"],getImmutableReleasesSettingsRepositories:["GET /orgs/{org}/settings/immutable-releases/repositories"],getMembershipForAuthenticatedUser:["GET /user/memberships/orgs/{org}"],getMembershipForUser:["GET /orgs/{org}/memberships/{username}"],getOrgRole:["GET /orgs/{org}/organization-roles/{role_id}"],getOrgRulesetHistory:["GET /orgs/{org}/rulesets/{ruleset_id}/history"],getOrgRulesetVersion:["GET /orgs/{org}/rulesets/{ruleset_id}/history/{version_id}"],getWebhook:["GET /orgs/{org}/hooks/{hook_id}"],getWebhookConfigForOrg:["GET /orgs/{org}/hooks/{hook_id}/config"],getWebhookDelivery:["GET /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}"],list:["GET /organizations"],listAppInstallations:["GET /orgs/{org}/installations"],listArtifactStorageRecords:["GET /orgs/{org}/artifacts/{subject_digest}/metadata/storage-records"],listAttestationRepositories:["GET /orgs/{org}/attestations/repositories"],listAttestations:["GET /orgs/{org}/attestations/{subject_digest}"],listAttestationsBulk:["POST /orgs/{org}/attestations/bulk-list{?per_page,before,after}"],listBlockedUsers:["GET /orgs/{org}/blocks"],listFailedInvitations:["GET /orgs/{org}/failed_invitations"],listForAuthenticatedUser:["GET /user/orgs"],listForUser:["GET /users/{username}/orgs"],listInvitationTeams:["GET /orgs/{org}/invitations/{invitation_id}/teams"],listIssueTypes:["GET /orgs/{org}/issue-types"],listMembers:["GET /orgs/{org}/members"],listMembershipsForAuthenticatedUser:["GET /user/memberships/orgs"],listOrgRoleTeams:["GET /orgs/{org}/organization-roles/{role_id}/teams"],listOrgRoleUsers:["GET /orgs/{org}/organization-roles/{role_id}/users"],listOrgRoles:["GET /orgs/{org}/organization-roles"],listOrganizationFineGrainedPermissions:["GET /orgs/{org}/organization-fine-grained-permissions"],listOutsideCollaborators:["GET /orgs/{org}/outside_collaborators"],listPatGrantRepositories:["GET /orgs/{org}/personal-access-tokens/{pat_id}/repositories"],listPatGrantRequestRepositories:["GET /orgs/{org}/personal-access-token-requests/{pat_request_id}/repositories"],listPatGrantRequests:["GET /orgs/{org}/personal-access-token-requests"],listPatGrants:["GET /orgs/{org}/personal-access-tokens"],listPendingInvitations:["GET /orgs/{org}/invitations"],listPublicMembers:["GET /orgs/{org}/public_members"],listSecurityManagerTeams:["GET /orgs/{org}/security-managers",{},{deprecated:"octokit.rest.orgs.listSecurityManagerTeams() is deprecated, see https://docs.github.com/rest/orgs/security-managers#list-security-manager-teams"}],listWebhookDeliveries:["GET /orgs/{org}/hooks/{hook_id}/deliveries"],listWebhooks:["GET /orgs/{org}/hooks"],pingWebhook:["POST /orgs/{org}/hooks/{hook_id}/pings"],redeliverWebhookDelivery:["POST /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"],removeMember:["DELETE /orgs/{org}/members/{username}"],removeMembershipForUser:["DELETE /orgs/{org}/memberships/{username}"],removeOutsideCollaborator:["DELETE /orgs/{org}/outside_collaborators/{username}"],removePublicMembershipForAuthenticatedUser:["DELETE /orgs/{org}/public_members/{username}"],removeSecurityManagerTeam:["DELETE /orgs/{org}/security-managers/teams/{team_slug}",{},{deprecated:"octokit.rest.orgs.removeSecurityManagerTeam() is deprecated, see https://docs.github.com/rest/orgs/security-managers#remove-a-security-manager-team"}],reviewPatGrantRequest:["POST /orgs/{org}/personal-access-token-requests/{pat_request_id}"],reviewPatGrantRequestsInBulk:["POST /orgs/{org}/personal-access-token-requests"],revokeAllOrgRolesTeam:["DELETE /orgs/{org}/organization-roles/teams/{team_slug}"],revokeAllOrgRolesUser:["DELETE /orgs/{org}/organization-roles/users/{username}"],revokeOrgRoleTeam:["DELETE /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}"],revokeOrgRoleUser:["DELETE /orgs/{org}/organization-roles/users/{username}/{role_id}"],setImmutableReleasesSettings:["PUT /orgs/{org}/settings/immutable-releases"],setImmutableReleasesSettingsRepositories:["PUT /orgs/{org}/settings/immutable-releases/repositories"],setMembershipForUser:["PUT /orgs/{org}/memberships/{username}"],setPublicMembershipForAuthenticatedUser:["PUT /orgs/{org}/public_members/{username}"],unblockUser:["DELETE /orgs/{org}/blocks/{username}"],update:["PATCH /orgs/{org}"],updateIssueType:["PUT /orgs/{org}/issue-types/{issue_type_id}"],updateMembershipForAuthenticatedUser:["PATCH /user/memberships/orgs/{org}"],updatePatAccess:["POST /orgs/{org}/personal-access-tokens/{pat_id}"],updatePatAccesses:["POST /orgs/{org}/personal-access-tokens"],updateWebhook:["PATCH /orgs/{org}/hooks/{hook_id}"],updateWebhookConfigForOrg:["PATCH /orgs/{org}/hooks/{hook_id}/config"]},packages:{deletePackageForAuthenticatedUser:["DELETE /user/packages/{package_type}/{package_name}"],deletePackageForOrg:["DELETE /orgs/{org}/packages/{package_type}/{package_name}"],deletePackageForUser:["DELETE /users/{username}/packages/{package_type}/{package_name}"],deletePackageVersionForAuthenticatedUser:["DELETE /user/packages/{package_type}/{package_name}/versions/{package_version_id}"],deletePackageVersionForOrg:["DELETE /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"],deletePackageVersionForUser:["DELETE /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"],getAllPackageVersionsForAPackageOwnedByAnOrg:["GET /orgs/{org}/packages/{package_type}/{package_name}/versions",{},{renamed:["packages","getAllPackageVersionsForPackageOwnedByOrg"]}],getAllPackageVersionsForAPackageOwnedByTheAuthenticatedUser:["GET /user/packages/{package_type}/{package_name}/versions",{},{renamed:["packages","getAllPackageVersionsForPackageOwnedByAuthenticatedUser"]}],getAllPackageVersionsForPackageOwnedByAuthenticatedUser:["GET /user/packages/{package_type}/{package_name}/versions"],getAllPackageVersionsForPackageOwnedByOrg:["GET /orgs/{org}/packages/{package_type}/{package_name}/versions"],getAllPackageVersionsForPackageOwnedByUser:["GET /users/{username}/packages/{package_type}/{package_name}/versions"],getPackageForAuthenticatedUser:["GET /user/packages/{package_type}/{package_name}"],getPackageForOrganization:["GET /orgs/{org}/packages/{package_type}/{package_name}"],getPackageForUser:["GET /users/{username}/packages/{package_type}/{package_name}"],getPackageVersionForAuthenticatedUser:["GET /user/packages/{package_type}/{package_name}/versions/{package_version_id}"],getPackageVersionForOrganization:["GET /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}"],getPackageVersionForUser:["GET /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}"],listDockerMigrationConflictingPackagesForAuthenticatedUser:["GET /user/docker/conflicts"],listDockerMigrationConflictingPackagesForOrganization:["GET /orgs/{org}/docker/conflicts"],listDockerMigrationConflictingPackagesForUser:["GET /users/{username}/docker/conflicts"],listPackagesForAuthenticatedUser:["GET /user/packages"],listPackagesForOrganization:["GET /orgs/{org}/packages"],listPackagesForUser:["GET /users/{username}/packages"],restorePackageForAuthenticatedUser:["POST /user/packages/{package_type}/{package_name}/restore{?token}"],restorePackageForOrg:["POST /orgs/{org}/packages/{package_type}/{package_name}/restore{?token}"],restorePackageForUser:["POST /users/{username}/packages/{package_type}/{package_name}/restore{?token}"],restorePackageVersionForAuthenticatedUser:["POST /user/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"],restorePackageVersionForOrg:["POST /orgs/{org}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"],restorePackageVersionForUser:["POST /users/{username}/packages/{package_type}/{package_name}/versions/{package_version_id}/restore"]},privateRegistries:{createOrgPrivateRegistry:["POST /orgs/{org}/private-registries"],deleteOrgPrivateRegistry:["DELETE /orgs/{org}/private-registries/{secret_name}"],getOrgPrivateRegistry:["GET /orgs/{org}/private-registries/{secret_name}"],getOrgPublicKey:["GET /orgs/{org}/private-registries/public-key"],listOrgPrivateRegistries:["GET /orgs/{org}/private-registries"],updateOrgPrivateRegistry:["PATCH /orgs/{org}/private-registries/{secret_name}"]},projects:{addItemForOrg:["POST /orgs/{org}/projectsV2/{project_number}/items"],addItemForUser:["POST /users/{username}/projectsV2/{project_number}/items"],deleteItemForOrg:["DELETE /orgs/{org}/projectsV2/{project_number}/items/{item_id}"],deleteItemForUser:["DELETE /users/{username}/projectsV2/{project_number}/items/{item_id}"],getFieldForOrg:["GET /orgs/{org}/projectsV2/{project_number}/fields/{field_id}"],getFieldForUser:["GET /users/{username}/projectsV2/{project_number}/fields/{field_id}"],getForOrg:["GET /orgs/{org}/projectsV2/{project_number}"],getForUser:["GET /users/{username}/projectsV2/{project_number}"],getOrgItem:["GET /orgs/{org}/projectsV2/{project_number}/items/{item_id}"],getUserItem:["GET /users/{username}/projectsV2/{project_number}/items/{item_id}"],listFieldsForOrg:["GET /orgs/{org}/projectsV2/{project_number}/fields"],listFieldsForUser:["GET /users/{username}/projectsV2/{project_number}/fields"],listForOrg:["GET /orgs/{org}/projectsV2"],listForUser:["GET /users/{username}/projectsV2"],listItemsForOrg:["GET /orgs/{org}/projectsV2/{project_number}/items"],listItemsForUser:["GET /users/{username}/projectsV2/{project_number}/items"],updateItemForOrg:["PATCH /orgs/{org}/projectsV2/{project_number}/items/{item_id}"],updateItemForUser:["PATCH /users/{username}/projectsV2/{project_number}/items/{item_id}"]},pulls:{checkIfMerged:["GET /repos/{owner}/{repo}/pulls/{pull_number}/merge"],create:["POST /repos/{owner}/{repo}/pulls"],createReplyForReviewComment:["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies"],createReview:["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],createReviewComment:["POST /repos/{owner}/{repo}/pulls/{pull_number}/comments"],deletePendingReview:["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],deleteReviewComment:["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}"],dismissReview:["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/dismissals"],get:["GET /repos/{owner}/{repo}/pulls/{pull_number}"],getReview:["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],getReviewComment:["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}"],list:["GET /repos/{owner}/{repo}/pulls"],listCommentsForReview:["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/comments"],listCommits:["GET /repos/{owner}/{repo}/pulls/{pull_number}/commits"],listFiles:["GET /repos/{owner}/{repo}/pulls/{pull_number}/files"],listRequestedReviewers:["GET /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],listReviewComments:["GET /repos/{owner}/{repo}/pulls/{pull_number}/comments"],listReviewCommentsForRepo:["GET /repos/{owner}/{repo}/pulls/comments"],listReviews:["GET /repos/{owner}/{repo}/pulls/{pull_number}/reviews"],merge:["PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge"],removeRequestedReviewers:["DELETE /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],requestReviewers:["POST /repos/{owner}/{repo}/pulls/{pull_number}/requested_reviewers"],submitReview:["POST /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}/events"],update:["PATCH /repos/{owner}/{repo}/pulls/{pull_number}"],updateBranch:["PUT /repos/{owner}/{repo}/pulls/{pull_number}/update-branch"],updateReview:["PUT /repos/{owner}/{repo}/pulls/{pull_number}/reviews/{review_id}"],updateReviewComment:["PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}"]},rateLimit:{get:["GET /rate_limit"]},reactions:{createForCommitComment:["POST /repos/{owner}/{repo}/comments/{comment_id}/reactions"],createForIssue:["POST /repos/{owner}/{repo}/issues/{issue_number}/reactions"],createForIssueComment:["POST /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"],createForPullRequestReviewComment:["POST /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"],createForRelease:["POST /repos/{owner}/{repo}/releases/{release_id}/reactions"],createForTeamDiscussionCommentInOrg:["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"],createForTeamDiscussionInOrg:["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"],deleteForCommitComment:["DELETE /repos/{owner}/{repo}/comments/{comment_id}/reactions/{reaction_id}"],deleteForIssue:["DELETE /repos/{owner}/{repo}/issues/{issue_number}/reactions/{reaction_id}"],deleteForIssueComment:["DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions/{reaction_id}"],deleteForPullRequestComment:["DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions/{reaction_id}"],deleteForRelease:["DELETE /repos/{owner}/{repo}/releases/{release_id}/reactions/{reaction_id}"],deleteForTeamDiscussion:["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions/{reaction_id}"],deleteForTeamDiscussionComment:["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions/{reaction_id}"],listForCommitComment:["GET /repos/{owner}/{repo}/comments/{comment_id}/reactions"],listForIssue:["GET /repos/{owner}/{repo}/issues/{issue_number}/reactions"],listForIssueComment:["GET /repos/{owner}/{repo}/issues/comments/{comment_id}/reactions"],listForPullRequestReviewComment:["GET /repos/{owner}/{repo}/pulls/comments/{comment_id}/reactions"],listForRelease:["GET /repos/{owner}/{repo}/releases/{release_id}/reactions"],listForTeamDiscussionCommentInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}/reactions"],listForTeamDiscussionInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/reactions"]},repos:{acceptInvitation:["PATCH /user/repository_invitations/{invitation_id}",{},{renamed:["repos","acceptInvitationForAuthenticatedUser"]}],acceptInvitationForAuthenticatedUser:["PATCH /user/repository_invitations/{invitation_id}"],addAppAccessRestrictions:["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",{},{mapToData:"apps"}],addCollaborator:["PUT /repos/{owner}/{repo}/collaborators/{username}"],addStatusCheckContexts:["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",{},{mapToData:"contexts"}],addTeamAccessRestrictions:["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",{},{mapToData:"teams"}],addUserAccessRestrictions:["POST /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",{},{mapToData:"users"}],cancelPagesDeployment:["POST /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}/cancel"],checkAutomatedSecurityFixes:["GET /repos/{owner}/{repo}/automated-security-fixes"],checkCollaborator:["GET /repos/{owner}/{repo}/collaborators/{username}"],checkImmutableReleases:["GET /repos/{owner}/{repo}/immutable-releases"],checkPrivateVulnerabilityReporting:["GET /repos/{owner}/{repo}/private-vulnerability-reporting"],checkVulnerabilityAlerts:["GET /repos/{owner}/{repo}/vulnerability-alerts"],codeownersErrors:["GET /repos/{owner}/{repo}/codeowners/errors"],compareCommits:["GET /repos/{owner}/{repo}/compare/{base}...{head}"],compareCommitsWithBasehead:["GET /repos/{owner}/{repo}/compare/{basehead}"],createAttestation:["POST /repos/{owner}/{repo}/attestations"],createAutolink:["POST /repos/{owner}/{repo}/autolinks"],createCommitComment:["POST /repos/{owner}/{repo}/commits/{commit_sha}/comments"],createCommitSignatureProtection:["POST /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"],createCommitStatus:["POST /repos/{owner}/{repo}/statuses/{sha}"],createDeployKey:["POST /repos/{owner}/{repo}/keys"],createDeployment:["POST /repos/{owner}/{repo}/deployments"],createDeploymentBranchPolicy:["POST /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"],createDeploymentProtectionRule:["POST /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"],createDeploymentStatus:["POST /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],createDispatchEvent:["POST /repos/{owner}/{repo}/dispatches"],createForAuthenticatedUser:["POST /user/repos"],createFork:["POST /repos/{owner}/{repo}/forks"],createInOrg:["POST /orgs/{org}/repos"],createOrUpdateEnvironment:["PUT /repos/{owner}/{repo}/environments/{environment_name}"],createOrUpdateFileContents:["PUT /repos/{owner}/{repo}/contents/{path}"],createOrgRuleset:["POST /orgs/{org}/rulesets"],createPagesDeployment:["POST /repos/{owner}/{repo}/pages/deployments"],createPagesSite:["POST /repos/{owner}/{repo}/pages"],createRelease:["POST /repos/{owner}/{repo}/releases"],createRepoRuleset:["POST /repos/{owner}/{repo}/rulesets"],createUsingTemplate:["POST /repos/{template_owner}/{template_repo}/generate"],createWebhook:["POST /repos/{owner}/{repo}/hooks"],customPropertiesForReposCreateOrUpdateRepositoryValues:["PATCH /repos/{owner}/{repo}/properties/values"],customPropertiesForReposGetRepositoryValues:["GET /repos/{owner}/{repo}/properties/values"],declineInvitation:["DELETE /user/repository_invitations/{invitation_id}",{},{renamed:["repos","declineInvitationForAuthenticatedUser"]}],declineInvitationForAuthenticatedUser:["DELETE /user/repository_invitations/{invitation_id}"],delete:["DELETE /repos/{owner}/{repo}"],deleteAccessRestrictions:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],deleteAdminBranchProtection:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],deleteAnEnvironment:["DELETE /repos/{owner}/{repo}/environments/{environment_name}"],deleteAutolink:["DELETE /repos/{owner}/{repo}/autolinks/{autolink_id}"],deleteBranchProtection:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection"],deleteCommitComment:["DELETE /repos/{owner}/{repo}/comments/{comment_id}"],deleteCommitSignatureProtection:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"],deleteDeployKey:["DELETE /repos/{owner}/{repo}/keys/{key_id}"],deleteDeployment:["DELETE /repos/{owner}/{repo}/deployments/{deployment_id}"],deleteDeploymentBranchPolicy:["DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"],deleteFile:["DELETE /repos/{owner}/{repo}/contents/{path}"],deleteInvitation:["DELETE /repos/{owner}/{repo}/invitations/{invitation_id}"],deleteOrgRuleset:["DELETE /orgs/{org}/rulesets/{ruleset_id}"],deletePagesSite:["DELETE /repos/{owner}/{repo}/pages"],deletePullRequestReviewProtection:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],deleteRelease:["DELETE /repos/{owner}/{repo}/releases/{release_id}"],deleteReleaseAsset:["DELETE /repos/{owner}/{repo}/releases/assets/{asset_id}"],deleteRepoRuleset:["DELETE /repos/{owner}/{repo}/rulesets/{ruleset_id}"],deleteWebhook:["DELETE /repos/{owner}/{repo}/hooks/{hook_id}"],disableAutomatedSecurityFixes:["DELETE /repos/{owner}/{repo}/automated-security-fixes"],disableDeploymentProtectionRule:["DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"],disableImmutableReleases:["DELETE /repos/{owner}/{repo}/immutable-releases"],disablePrivateVulnerabilityReporting:["DELETE /repos/{owner}/{repo}/private-vulnerability-reporting"],disableVulnerabilityAlerts:["DELETE /repos/{owner}/{repo}/vulnerability-alerts"],downloadArchive:["GET /repos/{owner}/{repo}/zipball/{ref}",{},{renamed:["repos","downloadZipballArchive"]}],downloadTarballArchive:["GET /repos/{owner}/{repo}/tarball/{ref}"],downloadZipballArchive:["GET /repos/{owner}/{repo}/zipball/{ref}"],enableAutomatedSecurityFixes:["PUT /repos/{owner}/{repo}/automated-security-fixes"],enableImmutableReleases:["PUT /repos/{owner}/{repo}/immutable-releases"],enablePrivateVulnerabilityReporting:["PUT /repos/{owner}/{repo}/private-vulnerability-reporting"],enableVulnerabilityAlerts:["PUT /repos/{owner}/{repo}/vulnerability-alerts"],generateReleaseNotes:["POST /repos/{owner}/{repo}/releases/generate-notes"],get:["GET /repos/{owner}/{repo}"],getAccessRestrictions:["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions"],getAdminBranchProtection:["GET /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],getAllDeploymentProtectionRules:["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules"],getAllEnvironments:["GET /repos/{owner}/{repo}/environments"],getAllStatusCheckContexts:["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts"],getAllTopics:["GET /repos/{owner}/{repo}/topics"],getAppsWithAccessToProtectedBranch:["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps"],getAutolink:["GET /repos/{owner}/{repo}/autolinks/{autolink_id}"],getBranch:["GET /repos/{owner}/{repo}/branches/{branch}"],getBranchProtection:["GET /repos/{owner}/{repo}/branches/{branch}/protection"],getBranchRules:["GET /repos/{owner}/{repo}/rules/branches/{branch}"],getClones:["GET /repos/{owner}/{repo}/traffic/clones"],getCodeFrequencyStats:["GET /repos/{owner}/{repo}/stats/code_frequency"],getCollaboratorPermissionLevel:["GET /repos/{owner}/{repo}/collaborators/{username}/permission"],getCombinedStatusForRef:["GET /repos/{owner}/{repo}/commits/{ref}/status"],getCommit:["GET /repos/{owner}/{repo}/commits/{ref}"],getCommitActivityStats:["GET /repos/{owner}/{repo}/stats/commit_activity"],getCommitComment:["GET /repos/{owner}/{repo}/comments/{comment_id}"],getCommitSignatureProtection:["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_signatures"],getCommunityProfileMetrics:["GET /repos/{owner}/{repo}/community/profile"],getContent:["GET /repos/{owner}/{repo}/contents/{path}"],getContributorsStats:["GET /repos/{owner}/{repo}/stats/contributors"],getCustomDeploymentProtectionRule:["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/{protection_rule_id}"],getDeployKey:["GET /repos/{owner}/{repo}/keys/{key_id}"],getDeployment:["GET /repos/{owner}/{repo}/deployments/{deployment_id}"],getDeploymentBranchPolicy:["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"],getDeploymentStatus:["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses/{status_id}"],getEnvironment:["GET /repos/{owner}/{repo}/environments/{environment_name}"],getLatestPagesBuild:["GET /repos/{owner}/{repo}/pages/builds/latest"],getLatestRelease:["GET /repos/{owner}/{repo}/releases/latest"],getOrgRuleSuite:["GET /orgs/{org}/rulesets/rule-suites/{rule_suite_id}"],getOrgRuleSuites:["GET /orgs/{org}/rulesets/rule-suites"],getOrgRuleset:["GET /orgs/{org}/rulesets/{ruleset_id}"],getOrgRulesets:["GET /orgs/{org}/rulesets"],getPages:["GET /repos/{owner}/{repo}/pages"],getPagesBuild:["GET /repos/{owner}/{repo}/pages/builds/{build_id}"],getPagesDeployment:["GET /repos/{owner}/{repo}/pages/deployments/{pages_deployment_id}"],getPagesHealthCheck:["GET /repos/{owner}/{repo}/pages/health"],getParticipationStats:["GET /repos/{owner}/{repo}/stats/participation"],getPullRequestReviewProtection:["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],getPunchCardStats:["GET /repos/{owner}/{repo}/stats/punch_card"],getReadme:["GET /repos/{owner}/{repo}/readme"],getReadmeInDirectory:["GET /repos/{owner}/{repo}/readme/{dir}"],getRelease:["GET /repos/{owner}/{repo}/releases/{release_id}"],getReleaseAsset:["GET /repos/{owner}/{repo}/releases/assets/{asset_id}"],getReleaseByTag:["GET /repos/{owner}/{repo}/releases/tags/{tag}"],getRepoRuleSuite:["GET /repos/{owner}/{repo}/rulesets/rule-suites/{rule_suite_id}"],getRepoRuleSuites:["GET /repos/{owner}/{repo}/rulesets/rule-suites"],getRepoRuleset:["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}"],getRepoRulesetHistory:["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}/history"],getRepoRulesetVersion:["GET /repos/{owner}/{repo}/rulesets/{ruleset_id}/history/{version_id}"],getRepoRulesets:["GET /repos/{owner}/{repo}/rulesets"],getStatusChecksProtection:["GET /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],getTeamsWithAccessToProtectedBranch:["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams"],getTopPaths:["GET /repos/{owner}/{repo}/traffic/popular/paths"],getTopReferrers:["GET /repos/{owner}/{repo}/traffic/popular/referrers"],getUsersWithAccessToProtectedBranch:["GET /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users"],getViews:["GET /repos/{owner}/{repo}/traffic/views"],getWebhook:["GET /repos/{owner}/{repo}/hooks/{hook_id}"],getWebhookConfigForRepo:["GET /repos/{owner}/{repo}/hooks/{hook_id}/config"],getWebhookDelivery:["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}"],listActivities:["GET /repos/{owner}/{repo}/activity"],listAttestations:["GET /repos/{owner}/{repo}/attestations/{subject_digest}"],listAutolinks:["GET /repos/{owner}/{repo}/autolinks"],listBranches:["GET /repos/{owner}/{repo}/branches"],listBranchesForHeadCommit:["GET /repos/{owner}/{repo}/commits/{commit_sha}/branches-where-head"],listCollaborators:["GET /repos/{owner}/{repo}/collaborators"],listCommentsForCommit:["GET /repos/{owner}/{repo}/commits/{commit_sha}/comments"],listCommitCommentsForRepo:["GET /repos/{owner}/{repo}/comments"],listCommitStatusesForRef:["GET /repos/{owner}/{repo}/commits/{ref}/statuses"],listCommits:["GET /repos/{owner}/{repo}/commits"],listContributors:["GET /repos/{owner}/{repo}/contributors"],listCustomDeploymentRuleIntegrations:["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment_protection_rules/apps"],listDeployKeys:["GET /repos/{owner}/{repo}/keys"],listDeploymentBranchPolicies:["GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies"],listDeploymentStatuses:["GET /repos/{owner}/{repo}/deployments/{deployment_id}/statuses"],listDeployments:["GET /repos/{owner}/{repo}/deployments"],listForAuthenticatedUser:["GET /user/repos"],listForOrg:["GET /orgs/{org}/repos"],listForUser:["GET /users/{username}/repos"],listForks:["GET /repos/{owner}/{repo}/forks"],listInvitations:["GET /repos/{owner}/{repo}/invitations"],listInvitationsForAuthenticatedUser:["GET /user/repository_invitations"],listLanguages:["GET /repos/{owner}/{repo}/languages"],listPagesBuilds:["GET /repos/{owner}/{repo}/pages/builds"],listPublic:["GET /repositories"],listPullRequestsAssociatedWithCommit:["GET /repos/{owner}/{repo}/commits/{commit_sha}/pulls"],listReleaseAssets:["GET /repos/{owner}/{repo}/releases/{release_id}/assets"],listReleases:["GET /repos/{owner}/{repo}/releases"],listTags:["GET /repos/{owner}/{repo}/tags"],listTeams:["GET /repos/{owner}/{repo}/teams"],listWebhookDeliveries:["GET /repos/{owner}/{repo}/hooks/{hook_id}/deliveries"],listWebhooks:["GET /repos/{owner}/{repo}/hooks"],merge:["POST /repos/{owner}/{repo}/merges"],mergeUpstream:["POST /repos/{owner}/{repo}/merge-upstream"],pingWebhook:["POST /repos/{owner}/{repo}/hooks/{hook_id}/pings"],redeliverWebhookDelivery:["POST /repos/{owner}/{repo}/hooks/{hook_id}/deliveries/{delivery_id}/attempts"],removeAppAccessRestrictions:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",{},{mapToData:"apps"}],removeCollaborator:["DELETE /repos/{owner}/{repo}/collaborators/{username}"],removeStatusCheckContexts:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",{},{mapToData:"contexts"}],removeStatusCheckProtection:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],removeTeamAccessRestrictions:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",{},{mapToData:"teams"}],removeUserAccessRestrictions:["DELETE /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",{},{mapToData:"users"}],renameBranch:["POST /repos/{owner}/{repo}/branches/{branch}/rename"],replaceAllTopics:["PUT /repos/{owner}/{repo}/topics"],requestPagesBuild:["POST /repos/{owner}/{repo}/pages/builds"],setAdminBranchProtection:["POST /repos/{owner}/{repo}/branches/{branch}/protection/enforce_admins"],setAppAccessRestrictions:["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/apps",{},{mapToData:"apps"}],setStatusCheckContexts:["PUT /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks/contexts",{},{mapToData:"contexts"}],setTeamAccessRestrictions:["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/teams",{},{mapToData:"teams"}],setUserAccessRestrictions:["PUT /repos/{owner}/{repo}/branches/{branch}/protection/restrictions/users",{},{mapToData:"users"}],testPushWebhook:["POST /repos/{owner}/{repo}/hooks/{hook_id}/tests"],transfer:["POST /repos/{owner}/{repo}/transfer"],update:["PATCH /repos/{owner}/{repo}"],updateBranchProtection:["PUT /repos/{owner}/{repo}/branches/{branch}/protection"],updateCommitComment:["PATCH /repos/{owner}/{repo}/comments/{comment_id}"],updateDeploymentBranchPolicy:["PUT /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}"],updateInformationAboutPagesSite:["PUT /repos/{owner}/{repo}/pages"],updateInvitation:["PATCH /repos/{owner}/{repo}/invitations/{invitation_id}"],updateOrgRuleset:["PUT /orgs/{org}/rulesets/{ruleset_id}"],updatePullRequestReviewProtection:["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_pull_request_reviews"],updateRelease:["PATCH /repos/{owner}/{repo}/releases/{release_id}"],updateReleaseAsset:["PATCH /repos/{owner}/{repo}/releases/assets/{asset_id}"],updateRepoRuleset:["PUT /repos/{owner}/{repo}/rulesets/{ruleset_id}"],updateStatusCheckPotection:["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks",{},{renamed:["repos","updateStatusCheckProtection"]}],updateStatusCheckProtection:["PATCH /repos/{owner}/{repo}/branches/{branch}/protection/required_status_checks"],updateWebhook:["PATCH /repos/{owner}/{repo}/hooks/{hook_id}"],updateWebhookConfigForRepo:["PATCH /repos/{owner}/{repo}/hooks/{hook_id}/config"],uploadReleaseAsset:["POST /repos/{owner}/{repo}/releases/{release_id}/assets{?name,label}",{baseUrl:"https://uploads.github.com"}]},search:{code:["GET /search/code"],commits:["GET /search/commits"],issuesAndPullRequests:["GET /search/issues"],labels:["GET /search/labels"],repos:["GET /search/repositories"],topics:["GET /search/topics"],users:["GET /search/users"]},secretScanning:{createPushProtectionBypass:["POST /repos/{owner}/{repo}/secret-scanning/push-protection-bypasses"],getAlert:["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"],getScanHistory:["GET /repos/{owner}/{repo}/secret-scanning/scan-history"],listAlertsForOrg:["GET /orgs/{org}/secret-scanning/alerts"],listAlertsForRepo:["GET /repos/{owner}/{repo}/secret-scanning/alerts"],listLocationsForAlert:["GET /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}/locations"],listOrgPatternConfigs:["GET /orgs/{org}/secret-scanning/pattern-configurations"],updateAlert:["PATCH /repos/{owner}/{repo}/secret-scanning/alerts/{alert_number}"],updateOrgPatternConfigs:["PATCH /orgs/{org}/secret-scanning/pattern-configurations"]},securityAdvisories:{createFork:["POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/forks"],createPrivateVulnerabilityReport:["POST /repos/{owner}/{repo}/security-advisories/reports"],createRepositoryAdvisory:["POST /repos/{owner}/{repo}/security-advisories"],createRepositoryAdvisoryCveRequest:["POST /repos/{owner}/{repo}/security-advisories/{ghsa_id}/cve"],getGlobalAdvisory:["GET /advisories/{ghsa_id}"],getRepositoryAdvisory:["GET /repos/{owner}/{repo}/security-advisories/{ghsa_id}"],listGlobalAdvisories:["GET /advisories"],listOrgRepositoryAdvisories:["GET /orgs/{org}/security-advisories"],listRepositoryAdvisories:["GET /repos/{owner}/{repo}/security-advisories"],updateRepositoryAdvisory:["PATCH /repos/{owner}/{repo}/security-advisories/{ghsa_id}"]},teams:{addOrUpdateMembershipForUserInOrg:["PUT /orgs/{org}/teams/{team_slug}/memberships/{username}"],addOrUpdateRepoPermissionsInOrg:["PUT /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],checkPermissionsForRepoInOrg:["GET /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],create:["POST /orgs/{org}/teams"],createDiscussionCommentInOrg:["POST /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],createDiscussionInOrg:["POST /orgs/{org}/teams/{team_slug}/discussions"],deleteDiscussionCommentInOrg:["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],deleteDiscussionInOrg:["DELETE /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],deleteInOrg:["DELETE /orgs/{org}/teams/{team_slug}"],getByName:["GET /orgs/{org}/teams/{team_slug}"],getDiscussionCommentInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],getDiscussionInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],getMembershipForUserInOrg:["GET /orgs/{org}/teams/{team_slug}/memberships/{username}"],list:["GET /orgs/{org}/teams"],listChildInOrg:["GET /orgs/{org}/teams/{team_slug}/teams"],listDiscussionCommentsInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments"],listDiscussionsInOrg:["GET /orgs/{org}/teams/{team_slug}/discussions"],listForAuthenticatedUser:["GET /user/teams"],listMembersInOrg:["GET /orgs/{org}/teams/{team_slug}/members"],listPendingInvitationsInOrg:["GET /orgs/{org}/teams/{team_slug}/invitations"],listReposInOrg:["GET /orgs/{org}/teams/{team_slug}/repos"],removeMembershipForUserInOrg:["DELETE /orgs/{org}/teams/{team_slug}/memberships/{username}"],removeRepoInOrg:["DELETE /orgs/{org}/teams/{team_slug}/repos/{owner}/{repo}"],updateDiscussionCommentInOrg:["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}/comments/{comment_number}"],updateDiscussionInOrg:["PATCH /orgs/{org}/teams/{team_slug}/discussions/{discussion_number}"],updateInOrg:["PATCH /orgs/{org}/teams/{team_slug}"]},users:{addEmailForAuthenticated:["POST /user/emails",{},{renamed:["users","addEmailForAuthenticatedUser"]}],addEmailForAuthenticatedUser:["POST /user/emails"],addSocialAccountForAuthenticatedUser:["POST /user/social_accounts"],block:["PUT /user/blocks/{username}"],checkBlocked:["GET /user/blocks/{username}"],checkFollowingForUser:["GET /users/{username}/following/{target_user}"],checkPersonIsFollowedByAuthenticated:["GET /user/following/{username}"],createGpgKeyForAuthenticated:["POST /user/gpg_keys",{},{renamed:["users","createGpgKeyForAuthenticatedUser"]}],createGpgKeyForAuthenticatedUser:["POST /user/gpg_keys"],createPublicSshKeyForAuthenticated:["POST /user/keys",{},{renamed:["users","createPublicSshKeyForAuthenticatedUser"]}],createPublicSshKeyForAuthenticatedUser:["POST /user/keys"],createSshSigningKeyForAuthenticatedUser:["POST /user/ssh_signing_keys"],deleteAttestationsBulk:["POST /users/{username}/attestations/delete-request"],deleteAttestationsById:["DELETE /users/{username}/attestations/{attestation_id}"],deleteAttestationsBySubjectDigest:["DELETE /users/{username}/attestations/digest/{subject_digest}"],deleteEmailForAuthenticated:["DELETE /user/emails",{},{renamed:["users","deleteEmailForAuthenticatedUser"]}],deleteEmailForAuthenticatedUser:["DELETE /user/emails"],deleteGpgKeyForAuthenticated:["DELETE /user/gpg_keys/{gpg_key_id}",{},{renamed:["users","deleteGpgKeyForAuthenticatedUser"]}],deleteGpgKeyForAuthenticatedUser:["DELETE /user/gpg_keys/{gpg_key_id}"],deletePublicSshKeyForAuthenticated:["DELETE /user/keys/{key_id}",{},{renamed:["users","deletePublicSshKeyForAuthenticatedUser"]}],deletePublicSshKeyForAuthenticatedUser:["DELETE /user/keys/{key_id}"],deleteSocialAccountForAuthenticatedUser:["DELETE /user/social_accounts"],deleteSshSigningKeyForAuthenticatedUser:["DELETE /user/ssh_signing_keys/{ssh_signing_key_id}"],follow:["PUT /user/following/{username}"],getAuthenticated:["GET /user"],getById:["GET /user/{account_id}"],getByUsername:["GET /users/{username}"],getContextForUser:["GET /users/{username}/hovercard"],getGpgKeyForAuthenticated:["GET /user/gpg_keys/{gpg_key_id}",{},{renamed:["users","getGpgKeyForAuthenticatedUser"]}],getGpgKeyForAuthenticatedUser:["GET /user/gpg_keys/{gpg_key_id}"],getPublicSshKeyForAuthenticated:["GET /user/keys/{key_id}",{},{renamed:["users","getPublicSshKeyForAuthenticatedUser"]}],getPublicSshKeyForAuthenticatedUser:["GET /user/keys/{key_id}"],getSshSigningKeyForAuthenticatedUser:["GET /user/ssh_signing_keys/{ssh_signing_key_id}"],list:["GET /users"],listAttestations:["GET /users/{username}/attestations/{subject_digest}"],listAttestationsBulk:["POST /users/{username}/attestations/bulk-list{?per_page,before,after}"],listBlockedByAuthenticated:["GET /user/blocks",{},{renamed:["users","listBlockedByAuthenticatedUser"]}],listBlockedByAuthenticatedUser:["GET /user/blocks"],listEmailsForAuthenticated:["GET /user/emails",{},{renamed:["users","listEmailsForAuthenticatedUser"]}],listEmailsForAuthenticatedUser:["GET /user/emails"],listFollowedByAuthenticated:["GET /user/following",{},{renamed:["users","listFollowedByAuthenticatedUser"]}],listFollowedByAuthenticatedUser:["GET /user/following"],listFollowersForAuthenticatedUser:["GET /user/followers"],listFollowersForUser:["GET /users/{username}/followers"],listFollowingForUser:["GET /users/{username}/following"],listGpgKeysForAuthenticated:["GET /user/gpg_keys",{},{renamed:["users","listGpgKeysForAuthenticatedUser"]}],listGpgKeysForAuthenticatedUser:["GET /user/gpg_keys"],listGpgKeysForUser:["GET /users/{username}/gpg_keys"],listPublicEmailsForAuthenticated:["GET /user/public_emails",{},{renamed:["users","listPublicEmailsForAuthenticatedUser"]}],listPublicEmailsForAuthenticatedUser:["GET /user/public_emails"],listPublicKeysForUser:["GET /users/{username}/keys"],listPublicSshKeysForAuthenticated:["GET /user/keys",{},{renamed:["users","listPublicSshKeysForAuthenticatedUser"]}],listPublicSshKeysForAuthenticatedUser:["GET /user/keys"],listSocialAccountsForAuthenticatedUser:["GET /user/social_accounts"],listSocialAccountsForUser:["GET /users/{username}/social_accounts"],listSshSigningKeysForAuthenticatedUser:["GET /user/ssh_signing_keys"],listSshSigningKeysForUser:["GET /users/{username}/ssh_signing_keys"],setPrimaryEmailVisibilityForAuthenticated:["PATCH /user/email/visibility",{},{renamed:["users","setPrimaryEmailVisibilityForAuthenticatedUser"]}],setPrimaryEmailVisibilityForAuthenticatedUser:["PATCH /user/email/visibility"],unblock:["DELETE /user/blocks/{username}"],unfollow:["DELETE /user/following/{username}"],updateAuthenticated:["PATCH /user"]}},Xp=sM;var Gr=new Map;for(let[t,e]of Object.entries(Xp))for(let[r,A]of Object.entries(e)){let[s,o,n]=A,[i,a]=s.split(/ /),c=Object.assign({method:i,url:a},o);Gr.has(t)||Gr.set(t,new Map),Gr.get(t).set(r,{scope:t,methodName:r,endpointDefaults:c,decorations:n})}var oM={has({scope:t},e){return Gr.get(t).has(e)},getOwnPropertyDescriptor(t,e){return{value:this.get(t,e),configurable:!0,writable:!0,enumerable:!0}},defineProperty(t,e,r){return Object.defineProperty(t.cache,e,r),!0},deleteProperty(t,e){return delete t.cache[e],!0},ownKeys({scope:t}){return[...Gr.get(t).keys()]},set(t,e,r){return t.cache[e]=r},get({octokit:t,scope:e,cache:r},A){if(r[A])return r[A];let s=Gr.get(e).get(A);if(!s)return;let{endpointDefaults:o,decorations:n}=s;return n?r[A]=nM(t,e,A,o,n):r[A]=t.request.defaults(o),r[A]}};function su(t){let e={};for(let r of Gr.keys())e[r]=new Proxy({octokit:t,scope:r,cache:{}},oM);return e}function nM(t,e,r,A,s){let o=t.request.defaults(A);function n(...i){let a=o.endpoint.merge(...i);if(s.mapToData)return a=Object.assign({},a,{data:a[s.mapToData],[s.mapToData]:void 0}),o(a);if(s.renamed){let[c,u]=s.renamed;t.log.warn(`octokit.${e}.${r}() has been renamed to octokit.${c}.${u}()`)}if(s.deprecated&&t.log.warn(s.deprecated),s.renamedParameters){let c=o.endpoint.merge(...i);for(let[u,g]of Object.entries(s.renamedParameters))u in c&&(t.log.warn(`"${u}" parameter is deprecated for "octokit.${e}.${r}()". Use "${g}" instead`),g in c||(c[g]=c[u]),delete c[u]);return o(c)}return o(...i)}return Object.assign(n,o)}function iM(t){return{rest:su(t)}}iM.VERSION=Au;function ou(t){let e=su(t);return{...e,rest:e}}ou.VERSION=Au;var $p="22.0.1";var ef=ei.plugin(eu,ou,ru).defaults({userAgent:`octokit-rest.js/${$p}`});var tf=t=>typeof t?.status=="number"?t.status:void 0,aM=t=>t instanceof Error||typeof t?.message=="string"?t.message:"",cM=t=>/\bsecondary rate\b/i.test(aM(t)),gM=t=>{if(cM(t))return;let e=tf(t);if(e!==403&&e!==429)return;let r=t.response;if(r?.headers?.["x-ratelimit-remaining"]!=="0")return;let A=r.headers["x-ratelimit-reset"];if(!A?.trim())return;let s=A.trim();if(!/^\d+$/.test(s))return;let o=Number(s);if(Number.isSafeInteger(o))return Math.max(Math.ceil(o-Date.now()/1e3)+1,0)},uM=async(t,e)=>{let r=new sr(void 0);try{await r.sleepSeconds(t,e)}finally{r.dispose()}},rf=async(t,e,r,A,s)=>{let o=0,n=0,i=0;for(;;){s?.(),r?.throwIfAborted();let a;try{a=await t(o)}catch(c){s?.(),r?.throwIfAborted();let u=tf(c),g=gM(c),E;if(u!==void 0&&u>=500&&n({onRateLimit:(e,r,A,s)=>{if(xs(`Request quota exhausted for request ${r.method} ${r.url}`),s<1&&t)return xs(`Retrying after ${e} seconds!`),!0},onSecondaryRateLimit:(e,r)=>{xs(`Secondary rate limit detected for request ${r.method} ${r.url}`)}}),iu=t=>{let e={...t.signal?{signal:t.signal}:{},...t.checkDeadline?{checkDeadline:t.checkDeadline}:{}};return e.signal||e.checkDeadline?e:void 0},nu=(t,e)=>{let r=iu(e);return r?t.defaults({request:r}):t},dM=(t,e)=>!(!hM.has(t.status||"")||e.branch&&t.head_branch!==e.branch||e.queueName&&!t.display_title?.includes(e.queueName)&&!t.name?.includes(e.queueName)),ti=class{octokit;constructor(e,r=0){this.octokit=new lM({baseUrl:process.env.GITHUB_API_URL||"https://api.github.com",auth:e,retry:{enabled:!1},throttle:QM(!1)}),this.octokit.hook.wrap("request",(A,s)=>rf(o=>Promise.resolve(A({...s,request:{...s.request,retryCount:o}})),r,s.request.signal,o=>xs(`Retrying after ${o} seconds!`),s.request.checkDeadline))}workflows=async(e,r,A={})=>this.octokit.paginate(nu(this.octokit.actions.listRepoWorkflows,A),{owner:e,repo:r,per_page:100});run=async(e,r,A,s={})=>{let o=iu(s),{data:n}=await this.octokit.actions.getWorkflowRun({owner:e,repo:r,run_id:A,...o?{request:o}:{}});return n};listActiveRuns=async(e,r,A,s={})=>{let o=new Map,n=this.octokit.paginate;return await Promise.all(Af.map(async i=>{let a=0,c=await n(nu(e,s),{...r,...A.branch?{branch:A.branch}:{},status:i},(u,g)=>{a+=1;let E=u.data.filter(I=>dM(I,A));return a>=EM&&g(),E});for(let u of c)o.set(u.id,u)})),[...o.values()]};runs=async(e,r,A,s={},o={})=>{let n={owner:e,repo:r,workflow_id:A,per_page:100};return this.listActiveRuns(this.octokit.actions.listWorkflowRuns,n,s,o)};activeRunsForRepo=async(e,r,A={},s={})=>{let o={owner:e,repo:r,per_page:100};return this.listActiveRuns(this.octokit.actions.listWorkflowRunsForRepo,o,A,s)};jobs=async(e,r,A,s={})=>{let o={owner:e,repo:r,run_id:A,per_page:100};return this.octokit.paginate(nu(this.octokit.actions.listJobsForWorkflowRun,s),o)};steps=async(e,r,A,s={})=>{let o=iu(s),n={owner:e,repo:r,job_id:A,...o?{request:o}:{}},{data:i}=await this.octokit.actions.getJobForWorkflowRun(n);return i.steps||[]}};var Hs=(t,e,r,A)=>{let s=t[e];if(s===void 0||s.trim()==="")return r;let o=e.replace(/^INPUT_/,"").toLowerCase();if(!/^\d+$/.test(s.trim()))throw new Error(`${o} must be an integer greater than or equal to ${A}`);let n=Number(s);if(!Number.isSafeInteger(n)||n{if(!t)return;let r=["refs/heads/","refs/tags/"].find(A=>t.startsWith(A));return r?t.substring(r.length):t},IM=(t,e,r)=>{if(!t||!e||!r)return;let A=t.split("@")[0],s=`${e}/${r}/`;if(A.startsWith(s))return A.substring(s.length)},CM=t=>{let e=Number(t||"1");return Number.isSafeInteger(e)&&e>0?e:1},sf=t=>{let e=t.INPUT_TOKEN||"",[r,A]=(t.GITHUB_REPOSITORY||"").split("/"),s=t.GITHUB_WORKFLOW||"",o=IM(t.GITHUB_WORKFLOW_REF,r,A),i=t.INPUT_BRANCH?.trim()||t.GITHUB_HEAD_REF||t.GITHUB_REF_NAME||BM(t.GITHUB_REF)||"master",a=parseInt(t.GITHUB_RUN_ID||"0",10),c=CM(t.GITHUB_RUN_ATTEMPT),u=Hs(t,"INPUT_POLL-INTERVAL-SECONDS",60,1)??60,g=Hs(t,"INPUT_CONTINUE-AFTER-SECONDS",void 0,0),E=Hs(t,"INPUT_ABORT-AFTER-SECONDS",void 0,0);if(g!==void 0&&E!==void 0)throw new Error("Only one of continue-after-seconds and abort-after-seconds may be defined");let I=Hs(t,"INPUT_INITIAL-WAIT-SECONDS",0,0)??0,d=t["INPUT_SAME-BRANCH-ONLY"]==="true"||!t["INPUT_SAME-BRANCH-ONLY"],p=t["INPUT_JOB-TO-WAIT-FOR"],y=t["INPUT_STEP-TO-WAIT-FOR"],B=t["INPUT_QUEUE-NAME"],w=Hs(t,"INPUT_RETRIES",0,0)??0;if(y&&!p)throw new Error("step-to-wait-for requires job-to-wait-for to be defined");return{githubToken:e,owner:r,repo:A,branch:i,workflowName:s,workflowPath:o,runId:a,runAttempt:c,pollIntervalSeconds:u,continueAfterSeconds:g,abortAfterSeconds:E,sameBranchOnly:d,jobToWaitFor:p,stepToWaitFor:y,initialWaitSeconds:I,queueName:B,retries:w}};var pM=new Set(["in_progress","queued","waiting"]),fM=500,ri=t=>{if(!t)return;let e=Date.parse(t);return Number.isNaN(e)?void 0:e},Ai=t=>ri(t.run_started_at)||ri(t.created_at),mM=t=>ri(t.run_started_at),wM=t=>ri(t.created_at),yM=t=>(t.run_attempt||1)>1,bM=t=>pM.has(t.status||""),DM=(t,e)=>!e.sameBranchOnly||t.head_branch===e.branch,of=(t,e)=>t.filter(bM).filter(r=>DM(r,e)),nf=(t,e)=>t.find(r=>r.id===e.runId&&r.run_attempt===e.runAttempt)||t.find(r=>r.id===e.runId),kM=(t,e,r)=>{if(t.id===e.runId)return!1;if(yM(t)){let o=mM(t);return r===void 0||o===void 0?!1:o{let r=Ai(t),A=Ai(e);return r!==void 0&&A!==void 0&&r!==A?A-r:e.id-t.id},cf=t=>{It("previous_run_id",t?String(t.id):""),It("previous_run_url",t?.html_url||"")},RM=t=>t instanceof Error?t.message:String(t),si=class{info;debug;input;githubClient;workflowId;timing;sharedDeadline;previousRunOutput;deadline;constructor(e,r,A,s,o,n=Wn,i){this.workflowId=e,this.input=A,this.githubClient=r,this.info=s,this.debug=o,this.timing=n,this.sharedDeadline=i}setPreviousRunOutput=e=>{this.previousRunOutput&&af(e,this.previousRunOutput)>=0||(this.previousRunOutput=e,cf(e))};clearPreviousRunOutput=()=>{this.previousRunOutput||cf(void 0)};withDeadline=async e=>{let r=this.deadline;if(!r)throw new Error("Wait deadline has not been initialized");return r.race(A=>e({signal:A,checkDeadline:r.throwIfReached}))};discoverRuns=async()=>{this.debug(`Fetching workflow runs for workflow ID: ${this.workflowId}`);let e=this.input.queueName,r;try{r=await this.withDeadline(n=>this.githubClient.run(this.input.owner,this.input.repo,this.input.runId,n))}catch(n){this.deadline?.throwIfReached(),this.deadline?.signal.throwIfAborted(),this.debug(`Failed to fetch current run ${this.input.runId}: ${RM(n)}`)}let A={branch:this.input.sameBranchOnly?this.input.branch:void 0},s=await this.withDeadline(n=>this.githubClient.runs(this.input.owner,this.input.repo,this.workflowId,A,n));this.debug(`Found ${s.length} ${this.workflowId} runs`),r=r||nf(s,this.input);let o=of(s,this.input);if(e){this.debug(`Searching active workflow runs across repository for queue name: ${e}`);let n=await this.withDeadline(i=>this.githubClient.activeRunsForRepo(this.input.owner,this.input.repo,A,i));r=r||nf(n,this.input),o=of(n,this.input).filter(i=>{let a=i.display_title?.includes(e)||i.name?.includes(e);return a&&this.debug(`Run ${i.id} (${i.display_title||i.name}) matches queue: "${e}"`),a}),this.debug(`After queue filtering: ${o.length} runs match queue "${e}"`)}return{currentRun:r,filteredRuns:o}};waitForCompletion=async()=>{let e=this.timing.now()/1e3;for(;;){let{currentRun:r,filteredRuns:A}=await this.discoverRuns(),s=r?Ai(r):void 0;s!==void 0&&this.debug("Found current run "+this.input.runId+" attempt "+this.input.runAttempt+" at "+new Date(s).toISOString());let o=A.filter(n=>kM(n,this.input,s)).filter(n=>{let i=n.conclusion==="success";return i&&this.debug(`Skipping run ${n.id}, status: ${n.status}, conclusion: ${n.conclusion}`),!i}).sort(af).slice(0,fM);if(o.length===0){It("force_continued",""),this.clearPreviousRunOutput();let n=this.deadline;if(!n)throw new Error("Wait deadline has not been initialized");let i=Math.max(0,this.timing.now()/1e3-e);if(ithis.githubClient.jobs(this.input.owner,this.input.repo,i.id,u))).find(u=>u.name===this.input.jobToWaitFor);if(this.input.stepToWaitFor&&c){this.debug(`Fetching steps for job ${c.id}`);let g=(await this.withDeadline(E=>this.githubClient.steps(this.input.owner,this.input.repo,c.id,E))).find(E=>E.name===this.input.stepToWaitFor);if(g&&g.status!=="completed"){this.setPreviousRunOutput(i),this.info(`\u270BAwaiting step completion from job ${c.html_url} ...`),n=!0;break}else if(g){this.info(`Step ${this.input.stepToWaitFor} completed from run ${i.html_url}`);continue}this.info(`Step ${this.input.stepToWaitFor} not found in job ${c.id}, awaiting job completion for safety`)}if(c&&c.status!=="completed"){this.setPreviousRunOutput(i),this.info(`\u270BAwaiting job run completion from job ${c.html_url} ...`),n=!0;break}else if(c){this.info(`Job ${this.input.jobToWaitFor} completed from run ${i.html_url}`);continue}else this.info(`Job ${this.input.jobToWaitFor} not found in run ${i.id}, awaiting full run for safety`);this.setPreviousRunOutput(i),this.info(`\u270BAwaiting run ${i.html_url} ...`),n=!0;break}if(!n){this.clearPreviousRunOutput();return}}else{let n=o[0];this.setPreviousRunOutput(n),this.info(`\u270BAwaiting run ${n.html_url} ...`)}await this.pollAndWait()}};wait=async(e=0)=>{let r=this.sharedDeadline||sr.fromInput(this.input,this.timing,e),A=!this.sharedDeadline;this.deadline=r;try{r.throwIfReached(),await this.waitForCompletion(),r.throwIfReached();return}catch(s){if(s instanceof Ar)return zn(s,this.info,this.clearPreviousRunOutput);throw A&&r.cancel(s),s}finally{A&&r.dispose(),this.deadline=void 0}};pollAndWait=async()=>{let e=this.deadline;if(!e)throw new Error("Wait deadline has not been initialized");await e.sleepSeconds(this.input.pollIntervalSeconds)}};var gf=(t,e)=>((e.workflowPath?t.find(A=>A.path===e.workflowPath):void 0)||t.find(A=>A.name===e.workflowName))?.id;var TM=(t,e)=>new ti(t,e),FM=(t,e,r,A)=>new si(t,e,r,Og,NA,void 0,A),SM=t=>sr.fromInput(t),uf=t=>t instanceof Error?t.message:String(t);async function Ef(t=lf.env,e=TM,r=FM,A=SM){let s;try{let o=sf(t),n=A(o);s=n,NA(`Parsed inputs (w/o token): ${(({githubToken:u,...g})=>JSON.stringify(g))(o)}`),n.throwIfReached();let i=e(o.githubToken,o.retries);NA(`Fetching workflows for ${o.owner}/${o.repo}...`);let a=await n.race(u=>i.workflows(o.owner,o.repo,{signal:u,checkDeadline:n.throwIfReached}));NA(`Found ${a.length} workflows in ${o.owner}/${o.repo}`),n.throwIfReached();let c=gf(a,o);c!==void 0?await r(c,i,o,n).wait()===void 0&&n.throwIfReached():(n.throwIfReached(),qn(`No workflow found matching workflow path or name: ${o.workflowPath||o.workflowName}`))}catch(o){if(o instanceof Ar)try{zn(o,Og,()=>{It("previous_run_id",""),It("previous_run_url","")})}catch(n){qn(uf(n))}else s?.cancel(o),qn(uf(o))}finally{s?.dispose()}}require.main===module&&Ef();0&&(module.exports={run}); /*! Bundled license information: undici/lib/web/fetch/body.js: diff --git a/src/deadline.ts b/src/deadline.ts new file mode 100644 index 0000000..3808eb3 --- /dev/null +++ b/src/deadline.ts @@ -0,0 +1,253 @@ +import { setOutput } from '@actions/core'; + +export const MAX_TIMER_DELAY_MILLISECONDS = 2_147_483_647; + +export type DeadlineMode = 'continue' | 'abort'; + +export interface DeadlineConfig { + mode: DeadlineMode; + seconds: number; +} + +export interface DeadlineInput { + abortAfterSeconds: number | undefined; + continueAfterSeconds: number | undefined; +} + +export interface DeadlineTiming { + now(): number; + setTimeout(callback: () => void, milliseconds: number): ReturnType; + clearTimeout(timeout: ReturnType): void; +} + +export const systemDeadlineTiming: DeadlineTiming = { + now: () => performance.now(), + setTimeout: (callback, milliseconds) => setTimeout(callback, milliseconds), + clearTimeout: (timeout) => clearTimeout(timeout), +}; + +type DeadlineOutcome = { kind: 'deadline' }; +type OperationOutcome = { kind: 'value'; value: T } | { kind: 'error'; error: unknown }; + +export class DeadlineReached extends Error { + constructor( + readonly mode: DeadlineMode, + readonly seconds: number, + ) { + super(`Wait ${mode} deadline reached`); + } +} + +/** + * One monotonic action-lifecycle deadline and timer scheduler shared by all + * Actions API reads and sleeps. + */ +export class ActionDeadline { + readonly signal: AbortSignal; + + private readonly controller: AbortController; + private readonly deadlineAtSeconds: number | undefined; + private readonly reached: Promise; + private readonly resolveReached: (outcome: DeadlineOutcome) => void; + private readonly startedAtSeconds: number; + private readonly timing: DeadlineTiming; + private expired = false; + private timer: ReturnType | undefined; + + static fromInput( + input: DeadlineInput, + timing: DeadlineTiming = systemDeadlineTiming, + secondsSoFar: number = 0, + ): ActionDeadline { + const config: DeadlineConfig | undefined = + input.continueAfterSeconds !== undefined + ? { mode: 'continue', seconds: input.continueAfterSeconds } + : input.abortAfterSeconds !== undefined + ? { mode: 'abort', seconds: input.abortAfterSeconds } + : undefined; + return new ActionDeadline(config, timing, secondsSoFar); + } + + constructor( + readonly config: DeadlineConfig | undefined, + timing: DeadlineTiming = systemDeadlineTiming, + secondsSoFar: number = 0, + ) { + this.timing = timing; + this.startedAtSeconds = timing.now() / 1000 - secondsSoFar; + this.deadlineAtSeconds = + config === undefined ? undefined : this.startedAtSeconds + config.seconds; + this.controller = new AbortController(); + this.signal = this.controller.signal; + + let resolveReached!: (outcome: DeadlineOutcome) => void; + this.reached = new Promise((resolve) => { + resolveReached = resolve; + }); + this.resolveReached = resolveReached; + + this.scheduleDeadlineChunk(); + } + + private delayUntil = (targetSeconds: number): number => { + const remainingSeconds = targetSeconds - this.timing.now() / 1000; + if (remainingSeconds <= 0) { + return 0; + } + + const maximumTimerSeconds = MAX_TIMER_DELAY_MILLISECONDS / 1000; + if (remainingSeconds > maximumTimerSeconds) { + return MAX_TIMER_DELAY_MILLISECONDS; + } + + // Multiplication happens only after the value is bounded to Node's timer + // range. Keep a one-millisecond floor so an early fractional callback is + // rechecked instead of creating a zero-delay loop. + return Math.max(1, Math.round(remainingSeconds * 1000)); + }; + + private deadlineReached = (): boolean => + this.expired || + (this.deadlineAtSeconds !== undefined && this.timing.now() / 1000 >= this.deadlineAtSeconds); + + private expire = (): void => { + if (this.expired || !this.config) { + return; + } + + this.expired = true; + this.resolveReached({ kind: 'deadline' }); + this.controller.abort(); + }; + + private scheduleDeadlineChunk = (): void => { + if (this.deadlineAtSeconds === undefined || this.expired) { + return; + } + + const delay = this.delayUntil(this.deadlineAtSeconds); + if (delay === 0) { + this.expire(); + return; + } + + this.timer = this.timing.setTimeout(() => { + this.timer = undefined; + if (this.deadlineReached()) { + this.expire(); + } else { + this.scheduleDeadlineChunk(); + } + }, delay); + }; + + throwIfReached = (): void => { + const config = this.config; + if (config && this.deadlineReached()) { + this.expire(); + throw new DeadlineReached(config.mode, config.seconds); + } + }; + + race = async (operation: (signal: AbortSignal) => Promise): Promise => { + this.throwIfReached(); + this.signal.throwIfAborted(); + const config = this.config; + if (!config) { + return operation(this.signal); + } + + const operationOutcome = Promise.resolve() + .then(() => operation(this.signal)) + .then, OperationOutcome>( + (value) => ({ kind: 'value', value }), + (error: unknown) => ({ kind: 'error', error }), + ); + const outcome = await Promise.race([operationOutcome, this.reached]); + + if (outcome.kind === 'deadline') { + throw new DeadlineReached(config.mode, config.seconds); + } + // The monotonic boundary wins even if the event loop has not delivered the + // timer callback yet. This check also makes API rejection at the boundary a + // deadline result rather than an incidental abort error. + this.throwIfReached(); + if (outcome.kind === 'error') { + throw outcome.error; + } + return outcome.value; + }; + + private sleepUntilSeconds = async ( + sleepUntilSeconds: number, + signal?: AbortSignal, + ): Promise => { + signal?.throwIfAborted(); + this.throwIfReached(); + + while (true) { + this.throwIfReached(); + const delay = this.delayUntil(sleepUntilSeconds); + if (delay === 0) { + return; + } + + let sleepTimer: ReturnType | undefined; + const chunk = new Promise((resolve) => { + sleepTimer = this.timing.setTimeout(resolve, delay); + }); + let rejectForAbort!: (reason: unknown) => void; + const aborted = new Promise((_resolve, reject) => { + rejectForAbort = reject; + }); + const onAbort = () => { + if (sleepTimer !== undefined) { + this.timing.clearTimeout(sleepTimer); + sleepTimer = undefined; + } + rejectForAbort(signal?.reason); + }; + signal?.addEventListener('abort', onAbort, { once: true }); + try { + await this.race(() => (signal ? Promise.race([chunk, aborted]) : chunk)); + } finally { + signal?.removeEventListener('abort', onAbort); + if (sleepTimer !== undefined) { + this.timing.clearTimeout(sleepTimer); + } + } + } + }; + + sleepSeconds = async (seconds: number, signal?: AbortSignal): Promise => + this.sleepUntilSeconds(this.timing.now() / 1000 + seconds, signal); + + cancel = (reason?: unknown): void => { + this.controller.abort(reason); + }; + + dispose = (): void => { + if (this.timer !== undefined) { + this.timing.clearTimeout(this.timer); + this.timer = undefined; + } + }; +} + +export const handleDeadline = ( + reached: DeadlineReached, + info: (message: string) => void, + clearPreviousRunOutput: () => void, +): number => { + if (reached.mode === 'continue') { + info(`🤙Exceeded wait seconds. Continuing...`); + setOutput('force_continued', '1'); + clearPreviousRunOutput(); + return reached.seconds; + } + + info(`🛑Exceeded wait seconds. Aborting...`); + setOutput('force_continued', ''); + clearPreviousRunOutput(); + throw new Error(`Aborted after waiting ${reached.seconds} seconds`); +}; diff --git a/src/github.ts b/src/github.ts index 85f71d3..6cd496e 100644 --- a/src/github.ts +++ b/src/github.ts @@ -2,29 +2,36 @@ import { warning } from '@actions/core'; import { retry } from '@octokit/plugin-retry'; import { throttling } from '@octokit/plugin-throttling'; import { Octokit } from '@octokit/rest'; -import type { EndpointDefaults, Endpoints, RequestParameters } from '@octokit/types'; +import type { + EndpointDefaults, + Endpoints, + RequestInterface, + RequestParameters, +} from '@octokit/types'; +import { retryRequest } from './retry'; const ThrottledOctokit = Octokit.plugin(throttling, retry); const MAX_WORKFLOW_RUN_PAGES = 50; const ACTIVE_RUN_STATUSES = ['in_progress', 'queued', 'waiting'] as const; const ACTIVE_RUN_STATUS_SET = new Set(ACTIVE_RUN_STATUSES); -const DO_NOT_RETRY_STATUS_CODES = Array.from({ length: 100 }, (_, index) => 400 + index); type ThrottleRequestOptions = Pick, 'method' | 'url'>; -export const createThrottleOptions = () => ({ +export const createThrottleOptions = (retryThroughPlugin: boolean = true) => ({ onRateLimit: ( retryAfter: number, options: ThrottleRequestOptions, _octokit: unknown, retryCount: number, - ) => { + ): true | undefined => { warning(`Request quota exhausted for request ${options.method} ${options.url}`); - if (retryCount < 1) { + if (retryCount < 1 && retryThroughPlugin) { // only retries once warning(`Retrying after ${retryAfter} seconds!`); return true; } + + return undefined; }, onSecondaryRateLimit: (_retryAfter: number, options: ThrottleRequestOptions) => { // does not retry, only logs a warning @@ -45,8 +52,33 @@ export interface WorkflowRunFilters { export interface GitHubRequestOptions { signal?: AbortSignal; + checkDeadline?: () => void; } +const presentRequestOptions = ( + requestOptions: GitHubRequestOptions, +): GitHubRequestOptions | undefined => { + const options: GitHubRequestOptions = { + ...(requestOptions.signal ? { signal: requestOptions.signal } : {}), + ...(requestOptions.checkDeadline ? { checkDeadline: requestOptions.checkDeadline } : {}), + }; + return options.signal || options.checkDeadline ? options : undefined; +}; + +const bindRequestOptions = ( + request: T, + requestOptions: GitHubRequestOptions, +): T => { + const options = presentRequestOptions(requestOptions); + // The pagination plugin reconstructs each page request from method, URL, + // and headers. Binding lifecycle options into the method defaults keeps the + // signal and monotonic checkpoint present when those reduced page options + // pass through the request and retry hooks. + // `.defaults()` preserves the endpoint's request and response contract, but + // its public return type does not retain the endpoint method's subtype. + return (options ? request.defaults({ request: options }) : request) as T; +}; + const matchesWorkflowRunFilters = (run: WorkflowRun, filters: WorkflowRunFilters) => { if (!ACTIVE_RUN_STATUS_SET.has(run.status || '')) { return false; @@ -74,25 +106,47 @@ export class OctokitGitHub { this.octokit = new ThrottledOctokit({ baseUrl: process.env['GITHUB_API_URL'] || 'https://api.github.com', auth: githubToken, - // retries defaults to 0, which disables the retry plugin entirely (no - // request wrapping). When set, it retries transient 5xx errors with - // backoff. All 4xx responses are excluded so permanent client errors and - // rate limits do not retry through plugin-retry. + // Turnstyle installs its equivalent request hook below so a shared + // action signal can cancel 5xx backoff. Disable plugin-retry's private + // Bottleneck timer while retaining the plugin dependency and API shape. retry: { - enabled: retries > 0, - retries, - doNotRetry: DO_NOT_RETRY_STATUS_CODES, + enabled: false, }, - throttle: createThrottleOptions(), + // The callback keeps the existing warning behavior but declines the + // plugin's private retry timer. The request hook below applies the same + // retry policy through Turnstyle's abortable scheduler. + throttle: createThrottleOptions(false), }); - } - workflows = async (owner: string, repo: string) => - this.octokit.paginate(this.octokit.actions.listRepoWorkflows, { - owner, - repo, - per_page: 100, + this.octokit.hook.wrap('request', (request, options) => { + return retryRequest( + (retryCount) => + Promise.resolve( + request({ + ...options, + request: { + ...options.request, + retryCount, + }, + }), + ), + retries, + options.request.signal, + (delaySeconds) => warning(`Retrying after ${delaySeconds} seconds!`), + options.request.checkDeadline, + ); }); + } + + workflows = async (owner: string, repo: string, requestOptions: GitHubRequestOptions = {}) => + this.octokit.paginate( + bindRequestOptions(this.octokit.actions.listRepoWorkflows, requestOptions), + { + owner, + repo, + per_page: 100, + }, + ); run = async ( owner: string, @@ -100,11 +154,12 @@ export class OctokitGitHub { run_id: number, requestOptions: GitHubRequestOptions = {}, ): Promise => { + const lifecycleOptions = presentRequestOptions(requestOptions); const { data } = await this.octokit.actions.getWorkflowRun({ owner, repo, run_id, - ...(requestOptions.signal ? { request: { signal: requestOptions.signal } } : {}), + ...(lifecycleOptions ? { request: lifecycleOptions } : {}), }); return data as WorkflowRun; }; @@ -131,12 +186,11 @@ export class OctokitGitHub { ACTIVE_RUN_STATUSES.map(async (status) => { let pagesScanned = 0; const runs = await paginateWorkflowRuns( - listRuns, + bindRequestOptions(listRuns, requestOptions), { ...baseOptions, ...(filters.branch ? { branch: filters.branch } : {}), status, - ...(requestOptions.signal ? { request: { signal: requestOptions.signal } } : {}), }, (response: { data: WorkflowRun[] }, done: () => void) => { pagesScanned += 1; @@ -204,7 +258,12 @@ export class OctokitGitHub { ); }; - jobs = async (owner: string, repo: string, run_id: number) => { + jobs = async ( + owner: string, + repo: string, + run_id: number, + requestOptions: GitHubRequestOptions = {}, + ) => { const options: Endpoints['GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs']['parameters'] = { owner, @@ -213,14 +272,24 @@ export class OctokitGitHub { per_page: 100, }; - return this.octokit.paginate(this.octokit.actions.listJobsForWorkflowRun, options); + return this.octokit.paginate( + bindRequestOptions(this.octokit.actions.listJobsForWorkflowRun, requestOptions), + options, + ); }; - steps = async (owner: string, repo: string, job_id: number) => { + steps = async ( + owner: string, + repo: string, + job_id: number, + requestOptions: GitHubRequestOptions = {}, + ) => { + const lifecycleOptions = presentRequestOptions(requestOptions); const options: Endpoints['GET /repos/{owner}/{repo}/actions/jobs/{job_id}']['parameters'] = { owner, repo, job_id, + ...(lifecycleOptions ? { request: lifecycleOptions } : {}), }; const { data: job } = await this.octokit.actions.getJobForWorkflowRun(options); return job.steps || []; diff --git a/src/main.ts b/src/main.ts index 59019bb..1e1d6a9 100644 --- a/src/main.ts +++ b/src/main.ts @@ -1,21 +1,33 @@ -import { debug, info, setFailed } from '@actions/core'; +import { debug, info, setFailed, setOutput } from '@actions/core'; import { env } from 'process'; -import { OctokitGitHub } from './github'; +import { ActionDeadline, DeadlineReached, handleDeadline } from './deadline'; +import { OctokitGitHub, type GitHubRequestOptions } from './github'; import { parseInput, type Input } from './input'; import { Waiter, type Wait, type WaiterGitHubClient } from './wait'; import { findWorkflowId, type Workflow } from './workflow'; export interface ActionGitHubClient extends WaiterGitHubClient { - workflows(owner: string, repo: string): Promise; + workflows( + owner: string, + repo: string, + requestOptions?: GitHubRequestOptions, + ): Promise; } export type GitHubClientFactory = (githubToken: string, retries: number) => ActionGitHubClient; -export type WaiterFactory = (workflowId: number, github: WaiterGitHubClient, input: Input) => Wait; +export type WaiterFactory = ( + workflowId: number, + github: WaiterGitHubClient, + input: Input, + deadline: ActionDeadline, +) => Wait; +export type DeadlineFactory = (input: Input) => ActionDeadline; const createGitHubClient: GitHubClientFactory = (githubToken, retries) => new OctokitGitHub(githubToken, retries); -const createWaiter: WaiterFactory = (workflowId, github, input) => - new Waiter(workflowId, github, input, info, debug); +const createWaiter: WaiterFactory = (workflowId, github, input, deadline) => + new Waiter(workflowId, github, input, info, debug, undefined, deadline); +const createDeadline: DeadlineFactory = (input) => ActionDeadline.fromInput(input); const errorMessage = (error: unknown): string => error instanceof Error ? error.message : String(error); @@ -23,28 +35,57 @@ export async function run( environment: Record = env, githubFactory: GitHubClientFactory = createGitHubClient, waiterFactory: WaiterFactory = createWaiter, + deadlineFactory: DeadlineFactory = createDeadline, ) { + let deadline: ActionDeadline | undefined; try { const input = parseInput(environment); + const actionDeadline = deadlineFactory(input); + deadline = actionDeadline; debug( `Parsed inputs (w/o token): ${(({ githubToken, ...inputs }) => JSON.stringify(inputs))( input, )}`, ); + actionDeadline.throwIfReached(); const github = githubFactory(input.githubToken, input.retries); debug(`Fetching workflows for ${input.owner}/${input.repo}...`); - const workflows = await github.workflows(input.owner, input.repo); + const workflows = await actionDeadline.race((signal) => + github.workflows(input.owner, input.repo, { + signal, + checkDeadline: actionDeadline.throwIfReached, + }), + ); debug(`Found ${workflows.length} workflows in ${input.owner}/${input.repo}`); + actionDeadline.throwIfReached(); const workflowId = findWorkflowId(workflows, input); if (workflowId !== undefined) { - await waiterFactory(workflowId, github, input).wait(); + const result = await waiterFactory(workflowId, github, input, actionDeadline).wait(); + if (result === undefined) { + actionDeadline.throwIfReached(); + } } else { + actionDeadline.throwIfReached(); setFailed( `No workflow found matching workflow path or name: ${input.workflowPath || input.workflowName}`, ); } } catch (error: unknown) { - setFailed(errorMessage(error)); + if (error instanceof DeadlineReached) { + try { + handleDeadline(error, info, () => { + setOutput('previous_run_id', ''); + setOutput('previous_run_url', ''); + }); + } catch (deadlineError: unknown) { + setFailed(errorMessage(deadlineError)); + } + } else { + deadline?.cancel(error); + setFailed(errorMessage(error)); + } + } finally { + deadline?.dispose(); } } diff --git a/src/retry.ts b/src/retry.ts new file mode 100644 index 0000000..f9ea4fa --- /dev/null +++ b/src/retry.ts @@ -0,0 +1,117 @@ +import { ActionDeadline } from './deadline'; + +interface RequestErrorResponse { + headers?: Record; +} + +const errorStatus = (error: unknown): number | undefined => + typeof (error as { status?: unknown } | null)?.status === 'number' + ? (error as { status: number }).status + : undefined; + +const errorMessage = (error: unknown): string => + error instanceof Error + ? error.message + : typeof (error as { message?: unknown } | null)?.message === 'string' + ? (error as { message: string }).message + : ''; + +const isSecondaryRateLimit = (error: unknown): boolean => + /\bsecondary rate\b/i.test(errorMessage(error)); + +const primaryRateLimitDelaySeconds = (error: unknown): number | undefined => { + if (isSecondaryRateLimit(error)) { + return undefined; + } + + const status = errorStatus(error); + if (status !== 403 && status !== 429) { + return undefined; + } + + const response = (error as { response?: RequestErrorResponse }).response; + if (response?.headers?.['x-ratelimit-remaining'] !== '0') { + return undefined; + } + + const resetHeader = response.headers['x-ratelimit-reset']; + if (!resetHeader?.trim()) { + return undefined; + } + + const normalizedReset = resetHeader.trim(); + if (!/^\d+$/.test(normalizedReset)) { + return undefined; + } + + const resetAtSeconds = Number(normalizedReset); + if (!Number.isSafeInteger(resetAtSeconds)) { + return undefined; + } + + return Math.max(Math.ceil(resetAtSeconds - Date.now() / 1000) + 1, 0); +}; + +const waitForRetry = async (seconds: number, signal: AbortSignal | undefined) => { + const scheduler = new ActionDeadline(undefined); + try { + await scheduler.sleepSeconds(seconds, signal); + } finally { + scheduler.dispose(); + } +}; + +/** + * Preserves Turnstyle's retry policy without leaving Octokit's private + * Bottleneck retry timers alive after the action lifecycle signal aborts. + */ +export const retryRequest = async ( + operation: (requestAttemptCount: number) => Promise, + serverErrorRetries: number, + signal?: AbortSignal, + onPrimaryRateLimitRetry?: (delaySeconds: number) => void, + checkDeadline?: () => void, +): Promise => { + let requestAttemptCount = 0; + let serverErrorRetryCount = 0; + let primaryRateLimitRetryCount = 0; + while (true) { + checkDeadline?.(); + signal?.throwIfAborted(); + let value: T; + try { + value = await operation(requestAttemptCount); + } catch (error: unknown) { + // A delayed deadline timer must not allow a completed request to start + // another backoff or retry after the monotonic boundary. + checkDeadline?.(); + signal?.throwIfAborted(); + const status = errorStatus(error); + const primaryRateLimitDelay = primaryRateLimitDelaySeconds(error); + let retryDelay: number | undefined; + + if (status !== undefined && status >= 500 && serverErrorRetryCount < serverErrorRetries) { + serverErrorRetryCount += 1; + retryDelay = serverErrorRetryCount ** 2; + } else if (primaryRateLimitDelay !== undefined && primaryRateLimitRetryCount < 1) { + primaryRateLimitRetryCount += 1; + retryDelay = primaryRateLimitDelay; + onPrimaryRateLimitRetry?.(retryDelay); + } + + if (retryDelay === undefined) { + throw error; + } + + requestAttemptCount += 1; + await waitForRetry(retryDelay, signal); + continue; + } + + // Pagination may use this response to issue another request. Check before + // returning it to Octokit so a late timer callback cannot start that page. + checkDeadline?.(); + signal?.throwIfAborted(); + return value; + } +}; diff --git a/src/wait.ts b/src/wait.ts index 1a80a62..bb9c010 100644 --- a/src/wait.ts +++ b/src/wait.ts @@ -1,4 +1,11 @@ import { setOutput } from '@actions/core'; +import { + ActionDeadline, + DeadlineReached, + handleDeadline, + systemDeadlineTiming, + type DeadlineTiming, +} from './deadline'; import type { GitHubRequestOptions, WorkflowJob, @@ -121,8 +128,18 @@ export interface WaiterGitHubClient { filters?: WorkflowRunFilters, requestOptions?: GitHubRequestOptions, ): Promise; - jobs(owner: string, repo: string, runId: number): Promise; - steps(owner: string, repo: string, jobId: number): Promise; + jobs( + owner: string, + repo: string, + runId: number, + requestOptions?: GitHubRequestOptions, + ): Promise; + steps( + owner: string, + repo: string, + jobId: number, + requestOptions?: GitHubRequestOptions, + ): Promise; } export interface Wait { @@ -135,7 +152,10 @@ export class Waiter implements Wait { private readonly input: Input; private readonly githubClient: WaiterGitHubClient; private readonly workflowId: number; + private readonly timing: DeadlineTiming; + private readonly sharedDeadline: ActionDeadline | undefined; private previousRunOutput: WorkflowRun | undefined; + private deadline: ActionDeadline | undefined; constructor( workflowId: number, @@ -143,12 +163,16 @@ export class Waiter implements Wait { input: Input, info: (msg: string) => void, debug: (msg: string) => void, + timing: DeadlineTiming = systemDeadlineTiming, + deadline?: ActionDeadline, ) { this.workflowId = workflowId; this.input = input; this.githubClient = githubClient; this.info = info; this.debug = debug; + this.timing = timing; + this.sharedDeadline = deadline; } private setPreviousRunOutput = (run: WorkflowRun) => { @@ -166,252 +190,242 @@ export class Waiter implements Wait { } }; - private abortError = (elapsedSeconds: number): Error => { - this.info(`🛑Exceeded wait seconds. Aborting...`); - setOutput('force_continued', ''); - this.clearPreviousRunOutput(); - return new Error(`Aborted after waiting ${elapsedSeconds} seconds`); - }; - - private abort = (elapsedSeconds: number): never => { - throw this.abortError(elapsedSeconds); - }; - - private withAbortTimeout = async ( - elapsedSeconds: number, - operation: (signal: AbortSignal | undefined) => Promise, + private withDeadline = async ( + operation: (requestOptions: GitHubRequestOptions) => Promise, ): Promise => { - if (this.input.abortAfterSeconds === undefined) { - return operation(undefined); - } - - const abortAtSeconds = this.input.abortAfterSeconds; - if (elapsedSeconds >= abortAtSeconds) { - this.abort(elapsedSeconds); + const deadline = this.deadline; + if (!deadline) { + throw new Error('Wait deadline has not been initialized'); } - const remainingMilliseconds = (abortAtSeconds - elapsedSeconds) * 1000; - const controller = new AbortController(); - let timeout: ReturnType | undefined; - const timeoutPromise = new Promise((_, reject) => { - timeout = setTimeout(() => { - controller.abort(); - reject(this.abortError(abortAtSeconds)); - }, remainingMilliseconds); - }); - - try { - return await Promise.race([operation(controller.signal), timeoutPromise]); - } finally { - if (timeout) { - clearTimeout(timeout); - } - } + return deadline.race((signal) => operation({ signal, checkDeadline: deadline.throwIfReached })); }; - wait = async (secondsSoFar?: number): Promise => { - const elapsedSeconds = secondsSoFar || 0; - - if ( - this.input.continueAfterSeconds !== undefined && - elapsedSeconds >= this.input.continueAfterSeconds - ) { - this.info(`🤙Exceeded wait seconds. Continuing...`); - setOutput('force_continued', '1'); - this.clearPreviousRunOutput(); - return elapsedSeconds; - } - - if ( - this.input.abortAfterSeconds !== undefined && - elapsedSeconds >= this.input.abortAfterSeconds - ) { - this.abort(elapsedSeconds); - } - + private discoverRuns = async (): Promise<{ + currentRun: WorkflowRun | undefined; + filteredRuns: WorkflowRun[]; + }> => { this.debug(`Fetching workflow runs for workflow ID: ${this.workflowId}`); const queueName = this.input.queueName; - const { currentRun, filteredRuns } = await this.withAbortTimeout( - elapsedSeconds, - async (signal) => { - const requestOptions = signal ? { signal } : undefined; - let currentRun: WorkflowRun | undefined; - try { - currentRun = requestOptions - ? await this.githubClient.run( - this.input.owner, - this.input.repo, - this.input.runId, - requestOptions, - ) - : await this.githubClient.run(this.input.owner, this.input.repo, this.input.runId); - } catch (error: unknown) { - this.debug(`Failed to fetch current run ${this.input.runId}: ${errorMessage(error)}`); - } - - const runFilters = { - branch: this.input.sameBranchOnly ? this.input.branch : undefined, - }; - const runs = requestOptions - ? await this.githubClient.runs( - this.input.owner, - this.input.repo, - this.workflowId, - runFilters, - requestOptions, - ) - : await this.githubClient.runs( - this.input.owner, - this.input.repo, - this.workflowId, - runFilters, - ); + let currentRun: WorkflowRun | undefined; + try { + currentRun = await this.withDeadline((requestOptions) => + this.githubClient.run(this.input.owner, this.input.repo, this.input.runId, requestOptions), + ); + } catch (error: unknown) { + this.deadline?.throwIfReached(); + this.deadline?.signal.throwIfAborted(); + this.debug(`Failed to fetch current run ${this.input.runId}: ${errorMessage(error)}`); + } - this.debug(`Found ${runs.length} ${this.workflowId} runs`); + const runFilters = { + branch: this.input.sameBranchOnly ? this.input.branch : undefined, + }; + const runs = await this.withDeadline((requestOptions) => + this.githubClient.runs( + this.input.owner, + this.input.repo, + this.workflowId, + runFilters, + requestOptions, + ), + ); - currentRun = currentRun || findCurrentRun(runs, this.input); - let filteredRuns = filterEligibleRuns(runs, this.input); + this.debug(`Found ${runs.length} ${this.workflowId} runs`); - if (queueName) { - this.debug( - `Searching active workflow runs across repository for queue name: ${queueName}`, - ); - const queueRuns = requestOptions - ? await this.githubClient.activeRunsForRepo( - this.input.owner, - this.input.repo, - runFilters, - requestOptions, - ) - : await this.githubClient.activeRunsForRepo( - this.input.owner, - this.input.repo, - runFilters, - ); + currentRun = currentRun || findCurrentRun(runs, this.input); + let filteredRuns = filterEligibleRuns(runs, this.input); - currentRun = currentRun || findCurrentRun(queueRuns, this.input); - filteredRuns = filterEligibleRuns(queueRuns, this.input).filter((run) => { - const matchesQueue = - run.display_title?.includes(queueName) || run.name?.includes(queueName); - if (matchesQueue) { - this.debug( - `Run ${run.id} (${run.display_title || run.name}) matches queue: "${queueName}"`, - ); - } - return matchesQueue; - }); + if (queueName) { + this.debug(`Searching active workflow runs across repository for queue name: ${queueName}`); + const queueRuns = await this.withDeadline((requestOptions) => + this.githubClient.activeRunsForRepo( + this.input.owner, + this.input.repo, + runFilters, + requestOptions, + ), + ); + currentRun = currentRun || findCurrentRun(queueRuns, this.input); + filteredRuns = filterEligibleRuns(queueRuns, this.input).filter((run) => { + const matchesQueue = + run.display_title?.includes(queueName) || run.name?.includes(queueName); + if (matchesQueue) { this.debug( - `After queue filtering: ${filteredRuns.length} runs match queue "${queueName}"`, + `Run ${run.id} (${run.display_title || run.name}) matches queue: "${queueName}"`, ); } + return matchesQueue; + }); - return { currentRun, filteredRuns }; - }, - ); - - const currentRunStartedAt = currentRun ? runTimestamp(currentRun) : undefined; - if (currentRunStartedAt !== undefined) { - this.debug( - 'Found current run ' + - this.input.runId + - ' attempt ' + - this.input.runAttempt + - ' at ' + - new Date(currentRunStartedAt).toISOString(), - ); + this.debug(`After queue filtering: ${filteredRuns.length} runs match queue "${queueName}"`); } - const previousRuns = filteredRuns - .filter((run) => isPreviousRun(run, this.input, currentRunStartedAt)) - .filter((run) => { - const isSuccessful: boolean = run.conclusion === 'success'; - - if (isSuccessful) { - this.debug( - `Skipping run ${run.id}, status: ${run.status}, conclusion: ${run.conclusion}`, - ); - } + return { currentRun, filteredRuns }; + }; - return !isSuccessful; - }) - .sort(compareRunsNewestFirst) - .slice(0, MAX_PREVIOUS_WORKFLOW_RUNS); - if (!previousRuns || !previousRuns.length) { - setOutput('force_continued', ''); - this.clearPreviousRunOutput(); - if (this.input.initialWaitSeconds > 0 && elapsedSeconds < this.input.initialWaitSeconds) { - this.info( - `🔎 Waiting for ${this.input.initialWaitSeconds} seconds before checking for runs again...`, + private waitForCompletion = async (): Promise => { + const initialDiscoveryStartedAtSeconds = this.timing.now() / 1000; + + while (true) { + const { currentRun, filteredRuns } = await this.discoverRuns(); + + const currentRunStartedAt = currentRun ? runTimestamp(currentRun) : undefined; + if (currentRunStartedAt !== undefined) { + this.debug( + 'Found current run ' + + this.input.runId + + ' attempt ' + + this.input.runAttempt + + ' at ' + + new Date(currentRunStartedAt).toISOString(), ); - await new Promise((resolve) => setTimeout(resolve, this.input.initialWaitSeconds * 1000)); - return this.wait(elapsedSeconds + this.input.initialWaitSeconds); } - return; - } else { - this.debug(`Found ${previousRuns.length} previous runs`); - } - // Handle if we are checking for a specific job / step to wait for - if (this.input.jobToWaitFor) { - for (const previousRun of previousRuns) { - this.debug(`Fetching jobs for run ${previousRun.id}`); - const jobs = await this.githubClient.jobs( - this.input.owner, - this.input.repo, - previousRun.id, + const previousRuns = filteredRuns + .filter((run) => isPreviousRun(run, this.input, currentRunStartedAt)) + .filter((run) => { + const isSuccessful: boolean = run.conclusion === 'success'; + + if (isSuccessful) { + this.debug( + `Skipping run ${run.id}, status: ${run.status}, conclusion: ${run.conclusion}`, + ); + } + + return !isSuccessful; + }) + .sort(compareRunsNewestFirst) + .slice(0, MAX_PREVIOUS_WORKFLOW_RUNS); + if (previousRuns.length === 0) { + setOutput('force_continued', ''); + this.clearPreviousRunOutput(); + const deadline = this.deadline; + if (!deadline) { + throw new Error('Wait deadline has not been initialized'); + } + const initialDiscoveryElapsedSeconds = Math.max( + 0, + this.timing.now() / 1000 - initialDiscoveryStartedAtSeconds, ); - const job = jobs.find((job) => job.name === this.input.jobToWaitFor); - // Now handle if we are checking for a specific step - if (this.input.stepToWaitFor && job) { - this.debug(`Fetching steps for job ${job.id}`); - const steps = await this.githubClient.steps(this.input.owner, this.input.repo, job.id); - const step = steps.find((step) => step.name === this.input.stepToWaitFor); - if (step && step.status !== 'completed') { - this.setPreviousRunOutput(previousRun); - this.info(`✋Awaiting step completion from job ${job.html_url} ...`); - return this.pollAndWait(secondsSoFar); - } else if (step) { + if (initialDiscoveryElapsedSeconds < this.input.initialWaitSeconds) { + this.info( + `🔎 Waiting until the ${this.input.initialWaitSeconds}-second initial discovery window expires before checking again...`, + ); + await deadline.sleepSeconds( + this.input.initialWaitSeconds - initialDiscoveryElapsedSeconds, + ); + continue; + } + return; + } else { + this.debug(`Found ${previousRuns.length} previous runs`); + } + + // Handle if we are checking for a specific job / step to wait for + if (this.input.jobToWaitFor) { + let shouldPoll = false; + for (const previousRun of previousRuns) { + this.debug(`Fetching jobs for run ${previousRun.id}`); + const jobs = await this.withDeadline((requestOptions) => + this.githubClient.jobs( + this.input.owner, + this.input.repo, + previousRun.id, + requestOptions, + ), + ); + const job = jobs.find((job) => job.name === this.input.jobToWaitFor); + // Now handle if we are checking for a specific step + if (this.input.stepToWaitFor && job) { + this.debug(`Fetching steps for job ${job.id}`); + const steps = await this.withDeadline((requestOptions) => + this.githubClient.steps(this.input.owner, this.input.repo, job.id, requestOptions), + ); + const step = steps.find((step) => step.name === this.input.stepToWaitFor); + if (step && step.status !== 'completed') { + this.setPreviousRunOutput(previousRun); + this.info(`✋Awaiting step completion from job ${job.html_url} ...`); + shouldPoll = true; + break; + } else if (step) { + this.info( + `Step ${this.input.stepToWaitFor} completed from run ${previousRun.html_url}`, + ); + continue; + } this.info( - `Step ${this.input.stepToWaitFor} completed from run ${previousRun.html_url}`, + `Step ${this.input.stepToWaitFor} not found in job ${job.id}, awaiting job completion for safety`, ); + } + + if (job && job.status !== 'completed') { + this.setPreviousRunOutput(previousRun); + this.info(`✋Awaiting job run completion from job ${job.html_url} ...`); + shouldPoll = true; + break; + } else if (job) { + this.info(`Job ${this.input.jobToWaitFor} completed from run ${previousRun.html_url}`); continue; } else { this.info( - `Step ${this.input.stepToWaitFor} not found in job ${job.id}, awaiting full run for safety`, + `Job ${this.input.jobToWaitFor} not found in run ${previousRun.id}, awaiting full run for safety`, ); } - } - if (job && job.status !== 'completed') { this.setPreviousRunOutput(previousRun); - this.info(`✋Awaiting job run completion from job ${job.html_url} ...`); - return this.pollAndWait(secondsSoFar); - } else if (job) { - this.info(`Job ${this.input.jobToWaitFor} completed from run ${previousRun.html_url}`); - continue; - } else { - this.info( - `Job ${this.input.jobToWaitFor} not found in run ${previousRun.id}, awaiting full run for safety`, - ); + this.info(`✋Awaiting run ${previousRun.html_url} ...`); + shouldPoll = true; + break; } + if (!shouldPoll) { + this.clearPreviousRunOutput(); + return; + } + } else { + const previousRun = previousRuns[0]; this.setPreviousRunOutput(previousRun); this.info(`✋Awaiting run ${previousRun.html_url} ...`); - return this.pollAndWait(secondsSoFar); } - this.clearPreviousRunOutput(); - return; + + await this.pollAndWait(); } + }; - const previousRun = previousRuns[0]; - this.setPreviousRunOutput(previousRun); - this.info(`✋Awaiting run ${previousRun.html_url} ...`); - return this.pollAndWait(secondsSoFar); + wait = async (secondsSoFar: number = 0): Promise => { + const deadline = + this.sharedDeadline || ActionDeadline.fromInput(this.input, this.timing, secondsSoFar); + const ownsDeadline = !this.sharedDeadline; + this.deadline = deadline; + + try { + deadline.throwIfReached(); + await this.waitForCompletion(); + deadline.throwIfReached(); + return undefined; + } catch (error: unknown) { + if (error instanceof DeadlineReached) { + return handleDeadline(error, this.info, this.clearPreviousRunOutput); + } + if (ownsDeadline) { + deadline.cancel(error); + } + throw error; + } finally { + if (ownsDeadline) { + deadline.dispose(); + } + this.deadline = undefined; + } }; - pollAndWait = async (secondsSoFar?: number): Promise => { - await new Promise((resolve) => setTimeout(resolve, this.input.pollIntervalSeconds * 1000)); - return this.wait((secondsSoFar || 0) + this.input.pollIntervalSeconds); + pollAndWait = async (): Promise => { + const deadline = this.deadline; + if (!deadline) { + throw new Error('Wait deadline has not been initialized'); + } + await deadline.sleepSeconds(this.input.pollIntervalSeconds); }; } diff --git a/tsconfig.json b/tsconfig.json index bb2802e..afa5601 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -23,7 +23,7 @@ /* Strict Type-Checking Options */ "strict": true, /* Enable all strict type-checking options. */ - "noImplicitAny": false, /* Raise error on expressions and declarations with an implied 'any' type. */ + "noImplicitAny": true, /* Raise error on expressions and declarations with an implied 'any' type. */ // "strictNullChecks": true, /* Enable strict null checks. */ // "strictFunctionTypes": true, /* Enable strict checking of function types. */ // "strictBindCallApply": true, /* Enable strict 'bind', 'call', and 'apply' methods on functions. */ @@ -34,8 +34,8 @@ /* Additional Checks */ // "noUnusedLocals": true, /* Report errors on unused locals. */ // "noUnusedParameters": true, /* Report errors on unused parameters. */ - // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */ - // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */ + "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */ + "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */ /* Module Resolution Options */ // "moduleResolution": "node", /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */ @@ -43,7 +43,7 @@ // "paths": {}, /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */ // "rootDirs": [], /* List of root folders whose combined content represents the structure of the project at runtime. */ // "typeRoots": [], /* List of folders to include type definitions from. */ - "types": ["node", "vitest/globals"], /* Type declaration files to be included in compilation. */ + "types": ["node"], /* Type declaration files to be included in compilation. */ // "allowSyntheticDefaultImports": true, /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */ "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */ // "preserveSymlinks": true, /* Do not resolve the real path of symlinks. */ diff --git a/tsconfig.test.json b/tsconfig.test.json index f873647..ce0557f 100644 --- a/tsconfig.test.json +++ b/tsconfig.test.json @@ -2,7 +2,8 @@ "extends": "./tsconfig.json", "compilerOptions": { "noEmit": true, - "rootDir": "." + "rootDir": ".", + "types": ["node", "vitest/globals"] }, "include": ["src/**/*.ts", "__tests__/**/*.ts", "vitest.config.ts"], "exclude": ["node_modules", "dist", "coverage"] diff --git a/vitest.config.ts b/vitest.config.ts index 1526245..57acf3b 100644 --- a/vitest.config.ts +++ b/vitest.config.ts @@ -7,10 +7,10 @@ export default defineConfig({ include: ['src/**/*.ts'], reporter: ['text', 'lcov', 'json-summary'], thresholds: { - statements: 95, - branches: 90, - functions: 95, - lines: 95, + statements: 98, + branches: 95, + functions: 98, + lines: 98, }, }, include: ['__tests__/**/*.ts'],