diff --git a/.context/attachments/CleanShot 2026-03-09 at 17.50.38@2x.png b/.context/attachments/CleanShot 2026-03-09 at 17.50.38@2x.png new file mode 100644 index 0000000..f551578 Binary files /dev/null and b/.context/attachments/CleanShot 2026-03-09 at 17.50.38@2x.png differ diff --git a/.context/attachments/pasted_text_2026-03-09_14-00-35.txt b/.context/attachments/pasted_text_2026-03-09_14-00-35.txt new file mode 100644 index 0000000..0a76f12 --- /dev/null +++ b/.context/attachments/pasted_text_2026-03-09_14-00-35.txt @@ -0,0 +1,69 @@ +Assuming “this” means the current branch goal: finish the browser-only OpenHandoff workbench and align it with the documented org-scoped product direction. That inference is based on [SPEC.md](/Users/nathan/conductor/workspaces/handoff/zurich/SPEC.md), [PRD.md](/Users/nathan/conductor/workspaces/handoff/zurich/PRD.md), the current route wiring in [packages/frontend/src/app/router.tsx](/Users/nathan/conductor/workspaces/handoff/zurich/packages/frontend/src/app/router.tsx), the shared workbench contract in [packages/client/src/workbench-client.ts](/Users/nathan/conductor/workspaces/handoff/zurich/packages/client/src/workbench-client.ts), and the backend workbench actions in [packages/backend/src/actors/workspace/actions.ts](/Users/nathan/conductor/workspaces/handoff/zurich/packages/backend/src/actors/workspace/actions.ts) and [packages/backend/src/actors/handoff/workbench.ts](/Users/nathan/conductor/workspaces/handoff/zurich/packages/backend/src/actors/handoff/workbench.ts). + +**Implementation Spec** +OpenHandoff must ship as a browser-only product. The removed CLI/TUI stays removed. The browser UI is the only supported user surface, the backend is a RivetKit actor runtime, and all persistent product state lives in actor-owned SQLite/Drizzle databases. + +The implementation should be treated as one program with two milestones. Milestone 1 is required for merge: deliver the real remote browser workbench on the existing workspace-scoped runtime. Milestone 2 is the documented product cutover: Better Auth, org actors, automatic GitHub org import, seat accounting, and hosted Stripe billing. The code should be structured so Milestone 2 layers onto Milestone 1 without rewriting the workbench contract. + +**Current Baseline** +The frontend currently routes all workbench URLs into the mock layout. The backend and client already expose a real workbench API. The runtime currently registers `workspace`, `project`, `handoff`, `sandboxInstance`, `history`, and sync actors, but not the documented `AuthIndexActor`, `UserActor`, or `OrganizationActor`. The spec below preserves the existing workbench API surface and extends the system around it. + +**Product Scope** +The main screen is a three-column workbench: left rail, center panel, right rail. The left rail shows the active org/workspace, repos, and handoffs grouped by repo and sorted by most recent activity. The center panel shows either the active handoff transcript or repo-level empty/loading states. The right rail shows branch/PR status, changed files, full file tree, and actions such as publish, push, revert, and archive. + +A handoff must support multiple session tabs, diff tabs, unread state, draft persistence, inline rename for handoff title and branch, diff-line attachments into the composer, stop/send actions, PR publish/open, file revert, and archive. Archived handoffs become read-only. Repo routes may continue to redirect into the active handoff until a dedicated repo overview is fully productized, but the route contract must remain stable. + +Milestone 2 adds sign-in with GitHub via Better Auth, org selection, automatic repo catalog import for the active org, seat accounting by signed-in member email after first prompt, and Stripe hosted billing flows. Personal GitHub use is modeled as a personal org. + +**Architecture Rules** +`packages/frontend` owns UI only. `packages/client` is the only browser-to-backend boundary. `packages/frontend` must not call RivetKit or backend endpoints directly. The backend exposes RivetKit routes and Better Auth routes only; do not add a custom REST shim. + +All actor keys remain prefixed with `["ws", workspaceId, ...]`. `workspaceId` is still the internal key label even after org support lands; treat it as the active org identifier. Parent actors use command-only loops with no timeout. Periodic polling stays in dedicated child actors with one timeout cadence each. Every table or row has exactly one actor writer. + +Milestone 1 continues to use the existing actor set. Milestone 2 introduces `AuthIndexActor`, `UserActor`, and `OrganizationActor` without breaking existing workspace/project/handoff keying. `OrganizationActor` owns membership, seats, billing state, and repo catalog import. `UserActor` owns auth-linked user state and GitHub credential references. GitHub API access must use the signed-in user OAuth token, never a backend-global GitHub token for normal product behavior. + +**Canonical Contracts** +The canonical browser workbench contract is `HandoffWorkbenchClient` plus the shared snapshot/types in [packages/shared/src/workbench.ts](/Users/nathan/conductor/workspaces/handoff/zurich/packages/shared/src/workbench.ts). Keep that surface stable. The remote implementation may evolve internally, but the frontend should continue consuming a single live snapshot plus async commands. + +The workbench snapshot must contain workspace/org id, repo list, grouped projects, handoffs, session tabs, transcript events, file changes, parsed diffs, and file tree. The UI’s stable behavior is defined by the mock feature tracker in [docs/frontend/mock-ui-features.md](/Users/nathan/conductor/workspaces/handoff/zurich/docs/frontend/mock-ui-features.md); the remote workbench must reach feature parity with every item marked `Done` in mock mode, except the currently partial Push button which must become fully functional. + +**Frontend Requirements** +Replace the hardwired mock routing with mode-aware routing. `mock` mode must continue to work for UI development. `remote` mode must render the same workbench UX backed by the remote client. Do not fork the UI into separate mock and remote component trees; keep one render path over the shared contract. + +Keep transient UI state local: selected tab, open diff tabs, inline rename state, local scroll/selection state. Keep persistent workbench state in the backend-owned snapshot: drafts, unread flags, session metadata, transcript, diff/file state, handoff metadata. The UI must react in realtime to backend broadcasts without manual refresh controls. + +The transcript renderer must collapse chunked agent output into readable messages and hide non-user-facing session envelopes. When an agent reply completes, the backend owns unread transitions; the frontend clears unread only when the user actually views that session. Sending from a diff tab must return focus to the last selected agent tab. Closing the last remaining session tab is disallowed. + +**Backend Requirements** +`WorkspaceActor.getWorkbench()` remains the top-level snapshot assembler. `HandoffActor.getWorkbench()` remains the per-handoff projection builder. The workbench session table in the handoff actor remains the source of truth for session name, model, unread state, draft text, draft attachments, closed state, and thinking timestamp. + +Git state for the right rail comes from the active sandbox checkout. The backend must continue deriving changed files, per-file diffs, and the file tree from git state inside the sandbox. Revert operates in the sandbox checkout. Publish PR uses the GitHub driver. Push must be implemented end-to-end as a real handoff action exposed in the workbench client and UI. + +Lifecycle state remains explicit and persisted. The user-facing handoff states are `new`, `running`, `idle`, and `archived`, derived from the more granular backend status set. Archive must not block on slow sandbox teardown; finalize user-visible archive first, then allow best-effort sandbox cleanup. + +**Auth / Org / Billing Requirements** +Add Better Auth at `/api/auth/*` with GitHub OAuth as the primary provider. Org selection happens immediately after sign-in if there is more than one eligible org. Selecting an org initializes the active `workspaceId` scope. Repo catalogs import automatically for that org. The user does not manually register repos in Milestone 2 unless a repo is outside the imported catalog flow. + +Seat accounting increments when a signed-in member sends their first prompt in an org. Seat usage is org-scoped and tied to member email. Billing uses the simplest hosted Stripe flow possible. Billing state lives in actor-owned persistence, not a shared Postgres service. + +**Non-Goals** +Do not revive CLI/TUI behavior. Do not add frontend-side direct RivetKit usage. Do not add polling-based manual refresh UX for normal product flows. Do not add custom billing UI unless Stripe forces it. Do not add backend-global SQLite singletons. + +**Delivery Plan** +Phase 1: switch browser routes to a shared real workbench UI, backed by `HandoffWorkbenchClient` in both mock and remote modes. +Phase 2: close remote parity gaps: unread rules, rename flows, multi-tab session management, diff attachments, push, publish, revert, archive, and realtime updates. +Phase 3: add Better Auth, GitHub OAuth token propagation, org actors, org repo import, and active-org selection. +Phase 4: add seat accounting and hosted Stripe billing. +Phase 5: update docs, screenshots, and E2E coverage; remove any stale frontend/dashboard paths that duplicate the workbench. + +**Acceptance Criteria** +In remote mode, `/workspaces/$workspaceId/handoffs/$handoffId` works end-to-end against the real backend with the same interaction model as mock mode. +Every mock feature marked `Done` is implemented remotely, except anything explicitly reclassified as out of scope in docs. +The frontend never calls backend endpoints directly outside `packages/client`. +Realtime updates happen via actor broadcasts/subscriptions, not user refresh. +GitHub operations use the signed-in user’s OAuth token. +Org selection, repo import, seat accrual, and billing flows are browser-first and organization-scoped. +Validation passes with `pnpm -w typecheck`, `pnpm -w build`, and `pnpm -w test`. +Client E2E covers create handoff, initial run, add tab, rename session, draft persistence, send message, unread transitions, close tab, revert file, archive, and publish/push where supported. + +If you want, I can turn this into a repo-ready `SPEC.md` rewrite or split it into implementation tickets by phase. \ No newline at end of file diff --git a/.context/factory-workbench-remote.png b/.context/factory-workbench-remote.png new file mode 100644 index 0000000..f11fa66 Binary files /dev/null and b/.context/factory-workbench-remote.png differ diff --git a/.context/mock-billing.png b/.context/mock-billing.png new file mode 100644 index 0000000..1f881c9 Binary files /dev/null and b/.context/mock-billing.png differ diff --git a/.context/mock-import.png b/.context/mock-import.png new file mode 100644 index 0000000..5a50051 Binary files /dev/null and b/.context/mock-import.png differ diff --git a/.context/mock-org-settings.png b/.context/mock-org-settings.png new file mode 100644 index 0000000..4fe0118 Binary files /dev/null and b/.context/mock-org-settings.png differ diff --git a/.context/mock-signin.png b/.context/mock-signin.png new file mode 100644 index 0000000..3f0e9fc Binary files /dev/null and b/.context/mock-signin.png differ diff --git a/.context/notes.md b/.context/notes.md new file mode 100644 index 0000000..e69de29 diff --git a/.context/todos.md b/.context/todos.md new file mode 100644 index 0000000..e69de29 diff --git a/.dockerignore b/.dockerignore index cb03545..5625bc9 100644 --- a/.dockerignore +++ b/.dockerignore @@ -17,7 +17,7 @@ coverage/ # Environment .env .env.* -.openhandoff/ +.sandbox-agent-factory/ # IDE .idea/ diff --git a/.gitignore b/.gitignore index da6874a..cf8bd83 100644 --- a/.gitignore +++ b/.gitignore @@ -51,6 +51,7 @@ Cargo.lock # Example temp files .tmp-upload/ *.db +.sandbox-agent-factory/ .openhandoff/ # CLI binaries (downloaded during npm publish) diff --git a/factory/.context/e2e-remote.git/HEAD b/factory/.context/e2e-remote.git/HEAD new file mode 100644 index 0000000..b870d82 --- /dev/null +++ b/factory/.context/e2e-remote.git/HEAD @@ -0,0 +1 @@ +ref: refs/heads/main diff --git a/factory/.context/e2e-remote.git/config b/factory/.context/e2e-remote.git/config new file mode 100644 index 0000000..e6da231 --- /dev/null +++ b/factory/.context/e2e-remote.git/config @@ -0,0 +1,6 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = true + ignorecase = true + precomposeunicode = true diff --git a/factory/.context/e2e-remote.git/description b/factory/.context/e2e-remote.git/description new file mode 100644 index 0000000..498b267 --- /dev/null +++ b/factory/.context/e2e-remote.git/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/factory/.context/e2e-remote.git/hooks/applypatch-msg.sample b/factory/.context/e2e-remote.git/hooks/applypatch-msg.sample new file mode 100755 index 0000000..a5d7b84 --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/applypatch-msg.sample @@ -0,0 +1,15 @@ +#!/bin/sh +# +# An example hook script to check the commit log message taken by +# applypatch from an e-mail message. +# +# The hook should exit with non-zero status after issuing an +# appropriate message if it wants to stop the commit. The hook is +# allowed to edit the commit message file. +# +# To enable this hook, rename this file to "applypatch-msg". + +. git-sh-setup +commitmsg="$(git rev-parse --git-path hooks/commit-msg)" +test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"} +: diff --git a/factory/.context/e2e-remote.git/hooks/commit-msg.sample b/factory/.context/e2e-remote.git/hooks/commit-msg.sample new file mode 100755 index 0000000..b58d118 --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/commit-msg.sample @@ -0,0 +1,24 @@ +#!/bin/sh +# +# An example hook script to check the commit log message. +# Called by "git commit" with one argument, the name of the file +# that has the commit message. The hook should exit with non-zero +# status after issuing an appropriate message if it wants to stop the +# commit. The hook is allowed to edit the commit message file. +# +# To enable this hook, rename this file to "commit-msg". + +# Uncomment the below to add a Signed-off-by line to the message. +# Doing this in a hook is a bad idea in general, but the prepare-commit-msg +# hook is more suited to it. +# +# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') +# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1" + +# This example catches duplicate Signed-off-by lines. + +test "" = "$(grep '^Signed-off-by: ' "$1" | + sort | uniq -c | sed -e '/^[ ]*1[ ]/d')" || { + echo >&2 Duplicate Signed-off-by lines. + exit 1 +} diff --git a/factory/.context/e2e-remote.git/hooks/fsmonitor-watchman.sample b/factory/.context/e2e-remote.git/hooks/fsmonitor-watchman.sample new file mode 100755 index 0000000..23e856f --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/fsmonitor-watchman.sample @@ -0,0 +1,174 @@ +#!/usr/bin/perl + +use strict; +use warnings; +use IPC::Open2; + +# An example hook script to integrate Watchman +# (https://facebook.github.io/watchman/) with git to speed up detecting +# new and modified files. +# +# The hook is passed a version (currently 2) and last update token +# formatted as a string and outputs to stdout a new update token and +# all files that have been modified since the update token. Paths must +# be relative to the root of the working tree and separated by a single NUL. +# +# To enable this hook, rename this file to "query-watchman" and set +# 'git config core.fsmonitor .git/hooks/query-watchman' +# +my ($version, $last_update_token) = @ARGV; + +# Uncomment for debugging +# print STDERR "$0 $version $last_update_token\n"; + +# Check the hook interface version +if ($version ne 2) { + die "Unsupported query-fsmonitor hook version '$version'.\n" . + "Falling back to scanning...\n"; +} + +my $git_work_tree = get_working_dir(); + +my $retry = 1; + +my $json_pkg; +eval { + require JSON::XS; + $json_pkg = "JSON::XS"; + 1; +} or do { + require JSON::PP; + $json_pkg = "JSON::PP"; +}; + +launch_watchman(); + +sub launch_watchman { + my $o = watchman_query(); + if (is_work_tree_watched($o)) { + output_result($o->{clock}, @{$o->{files}}); + } +} + +sub output_result { + my ($clockid, @files) = @_; + + # Uncomment for debugging watchman output + # open (my $fh, ">", ".git/watchman-output.out"); + # binmode $fh, ":utf8"; + # print $fh "$clockid\n@files\n"; + # close $fh; + + binmode STDOUT, ":utf8"; + print $clockid; + print "\0"; + local $, = "\0"; + print @files; +} + +sub watchman_clock { + my $response = qx/watchman clock "$git_work_tree"/; + die "Failed to get clock id on '$git_work_tree'.\n" . + "Falling back to scanning...\n" if $? != 0; + + return $json_pkg->new->utf8->decode($response); +} + +sub watchman_query { + my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty') + or die "open2() failed: $!\n" . + "Falling back to scanning...\n"; + + # In the query expression below we're asking for names of files that + # changed since $last_update_token but not from the .git folder. + # + # To accomplish this, we're using the "since" generator to use the + # recency index to select candidate nodes and "fields" to limit the + # output to file names only. Then we're using the "expression" term to + # further constrain the results. + my $last_update_line = ""; + if (substr($last_update_token, 0, 1) eq "c") { + $last_update_token = "\"$last_update_token\""; + $last_update_line = qq[\n"since": $last_update_token,]; + } + my $query = <<" END"; + ["query", "$git_work_tree", {$last_update_line + "fields": ["name"], + "expression": ["not", ["dirname", ".git"]] + }] + END + + # Uncomment for debugging the watchman query + # open (my $fh, ">", ".git/watchman-query.json"); + # print $fh $query; + # close $fh; + + print CHLD_IN $query; + close CHLD_IN; + my $response = do {local $/; }; + + # Uncomment for debugging the watch response + # open ($fh, ">", ".git/watchman-response.json"); + # print $fh $response; + # close $fh; + + die "Watchman: command returned no output.\n" . + "Falling back to scanning...\n" if $response eq ""; + die "Watchman: command returned invalid output: $response\n" . + "Falling back to scanning...\n" unless $response =~ /^\{/; + + return $json_pkg->new->utf8->decode($response); +} + +sub is_work_tree_watched { + my ($output) = @_; + my $error = $output->{error}; + if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) { + $retry--; + my $response = qx/watchman watch "$git_work_tree"/; + die "Failed to make watchman watch '$git_work_tree'.\n" . + "Falling back to scanning...\n" if $? != 0; + $output = $json_pkg->new->utf8->decode($response); + $error = $output->{error}; + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + # Uncomment for debugging watchman output + # open (my $fh, ">", ".git/watchman-output.out"); + # close $fh; + + # Watchman will always return all files on the first query so + # return the fast "everything is dirty" flag to git and do the + # Watchman query just to get it over with now so we won't pay + # the cost in git to look up each individual file. + my $o = watchman_clock(); + $error = $output->{error}; + + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + output_result($o->{clock}, ("/")); + $last_update_token = $o->{clock}; + + eval { launch_watchman() }; + return 0; + } + + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + return 1; +} + +sub get_working_dir { + my $working_dir; + if ($^O =~ 'msys' || $^O =~ 'cygwin') { + $working_dir = Win32::GetCwd(); + $working_dir =~ tr/\\/\//; + } else { + require Cwd; + $working_dir = Cwd::cwd(); + } + + return $working_dir; +} diff --git a/factory/.context/e2e-remote.git/hooks/post-update.sample b/factory/.context/e2e-remote.git/hooks/post-update.sample new file mode 100755 index 0000000..ec17ec1 --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/post-update.sample @@ -0,0 +1,8 @@ +#!/bin/sh +# +# An example hook script to prepare a packed repository for use over +# dumb transports. +# +# To enable this hook, rename this file to "post-update". + +exec git update-server-info diff --git a/factory/.context/e2e-remote.git/hooks/pre-applypatch.sample b/factory/.context/e2e-remote.git/hooks/pre-applypatch.sample new file mode 100755 index 0000000..4142082 --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/pre-applypatch.sample @@ -0,0 +1,14 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed +# by applypatch from an e-mail message. +# +# The hook should exit with non-zero status after issuing an +# appropriate message if it wants to stop the commit. +# +# To enable this hook, rename this file to "pre-applypatch". + +. git-sh-setup +precommit="$(git rev-parse --git-path hooks/pre-commit)" +test -x "$precommit" && exec "$precommit" ${1+"$@"} +: diff --git a/factory/.context/e2e-remote.git/hooks/pre-commit.sample b/factory/.context/e2e-remote.git/hooks/pre-commit.sample new file mode 100755 index 0000000..29ed5ee --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/pre-commit.sample @@ -0,0 +1,49 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed. +# Called by "git commit" with no arguments. The hook should +# exit with non-zero status after issuing an appropriate message if +# it wants to stop the commit. +# +# To enable this hook, rename this file to "pre-commit". + +if git rev-parse --verify HEAD >/dev/null 2>&1 +then + against=HEAD +else + # Initial commit: diff against an empty tree object + against=$(git hash-object -t tree /dev/null) +fi + +# If you want to allow non-ASCII filenames set this variable to true. +allownonascii=$(git config --type=bool hooks.allownonascii) + +# Redirect output to stderr. +exec 1>&2 + +# Cross platform projects tend to avoid non-ASCII filenames; prevent +# them from being added to the repository. We exploit the fact that the +# printable range starts at the space character and ends with tilde. +if [ "$allownonascii" != "true" ] && + # Note that the use of brackets around a tr range is ok here, (it's + # even required, for portability to Solaris 10's /usr/bin/tr), since + # the square bracket bytes happen to fall in the designated range. + test $(git diff-index --cached --name-only --diff-filter=A -z $against | + LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0 +then + cat <<\EOF +Error: Attempt to add a non-ASCII file name. + +This can cause problems if you want to work with people on other platforms. + +To be portable it is advisable to rename the file. + +If you know what you are doing you can disable this check using: + + git config hooks.allownonascii true +EOF + exit 1 +fi + +# If there are whitespace errors, print the offending file names and fail. +exec git diff-index --check --cached $against -- diff --git a/factory/.context/e2e-remote.git/hooks/pre-merge-commit.sample b/factory/.context/e2e-remote.git/hooks/pre-merge-commit.sample new file mode 100755 index 0000000..399eab1 --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/pre-merge-commit.sample @@ -0,0 +1,13 @@ +#!/bin/sh +# +# An example hook script to verify what is about to be committed. +# Called by "git merge" with no arguments. The hook should +# exit with non-zero status after issuing an appropriate message to +# stderr if it wants to stop the merge commit. +# +# To enable this hook, rename this file to "pre-merge-commit". + +. git-sh-setup +test -x "$GIT_DIR/hooks/pre-commit" && + exec "$GIT_DIR/hooks/pre-commit" +: diff --git a/factory/.context/e2e-remote.git/hooks/pre-push.sample b/factory/.context/e2e-remote.git/hooks/pre-push.sample new file mode 100755 index 0000000..4ce688d --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/pre-push.sample @@ -0,0 +1,53 @@ +#!/bin/sh + +# An example hook script to verify what is about to be pushed. Called by "git +# push" after it has checked the remote status, but before anything has been +# pushed. If this script exits with a non-zero status nothing will be pushed. +# +# This hook is called with the following parameters: +# +# $1 -- Name of the remote to which the push is being done +# $2 -- URL to which the push is being done +# +# If pushing without using a named remote those arguments will be equal. +# +# Information about the commits which are being pushed is supplied as lines to +# the standard input in the form: +# +# +# +# This sample shows how to prevent push of commits where the log message starts +# with "WIP" (work in progress). + +remote="$1" +url="$2" + +zero=$(git hash-object --stdin &2 "Found WIP commit in $local_ref, not pushing" + exit 1 + fi + fi +done + +exit 0 diff --git a/factory/.context/e2e-remote.git/hooks/pre-rebase.sample b/factory/.context/e2e-remote.git/hooks/pre-rebase.sample new file mode 100755 index 0000000..6cbef5c --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/pre-rebase.sample @@ -0,0 +1,169 @@ +#!/bin/sh +# +# Copyright (c) 2006, 2008 Junio C Hamano +# +# The "pre-rebase" hook is run just before "git rebase" starts doing +# its job, and can prevent the command from running by exiting with +# non-zero status. +# +# The hook is called with the following parameters: +# +# $1 -- the upstream the series was forked from. +# $2 -- the branch being rebased (or empty when rebasing the current branch). +# +# This sample shows how to prevent topic branches that are already +# merged to 'next' branch from getting rebased, because allowing it +# would result in rebasing already published history. + +publish=next +basebranch="$1" +if test "$#" = 2 +then + topic="refs/heads/$2" +else + topic=`git symbolic-ref HEAD` || + exit 0 ;# we do not interrupt rebasing detached HEAD +fi + +case "$topic" in +refs/heads/??/*) + ;; +*) + exit 0 ;# we do not interrupt others. + ;; +esac + +# Now we are dealing with a topic branch being rebased +# on top of master. Is it OK to rebase it? + +# Does the topic really exist? +git show-ref -q "$topic" || { + echo >&2 "No such branch $topic" + exit 1 +} + +# Is topic fully merged to master? +not_in_master=`git rev-list --pretty=oneline ^master "$topic"` +if test -z "$not_in_master" +then + echo >&2 "$topic is fully merged to master; better remove it." + exit 1 ;# we could allow it, but there is no point. +fi + +# Is topic ever merged to next? If so you should not be rebasing it. +only_next_1=`git rev-list ^master "^$topic" ${publish} | sort` +only_next_2=`git rev-list ^master ${publish} | sort` +if test "$only_next_1" = "$only_next_2" +then + not_in_topic=`git rev-list "^$topic" master` + if test -z "$not_in_topic" + then + echo >&2 "$topic is already up to date with master" + exit 1 ;# we could allow it, but there is no point. + else + exit 0 + fi +else + not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"` + /usr/bin/perl -e ' + my $topic = $ARGV[0]; + my $msg = "* $topic has commits already merged to public branch:\n"; + my (%not_in_next) = map { + /^([0-9a-f]+) /; + ($1 => 1); + } split(/\n/, $ARGV[1]); + for my $elem (map { + /^([0-9a-f]+) (.*)$/; + [$1 => $2]; + } split(/\n/, $ARGV[2])) { + if (!exists $not_in_next{$elem->[0]}) { + if ($msg) { + print STDERR $msg; + undef $msg; + } + print STDERR " $elem->[1]\n"; + } + } + ' "$topic" "$not_in_next" "$not_in_master" + exit 1 +fi + +<<\DOC_END + +This sample hook safeguards topic branches that have been +published from being rewound. + +The workflow assumed here is: + + * Once a topic branch forks from "master", "master" is never + merged into it again (either directly or indirectly). + + * Once a topic branch is fully cooked and merged into "master", + it is deleted. If you need to build on top of it to correct + earlier mistakes, a new topic branch is created by forking at + the tip of the "master". This is not strictly necessary, but + it makes it easier to keep your history simple. + + * Whenever you need to test or publish your changes to topic + branches, merge them into "next" branch. + +The script, being an example, hardcodes the publish branch name +to be "next", but it is trivial to make it configurable via +$GIT_DIR/config mechanism. + +With this workflow, you would want to know: + +(1) ... if a topic branch has ever been merged to "next". Young + topic branches can have stupid mistakes you would rather + clean up before publishing, and things that have not been + merged into other branches can be easily rebased without + affecting other people. But once it is published, you would + not want to rewind it. + +(2) ... if a topic branch has been fully merged to "master". + Then you can delete it. More importantly, you should not + build on top of it -- other people may already want to + change things related to the topic as patches against your + "master", so if you need further changes, it is better to + fork the topic (perhaps with the same name) afresh from the + tip of "master". + +Let's look at this example: + + o---o---o---o---o---o---o---o---o---o "next" + / / / / + / a---a---b A / / + / / / / + / / c---c---c---c B / + / / / \ / + / / / b---b C \ / + / / / / \ / + ---o---o---o---o---o---o---o---o---o---o---o "master" + + +A, B and C are topic branches. + + * A has one fix since it was merged up to "next". + + * B has finished. It has been fully merged up to "master" and "next", + and is ready to be deleted. + + * C has not merged to "next" at all. + +We would want to allow C to be rebased, refuse A, and encourage +B to be deleted. + +To compute (1): + + git rev-list ^master ^topic next + git rev-list ^master next + + if these match, topic has not merged in next at all. + +To compute (2): + + git rev-list master..topic + + if this is empty, it is fully merged to "master". + +DOC_END diff --git a/factory/.context/e2e-remote.git/hooks/pre-receive.sample b/factory/.context/e2e-remote.git/hooks/pre-receive.sample new file mode 100755 index 0000000..a1fd29e --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/pre-receive.sample @@ -0,0 +1,24 @@ +#!/bin/sh +# +# An example hook script to make use of push options. +# The example simply echoes all push options that start with 'echoback=' +# and rejects all pushes when the "reject" push option is used. +# +# To enable this hook, rename this file to "pre-receive". + +if test -n "$GIT_PUSH_OPTION_COUNT" +then + i=0 + while test "$i" -lt "$GIT_PUSH_OPTION_COUNT" + do + eval "value=\$GIT_PUSH_OPTION_$i" + case "$value" in + echoback=*) + echo "echo from the pre-receive-hook: ${value#*=}" >&2 + ;; + reject) + exit 1 + esac + i=$((i + 1)) + done +fi diff --git a/factory/.context/e2e-remote.git/hooks/prepare-commit-msg.sample b/factory/.context/e2e-remote.git/hooks/prepare-commit-msg.sample new file mode 100755 index 0000000..10fa14c --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/prepare-commit-msg.sample @@ -0,0 +1,42 @@ +#!/bin/sh +# +# An example hook script to prepare the commit log message. +# Called by "git commit" with the name of the file that has the +# commit message, followed by the description of the commit +# message's source. The hook's purpose is to edit the commit +# message file. If the hook fails with a non-zero status, +# the commit is aborted. +# +# To enable this hook, rename this file to "prepare-commit-msg". + +# This hook includes three examples. The first one removes the +# "# Please enter the commit message..." help message. +# +# The second includes the output of "git diff --name-status -r" +# into the message, just before the "git status" output. It is +# commented because it doesn't cope with --amend or with squashed +# commits. +# +# The third example adds a Signed-off-by line to the message, that can +# still be edited. This is rarely a good idea. + +COMMIT_MSG_FILE=$1 +COMMIT_SOURCE=$2 +SHA1=$3 + +/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE" + +# case "$COMMIT_SOURCE,$SHA1" in +# ,|template,) +# /usr/bin/perl -i.bak -pe ' +# print "\n" . `git diff --cached --name-status -r` +# if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;; +# *) ;; +# esac + +# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') +# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE" +# if test -z "$COMMIT_SOURCE" +# then +# /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE" +# fi diff --git a/factory/.context/e2e-remote.git/hooks/push-to-checkout.sample b/factory/.context/e2e-remote.git/hooks/push-to-checkout.sample new file mode 100755 index 0000000..af5a0c0 --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/push-to-checkout.sample @@ -0,0 +1,78 @@ +#!/bin/sh + +# An example hook script to update a checked-out tree on a git push. +# +# This hook is invoked by git-receive-pack(1) when it reacts to git +# push and updates reference(s) in its repository, and when the push +# tries to update the branch that is currently checked out and the +# receive.denyCurrentBranch configuration variable is set to +# updateInstead. +# +# By default, such a push is refused if the working tree and the index +# of the remote repository has any difference from the currently +# checked out commit; when both the working tree and the index match +# the current commit, they are updated to match the newly pushed tip +# of the branch. This hook is to be used to override the default +# behaviour; however the code below reimplements the default behaviour +# as a starting point for convenient modification. +# +# The hook receives the commit with which the tip of the current +# branch is going to be updated: +commit=$1 + +# It can exit with a non-zero status to refuse the push (when it does +# so, it must not modify the index or the working tree). +die () { + echo >&2 "$*" + exit 1 +} + +# Or it can make any necessary changes to the working tree and to the +# index to bring them to the desired state when the tip of the current +# branch is updated to the new commit, and exit with a zero status. +# +# For example, the hook can simply run git read-tree -u -m HEAD "$1" +# in order to emulate git fetch that is run in the reverse direction +# with git push, as the two-tree form of git read-tree -u -m is +# essentially the same as git switch or git checkout that switches +# branches while keeping the local changes in the working tree that do +# not interfere with the difference between the branches. + +# The below is a more-or-less exact translation to shell of the C code +# for the default behaviour for git's push-to-checkout hook defined in +# the push_to_deploy() function in builtin/receive-pack.c. +# +# Note that the hook will be executed from the repository directory, +# not from the working tree, so if you want to perform operations on +# the working tree, you will have to adapt your code accordingly, e.g. +# by adding "cd .." or using relative paths. + +if ! git update-index -q --ignore-submodules --refresh +then + die "Up-to-date check failed" +fi + +if ! git diff-files --quiet --ignore-submodules -- +then + die "Working directory has unstaged changes" +fi + +# This is a rough translation of: +# +# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX +if git cat-file -e HEAD 2>/dev/null +then + head=HEAD +else + head=$(git hash-object -t tree --stdin &2 + exit 1 +} + +unset GIT_DIR GIT_WORK_TREE +cd "$worktree" && + +if grep -q "^diff --git " "$1" +then + validate_patch "$1" +else + validate_cover_letter "$1" +fi && + +if test "$GIT_SENDEMAIL_FILE_COUNTER" = "$GIT_SENDEMAIL_FILE_TOTAL" +then + git config --unset-all sendemail.validateWorktree && + trap 'git worktree remove -ff "$worktree"' EXIT && + validate_series +fi diff --git a/factory/.context/e2e-remote.git/hooks/update.sample b/factory/.context/e2e-remote.git/hooks/update.sample new file mode 100755 index 0000000..c4d426b --- /dev/null +++ b/factory/.context/e2e-remote.git/hooks/update.sample @@ -0,0 +1,128 @@ +#!/bin/sh +# +# An example hook script to block unannotated tags from entering. +# Called by "git receive-pack" with arguments: refname sha1-old sha1-new +# +# To enable this hook, rename this file to "update". +# +# Config +# ------ +# hooks.allowunannotated +# This boolean sets whether unannotated tags will be allowed into the +# repository. By default they won't be. +# hooks.allowdeletetag +# This boolean sets whether deleting tags will be allowed in the +# repository. By default they won't be. +# hooks.allowmodifytag +# This boolean sets whether a tag may be modified after creation. By default +# it won't be. +# hooks.allowdeletebranch +# This boolean sets whether deleting branches will be allowed in the +# repository. By default they won't be. +# hooks.denycreatebranch +# This boolean sets whether remotely creating branches will be denied +# in the repository. By default this is allowed. +# + +# --- Command line +refname="$1" +oldrev="$2" +newrev="$3" + +# --- Safety check +if [ -z "$GIT_DIR" ]; then + echo "Don't run this script from the command line." >&2 + echo " (if you want, you could supply GIT_DIR then run" >&2 + echo " $0 )" >&2 + exit 1 +fi + +if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then + echo "usage: $0 " >&2 + exit 1 +fi + +# --- Config +allowunannotated=$(git config --type=bool hooks.allowunannotated) +allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch) +denycreatebranch=$(git config --type=bool hooks.denycreatebranch) +allowdeletetag=$(git config --type=bool hooks.allowdeletetag) +allowmodifytag=$(git config --type=bool hooks.allowmodifytag) + +# check for no description +projectdesc=$(sed -e '1q' "$GIT_DIR/description") +case "$projectdesc" in +"Unnamed repository"* | "") + echo "*** Project description file hasn't been set" >&2 + exit 1 + ;; +esac + +# --- Check types +# if $newrev is 0000...0000, it's a commit to delete a ref. +zero=$(git hash-object --stdin &2 + echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2 + exit 1 + fi + ;; + refs/tags/*,delete) + # delete tag + if [ "$allowdeletetag" != "true" ]; then + echo "*** Deleting a tag is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/tags/*,tag) + # annotated tag + if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1 + then + echo "*** Tag '$refname' already exists." >&2 + echo "*** Modifying a tag is not allowed in this repository." >&2 + exit 1 + fi + ;; + refs/heads/*,commit) + # branch + if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then + echo "*** Creating a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/heads/*,delete) + # delete branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/remotes/*,commit) + # tracking branch + ;; + refs/remotes/*,delete) + # delete tracking branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a tracking branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + *) + # Anything else (is there anything else?) + echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2 + exit 1 + ;; +esac + +# --- Finished +exit 0 diff --git a/factory/.context/e2e-remote.git/info/exclude b/factory/.context/e2e-remote.git/info/exclude new file mode 100644 index 0000000..a5196d1 --- /dev/null +++ b/factory/.context/e2e-remote.git/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/factory/.context/e2e-remote.git/objects/2d/2805be0106da973023879415a3ba82b35018ab b/factory/.context/e2e-remote.git/objects/2d/2805be0106da973023879415a3ba82b35018ab new file mode 100644 index 0000000..b69e821 Binary files /dev/null and b/factory/.context/e2e-remote.git/objects/2d/2805be0106da973023879415a3ba82b35018ab differ diff --git a/factory/.context/e2e-remote.git/objects/50/1a558a953fd8bff7b25db63ba74ee9283a5bdc b/factory/.context/e2e-remote.git/objects/50/1a558a953fd8bff7b25db63ba74ee9283a5bdc new file mode 100644 index 0000000..b494a6b Binary files /dev/null and b/factory/.context/e2e-remote.git/objects/50/1a558a953fd8bff7b25db63ba74ee9283a5bdc differ diff --git a/factory/.context/e2e-remote.git/objects/e3/1de1f3a235fd5e8f97207b8e43cd2aa06a6417 b/factory/.context/e2e-remote.git/objects/e3/1de1f3a235fd5e8f97207b8e43cd2aa06a6417 new file mode 100644 index 0000000..2a61bc7 Binary files /dev/null and b/factory/.context/e2e-remote.git/objects/e3/1de1f3a235fd5e8f97207b8e43cd2aa06a6417 differ diff --git a/factory/.context/e2e-remote.git/refs/heads/e2e/local-smoke b/factory/.context/e2e-remote.git/refs/heads/e2e/local-smoke new file mode 100644 index 0000000..ea65ff2 --- /dev/null +++ b/factory/.context/e2e-remote.git/refs/heads/e2e/local-smoke @@ -0,0 +1 @@ +501a558a953fd8bff7b25db63ba74ee9283a5bdc diff --git a/factory/.context/e2e-remote.git/refs/heads/e2e/wb-mmjt8hbd b/factory/.context/e2e-remote.git/refs/heads/e2e/wb-mmjt8hbd new file mode 100644 index 0000000..ea65ff2 --- /dev/null +++ b/factory/.context/e2e-remote.git/refs/heads/e2e/wb-mmjt8hbd @@ -0,0 +1 @@ +501a558a953fd8bff7b25db63ba74ee9283a5bdc diff --git a/factory/.context/e2e-remote.git/refs/heads/main b/factory/.context/e2e-remote.git/refs/heads/main new file mode 100644 index 0000000..ea65ff2 --- /dev/null +++ b/factory/.context/e2e-remote.git/refs/heads/main @@ -0,0 +1 @@ +501a558a953fd8bff7b25db63ba74ee9283a5bdc diff --git a/factory/.context/e2e-seed b/factory/.context/e2e-seed new file mode 160000 index 0000000..501a558 --- /dev/null +++ b/factory/.context/e2e-seed @@ -0,0 +1 @@ +Subproject commit 501a558a953fd8bff7b25db63ba74ee9283a5bdc diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/006ab308 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/006ab308 new file mode 100644 index 0000000..8af9dfc Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/006ab308 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/00c27eb1 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/00c27eb1 new file mode 100644 index 0000000..e16ac1b Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/00c27eb1 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/02f5ecb5 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/02f5ecb5 new file mode 100644 index 0000000..f9c9724 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/02f5ecb5 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/094e5d4f b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/094e5d4f new file mode 100644 index 0000000..b88e4b6 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/094e5d4f differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0a4b01cf b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0a4b01cf new file mode 100644 index 0000000..1f5a3ad Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0a4b01cf differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0b26d13d b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0b26d13d new file mode 100644 index 0000000..1739500 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0b26d13d differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0c6f242a b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0c6f242a new file mode 100644 index 0000000..ab8e11f Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0c6f242a differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0d8bfbc3 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0d8bfbc3 new file mode 100644 index 0000000..100ca1f Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0d8bfbc3 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0d92255c b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0d92255c new file mode 100644 index 0000000..e8d9d49 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/0d92255c differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/12bfa98c b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/12bfa98c new file mode 100644 index 0000000..a519bf3 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/12bfa98c differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/1304914a b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/1304914a new file mode 100644 index 0000000..b53a1c8 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/1304914a differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/13376909 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/13376909 new file mode 100644 index 0000000..183a7e9 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/13376909 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/13de72ab b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/13de72ab new file mode 100644 index 0000000..17594f2 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/13de72ab differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/1dc31cec b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/1dc31cec new file mode 100644 index 0000000..fa9a43d Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/1dc31cec differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/214b1c61 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/214b1c61 new file mode 100644 index 0000000..d2962b4 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/214b1c61 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/28cd7d24 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/28cd7d24 new file mode 100644 index 0000000..b0e226d Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/28cd7d24 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/2939fc8c b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/2939fc8c new file mode 100644 index 0000000..0321bee Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/2939fc8c differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/29bbac62 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/29bbac62 new file mode 100644 index 0000000..afcf6d8 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/29bbac62 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/2aef9381 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/2aef9381 new file mode 100644 index 0000000..945d7a9 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/2aef9381 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/2d522d35 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/2d522d35 new file mode 100644 index 0000000..cbc5643 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/2d522d35 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/36a44d7a b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/36a44d7a new file mode 100644 index 0000000..32269a9 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/36a44d7a differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/3965806b b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/3965806b new file mode 100644 index 0000000..8b2b540 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/3965806b differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/3b0ae579 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/3b0ae579 new file mode 100644 index 0000000..9a77734 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/3b0ae579 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4063c055 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4063c055 new file mode 100644 index 0000000..367157b Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4063c055 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/41869999 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/41869999 new file mode 100644 index 0000000..8fb9b36 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/41869999 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/448562ce b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/448562ce new file mode 100644 index 0000000..2931742 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/448562ce differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/44ad961a b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/44ad961a new file mode 100644 index 0000000..0c616df Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/44ad961a differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/453ede65 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/453ede65 new file mode 100644 index 0000000..68c05a7 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/453ede65 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/470d45df b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/470d45df new file mode 100644 index 0000000..2630513 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/470d45df differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4836988b b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4836988b new file mode 100644 index 0000000..a211e9e Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4836988b differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4857ba95 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4857ba95 new file mode 100644 index 0000000..fca11be Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4857ba95 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4b9353d7 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4b9353d7 new file mode 100644 index 0000000..327fe45 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4b9353d7 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4dadd610 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4dadd610 new file mode 100644 index 0000000..e5bef38 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4dadd610 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4dd619e0 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4dd619e0 new file mode 100644 index 0000000..00ac4ce Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/4dd619e0 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5017de43 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5017de43 new file mode 100644 index 0000000..cf3095c Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5017de43 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/512f33e8 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/512f33e8 new file mode 100644 index 0000000..e16ec51 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/512f33e8 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5141b680 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5141b680 new file mode 100644 index 0000000..c07ca9f Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5141b680 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/518ae1ce b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/518ae1ce new file mode 100644 index 0000000..acaab94 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/518ae1ce differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/550abaf5 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/550abaf5 new file mode 100644 index 0000000..16ba186 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/550abaf5 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5c060858 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5c060858 new file mode 100644 index 0000000..709f5fc Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5c060858 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5d495090 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5d495090 new file mode 100644 index 0000000..92c8427 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5d495090 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5fb6336a b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5fb6336a new file mode 100644 index 0000000..32016f9 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/5fb6336a differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/618fb585 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/618fb585 new file mode 100644 index 0000000..5901dfc Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/618fb585 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/623e8a71 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/623e8a71 new file mode 100644 index 0000000..1ad3220 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/623e8a71 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/64d0f172 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/64d0f172 new file mode 100644 index 0000000..fc60a6a Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/64d0f172 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/670a4bc6 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/670a4bc6 new file mode 100644 index 0000000..9a448fb Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/670a4bc6 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/6877f963 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/6877f963 new file mode 100644 index 0000000..f3bfe49 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/6877f963 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/69597a69 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/69597a69 new file mode 100644 index 0000000..0728f7b Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/69597a69 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/69cf6a4d b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/69cf6a4d new file mode 100644 index 0000000..b1eec1a Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/69cf6a4d differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7334977b b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7334977b new file mode 100644 index 0000000..120bbf4 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7334977b differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/77e80838 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/77e80838 new file mode 100644 index 0000000..2b62326 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/77e80838 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7b4ad26e b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7b4ad26e new file mode 100644 index 0000000..bb7bfe2 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7b4ad26e differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7cfc2061 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7cfc2061 new file mode 100644 index 0000000..90be0fd Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7cfc2061 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7d32fe7c b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7d32fe7c new file mode 100644 index 0000000..21ad2c1 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7d32fe7c differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7e831dbb b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7e831dbb new file mode 100644 index 0000000..dd0e3c8 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7e831dbb differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7f28a193 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7f28a193 new file mode 100644 index 0000000..2a5dc3a Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7f28a193 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7f62d6e2 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7f62d6e2 new file mode 100644 index 0000000..0a8bba6 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/7f62d6e2 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/80a4847b b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/80a4847b new file mode 100644 index 0000000..c73c326 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/80a4847b differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/80f42726 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/80f42726 new file mode 100644 index 0000000..addf7e7 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/80f42726 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/810d1c2d b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/810d1c2d new file mode 100644 index 0000000..a45bbc7 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/810d1c2d differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/82380755 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/82380755 new file mode 100644 index 0000000..fac3950 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/82380755 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/8458ccaa b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/8458ccaa new file mode 100644 index 0000000..0f93eae Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/8458ccaa differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/86fd74ab b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/86fd74ab new file mode 100644 index 0000000..a23e5d3 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/86fd74ab differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/87aa8b8a b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/87aa8b8a new file mode 100644 index 0000000..dc92cbd Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/87aa8b8a differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/8885dd4b b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/8885dd4b new file mode 100644 index 0000000..4fb8ed0 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/8885dd4b differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/88af77d4 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/88af77d4 new file mode 100644 index 0000000..0479b91 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/88af77d4 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/8e276578 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/8e276578 new file mode 100644 index 0000000..cc8885c Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/8e276578 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/95e7e329 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/95e7e329 new file mode 100644 index 0000000..38e79ec Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/95e7e329 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/965f7d89 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/965f7d89 new file mode 100644 index 0000000..cf3b7b4 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/965f7d89 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/96cd3cb3 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/96cd3cb3 new file mode 100644 index 0000000..b6a4522 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/96cd3cb3 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9887bedf b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9887bedf new file mode 100644 index 0000000..bb097ac Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9887bedf differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9b855764 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9b855764 new file mode 100644 index 0000000..4271aff Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9b855764 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9e231cc5 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9e231cc5 new file mode 100644 index 0000000..919d25f Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9e231cc5 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9edd10c8 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9edd10c8 new file mode 100644 index 0000000..46b6c07 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9edd10c8 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9f0e5fec b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9f0e5fec new file mode 100644 index 0000000..3b36e38 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/9f0e5fec differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a00f3274 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a00f3274 new file mode 100644 index 0000000..0837409 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a00f3274 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a0b89922 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a0b89922 new file mode 100644 index 0000000..a5c4628 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a0b89922 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a225b0be b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a225b0be new file mode 100644 index 0000000..a2829a2 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a225b0be differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a48ea035 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a48ea035 new file mode 100644 index 0000000..8861bd7 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a48ea035 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a93ad4c4 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a93ad4c4 new file mode 100644 index 0000000..d4b0b4d Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/a93ad4c4 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ab6f3662 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ab6f3662 new file mode 100644 index 0000000..66c3262 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ab6f3662 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/adb607d4 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/adb607d4 new file mode 100644 index 0000000..b19c41c Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/adb607d4 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/afded14d b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/afded14d new file mode 100644 index 0000000..22e098d Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/afded14d differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/b098a7d8 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/b098a7d8 new file mode 100644 index 0000000..b27dd2a Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/b098a7d8 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/b1e28e08 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/b1e28e08 new file mode 100644 index 0000000..53fb5e3 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/b1e28e08 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/b8f263ed b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/b8f263ed new file mode 100644 index 0000000..08d3897 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/b8f263ed differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/be70eb0d b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/be70eb0d new file mode 100644 index 0000000..430d7c3 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/be70eb0d differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/bf2b9899 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/bf2b9899 new file mode 100644 index 0000000..6983242 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/bf2b9899 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/bfa6eee0 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/bfa6eee0 new file mode 100644 index 0000000..b76e32f Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/bfa6eee0 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/c09ebcad b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/c09ebcad new file mode 100644 index 0000000..d73e801 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/c09ebcad differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/c2ecbb40 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/c2ecbb40 new file mode 100644 index 0000000..40a38b5 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/c2ecbb40 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/c9bd9e68 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/c9bd9e68 new file mode 100644 index 0000000..de2340f Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/c9bd9e68 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ca65dd32 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ca65dd32 new file mode 100644 index 0000000..8bb97d4 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ca65dd32 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ca988750 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ca988750 new file mode 100644 index 0000000..8720a75 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ca988750 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/cc408eff b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/cc408eff new file mode 100644 index 0000000..676508f Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/cc408eff differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/cd61fc58 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/cd61fc58 new file mode 100644 index 0000000..9ae6d09 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/cd61fc58 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/cf75c8a9 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/cf75c8a9 new file mode 100644 index 0000000..16548a2 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/cf75c8a9 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/d0a7a340 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/d0a7a340 new file mode 100644 index 0000000..f236055 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/d0a7a340 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/d53d2de3 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/d53d2de3 new file mode 100644 index 0000000..69fec56 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/d53d2de3 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/d7886cb1 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/d7886cb1 new file mode 100644 index 0000000..89132c6 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/d7886cb1 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/dcf12c22 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/dcf12c22 new file mode 100644 index 0000000..b105d4d Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/dcf12c22 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/de992222 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/de992222 new file mode 100644 index 0000000..5dc5464 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/de992222 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/df2d2969 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/df2d2969 new file mode 100644 index 0000000..4343dd9 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/df2d2969 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/e2156902 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/e2156902 new file mode 100644 index 0000000..c4ab2b5 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/e2156902 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/e43d80dd b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/e43d80dd new file mode 100644 index 0000000..5cff283 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/e43d80dd differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/e60bb1c3 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/e60bb1c3 new file mode 100644 index 0000000..998c1eb Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/e60bb1c3 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/eebe0d50 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/eebe0d50 new file mode 100644 index 0000000..34774d4 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/eebe0d50 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ef2aef94 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ef2aef94 new file mode 100644 index 0000000..6ac9260 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/ef2aef94 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f0d1e4b6 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f0d1e4b6 new file mode 100644 index 0000000..be4e636 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f0d1e4b6 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f0f29950 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f0f29950 new file mode 100644 index 0000000..f06d41a Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f0f29950 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f32a667c b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f32a667c new file mode 100644 index 0000000..16d7ba4 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f32a667c differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f47f34f3 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f47f34f3 new file mode 100644 index 0000000..12636ac Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/f47f34f3 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/fa70fcc8 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/fa70fcc8 new file mode 100644 index 0000000..3fe2d04 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/fa70fcc8 differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/fb565c8e b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/fb565c8e new file mode 100644 index 0000000..b0da732 Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/fb565c8e differ diff --git a/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/fb97d511 b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/fb97d511 new file mode 100644 index 0000000..dbcd44c Binary files /dev/null and b/factory/.context/test-tmp/node-compile-cache/v22.16.0-arm64-9e3ad1fa-501/fb97d511 differ diff --git a/factory/.context/test-tmp/tsx-501/17730-785eb9210737e79a8093a1a6bd8ced57698ce67c b/factory/.context/test-tmp/tsx-501/17730-785eb9210737e79a8093a1a6bd8ced57698ce67c new file mode 100644 index 0000000..e69de29 diff --git a/factory/.context/vite-cache/deps/@react-grab_mcp_client.js b/factory/.context/vite-cache/deps/@react-grab_mcp_client.js new file mode 100644 index 0000000..32f74ea --- /dev/null +++ b/factory/.context/vite-cache/deps/@react-grab_mcp_client.js @@ -0,0 +1,60 @@ +import "./chunk-V4OQ3NZ2.js"; + +// ../../../node_modules/.pnpm/@react-grab+mcp@0.1.27_@types+react@18.3.27_react@19.2.4/node_modules/@react-grab/mcp/dist/client.js +var DEFAULT_MCP_PORT = 4723; +var sendContextToServer = async (contextUrl, content, prompt) => { + await fetch(contextUrl, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ content, prompt }) + }).catch(() => { + }); +}; +var createMcpPlugin = (options = {}) => { + const port = options.port ?? DEFAULT_MCP_PORT; + const contextUrl = `http://localhost:${port}/context`; + return { + name: "mcp", + hooks: { + onCopySuccess: (_elements, content) => { + void sendContextToServer(contextUrl, [content]); + }, + transformAgentContext: async (context) => { + await sendContextToServer(contextUrl, context.content, context.prompt); + return context; + } + } + }; +}; +var isReactGrabApi = (value) => typeof value === "object" && value !== null && "registerPlugin" in value; +var attachMcpPlugin = () => { + if (typeof window === "undefined") return; + const plugin = createMcpPlugin(); + const attach = (api) => { + api.registerPlugin(plugin); + }; + const existingApi = window.__REACT_GRAB__; + if (isReactGrabApi(existingApi)) { + attach(existingApi); + return; + } + window.addEventListener( + "react-grab:init", + (event) => { + if (!(event instanceof CustomEvent)) return; + if (!isReactGrabApi(event.detail)) return; + attach(event.detail); + }, + { once: true } + ); + const apiAfterListener = window.__REACT_GRAB__; + if (isReactGrabApi(apiAfterListener)) { + attach(apiAfterListener); + } +}; +attachMcpPlugin(); +export { + attachMcpPlugin, + createMcpPlugin +}; +//# sourceMappingURL=@react-grab_mcp_client.js.map diff --git a/factory/.context/vite-cache/deps/@react-grab_mcp_client.js.map b/factory/.context/vite-cache/deps/@react-grab_mcp_client.js.map new file mode 100644 index 0000000..bf6c50f --- /dev/null +++ b/factory/.context/vite-cache/deps/@react-grab_mcp_client.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../../../node_modules/.pnpm/@react-grab+mcp@0.1.27_@types+react@18.3.27_react@19.2.4/node_modules/@react-grab/mcp/dist/client.js"], + "sourcesContent": ["// src/constants.ts\nvar DEFAULT_MCP_PORT = 4723;\n\n// src/client.ts\nvar sendContextToServer = async (contextUrl, content, prompt) => {\n await fetch(contextUrl, {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/json\" },\n body: JSON.stringify({ content, prompt })\n }).catch(() => {\n });\n};\nvar createMcpPlugin = (options = {}) => {\n const port = options.port ?? DEFAULT_MCP_PORT;\n const contextUrl = `http://localhost:${port}/context`;\n return {\n name: \"mcp\",\n hooks: {\n onCopySuccess: (_elements, content) => {\n void sendContextToServer(contextUrl, [content]);\n },\n transformAgentContext: async (context) => {\n await sendContextToServer(contextUrl, context.content, context.prompt);\n return context;\n }\n }\n };\n};\nvar isReactGrabApi = (value) => typeof value === \"object\" && value !== null && \"registerPlugin\" in value;\nvar attachMcpPlugin = () => {\n if (typeof window === \"undefined\") return;\n const plugin = createMcpPlugin();\n const attach = (api) => {\n api.registerPlugin(plugin);\n };\n const existingApi = window.__REACT_GRAB__;\n if (isReactGrabApi(existingApi)) {\n attach(existingApi);\n return;\n }\n window.addEventListener(\n \"react-grab:init\",\n (event) => {\n if (!(event instanceof CustomEvent)) return;\n if (!isReactGrabApi(event.detail)) return;\n attach(event.detail);\n },\n { once: true }\n );\n const apiAfterListener = window.__REACT_GRAB__;\n if (isReactGrabApi(apiAfterListener)) {\n attach(apiAfterListener);\n }\n};\nattachMcpPlugin();\n\nexport { attachMcpPlugin, createMcpPlugin };\n"], + "mappings": ";;;AACA,IAAI,mBAAmB;AAGvB,IAAI,sBAAsB,OAAO,YAAY,SAAS,WAAW;AAC/D,QAAM,MAAM,YAAY;AAAA,IACtB,QAAQ;AAAA,IACR,SAAS,EAAE,gBAAgB,mBAAmB;AAAA,IAC9C,MAAM,KAAK,UAAU,EAAE,SAAS,OAAO,CAAC;AAAA,EAC1C,CAAC,EAAE,MAAM,MAAM;AAAA,EACf,CAAC;AACH;AACA,IAAI,kBAAkB,CAAC,UAAU,CAAC,MAAM;AACtC,QAAM,OAAO,QAAQ,QAAQ;AAC7B,QAAM,aAAa,oBAAoB,IAAI;AAC3C,SAAO;AAAA,IACL,MAAM;AAAA,IACN,OAAO;AAAA,MACL,eAAe,CAAC,WAAW,YAAY;AACrC,aAAK,oBAAoB,YAAY,CAAC,OAAO,CAAC;AAAA,MAChD;AAAA,MACA,uBAAuB,OAAO,YAAY;AACxC,cAAM,oBAAoB,YAAY,QAAQ,SAAS,QAAQ,MAAM;AACrE,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AACF;AACA,IAAI,iBAAiB,CAAC,UAAU,OAAO,UAAU,YAAY,UAAU,QAAQ,oBAAoB;AACnG,IAAI,kBAAkB,MAAM;AAC1B,MAAI,OAAO,WAAW,YAAa;AACnC,QAAM,SAAS,gBAAgB;AAC/B,QAAM,SAAS,CAAC,QAAQ;AACtB,QAAI,eAAe,MAAM;AAAA,EAC3B;AACA,QAAM,cAAc,OAAO;AAC3B,MAAI,eAAe,WAAW,GAAG;AAC/B,WAAO,WAAW;AAClB;AAAA,EACF;AACA,SAAO;AAAA,IACL;AAAA,IACA,CAAC,UAAU;AACT,UAAI,EAAE,iBAAiB,aAAc;AACrC,UAAI,CAAC,eAAe,MAAM,MAAM,EAAG;AACnC,aAAO,MAAM,MAAM;AAAA,IACrB;AAAA,IACA,EAAE,MAAM,KAAK;AAAA,EACf;AACA,QAAM,mBAAmB,OAAO;AAChC,MAAI,eAAe,gBAAgB,GAAG;AACpC,WAAO,gBAAgB;AAAA,EACzB;AACF;AACA,gBAAgB;", + "names": [] +} diff --git a/factory/.context/vite-cache/deps/@tanstack_react-query.js b/factory/.context/vite-cache/deps/@tanstack_react-query.js new file mode 100644 index 0000000..fada55c --- /dev/null +++ b/factory/.context/vite-cache/deps/@tanstack_react-query.js @@ -0,0 +1,3668 @@ +import { + require_jsx_runtime +} from "./chunk-L53IR3KW.js"; +import { + require_react +} from "./chunk-776SV3ZX.js"; +import { + __toESM +} from "./chunk-V4OQ3NZ2.js"; + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/subscribable.js +var Subscribable = class { + constructor() { + this.listeners = /* @__PURE__ */ new Set(); + this.subscribe = this.subscribe.bind(this); + } + subscribe(listener) { + this.listeners.add(listener); + this.onSubscribe(); + return () => { + this.listeners.delete(listener); + this.onUnsubscribe(); + }; + } + hasListeners() { + return this.listeners.size > 0; + } + onSubscribe() { + } + onUnsubscribe() { + } +}; + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/timeoutManager.js +var defaultTimeoutProvider = { + // We need the wrapper function syntax below instead of direct references to + // global setTimeout etc. + // + // BAD: `setTimeout: setTimeout` + // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)` + // + // If we use direct references here, then anything that wants to spy on or + // replace the global setTimeout (like tests) won't work since we'll already + // have a hard reference to the original implementation at the time when this + // file was imported. + setTimeout: (callback, delay) => setTimeout(callback, delay), + clearTimeout: (timeoutId) => clearTimeout(timeoutId), + setInterval: (callback, delay) => setInterval(callback, delay), + clearInterval: (intervalId) => clearInterval(intervalId) +}; +var TimeoutManager = class { + // We cannot have TimeoutManager as we must instantiate it with a concrete + // type at app boot; and if we leave that type, then any new timer provider + // would need to support ReturnType, which is infeasible. + // + // We settle for type safety for the TimeoutProvider type, and accept that + // this class is unsafe internally to allow for extension. + #provider = defaultTimeoutProvider; + #providerCalled = false; + setTimeoutProvider(provider) { + if (true) { + if (this.#providerCalled && provider !== this.#provider) { + console.error( + `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`, + { previous: this.#provider, provider } + ); + } + } + this.#provider = provider; + if (true) { + this.#providerCalled = false; + } + } + setTimeout(callback, delay) { + if (true) { + this.#providerCalled = true; + } + return this.#provider.setTimeout(callback, delay); + } + clearTimeout(timeoutId) { + this.#provider.clearTimeout(timeoutId); + } + setInterval(callback, delay) { + if (true) { + this.#providerCalled = true; + } + return this.#provider.setInterval(callback, delay); + } + clearInterval(intervalId) { + this.#provider.clearInterval(intervalId); + } +}; +var timeoutManager = new TimeoutManager(); +function systemSetTimeoutZero(callback) { + setTimeout(callback, 0); +} + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/utils.js +var isServer = typeof window === "undefined" || "Deno" in globalThis; +function noop() { +} +function functionalUpdate(updater, input) { + return typeof updater === "function" ? updater(input) : updater; +} +function isValidTimeout(value) { + return typeof value === "number" && value >= 0 && value !== Infinity; +} +function timeUntilStale(updatedAt, staleTime) { + return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0); +} +function resolveStaleTime(staleTime, query) { + return typeof staleTime === "function" ? staleTime(query) : staleTime; +} +function resolveEnabled(enabled, query) { + return typeof enabled === "function" ? enabled(query) : enabled; +} +function matchQuery(filters, query) { + const { + type = "all", + exact, + fetchStatus, + predicate, + queryKey, + stale + } = filters; + if (queryKey) { + if (exact) { + if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) { + return false; + } + } else if (!partialMatchKey(query.queryKey, queryKey)) { + return false; + } + } + if (type !== "all") { + const isActive = query.isActive(); + if (type === "active" && !isActive) { + return false; + } + if (type === "inactive" && isActive) { + return false; + } + } + if (typeof stale === "boolean" && query.isStale() !== stale) { + return false; + } + if (fetchStatus && fetchStatus !== query.state.fetchStatus) { + return false; + } + if (predicate && !predicate(query)) { + return false; + } + return true; +} +function matchMutation(filters, mutation) { + const { exact, status, predicate, mutationKey } = filters; + if (mutationKey) { + if (!mutation.options.mutationKey) { + return false; + } + if (exact) { + if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) { + return false; + } + } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) { + return false; + } + } + if (status && mutation.state.status !== status) { + return false; + } + if (predicate && !predicate(mutation)) { + return false; + } + return true; +} +function hashQueryKeyByOptions(queryKey, options) { + const hashFn = options?.queryKeyHashFn || hashKey; + return hashFn(queryKey); +} +function hashKey(queryKey) { + return JSON.stringify( + queryKey, + (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => { + result[key] = val[key]; + return result; + }, {}) : val + ); +} +function partialMatchKey(a, b) { + if (a === b) { + return true; + } + if (typeof a !== typeof b) { + return false; + } + if (a && b && typeof a === "object" && typeof b === "object") { + return Object.keys(b).every((key) => partialMatchKey(a[key], b[key])); + } + return false; +} +var hasOwn = Object.prototype.hasOwnProperty; +function replaceEqualDeep(a, b, depth = 0) { + if (a === b) { + return a; + } + if (depth > 500) return b; + const array = isPlainArray(a) && isPlainArray(b); + if (!array && !(isPlainObject(a) && isPlainObject(b))) return b; + const aItems = array ? a : Object.keys(a); + const aSize = aItems.length; + const bItems = array ? b : Object.keys(b); + const bSize = bItems.length; + const copy = array ? new Array(bSize) : {}; + let equalItems = 0; + for (let i = 0; i < bSize; i++) { + const key = array ? i : bItems[i]; + const aItem = a[key]; + const bItem = b[key]; + if (aItem === bItem) { + copy[key] = aItem; + if (array ? i < aSize : hasOwn.call(a, key)) equalItems++; + continue; + } + if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") { + copy[key] = bItem; + continue; + } + const v = replaceEqualDeep(aItem, bItem, depth + 1); + copy[key] = v; + if (v === aItem) equalItems++; + } + return aSize === bSize && equalItems === aSize ? a : copy; +} +function shallowEqualObjects(a, b) { + if (!b || Object.keys(a).length !== Object.keys(b).length) { + return false; + } + for (const key in a) { + if (a[key] !== b[key]) { + return false; + } + } + return true; +} +function isPlainArray(value) { + return Array.isArray(value) && value.length === Object.keys(value).length; +} +function isPlainObject(o) { + if (!hasObjectPrototype(o)) { + return false; + } + const ctor = o.constructor; + if (ctor === void 0) { + return true; + } + const prot = ctor.prototype; + if (!hasObjectPrototype(prot)) { + return false; + } + if (!prot.hasOwnProperty("isPrototypeOf")) { + return false; + } + if (Object.getPrototypeOf(o) !== Object.prototype) { + return false; + } + return true; +} +function hasObjectPrototype(o) { + return Object.prototype.toString.call(o) === "[object Object]"; +} +function sleep(timeout) { + return new Promise((resolve) => { + timeoutManager.setTimeout(resolve, timeout); + }); +} +function replaceData(prevData, data, options) { + if (typeof options.structuralSharing === "function") { + return options.structuralSharing(prevData, data); + } else if (options.structuralSharing !== false) { + if (true) { + try { + return replaceEqualDeep(prevData, data); + } catch (error) { + console.error( + `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}` + ); + throw error; + } + } + return replaceEqualDeep(prevData, data); + } + return data; +} +function keepPreviousData(previousData) { + return previousData; +} +function addToEnd(items, item, max = 0) { + const newItems = [...items, item]; + return max && newItems.length > max ? newItems.slice(1) : newItems; +} +function addToStart(items, item, max = 0) { + const newItems = [item, ...items]; + return max && newItems.length > max ? newItems.slice(0, -1) : newItems; +} +var skipToken = /* @__PURE__ */ Symbol(); +function ensureQueryFn(options, fetchOptions) { + if (true) { + if (options.queryFn === skipToken) { + console.error( + `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'` + ); + } + } + if (!options.queryFn && fetchOptions?.initialPromise) { + return () => fetchOptions.initialPromise; + } + if (!options.queryFn || options.queryFn === skipToken) { + return () => Promise.reject(new Error(`Missing queryFn: '${options.queryHash}'`)); + } + return options.queryFn; +} +function shouldThrowError(throwOnError, params) { + if (typeof throwOnError === "function") { + return throwOnError(...params); + } + return !!throwOnError; +} +function addConsumeAwareSignal(object, getSignal, onCancelled) { + let consumed = false; + let signal; + Object.defineProperty(object, "signal", { + enumerable: true, + get: () => { + signal ??= getSignal(); + if (consumed) { + return signal; + } + consumed = true; + if (signal.aborted) { + onCancelled(); + } else { + signal.addEventListener("abort", onCancelled, { once: true }); + } + return signal; + } + }); + return object; +} + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/focusManager.js +var FocusManager = class extends Subscribable { + #focused; + #cleanup; + #setup; + constructor() { + super(); + this.#setup = (onFocus) => { + if (!isServer && window.addEventListener) { + const listener = () => onFocus(); + window.addEventListener("visibilitychange", listener, false); + return () => { + window.removeEventListener("visibilitychange", listener); + }; + } + return; + }; + } + onSubscribe() { + if (!this.#cleanup) { + this.setEventListener(this.#setup); + } + } + onUnsubscribe() { + if (!this.hasListeners()) { + this.#cleanup?.(); + this.#cleanup = void 0; + } + } + setEventListener(setup) { + this.#setup = setup; + this.#cleanup?.(); + this.#cleanup = setup((focused) => { + if (typeof focused === "boolean") { + this.setFocused(focused); + } else { + this.onFocus(); + } + }); + } + setFocused(focused) { + const changed = this.#focused !== focused; + if (changed) { + this.#focused = focused; + this.onFocus(); + } + } + onFocus() { + const isFocused = this.isFocused(); + this.listeners.forEach((listener) => { + listener(isFocused); + }); + } + isFocused() { + if (typeof this.#focused === "boolean") { + return this.#focused; + } + return globalThis.document?.visibilityState !== "hidden"; + } +}; +var focusManager = new FocusManager(); + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/thenable.js +function pendingThenable() { + let resolve; + let reject; + const thenable = new Promise((_resolve, _reject) => { + resolve = _resolve; + reject = _reject; + }); + thenable.status = "pending"; + thenable.catch(() => { + }); + function finalize(data) { + Object.assign(thenable, data); + delete thenable.resolve; + delete thenable.reject; + } + thenable.resolve = (value) => { + finalize({ + status: "fulfilled", + value + }); + resolve(value); + }; + thenable.reject = (reason) => { + finalize({ + status: "rejected", + reason + }); + reject(reason); + }; + return thenable; +} +function tryResolveSync(promise) { + let data; + promise.then((result) => { + data = result; + return result; + }, noop)?.catch(noop); + if (data !== void 0) { + return { data }; + } + return void 0; +} + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/hydration.js +function defaultTransformerFn(data) { + return data; +} +function dehydrateMutation(mutation) { + return { + mutationKey: mutation.options.mutationKey, + state: mutation.state, + ...mutation.options.scope && { scope: mutation.options.scope }, + ...mutation.meta && { meta: mutation.meta } + }; +} +function dehydrateQuery(query, serializeData, shouldRedactErrors) { + const dehydratePromise = () => { + const promise = query.promise?.then(serializeData).catch((error) => { + if (!shouldRedactErrors(error)) { + return Promise.reject(error); + } + if (true) { + console.error( + `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds` + ); + } + return Promise.reject(new Error("redacted")); + }); + promise?.catch(noop); + return promise; + }; + return { + dehydratedAt: Date.now(), + state: { + ...query.state, + ...query.state.data !== void 0 && { + data: serializeData(query.state.data) + } + }, + queryKey: query.queryKey, + queryHash: query.queryHash, + ...query.state.status === "pending" && { + promise: dehydratePromise() + }, + ...query.meta && { meta: query.meta } + }; +} +function defaultShouldDehydrateMutation(mutation) { + return mutation.state.isPaused; +} +function defaultShouldDehydrateQuery(query) { + return query.state.status === "success"; +} +function defaultShouldRedactErrors(_) { + return true; +} +function dehydrate(client, options = {}) { + const filterMutation = options.shouldDehydrateMutation ?? client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ?? defaultShouldDehydrateMutation; + const mutations = client.getMutationCache().getAll().flatMap( + (mutation) => filterMutation(mutation) ? [dehydrateMutation(mutation)] : [] + ); + const filterQuery = options.shouldDehydrateQuery ?? client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ?? defaultShouldDehydrateQuery; + const shouldRedactErrors = options.shouldRedactErrors ?? client.getDefaultOptions().dehydrate?.shouldRedactErrors ?? defaultShouldRedactErrors; + const serializeData = options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData ?? defaultTransformerFn; + const queries = client.getQueryCache().getAll().flatMap( + (query) => filterQuery(query) ? [dehydrateQuery(query, serializeData, shouldRedactErrors)] : [] + ); + return { mutations, queries }; +} +function hydrate(client, dehydratedState, options) { + if (typeof dehydratedState !== "object" || dehydratedState === null) { + return; + } + const mutationCache = client.getMutationCache(); + const queryCache = client.getQueryCache(); + const deserializeData = options?.defaultOptions?.deserializeData ?? client.getDefaultOptions().hydrate?.deserializeData ?? defaultTransformerFn; + const mutations = dehydratedState.mutations || []; + const queries = dehydratedState.queries || []; + mutations.forEach(({ state, ...mutationOptions2 }) => { + mutationCache.build( + client, + { + ...client.getDefaultOptions().hydrate?.mutations, + ...options?.defaultOptions?.mutations, + ...mutationOptions2 + }, + state + ); + }); + queries.forEach( + ({ queryKey, state, queryHash, meta, promise, dehydratedAt }) => { + const syncData = promise ? tryResolveSync(promise) : void 0; + const rawData = state.data === void 0 ? syncData?.data : state.data; + const data = rawData === void 0 ? rawData : deserializeData(rawData); + let query = queryCache.get(queryHash); + const existingQueryIsPending = query?.state.status === "pending"; + const existingQueryIsFetching = query?.state.fetchStatus === "fetching"; + if (query) { + const hasNewerSyncData = syncData && // We only need this undefined check to handle older dehydration + // payloads that might not have dehydratedAt + dehydratedAt !== void 0 && dehydratedAt > query.state.dataUpdatedAt; + if (state.dataUpdatedAt > query.state.dataUpdatedAt || hasNewerSyncData) { + const { fetchStatus: _ignored, ...serializedState } = state; + query.setState({ + ...serializedState, + data + }); + } + } else { + query = queryCache.build( + client, + { + ...client.getDefaultOptions().hydrate?.queries, + ...options?.defaultOptions?.queries, + queryKey, + queryHash, + meta + }, + // Reset fetch status to idle to avoid + // query being stuck in fetching state upon hydration + { + ...state, + data, + fetchStatus: "idle", + status: data !== void 0 ? "success" : state.status + } + ); + } + if (promise && !existingQueryIsPending && !existingQueryIsFetching && // Only hydrate if dehydration is newer than any existing data, + // this is always true for new queries + (dehydratedAt === void 0 || dehydratedAt > query.state.dataUpdatedAt)) { + query.fetch(void 0, { + // RSC transformed promises are not thenable + initialPromise: Promise.resolve(promise).then(deserializeData) + }).catch(noop); + } + } + ); +} + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/notifyManager.js +var defaultScheduler = systemSetTimeoutZero; +function createNotifyManager() { + let queue = []; + let transactions = 0; + let notifyFn = (callback) => { + callback(); + }; + let batchNotifyFn = (callback) => { + callback(); + }; + let scheduleFn = defaultScheduler; + const schedule = (callback) => { + if (transactions) { + queue.push(callback); + } else { + scheduleFn(() => { + notifyFn(callback); + }); + } + }; + const flush = () => { + const originalQueue = queue; + queue = []; + if (originalQueue.length) { + scheduleFn(() => { + batchNotifyFn(() => { + originalQueue.forEach((callback) => { + notifyFn(callback); + }); + }); + }); + } + }; + return { + batch: (callback) => { + let result; + transactions++; + try { + result = callback(); + } finally { + transactions--; + if (!transactions) { + flush(); + } + } + return result; + }, + /** + * All calls to the wrapped function will be batched. + */ + batchCalls: (callback) => { + return (...args) => { + schedule(() => { + callback(...args); + }); + }; + }, + schedule, + /** + * Use this method to set a custom notify function. + * This can be used to for example wrap notifications with `React.act` while running tests. + */ + setNotifyFunction: (fn) => { + notifyFn = fn; + }, + /** + * Use this method to set a custom function to batch notifications together into a single tick. + * By default React Query will use the batch function provided by ReactDOM or React Native. + */ + setBatchNotifyFunction: (fn) => { + batchNotifyFn = fn; + }, + setScheduler: (fn) => { + scheduleFn = fn; + } + }; +} +var notifyManager = createNotifyManager(); + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/onlineManager.js +var OnlineManager = class extends Subscribable { + #online = true; + #cleanup; + #setup; + constructor() { + super(); + this.#setup = (onOnline) => { + if (!isServer && window.addEventListener) { + const onlineListener = () => onOnline(true); + const offlineListener = () => onOnline(false); + window.addEventListener("online", onlineListener, false); + window.addEventListener("offline", offlineListener, false); + return () => { + window.removeEventListener("online", onlineListener); + window.removeEventListener("offline", offlineListener); + }; + } + return; + }; + } + onSubscribe() { + if (!this.#cleanup) { + this.setEventListener(this.#setup); + } + } + onUnsubscribe() { + if (!this.hasListeners()) { + this.#cleanup?.(); + this.#cleanup = void 0; + } + } + setEventListener(setup) { + this.#setup = setup; + this.#cleanup?.(); + this.#cleanup = setup(this.setOnline.bind(this)); + } + setOnline(online) { + const changed = this.#online !== online; + if (changed) { + this.#online = online; + this.listeners.forEach((listener) => { + listener(online); + }); + } + } + isOnline() { + return this.#online; + } +}; +var onlineManager = new OnlineManager(); + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/retryer.js +function defaultRetryDelay(failureCount) { + return Math.min(1e3 * 2 ** failureCount, 3e4); +} +function canFetch(networkMode) { + return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true; +} +var CancelledError = class extends Error { + constructor(options) { + super("CancelledError"); + this.revert = options?.revert; + this.silent = options?.silent; + } +}; +function isCancelledError(value) { + return value instanceof CancelledError; +} +function createRetryer(config) { + let isRetryCancelled = false; + let failureCount = 0; + let continueFn; + const thenable = pendingThenable(); + const isResolved = () => thenable.status !== "pending"; + const cancel = (cancelOptions) => { + if (!isResolved()) { + const error = new CancelledError(cancelOptions); + reject(error); + config.onCancel?.(error); + } + }; + const cancelRetry = () => { + isRetryCancelled = true; + }; + const continueRetry = () => { + isRetryCancelled = false; + }; + const canContinue = () => focusManager.isFocused() && (config.networkMode === "always" || onlineManager.isOnline()) && config.canRun(); + const canStart = () => canFetch(config.networkMode) && config.canRun(); + const resolve = (value) => { + if (!isResolved()) { + continueFn?.(); + thenable.resolve(value); + } + }; + const reject = (value) => { + if (!isResolved()) { + continueFn?.(); + thenable.reject(value); + } + }; + const pause = () => { + return new Promise((continueResolve) => { + continueFn = (value) => { + if (isResolved() || canContinue()) { + continueResolve(value); + } + }; + config.onPause?.(); + }).then(() => { + continueFn = void 0; + if (!isResolved()) { + config.onContinue?.(); + } + }); + }; + const run = () => { + if (isResolved()) { + return; + } + let promiseOrValue; + const initialPromise = failureCount === 0 ? config.initialPromise : void 0; + try { + promiseOrValue = initialPromise ?? config.fn(); + } catch (error) { + promiseOrValue = Promise.reject(error); + } + Promise.resolve(promiseOrValue).then(resolve).catch((error) => { + if (isResolved()) { + return; + } + const retry = config.retry ?? (isServer ? 0 : 3); + const retryDelay = config.retryDelay ?? defaultRetryDelay; + const delay = typeof retryDelay === "function" ? retryDelay(failureCount, error) : retryDelay; + const shouldRetry = retry === true || typeof retry === "number" && failureCount < retry || typeof retry === "function" && retry(failureCount, error); + if (isRetryCancelled || !shouldRetry) { + reject(error); + return; + } + failureCount++; + config.onFail?.(failureCount, error); + sleep(delay).then(() => { + return canContinue() ? void 0 : pause(); + }).then(() => { + if (isRetryCancelled) { + reject(error); + } else { + run(); + } + }); + }); + }; + return { + promise: thenable, + status: () => thenable.status, + cancel, + continue: () => { + continueFn?.(); + return thenable; + }, + cancelRetry, + continueRetry, + canStart, + start: () => { + if (canStart()) { + run(); + } else { + pause().then(run); + } + return thenable; + } + }; +} + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/removable.js +var Removable = class { + #gcTimeout; + destroy() { + this.clearGcTimeout(); + } + scheduleGc() { + this.clearGcTimeout(); + if (isValidTimeout(this.gcTime)) { + this.#gcTimeout = timeoutManager.setTimeout(() => { + this.optionalRemove(); + }, this.gcTime); + } + } + updateGcTime(newGcTime) { + this.gcTime = Math.max( + this.gcTime || 0, + newGcTime ?? (isServer ? Infinity : 5 * 60 * 1e3) + ); + } + clearGcTimeout() { + if (this.#gcTimeout) { + timeoutManager.clearTimeout(this.#gcTimeout); + this.#gcTimeout = void 0; + } + } +}; + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/query.js +var Query = class extends Removable { + #initialState; + #revertState; + #cache; + #client; + #retryer; + #defaultOptions; + #abortSignalConsumed; + constructor(config) { + super(); + this.#abortSignalConsumed = false; + this.#defaultOptions = config.defaultOptions; + this.setOptions(config.options); + this.observers = []; + this.#client = config.client; + this.#cache = this.#client.getQueryCache(); + this.queryKey = config.queryKey; + this.queryHash = config.queryHash; + this.#initialState = getDefaultState(this.options); + this.state = config.state ?? this.#initialState; + this.scheduleGc(); + } + get meta() { + return this.options.meta; + } + get promise() { + return this.#retryer?.promise; + } + setOptions(options) { + this.options = { ...this.#defaultOptions, ...options }; + this.updateGcTime(this.options.gcTime); + if (this.state && this.state.data === void 0) { + const defaultState = getDefaultState(this.options); + if (defaultState.data !== void 0) { + this.setState( + successState(defaultState.data, defaultState.dataUpdatedAt) + ); + this.#initialState = defaultState; + } + } + } + optionalRemove() { + if (!this.observers.length && this.state.fetchStatus === "idle") { + this.#cache.remove(this); + } + } + setData(newData, options) { + const data = replaceData(this.state.data, newData, this.options); + this.#dispatch({ + data, + type: "success", + dataUpdatedAt: options?.updatedAt, + manual: options?.manual + }); + return data; + } + setState(state, setStateOptions) { + this.#dispatch({ type: "setState", state, setStateOptions }); + } + cancel(options) { + const promise = this.#retryer?.promise; + this.#retryer?.cancel(options); + return promise ? promise.then(noop).catch(noop) : Promise.resolve(); + } + destroy() { + super.destroy(); + this.cancel({ silent: true }); + } + reset() { + this.destroy(); + this.setState(this.#initialState); + } + isActive() { + return this.observers.some( + (observer) => resolveEnabled(observer.options.enabled, this) !== false + ); + } + isDisabled() { + if (this.getObserversCount() > 0) { + return !this.isActive(); + } + return this.options.queryFn === skipToken || this.state.dataUpdateCount + this.state.errorUpdateCount === 0; + } + isStatic() { + if (this.getObserversCount() > 0) { + return this.observers.some( + (observer) => resolveStaleTime(observer.options.staleTime, this) === "static" + ); + } + return false; + } + isStale() { + if (this.getObserversCount() > 0) { + return this.observers.some( + (observer) => observer.getCurrentResult().isStale + ); + } + return this.state.data === void 0 || this.state.isInvalidated; + } + isStaleByTime(staleTime = 0) { + if (this.state.data === void 0) { + return true; + } + if (staleTime === "static") { + return false; + } + if (this.state.isInvalidated) { + return true; + } + return !timeUntilStale(this.state.dataUpdatedAt, staleTime); + } + onFocus() { + const observer = this.observers.find((x) => x.shouldFetchOnWindowFocus()); + observer?.refetch({ cancelRefetch: false }); + this.#retryer?.continue(); + } + onOnline() { + const observer = this.observers.find((x) => x.shouldFetchOnReconnect()); + observer?.refetch({ cancelRefetch: false }); + this.#retryer?.continue(); + } + addObserver(observer) { + if (!this.observers.includes(observer)) { + this.observers.push(observer); + this.clearGcTimeout(); + this.#cache.notify({ type: "observerAdded", query: this, observer }); + } + } + removeObserver(observer) { + if (this.observers.includes(observer)) { + this.observers = this.observers.filter((x) => x !== observer); + if (!this.observers.length) { + if (this.#retryer) { + if (this.#abortSignalConsumed) { + this.#retryer.cancel({ revert: true }); + } else { + this.#retryer.cancelRetry(); + } + } + this.scheduleGc(); + } + this.#cache.notify({ type: "observerRemoved", query: this, observer }); + } + } + getObserversCount() { + return this.observers.length; + } + invalidate() { + if (!this.state.isInvalidated) { + this.#dispatch({ type: "invalidate" }); + } + } + async fetch(options, fetchOptions) { + if (this.state.fetchStatus !== "idle" && // If the promise in the retryer is already rejected, we have to definitely + // re-start the fetch; there is a chance that the query is still in a + // pending state when that happens + this.#retryer?.status() !== "rejected") { + if (this.state.data !== void 0 && fetchOptions?.cancelRefetch) { + this.cancel({ silent: true }); + } else if (this.#retryer) { + this.#retryer.continueRetry(); + return this.#retryer.promise; + } + } + if (options) { + this.setOptions(options); + } + if (!this.options.queryFn) { + const observer = this.observers.find((x) => x.options.queryFn); + if (observer) { + this.setOptions(observer.options); + } + } + if (true) { + if (!Array.isArray(this.options.queryKey)) { + console.error( + `As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']` + ); + } + } + const abortController = new AbortController(); + const addSignalProperty = (object) => { + Object.defineProperty(object, "signal", { + enumerable: true, + get: () => { + this.#abortSignalConsumed = true; + return abortController.signal; + } + }); + }; + const fetchFn = () => { + const queryFn = ensureQueryFn(this.options, fetchOptions); + const createQueryFnContext = () => { + const queryFnContext2 = { + client: this.#client, + queryKey: this.queryKey, + meta: this.meta + }; + addSignalProperty(queryFnContext2); + return queryFnContext2; + }; + const queryFnContext = createQueryFnContext(); + this.#abortSignalConsumed = false; + if (this.options.persister) { + return this.options.persister( + queryFn, + queryFnContext, + this + ); + } + return queryFn(queryFnContext); + }; + const createFetchContext = () => { + const context2 = { + fetchOptions, + options: this.options, + queryKey: this.queryKey, + client: this.#client, + state: this.state, + fetchFn + }; + addSignalProperty(context2); + return context2; + }; + const context = createFetchContext(); + this.options.behavior?.onFetch(context, this); + this.#revertState = this.state; + if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== context.fetchOptions?.meta) { + this.#dispatch({ type: "fetch", meta: context.fetchOptions?.meta }); + } + this.#retryer = createRetryer({ + initialPromise: fetchOptions?.initialPromise, + fn: context.fetchFn, + onCancel: (error) => { + if (error instanceof CancelledError && error.revert) { + this.setState({ + ...this.#revertState, + fetchStatus: "idle" + }); + } + abortController.abort(); + }, + onFail: (failureCount, error) => { + this.#dispatch({ type: "failed", failureCount, error }); + }, + onPause: () => { + this.#dispatch({ type: "pause" }); + }, + onContinue: () => { + this.#dispatch({ type: "continue" }); + }, + retry: context.options.retry, + retryDelay: context.options.retryDelay, + networkMode: context.options.networkMode, + canRun: () => true + }); + try { + const data = await this.#retryer.start(); + if (data === void 0) { + if (true) { + console.error( + `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}` + ); + } + throw new Error(`${this.queryHash} data is undefined`); + } + this.setData(data); + this.#cache.config.onSuccess?.(data, this); + this.#cache.config.onSettled?.( + data, + this.state.error, + this + ); + return data; + } catch (error) { + if (error instanceof CancelledError) { + if (error.silent) { + return this.#retryer.promise; + } else if (error.revert) { + if (this.state.data === void 0) { + throw error; + } + return this.state.data; + } + } + this.#dispatch({ + type: "error", + error + }); + this.#cache.config.onError?.( + error, + this + ); + this.#cache.config.onSettled?.( + this.state.data, + error, + this + ); + throw error; + } finally { + this.scheduleGc(); + } + } + #dispatch(action) { + const reducer = (state) => { + switch (action.type) { + case "failed": + return { + ...state, + fetchFailureCount: action.failureCount, + fetchFailureReason: action.error + }; + case "pause": + return { + ...state, + fetchStatus: "paused" + }; + case "continue": + return { + ...state, + fetchStatus: "fetching" + }; + case "fetch": + return { + ...state, + ...fetchState(state.data, this.options), + fetchMeta: action.meta ?? null + }; + case "success": + const newState = { + ...state, + ...successState(action.data, action.dataUpdatedAt), + dataUpdateCount: state.dataUpdateCount + 1, + ...!action.manual && { + fetchStatus: "idle", + fetchFailureCount: 0, + fetchFailureReason: null + } + }; + this.#revertState = action.manual ? newState : void 0; + return newState; + case "error": + const error = action.error; + return { + ...state, + error, + errorUpdateCount: state.errorUpdateCount + 1, + errorUpdatedAt: Date.now(), + fetchFailureCount: state.fetchFailureCount + 1, + fetchFailureReason: error, + fetchStatus: "idle", + status: "error", + // flag existing data as invalidated if we get a background error + // note that "no data" always means stale so we can set unconditionally here + isInvalidated: true + }; + case "invalidate": + return { + ...state, + isInvalidated: true + }; + case "setState": + return { + ...state, + ...action.state + }; + } + }; + this.state = reducer(this.state); + notifyManager.batch(() => { + this.observers.forEach((observer) => { + observer.onQueryUpdate(); + }); + this.#cache.notify({ query: this, type: "updated", action }); + }); + } +}; +function fetchState(data, options) { + return { + fetchFailureCount: 0, + fetchFailureReason: null, + fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused", + ...data === void 0 && { + error: null, + status: "pending" + } + }; +} +function successState(data, dataUpdatedAt) { + return { + data, + dataUpdatedAt: dataUpdatedAt ?? Date.now(), + error: null, + isInvalidated: false, + status: "success" + }; +} +function getDefaultState(options) { + const data = typeof options.initialData === "function" ? options.initialData() : options.initialData; + const hasData = data !== void 0; + const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0; + return { + data, + dataUpdateCount: 0, + dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0, + error: null, + errorUpdateCount: 0, + errorUpdatedAt: 0, + fetchFailureCount: 0, + fetchFailureReason: null, + fetchMeta: null, + isInvalidated: false, + status: hasData ? "success" : "pending", + fetchStatus: "idle" + }; +} + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/queryObserver.js +var QueryObserver = class extends Subscribable { + constructor(client, options) { + super(); + this.options = options; + this.#client = client; + this.#selectError = null; + this.#currentThenable = pendingThenable(); + this.bindMethods(); + this.setOptions(options); + } + #client; + #currentQuery = void 0; + #currentQueryInitialState = void 0; + #currentResult = void 0; + #currentResultState; + #currentResultOptions; + #currentThenable; + #selectError; + #selectFn; + #selectResult; + // This property keeps track of the last query with defined data. + // It will be used to pass the previous data and query to the placeholder function between renders. + #lastQueryWithDefinedData; + #staleTimeoutId; + #refetchIntervalId; + #currentRefetchInterval; + #trackedProps = /* @__PURE__ */ new Set(); + bindMethods() { + this.refetch = this.refetch.bind(this); + } + onSubscribe() { + if (this.listeners.size === 1) { + this.#currentQuery.addObserver(this); + if (shouldFetchOnMount(this.#currentQuery, this.options)) { + this.#executeFetch(); + } else { + this.updateResult(); + } + this.#updateTimers(); + } + } + onUnsubscribe() { + if (!this.hasListeners()) { + this.destroy(); + } + } + shouldFetchOnReconnect() { + return shouldFetchOn( + this.#currentQuery, + this.options, + this.options.refetchOnReconnect + ); + } + shouldFetchOnWindowFocus() { + return shouldFetchOn( + this.#currentQuery, + this.options, + this.options.refetchOnWindowFocus + ); + } + destroy() { + this.listeners = /* @__PURE__ */ new Set(); + this.#clearStaleTimeout(); + this.#clearRefetchInterval(); + this.#currentQuery.removeObserver(this); + } + setOptions(options) { + const prevOptions = this.options; + const prevQuery = this.#currentQuery; + this.options = this.#client.defaultQueryOptions(options); + if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveEnabled(this.options.enabled, this.#currentQuery) !== "boolean") { + throw new Error( + "Expected enabled to be a boolean or a callback that returns a boolean" + ); + } + this.#updateQuery(); + this.#currentQuery.setOptions(this.options); + if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) { + this.#client.getQueryCache().notify({ + type: "observerOptionsUpdated", + query: this.#currentQuery, + observer: this + }); + } + const mounted = this.hasListeners(); + if (mounted && shouldFetchOptionally( + this.#currentQuery, + prevQuery, + this.options, + prevOptions + )) { + this.#executeFetch(); + } + this.updateResult(); + if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || resolveStaleTime(this.options.staleTime, this.#currentQuery) !== resolveStaleTime(prevOptions.staleTime, this.#currentQuery))) { + this.#updateStaleTimeout(); + } + const nextRefetchInterval = this.#computeRefetchInterval(); + if (mounted && (this.#currentQuery !== prevQuery || resolveEnabled(this.options.enabled, this.#currentQuery) !== resolveEnabled(prevOptions.enabled, this.#currentQuery) || nextRefetchInterval !== this.#currentRefetchInterval)) { + this.#updateRefetchInterval(nextRefetchInterval); + } + } + getOptimisticResult(options) { + const query = this.#client.getQueryCache().build(this.#client, options); + const result = this.createResult(query, options); + if (shouldAssignObserverCurrentProperties(this, result)) { + this.#currentResult = result; + this.#currentResultOptions = this.options; + this.#currentResultState = this.#currentQuery.state; + } + return result; + } + getCurrentResult() { + return this.#currentResult; + } + trackResult(result, onPropTracked) { + return new Proxy(result, { + get: (target, key) => { + this.trackProp(key); + onPropTracked?.(key); + if (key === "promise") { + this.trackProp("data"); + if (!this.options.experimental_prefetchInRender && this.#currentThenable.status === "pending") { + this.#currentThenable.reject( + new Error( + "experimental_prefetchInRender feature flag is not enabled" + ) + ); + } + } + return Reflect.get(target, key); + } + }); + } + trackProp(key) { + this.#trackedProps.add(key); + } + getCurrentQuery() { + return this.#currentQuery; + } + refetch({ ...options } = {}) { + return this.fetch({ + ...options + }); + } + fetchOptimistic(options) { + const defaultedOptions = this.#client.defaultQueryOptions(options); + const query = this.#client.getQueryCache().build(this.#client, defaultedOptions); + return query.fetch().then(() => this.createResult(query, defaultedOptions)); + } + fetch(fetchOptions) { + return this.#executeFetch({ + ...fetchOptions, + cancelRefetch: fetchOptions.cancelRefetch ?? true + }).then(() => { + this.updateResult(); + return this.#currentResult; + }); + } + #executeFetch(fetchOptions) { + this.#updateQuery(); + let promise = this.#currentQuery.fetch( + this.options, + fetchOptions + ); + if (!fetchOptions?.throwOnError) { + promise = promise.catch(noop); + } + return promise; + } + #updateStaleTimeout() { + this.#clearStaleTimeout(); + const staleTime = resolveStaleTime( + this.options.staleTime, + this.#currentQuery + ); + if (isServer || this.#currentResult.isStale || !isValidTimeout(staleTime)) { + return; + } + const time = timeUntilStale(this.#currentResult.dataUpdatedAt, staleTime); + const timeout = time + 1; + this.#staleTimeoutId = timeoutManager.setTimeout(() => { + if (!this.#currentResult.isStale) { + this.updateResult(); + } + }, timeout); + } + #computeRefetchInterval() { + return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(this.#currentQuery) : this.options.refetchInterval) ?? false; + } + #updateRefetchInterval(nextInterval) { + this.#clearRefetchInterval(); + this.#currentRefetchInterval = nextInterval; + if (isServer || resolveEnabled(this.options.enabled, this.#currentQuery) === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) { + return; + } + this.#refetchIntervalId = timeoutManager.setInterval(() => { + if (this.options.refetchIntervalInBackground || focusManager.isFocused()) { + this.#executeFetch(); + } + }, this.#currentRefetchInterval); + } + #updateTimers() { + this.#updateStaleTimeout(); + this.#updateRefetchInterval(this.#computeRefetchInterval()); + } + #clearStaleTimeout() { + if (this.#staleTimeoutId) { + timeoutManager.clearTimeout(this.#staleTimeoutId); + this.#staleTimeoutId = void 0; + } + } + #clearRefetchInterval() { + if (this.#refetchIntervalId) { + timeoutManager.clearInterval(this.#refetchIntervalId); + this.#refetchIntervalId = void 0; + } + } + createResult(query, options) { + const prevQuery = this.#currentQuery; + const prevOptions = this.options; + const prevResult = this.#currentResult; + const prevResultState = this.#currentResultState; + const prevResultOptions = this.#currentResultOptions; + const queryChange = query !== prevQuery; + const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState; + const { state } = query; + let newState = { ...state }; + let isPlaceholderData = false; + let data; + if (options._optimisticResults) { + const mounted = this.hasListeners(); + const fetchOnMount = !mounted && shouldFetchOnMount(query, options); + const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions); + if (fetchOnMount || fetchOptionally) { + newState = { + ...newState, + ...fetchState(state.data, query.options) + }; + } + if (options._optimisticResults === "isRestoring") { + newState.fetchStatus = "idle"; + } + } + let { error, errorUpdatedAt, status } = newState; + data = newState.data; + let skipSelect = false; + if (options.placeholderData !== void 0 && data === void 0 && status === "pending") { + let placeholderData; + if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) { + placeholderData = prevResult.data; + skipSelect = true; + } else { + placeholderData = typeof options.placeholderData === "function" ? options.placeholderData( + this.#lastQueryWithDefinedData?.state.data, + this.#lastQueryWithDefinedData + ) : options.placeholderData; + } + if (placeholderData !== void 0) { + status = "success"; + data = replaceData( + prevResult?.data, + placeholderData, + options + ); + isPlaceholderData = true; + } + } + if (options.select && data !== void 0 && !skipSelect) { + if (prevResult && data === prevResultState?.data && options.select === this.#selectFn) { + data = this.#selectResult; + } else { + try { + this.#selectFn = options.select; + data = options.select(data); + data = replaceData(prevResult?.data, data, options); + this.#selectResult = data; + this.#selectError = null; + } catch (selectError) { + this.#selectError = selectError; + } + } + } + if (this.#selectError) { + error = this.#selectError; + data = this.#selectResult; + errorUpdatedAt = Date.now(); + status = "error"; + } + const isFetching = newState.fetchStatus === "fetching"; + const isPending = status === "pending"; + const isError = status === "error"; + const isLoading = isPending && isFetching; + const hasData = data !== void 0; + const result = { + status, + fetchStatus: newState.fetchStatus, + isPending, + isSuccess: status === "success", + isError, + isInitialLoading: isLoading, + isLoading, + data, + dataUpdatedAt: newState.dataUpdatedAt, + error, + errorUpdatedAt, + failureCount: newState.fetchFailureCount, + failureReason: newState.fetchFailureReason, + errorUpdateCount: newState.errorUpdateCount, + isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0, + isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount, + isFetching, + isRefetching: isFetching && !isPending, + isLoadingError: isError && !hasData, + isPaused: newState.fetchStatus === "paused", + isPlaceholderData, + isRefetchError: isError && hasData, + isStale: isStale(query, options), + refetch: this.refetch, + promise: this.#currentThenable, + isEnabled: resolveEnabled(options.enabled, query) !== false + }; + const nextResult = result; + if (this.options.experimental_prefetchInRender) { + const hasResultData = nextResult.data !== void 0; + const isErrorWithoutData = nextResult.status === "error" && !hasResultData; + const finalizeThenableIfPossible = (thenable) => { + if (isErrorWithoutData) { + thenable.reject(nextResult.error); + } else if (hasResultData) { + thenable.resolve(nextResult.data); + } + }; + const recreateThenable = () => { + const pending = this.#currentThenable = nextResult.promise = pendingThenable(); + finalizeThenableIfPossible(pending); + }; + const prevThenable = this.#currentThenable; + switch (prevThenable.status) { + case "pending": + if (query.queryHash === prevQuery.queryHash) { + finalizeThenableIfPossible(prevThenable); + } + break; + case "fulfilled": + if (isErrorWithoutData || nextResult.data !== prevThenable.value) { + recreateThenable(); + } + break; + case "rejected": + if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) { + recreateThenable(); + } + break; + } + } + return nextResult; + } + updateResult() { + const prevResult = this.#currentResult; + const nextResult = this.createResult(this.#currentQuery, this.options); + this.#currentResultState = this.#currentQuery.state; + this.#currentResultOptions = this.options; + if (this.#currentResultState.data !== void 0) { + this.#lastQueryWithDefinedData = this.#currentQuery; + } + if (shallowEqualObjects(nextResult, prevResult)) { + return; + } + this.#currentResult = nextResult; + const shouldNotifyListeners = () => { + if (!prevResult) { + return true; + } + const { notifyOnChangeProps } = this.options; + const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps; + if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !this.#trackedProps.size) { + return true; + } + const includedProps = new Set( + notifyOnChangePropsValue ?? this.#trackedProps + ); + if (this.options.throwOnError) { + includedProps.add("error"); + } + return Object.keys(this.#currentResult).some((key) => { + const typedKey = key; + const changed = this.#currentResult[typedKey] !== prevResult[typedKey]; + return changed && includedProps.has(typedKey); + }); + }; + this.#notify({ listeners: shouldNotifyListeners() }); + } + #updateQuery() { + const query = this.#client.getQueryCache().build(this.#client, this.options); + if (query === this.#currentQuery) { + return; + } + const prevQuery = this.#currentQuery; + this.#currentQuery = query; + this.#currentQueryInitialState = query.state; + if (this.hasListeners()) { + prevQuery?.removeObserver(this); + query.addObserver(this); + } + } + onQueryUpdate() { + this.updateResult(); + if (this.hasListeners()) { + this.#updateTimers(); + } + } + #notify(notifyOptions) { + notifyManager.batch(() => { + if (notifyOptions.listeners) { + this.listeners.forEach((listener) => { + listener(this.#currentResult); + }); + } + this.#client.getQueryCache().notify({ + query: this.#currentQuery, + type: "observerResultsUpdated" + }); + }); + } +}; +function shouldLoadOnMount(query, options) { + return resolveEnabled(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && options.retryOnMount === false); +} +function shouldFetchOnMount(query, options) { + return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount); +} +function shouldFetchOn(query, options, field) { + if (resolveEnabled(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") { + const value = typeof field === "function" ? field(query) : field; + return value === "always" || value !== false && isStale(query, options); + } + return false; +} +function shouldFetchOptionally(query, prevQuery, options, prevOptions) { + return (query !== prevQuery || resolveEnabled(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options); +} +function isStale(query, options) { + return resolveEnabled(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query)); +} +function shouldAssignObserverCurrentProperties(observer, optimisticResult) { + if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) { + return true; + } + return false; +} + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js +function infiniteQueryBehavior(pages) { + return { + onFetch: (context, query) => { + const options = context.options; + const direction = context.fetchOptions?.meta?.fetchMore?.direction; + const oldPages = context.state.data?.pages || []; + const oldPageParams = context.state.data?.pageParams || []; + let result = { pages: [], pageParams: [] }; + let currentPage = 0; + const fetchFn = async () => { + let cancelled = false; + const addSignalProperty = (object) => { + addConsumeAwareSignal( + object, + () => context.signal, + () => cancelled = true + ); + }; + const queryFn = ensureQueryFn(context.options, context.fetchOptions); + const fetchPage = async (data, param, previous) => { + if (cancelled) { + return Promise.reject(); + } + if (param == null && data.pages.length) { + return Promise.resolve(data); + } + const createQueryFnContext = () => { + const queryFnContext2 = { + client: context.client, + queryKey: context.queryKey, + pageParam: param, + direction: previous ? "backward" : "forward", + meta: context.options.meta + }; + addSignalProperty(queryFnContext2); + return queryFnContext2; + }; + const queryFnContext = createQueryFnContext(); + const page = await queryFn(queryFnContext); + const { maxPages } = context.options; + const addTo = previous ? addToStart : addToEnd; + return { + pages: addTo(data.pages, page, maxPages), + pageParams: addTo(data.pageParams, param, maxPages) + }; + }; + if (direction && oldPages.length) { + const previous = direction === "backward"; + const pageParamFn = previous ? getPreviousPageParam : getNextPageParam; + const oldData = { + pages: oldPages, + pageParams: oldPageParams + }; + const param = pageParamFn(options, oldData); + result = await fetchPage(oldData, param, previous); + } else { + const remainingPages = pages ?? oldPages.length; + do { + const param = currentPage === 0 ? oldPageParams[0] ?? options.initialPageParam : getNextPageParam(options, result); + if (currentPage > 0 && param == null) { + break; + } + result = await fetchPage(result, param); + currentPage++; + } while (currentPage < remainingPages); + } + return result; + }; + if (context.options.persister) { + context.fetchFn = () => { + return context.options.persister?.( + fetchFn, + { + client: context.client, + queryKey: context.queryKey, + meta: context.options.meta, + signal: context.signal + }, + query + ); + }; + } else { + context.fetchFn = fetchFn; + } + } + }; +} +function getNextPageParam(options, { pages, pageParams }) { + const lastIndex = pages.length - 1; + return pages.length > 0 ? options.getNextPageParam( + pages[lastIndex], + pages, + pageParams[lastIndex], + pageParams + ) : void 0; +} +function getPreviousPageParam(options, { pages, pageParams }) { + return pages.length > 0 ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams) : void 0; +} +function hasNextPage(options, data) { + if (!data) return false; + return getNextPageParam(options, data) != null; +} +function hasPreviousPage(options, data) { + if (!data || !options.getPreviousPageParam) return false; + return getPreviousPageParam(options, data) != null; +} + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/infiniteQueryObserver.js +var InfiniteQueryObserver = class extends QueryObserver { + constructor(client, options) { + super(client, options); + } + bindMethods() { + super.bindMethods(); + this.fetchNextPage = this.fetchNextPage.bind(this); + this.fetchPreviousPage = this.fetchPreviousPage.bind(this); + } + setOptions(options) { + super.setOptions({ + ...options, + behavior: infiniteQueryBehavior() + }); + } + getOptimisticResult(options) { + options.behavior = infiniteQueryBehavior(); + return super.getOptimisticResult(options); + } + fetchNextPage(options) { + return this.fetch({ + ...options, + meta: { + fetchMore: { direction: "forward" } + } + }); + } + fetchPreviousPage(options) { + return this.fetch({ + ...options, + meta: { + fetchMore: { direction: "backward" } + } + }); + } + createResult(query, options) { + const { state } = query; + const parentResult = super.createResult(query, options); + const { isFetching, isRefetching, isError, isRefetchError } = parentResult; + const fetchDirection = state.fetchMeta?.fetchMore?.direction; + const isFetchNextPageError = isError && fetchDirection === "forward"; + const isFetchingNextPage = isFetching && fetchDirection === "forward"; + const isFetchPreviousPageError = isError && fetchDirection === "backward"; + const isFetchingPreviousPage = isFetching && fetchDirection === "backward"; + const result = { + ...parentResult, + fetchNextPage: this.fetchNextPage, + fetchPreviousPage: this.fetchPreviousPage, + hasNextPage: hasNextPage(options, state.data), + hasPreviousPage: hasPreviousPage(options, state.data), + isFetchNextPageError, + isFetchingNextPage, + isFetchPreviousPageError, + isFetchingPreviousPage, + isRefetchError: isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError, + isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage + }; + return result; + } +}; + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/mutation.js +var Mutation = class extends Removable { + #client; + #observers; + #mutationCache; + #retryer; + constructor(config) { + super(); + this.#client = config.client; + this.mutationId = config.mutationId; + this.#mutationCache = config.mutationCache; + this.#observers = []; + this.state = config.state || getDefaultState2(); + this.setOptions(config.options); + this.scheduleGc(); + } + setOptions(options) { + this.options = options; + this.updateGcTime(this.options.gcTime); + } + get meta() { + return this.options.meta; + } + addObserver(observer) { + if (!this.#observers.includes(observer)) { + this.#observers.push(observer); + this.clearGcTimeout(); + this.#mutationCache.notify({ + type: "observerAdded", + mutation: this, + observer + }); + } + } + removeObserver(observer) { + this.#observers = this.#observers.filter((x) => x !== observer); + this.scheduleGc(); + this.#mutationCache.notify({ + type: "observerRemoved", + mutation: this, + observer + }); + } + optionalRemove() { + if (!this.#observers.length) { + if (this.state.status === "pending") { + this.scheduleGc(); + } else { + this.#mutationCache.remove(this); + } + } + } + continue() { + return this.#retryer?.continue() ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before + this.execute(this.state.variables); + } + async execute(variables) { + const onContinue = () => { + this.#dispatch({ type: "continue" }); + }; + const mutationFnContext = { + client: this.#client, + meta: this.options.meta, + mutationKey: this.options.mutationKey + }; + this.#retryer = createRetryer({ + fn: () => { + if (!this.options.mutationFn) { + return Promise.reject(new Error("No mutationFn found")); + } + return this.options.mutationFn(variables, mutationFnContext); + }, + onFail: (failureCount, error) => { + this.#dispatch({ type: "failed", failureCount, error }); + }, + onPause: () => { + this.#dispatch({ type: "pause" }); + }, + onContinue, + retry: this.options.retry ?? 0, + retryDelay: this.options.retryDelay, + networkMode: this.options.networkMode, + canRun: () => this.#mutationCache.canRun(this) + }); + const restored = this.state.status === "pending"; + const isPaused = !this.#retryer.canStart(); + try { + if (restored) { + onContinue(); + } else { + this.#dispatch({ type: "pending", variables, isPaused }); + if (this.#mutationCache.config.onMutate) { + await this.#mutationCache.config.onMutate( + variables, + this, + mutationFnContext + ); + } + const context = await this.options.onMutate?.( + variables, + mutationFnContext + ); + if (context !== this.state.context) { + this.#dispatch({ + type: "pending", + context, + variables, + isPaused + }); + } + } + const data = await this.#retryer.start(); + await this.#mutationCache.config.onSuccess?.( + data, + variables, + this.state.context, + this, + mutationFnContext + ); + await this.options.onSuccess?.( + data, + variables, + this.state.context, + mutationFnContext + ); + await this.#mutationCache.config.onSettled?.( + data, + null, + this.state.variables, + this.state.context, + this, + mutationFnContext + ); + await this.options.onSettled?.( + data, + null, + variables, + this.state.context, + mutationFnContext + ); + this.#dispatch({ type: "success", data }); + return data; + } catch (error) { + try { + await this.#mutationCache.config.onError?.( + error, + variables, + this.state.context, + this, + mutationFnContext + ); + } catch (e) { + void Promise.reject(e); + } + try { + await this.options.onError?.( + error, + variables, + this.state.context, + mutationFnContext + ); + } catch (e) { + void Promise.reject(e); + } + try { + await this.#mutationCache.config.onSettled?.( + void 0, + error, + this.state.variables, + this.state.context, + this, + mutationFnContext + ); + } catch (e) { + void Promise.reject(e); + } + try { + await this.options.onSettled?.( + void 0, + error, + variables, + this.state.context, + mutationFnContext + ); + } catch (e) { + void Promise.reject(e); + } + this.#dispatch({ type: "error", error }); + throw error; + } finally { + this.#mutationCache.runNext(this); + } + } + #dispatch(action) { + const reducer = (state) => { + switch (action.type) { + case "failed": + return { + ...state, + failureCount: action.failureCount, + failureReason: action.error + }; + case "pause": + return { + ...state, + isPaused: true + }; + case "continue": + return { + ...state, + isPaused: false + }; + case "pending": + return { + ...state, + context: action.context, + data: void 0, + failureCount: 0, + failureReason: null, + error: null, + isPaused: action.isPaused, + status: "pending", + variables: action.variables, + submittedAt: Date.now() + }; + case "success": + return { + ...state, + data: action.data, + failureCount: 0, + failureReason: null, + error: null, + status: "success", + isPaused: false + }; + case "error": + return { + ...state, + data: void 0, + error: action.error, + failureCount: state.failureCount + 1, + failureReason: action.error, + isPaused: false, + status: "error" + }; + } + }; + this.state = reducer(this.state); + notifyManager.batch(() => { + this.#observers.forEach((observer) => { + observer.onMutationUpdate(action); + }); + this.#mutationCache.notify({ + mutation: this, + type: "updated", + action + }); + }); + } +}; +function getDefaultState2() { + return { + context: void 0, + data: void 0, + error: null, + failureCount: 0, + failureReason: null, + isPaused: false, + status: "idle", + variables: void 0, + submittedAt: 0 + }; +} + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/mutationCache.js +var MutationCache = class extends Subscribable { + constructor(config = {}) { + super(); + this.config = config; + this.#mutations = /* @__PURE__ */ new Set(); + this.#scopes = /* @__PURE__ */ new Map(); + this.#mutationId = 0; + } + #mutations; + #scopes; + #mutationId; + build(client, options, state) { + const mutation = new Mutation({ + client, + mutationCache: this, + mutationId: ++this.#mutationId, + options: client.defaultMutationOptions(options), + state + }); + this.add(mutation); + return mutation; + } + add(mutation) { + this.#mutations.add(mutation); + const scope = scopeFor(mutation); + if (typeof scope === "string") { + const scopedMutations = this.#scopes.get(scope); + if (scopedMutations) { + scopedMutations.push(mutation); + } else { + this.#scopes.set(scope, [mutation]); + } + } + this.notify({ type: "added", mutation }); + } + remove(mutation) { + if (this.#mutations.delete(mutation)) { + const scope = scopeFor(mutation); + if (typeof scope === "string") { + const scopedMutations = this.#scopes.get(scope); + if (scopedMutations) { + if (scopedMutations.length > 1) { + const index = scopedMutations.indexOf(mutation); + if (index !== -1) { + scopedMutations.splice(index, 1); + } + } else if (scopedMutations[0] === mutation) { + this.#scopes.delete(scope); + } + } + } + } + this.notify({ type: "removed", mutation }); + } + canRun(mutation) { + const scope = scopeFor(mutation); + if (typeof scope === "string") { + const mutationsWithSameScope = this.#scopes.get(scope); + const firstPendingMutation = mutationsWithSameScope?.find( + (m) => m.state.status === "pending" + ); + return !firstPendingMutation || firstPendingMutation === mutation; + } else { + return true; + } + } + runNext(mutation) { + const scope = scopeFor(mutation); + if (typeof scope === "string") { + const foundMutation = this.#scopes.get(scope)?.find((m) => m !== mutation && m.state.isPaused); + return foundMutation?.continue() ?? Promise.resolve(); + } else { + return Promise.resolve(); + } + } + clear() { + notifyManager.batch(() => { + this.#mutations.forEach((mutation) => { + this.notify({ type: "removed", mutation }); + }); + this.#mutations.clear(); + this.#scopes.clear(); + }); + } + getAll() { + return Array.from(this.#mutations); + } + find(filters) { + const defaultedFilters = { exact: true, ...filters }; + return this.getAll().find( + (mutation) => matchMutation(defaultedFilters, mutation) + ); + } + findAll(filters = {}) { + return this.getAll().filter((mutation) => matchMutation(filters, mutation)); + } + notify(event) { + notifyManager.batch(() => { + this.listeners.forEach((listener) => { + listener(event); + }); + }); + } + resumePausedMutations() { + const pausedMutations = this.getAll().filter((x) => x.state.isPaused); + return notifyManager.batch( + () => Promise.all( + pausedMutations.map((mutation) => mutation.continue().catch(noop)) + ) + ); + } +}; +function scopeFor(mutation) { + return mutation.options.scope?.id; +} + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/mutationObserver.js +var MutationObserver = class extends Subscribable { + #client; + #currentResult = void 0; + #currentMutation; + #mutateOptions; + constructor(client, options) { + super(); + this.#client = client; + this.setOptions(options); + this.bindMethods(); + this.#updateResult(); + } + bindMethods() { + this.mutate = this.mutate.bind(this); + this.reset = this.reset.bind(this); + } + setOptions(options) { + const prevOptions = this.options; + this.options = this.#client.defaultMutationOptions(options); + if (!shallowEqualObjects(this.options, prevOptions)) { + this.#client.getMutationCache().notify({ + type: "observerOptionsUpdated", + mutation: this.#currentMutation, + observer: this + }); + } + if (prevOptions?.mutationKey && this.options.mutationKey && hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)) { + this.reset(); + } else if (this.#currentMutation?.state.status === "pending") { + this.#currentMutation.setOptions(this.options); + } + } + onUnsubscribe() { + if (!this.hasListeners()) { + this.#currentMutation?.removeObserver(this); + } + } + onMutationUpdate(action) { + this.#updateResult(); + this.#notify(action); + } + getCurrentResult() { + return this.#currentResult; + } + reset() { + this.#currentMutation?.removeObserver(this); + this.#currentMutation = void 0; + this.#updateResult(); + this.#notify(); + } + mutate(variables, options) { + this.#mutateOptions = options; + this.#currentMutation?.removeObserver(this); + this.#currentMutation = this.#client.getMutationCache().build(this.#client, this.options); + this.#currentMutation.addObserver(this); + return this.#currentMutation.execute(variables); + } + #updateResult() { + const state = this.#currentMutation?.state ?? getDefaultState2(); + this.#currentResult = { + ...state, + isPending: state.status === "pending", + isSuccess: state.status === "success", + isError: state.status === "error", + isIdle: state.status === "idle", + mutate: this.mutate, + reset: this.reset + }; + } + #notify(action) { + notifyManager.batch(() => { + if (this.#mutateOptions && this.hasListeners()) { + const variables = this.#currentResult.variables; + const onMutateResult = this.#currentResult.context; + const context = { + client: this.#client, + meta: this.options.meta, + mutationKey: this.options.mutationKey + }; + if (action?.type === "success") { + try { + this.#mutateOptions.onSuccess?.( + action.data, + variables, + onMutateResult, + context + ); + } catch (e) { + void Promise.reject(e); + } + try { + this.#mutateOptions.onSettled?.( + action.data, + null, + variables, + onMutateResult, + context + ); + } catch (e) { + void Promise.reject(e); + } + } else if (action?.type === "error") { + try { + this.#mutateOptions.onError?.( + action.error, + variables, + onMutateResult, + context + ); + } catch (e) { + void Promise.reject(e); + } + try { + this.#mutateOptions.onSettled?.( + void 0, + action.error, + variables, + onMutateResult, + context + ); + } catch (e) { + void Promise.reject(e); + } + } + } + this.listeners.forEach((listener) => { + listener(this.#currentResult); + }); + }); + } +}; + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/queriesObserver.js +function difference(array1, array2) { + const excludeSet = new Set(array2); + return array1.filter((x) => !excludeSet.has(x)); +} +function replaceAt(array, index, value) { + const copy = array.slice(0); + copy[index] = value; + return copy; +} +var QueriesObserver = class extends Subscribable { + #client; + #result; + #queries; + #options; + #observers; + #combinedResult; + #lastCombine; + #lastResult; + #lastQueryHashes; + #observerMatches = []; + constructor(client, queries, options) { + super(); + this.#client = client; + this.#options = options; + this.#queries = []; + this.#observers = []; + this.#result = []; + this.setQueries(queries); + } + onSubscribe() { + if (this.listeners.size === 1) { + this.#observers.forEach((observer) => { + observer.subscribe((result) => { + this.#onUpdate(observer, result); + }); + }); + } + } + onUnsubscribe() { + if (!this.listeners.size) { + this.destroy(); + } + } + destroy() { + this.listeners = /* @__PURE__ */ new Set(); + this.#observers.forEach((observer) => { + observer.destroy(); + }); + } + setQueries(queries, options) { + this.#queries = queries; + this.#options = options; + if (true) { + const queryHashes = queries.map( + (query) => this.#client.defaultQueryOptions(query).queryHash + ); + if (new Set(queryHashes).size !== queryHashes.length) { + console.warn( + "[QueriesObserver]: Duplicate Queries found. This might result in unexpected behavior." + ); + } + } + notifyManager.batch(() => { + const prevObservers = this.#observers; + const newObserverMatches = this.#findMatchingObservers(this.#queries); + newObserverMatches.forEach( + (match) => match.observer.setOptions(match.defaultedQueryOptions) + ); + const newObservers = newObserverMatches.map((match) => match.observer); + const newResult = newObservers.map( + (observer) => observer.getCurrentResult() + ); + const hasLengthChange = prevObservers.length !== newObservers.length; + const hasIndexChange = newObservers.some( + (observer, index) => observer !== prevObservers[index] + ); + const hasStructuralChange = hasLengthChange || hasIndexChange; + const hasResultChange = hasStructuralChange ? true : newResult.some((result, index) => { + const prev = this.#result[index]; + return !prev || !shallowEqualObjects(result, prev); + }); + if (!hasStructuralChange && !hasResultChange) return; + if (hasStructuralChange) { + this.#observerMatches = newObserverMatches; + this.#observers = newObservers; + } + this.#result = newResult; + if (!this.hasListeners()) return; + if (hasStructuralChange) { + difference(prevObservers, newObservers).forEach((observer) => { + observer.destroy(); + }); + difference(newObservers, prevObservers).forEach((observer) => { + observer.subscribe((result) => { + this.#onUpdate(observer, result); + }); + }); + } + this.#notify(); + }); + } + getCurrentResult() { + return this.#result; + } + getQueries() { + return this.#observers.map((observer) => observer.getCurrentQuery()); + } + getObservers() { + return this.#observers; + } + getOptimisticResult(queries, combine) { + const matches = this.#findMatchingObservers(queries); + const result = matches.map( + (match) => match.observer.getOptimisticResult(match.defaultedQueryOptions) + ); + const queryHashes = matches.map( + (match) => match.defaultedQueryOptions.queryHash + ); + return [ + result, + (r) => { + return this.#combineResult(r ?? result, combine, queryHashes); + }, + () => { + return this.#trackResult(result, matches); + } + ]; + } + #trackResult(result, matches) { + return matches.map((match, index) => { + const observerResult = result[index]; + return !match.defaultedQueryOptions.notifyOnChangeProps ? match.observer.trackResult(observerResult, (accessedProp) => { + matches.forEach((m) => { + m.observer.trackProp(accessedProp); + }); + }) : observerResult; + }); + } + #combineResult(input, combine, queryHashes) { + if (combine) { + const lastHashes = this.#lastQueryHashes; + const queryHashesChanged = queryHashes !== void 0 && lastHashes !== void 0 && (lastHashes.length !== queryHashes.length || queryHashes.some((hash, i) => hash !== lastHashes[i])); + if (!this.#combinedResult || this.#result !== this.#lastResult || queryHashesChanged || combine !== this.#lastCombine) { + this.#lastCombine = combine; + this.#lastResult = this.#result; + if (queryHashes !== void 0) { + this.#lastQueryHashes = queryHashes; + } + this.#combinedResult = replaceEqualDeep( + this.#combinedResult, + combine(input) + ); + } + return this.#combinedResult; + } + return input; + } + #findMatchingObservers(queries) { + const prevObserversMap = /* @__PURE__ */ new Map(); + this.#observers.forEach((observer) => { + const key = observer.options.queryHash; + if (!key) return; + const previousObservers = prevObserversMap.get(key); + if (previousObservers) { + previousObservers.push(observer); + } else { + prevObserversMap.set(key, [observer]); + } + }); + const observers = []; + queries.forEach((options) => { + const defaultedOptions = this.#client.defaultQueryOptions(options); + const match = prevObserversMap.get(defaultedOptions.queryHash)?.shift(); + const observer = match ?? new QueryObserver(this.#client, defaultedOptions); + observers.push({ + defaultedQueryOptions: defaultedOptions, + observer + }); + }); + return observers; + } + #onUpdate(observer, result) { + const index = this.#observers.indexOf(observer); + if (index !== -1) { + this.#result = replaceAt(this.#result, index, result); + this.#notify(); + } + } + #notify() { + if (this.hasListeners()) { + const previousResult = this.#combinedResult; + const newTracked = this.#trackResult(this.#result, this.#observerMatches); + const newResult = this.#combineResult(newTracked, this.#options?.combine); + if (previousResult !== newResult) { + notifyManager.batch(() => { + this.listeners.forEach((listener) => { + listener(this.#result); + }); + }); + } + } + } +}; + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/queryCache.js +var QueryCache = class extends Subscribable { + constructor(config = {}) { + super(); + this.config = config; + this.#queries = /* @__PURE__ */ new Map(); + } + #queries; + build(client, options, state) { + const queryKey = options.queryKey; + const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options); + let query = this.get(queryHash); + if (!query) { + query = new Query({ + client, + queryKey, + queryHash, + options: client.defaultQueryOptions(options), + state, + defaultOptions: client.getQueryDefaults(queryKey) + }); + this.add(query); + } + return query; + } + add(query) { + if (!this.#queries.has(query.queryHash)) { + this.#queries.set(query.queryHash, query); + this.notify({ + type: "added", + query + }); + } + } + remove(query) { + const queryInMap = this.#queries.get(query.queryHash); + if (queryInMap) { + query.destroy(); + if (queryInMap === query) { + this.#queries.delete(query.queryHash); + } + this.notify({ type: "removed", query }); + } + } + clear() { + notifyManager.batch(() => { + this.getAll().forEach((query) => { + this.remove(query); + }); + }); + } + get(queryHash) { + return this.#queries.get(queryHash); + } + getAll() { + return [...this.#queries.values()]; + } + find(filters) { + const defaultedFilters = { exact: true, ...filters }; + return this.getAll().find( + (query) => matchQuery(defaultedFilters, query) + ); + } + findAll(filters = {}) { + const queries = this.getAll(); + return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries; + } + notify(event) { + notifyManager.batch(() => { + this.listeners.forEach((listener) => { + listener(event); + }); + }); + } + onFocus() { + notifyManager.batch(() => { + this.getAll().forEach((query) => { + query.onFocus(); + }); + }); + } + onOnline() { + notifyManager.batch(() => { + this.getAll().forEach((query) => { + query.onOnline(); + }); + }); + } +}; + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/queryClient.js +var QueryClient = class { + #queryCache; + #mutationCache; + #defaultOptions; + #queryDefaults; + #mutationDefaults; + #mountCount; + #unsubscribeFocus; + #unsubscribeOnline; + constructor(config = {}) { + this.#queryCache = config.queryCache || new QueryCache(); + this.#mutationCache = config.mutationCache || new MutationCache(); + this.#defaultOptions = config.defaultOptions || {}; + this.#queryDefaults = /* @__PURE__ */ new Map(); + this.#mutationDefaults = /* @__PURE__ */ new Map(); + this.#mountCount = 0; + } + mount() { + this.#mountCount++; + if (this.#mountCount !== 1) return; + this.#unsubscribeFocus = focusManager.subscribe(async (focused) => { + if (focused) { + await this.resumePausedMutations(); + this.#queryCache.onFocus(); + } + }); + this.#unsubscribeOnline = onlineManager.subscribe(async (online) => { + if (online) { + await this.resumePausedMutations(); + this.#queryCache.onOnline(); + } + }); + } + unmount() { + this.#mountCount--; + if (this.#mountCount !== 0) return; + this.#unsubscribeFocus?.(); + this.#unsubscribeFocus = void 0; + this.#unsubscribeOnline?.(); + this.#unsubscribeOnline = void 0; + } + isFetching(filters) { + return this.#queryCache.findAll({ ...filters, fetchStatus: "fetching" }).length; + } + isMutating(filters) { + return this.#mutationCache.findAll({ ...filters, status: "pending" }).length; + } + /** + * Imperative (non-reactive) way to retrieve data for a QueryKey. + * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates. + * + * Hint: Do not use this function inside a component, because it won't receive updates. + * Use `useQuery` to create a `QueryObserver` that subscribes to changes. + */ + getQueryData(queryKey) { + const options = this.defaultQueryOptions({ queryKey }); + return this.#queryCache.get(options.queryHash)?.state.data; + } + ensureQueryData(options) { + const defaultedOptions = this.defaultQueryOptions(options); + const query = this.#queryCache.build(this, defaultedOptions); + const cachedData = query.state.data; + if (cachedData === void 0) { + return this.fetchQuery(options); + } + if (options.revalidateIfStale && query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))) { + void this.prefetchQuery(defaultedOptions); + } + return Promise.resolve(cachedData); + } + getQueriesData(filters) { + return this.#queryCache.findAll(filters).map(({ queryKey, state }) => { + const data = state.data; + return [queryKey, data]; + }); + } + setQueryData(queryKey, updater, options) { + const defaultedOptions = this.defaultQueryOptions({ queryKey }); + const query = this.#queryCache.get( + defaultedOptions.queryHash + ); + const prevData = query?.state.data; + const data = functionalUpdate(updater, prevData); + if (data === void 0) { + return void 0; + } + return this.#queryCache.build(this, defaultedOptions).setData(data, { ...options, manual: true }); + } + setQueriesData(filters, updater, options) { + return notifyManager.batch( + () => this.#queryCache.findAll(filters).map(({ queryKey }) => [ + queryKey, + this.setQueryData(queryKey, updater, options) + ]) + ); + } + getQueryState(queryKey) { + const options = this.defaultQueryOptions({ queryKey }); + return this.#queryCache.get( + options.queryHash + )?.state; + } + removeQueries(filters) { + const queryCache = this.#queryCache; + notifyManager.batch(() => { + queryCache.findAll(filters).forEach((query) => { + queryCache.remove(query); + }); + }); + } + resetQueries(filters, options) { + const queryCache = this.#queryCache; + return notifyManager.batch(() => { + queryCache.findAll(filters).forEach((query) => { + query.reset(); + }); + return this.refetchQueries( + { + type: "active", + ...filters + }, + options + ); + }); + } + cancelQueries(filters, cancelOptions = {}) { + const defaultedCancelOptions = { revert: true, ...cancelOptions }; + const promises = notifyManager.batch( + () => this.#queryCache.findAll(filters).map((query) => query.cancel(defaultedCancelOptions)) + ); + return Promise.all(promises).then(noop).catch(noop); + } + invalidateQueries(filters, options = {}) { + return notifyManager.batch(() => { + this.#queryCache.findAll(filters).forEach((query) => { + query.invalidate(); + }); + if (filters?.refetchType === "none") { + return Promise.resolve(); + } + return this.refetchQueries( + { + ...filters, + type: filters?.refetchType ?? filters?.type ?? "active" + }, + options + ); + }); + } + refetchQueries(filters, options = {}) { + const fetchOptions = { + ...options, + cancelRefetch: options.cancelRefetch ?? true + }; + const promises = notifyManager.batch( + () => this.#queryCache.findAll(filters).filter((query) => !query.isDisabled() && !query.isStatic()).map((query) => { + let promise = query.fetch(void 0, fetchOptions); + if (!fetchOptions.throwOnError) { + promise = promise.catch(noop); + } + return query.state.fetchStatus === "paused" ? Promise.resolve() : promise; + }) + ); + return Promise.all(promises).then(noop); + } + fetchQuery(options) { + const defaultedOptions = this.defaultQueryOptions(options); + if (defaultedOptions.retry === void 0) { + defaultedOptions.retry = false; + } + const query = this.#queryCache.build(this, defaultedOptions); + return query.isStaleByTime( + resolveStaleTime(defaultedOptions.staleTime, query) + ) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data); + } + prefetchQuery(options) { + return this.fetchQuery(options).then(noop).catch(noop); + } + fetchInfiniteQuery(options) { + options.behavior = infiniteQueryBehavior(options.pages); + return this.fetchQuery(options); + } + prefetchInfiniteQuery(options) { + return this.fetchInfiniteQuery(options).then(noop).catch(noop); + } + ensureInfiniteQueryData(options) { + options.behavior = infiniteQueryBehavior(options.pages); + return this.ensureQueryData(options); + } + resumePausedMutations() { + if (onlineManager.isOnline()) { + return this.#mutationCache.resumePausedMutations(); + } + return Promise.resolve(); + } + getQueryCache() { + return this.#queryCache; + } + getMutationCache() { + return this.#mutationCache; + } + getDefaultOptions() { + return this.#defaultOptions; + } + setDefaultOptions(options) { + this.#defaultOptions = options; + } + setQueryDefaults(queryKey, options) { + this.#queryDefaults.set(hashKey(queryKey), { + queryKey, + defaultOptions: options + }); + } + getQueryDefaults(queryKey) { + const defaults = [...this.#queryDefaults.values()]; + const result = {}; + defaults.forEach((queryDefault) => { + if (partialMatchKey(queryKey, queryDefault.queryKey)) { + Object.assign(result, queryDefault.defaultOptions); + } + }); + return result; + } + setMutationDefaults(mutationKey, options) { + this.#mutationDefaults.set(hashKey(mutationKey), { + mutationKey, + defaultOptions: options + }); + } + getMutationDefaults(mutationKey) { + const defaults = [...this.#mutationDefaults.values()]; + const result = {}; + defaults.forEach((queryDefault) => { + if (partialMatchKey(mutationKey, queryDefault.mutationKey)) { + Object.assign(result, queryDefault.defaultOptions); + } + }); + return result; + } + defaultQueryOptions(options) { + if (options._defaulted) { + return options; + } + const defaultedOptions = { + ...this.#defaultOptions.queries, + ...this.getQueryDefaults(options.queryKey), + ...options, + _defaulted: true + }; + if (!defaultedOptions.queryHash) { + defaultedOptions.queryHash = hashQueryKeyByOptions( + defaultedOptions.queryKey, + defaultedOptions + ); + } + if (defaultedOptions.refetchOnReconnect === void 0) { + defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== "always"; + } + if (defaultedOptions.throwOnError === void 0) { + defaultedOptions.throwOnError = !!defaultedOptions.suspense; + } + if (!defaultedOptions.networkMode && defaultedOptions.persister) { + defaultedOptions.networkMode = "offlineFirst"; + } + if (defaultedOptions.queryFn === skipToken) { + defaultedOptions.enabled = false; + } + return defaultedOptions; + } + defaultMutationOptions(options) { + if (options?._defaulted) { + return options; + } + return { + ...this.#defaultOptions.mutations, + ...options?.mutationKey && this.getMutationDefaults(options.mutationKey), + ...options, + _defaulted: true + }; + } + clear() { + this.#queryCache.clear(); + this.#mutationCache.clear(); + } +}; + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/streamedQuery.js +function streamedQuery({ + streamFn, + refetchMode = "reset", + reducer = (items, chunk) => addToEnd(items, chunk), + initialValue = [] +}) { + return async (context) => { + const query = context.client.getQueryCache().find({ queryKey: context.queryKey, exact: true }); + const isRefetch = !!query && query.state.data !== void 0; + if (isRefetch && refetchMode === "reset") { + query.setState({ + status: "pending", + data: void 0, + error: null, + fetchStatus: "fetching" + }); + } + let result = initialValue; + let cancelled = false; + const streamFnContext = addConsumeAwareSignal( + { + client: context.client, + meta: context.meta, + queryKey: context.queryKey, + pageParam: context.pageParam, + direction: context.direction + }, + () => context.signal, + () => cancelled = true + ); + const stream = await streamFn(streamFnContext); + const isReplaceRefetch = isRefetch && refetchMode === "replace"; + for await (const chunk of stream) { + if (cancelled) { + break; + } + if (isReplaceRefetch) { + result = reducer(result, chunk); + } else { + context.client.setQueryData( + context.queryKey, + (prev) => reducer(prev === void 0 ? initialValue : prev, chunk) + ); + } + } + if (isReplaceRefetch && !cancelled) { + context.client.setQueryData(context.queryKey, result); + } + return context.client.getQueryData(context.queryKey) ?? initialValue; + }; +} + +// ../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/build/modern/types.js +var dataTagSymbol = /* @__PURE__ */ Symbol("dataTagSymbol"); +var dataTagErrorSymbol = /* @__PURE__ */ Symbol("dataTagErrorSymbol"); +var unsetMarker = /* @__PURE__ */ Symbol("unsetMarker"); + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useQueries.js +var React5 = __toESM(require_react(), 1); + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js +var React = __toESM(require_react(), 1); +var import_jsx_runtime = __toESM(require_jsx_runtime(), 1); +var QueryClientContext = React.createContext( + void 0 +); +var useQueryClient = (queryClient) => { + const client = React.useContext(QueryClientContext); + if (queryClient) { + return queryClient; + } + if (!client) { + throw new Error("No QueryClient set, use QueryClientProvider to set one"); + } + return client; +}; +var QueryClientProvider = ({ + client, + children +}) => { + React.useEffect(() => { + client.mount(); + return () => { + client.unmount(); + }; + }, [client]); + return (0, import_jsx_runtime.jsx)(QueryClientContext.Provider, { value: client, children }); +}; + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js +var React2 = __toESM(require_react(), 1); +var IsRestoringContext = React2.createContext(false); +var useIsRestoring = () => React2.useContext(IsRestoringContext); +var IsRestoringProvider = IsRestoringContext.Provider; + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js +var React3 = __toESM(require_react(), 1); +var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1); +function createValue() { + let isReset = false; + return { + clearReset: () => { + isReset = false; + }, + reset: () => { + isReset = true; + }, + isReset: () => { + return isReset; + } + }; +} +var QueryErrorResetBoundaryContext = React3.createContext(createValue()); +var useQueryErrorResetBoundary = () => React3.useContext(QueryErrorResetBoundaryContext); +var QueryErrorResetBoundary = ({ + children +}) => { + const [value] = React3.useState(() => createValue()); + return (0, import_jsx_runtime2.jsx)(QueryErrorResetBoundaryContext.Provider, { value, children: typeof children === "function" ? children(value) : children }); +}; + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js +var React4 = __toESM(require_react(), 1); +var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => { + const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError; + if (options.suspense || options.experimental_prefetchInRender || throwOnError) { + if (!errorResetBoundary.isReset()) { + options.retryOnMount = false; + } + } +}; +var useClearResetErrorBoundary = (errorResetBoundary) => { + React4.useEffect(() => { + errorResetBoundary.clearReset(); + }, [errorResetBoundary]); +}; +var getHasError = ({ + result, + errorResetBoundary, + throwOnError, + query, + suspense +}) => { + return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query])); +}; + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/suspense.js +var defaultThrowOnError = (_error, query) => query.state.data === void 0; +var ensureSuspenseTimers = (defaultedOptions) => { + if (defaultedOptions.suspense) { + const MIN_SUSPENSE_TIME_MS = 1e3; + const clamp = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS); + const originalStaleTime = defaultedOptions.staleTime; + defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp(originalStaleTime(...args)) : clamp(originalStaleTime); + if (typeof defaultedOptions.gcTime === "number") { + defaultedOptions.gcTime = Math.max( + defaultedOptions.gcTime, + MIN_SUSPENSE_TIME_MS + ); + } + } +}; +var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring; +var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending; +var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => { + errorResetBoundary.clearReset(); +}); + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useQueries.js +function useQueries({ + queries, + ...options +}, queryClient) { + const client = useQueryClient(queryClient); + const isRestoring = useIsRestoring(); + const errorResetBoundary = useQueryErrorResetBoundary(); + const defaultedQueries = React5.useMemo( + () => queries.map((opts) => { + const defaultedOptions = client.defaultQueryOptions( + opts + ); + defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic"; + return defaultedOptions; + }), + [queries, client, isRestoring] + ); + defaultedQueries.forEach((queryOptions2) => { + ensureSuspenseTimers(queryOptions2); + const query = client.getQueryCache().get(queryOptions2.queryHash); + ensurePreventErrorBoundaryRetry(queryOptions2, errorResetBoundary, query); + }); + useClearResetErrorBoundary(errorResetBoundary); + const [observer] = React5.useState( + () => new QueriesObserver( + client, + defaultedQueries, + options + ) + ); + const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult( + defaultedQueries, + options.combine + ); + const shouldSubscribe = !isRestoring && options.subscribed !== false; + React5.useSyncExternalStore( + React5.useCallback( + (onStoreChange) => shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop, + [observer, shouldSubscribe] + ), + () => observer.getCurrentResult(), + () => observer.getCurrentResult() + ); + React5.useEffect(() => { + observer.setQueries( + defaultedQueries, + options + ); + }, [defaultedQueries, options, observer]); + const shouldAtLeastOneSuspend = optimisticResult.some( + (result, index) => shouldSuspend(defaultedQueries[index], result) + ); + const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => { + const opts = defaultedQueries[index]; + if (opts && shouldSuspend(opts, result)) { + const queryObserver = new QueryObserver(client, opts); + return fetchOptimistic(opts, queryObserver, errorResetBoundary); + } + return []; + }) : []; + if (suspensePromises.length > 0) { + throw Promise.all(suspensePromises); + } + const firstSingleResultWhichShouldThrow = optimisticResult.find( + (result, index) => { + const query = defaultedQueries[index]; + return query && getHasError({ + result, + errorResetBoundary, + throwOnError: query.throwOnError, + query: client.getQueryCache().get(query.queryHash), + suspense: query.suspense + }); + } + ); + if (firstSingleResultWhichShouldThrow?.error) { + throw firstSingleResultWhichShouldThrow.error; + } + return getCombinedResult(trackResult()); +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js +var React6 = __toESM(require_react(), 1); +function useBaseQuery(options, Observer, queryClient) { + if (true) { + if (typeof options !== "object" || Array.isArray(options)) { + throw new Error( + 'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object' + ); + } + } + const isRestoring = useIsRestoring(); + const errorResetBoundary = useQueryErrorResetBoundary(); + const client = useQueryClient(queryClient); + const defaultedOptions = client.defaultQueryOptions(options); + client.getDefaultOptions().queries?._experimental_beforeQuery?.( + defaultedOptions + ); + const query = client.getQueryCache().get(defaultedOptions.queryHash); + if (true) { + if (!defaultedOptions.queryFn) { + console.error( + `[${defaultedOptions.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function` + ); + } + } + defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic"; + ensureSuspenseTimers(defaultedOptions); + ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query); + useClearResetErrorBoundary(errorResetBoundary); + const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash); + const [observer] = React6.useState( + () => new Observer( + client, + defaultedOptions + ) + ); + const result = observer.getOptimisticResult(defaultedOptions); + const shouldSubscribe = !isRestoring && options.subscribed !== false; + React6.useSyncExternalStore( + React6.useCallback( + (onStoreChange) => { + const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop; + observer.updateResult(); + return unsubscribe; + }, + [observer, shouldSubscribe] + ), + () => observer.getCurrentResult(), + () => observer.getCurrentResult() + ); + React6.useEffect(() => { + observer.setOptions(defaultedOptions); + }, [defaultedOptions, observer]); + if (shouldSuspend(defaultedOptions, result)) { + throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary); + } + if (getHasError({ + result, + errorResetBoundary, + throwOnError: defaultedOptions.throwOnError, + query, + suspense: defaultedOptions.suspense + })) { + throw result.error; + } + ; + client.getDefaultOptions().queries?._experimental_afterQuery?.( + defaultedOptions, + result + ); + if (defaultedOptions.experimental_prefetchInRender && !isServer && willFetch(result, isRestoring)) { + const promise = isNewCacheEntry ? ( + // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted + fetchOptimistic(defaultedOptions, observer, errorResetBoundary) + ) : ( + // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in + query?.promise + ); + promise?.catch(noop).finally(() => { + observer.updateResult(); + }); + } + return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result; +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useQuery.js +function useQuery(options, queryClient) { + return useBaseQuery(options, QueryObserver, queryClient); +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useSuspenseQuery.js +function useSuspenseQuery(options, queryClient) { + if (true) { + if (options.queryFn === skipToken) { + console.error("skipToken is not allowed for useSuspenseQuery"); + } + } + return useBaseQuery( + { + ...options, + enabled: true, + suspense: true, + throwOnError: defaultThrowOnError, + placeholderData: void 0 + }, + QueryObserver, + queryClient + ); +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useSuspenseInfiniteQuery.js +function useSuspenseInfiniteQuery(options, queryClient) { + if (true) { + if (options.queryFn === skipToken) { + console.error("skipToken is not allowed for useSuspenseInfiniteQuery"); + } + } + return useBaseQuery( + { + ...options, + enabled: true, + suspense: true, + throwOnError: defaultThrowOnError + }, + InfiniteQueryObserver, + queryClient + ); +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useSuspenseQueries.js +function useSuspenseQueries(options, queryClient) { + return useQueries( + { + ...options, + queries: options.queries.map((query) => { + if (true) { + if (query.queryFn === skipToken) { + console.error("skipToken is not allowed for useSuspenseQueries"); + } + } + return { + ...query, + suspense: true, + throwOnError: defaultThrowOnError, + enabled: true, + placeholderData: void 0 + }; + }) + }, + queryClient + ); +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/usePrefetchQuery.js +function usePrefetchQuery(options, queryClient) { + const client = useQueryClient(queryClient); + if (!client.getQueryState(options.queryKey)) { + client.prefetchQuery(options); + } +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/usePrefetchInfiniteQuery.js +function usePrefetchInfiniteQuery(options, queryClient) { + const client = useQueryClient(queryClient); + if (!client.getQueryState(options.queryKey)) { + client.prefetchInfiniteQuery(options); + } +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/queryOptions.js +function queryOptions(options) { + return options; +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/infiniteQueryOptions.js +function infiniteQueryOptions(options) { + return options; +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/HydrationBoundary.js +var React7 = __toESM(require_react(), 1); +var HydrationBoundary = ({ + children, + options = {}, + state, + queryClient +}) => { + const client = useQueryClient(queryClient); + const optionsRef = React7.useRef(options); + React7.useEffect(() => { + optionsRef.current = options; + }); + const hydrationQueue = React7.useMemo(() => { + if (state) { + if (typeof state !== "object") { + return; + } + const queryCache = client.getQueryCache(); + const queries = state.queries || []; + const newQueries = []; + const existingQueries = []; + for (const dehydratedQuery of queries) { + const existingQuery = queryCache.get(dehydratedQuery.queryHash); + if (!existingQuery) { + newQueries.push(dehydratedQuery); + } else { + const hydrationIsNewer = dehydratedQuery.state.dataUpdatedAt > existingQuery.state.dataUpdatedAt || dehydratedQuery.promise && existingQuery.state.status !== "pending" && existingQuery.state.fetchStatus !== "fetching" && dehydratedQuery.dehydratedAt !== void 0 && dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt; + if (hydrationIsNewer) { + existingQueries.push(dehydratedQuery); + } + } + } + if (newQueries.length > 0) { + hydrate(client, { queries: newQueries }, optionsRef.current); + } + if (existingQueries.length > 0) { + return existingQueries; + } + } + return void 0; + }, [client, state]); + React7.useEffect(() => { + if (hydrationQueue) { + hydrate(client, { queries: hydrationQueue }, optionsRef.current); + } + }, [client, hydrationQueue]); + return children; +}; + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useIsFetching.js +var React8 = __toESM(require_react(), 1); +function useIsFetching(filters, queryClient) { + const client = useQueryClient(queryClient); + const queryCache = client.getQueryCache(); + return React8.useSyncExternalStore( + React8.useCallback( + (onStoreChange) => queryCache.subscribe(notifyManager.batchCalls(onStoreChange)), + [queryCache] + ), + () => client.isFetching(filters), + () => client.isFetching(filters) + ); +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useMutationState.js +var React9 = __toESM(require_react(), 1); +function useIsMutating(filters, queryClient) { + const client = useQueryClient(queryClient); + return useMutationState( + { filters: { ...filters, status: "pending" } }, + client + ).length; +} +function getResult(mutationCache, options) { + return mutationCache.findAll(options.filters).map( + (mutation) => options.select ? options.select(mutation) : mutation.state + ); +} +function useMutationState(options = {}, queryClient) { + const mutationCache = useQueryClient(queryClient).getMutationCache(); + const optionsRef = React9.useRef(options); + const result = React9.useRef(null); + if (result.current === null) { + result.current = getResult(mutationCache, options); + } + React9.useEffect(() => { + optionsRef.current = options; + }); + return React9.useSyncExternalStore( + React9.useCallback( + (onStoreChange) => mutationCache.subscribe(() => { + const nextResult = replaceEqualDeep( + result.current, + getResult(mutationCache, optionsRef.current) + ); + if (result.current !== nextResult) { + result.current = nextResult; + notifyManager.schedule(onStoreChange); + } + }), + [mutationCache] + ), + () => result.current, + () => result.current + ); +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useMutation.js +var React10 = __toESM(require_react(), 1); +function useMutation(options, queryClient) { + const client = useQueryClient(queryClient); + const [observer] = React10.useState( + () => new MutationObserver( + client, + options + ) + ); + React10.useEffect(() => { + observer.setOptions(options); + }, [observer, options]); + const result = React10.useSyncExternalStore( + React10.useCallback( + (onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)), + [observer] + ), + () => observer.getCurrentResult(), + () => observer.getCurrentResult() + ); + const mutate = React10.useCallback( + (variables, mutateOptions) => { + observer.mutate(variables, mutateOptions).catch(noop); + }, + [observer] + ); + if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) { + throw result.error; + } + return { ...result, mutate, mutateAsync: result.mutate }; +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/mutationOptions.js +function mutationOptions(options) { + return options; +} + +// ../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/build/modern/useInfiniteQuery.js +function useInfiniteQuery(options, queryClient) { + return useBaseQuery( + options, + InfiniteQueryObserver, + queryClient + ); +} +export { + CancelledError, + HydrationBoundary, + InfiniteQueryObserver, + IsRestoringProvider, + Mutation, + MutationCache, + MutationObserver, + QueriesObserver, + Query, + QueryCache, + QueryClient, + QueryClientContext, + QueryClientProvider, + QueryErrorResetBoundary, + QueryObserver, + dataTagErrorSymbol, + dataTagSymbol, + defaultScheduler, + defaultShouldDehydrateMutation, + defaultShouldDehydrateQuery, + dehydrate, + streamedQuery as experimental_streamedQuery, + focusManager, + hashKey, + hydrate, + infiniteQueryOptions, + isCancelledError, + isServer, + keepPreviousData, + matchMutation, + matchQuery, + mutationOptions, + noop, + notifyManager, + onlineManager, + partialMatchKey, + queryOptions, + replaceEqualDeep, + shouldThrowError, + skipToken, + timeoutManager, + unsetMarker, + useInfiniteQuery, + useIsFetching, + useIsMutating, + useIsRestoring, + useMutation, + useMutationState, + usePrefetchInfiniteQuery, + usePrefetchQuery, + useQueries, + useQuery, + useQueryClient, + useQueryErrorResetBoundary, + useSuspenseInfiniteQuery, + useSuspenseQueries, + useSuspenseQuery +}; +//# sourceMappingURL=@tanstack_react-query.js.map diff --git a/factory/.context/vite-cache/deps/@tanstack_react-query.js.map b/factory/.context/vite-cache/deps/@tanstack_react-query.js.map new file mode 100644 index 0000000..da30f44 --- /dev/null +++ b/factory/.context/vite-cache/deps/@tanstack_react-query.js.map @@ -0,0 +1,7 @@ +{ + "version": 3, + "sources": ["../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/subscribable.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/timeoutManager.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/utils.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/focusManager.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/thenable.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/hydration.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/notifyManager.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/onlineManager.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/retryer.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/removable.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/query.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/queryObserver.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/infiniteQueryBehavior.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/infiniteQueryObserver.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/mutation.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/mutationCache.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/mutationObserver.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/queriesObserver.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/queryCache.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/queryClient.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/streamedQuery.ts", "../../../../node_modules/.pnpm/@tanstack+query-core@5.90.20/node_modules/@tanstack/query-core/src/types.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/useQueries.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/QueryClientProvider.tsx", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/IsRestoringProvider.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/QueryErrorResetBoundary.tsx", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/errorBoundaryUtils.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/suspense.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/useBaseQuery.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/useQuery.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/useSuspenseQuery.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/useSuspenseInfiniteQuery.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/useSuspenseQueries.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/usePrefetchQuery.tsx", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/usePrefetchInfiniteQuery.tsx", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/queryOptions.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/infiniteQueryOptions.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/HydrationBoundary.tsx", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/useIsFetching.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/useMutationState.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/useMutation.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/mutationOptions.ts", "../../../../node_modules/.pnpm/@tanstack+react-query@5.90.21_react@19.2.4/node_modules/@tanstack/react-query/src/useInfiniteQuery.ts"], + "sourcesContent": ["export class Subscribable {\n protected listeners = new Set()\n\n constructor() {\n this.subscribe = this.subscribe.bind(this)\n }\n\n subscribe(listener: TListener): () => void {\n this.listeners.add(listener)\n\n this.onSubscribe()\n\n return () => {\n this.listeners.delete(listener)\n this.onUnsubscribe()\n }\n }\n\n hasListeners(): boolean {\n return this.listeners.size > 0\n }\n\n protected onSubscribe(): void {\n // Do nothing\n }\n\n protected onUnsubscribe(): void {\n // Do nothing\n }\n}\n", "/**\n * {@link TimeoutManager} does not support passing arguments to the callback.\n *\n * `(_: void)` is the argument type inferred by TypeScript's default typings for\n * `setTimeout(cb, number)`.\n * If we don't accept a single void argument, then\n * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.\n */\nexport type TimeoutCallback = (_: void) => void\n\n/**\n * Wrapping `setTimeout` is awkward from a typing perspective because platform\n * typings may extend the return type of `setTimeout`. For example, NodeJS\n * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be\n * able to return such a type.\n */\nexport type ManagedTimerId = number | { [Symbol.toPrimitive]: () => number }\n\n/**\n * Backend for timer functions.\n */\nexport type TimeoutProvider =\n {\n readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId\n readonly clearTimeout: (timeoutId: TTimerId | undefined) => void\n\n readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId\n readonly clearInterval: (intervalId: TTimerId | undefined) => void\n }\n\nexport const defaultTimeoutProvider: TimeoutProvider<\n ReturnType\n> = {\n // We need the wrapper function syntax below instead of direct references to\n // global setTimeout etc.\n //\n // BAD: `setTimeout: setTimeout`\n // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`\n //\n // If we use direct references here, then anything that wants to spy on or\n // replace the global setTimeout (like tests) won't work since we'll already\n // have a hard reference to the original implementation at the time when this\n // file was imported.\n setTimeout: (callback, delay) => setTimeout(callback, delay),\n clearTimeout: (timeoutId) => clearTimeout(timeoutId),\n\n setInterval: (callback, delay) => setInterval(callback, delay),\n clearInterval: (intervalId) => clearInterval(intervalId),\n}\n\n/**\n * Allows customization of how timeouts are created.\n *\n * @tanstack/query-core makes liberal use of timeouts to implement `staleTime`\n * and `gcTime`. The default TimeoutManager provider uses the platform's global\n * `setTimeout` implementation, which is known to have scalability issues with\n * thousands of timeouts on the event loop.\n *\n * If you hit this limitation, consider providing a custom TimeoutProvider that\n * coalesces timeouts.\n */\nexport class TimeoutManager implements Omit {\n // We cannot have TimeoutManager as we must instantiate it with a concrete\n // type at app boot; and if we leave that type, then any new timer provider\n // would need to support ReturnType, which is infeasible.\n //\n // We settle for type safety for the TimeoutProvider type, and accept that\n // this class is unsafe internally to allow for extension.\n #provider: TimeoutProvider = defaultTimeoutProvider\n #providerCalled = false\n\n setTimeoutProvider(\n provider: TimeoutProvider,\n ): void {\n if (process.env.NODE_ENV !== 'production') {\n if (this.#providerCalled && provider !== this.#provider) {\n // After changing providers, `clearTimeout` will not work as expected for\n // timeouts from the previous provider.\n //\n // Since they may allocate the same timeout ID, clearTimeout may cancel an\n // arbitrary different timeout, or unexpected no-op.\n //\n // We could protect against this by mixing the timeout ID bits\n // deterministically with some per-provider bits.\n //\n // We could internally queue `setTimeout` calls to `TimeoutManager` until\n // some API call to set the initial provider.\n console.error(\n `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,\n { previous: this.#provider, provider },\n )\n }\n }\n\n this.#provider = provider\n if (process.env.NODE_ENV !== 'production') {\n this.#providerCalled = false\n }\n }\n\n setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId {\n if (process.env.NODE_ENV !== 'production') {\n this.#providerCalled = true\n }\n return this.#provider.setTimeout(callback, delay)\n }\n\n clearTimeout(timeoutId: ManagedTimerId | undefined): void {\n this.#provider.clearTimeout(timeoutId)\n }\n\n setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId {\n if (process.env.NODE_ENV !== 'production') {\n this.#providerCalled = true\n }\n return this.#provider.setInterval(callback, delay)\n }\n\n clearInterval(intervalId: ManagedTimerId | undefined): void {\n this.#provider.clearInterval(intervalId)\n }\n}\n\nexport const timeoutManager = new TimeoutManager()\n\n/**\n * In many cases code wants to delay to the next event loop tick; this is not\n * mediated by {@link timeoutManager}.\n *\n * This function is provided to make auditing the `tanstack/query-core` for\n * incorrect use of system `setTimeout` easier.\n */\nexport function systemSetTimeoutZero(callback: TimeoutCallback): void {\n setTimeout(callback, 0)\n}\n", "import { timeoutManager } from './timeoutManager'\nimport type {\n DefaultError,\n Enabled,\n FetchStatus,\n MutationKey,\n MutationStatus,\n QueryFunction,\n QueryKey,\n QueryOptions,\n StaleTime,\n StaleTimeFunction,\n} from './types'\nimport type { Mutation } from './mutation'\nimport type { FetchOptions, Query } from './query'\n\n// TYPES\n\ntype DropLast> = T extends readonly [\n ...infer R,\n unknown,\n]\n ? readonly [...R]\n : never\n\ntype TuplePrefixes> = T extends readonly []\n ? readonly []\n : TuplePrefixes> | T\n\nexport interface QueryFilters {\n /**\n * Filter to active queries, inactive queries or all queries\n */\n type?: QueryTypeFilter\n /**\n * Match query key exactly\n */\n exact?: boolean\n /**\n * Include queries matching this predicate function\n */\n predicate?: (query: Query) => boolean\n /**\n * Include queries matching this query key\n */\n queryKey?: TQueryKey | TuplePrefixes\n /**\n * Include or exclude stale queries\n */\n stale?: boolean\n /**\n * Include queries matching their fetchStatus\n */\n fetchStatus?: FetchStatus\n}\n\nexport interface MutationFilters<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> {\n /**\n * Match mutation key exactly\n */\n exact?: boolean\n /**\n * Include mutations matching this predicate function\n */\n predicate?: (\n mutation: Mutation,\n ) => boolean\n /**\n * Include mutations matching this mutation key\n */\n mutationKey?: TuplePrefixes\n /**\n * Filter by mutation status\n */\n status?: MutationStatus\n}\n\nexport type Updater = TOutput | ((input: TInput) => TOutput)\n\nexport type QueryTypeFilter = 'all' | 'active' | 'inactive'\n\n// UTILS\n\nexport const isServer = typeof window === 'undefined' || 'Deno' in globalThis\n\nexport function noop(): void\nexport function noop(): undefined\nexport function noop() {}\n\nexport function functionalUpdate(\n updater: Updater,\n input: TInput,\n): TOutput {\n return typeof updater === 'function'\n ? (updater as (_: TInput) => TOutput)(input)\n : updater\n}\n\nexport function isValidTimeout(value: unknown): value is number {\n return typeof value === 'number' && value >= 0 && value !== Infinity\n}\n\nexport function timeUntilStale(updatedAt: number, staleTime?: number): number {\n return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0)\n}\n\nexport function resolveStaleTime<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n staleTime:\n | undefined\n | StaleTimeFunction,\n query: Query,\n): StaleTime | undefined {\n return typeof staleTime === 'function' ? staleTime(query) : staleTime\n}\n\nexport function resolveEnabled<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n enabled: undefined | Enabled,\n query: Query,\n): boolean | undefined {\n return typeof enabled === 'function' ? enabled(query) : enabled\n}\n\nexport function matchQuery(\n filters: QueryFilters,\n query: Query,\n): boolean {\n const {\n type = 'all',\n exact,\n fetchStatus,\n predicate,\n queryKey,\n stale,\n } = filters\n\n if (queryKey) {\n if (exact) {\n if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {\n return false\n }\n } else if (!partialMatchKey(query.queryKey, queryKey)) {\n return false\n }\n }\n\n if (type !== 'all') {\n const isActive = query.isActive()\n if (type === 'active' && !isActive) {\n return false\n }\n if (type === 'inactive' && isActive) {\n return false\n }\n }\n\n if (typeof stale === 'boolean' && query.isStale() !== stale) {\n return false\n }\n\n if (fetchStatus && fetchStatus !== query.state.fetchStatus) {\n return false\n }\n\n if (predicate && !predicate(query)) {\n return false\n }\n\n return true\n}\n\nexport function matchMutation(\n filters: MutationFilters,\n mutation: Mutation,\n): boolean {\n const { exact, status, predicate, mutationKey } = filters\n if (mutationKey) {\n if (!mutation.options.mutationKey) {\n return false\n }\n if (exact) {\n if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) {\n return false\n }\n } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {\n return false\n }\n }\n\n if (status && mutation.state.status !== status) {\n return false\n }\n\n if (predicate && !predicate(mutation)) {\n return false\n }\n\n return true\n}\n\nexport function hashQueryKeyByOptions(\n queryKey: TQueryKey,\n options?: Pick, 'queryKeyHashFn'>,\n): string {\n const hashFn = options?.queryKeyHashFn || hashKey\n return hashFn(queryKey)\n}\n\n/**\n * Default query & mutation keys hash function.\n * Hashes the value into a stable hash.\n */\nexport function hashKey(queryKey: QueryKey | MutationKey): string {\n return JSON.stringify(queryKey, (_, val) =>\n isPlainObject(val)\n ? Object.keys(val)\n .sort()\n .reduce((result, key) => {\n result[key] = val[key]\n return result\n }, {} as any)\n : val,\n )\n}\n\n/**\n * Checks if key `b` partially matches with key `a`.\n */\nexport function partialMatchKey(a: QueryKey, b: QueryKey): boolean\nexport function partialMatchKey(a: any, b: any): boolean {\n if (a === b) {\n return true\n }\n\n if (typeof a !== typeof b) {\n return false\n }\n\n if (a && b && typeof a === 'object' && typeof b === 'object') {\n return Object.keys(b).every((key) => partialMatchKey(a[key], b[key]))\n }\n\n return false\n}\n\nconst hasOwn = Object.prototype.hasOwnProperty\n\n/**\n * This function returns `a` if `b` is deeply equal.\n * If not, it will replace any deeply equal children of `b` with those of `a`.\n * This can be used for structural sharing between JSON values for example.\n */\nexport function replaceEqualDeep(a: unknown, b: T, depth?: number): T\nexport function replaceEqualDeep(a: any, b: any, depth = 0): any {\n if (a === b) {\n return a\n }\n\n if (depth > 500) return b\n\n const array = isPlainArray(a) && isPlainArray(b)\n\n if (!array && !(isPlainObject(a) && isPlainObject(b))) return b\n\n const aItems = array ? a : Object.keys(a)\n const aSize = aItems.length\n const bItems = array ? b : Object.keys(b)\n const bSize = bItems.length\n const copy: any = array ? new Array(bSize) : {}\n\n let equalItems = 0\n\n for (let i = 0; i < bSize; i++) {\n const key: any = array ? i : bItems[i]\n const aItem = a[key]\n const bItem = b[key]\n\n if (aItem === bItem) {\n copy[key] = aItem\n if (array ? i < aSize : hasOwn.call(a, key)) equalItems++\n continue\n }\n\n if (\n aItem === null ||\n bItem === null ||\n typeof aItem !== 'object' ||\n typeof bItem !== 'object'\n ) {\n copy[key] = bItem\n continue\n }\n\n const v = replaceEqualDeep(aItem, bItem, depth + 1)\n copy[key] = v\n if (v === aItem) equalItems++\n }\n\n return aSize === bSize && equalItems === aSize ? a : copy\n}\n\n/**\n * Shallow compare objects.\n */\nexport function shallowEqualObjects>(\n a: T,\n b: T | undefined,\n): boolean {\n if (!b || Object.keys(a).length !== Object.keys(b).length) {\n return false\n }\n\n for (const key in a) {\n if (a[key] !== b[key]) {\n return false\n }\n }\n\n return true\n}\n\nexport function isPlainArray(value: unknown): value is Array {\n return Array.isArray(value) && value.length === Object.keys(value).length\n}\n\n// Copied from: https://github.com/jonschlinkert/is-plain-object\nexport function isPlainObject(o: any): o is Record {\n if (!hasObjectPrototype(o)) {\n return false\n }\n\n // If has no constructor\n const ctor = o.constructor\n if (ctor === undefined) {\n return true\n }\n\n // If has modified prototype\n const prot = ctor.prototype\n if (!hasObjectPrototype(prot)) {\n return false\n }\n\n // If constructor does not have an Object-specific method\n if (!prot.hasOwnProperty('isPrototypeOf')) {\n return false\n }\n\n // Handles Objects created by Object.create()\n if (Object.getPrototypeOf(o) !== Object.prototype) {\n return false\n }\n\n // Most likely a plain Object\n return true\n}\n\nfunction hasObjectPrototype(o: any): boolean {\n return Object.prototype.toString.call(o) === '[object Object]'\n}\n\nexport function sleep(timeout: number): Promise {\n return new Promise((resolve) => {\n timeoutManager.setTimeout(resolve, timeout)\n })\n}\n\nexport function replaceData<\n TData,\n TOptions extends QueryOptions,\n>(prevData: TData | undefined, data: TData, options: TOptions): TData {\n if (typeof options.structuralSharing === 'function') {\n return options.structuralSharing(prevData, data) as TData\n } else if (options.structuralSharing !== false) {\n if (process.env.NODE_ENV !== 'production') {\n try {\n return replaceEqualDeep(prevData, data)\n } catch (error) {\n console.error(\n `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}`,\n )\n\n // Prevent the replaceEqualDeep from being called again down below.\n throw error\n }\n }\n // Structurally share data between prev and new data if needed\n return replaceEqualDeep(prevData, data)\n }\n return data\n}\n\nexport function keepPreviousData(\n previousData: T | undefined,\n): T | undefined {\n return previousData\n}\n\nexport function addToEnd(items: Array, item: T, max = 0): Array {\n const newItems = [...items, item]\n return max && newItems.length > max ? newItems.slice(1) : newItems\n}\n\nexport function addToStart(items: Array, item: T, max = 0): Array {\n const newItems = [item, ...items]\n return max && newItems.length > max ? newItems.slice(0, -1) : newItems\n}\n\nexport const skipToken = Symbol()\nexport type SkipToken = typeof skipToken\n\nexport function ensureQueryFn<\n TQueryFnData = unknown,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: {\n queryFn?: QueryFunction | SkipToken\n queryHash?: string\n },\n fetchOptions?: FetchOptions,\n): QueryFunction {\n if (process.env.NODE_ENV !== 'production') {\n if (options.queryFn === skipToken) {\n console.error(\n `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'`,\n )\n }\n }\n\n // if we attempt to retry a fetch that was triggered from an initialPromise\n // when we don't have a queryFn yet, we can't retry, so we just return the already rejected initialPromise\n // if an observer has already mounted, we will be able to retry with that queryFn\n if (!options.queryFn && fetchOptions?.initialPromise) {\n return () => fetchOptions.initialPromise!\n }\n\n if (!options.queryFn || options.queryFn === skipToken) {\n return () =>\n Promise.reject(new Error(`Missing queryFn: '${options.queryHash}'`))\n }\n\n return options.queryFn\n}\n\nexport function shouldThrowError) => boolean>(\n throwOnError: boolean | T | undefined,\n params: Parameters,\n): boolean {\n // Allow throwOnError function to override throwing behavior on a per-error basis\n if (typeof throwOnError === 'function') {\n return throwOnError(...params)\n }\n\n return !!throwOnError\n}\n\nexport function addConsumeAwareSignal(\n object: T,\n getSignal: () => AbortSignal,\n onCancelled: VoidFunction,\n): T & { signal: AbortSignal } {\n let consumed = false\n let signal: AbortSignal | undefined\n\n Object.defineProperty(object, 'signal', {\n enumerable: true,\n get: () => {\n signal ??= getSignal()\n if (consumed) {\n return signal\n }\n\n consumed = true\n if (signal.aborted) {\n onCancelled()\n } else {\n signal.addEventListener('abort', onCancelled, { once: true })\n }\n\n return signal\n },\n })\n\n return object as T & { signal: AbortSignal }\n}\n", "import { Subscribable } from './subscribable'\nimport { isServer } from './utils'\n\ntype Listener = (focused: boolean) => void\n\ntype SetupFn = (\n setFocused: (focused?: boolean) => void,\n) => (() => void) | undefined\n\nexport class FocusManager extends Subscribable {\n #focused?: boolean\n #cleanup?: () => void\n\n #setup: SetupFn\n\n constructor() {\n super()\n this.#setup = (onFocus) => {\n // addEventListener does not exist in React Native, but window does\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n if (!isServer && window.addEventListener) {\n const listener = () => onFocus()\n // Listen to visibilitychange\n window.addEventListener('visibilitychange', listener, false)\n\n return () => {\n // Be sure to unsubscribe if a new handler is set\n window.removeEventListener('visibilitychange', listener)\n }\n }\n return\n }\n }\n\n protected onSubscribe(): void {\n if (!this.#cleanup) {\n this.setEventListener(this.#setup)\n }\n }\n\n protected onUnsubscribe() {\n if (!this.hasListeners()) {\n this.#cleanup?.()\n this.#cleanup = undefined\n }\n }\n\n setEventListener(setup: SetupFn): void {\n this.#setup = setup\n this.#cleanup?.()\n this.#cleanup = setup((focused) => {\n if (typeof focused === 'boolean') {\n this.setFocused(focused)\n } else {\n this.onFocus()\n }\n })\n }\n\n setFocused(focused?: boolean): void {\n const changed = this.#focused !== focused\n if (changed) {\n this.#focused = focused\n this.onFocus()\n }\n }\n\n onFocus(): void {\n const isFocused = this.isFocused()\n this.listeners.forEach((listener) => {\n listener(isFocused)\n })\n }\n\n isFocused(): boolean {\n if (typeof this.#focused === 'boolean') {\n return this.#focused\n }\n\n // document global can be unavailable in react native\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n return globalThis.document?.visibilityState !== 'hidden'\n }\n}\n\nexport const focusManager = new FocusManager()\n", "/**\n * Thenable types which matches React's types for promises\n *\n * React seemingly uses `.status`, `.value` and `.reason` properties on a promises to optimistically unwrap data from promises\n *\n * @see https://github.com/facebook/react/blob/main/packages/shared/ReactTypes.js#L112-L138\n * @see https://github.com/facebook/react/blob/4f604941569d2e8947ce1460a0b2997e835f37b9/packages/react-debug-tools/src/ReactDebugHooks.js#L224-L227\n */\n\nimport { noop } from './utils'\n\ninterface Fulfilled {\n status: 'fulfilled'\n value: T\n}\ninterface Rejected {\n status: 'rejected'\n reason: unknown\n}\ninterface Pending {\n status: 'pending'\n\n /**\n * Resolve the promise with a value.\n * Will remove the `resolve` and `reject` properties from the promise.\n */\n resolve: (value: T) => void\n /**\n * Reject the promise with a reason.\n * Will remove the `resolve` and `reject` properties from the promise.\n */\n reject: (reason: unknown) => void\n}\n\nexport type FulfilledThenable = Promise & Fulfilled\nexport type RejectedThenable = Promise & Rejected\nexport type PendingThenable = Promise & Pending\n\nexport type Thenable =\n | FulfilledThenable\n | RejectedThenable\n | PendingThenable\n\nexport function pendingThenable(): PendingThenable {\n let resolve: Pending['resolve']\n let reject: Pending['reject']\n // this could use `Promise.withResolvers()` in the future\n const thenable = new Promise((_resolve, _reject) => {\n resolve = _resolve\n reject = _reject\n }) as PendingThenable\n\n thenable.status = 'pending'\n thenable.catch(() => {\n // prevent unhandled rejection errors\n })\n\n function finalize(data: Fulfilled | Rejected) {\n Object.assign(thenable, data)\n\n // clear pending props props to avoid calling them twice\n delete (thenable as Partial>).resolve\n delete (thenable as Partial>).reject\n }\n\n thenable.resolve = (value) => {\n finalize({\n status: 'fulfilled',\n value,\n })\n\n resolve(value)\n }\n thenable.reject = (reason) => {\n finalize({\n status: 'rejected',\n reason,\n })\n\n reject(reason)\n }\n\n return thenable\n}\n\n/**\n * This function takes a Promise-like input and detects whether the data\n * is synchronously available or not.\n *\n * It does not inspect .status, .value or .reason properties of the promise,\n * as those are not always available, and the .status of React's promises\n * should not be considered part of the public API.\n */\nexport function tryResolveSync(promise: Promise | Thenable) {\n let data: unknown\n\n promise\n .then((result) => {\n data = result\n return result\n }, noop)\n // .catch can be unavailable on certain kinds of thenable's\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n ?.catch(noop)\n\n if (data !== undefined) {\n return { data }\n }\n\n return undefined\n}\n", "import { tryResolveSync } from './thenable'\nimport { noop } from './utils'\nimport type {\n DefaultError,\n MutationKey,\n MutationMeta,\n MutationOptions,\n MutationScope,\n QueryKey,\n QueryMeta,\n QueryOptions,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query, QueryState } from './query'\nimport type { Mutation, MutationState } from './mutation'\n\n// TYPES\ntype TransformerFn = (data: any) => any\nfunction defaultTransformerFn(data: any): any {\n return data\n}\n\nexport interface DehydrateOptions {\n serializeData?: TransformerFn\n shouldDehydrateMutation?: (mutation: Mutation) => boolean\n shouldDehydrateQuery?: (query: Query) => boolean\n shouldRedactErrors?: (error: unknown) => boolean\n}\n\nexport interface HydrateOptions {\n defaultOptions?: {\n deserializeData?: TransformerFn\n queries?: QueryOptions\n mutations?: MutationOptions\n }\n}\n\ninterface DehydratedMutation {\n mutationKey?: MutationKey\n state: MutationState\n meta?: MutationMeta\n scope?: MutationScope\n}\n\ninterface DehydratedQuery {\n queryHash: string\n queryKey: QueryKey\n state: QueryState\n promise?: Promise\n meta?: QueryMeta\n // This is only optional because older versions of Query might have dehydrated\n // without it which we need to handle for backwards compatibility.\n // This should be changed to required in the future.\n dehydratedAt?: number\n}\n\nexport interface DehydratedState {\n mutations: Array\n queries: Array\n}\n\n// FUNCTIONS\n\nfunction dehydrateMutation(mutation: Mutation): DehydratedMutation {\n return {\n mutationKey: mutation.options.mutationKey,\n state: mutation.state,\n ...(mutation.options.scope && { scope: mutation.options.scope }),\n ...(mutation.meta && { meta: mutation.meta }),\n }\n}\n\n// Most config is not dehydrated but instead meant to configure again when\n// consuming the de/rehydrated data, typically with useQuery on the client.\n// Sometimes it might make sense to prefetch data on the server and include\n// in the html-payload, but not consume it on the initial render.\nfunction dehydrateQuery(\n query: Query,\n serializeData: TransformerFn,\n shouldRedactErrors: (error: unknown) => boolean,\n): DehydratedQuery {\n const dehydratePromise = () => {\n const promise = query.promise?.then(serializeData).catch((error) => {\n if (!shouldRedactErrors(error)) {\n // Reject original error if it should not be redacted\n return Promise.reject(error)\n }\n // If not in production, log original error before rejecting redacted error\n if (process.env.NODE_ENV !== 'production') {\n console.error(\n `A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`,\n )\n }\n return Promise.reject(new Error('redacted'))\n })\n\n // Avoid unhandled promise rejections\n // We need the promise we dehydrate to reject to get the correct result into\n // the query cache, but we also want to avoid unhandled promise rejections\n // in whatever environment the prefetches are happening in.\n promise?.catch(noop)\n\n return promise\n }\n\n return {\n dehydratedAt: Date.now(),\n state: {\n ...query.state,\n ...(query.state.data !== undefined && {\n data: serializeData(query.state.data),\n }),\n },\n queryKey: query.queryKey,\n queryHash: query.queryHash,\n ...(query.state.status === 'pending' && {\n promise: dehydratePromise(),\n }),\n ...(query.meta && { meta: query.meta }),\n }\n}\n\nexport function defaultShouldDehydrateMutation(mutation: Mutation) {\n return mutation.state.isPaused\n}\n\nexport function defaultShouldDehydrateQuery(query: Query) {\n return query.state.status === 'success'\n}\n\nfunction defaultShouldRedactErrors(_: unknown) {\n return true\n}\n\nexport function dehydrate(\n client: QueryClient,\n options: DehydrateOptions = {},\n): DehydratedState {\n const filterMutation =\n options.shouldDehydrateMutation ??\n client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ??\n defaultShouldDehydrateMutation\n\n const mutations = client\n .getMutationCache()\n .getAll()\n .flatMap((mutation) =>\n filterMutation(mutation) ? [dehydrateMutation(mutation)] : [],\n )\n\n const filterQuery =\n options.shouldDehydrateQuery ??\n client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ??\n defaultShouldDehydrateQuery\n\n const shouldRedactErrors =\n options.shouldRedactErrors ??\n client.getDefaultOptions().dehydrate?.shouldRedactErrors ??\n defaultShouldRedactErrors\n\n const serializeData =\n options.serializeData ??\n client.getDefaultOptions().dehydrate?.serializeData ??\n defaultTransformerFn\n\n const queries = client\n .getQueryCache()\n .getAll()\n .flatMap((query) =>\n filterQuery(query)\n ? [dehydrateQuery(query, serializeData, shouldRedactErrors)]\n : [],\n )\n\n return { mutations, queries }\n}\n\nexport function hydrate(\n client: QueryClient,\n dehydratedState: unknown,\n options?: HydrateOptions,\n): void {\n if (typeof dehydratedState !== 'object' || dehydratedState === null) {\n return\n }\n\n const mutationCache = client.getMutationCache()\n const queryCache = client.getQueryCache()\n const deserializeData =\n options?.defaultOptions?.deserializeData ??\n client.getDefaultOptions().hydrate?.deserializeData ??\n defaultTransformerFn\n\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const mutations = (dehydratedState as DehydratedState).mutations || []\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const queries = (dehydratedState as DehydratedState).queries || []\n\n mutations.forEach(({ state, ...mutationOptions }) => {\n mutationCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.mutations,\n ...options?.defaultOptions?.mutations,\n ...mutationOptions,\n },\n state,\n )\n })\n\n queries.forEach(\n ({ queryKey, state, queryHash, meta, promise, dehydratedAt }) => {\n const syncData = promise ? tryResolveSync(promise) : undefined\n const rawData = state.data === undefined ? syncData?.data : state.data\n const data = rawData === undefined ? rawData : deserializeData(rawData)\n\n let query = queryCache.get(queryHash)\n const existingQueryIsPending = query?.state.status === 'pending'\n const existingQueryIsFetching = query?.state.fetchStatus === 'fetching'\n\n // Do not hydrate if an existing query exists with newer data\n if (query) {\n const hasNewerSyncData =\n syncData &&\n // We only need this undefined check to handle older dehydration\n // payloads that might not have dehydratedAt\n dehydratedAt !== undefined &&\n dehydratedAt > query.state.dataUpdatedAt\n if (\n state.dataUpdatedAt > query.state.dataUpdatedAt ||\n hasNewerSyncData\n ) {\n // omit fetchStatus from dehydrated state\n // so that query stays in its current fetchStatus\n const { fetchStatus: _ignored, ...serializedState } = state\n query.setState({\n ...serializedState,\n data,\n })\n }\n } else {\n // Restore query\n query = queryCache.build(\n client,\n {\n ...client.getDefaultOptions().hydrate?.queries,\n ...options?.defaultOptions?.queries,\n queryKey,\n queryHash,\n meta,\n },\n // Reset fetch status to idle to avoid\n // query being stuck in fetching state upon hydration\n {\n ...state,\n data,\n fetchStatus: 'idle',\n status: data !== undefined ? 'success' : state.status,\n },\n )\n }\n\n if (\n promise &&\n !existingQueryIsPending &&\n !existingQueryIsFetching &&\n // Only hydrate if dehydration is newer than any existing data,\n // this is always true for new queries\n (dehydratedAt === undefined || dehydratedAt > query.state.dataUpdatedAt)\n ) {\n // This doesn't actually fetch - it just creates a retryer\n // which will re-use the passed `initialPromise`\n // Note that we need to call these even when data was synchronously\n // available, as we still need to set up the retryer\n query\n .fetch(undefined, {\n // RSC transformed promises are not thenable\n initialPromise: Promise.resolve(promise).then(deserializeData),\n })\n // Avoid unhandled promise rejections\n .catch(noop)\n }\n },\n )\n}\n", "// TYPES\n\nimport { systemSetTimeoutZero } from './timeoutManager'\n\ntype NotifyCallback = () => void\n\ntype NotifyFunction = (callback: () => void) => void\n\ntype BatchNotifyFunction = (callback: () => void) => void\n\ntype BatchCallsCallback> = (...args: T) => void\n\ntype ScheduleFunction = (callback: () => void) => void\n\nexport const defaultScheduler: ScheduleFunction = systemSetTimeoutZero\n\nexport function createNotifyManager() {\n let queue: Array = []\n let transactions = 0\n let notifyFn: NotifyFunction = (callback) => {\n callback()\n }\n let batchNotifyFn: BatchNotifyFunction = (callback: () => void) => {\n callback()\n }\n let scheduleFn = defaultScheduler\n\n const schedule = (callback: NotifyCallback): void => {\n if (transactions) {\n queue.push(callback)\n } else {\n scheduleFn(() => {\n notifyFn(callback)\n })\n }\n }\n const flush = (): void => {\n const originalQueue = queue\n queue = []\n if (originalQueue.length) {\n scheduleFn(() => {\n batchNotifyFn(() => {\n originalQueue.forEach((callback) => {\n notifyFn(callback)\n })\n })\n })\n }\n }\n\n return {\n batch: (callback: () => T): T => {\n let result\n transactions++\n try {\n result = callback()\n } finally {\n transactions--\n if (!transactions) {\n flush()\n }\n }\n return result\n },\n /**\n * All calls to the wrapped function will be batched.\n */\n batchCalls: >(\n callback: BatchCallsCallback,\n ): BatchCallsCallback => {\n return (...args) => {\n schedule(() => {\n callback(...args)\n })\n }\n },\n schedule,\n /**\n * Use this method to set a custom notify function.\n * This can be used to for example wrap notifications with `React.act` while running tests.\n */\n setNotifyFunction: (fn: NotifyFunction) => {\n notifyFn = fn\n },\n /**\n * Use this method to set a custom function to batch notifications together into a single tick.\n * By default React Query will use the batch function provided by ReactDOM or React Native.\n */\n setBatchNotifyFunction: (fn: BatchNotifyFunction) => {\n batchNotifyFn = fn\n },\n setScheduler: (fn: ScheduleFunction) => {\n scheduleFn = fn\n },\n } as const\n}\n\n// SINGLETON\nexport const notifyManager = createNotifyManager()\n", "import { Subscribable } from './subscribable'\nimport { isServer } from './utils'\n\ntype Listener = (online: boolean) => void\ntype SetupFn = (setOnline: Listener) => (() => void) | undefined\n\nexport class OnlineManager extends Subscribable {\n #online = true\n #cleanup?: () => void\n\n #setup: SetupFn\n\n constructor() {\n super()\n this.#setup = (onOnline) => {\n // addEventListener does not exist in React Native, but window does\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n if (!isServer && window.addEventListener) {\n const onlineListener = () => onOnline(true)\n const offlineListener = () => onOnline(false)\n // Listen to online\n window.addEventListener('online', onlineListener, false)\n window.addEventListener('offline', offlineListener, false)\n\n return () => {\n // Be sure to unsubscribe if a new handler is set\n window.removeEventListener('online', onlineListener)\n window.removeEventListener('offline', offlineListener)\n }\n }\n\n return\n }\n }\n\n protected onSubscribe(): void {\n if (!this.#cleanup) {\n this.setEventListener(this.#setup)\n }\n }\n\n protected onUnsubscribe() {\n if (!this.hasListeners()) {\n this.#cleanup?.()\n this.#cleanup = undefined\n }\n }\n\n setEventListener(setup: SetupFn): void {\n this.#setup = setup\n this.#cleanup?.()\n this.#cleanup = setup(this.setOnline.bind(this))\n }\n\n setOnline(online: boolean): void {\n const changed = this.#online !== online\n\n if (changed) {\n this.#online = online\n this.listeners.forEach((listener) => {\n listener(online)\n })\n }\n }\n\n isOnline(): boolean {\n return this.#online\n }\n}\n\nexport const onlineManager = new OnlineManager()\n", "import { focusManager } from './focusManager'\nimport { onlineManager } from './onlineManager'\nimport { pendingThenable } from './thenable'\nimport { isServer, sleep } from './utils'\nimport type { Thenable } from './thenable'\nimport type { CancelOptions, DefaultError, NetworkMode } from './types'\n\n// TYPES\n\ninterface RetryerConfig {\n fn: () => TData | Promise\n initialPromise?: Promise\n onCancel?: (error: TError) => void\n onFail?: (failureCount: number, error: TError) => void\n onPause?: () => void\n onContinue?: () => void\n retry?: RetryValue\n retryDelay?: RetryDelayValue\n networkMode: NetworkMode | undefined\n canRun: () => boolean\n}\n\nexport interface Retryer {\n promise: Promise\n cancel: (cancelOptions?: CancelOptions) => void\n continue: () => Promise\n cancelRetry: () => void\n continueRetry: () => void\n canStart: () => boolean\n start: () => Promise\n status: () => 'pending' | 'resolved' | 'rejected'\n}\n\nexport type RetryValue = boolean | number | ShouldRetryFunction\n\ntype ShouldRetryFunction = (\n failureCount: number,\n error: TError,\n) => boolean\n\nexport type RetryDelayValue = number | RetryDelayFunction\n\ntype RetryDelayFunction = (\n failureCount: number,\n error: TError,\n) => number\n\nfunction defaultRetryDelay(failureCount: number) {\n return Math.min(1000 * 2 ** failureCount, 30000)\n}\n\nexport function canFetch(networkMode: NetworkMode | undefined): boolean {\n return (networkMode ?? 'online') === 'online'\n ? onlineManager.isOnline()\n : true\n}\n\nexport class CancelledError extends Error {\n revert?: boolean\n silent?: boolean\n constructor(options?: CancelOptions) {\n super('CancelledError')\n this.revert = options?.revert\n this.silent = options?.silent\n }\n}\n\n/**\n * @deprecated Use instanceof `CancelledError` instead.\n */\nexport function isCancelledError(value: any): value is CancelledError {\n return value instanceof CancelledError\n}\n\nexport function createRetryer(\n config: RetryerConfig,\n): Retryer {\n let isRetryCancelled = false\n let failureCount = 0\n let continueFn: ((value?: unknown) => void) | undefined\n\n const thenable = pendingThenable()\n\n const isResolved = () =>\n (thenable.status as Thenable['status']) !== 'pending'\n\n const cancel = (cancelOptions?: CancelOptions): void => {\n if (!isResolved()) {\n const error = new CancelledError(cancelOptions) as TError\n reject(error)\n\n config.onCancel?.(error)\n }\n }\n const cancelRetry = () => {\n isRetryCancelled = true\n }\n\n const continueRetry = () => {\n isRetryCancelled = false\n }\n\n const canContinue = () =>\n focusManager.isFocused() &&\n (config.networkMode === 'always' || onlineManager.isOnline()) &&\n config.canRun()\n\n const canStart = () => canFetch(config.networkMode) && config.canRun()\n\n const resolve = (value: any) => {\n if (!isResolved()) {\n continueFn?.()\n thenable.resolve(value)\n }\n }\n\n const reject = (value: any) => {\n if (!isResolved()) {\n continueFn?.()\n thenable.reject(value)\n }\n }\n\n const pause = () => {\n return new Promise((continueResolve) => {\n continueFn = (value) => {\n if (isResolved() || canContinue()) {\n continueResolve(value)\n }\n }\n config.onPause?.()\n }).then(() => {\n continueFn = undefined\n if (!isResolved()) {\n config.onContinue?.()\n }\n })\n }\n\n // Create loop function\n const run = () => {\n // Do nothing if already resolved\n if (isResolved()) {\n return\n }\n\n let promiseOrValue: any\n\n // we can re-use config.initialPromise on the first call of run()\n const initialPromise =\n failureCount === 0 ? config.initialPromise : undefined\n\n // Execute query\n try {\n promiseOrValue = initialPromise ?? config.fn()\n } catch (error) {\n promiseOrValue = Promise.reject(error)\n }\n\n Promise.resolve(promiseOrValue)\n .then(resolve)\n .catch((error) => {\n // Stop if the fetch is already resolved\n if (isResolved()) {\n return\n }\n\n // Do we need to retry the request?\n const retry = config.retry ?? (isServer ? 0 : 3)\n const retryDelay = config.retryDelay ?? defaultRetryDelay\n const delay =\n typeof retryDelay === 'function'\n ? retryDelay(failureCount, error)\n : retryDelay\n const shouldRetry =\n retry === true ||\n (typeof retry === 'number' && failureCount < retry) ||\n (typeof retry === 'function' && retry(failureCount, error))\n\n if (isRetryCancelled || !shouldRetry) {\n // We are done if the query does not need to be retried\n reject(error)\n return\n }\n\n failureCount++\n\n // Notify on fail\n config.onFail?.(failureCount, error)\n\n // Delay\n sleep(delay)\n // Pause if the document is not visible or when the device is offline\n .then(() => {\n return canContinue() ? undefined : pause()\n })\n .then(() => {\n if (isRetryCancelled) {\n reject(error)\n } else {\n run()\n }\n })\n })\n }\n\n return {\n promise: thenable,\n status: () => thenable.status,\n cancel,\n continue: () => {\n continueFn?.()\n return thenable\n },\n cancelRetry,\n continueRetry,\n canStart,\n start: () => {\n // Start loop\n if (canStart()) {\n run()\n } else {\n pause().then(run)\n }\n return thenable\n },\n }\n}\n", "import { timeoutManager } from './timeoutManager'\nimport { isServer, isValidTimeout } from './utils'\nimport type { ManagedTimerId } from './timeoutManager'\n\nexport abstract class Removable {\n gcTime!: number\n #gcTimeout?: ManagedTimerId\n\n destroy(): void {\n this.clearGcTimeout()\n }\n\n protected scheduleGc(): void {\n this.clearGcTimeout()\n\n if (isValidTimeout(this.gcTime)) {\n this.#gcTimeout = timeoutManager.setTimeout(() => {\n this.optionalRemove()\n }, this.gcTime)\n }\n }\n\n protected updateGcTime(newGcTime: number | undefined): void {\n // Default to 5 minutes (Infinity for server-side) if no gcTime is set\n this.gcTime = Math.max(\n this.gcTime || 0,\n newGcTime ?? (isServer ? Infinity : 5 * 60 * 1000),\n )\n }\n\n protected clearGcTimeout() {\n if (this.#gcTimeout) {\n timeoutManager.clearTimeout(this.#gcTimeout)\n this.#gcTimeout = undefined\n }\n }\n\n protected abstract optionalRemove(): void\n}\n", "import {\n ensureQueryFn,\n noop,\n replaceData,\n resolveEnabled,\n resolveStaleTime,\n skipToken,\n timeUntilStale,\n} from './utils'\nimport { notifyManager } from './notifyManager'\nimport { CancelledError, canFetch, createRetryer } from './retryer'\nimport { Removable } from './removable'\nimport type { QueryCache } from './queryCache'\nimport type { QueryClient } from './queryClient'\nimport type {\n CancelOptions,\n DefaultError,\n FetchStatus,\n InitialDataFunction,\n OmitKeyof,\n QueryFunctionContext,\n QueryKey,\n QueryMeta,\n QueryOptions,\n QueryStatus,\n SetDataOptions,\n StaleTime,\n} from './types'\nimport type { QueryObserver } from './queryObserver'\nimport type { Retryer } from './retryer'\n\n// TYPES\n\ninterface QueryConfig<\n TQueryFnData,\n TError,\n TData,\n TQueryKey extends QueryKey = QueryKey,\n> {\n client: QueryClient\n queryKey: TQueryKey\n queryHash: string\n options?: QueryOptions\n defaultOptions?: QueryOptions\n state?: QueryState\n}\n\nexport interface QueryState {\n data: TData | undefined\n dataUpdateCount: number\n dataUpdatedAt: number\n error: TError | null\n errorUpdateCount: number\n errorUpdatedAt: number\n fetchFailureCount: number\n fetchFailureReason: TError | null\n fetchMeta: FetchMeta | null\n isInvalidated: boolean\n status: QueryStatus\n fetchStatus: FetchStatus\n}\n\nexport interface FetchContext<\n TQueryFnData,\n TError,\n TData,\n TQueryKey extends QueryKey = QueryKey,\n> {\n fetchFn: () => unknown | Promise\n fetchOptions?: FetchOptions\n signal: AbortSignal\n options: QueryOptions\n client: QueryClient\n queryKey: TQueryKey\n state: QueryState\n}\n\nexport interface QueryBehavior<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> {\n onFetch: (\n context: FetchContext,\n query: Query,\n ) => void\n}\n\nexport type FetchDirection = 'forward' | 'backward'\n\nexport interface FetchMeta {\n fetchMore?: { direction: FetchDirection }\n}\n\nexport interface FetchOptions {\n cancelRefetch?: boolean\n meta?: FetchMeta\n initialPromise?: Promise\n}\n\ninterface FailedAction {\n type: 'failed'\n failureCount: number\n error: TError\n}\n\ninterface FetchAction {\n type: 'fetch'\n meta?: FetchMeta\n}\n\ninterface SuccessAction {\n data: TData | undefined\n type: 'success'\n dataUpdatedAt?: number\n manual?: boolean\n}\n\ninterface ErrorAction {\n type: 'error'\n error: TError\n}\n\ninterface InvalidateAction {\n type: 'invalidate'\n}\n\ninterface PauseAction {\n type: 'pause'\n}\n\ninterface ContinueAction {\n type: 'continue'\n}\n\ninterface SetStateAction {\n type: 'setState'\n state: Partial>\n setStateOptions?: SetStateOptions\n}\n\nexport type Action =\n | ContinueAction\n | ErrorAction\n | FailedAction\n | FetchAction\n | InvalidateAction\n | PauseAction\n | SetStateAction\n | SuccessAction\n\nexport interface SetStateOptions {\n meta?: any\n}\n\n// CLASS\n\nexport class Query<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends Removable {\n queryKey: TQueryKey\n queryHash: string\n options!: QueryOptions\n state: QueryState\n\n #initialState: QueryState\n #revertState?: QueryState\n #cache: QueryCache\n #client: QueryClient\n #retryer?: Retryer\n observers: Array>\n #defaultOptions?: QueryOptions\n #abortSignalConsumed: boolean\n\n constructor(config: QueryConfig) {\n super()\n\n this.#abortSignalConsumed = false\n this.#defaultOptions = config.defaultOptions\n this.setOptions(config.options)\n this.observers = []\n this.#client = config.client\n this.#cache = this.#client.getQueryCache()\n this.queryKey = config.queryKey\n this.queryHash = config.queryHash\n this.#initialState = getDefaultState(this.options)\n this.state = config.state ?? this.#initialState\n this.scheduleGc()\n }\n get meta(): QueryMeta | undefined {\n return this.options.meta\n }\n\n get promise(): Promise | undefined {\n return this.#retryer?.promise\n }\n\n setOptions(\n options?: QueryOptions,\n ): void {\n this.options = { ...this.#defaultOptions, ...options }\n\n this.updateGcTime(this.options.gcTime)\n\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n if (this.state && this.state.data === undefined) {\n const defaultState = getDefaultState(this.options)\n if (defaultState.data !== undefined) {\n this.setState(\n successState(defaultState.data, defaultState.dataUpdatedAt),\n )\n this.#initialState = defaultState\n }\n }\n }\n\n protected optionalRemove() {\n if (!this.observers.length && this.state.fetchStatus === 'idle') {\n this.#cache.remove(this)\n }\n }\n\n setData(\n newData: TData,\n options?: SetDataOptions & { manual: boolean },\n ): TData {\n const data = replaceData(this.state.data, newData, this.options)\n\n // Set data and mark it as cached\n this.#dispatch({\n data,\n type: 'success',\n dataUpdatedAt: options?.updatedAt,\n manual: options?.manual,\n })\n\n return data\n }\n\n setState(\n state: Partial>,\n setStateOptions?: SetStateOptions,\n ): void {\n this.#dispatch({ type: 'setState', state, setStateOptions })\n }\n\n cancel(options?: CancelOptions): Promise {\n const promise = this.#retryer?.promise\n this.#retryer?.cancel(options)\n return promise ? promise.then(noop).catch(noop) : Promise.resolve()\n }\n\n destroy(): void {\n super.destroy()\n\n this.cancel({ silent: true })\n }\n\n reset(): void {\n this.destroy()\n this.setState(this.#initialState)\n }\n\n isActive(): boolean {\n return this.observers.some(\n (observer) => resolveEnabled(observer.options.enabled, this) !== false,\n )\n }\n\n isDisabled(): boolean {\n if (this.getObserversCount() > 0) {\n return !this.isActive()\n }\n // if a query has no observers, it should still be considered disabled if it never attempted a fetch\n return (\n this.options.queryFn === skipToken ||\n this.state.dataUpdateCount + this.state.errorUpdateCount === 0\n )\n }\n\n isStatic(): boolean {\n if (this.getObserversCount() > 0) {\n return this.observers.some(\n (observer) =>\n resolveStaleTime(observer.options.staleTime, this) === 'static',\n )\n }\n\n return false\n }\n\n isStale(): boolean {\n // check observers first, their `isStale` has the source of truth\n // calculated with `isStaleByTime` and it takes `enabled` into account\n if (this.getObserversCount() > 0) {\n return this.observers.some(\n (observer) => observer.getCurrentResult().isStale,\n )\n }\n\n return this.state.data === undefined || this.state.isInvalidated\n }\n\n isStaleByTime(staleTime: StaleTime = 0): boolean {\n // no data is always stale\n if (this.state.data === undefined) {\n return true\n }\n // static is never stale\n if (staleTime === 'static') {\n return false\n }\n // if the query is invalidated, it is stale\n if (this.state.isInvalidated) {\n return true\n }\n\n return !timeUntilStale(this.state.dataUpdatedAt, staleTime)\n }\n\n onFocus(): void {\n const observer = this.observers.find((x) => x.shouldFetchOnWindowFocus())\n\n observer?.refetch({ cancelRefetch: false })\n\n // Continue fetch if currently paused\n this.#retryer?.continue()\n }\n\n onOnline(): void {\n const observer = this.observers.find((x) => x.shouldFetchOnReconnect())\n\n observer?.refetch({ cancelRefetch: false })\n\n // Continue fetch if currently paused\n this.#retryer?.continue()\n }\n\n addObserver(observer: QueryObserver): void {\n if (!this.observers.includes(observer)) {\n this.observers.push(observer)\n\n // Stop the query from being garbage collected\n this.clearGcTimeout()\n\n this.#cache.notify({ type: 'observerAdded', query: this, observer })\n }\n }\n\n removeObserver(observer: QueryObserver): void {\n if (this.observers.includes(observer)) {\n this.observers = this.observers.filter((x) => x !== observer)\n\n if (!this.observers.length) {\n // If the transport layer does not support cancellation\n // we'll let the query continue so the result can be cached\n if (this.#retryer) {\n if (this.#abortSignalConsumed) {\n this.#retryer.cancel({ revert: true })\n } else {\n this.#retryer.cancelRetry()\n }\n }\n\n this.scheduleGc()\n }\n\n this.#cache.notify({ type: 'observerRemoved', query: this, observer })\n }\n }\n\n getObserversCount(): number {\n return this.observers.length\n }\n\n invalidate(): void {\n if (!this.state.isInvalidated) {\n this.#dispatch({ type: 'invalidate' })\n }\n }\n\n async fetch(\n options?: QueryOptions,\n fetchOptions?: FetchOptions,\n ): Promise {\n if (\n this.state.fetchStatus !== 'idle' &&\n // If the promise in the retryer is already rejected, we have to definitely\n // re-start the fetch; there is a chance that the query is still in a\n // pending state when that happens\n this.#retryer?.status() !== 'rejected'\n ) {\n if (this.state.data !== undefined && fetchOptions?.cancelRefetch) {\n // Silently cancel current fetch if the user wants to cancel refetch\n this.cancel({ silent: true })\n } else if (this.#retryer) {\n // make sure that retries that were potentially cancelled due to unmounts can continue\n this.#retryer.continueRetry()\n // Return current promise if we are already fetching\n return this.#retryer.promise\n }\n }\n\n // Update config if passed, otherwise the config from the last execution is used\n if (options) {\n this.setOptions(options)\n }\n\n // Use the options from the first observer with a query function if no function is found.\n // This can happen when the query is hydrated or created with setQueryData.\n if (!this.options.queryFn) {\n const observer = this.observers.find((x) => x.options.queryFn)\n if (observer) {\n this.setOptions(observer.options)\n }\n }\n\n if (process.env.NODE_ENV !== 'production') {\n if (!Array.isArray(this.options.queryKey)) {\n console.error(\n `As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']`,\n )\n }\n }\n\n const abortController = new AbortController()\n\n // Adds an enumerable signal property to the object that\n // which sets abortSignalConsumed to true when the signal\n // is read.\n const addSignalProperty = (object: unknown) => {\n Object.defineProperty(object, 'signal', {\n enumerable: true,\n get: () => {\n this.#abortSignalConsumed = true\n return abortController.signal\n },\n })\n }\n\n // Create fetch function\n const fetchFn = () => {\n const queryFn = ensureQueryFn(this.options, fetchOptions)\n\n // Create query function context\n const createQueryFnContext = (): QueryFunctionContext => {\n const queryFnContext: OmitKeyof<\n QueryFunctionContext,\n 'signal'\n > = {\n client: this.#client,\n queryKey: this.queryKey,\n meta: this.meta,\n }\n addSignalProperty(queryFnContext)\n return queryFnContext as QueryFunctionContext\n }\n\n const queryFnContext = createQueryFnContext()\n\n this.#abortSignalConsumed = false\n if (this.options.persister) {\n return this.options.persister(\n queryFn,\n queryFnContext,\n this as unknown as Query,\n )\n }\n\n return queryFn(queryFnContext)\n }\n\n // Trigger behavior hook\n const createFetchContext = (): FetchContext<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n > => {\n const context: OmitKeyof<\n FetchContext,\n 'signal'\n > = {\n fetchOptions,\n options: this.options,\n queryKey: this.queryKey,\n client: this.#client,\n state: this.state,\n fetchFn,\n }\n\n addSignalProperty(context)\n return context as FetchContext\n }\n\n const context = createFetchContext()\n\n this.options.behavior?.onFetch(context, this as unknown as Query)\n\n // Store state in case the current fetch needs to be reverted\n this.#revertState = this.state\n\n // Set to fetching state if not already in it\n if (\n this.state.fetchStatus === 'idle' ||\n this.state.fetchMeta !== context.fetchOptions?.meta\n ) {\n this.#dispatch({ type: 'fetch', meta: context.fetchOptions?.meta })\n }\n\n // Try to fetch the data\n this.#retryer = createRetryer({\n initialPromise: fetchOptions?.initialPromise as\n | Promise\n | undefined,\n fn: context.fetchFn as () => Promise,\n onCancel: (error) => {\n if (error instanceof CancelledError && error.revert) {\n this.setState({\n ...this.#revertState,\n fetchStatus: 'idle' as const,\n })\n }\n abortController.abort()\n },\n onFail: (failureCount, error) => {\n this.#dispatch({ type: 'failed', failureCount, error })\n },\n onPause: () => {\n this.#dispatch({ type: 'pause' })\n },\n onContinue: () => {\n this.#dispatch({ type: 'continue' })\n },\n retry: context.options.retry,\n retryDelay: context.options.retryDelay,\n networkMode: context.options.networkMode,\n canRun: () => true,\n })\n\n try {\n const data = await this.#retryer.start()\n // this is more of a runtime guard\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n if (data === undefined) {\n if (process.env.NODE_ENV !== 'production') {\n console.error(\n `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`,\n )\n }\n throw new Error(`${this.queryHash} data is undefined`)\n }\n\n this.setData(data)\n\n // Notify cache callback\n this.#cache.config.onSuccess?.(data, this as Query)\n this.#cache.config.onSettled?.(\n data,\n this.state.error as any,\n this as Query,\n )\n return data\n } catch (error) {\n if (error instanceof CancelledError) {\n if (error.silent) {\n // silent cancellation implies a new fetch is going to be started,\n // so we piggyback onto that promise\n return this.#retryer.promise\n } else if (error.revert) {\n // transform error into reverted state data\n // if the initial fetch was cancelled, we have no data, so we have\n // to get reject with a CancelledError\n if (this.state.data === undefined) {\n throw error\n }\n return this.state.data\n }\n }\n this.#dispatch({\n type: 'error',\n error: error as TError,\n })\n\n // Notify cache callback\n this.#cache.config.onError?.(\n error as any,\n this as Query,\n )\n this.#cache.config.onSettled?.(\n this.state.data,\n error as any,\n this as Query,\n )\n\n throw error // rethrow the error for further handling\n } finally {\n // Schedule query gc after fetching\n this.scheduleGc()\n }\n }\n\n #dispatch(action: Action): void {\n const reducer = (\n state: QueryState,\n ): QueryState => {\n switch (action.type) {\n case 'failed':\n return {\n ...state,\n fetchFailureCount: action.failureCount,\n fetchFailureReason: action.error,\n }\n case 'pause':\n return {\n ...state,\n fetchStatus: 'paused',\n }\n case 'continue':\n return {\n ...state,\n fetchStatus: 'fetching',\n }\n case 'fetch':\n return {\n ...state,\n ...fetchState(state.data, this.options),\n fetchMeta: action.meta ?? null,\n }\n case 'success':\n const newState = {\n ...state,\n ...successState(action.data, action.dataUpdatedAt),\n dataUpdateCount: state.dataUpdateCount + 1,\n ...(!action.manual && {\n fetchStatus: 'idle' as const,\n fetchFailureCount: 0,\n fetchFailureReason: null,\n }),\n }\n // If fetching ends successfully, we don't need revertState as a fallback anymore.\n // For manual updates, capture the state to revert to it in case of a cancellation.\n this.#revertState = action.manual ? newState : undefined\n\n return newState\n case 'error':\n const error = action.error\n return {\n ...state,\n error,\n errorUpdateCount: state.errorUpdateCount + 1,\n errorUpdatedAt: Date.now(),\n fetchFailureCount: state.fetchFailureCount + 1,\n fetchFailureReason: error,\n fetchStatus: 'idle',\n status: 'error',\n // flag existing data as invalidated if we get a background error\n // note that \"no data\" always means stale so we can set unconditionally here\n isInvalidated: true,\n }\n case 'invalidate':\n return {\n ...state,\n isInvalidated: true,\n }\n case 'setState':\n return {\n ...state,\n ...action.state,\n }\n }\n }\n\n this.state = reducer(this.state)\n\n notifyManager.batch(() => {\n this.observers.forEach((observer) => {\n observer.onQueryUpdate()\n })\n\n this.#cache.notify({ query: this, type: 'updated', action })\n })\n }\n}\n\nexport function fetchState<\n TQueryFnData,\n TError,\n TData,\n TQueryKey extends QueryKey,\n>(\n data: TData | undefined,\n options: QueryOptions,\n) {\n return {\n fetchFailureCount: 0,\n fetchFailureReason: null,\n fetchStatus: canFetch(options.networkMode) ? 'fetching' : 'paused',\n ...(data === undefined &&\n ({\n error: null,\n status: 'pending',\n } as const)),\n } as const\n}\n\nfunction successState(data: TData | undefined, dataUpdatedAt?: number) {\n return {\n data,\n dataUpdatedAt: dataUpdatedAt ?? Date.now(),\n error: null,\n isInvalidated: false,\n status: 'success' as const,\n }\n}\n\nfunction getDefaultState<\n TQueryFnData,\n TError,\n TData,\n TQueryKey extends QueryKey,\n>(\n options: QueryOptions,\n): QueryState {\n const data =\n typeof options.initialData === 'function'\n ? (options.initialData as InitialDataFunction)()\n : options.initialData\n\n const hasData = data !== undefined\n\n const initialDataUpdatedAt = hasData\n ? typeof options.initialDataUpdatedAt === 'function'\n ? options.initialDataUpdatedAt()\n : options.initialDataUpdatedAt\n : 0\n\n return {\n data,\n dataUpdateCount: 0,\n dataUpdatedAt: hasData ? (initialDataUpdatedAt ?? Date.now()) : 0,\n error: null,\n errorUpdateCount: 0,\n errorUpdatedAt: 0,\n fetchFailureCount: 0,\n fetchFailureReason: null,\n fetchMeta: null,\n isInvalidated: false,\n status: hasData ? 'success' : 'pending',\n fetchStatus: 'idle',\n }\n}\n", "import { focusManager } from './focusManager'\nimport { notifyManager } from './notifyManager'\nimport { fetchState } from './query'\nimport { Subscribable } from './subscribable'\nimport { pendingThenable } from './thenable'\nimport {\n isServer,\n isValidTimeout,\n noop,\n replaceData,\n resolveEnabled,\n resolveStaleTime,\n shallowEqualObjects,\n timeUntilStale,\n} from './utils'\nimport { timeoutManager } from './timeoutManager'\nimport type { ManagedTimerId } from './timeoutManager'\nimport type { FetchOptions, Query, QueryState } from './query'\nimport type { QueryClient } from './queryClient'\nimport type { PendingThenable, Thenable } from './thenable'\nimport type {\n DefaultError,\n DefaultedQueryObserverOptions,\n PlaceholderDataFunction,\n QueryKey,\n QueryObserverBaseResult,\n QueryObserverOptions,\n QueryObserverResult,\n RefetchOptions,\n} from './types'\n\ntype QueryObserverListener = (\n result: QueryObserverResult,\n) => void\n\ninterface ObserverFetchOptions extends FetchOptions {\n throwOnError?: boolean\n}\n\nexport class QueryObserver<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> extends Subscribable> {\n #client: QueryClient\n #currentQuery: Query = undefined!\n #currentQueryInitialState: QueryState = undefined!\n #currentResult: QueryObserverResult = undefined!\n #currentResultState?: QueryState\n #currentResultOptions?: QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >\n #currentThenable: Thenable\n #selectError: TError | null\n #selectFn?: (data: TQueryData) => TData\n #selectResult?: TData\n // This property keeps track of the last query with defined data.\n // It will be used to pass the previous data and query to the placeholder function between renders.\n #lastQueryWithDefinedData?: Query\n #staleTimeoutId?: ManagedTimerId\n #refetchIntervalId?: ManagedTimerId\n #currentRefetchInterval?: number | false\n #trackedProps = new Set()\n\n constructor(\n client: QueryClient,\n public options: QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n ) {\n super()\n\n this.#client = client\n this.#selectError = null\n this.#currentThenable = pendingThenable()\n\n this.bindMethods()\n this.setOptions(options)\n }\n\n protected bindMethods(): void {\n this.refetch = this.refetch.bind(this)\n }\n\n protected onSubscribe(): void {\n if (this.listeners.size === 1) {\n this.#currentQuery.addObserver(this)\n\n if (shouldFetchOnMount(this.#currentQuery, this.options)) {\n this.#executeFetch()\n } else {\n this.updateResult()\n }\n\n this.#updateTimers()\n }\n }\n\n protected onUnsubscribe(): void {\n if (!this.hasListeners()) {\n this.destroy()\n }\n }\n\n shouldFetchOnReconnect(): boolean {\n return shouldFetchOn(\n this.#currentQuery,\n this.options,\n this.options.refetchOnReconnect,\n )\n }\n\n shouldFetchOnWindowFocus(): boolean {\n return shouldFetchOn(\n this.#currentQuery,\n this.options,\n this.options.refetchOnWindowFocus,\n )\n }\n\n destroy(): void {\n this.listeners = new Set()\n this.#clearStaleTimeout()\n this.#clearRefetchInterval()\n this.#currentQuery.removeObserver(this)\n }\n\n setOptions(\n options: QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n ): void {\n const prevOptions = this.options\n const prevQuery = this.#currentQuery\n\n this.options = this.#client.defaultQueryOptions(options)\n\n if (\n this.options.enabled !== undefined &&\n typeof this.options.enabled !== 'boolean' &&\n typeof this.options.enabled !== 'function' &&\n typeof resolveEnabled(this.options.enabled, this.#currentQuery) !==\n 'boolean'\n ) {\n throw new Error(\n 'Expected enabled to be a boolean or a callback that returns a boolean',\n )\n }\n\n this.#updateQuery()\n this.#currentQuery.setOptions(this.options)\n\n if (\n prevOptions._defaulted &&\n !shallowEqualObjects(this.options, prevOptions)\n ) {\n this.#client.getQueryCache().notify({\n type: 'observerOptionsUpdated',\n query: this.#currentQuery,\n observer: this,\n })\n }\n\n const mounted = this.hasListeners()\n\n // Fetch if there are subscribers\n if (\n mounted &&\n shouldFetchOptionally(\n this.#currentQuery,\n prevQuery,\n this.options,\n prevOptions,\n )\n ) {\n this.#executeFetch()\n }\n\n // Update result\n this.updateResult()\n\n // Update stale interval if needed\n if (\n mounted &&\n (this.#currentQuery !== prevQuery ||\n resolveEnabled(this.options.enabled, this.#currentQuery) !==\n resolveEnabled(prevOptions.enabled, this.#currentQuery) ||\n resolveStaleTime(this.options.staleTime, this.#currentQuery) !==\n resolveStaleTime(prevOptions.staleTime, this.#currentQuery))\n ) {\n this.#updateStaleTimeout()\n }\n\n const nextRefetchInterval = this.#computeRefetchInterval()\n\n // Update refetch interval if needed\n if (\n mounted &&\n (this.#currentQuery !== prevQuery ||\n resolveEnabled(this.options.enabled, this.#currentQuery) !==\n resolveEnabled(prevOptions.enabled, this.#currentQuery) ||\n nextRefetchInterval !== this.#currentRefetchInterval)\n ) {\n this.#updateRefetchInterval(nextRefetchInterval)\n }\n }\n\n getOptimisticResult(\n options: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n ): QueryObserverResult {\n const query = this.#client.getQueryCache().build(this.#client, options)\n\n const result = this.createResult(query, options)\n\n if (shouldAssignObserverCurrentProperties(this, result)) {\n // this assigns the optimistic result to the current Observer\n // because if the query function changes, useQuery will be performing\n // an effect where it would fetch again.\n // When the fetch finishes, we perform a deep data cloning in order\n // to reuse objects references. This deep data clone is performed against\n // the `observer.currentResult.data` property\n // When QueryKey changes, we refresh the query and get new `optimistic`\n // result, while we leave the `observer.currentResult`, so when new data\n // arrives, it finds the old `observer.currentResult` which is related\n // to the old QueryKey. Which means that currentResult and selectData are\n // out of sync already.\n // To solve this, we move the cursor of the currentResult every time\n // an observer reads an optimistic value.\n\n // When keeping the previous data, the result doesn't change until new\n // data arrives.\n this.#currentResult = result\n this.#currentResultOptions = this.options\n this.#currentResultState = this.#currentQuery.state\n }\n return result\n }\n\n getCurrentResult(): QueryObserverResult {\n return this.#currentResult\n }\n\n trackResult(\n result: QueryObserverResult,\n onPropTracked?: (key: keyof QueryObserverResult) => void,\n ): QueryObserverResult {\n return new Proxy(result, {\n get: (target, key) => {\n this.trackProp(key as keyof QueryObserverResult)\n onPropTracked?.(key as keyof QueryObserverResult)\n if (key === 'promise') {\n this.trackProp('data')\n if (\n !this.options.experimental_prefetchInRender &&\n this.#currentThenable.status === 'pending'\n ) {\n this.#currentThenable.reject(\n new Error(\n 'experimental_prefetchInRender feature flag is not enabled',\n ),\n )\n }\n }\n return Reflect.get(target, key)\n },\n })\n }\n\n trackProp(key: keyof QueryObserverResult) {\n this.#trackedProps.add(key)\n }\n\n getCurrentQuery(): Query {\n return this.#currentQuery\n }\n\n refetch({ ...options }: RefetchOptions = {}): Promise<\n QueryObserverResult\n > {\n return this.fetch({\n ...options,\n })\n }\n\n fetchOptimistic(\n options: QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n ): Promise> {\n const defaultedOptions = this.#client.defaultQueryOptions(options)\n\n const query = this.#client\n .getQueryCache()\n .build(this.#client, defaultedOptions)\n\n return query.fetch().then(() => this.createResult(query, defaultedOptions))\n }\n\n protected fetch(\n fetchOptions: ObserverFetchOptions,\n ): Promise> {\n return this.#executeFetch({\n ...fetchOptions,\n cancelRefetch: fetchOptions.cancelRefetch ?? true,\n }).then(() => {\n this.updateResult()\n return this.#currentResult\n })\n }\n\n #executeFetch(\n fetchOptions?: Omit,\n ): Promise {\n // Make sure we reference the latest query as the current one might have been removed\n this.#updateQuery()\n\n // Fetch\n let promise: Promise = this.#currentQuery.fetch(\n this.options,\n fetchOptions,\n )\n\n if (!fetchOptions?.throwOnError) {\n promise = promise.catch(noop)\n }\n\n return promise\n }\n\n #updateStaleTimeout(): void {\n this.#clearStaleTimeout()\n const staleTime = resolveStaleTime(\n this.options.staleTime,\n this.#currentQuery,\n )\n\n if (isServer || this.#currentResult.isStale || !isValidTimeout(staleTime)) {\n return\n }\n\n const time = timeUntilStale(this.#currentResult.dataUpdatedAt, staleTime)\n\n // The timeout is sometimes triggered 1 ms before the stale time expiration.\n // To mitigate this issue we always add 1 ms to the timeout.\n const timeout = time + 1\n\n this.#staleTimeoutId = timeoutManager.setTimeout(() => {\n if (!this.#currentResult.isStale) {\n this.updateResult()\n }\n }, timeout)\n }\n\n #computeRefetchInterval() {\n return (\n (typeof this.options.refetchInterval === 'function'\n ? this.options.refetchInterval(this.#currentQuery)\n : this.options.refetchInterval) ?? false\n )\n }\n\n #updateRefetchInterval(nextInterval: number | false): void {\n this.#clearRefetchInterval()\n\n this.#currentRefetchInterval = nextInterval\n\n if (\n isServer ||\n resolveEnabled(this.options.enabled, this.#currentQuery) === false ||\n !isValidTimeout(this.#currentRefetchInterval) ||\n this.#currentRefetchInterval === 0\n ) {\n return\n }\n\n this.#refetchIntervalId = timeoutManager.setInterval(() => {\n if (\n this.options.refetchIntervalInBackground ||\n focusManager.isFocused()\n ) {\n this.#executeFetch()\n }\n }, this.#currentRefetchInterval)\n }\n\n #updateTimers(): void {\n this.#updateStaleTimeout()\n this.#updateRefetchInterval(this.#computeRefetchInterval())\n }\n\n #clearStaleTimeout(): void {\n if (this.#staleTimeoutId) {\n timeoutManager.clearTimeout(this.#staleTimeoutId)\n this.#staleTimeoutId = undefined\n }\n }\n\n #clearRefetchInterval(): void {\n if (this.#refetchIntervalId) {\n timeoutManager.clearInterval(this.#refetchIntervalId)\n this.#refetchIntervalId = undefined\n }\n }\n\n protected createResult(\n query: Query,\n options: QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n ): QueryObserverResult {\n const prevQuery = this.#currentQuery\n const prevOptions = this.options\n const prevResult = this.#currentResult as\n | QueryObserverResult\n | undefined\n const prevResultState = this.#currentResultState\n const prevResultOptions = this.#currentResultOptions\n const queryChange = query !== prevQuery\n const queryInitialState = queryChange\n ? query.state\n : this.#currentQueryInitialState\n\n const { state } = query\n let newState = { ...state }\n let isPlaceholderData = false\n let data: TData | undefined\n\n // Optimistically set result in fetching state if needed\n if (options._optimisticResults) {\n const mounted = this.hasListeners()\n\n const fetchOnMount = !mounted && shouldFetchOnMount(query, options)\n\n const fetchOptionally =\n mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions)\n\n if (fetchOnMount || fetchOptionally) {\n newState = {\n ...newState,\n ...fetchState(state.data, query.options),\n }\n }\n if (options._optimisticResults === 'isRestoring') {\n newState.fetchStatus = 'idle'\n }\n }\n\n let { error, errorUpdatedAt, status } = newState\n\n // Per default, use query data\n data = newState.data as unknown as TData\n let skipSelect = false\n\n // use placeholderData if needed\n if (\n options.placeholderData !== undefined &&\n data === undefined &&\n status === 'pending'\n ) {\n let placeholderData\n\n // Memoize placeholder data\n if (\n prevResult?.isPlaceholderData &&\n options.placeholderData === prevResultOptions?.placeholderData\n ) {\n placeholderData = prevResult.data\n // we have to skip select when reading this memoization\n // because prevResult.data is already \"selected\"\n skipSelect = true\n } else {\n // compute placeholderData\n placeholderData =\n typeof options.placeholderData === 'function'\n ? (\n options.placeholderData as unknown as PlaceholderDataFunction\n )(\n this.#lastQueryWithDefinedData?.state.data,\n this.#lastQueryWithDefinedData as any,\n )\n : options.placeholderData\n }\n\n if (placeholderData !== undefined) {\n status = 'success'\n data = replaceData(\n prevResult?.data,\n placeholderData as unknown,\n options,\n ) as TData\n isPlaceholderData = true\n }\n }\n\n // Select data if needed\n // this also runs placeholderData through the select function\n if (options.select && data !== undefined && !skipSelect) {\n // Memoize select result\n if (\n prevResult &&\n data === prevResultState?.data &&\n options.select === this.#selectFn\n ) {\n data = this.#selectResult\n } else {\n try {\n this.#selectFn = options.select\n data = options.select(data as any)\n data = replaceData(prevResult?.data, data, options)\n this.#selectResult = data\n this.#selectError = null\n } catch (selectError) {\n this.#selectError = selectError as TError\n }\n }\n }\n\n if (this.#selectError) {\n error = this.#selectError\n data = this.#selectResult\n errorUpdatedAt = Date.now()\n status = 'error'\n }\n\n const isFetching = newState.fetchStatus === 'fetching'\n const isPending = status === 'pending'\n const isError = status === 'error'\n\n const isLoading = isPending && isFetching\n const hasData = data !== undefined\n\n const result: QueryObserverBaseResult = {\n status,\n fetchStatus: newState.fetchStatus,\n isPending,\n isSuccess: status === 'success',\n isError,\n isInitialLoading: isLoading,\n isLoading,\n data,\n dataUpdatedAt: newState.dataUpdatedAt,\n error,\n errorUpdatedAt,\n failureCount: newState.fetchFailureCount,\n failureReason: newState.fetchFailureReason,\n errorUpdateCount: newState.errorUpdateCount,\n isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0,\n isFetchedAfterMount:\n newState.dataUpdateCount > queryInitialState.dataUpdateCount ||\n newState.errorUpdateCount > queryInitialState.errorUpdateCount,\n isFetching,\n isRefetching: isFetching && !isPending,\n isLoadingError: isError && !hasData,\n isPaused: newState.fetchStatus === 'paused',\n isPlaceholderData,\n isRefetchError: isError && hasData,\n isStale: isStale(query, options),\n refetch: this.refetch,\n promise: this.#currentThenable,\n isEnabled: resolveEnabled(options.enabled, query) !== false,\n }\n\n const nextResult = result as QueryObserverResult\n\n if (this.options.experimental_prefetchInRender) {\n const hasResultData = nextResult.data !== undefined\n const isErrorWithoutData = nextResult.status === 'error' && !hasResultData\n const finalizeThenableIfPossible = (thenable: PendingThenable) => {\n if (isErrorWithoutData) {\n thenable.reject(nextResult.error)\n } else if (hasResultData) {\n thenable.resolve(nextResult.data as TData)\n }\n }\n\n /**\n * Create a new thenable and result promise when the results have changed\n */\n const recreateThenable = () => {\n const pending =\n (this.#currentThenable =\n nextResult.promise =\n pendingThenable())\n\n finalizeThenableIfPossible(pending)\n }\n\n const prevThenable = this.#currentThenable\n switch (prevThenable.status) {\n case 'pending':\n // Finalize the previous thenable if it was pending\n // and we are still observing the same query\n if (query.queryHash === prevQuery.queryHash) {\n finalizeThenableIfPossible(prevThenable)\n }\n break\n case 'fulfilled':\n if (isErrorWithoutData || nextResult.data !== prevThenable.value) {\n recreateThenable()\n }\n break\n case 'rejected':\n if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) {\n recreateThenable()\n }\n break\n }\n }\n\n return nextResult\n }\n\n updateResult(): void {\n const prevResult = this.#currentResult as\n | QueryObserverResult\n | undefined\n\n const nextResult = this.createResult(this.#currentQuery, this.options)\n\n this.#currentResultState = this.#currentQuery.state\n this.#currentResultOptions = this.options\n\n if (this.#currentResultState.data !== undefined) {\n this.#lastQueryWithDefinedData = this.#currentQuery\n }\n\n // Only notify and update result if something has changed\n if (shallowEqualObjects(nextResult, prevResult)) {\n return\n }\n\n this.#currentResult = nextResult\n\n const shouldNotifyListeners = (): boolean => {\n if (!prevResult) {\n return true\n }\n\n const { notifyOnChangeProps } = this.options\n const notifyOnChangePropsValue =\n typeof notifyOnChangeProps === 'function'\n ? notifyOnChangeProps()\n : notifyOnChangeProps\n\n if (\n notifyOnChangePropsValue === 'all' ||\n (!notifyOnChangePropsValue && !this.#trackedProps.size)\n ) {\n return true\n }\n\n const includedProps = new Set(\n notifyOnChangePropsValue ?? this.#trackedProps,\n )\n\n if (this.options.throwOnError) {\n includedProps.add('error')\n }\n\n return Object.keys(this.#currentResult).some((key) => {\n const typedKey = key as keyof QueryObserverResult\n const changed = this.#currentResult[typedKey] !== prevResult[typedKey]\n\n return changed && includedProps.has(typedKey)\n })\n }\n\n this.#notify({ listeners: shouldNotifyListeners() })\n }\n\n #updateQuery(): void {\n const query = this.#client.getQueryCache().build(this.#client, this.options)\n\n if (query === this.#currentQuery) {\n return\n }\n\n const prevQuery = this.#currentQuery as\n | Query\n | undefined\n this.#currentQuery = query\n this.#currentQueryInitialState = query.state\n\n if (this.hasListeners()) {\n prevQuery?.removeObserver(this)\n query.addObserver(this)\n }\n }\n\n onQueryUpdate(): void {\n this.updateResult()\n\n if (this.hasListeners()) {\n this.#updateTimers()\n }\n }\n\n #notify(notifyOptions: { listeners: boolean }): void {\n notifyManager.batch(() => {\n // First, trigger the listeners\n if (notifyOptions.listeners) {\n this.listeners.forEach((listener) => {\n listener(this.#currentResult)\n })\n }\n\n // Then the cache listeners\n this.#client.getQueryCache().notify({\n query: this.#currentQuery,\n type: 'observerResultsUpdated',\n })\n })\n }\n}\n\nfunction shouldLoadOnMount(\n query: Query,\n options: QueryObserverOptions,\n): boolean {\n return (\n resolveEnabled(options.enabled, query) !== false &&\n query.state.data === undefined &&\n !(query.state.status === 'error' && options.retryOnMount === false)\n )\n}\n\nfunction shouldFetchOnMount(\n query: Query,\n options: QueryObserverOptions,\n): boolean {\n return (\n shouldLoadOnMount(query, options) ||\n (query.state.data !== undefined &&\n shouldFetchOn(query, options, options.refetchOnMount))\n )\n}\n\nfunction shouldFetchOn(\n query: Query,\n options: QueryObserverOptions,\n field: (typeof options)['refetchOnMount'] &\n (typeof options)['refetchOnWindowFocus'] &\n (typeof options)['refetchOnReconnect'],\n) {\n if (\n resolveEnabled(options.enabled, query) !== false &&\n resolveStaleTime(options.staleTime, query) !== 'static'\n ) {\n const value = typeof field === 'function' ? field(query) : field\n\n return value === 'always' || (value !== false && isStale(query, options))\n }\n return false\n}\n\nfunction shouldFetchOptionally(\n query: Query,\n prevQuery: Query,\n options: QueryObserverOptions,\n prevOptions: QueryObserverOptions,\n): boolean {\n return (\n (query !== prevQuery ||\n resolveEnabled(prevOptions.enabled, query) === false) &&\n (!options.suspense || query.state.status !== 'error') &&\n isStale(query, options)\n )\n}\n\nfunction isStale(\n query: Query,\n options: QueryObserverOptions,\n): boolean {\n return (\n resolveEnabled(options.enabled, query) !== false &&\n query.isStaleByTime(resolveStaleTime(options.staleTime, query))\n )\n}\n\n// this function would decide if we will update the observer's 'current'\n// properties after an optimistic reading via getOptimisticResult\nfunction shouldAssignObserverCurrentProperties<\n TQueryFnData = unknown,\n TError = unknown,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n observer: QueryObserver,\n optimisticResult: QueryObserverResult,\n) {\n // if the newly created result isn't what the observer is holding as current,\n // then we'll need to update the properties as well\n if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {\n return true\n }\n\n // basically, just keep previous properties if nothing changed\n return false\n}\n", "import {\n addConsumeAwareSignal,\n addToEnd,\n addToStart,\n ensureQueryFn,\n} from './utils'\nimport type { QueryBehavior } from './query'\nimport type {\n InfiniteData,\n InfiniteQueryPageParamsOptions,\n OmitKeyof,\n QueryFunctionContext,\n QueryKey,\n} from './types'\n\nexport function infiniteQueryBehavior(\n pages?: number,\n): QueryBehavior> {\n return {\n onFetch: (context, query) => {\n const options = context.options as InfiniteQueryPageParamsOptions\n const direction = context.fetchOptions?.meta?.fetchMore?.direction\n const oldPages = context.state.data?.pages || []\n const oldPageParams = context.state.data?.pageParams || []\n let result: InfiniteData = { pages: [], pageParams: [] }\n let currentPage = 0\n\n const fetchFn = async () => {\n let cancelled = false\n const addSignalProperty = (object: unknown) => {\n addConsumeAwareSignal(\n object,\n () => context.signal,\n () => (cancelled = true),\n )\n }\n\n const queryFn = ensureQueryFn(context.options, context.fetchOptions)\n\n // Create function to fetch a page\n const fetchPage = async (\n data: InfiniteData,\n param: unknown,\n previous?: boolean,\n ): Promise> => {\n if (cancelled) {\n return Promise.reject()\n }\n\n if (param == null && data.pages.length) {\n return Promise.resolve(data)\n }\n\n const createQueryFnContext = () => {\n const queryFnContext: OmitKeyof<\n QueryFunctionContext,\n 'signal'\n > = {\n client: context.client,\n queryKey: context.queryKey,\n pageParam: param,\n direction: previous ? 'backward' : 'forward',\n meta: context.options.meta,\n }\n addSignalProperty(queryFnContext)\n return queryFnContext as QueryFunctionContext\n }\n\n const queryFnContext = createQueryFnContext()\n\n const page = await queryFn(queryFnContext)\n\n const { maxPages } = context.options\n const addTo = previous ? addToStart : addToEnd\n\n return {\n pages: addTo(data.pages, page, maxPages),\n pageParams: addTo(data.pageParams, param, maxPages),\n }\n }\n\n // fetch next / previous page?\n if (direction && oldPages.length) {\n const previous = direction === 'backward'\n const pageParamFn = previous ? getPreviousPageParam : getNextPageParam\n const oldData = {\n pages: oldPages,\n pageParams: oldPageParams,\n }\n const param = pageParamFn(options, oldData)\n\n result = await fetchPage(oldData, param, previous)\n } else {\n const remainingPages = pages ?? oldPages.length\n\n // Fetch all pages\n do {\n const param =\n currentPage === 0\n ? (oldPageParams[0] ?? options.initialPageParam)\n : getNextPageParam(options, result)\n if (currentPage > 0 && param == null) {\n break\n }\n result = await fetchPage(result, param)\n currentPage++\n } while (currentPage < remainingPages)\n }\n\n return result\n }\n if (context.options.persister) {\n context.fetchFn = () => {\n return context.options.persister?.(\n fetchFn as any,\n {\n client: context.client,\n queryKey: context.queryKey,\n meta: context.options.meta,\n signal: context.signal,\n },\n query,\n )\n }\n } else {\n context.fetchFn = fetchFn\n }\n },\n }\n}\n\nfunction getNextPageParam(\n options: InfiniteQueryPageParamsOptions,\n { pages, pageParams }: InfiniteData,\n): unknown | undefined {\n const lastIndex = pages.length - 1\n return pages.length > 0\n ? options.getNextPageParam(\n pages[lastIndex],\n pages,\n pageParams[lastIndex],\n pageParams,\n )\n : undefined\n}\n\nfunction getPreviousPageParam(\n options: InfiniteQueryPageParamsOptions,\n { pages, pageParams }: InfiniteData,\n): unknown | undefined {\n return pages.length > 0\n ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams)\n : undefined\n}\n\n/**\n * Checks if there is a next page.\n */\nexport function hasNextPage(\n options: InfiniteQueryPageParamsOptions,\n data?: InfiniteData,\n): boolean {\n if (!data) return false\n return getNextPageParam(options, data) != null\n}\n\n/**\n * Checks if there is a previous page.\n */\nexport function hasPreviousPage(\n options: InfiniteQueryPageParamsOptions,\n data?: InfiniteData,\n): boolean {\n if (!data || !options.getPreviousPageParam) return false\n return getPreviousPageParam(options, data) != null\n}\n", "import { QueryObserver } from './queryObserver'\nimport {\n hasNextPage,\n hasPreviousPage,\n infiniteQueryBehavior,\n} from './infiniteQueryBehavior'\nimport type { Subscribable } from './subscribable'\nimport type {\n DefaultError,\n DefaultedInfiniteQueryObserverOptions,\n FetchNextPageOptions,\n FetchPreviousPageOptions,\n InfiniteData,\n InfiniteQueryObserverBaseResult,\n InfiniteQueryObserverOptions,\n InfiniteQueryObserverResult,\n QueryKey,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Query } from './query'\n\ntype InfiniteQueryObserverListener = (\n result: InfiniteQueryObserverResult,\n) => void\n\nexport class InfiniteQueryObserver<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> extends QueryObserver<\n TQueryFnData,\n TError,\n TData,\n InfiniteData,\n TQueryKey\n> {\n // Type override\n subscribe!: Subscribable<\n InfiniteQueryObserverListener\n >['subscribe']\n\n // Type override\n getCurrentResult!: ReplaceReturnType<\n QueryObserver<\n TQueryFnData,\n TError,\n TData,\n InfiniteData,\n TQueryKey\n >['getCurrentResult'],\n InfiniteQueryObserverResult\n >\n\n // Type override\n protected fetch!: ReplaceReturnType<\n QueryObserver<\n TQueryFnData,\n TError,\n TData,\n InfiniteData,\n TQueryKey\n >['fetch'],\n Promise>\n >\n\n constructor(\n client: QueryClient,\n options: InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ) {\n super(client, options)\n }\n\n protected bindMethods(): void {\n super.bindMethods()\n this.fetchNextPage = this.fetchNextPage.bind(this)\n this.fetchPreviousPage = this.fetchPreviousPage.bind(this)\n }\n\n setOptions(\n options: InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ): void {\n super.setOptions({\n ...options,\n behavior: infiniteQueryBehavior(),\n })\n }\n\n getOptimisticResult(\n options: DefaultedInfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ): InfiniteQueryObserverResult {\n options.behavior = infiniteQueryBehavior()\n return super.getOptimisticResult(options) as InfiniteQueryObserverResult<\n TData,\n TError\n >\n }\n\n fetchNextPage(\n options?: FetchNextPageOptions,\n ): Promise> {\n return this.fetch({\n ...options,\n meta: {\n fetchMore: { direction: 'forward' },\n },\n })\n }\n\n fetchPreviousPage(\n options?: FetchPreviousPageOptions,\n ): Promise> {\n return this.fetch({\n ...options,\n meta: {\n fetchMore: { direction: 'backward' },\n },\n })\n }\n\n protected createResult(\n query: Query<\n TQueryFnData,\n TError,\n InfiniteData,\n TQueryKey\n >,\n options: InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ): InfiniteQueryObserverResult {\n const { state } = query\n const parentResult = super.createResult(query, options)\n\n const { isFetching, isRefetching, isError, isRefetchError } = parentResult\n const fetchDirection = state.fetchMeta?.fetchMore?.direction\n\n const isFetchNextPageError = isError && fetchDirection === 'forward'\n const isFetchingNextPage = isFetching && fetchDirection === 'forward'\n\n const isFetchPreviousPageError = isError && fetchDirection === 'backward'\n const isFetchingPreviousPage = isFetching && fetchDirection === 'backward'\n\n const result: InfiniteQueryObserverBaseResult = {\n ...parentResult,\n fetchNextPage: this.fetchNextPage,\n fetchPreviousPage: this.fetchPreviousPage,\n hasNextPage: hasNextPage(options, state.data),\n hasPreviousPage: hasPreviousPage(options, state.data),\n isFetchNextPageError,\n isFetchingNextPage,\n isFetchPreviousPageError,\n isFetchingPreviousPage,\n isRefetchError:\n isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,\n isRefetching:\n isRefetching && !isFetchingNextPage && !isFetchingPreviousPage,\n }\n\n return result as InfiniteQueryObserverResult\n }\n}\n\ntype ReplaceReturnType<\n TFunction extends (...args: Array) => unknown,\n TReturn,\n> = (...args: Parameters) => TReturn\n", "import { notifyManager } from './notifyManager'\nimport { Removable } from './removable'\nimport { createRetryer } from './retryer'\nimport type {\n DefaultError,\n MutationFunctionContext,\n MutationMeta,\n MutationOptions,\n MutationStatus,\n} from './types'\nimport type { MutationCache } from './mutationCache'\nimport type { MutationObserver } from './mutationObserver'\nimport type { Retryer } from './retryer'\nimport type { QueryClient } from './queryClient'\n\n// TYPES\n\ninterface MutationConfig {\n client: QueryClient\n mutationId: number\n mutationCache: MutationCache\n options: MutationOptions\n state?: MutationState\n}\n\nexport interface MutationState<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> {\n context: TOnMutateResult | undefined\n data: TData | undefined\n error: TError | null\n failureCount: number\n failureReason: TError | null\n isPaused: boolean\n status: MutationStatus\n variables: TVariables | undefined\n submittedAt: number\n}\n\ninterface FailedAction {\n type: 'failed'\n failureCount: number\n error: TError | null\n}\n\ninterface PendingAction {\n type: 'pending'\n isPaused: boolean\n variables?: TVariables\n context?: TOnMutateResult\n}\n\ninterface SuccessAction {\n type: 'success'\n data: TData\n}\n\ninterface ErrorAction {\n type: 'error'\n error: TError\n}\n\ninterface PauseAction {\n type: 'pause'\n}\n\ninterface ContinueAction {\n type: 'continue'\n}\n\nexport type Action =\n | ContinueAction\n | ErrorAction\n | FailedAction\n | PendingAction\n | PauseAction\n | SuccessAction\n\n// CLASS\n\nexport class Mutation<\n TData = unknown,\n TError = DefaultError,\n TVariables = unknown,\n TOnMutateResult = unknown,\n> extends Removable {\n state: MutationState\n options!: MutationOptions\n readonly mutationId: number\n\n #client: QueryClient\n #observers: Array<\n MutationObserver\n >\n #mutationCache: MutationCache\n #retryer?: Retryer\n\n constructor(\n config: MutationConfig,\n ) {\n super()\n\n this.#client = config.client\n this.mutationId = config.mutationId\n this.#mutationCache = config.mutationCache\n this.#observers = []\n this.state = config.state || getDefaultState()\n\n this.setOptions(config.options)\n this.scheduleGc()\n }\n\n setOptions(\n options: MutationOptions,\n ): void {\n this.options = options\n\n this.updateGcTime(this.options.gcTime)\n }\n\n get meta(): MutationMeta | undefined {\n return this.options.meta\n }\n\n addObserver(observer: MutationObserver): void {\n if (!this.#observers.includes(observer)) {\n this.#observers.push(observer)\n\n // Stop the mutation from being garbage collected\n this.clearGcTimeout()\n\n this.#mutationCache.notify({\n type: 'observerAdded',\n mutation: this,\n observer,\n })\n }\n }\n\n removeObserver(observer: MutationObserver): void {\n this.#observers = this.#observers.filter((x) => x !== observer)\n\n this.scheduleGc()\n\n this.#mutationCache.notify({\n type: 'observerRemoved',\n mutation: this,\n observer,\n })\n }\n\n protected optionalRemove() {\n if (!this.#observers.length) {\n if (this.state.status === 'pending') {\n this.scheduleGc()\n } else {\n this.#mutationCache.remove(this)\n }\n }\n }\n\n continue(): Promise {\n return (\n this.#retryer?.continue() ??\n // continuing a mutation assumes that variables are set, mutation must have been dehydrated before\n this.execute(this.state.variables!)\n )\n }\n\n async execute(variables: TVariables): Promise {\n const onContinue = () => {\n this.#dispatch({ type: 'continue' })\n }\n\n const mutationFnContext = {\n client: this.#client,\n meta: this.options.meta,\n mutationKey: this.options.mutationKey,\n } satisfies MutationFunctionContext\n\n this.#retryer = createRetryer({\n fn: () => {\n if (!this.options.mutationFn) {\n return Promise.reject(new Error('No mutationFn found'))\n }\n\n return this.options.mutationFn(variables, mutationFnContext)\n },\n onFail: (failureCount, error) => {\n this.#dispatch({ type: 'failed', failureCount, error })\n },\n onPause: () => {\n this.#dispatch({ type: 'pause' })\n },\n onContinue,\n retry: this.options.retry ?? 0,\n retryDelay: this.options.retryDelay,\n networkMode: this.options.networkMode,\n canRun: () => this.#mutationCache.canRun(this),\n })\n\n const restored = this.state.status === 'pending'\n const isPaused = !this.#retryer.canStart()\n\n try {\n if (restored) {\n // Dispatch continue action to unpause restored mutation\n onContinue()\n } else {\n this.#dispatch({ type: 'pending', variables, isPaused })\n // Notify cache callback\n if (this.#mutationCache.config.onMutate) {\n await this.#mutationCache.config.onMutate(\n variables,\n this as Mutation,\n mutationFnContext,\n )\n }\n const context = await this.options.onMutate?.(\n variables,\n mutationFnContext,\n )\n if (context !== this.state.context) {\n this.#dispatch({\n type: 'pending',\n context,\n variables,\n isPaused,\n })\n }\n }\n const data = await this.#retryer.start()\n\n // Notify cache callback\n await this.#mutationCache.config.onSuccess?.(\n data,\n variables,\n this.state.context,\n this as Mutation,\n mutationFnContext,\n )\n\n await this.options.onSuccess?.(\n data,\n variables,\n this.state.context!,\n mutationFnContext,\n )\n\n // Notify cache callback\n await this.#mutationCache.config.onSettled?.(\n data,\n null,\n this.state.variables,\n this.state.context,\n this as Mutation,\n mutationFnContext,\n )\n\n await this.options.onSettled?.(\n data,\n null,\n variables,\n this.state.context,\n mutationFnContext,\n )\n\n this.#dispatch({ type: 'success', data })\n return data\n } catch (error) {\n try {\n // Notify cache callback\n await this.#mutationCache.config.onError?.(\n error as any,\n variables,\n this.state.context,\n this as Mutation,\n mutationFnContext,\n )\n } catch (e) {\n void Promise.reject(e)\n }\n\n try {\n await this.options.onError?.(\n error as TError,\n variables,\n this.state.context,\n mutationFnContext,\n )\n } catch (e) {\n void Promise.reject(e)\n }\n\n try {\n // Notify cache callback\n await this.#mutationCache.config.onSettled?.(\n undefined,\n error as any,\n this.state.variables,\n this.state.context,\n this as Mutation,\n mutationFnContext,\n )\n } catch (e) {\n void Promise.reject(e)\n }\n\n try {\n await this.options.onSettled?.(\n undefined,\n error as TError,\n variables,\n this.state.context,\n mutationFnContext,\n )\n } catch (e) {\n void Promise.reject(e)\n }\n\n this.#dispatch({ type: 'error', error: error as TError })\n throw error\n } finally {\n this.#mutationCache.runNext(this)\n }\n }\n\n #dispatch(action: Action): void {\n const reducer = (\n state: MutationState,\n ): MutationState => {\n switch (action.type) {\n case 'failed':\n return {\n ...state,\n failureCount: action.failureCount,\n failureReason: action.error,\n }\n case 'pause':\n return {\n ...state,\n isPaused: true,\n }\n case 'continue':\n return {\n ...state,\n isPaused: false,\n }\n case 'pending':\n return {\n ...state,\n context: action.context,\n data: undefined,\n failureCount: 0,\n failureReason: null,\n error: null,\n isPaused: action.isPaused,\n status: 'pending',\n variables: action.variables,\n submittedAt: Date.now(),\n }\n case 'success':\n return {\n ...state,\n data: action.data,\n failureCount: 0,\n failureReason: null,\n error: null,\n status: 'success',\n isPaused: false,\n }\n case 'error':\n return {\n ...state,\n data: undefined,\n error: action.error,\n failureCount: state.failureCount + 1,\n failureReason: action.error,\n isPaused: false,\n status: 'error',\n }\n }\n }\n this.state = reducer(this.state)\n\n notifyManager.batch(() => {\n this.#observers.forEach((observer) => {\n observer.onMutationUpdate(action)\n })\n this.#mutationCache.notify({\n mutation: this,\n type: 'updated',\n action,\n })\n })\n }\n}\n\nexport function getDefaultState<\n TData,\n TError,\n TVariables,\n TOnMutateResult,\n>(): MutationState {\n return {\n context: undefined,\n data: undefined,\n error: null,\n failureCount: 0,\n failureReason: null,\n isPaused: false,\n status: 'idle',\n variables: undefined,\n submittedAt: 0,\n }\n}\n", "import { notifyManager } from './notifyManager'\nimport { Mutation } from './mutation'\nimport { matchMutation, noop } from './utils'\nimport { Subscribable } from './subscribable'\nimport type { MutationObserver } from './mutationObserver'\nimport type {\n DefaultError,\n MutationFunctionContext,\n MutationOptions,\n NotifyEvent,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { Action, MutationState } from './mutation'\nimport type { MutationFilters } from './utils'\n\n// TYPES\n\ninterface MutationCacheConfig {\n onError?: (\n error: DefaultError,\n variables: unknown,\n onMutateResult: unknown,\n mutation: Mutation,\n context: MutationFunctionContext,\n ) => Promise | unknown\n onSuccess?: (\n data: unknown,\n variables: unknown,\n onMutateResult: unknown,\n mutation: Mutation,\n context: MutationFunctionContext,\n ) => Promise | unknown\n onMutate?: (\n variables: unknown,\n mutation: Mutation,\n context: MutationFunctionContext,\n ) => Promise | unknown\n onSettled?: (\n data: unknown | undefined,\n error: DefaultError | null,\n variables: unknown,\n onMutateResult: unknown,\n mutation: Mutation,\n context: MutationFunctionContext,\n ) => Promise | unknown\n}\n\ninterface NotifyEventMutationAdded extends NotifyEvent {\n type: 'added'\n mutation: Mutation\n}\ninterface NotifyEventMutationRemoved extends NotifyEvent {\n type: 'removed'\n mutation: Mutation\n}\n\ninterface NotifyEventMutationObserverAdded extends NotifyEvent {\n type: 'observerAdded'\n mutation: Mutation\n observer: MutationObserver\n}\n\ninterface NotifyEventMutationObserverRemoved extends NotifyEvent {\n type: 'observerRemoved'\n mutation: Mutation\n observer: MutationObserver\n}\n\ninterface NotifyEventMutationObserverOptionsUpdated extends NotifyEvent {\n type: 'observerOptionsUpdated'\n mutation?: Mutation\n observer: MutationObserver\n}\n\ninterface NotifyEventMutationUpdated extends NotifyEvent {\n type: 'updated'\n mutation: Mutation\n action: Action\n}\n\nexport type MutationCacheNotifyEvent =\n | NotifyEventMutationAdded\n | NotifyEventMutationRemoved\n | NotifyEventMutationObserverAdded\n | NotifyEventMutationObserverRemoved\n | NotifyEventMutationObserverOptionsUpdated\n | NotifyEventMutationUpdated\n\ntype MutationCacheListener = (event: MutationCacheNotifyEvent) => void\n\n// CLASS\n\nexport class MutationCache extends Subscribable {\n #mutations: Set>\n #scopes: Map>>\n #mutationId: number\n\n constructor(public config: MutationCacheConfig = {}) {\n super()\n this.#mutations = new Set()\n this.#scopes = new Map()\n this.#mutationId = 0\n }\n\n build(\n client: QueryClient,\n options: MutationOptions,\n state?: MutationState,\n ): Mutation {\n const mutation = new Mutation({\n client,\n mutationCache: this,\n mutationId: ++this.#mutationId,\n options: client.defaultMutationOptions(options),\n state,\n })\n\n this.add(mutation)\n\n return mutation\n }\n\n add(mutation: Mutation): void {\n this.#mutations.add(mutation)\n const scope = scopeFor(mutation)\n if (typeof scope === 'string') {\n const scopedMutations = this.#scopes.get(scope)\n if (scopedMutations) {\n scopedMutations.push(mutation)\n } else {\n this.#scopes.set(scope, [mutation])\n }\n }\n this.notify({ type: 'added', mutation })\n }\n\n remove(mutation: Mutation): void {\n if (this.#mutations.delete(mutation)) {\n const scope = scopeFor(mutation)\n if (typeof scope === 'string') {\n const scopedMutations = this.#scopes.get(scope)\n if (scopedMutations) {\n if (scopedMutations.length > 1) {\n const index = scopedMutations.indexOf(mutation)\n if (index !== -1) {\n scopedMutations.splice(index, 1)\n }\n } else if (scopedMutations[0] === mutation) {\n this.#scopes.delete(scope)\n }\n }\n }\n }\n\n // Currently we notify the removal even if the mutation was already removed.\n // Consider making this an error or not notifying of the removal depending on the desired semantics.\n this.notify({ type: 'removed', mutation })\n }\n\n canRun(mutation: Mutation): boolean {\n const scope = scopeFor(mutation)\n if (typeof scope === 'string') {\n const mutationsWithSameScope = this.#scopes.get(scope)\n const firstPendingMutation = mutationsWithSameScope?.find(\n (m) => m.state.status === 'pending',\n )\n // we can run if there is no current pending mutation (start use-case)\n // or if WE are the first pending mutation (continue use-case)\n return !firstPendingMutation || firstPendingMutation === mutation\n } else {\n // For unscoped mutations there are never any pending mutations in front of the\n // current mutation\n return true\n }\n }\n\n runNext(mutation: Mutation): Promise {\n const scope = scopeFor(mutation)\n if (typeof scope === 'string') {\n const foundMutation = this.#scopes\n .get(scope)\n ?.find((m) => m !== mutation && m.state.isPaused)\n\n return foundMutation?.continue() ?? Promise.resolve()\n } else {\n return Promise.resolve()\n }\n }\n\n clear(): void {\n notifyManager.batch(() => {\n this.#mutations.forEach((mutation) => {\n this.notify({ type: 'removed', mutation })\n })\n this.#mutations.clear()\n this.#scopes.clear()\n })\n }\n\n getAll(): Array {\n return Array.from(this.#mutations)\n }\n\n find<\n TData = unknown,\n TError = DefaultError,\n TVariables = any,\n TOnMutateResult = unknown,\n >(\n filters: MutationFilters,\n ): Mutation | undefined {\n const defaultedFilters = { exact: true, ...filters }\n\n return this.getAll().find((mutation) =>\n matchMutation(defaultedFilters, mutation),\n ) as Mutation | undefined\n }\n\n findAll(filters: MutationFilters = {}): Array {\n return this.getAll().filter((mutation) => matchMutation(filters, mutation))\n }\n\n notify(event: MutationCacheNotifyEvent) {\n notifyManager.batch(() => {\n this.listeners.forEach((listener) => {\n listener(event)\n })\n })\n }\n\n resumePausedMutations(): Promise {\n const pausedMutations = this.getAll().filter((x) => x.state.isPaused)\n\n return notifyManager.batch(() =>\n Promise.all(\n pausedMutations.map((mutation) => mutation.continue().catch(noop)),\n ),\n )\n }\n}\n\nfunction scopeFor(mutation: Mutation) {\n return mutation.options.scope?.id\n}\n", "import { getDefaultState } from './mutation'\nimport { notifyManager } from './notifyManager'\nimport { Subscribable } from './subscribable'\nimport { hashKey, shallowEqualObjects } from './utils'\nimport type { QueryClient } from './queryClient'\nimport type {\n DefaultError,\n MutateOptions,\n MutationFunctionContext,\n MutationObserverOptions,\n MutationObserverResult,\n} from './types'\nimport type { Action, Mutation } from './mutation'\n\n// TYPES\n\ntype MutationObserverListener = (\n result: MutationObserverResult,\n) => void\n\n// CLASS\n\nexport class MutationObserver<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends Subscribable<\n MutationObserverListener\n> {\n options!: MutationObserverOptions\n\n #client: QueryClient\n #currentResult: MutationObserverResult<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n > = undefined!\n #currentMutation?: Mutation\n #mutateOptions?: MutateOptions\n\n constructor(\n client: QueryClient,\n options: MutationObserverOptions<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n >,\n ) {\n super()\n\n this.#client = client\n this.setOptions(options)\n this.bindMethods()\n this.#updateResult()\n }\n\n protected bindMethods(): void {\n this.mutate = this.mutate.bind(this)\n this.reset = this.reset.bind(this)\n }\n\n setOptions(\n options: MutationObserverOptions<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n >,\n ) {\n const prevOptions = this.options as\n | MutationObserverOptions\n | undefined\n this.options = this.#client.defaultMutationOptions(options)\n if (!shallowEqualObjects(this.options, prevOptions)) {\n this.#client.getMutationCache().notify({\n type: 'observerOptionsUpdated',\n mutation: this.#currentMutation,\n observer: this,\n })\n }\n\n if (\n prevOptions?.mutationKey &&\n this.options.mutationKey &&\n hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)\n ) {\n this.reset()\n } else if (this.#currentMutation?.state.status === 'pending') {\n this.#currentMutation.setOptions(this.options)\n }\n }\n\n protected onUnsubscribe(): void {\n if (!this.hasListeners()) {\n this.#currentMutation?.removeObserver(this)\n }\n }\n\n onMutationUpdate(\n action: Action,\n ): void {\n this.#updateResult()\n\n this.#notify(action)\n }\n\n getCurrentResult(): MutationObserverResult<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n > {\n return this.#currentResult\n }\n\n reset(): void {\n // reset needs to remove the observer from the mutation because there is no way to \"get it back\"\n // another mutate call will yield a new mutation!\n this.#currentMutation?.removeObserver(this)\n this.#currentMutation = undefined\n this.#updateResult()\n this.#notify()\n }\n\n mutate(\n variables: TVariables,\n options?: MutateOptions,\n ): Promise {\n this.#mutateOptions = options\n\n this.#currentMutation?.removeObserver(this)\n\n this.#currentMutation = this.#client\n .getMutationCache()\n .build(this.#client, this.options)\n\n this.#currentMutation.addObserver(this)\n\n return this.#currentMutation.execute(variables)\n }\n\n #updateResult(): void {\n const state =\n this.#currentMutation?.state ??\n getDefaultState()\n\n this.#currentResult = {\n ...state,\n isPending: state.status === 'pending',\n isSuccess: state.status === 'success',\n isError: state.status === 'error',\n isIdle: state.status === 'idle',\n mutate: this.mutate,\n reset: this.reset,\n } as MutationObserverResult\n }\n\n #notify(action?: Action): void {\n notifyManager.batch(() => {\n // First trigger the mutate callbacks\n if (this.#mutateOptions && this.hasListeners()) {\n const variables = this.#currentResult.variables!\n const onMutateResult = this.#currentResult.context\n\n const context = {\n client: this.#client,\n meta: this.options.meta,\n mutationKey: this.options.mutationKey,\n } satisfies MutationFunctionContext\n\n if (action?.type === 'success') {\n try {\n this.#mutateOptions.onSuccess?.(\n action.data,\n variables,\n onMutateResult,\n context,\n )\n } catch (e) {\n void Promise.reject(e)\n }\n try {\n this.#mutateOptions.onSettled?.(\n action.data,\n null,\n variables,\n onMutateResult,\n context,\n )\n } catch (e) {\n void Promise.reject(e)\n }\n } else if (action?.type === 'error') {\n try {\n this.#mutateOptions.onError?.(\n action.error,\n variables,\n onMutateResult,\n context,\n )\n } catch (e) {\n void Promise.reject(e)\n }\n try {\n this.#mutateOptions.onSettled?.(\n undefined,\n action.error,\n variables,\n onMutateResult,\n context,\n )\n } catch (e) {\n void Promise.reject(e)\n }\n }\n }\n\n // Then trigger the listeners\n this.listeners.forEach((listener) => {\n listener(this.#currentResult)\n })\n })\n }\n}\n", "import { notifyManager } from './notifyManager'\nimport { QueryObserver } from './queryObserver'\nimport { Subscribable } from './subscribable'\nimport { replaceEqualDeep, shallowEqualObjects } from './utils'\nimport type {\n DefaultedQueryObserverOptions,\n QueryObserverOptions,\n QueryObserverResult,\n} from './types'\nimport type { QueryClient } from './queryClient'\n\nfunction difference(array1: Array, array2: Array): Array {\n const excludeSet = new Set(array2)\n return array1.filter((x) => !excludeSet.has(x))\n}\n\nfunction replaceAt(array: Array, index: number, value: T): Array {\n const copy = array.slice(0)\n copy[index] = value\n return copy\n}\n\ntype QueriesObserverListener = (result: Array) => void\n\ntype CombineFn = (\n result: Array,\n) => TCombinedResult\n\nexport interface QueriesObserverOptions<\n TCombinedResult = Array,\n> {\n combine?: CombineFn\n}\n\nexport class QueriesObserver<\n TCombinedResult = Array,\n> extends Subscribable {\n #client: QueryClient\n #result!: Array\n #queries: Array\n #options?: QueriesObserverOptions\n #observers: Array\n #combinedResult?: TCombinedResult\n #lastCombine?: CombineFn\n #lastResult?: Array\n #lastQueryHashes?: Array\n #observerMatches: Array = []\n\n constructor(\n client: QueryClient,\n queries: Array>,\n options?: QueriesObserverOptions,\n ) {\n super()\n\n this.#client = client\n this.#options = options\n this.#queries = []\n this.#observers = []\n this.#result = []\n\n this.setQueries(queries)\n }\n\n protected onSubscribe(): void {\n if (this.listeners.size === 1) {\n this.#observers.forEach((observer) => {\n observer.subscribe((result) => {\n this.#onUpdate(observer, result)\n })\n })\n }\n }\n\n protected onUnsubscribe(): void {\n if (!this.listeners.size) {\n this.destroy()\n }\n }\n\n destroy(): void {\n this.listeners = new Set()\n this.#observers.forEach((observer) => {\n observer.destroy()\n })\n }\n\n setQueries(\n queries: Array,\n options?: QueriesObserverOptions,\n ): void {\n this.#queries = queries\n this.#options = options\n\n if (process.env.NODE_ENV !== 'production') {\n const queryHashes = queries.map(\n (query) => this.#client.defaultQueryOptions(query).queryHash,\n )\n if (new Set(queryHashes).size !== queryHashes.length) {\n console.warn(\n '[QueriesObserver]: Duplicate Queries found. This might result in unexpected behavior.',\n )\n }\n }\n\n notifyManager.batch(() => {\n const prevObservers = this.#observers\n\n const newObserverMatches = this.#findMatchingObservers(this.#queries)\n\n // set options for the new observers to notify of changes\n newObserverMatches.forEach((match) =>\n match.observer.setOptions(match.defaultedQueryOptions),\n )\n\n const newObservers = newObserverMatches.map((match) => match.observer)\n const newResult = newObservers.map((observer) =>\n observer.getCurrentResult(),\n )\n\n const hasLengthChange = prevObservers.length !== newObservers.length\n const hasIndexChange = newObservers.some(\n (observer, index) => observer !== prevObservers[index],\n )\n const hasStructuralChange = hasLengthChange || hasIndexChange\n\n const hasResultChange = hasStructuralChange\n ? true\n : newResult.some((result, index) => {\n const prev = this.#result[index]\n return !prev || !shallowEqualObjects(result, prev)\n })\n\n if (!hasStructuralChange && !hasResultChange) return\n\n if (hasStructuralChange) {\n this.#observerMatches = newObserverMatches\n this.#observers = newObservers\n }\n\n this.#result = newResult\n\n if (!this.hasListeners()) return\n\n if (hasStructuralChange) {\n difference(prevObservers, newObservers).forEach((observer) => {\n observer.destroy()\n })\n difference(newObservers, prevObservers).forEach((observer) => {\n observer.subscribe((result) => {\n this.#onUpdate(observer, result)\n })\n })\n }\n\n this.#notify()\n })\n }\n\n getCurrentResult(): Array {\n return this.#result\n }\n\n getQueries() {\n return this.#observers.map((observer) => observer.getCurrentQuery())\n }\n\n getObservers() {\n return this.#observers\n }\n\n getOptimisticResult(\n queries: Array,\n combine: CombineFn | undefined,\n ): [\n rawResult: Array,\n combineResult: (r?: Array) => TCombinedResult,\n trackResult: () => Array,\n ] {\n const matches = this.#findMatchingObservers(queries)\n const result = matches.map((match) =>\n match.observer.getOptimisticResult(match.defaultedQueryOptions),\n )\n const queryHashes = matches.map(\n (match) => match.defaultedQueryOptions.queryHash,\n )\n\n return [\n result,\n (r?: Array) => {\n return this.#combineResult(r ?? result, combine, queryHashes)\n },\n () => {\n return this.#trackResult(result, matches)\n },\n ]\n }\n\n #trackResult(\n result: Array,\n matches: Array,\n ) {\n return matches.map((match, index) => {\n const observerResult = result[index]!\n return !match.defaultedQueryOptions.notifyOnChangeProps\n ? match.observer.trackResult(observerResult, (accessedProp) => {\n // track property on all observers to ensure proper (synchronized) tracking (#7000)\n matches.forEach((m) => {\n m.observer.trackProp(accessedProp)\n })\n })\n : observerResult\n })\n }\n\n #combineResult(\n input: Array,\n combine: CombineFn | undefined,\n queryHashes?: Array,\n ): TCombinedResult {\n if (combine) {\n const lastHashes = this.#lastQueryHashes\n const queryHashesChanged =\n queryHashes !== undefined &&\n lastHashes !== undefined &&\n (lastHashes.length !== queryHashes.length ||\n queryHashes.some((hash, i) => hash !== lastHashes[i]))\n\n if (\n !this.#combinedResult ||\n this.#result !== this.#lastResult ||\n queryHashesChanged ||\n combine !== this.#lastCombine\n ) {\n this.#lastCombine = combine\n this.#lastResult = this.#result\n\n if (queryHashes !== undefined) {\n this.#lastQueryHashes = queryHashes\n }\n this.#combinedResult = replaceEqualDeep(\n this.#combinedResult,\n combine(input),\n )\n }\n\n return this.#combinedResult\n }\n return input as any\n }\n\n #findMatchingObservers(\n queries: Array,\n ): Array {\n const prevObserversMap = new Map>()\n\n this.#observers.forEach((observer) => {\n const key = observer.options.queryHash\n if (!key) return\n\n const previousObservers = prevObserversMap.get(key)\n\n if (previousObservers) {\n previousObservers.push(observer)\n } else {\n prevObserversMap.set(key, [observer])\n }\n })\n\n const observers: Array = []\n\n queries.forEach((options) => {\n const defaultedOptions = this.#client.defaultQueryOptions(options)\n const match = prevObserversMap.get(defaultedOptions.queryHash)?.shift()\n const observer =\n match ?? new QueryObserver(this.#client, defaultedOptions)\n\n observers.push({\n defaultedQueryOptions: defaultedOptions,\n observer,\n })\n })\n\n return observers\n }\n\n #onUpdate(observer: QueryObserver, result: QueryObserverResult): void {\n const index = this.#observers.indexOf(observer)\n if (index !== -1) {\n this.#result = replaceAt(this.#result, index, result)\n this.#notify()\n }\n }\n\n #notify(): void {\n if (this.hasListeners()) {\n const previousResult = this.#combinedResult\n const newTracked = this.#trackResult(this.#result, this.#observerMatches)\n const newResult = this.#combineResult(newTracked, this.#options?.combine)\n\n if (previousResult !== newResult) {\n notifyManager.batch(() => {\n this.listeners.forEach((listener) => {\n listener(this.#result)\n })\n })\n }\n }\n }\n}\n\ntype QueryObserverMatch = {\n defaultedQueryOptions: DefaultedQueryObserverOptions\n observer: QueryObserver\n}\n", "import { hashQueryKeyByOptions, matchQuery } from './utils'\nimport { Query } from './query'\nimport { notifyManager } from './notifyManager'\nimport { Subscribable } from './subscribable'\nimport type { QueryFilters } from './utils'\nimport type { Action, QueryState } from './query'\nimport type {\n DefaultError,\n NotifyEvent,\n QueryKey,\n QueryOptions,\n WithRequired,\n} from './types'\nimport type { QueryClient } from './queryClient'\nimport type { QueryObserver } from './queryObserver'\n\n// TYPES\n\ninterface QueryCacheConfig {\n onError?: (\n error: DefaultError,\n query: Query,\n ) => void\n onSuccess?: (data: unknown, query: Query) => void\n onSettled?: (\n data: unknown | undefined,\n error: DefaultError | null,\n query: Query,\n ) => void\n}\n\ninterface NotifyEventQueryAdded extends NotifyEvent {\n type: 'added'\n query: Query\n}\n\ninterface NotifyEventQueryRemoved extends NotifyEvent {\n type: 'removed'\n query: Query\n}\n\ninterface NotifyEventQueryUpdated extends NotifyEvent {\n type: 'updated'\n query: Query\n action: Action\n}\n\ninterface NotifyEventQueryObserverAdded extends NotifyEvent {\n type: 'observerAdded'\n query: Query\n observer: QueryObserver\n}\n\ninterface NotifyEventQueryObserverRemoved extends NotifyEvent {\n type: 'observerRemoved'\n query: Query\n observer: QueryObserver\n}\n\ninterface NotifyEventQueryObserverResultsUpdated extends NotifyEvent {\n type: 'observerResultsUpdated'\n query: Query\n}\n\ninterface NotifyEventQueryObserverOptionsUpdated extends NotifyEvent {\n type: 'observerOptionsUpdated'\n query: Query\n observer: QueryObserver\n}\n\nexport type QueryCacheNotifyEvent =\n | NotifyEventQueryAdded\n | NotifyEventQueryRemoved\n | NotifyEventQueryUpdated\n | NotifyEventQueryObserverAdded\n | NotifyEventQueryObserverRemoved\n | NotifyEventQueryObserverResultsUpdated\n | NotifyEventQueryObserverOptionsUpdated\n\ntype QueryCacheListener = (event: QueryCacheNotifyEvent) => void\n\nexport interface QueryStore {\n has: (queryHash: string) => boolean\n set: (queryHash: string, query: Query) => void\n get: (queryHash: string) => Query | undefined\n delete: (queryHash: string) => void\n values: () => IterableIterator\n}\n\n// CLASS\n\nexport class QueryCache extends Subscribable {\n #queries: QueryStore\n\n constructor(public config: QueryCacheConfig = {}) {\n super()\n this.#queries = new Map()\n }\n\n build<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n >(\n client: QueryClient,\n options: WithRequired<\n QueryOptions,\n 'queryKey'\n >,\n state?: QueryState,\n ): Query {\n const queryKey = options.queryKey\n const queryHash =\n options.queryHash ?? hashQueryKeyByOptions(queryKey, options)\n let query = this.get(queryHash)\n\n if (!query) {\n query = new Query({\n client,\n queryKey,\n queryHash,\n options: client.defaultQueryOptions(options),\n state,\n defaultOptions: client.getQueryDefaults(queryKey),\n })\n this.add(query)\n }\n\n return query\n }\n\n add(query: Query): void {\n if (!this.#queries.has(query.queryHash)) {\n this.#queries.set(query.queryHash, query)\n\n this.notify({\n type: 'added',\n query,\n })\n }\n }\n\n remove(query: Query): void {\n const queryInMap = this.#queries.get(query.queryHash)\n\n if (queryInMap) {\n query.destroy()\n\n if (queryInMap === query) {\n this.#queries.delete(query.queryHash)\n }\n\n this.notify({ type: 'removed', query })\n }\n }\n\n clear(): void {\n notifyManager.batch(() => {\n this.getAll().forEach((query) => {\n this.remove(query)\n })\n })\n }\n\n get<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n >(\n queryHash: string,\n ): Query | undefined {\n return this.#queries.get(queryHash) as\n | Query\n | undefined\n }\n\n getAll(): Array {\n return [...this.#queries.values()]\n }\n\n find(\n filters: WithRequired,\n ): Query | undefined {\n const defaultedFilters = { exact: true, ...filters }\n\n return this.getAll().find((query) =>\n matchQuery(defaultedFilters, query),\n ) as Query | undefined\n }\n\n findAll(filters: QueryFilters = {}): Array {\n const queries = this.getAll()\n return Object.keys(filters).length > 0\n ? queries.filter((query) => matchQuery(filters, query))\n : queries\n }\n\n notify(event: QueryCacheNotifyEvent): void {\n notifyManager.batch(() => {\n this.listeners.forEach((listener) => {\n listener(event)\n })\n })\n }\n\n onFocus(): void {\n notifyManager.batch(() => {\n this.getAll().forEach((query) => {\n query.onFocus()\n })\n })\n }\n\n onOnline(): void {\n notifyManager.batch(() => {\n this.getAll().forEach((query) => {\n query.onOnline()\n })\n })\n }\n}\n", "import {\n functionalUpdate,\n hashKey,\n hashQueryKeyByOptions,\n noop,\n partialMatchKey,\n resolveStaleTime,\n skipToken,\n} from './utils'\nimport { QueryCache } from './queryCache'\nimport { MutationCache } from './mutationCache'\nimport { focusManager } from './focusManager'\nimport { onlineManager } from './onlineManager'\nimport { notifyManager } from './notifyManager'\nimport { infiniteQueryBehavior } from './infiniteQueryBehavior'\nimport type {\n CancelOptions,\n DefaultError,\n DefaultOptions,\n DefaultedQueryObserverOptions,\n EnsureInfiniteQueryDataOptions,\n EnsureQueryDataOptions,\n FetchInfiniteQueryOptions,\n FetchQueryOptions,\n InferDataFromTag,\n InferErrorFromTag,\n InfiniteData,\n InvalidateOptions,\n InvalidateQueryFilters,\n MutationKey,\n MutationObserverOptions,\n MutationOptions,\n NoInfer,\n OmitKeyof,\n QueryClientConfig,\n QueryKey,\n QueryObserverOptions,\n QueryOptions,\n RefetchOptions,\n RefetchQueryFilters,\n ResetOptions,\n SetDataOptions,\n} from './types'\nimport type { QueryState } from './query'\nimport type { MutationFilters, QueryFilters, Updater } from './utils'\n\n// TYPES\n\ninterface QueryDefaults {\n queryKey: QueryKey\n defaultOptions: OmitKeyof, 'queryKey'>\n}\n\ninterface MutationDefaults {\n mutationKey: MutationKey\n defaultOptions: MutationOptions\n}\n\n// CLASS\n\nexport class QueryClient {\n #queryCache: QueryCache\n #mutationCache: MutationCache\n #defaultOptions: DefaultOptions\n #queryDefaults: Map\n #mutationDefaults: Map\n #mountCount: number\n #unsubscribeFocus?: () => void\n #unsubscribeOnline?: () => void\n\n constructor(config: QueryClientConfig = {}) {\n this.#queryCache = config.queryCache || new QueryCache()\n this.#mutationCache = config.mutationCache || new MutationCache()\n this.#defaultOptions = config.defaultOptions || {}\n this.#queryDefaults = new Map()\n this.#mutationDefaults = new Map()\n this.#mountCount = 0\n }\n\n mount(): void {\n this.#mountCount++\n if (this.#mountCount !== 1) return\n\n this.#unsubscribeFocus = focusManager.subscribe(async (focused) => {\n if (focused) {\n await this.resumePausedMutations()\n this.#queryCache.onFocus()\n }\n })\n this.#unsubscribeOnline = onlineManager.subscribe(async (online) => {\n if (online) {\n await this.resumePausedMutations()\n this.#queryCache.onOnline()\n }\n })\n }\n\n unmount(): void {\n this.#mountCount--\n if (this.#mountCount !== 0) return\n\n this.#unsubscribeFocus?.()\n this.#unsubscribeFocus = undefined\n\n this.#unsubscribeOnline?.()\n this.#unsubscribeOnline = undefined\n }\n\n isFetching = QueryFilters>(\n filters?: TQueryFilters,\n ): number {\n return this.#queryCache.findAll({ ...filters, fetchStatus: 'fetching' })\n .length\n }\n\n isMutating<\n TMutationFilters extends MutationFilters = MutationFilters,\n >(filters?: TMutationFilters): number {\n return this.#mutationCache.findAll({ ...filters, status: 'pending' }).length\n }\n\n /**\n * Imperative (non-reactive) way to retrieve data for a QueryKey.\n * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.\n *\n * Hint: Do not use this function inside a component, because it won't receive updates.\n * Use `useQuery` to create a `QueryObserver` that subscribes to changes.\n */\n getQueryData<\n TQueryFnData = unknown,\n TTaggedQueryKey extends QueryKey = QueryKey,\n TInferredQueryFnData = InferDataFromTag,\n >(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined {\n const options = this.defaultQueryOptions({ queryKey })\n\n return this.#queryCache.get(options.queryHash)?.state\n .data\n }\n\n ensureQueryData<\n TQueryFnData,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n >(\n options: EnsureQueryDataOptions,\n ): Promise {\n const defaultedOptions = this.defaultQueryOptions(options)\n const query = this.#queryCache.build(this, defaultedOptions)\n const cachedData = query.state.data\n\n if (cachedData === undefined) {\n return this.fetchQuery(options)\n }\n\n if (\n options.revalidateIfStale &&\n query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))\n ) {\n void this.prefetchQuery(defaultedOptions)\n }\n\n return Promise.resolve(cachedData)\n }\n\n getQueriesData<\n TQueryFnData = unknown,\n TQueryFilters extends QueryFilters = QueryFilters,\n >(filters: TQueryFilters): Array<[QueryKey, TQueryFnData | undefined]> {\n return this.#queryCache.findAll(filters).map(({ queryKey, state }) => {\n const data = state.data as TQueryFnData | undefined\n return [queryKey, data]\n })\n }\n\n setQueryData<\n TQueryFnData = unknown,\n TTaggedQueryKey extends QueryKey = QueryKey,\n TInferredQueryFnData = InferDataFromTag,\n >(\n queryKey: TTaggedQueryKey,\n updater: Updater<\n NoInfer | undefined,\n NoInfer | undefined\n >,\n options?: SetDataOptions,\n ): NoInfer | undefined {\n const defaultedOptions = this.defaultQueryOptions<\n any,\n any,\n unknown,\n any,\n QueryKey\n >({ queryKey })\n\n const query = this.#queryCache.get(\n defaultedOptions.queryHash,\n )\n const prevData = query?.state.data\n const data = functionalUpdate(updater, prevData)\n\n if (data === undefined) {\n return undefined\n }\n\n return this.#queryCache\n .build(this, defaultedOptions)\n .setData(data, { ...options, manual: true })\n }\n\n setQueriesData<\n TQueryFnData,\n TQueryFilters extends QueryFilters = QueryFilters,\n >(\n filters: TQueryFilters,\n updater: Updater<\n NoInfer | undefined,\n NoInfer | undefined\n >,\n options?: SetDataOptions,\n ): Array<[QueryKey, TQueryFnData | undefined]> {\n return notifyManager.batch(() =>\n this.#queryCache\n .findAll(filters)\n .map(({ queryKey }) => [\n queryKey,\n this.setQueryData(queryKey, updater, options),\n ]),\n )\n }\n\n getQueryState<\n TQueryFnData = unknown,\n TError = DefaultError,\n TTaggedQueryKey extends QueryKey = QueryKey,\n TInferredQueryFnData = InferDataFromTag,\n TInferredError = InferErrorFromTag,\n >(\n queryKey: TTaggedQueryKey,\n ): QueryState | undefined {\n const options = this.defaultQueryOptions({ queryKey })\n return this.#queryCache.get(\n options.queryHash,\n )?.state\n }\n\n removeQueries(\n filters?: QueryFilters,\n ): void {\n const queryCache = this.#queryCache\n notifyManager.batch(() => {\n queryCache.findAll(filters).forEach((query) => {\n queryCache.remove(query)\n })\n })\n }\n\n resetQueries(\n filters?: QueryFilters,\n options?: ResetOptions,\n ): Promise {\n const queryCache = this.#queryCache\n\n return notifyManager.batch(() => {\n queryCache.findAll(filters).forEach((query) => {\n query.reset()\n })\n return this.refetchQueries(\n {\n type: 'active',\n ...filters,\n },\n options,\n )\n })\n }\n\n cancelQueries(\n filters?: QueryFilters,\n cancelOptions: CancelOptions = {},\n ): Promise {\n const defaultedCancelOptions = { revert: true, ...cancelOptions }\n\n const promises = notifyManager.batch(() =>\n this.#queryCache\n .findAll(filters)\n .map((query) => query.cancel(defaultedCancelOptions)),\n )\n\n return Promise.all(promises).then(noop).catch(noop)\n }\n\n invalidateQueries(\n filters?: InvalidateQueryFilters,\n options: InvalidateOptions = {},\n ): Promise {\n return notifyManager.batch(() => {\n this.#queryCache.findAll(filters).forEach((query) => {\n query.invalidate()\n })\n\n if (filters?.refetchType === 'none') {\n return Promise.resolve()\n }\n return this.refetchQueries(\n {\n ...filters,\n type: filters?.refetchType ?? filters?.type ?? 'active',\n },\n options,\n )\n })\n }\n\n refetchQueries(\n filters?: RefetchQueryFilters,\n options: RefetchOptions = {},\n ): Promise {\n const fetchOptions = {\n ...options,\n cancelRefetch: options.cancelRefetch ?? true,\n }\n const promises = notifyManager.batch(() =>\n this.#queryCache\n .findAll(filters)\n .filter((query) => !query.isDisabled() && !query.isStatic())\n .map((query) => {\n let promise = query.fetch(undefined, fetchOptions)\n if (!fetchOptions.throwOnError) {\n promise = promise.catch(noop)\n }\n return query.state.fetchStatus === 'paused'\n ? Promise.resolve()\n : promise\n }),\n )\n\n return Promise.all(promises).then(noop)\n }\n\n fetchQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = never,\n >(\n options: FetchQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ): Promise {\n const defaultedOptions = this.defaultQueryOptions(options)\n\n // https://github.com/tannerlinsley/react-query/issues/652\n if (defaultedOptions.retry === undefined) {\n defaultedOptions.retry = false\n }\n\n const query = this.#queryCache.build(this, defaultedOptions)\n\n return query.isStaleByTime(\n resolveStaleTime(defaultedOptions.staleTime, query),\n )\n ? query.fetch(defaultedOptions)\n : Promise.resolve(query.state.data as TData)\n }\n\n prefetchQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n >(\n options: FetchQueryOptions,\n ): Promise {\n return this.fetchQuery(options).then(noop).catch(noop)\n }\n\n fetchInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n >(\n options: FetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ): Promise> {\n options.behavior = infiniteQueryBehavior<\n TQueryFnData,\n TError,\n TData,\n TPageParam\n >(options.pages)\n return this.fetchQuery(options as any)\n }\n\n prefetchInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n >(\n options: FetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ): Promise {\n return this.fetchInfiniteQuery(options).then(noop).catch(noop)\n }\n\n ensureInfiniteQueryData<\n TQueryFnData,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n >(\n options: EnsureInfiniteQueryDataOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n ): Promise> {\n options.behavior = infiniteQueryBehavior<\n TQueryFnData,\n TError,\n TData,\n TPageParam\n >(options.pages)\n\n return this.ensureQueryData(options as any)\n }\n\n resumePausedMutations(): Promise {\n if (onlineManager.isOnline()) {\n return this.#mutationCache.resumePausedMutations()\n }\n return Promise.resolve()\n }\n\n getQueryCache(): QueryCache {\n return this.#queryCache\n }\n\n getMutationCache(): MutationCache {\n return this.#mutationCache\n }\n\n getDefaultOptions(): DefaultOptions {\n return this.#defaultOptions\n }\n\n setDefaultOptions(options: DefaultOptions): void {\n this.#defaultOptions = options\n }\n\n setQueryDefaults<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n >(\n queryKey: QueryKey,\n options: Partial<\n OmitKeyof<\n QueryObserverOptions,\n 'queryKey'\n >\n >,\n ): void {\n this.#queryDefaults.set(hashKey(queryKey), {\n queryKey,\n defaultOptions: options,\n })\n }\n\n getQueryDefaults(\n queryKey: QueryKey,\n ): OmitKeyof, 'queryKey'> {\n const defaults = [...this.#queryDefaults.values()]\n\n const result: OmitKeyof<\n QueryObserverOptions,\n 'queryKey'\n > = {}\n\n defaults.forEach((queryDefault) => {\n if (partialMatchKey(queryKey, queryDefault.queryKey)) {\n Object.assign(result, queryDefault.defaultOptions)\n }\n })\n return result\n }\n\n setMutationDefaults<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n >(\n mutationKey: MutationKey,\n options: OmitKeyof<\n MutationObserverOptions,\n 'mutationKey'\n >,\n ): void {\n this.#mutationDefaults.set(hashKey(mutationKey), {\n mutationKey,\n defaultOptions: options,\n })\n }\n\n getMutationDefaults(\n mutationKey: MutationKey,\n ): OmitKeyof, 'mutationKey'> {\n const defaults = [...this.#mutationDefaults.values()]\n\n const result: OmitKeyof<\n MutationObserverOptions,\n 'mutationKey'\n > = {}\n\n defaults.forEach((queryDefault) => {\n if (partialMatchKey(mutationKey, queryDefault.mutationKey)) {\n Object.assign(result, queryDefault.defaultOptions)\n }\n })\n\n return result\n }\n\n defaultQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = never,\n >(\n options:\n | QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey,\n TPageParam\n >\n | DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n ): DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n > {\n if (options._defaulted) {\n return options as DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >\n }\n\n const defaultedOptions = {\n ...this.#defaultOptions.queries,\n ...this.getQueryDefaults(options.queryKey),\n ...options,\n _defaulted: true,\n }\n\n if (!defaultedOptions.queryHash) {\n defaultedOptions.queryHash = hashQueryKeyByOptions(\n defaultedOptions.queryKey,\n defaultedOptions,\n )\n }\n\n // dependent default values\n if (defaultedOptions.refetchOnReconnect === undefined) {\n defaultedOptions.refetchOnReconnect =\n defaultedOptions.networkMode !== 'always'\n }\n if (defaultedOptions.throwOnError === undefined) {\n defaultedOptions.throwOnError = !!defaultedOptions.suspense\n }\n\n if (!defaultedOptions.networkMode && defaultedOptions.persister) {\n defaultedOptions.networkMode = 'offlineFirst'\n }\n\n if (defaultedOptions.queryFn === skipToken) {\n defaultedOptions.enabled = false\n }\n\n return defaultedOptions as DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >\n }\n\n defaultMutationOptions>(\n options?: T,\n ): T {\n if (options?._defaulted) {\n return options\n }\n return {\n ...this.#defaultOptions.mutations,\n ...(options?.mutationKey &&\n this.getMutationDefaults(options.mutationKey)),\n ...options,\n _defaulted: true,\n } as T\n }\n\n clear(): void {\n this.#queryCache.clear()\n this.#mutationCache.clear()\n }\n}\n", "import { addConsumeAwareSignal, addToEnd } from './utils'\nimport type {\n OmitKeyof,\n QueryFunction,\n QueryFunctionContext,\n QueryKey,\n} from './types'\n\ntype BaseStreamedQueryParams = {\n streamFn: (\n context: QueryFunctionContext,\n ) => AsyncIterable | Promise>\n refetchMode?: 'append' | 'reset' | 'replace'\n}\n\ntype SimpleStreamedQueryParams<\n TQueryFnData,\n TQueryKey extends QueryKey,\n> = BaseStreamedQueryParams & {\n reducer?: never\n initialValue?: never\n}\n\ntype ReducibleStreamedQueryParams<\n TQueryFnData,\n TData,\n TQueryKey extends QueryKey,\n> = BaseStreamedQueryParams & {\n reducer: (acc: TData, chunk: TQueryFnData) => TData\n initialValue: TData\n}\n\ntype StreamedQueryParams =\n | SimpleStreamedQueryParams\n | ReducibleStreamedQueryParams\n\n/**\n * This is a helper function to create a query function that streams data from an AsyncIterable.\n * Data will be an Array of all the chunks received.\n * The query will be in a 'pending' state until the first chunk of data is received, but will go to 'success' after that.\n * The query will stay in fetchStatus 'fetching' until the stream ends.\n * @param queryFn - The function that returns an AsyncIterable to stream data from.\n * @param refetchMode - Defines how re-fetches are handled.\n * Defaults to `'reset'`, erases all data and puts the query back into `pending` state.\n * Set to `'append'` to append new data to the existing data.\n * Set to `'replace'` to write all data to the cache once the stream ends.\n * @param reducer - A function to reduce the streamed chunks into the final data.\n * Defaults to a function that appends chunks to the end of the array.\n * @param initialValue - Initial value to be used while the first chunk is being fetched, and returned if the stream yields no values.\n */\nexport function streamedQuery<\n TQueryFnData = unknown,\n TData = Array,\n TQueryKey extends QueryKey = QueryKey,\n>({\n streamFn,\n refetchMode = 'reset',\n reducer = (items, chunk) =>\n addToEnd(items as Array, chunk) as TData,\n initialValue = [] as TData,\n}: StreamedQueryParams): QueryFunction<\n TData,\n TQueryKey\n> {\n return async (context) => {\n const query = context.client\n .getQueryCache()\n .find({ queryKey: context.queryKey, exact: true })\n const isRefetch = !!query && query.state.data !== undefined\n if (isRefetch && refetchMode === 'reset') {\n query.setState({\n status: 'pending',\n data: undefined,\n error: null,\n fetchStatus: 'fetching',\n })\n }\n\n let result = initialValue\n\n let cancelled: boolean = false as boolean\n const streamFnContext = addConsumeAwareSignal<\n OmitKeyof\n >(\n {\n client: context.client,\n meta: context.meta,\n queryKey: context.queryKey,\n pageParam: context.pageParam,\n direction: context.direction,\n },\n () => context.signal,\n () => (cancelled = true),\n )\n\n const stream = await streamFn(streamFnContext)\n\n const isReplaceRefetch = isRefetch && refetchMode === 'replace'\n\n for await (const chunk of stream) {\n if (cancelled) {\n break\n }\n\n if (isReplaceRefetch) {\n // don't append to the cache directly when replace-refetching\n result = reducer(result, chunk)\n } else {\n context.client.setQueryData(context.queryKey, (prev) =>\n reducer(prev === undefined ? initialValue : prev, chunk),\n )\n }\n }\n\n // finalize result: replace-refetching needs to write to the cache\n if (isReplaceRefetch && !cancelled) {\n context.client.setQueryData(context.queryKey, result)\n }\n\n return context.client.getQueryData(context.queryKey) ?? initialValue\n }\n}\n", "/* istanbul ignore file */\n\nimport type { QueryClient } from './queryClient'\nimport type { DehydrateOptions, HydrateOptions } from './hydration'\nimport type { MutationState } from './mutation'\nimport type { FetchDirection, Query, QueryBehavior } from './query'\nimport type { RetryDelayValue, RetryValue } from './retryer'\nimport type { QueryFilters, QueryTypeFilter, SkipToken } from './utils'\nimport type { QueryCache } from './queryCache'\nimport type { MutationCache } from './mutationCache'\n\nexport type NonUndefinedGuard = T extends undefined ? never : T\n\nexport type DistributiveOmit<\n TObject,\n TKey extends keyof TObject,\n> = TObject extends any ? Omit : never\n\nexport type OmitKeyof<\n TObject,\n TKey extends TStrictly extends 'safely'\n ?\n | keyof TObject\n | (string & Record)\n | (number & Record)\n | (symbol & Record)\n : keyof TObject,\n TStrictly extends 'strictly' | 'safely' = 'strictly',\n> = Omit\n\nexport type Override = {\n [AKey in keyof TTargetA]: AKey extends keyof TTargetB\n ? TTargetB[AKey]\n : TTargetA[AKey]\n}\n\nexport type NoInfer = [T][T extends any ? 0 : never]\n\nexport interface Register {\n // defaultError: Error\n // queryMeta: Record\n // mutationMeta: Record\n // queryKey: ReadonlyArray\n // mutationKey: ReadonlyArray\n}\n\nexport type DefaultError = Register extends {\n defaultError: infer TError\n}\n ? TError\n : Error\n\nexport type QueryKey = Register extends {\n queryKey: infer TQueryKey\n}\n ? TQueryKey extends ReadonlyArray\n ? TQueryKey\n : TQueryKey extends Array\n ? TQueryKey\n : ReadonlyArray\n : ReadonlyArray\n\nexport const dataTagSymbol = Symbol('dataTagSymbol')\nexport type dataTagSymbol = typeof dataTagSymbol\nexport const dataTagErrorSymbol = Symbol('dataTagErrorSymbol')\nexport type dataTagErrorSymbol = typeof dataTagErrorSymbol\nexport const unsetMarker = Symbol('unsetMarker')\nexport type UnsetMarker = typeof unsetMarker\nexport type AnyDataTag = {\n [dataTagSymbol]: any\n [dataTagErrorSymbol]: any\n}\nexport type DataTag<\n TType,\n TValue,\n TError = UnsetMarker,\n> = TType extends AnyDataTag\n ? TType\n : TType & {\n [dataTagSymbol]: TValue\n [dataTagErrorSymbol]: TError\n }\n\nexport type InferDataFromTag =\n TTaggedQueryKey extends DataTag\n ? TaggedValue\n : TQueryFnData\n\nexport type InferErrorFromTag =\n TTaggedQueryKey extends DataTag\n ? TaggedError extends UnsetMarker\n ? TError\n : TaggedError\n : TError\n\nexport type QueryFunction<\n T = unknown,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = never,\n> = (context: QueryFunctionContext) => T | Promise\n\nexport type StaleTime = number | 'static'\n\nexport type StaleTimeFunction<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> =\n | StaleTime\n | ((query: Query) => StaleTime)\n\nexport type Enabled<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> =\n | boolean\n | ((query: Query) => boolean)\n\nexport type QueryPersister<\n T = unknown,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = never,\n> = [TPageParam] extends [never]\n ? (\n queryFn: QueryFunction,\n context: QueryFunctionContext,\n query: Query,\n ) => T | Promise\n : (\n queryFn: QueryFunction,\n context: QueryFunctionContext,\n query: Query,\n ) => T | Promise\n\nexport type QueryFunctionContext<\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = never,\n> = [TPageParam] extends [never]\n ? {\n client: QueryClient\n queryKey: TQueryKey\n signal: AbortSignal\n meta: QueryMeta | undefined\n pageParam?: unknown\n /**\n * @deprecated\n * if you want access to the direction, you can add it to the pageParam\n */\n direction?: unknown\n }\n : {\n client: QueryClient\n queryKey: TQueryKey\n signal: AbortSignal\n pageParam: TPageParam\n /**\n * @deprecated\n * if you want access to the direction, you can add it to the pageParam\n */\n direction: FetchDirection\n meta: QueryMeta | undefined\n }\n\nexport type InitialDataFunction = () => T | undefined\n\ntype NonFunctionGuard = T extends Function ? never : T\n\nexport type PlaceholderDataFunction<\n TQueryFnData = unknown,\n TError = DefaultError,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = (\n previousData: TQueryData | undefined,\n previousQuery: Query | undefined,\n) => TQueryData | undefined\n\nexport type QueriesPlaceholderDataFunction = (\n previousData: undefined,\n previousQuery: undefined,\n) => TQueryData | undefined\n\nexport type QueryKeyHashFunction = (\n queryKey: TQueryKey,\n) => string\n\nexport type GetPreviousPageParamFunction = (\n firstPage: TQueryFnData,\n allPages: Array,\n firstPageParam: TPageParam,\n allPageParams: Array,\n) => TPageParam | undefined | null\n\nexport type GetNextPageParamFunction = (\n lastPage: TQueryFnData,\n allPages: Array,\n lastPageParam: TPageParam,\n allPageParams: Array,\n) => TPageParam | undefined | null\n\nexport interface InfiniteData {\n pages: Array\n pageParams: Array\n}\n\nexport type QueryMeta = Register extends {\n queryMeta: infer TQueryMeta\n}\n ? TQueryMeta extends Record\n ? TQueryMeta\n : Record\n : Record\n\nexport type NetworkMode = 'online' | 'always' | 'offlineFirst'\n\nexport type NotifyOnChangeProps =\n | Array\n | 'all'\n | undefined\n | (() => Array | 'all' | undefined)\n\nexport interface QueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = never,\n> {\n /**\n * If `false`, failed queries will not retry by default.\n * If `true`, failed queries will retry infinitely., failureCount: num\n * If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.\n * If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.\n */\n retry?: RetryValue\n retryDelay?: RetryDelayValue\n networkMode?: NetworkMode\n /**\n * The time in milliseconds that unused/inactive cache data remains in memory.\n * When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.\n * When different garbage collection times are specified, the longest one will be used.\n * Setting it to `Infinity` will disable garbage collection.\n */\n gcTime?: number\n queryFn?: QueryFunction | SkipToken\n persister?: QueryPersister<\n NoInfer,\n NoInfer,\n NoInfer\n >\n queryHash?: string\n queryKey?: TQueryKey\n queryKeyHashFn?: QueryKeyHashFunction\n initialData?: TData | InitialDataFunction\n initialDataUpdatedAt?: number | (() => number | undefined)\n behavior?: QueryBehavior\n /**\n * Set this to `false` to disable structural sharing between query results.\n * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.\n * Defaults to `true`.\n */\n structuralSharing?:\n | boolean\n | ((oldData: unknown | undefined, newData: unknown) => unknown)\n _defaulted?: boolean\n /**\n * Additional payload to be stored on each query.\n * Use this property to pass information that can be used in other places.\n */\n meta?: QueryMeta\n /**\n * Maximum number of pages to store in the data of an infinite query.\n */\n maxPages?: number\n}\n\nexport interface InitialPageParam {\n initialPageParam: TPageParam\n}\n\nexport interface InfiniteQueryPageParamsOptions<\n TQueryFnData = unknown,\n TPageParam = unknown,\n> extends InitialPageParam {\n /**\n * This function can be set to automatically get the previous cursor for infinite queries.\n * The result will also be used to determine the value of `hasPreviousPage`.\n */\n getPreviousPageParam?: GetPreviousPageParamFunction\n /**\n * This function can be set to automatically get the next cursor for infinite queries.\n * The result will also be used to determine the value of `hasNextPage`.\n */\n getNextPageParam: GetNextPageParamFunction\n}\n\nexport type ThrowOnError<\n TQueryFnData,\n TError,\n TQueryData,\n TQueryKey extends QueryKey,\n> =\n | boolean\n | ((\n error: TError,\n query: Query,\n ) => boolean)\n\nexport interface QueryObserverOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = never,\n> extends WithRequired<\n QueryOptions,\n 'queryKey'\n> {\n /**\n * Set this to `false` or a function that returns `false` to disable automatic refetching when the query mounts or changes query keys.\n * To refetch the query, use the `refetch` method returned from the `useQuery` instance.\n * Accepts a boolean or function that returns a boolean.\n * Defaults to `true`.\n */\n enabled?: Enabled\n /**\n * The time in milliseconds after data is considered stale.\n * If set to `Infinity`, the data will never be considered stale.\n * If set to a function, the function will be executed with the query to compute a `staleTime`.\n * Defaults to `0`.\n */\n staleTime?: StaleTimeFunction\n /**\n * If set to a number, the query will continuously refetch at this frequency in milliseconds.\n * If set to a function, the function will be executed with the latest data and query to compute a frequency\n * Defaults to `false`.\n */\n refetchInterval?:\n | number\n | false\n | ((\n query: Query,\n ) => number | false | undefined)\n /**\n * If set to `true`, the query will continue to refetch while their tab/window is in the background.\n * Defaults to `false`.\n */\n refetchIntervalInBackground?: boolean\n /**\n * If set to `true`, the query will refetch on window focus if the data is stale.\n * If set to `false`, the query will not refetch on window focus.\n * If set to `'always'`, the query will always refetch on window focus.\n * If set to a function, the function will be executed with the latest data and query to compute the value.\n * Defaults to `true`.\n */\n refetchOnWindowFocus?:\n | boolean\n | 'always'\n | ((\n query: Query,\n ) => boolean | 'always')\n /**\n * If set to `true`, the query will refetch on reconnect if the data is stale.\n * If set to `false`, the query will not refetch on reconnect.\n * If set to `'always'`, the query will always refetch on reconnect.\n * If set to a function, the function will be executed with the latest data and query to compute the value.\n * Defaults to the value of `networkOnline` (`true`)\n */\n refetchOnReconnect?:\n | boolean\n | 'always'\n | ((\n query: Query,\n ) => boolean | 'always')\n /**\n * If set to `true`, the query will refetch on mount if the data is stale.\n * If set to `false`, will disable additional instances of a query to trigger background refetch.\n * If set to `'always'`, the query will always refetch on mount.\n * If set to a function, the function will be executed with the latest data and query to compute the value\n * Defaults to `true`.\n */\n refetchOnMount?:\n | boolean\n | 'always'\n | ((\n query: Query,\n ) => boolean | 'always')\n /**\n * If set to `false`, the query will not be retried on mount if it contains an error.\n * Defaults to `true`.\n */\n retryOnMount?: boolean\n /**\n * If set, the component will only re-render if any of the listed properties change.\n * When set to `['data', 'error']`, the component will only re-render when the `data` or `error` properties change.\n * When set to `'all'`, the component will re-render whenever a query is updated.\n * When set to a function, the function will be executed to compute the list of properties.\n * By default, access to properties will be tracked, and the component will only re-render when one of the tracked properties change.\n */\n notifyOnChangeProps?: NotifyOnChangeProps\n /**\n * Whether errors should be thrown instead of setting the `error` property.\n * If set to `true` or `suspense` is `true`, all errors will be thrown to the error boundary.\n * If set to `false` and `suspense` is `false`, errors are returned as state.\n * If set to a function, it will be passed the error and the query, and it should return a boolean indicating whether to show the error in an error boundary (`true`) or return the error as state (`false`).\n * Defaults to `false`.\n */\n throwOnError?: ThrowOnError\n /**\n * This option can be used to transform or select a part of the data returned by the query function.\n */\n select?: (data: TQueryData) => TData\n /**\n * If set to `true`, the query will suspend when `status === 'pending'`\n * and throw errors when `status === 'error'`.\n * Defaults to `false`.\n */\n suspense?: boolean\n /**\n * If set, this value will be used as the placeholder data for this particular query observer while the query is still in the `loading` data and no initialData has been provided.\n */\n placeholderData?:\n | NonFunctionGuard\n | PlaceholderDataFunction<\n NonFunctionGuard,\n TError,\n NonFunctionGuard,\n TQueryKey\n >\n\n _optimisticResults?: 'optimistic' | 'isRestoring'\n\n /**\n * Enable prefetching during rendering\n */\n experimental_prefetchInRender?: boolean\n}\n\nexport type WithRequired = TTarget & {\n [_ in TKey]: {}\n}\n\nexport type DefaultedQueryObserverOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = WithRequired<\n QueryObserverOptions,\n 'throwOnError' | 'refetchOnReconnect' | 'queryHash'\n>\n\nexport interface InfiniteQueryObserverOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>\n extends\n QueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n InfiniteData,\n TQueryKey,\n TPageParam\n >,\n InfiniteQueryPageParamsOptions {}\n\nexport type DefaultedInfiniteQueryObserverOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = WithRequired<\n InfiniteQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n 'throwOnError' | 'refetchOnReconnect' | 'queryHash'\n>\n\nexport interface FetchQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = never,\n> extends WithRequired<\n QueryOptions,\n 'queryKey'\n> {\n initialPageParam?: never\n /**\n * The time in milliseconds after data is considered stale.\n * If the data is fresh it will be returned from the cache.\n */\n staleTime?: StaleTimeFunction\n}\n\nexport interface EnsureQueryDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = never,\n> extends FetchQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> {\n revalidateIfStale?: boolean\n}\n\nexport type EnsureInfiniteQueryDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = FetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n revalidateIfStale?: boolean\n}\n\ntype FetchInfiniteQueryPages =\n | { pages?: never }\n | {\n pages: number\n getNextPageParam: GetNextPageParamFunction\n }\n\nexport type FetchInfiniteQueryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = Omit<\n FetchQueryOptions<\n TQueryFnData,\n TError,\n InfiniteData,\n TQueryKey,\n TPageParam\n >,\n 'initialPageParam'\n> &\n InitialPageParam &\n FetchInfiniteQueryPages\n\nexport interface ResultOptions {\n throwOnError?: boolean\n}\n\nexport interface RefetchOptions extends ResultOptions {\n /**\n * If set to `true`, a currently running request will be cancelled before a new request is made\n *\n * If set to `false`, no refetch will be made if there is already a request running.\n *\n * Defaults to `true`.\n */\n cancelRefetch?: boolean\n}\n\nexport interface InvalidateQueryFilters<\n TQueryKey extends QueryKey = QueryKey,\n> extends QueryFilters {\n refetchType?: QueryTypeFilter | 'none'\n}\n\nexport interface RefetchQueryFilters<\n TQueryKey extends QueryKey = QueryKey,\n> extends QueryFilters {}\n\nexport interface InvalidateOptions extends RefetchOptions {}\nexport interface ResetOptions extends RefetchOptions {}\n\nexport interface FetchNextPageOptions extends ResultOptions {\n /**\n * If set to `true`, calling `fetchNextPage` repeatedly will invoke `queryFn` every time,\n * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.\n *\n * If set to `false`, calling `fetchNextPage` repeatedly won't have any effect until the first invocation has resolved.\n *\n * Defaults to `true`.\n */\n cancelRefetch?: boolean\n}\n\nexport interface FetchPreviousPageOptions extends ResultOptions {\n /**\n * If set to `true`, calling `fetchPreviousPage` repeatedly will invoke `queryFn` every time,\n * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.\n *\n * If set to `false`, calling `fetchPreviousPage` repeatedly won't have any effect until the first invocation has resolved.\n *\n * Defaults to `true`.\n */\n cancelRefetch?: boolean\n}\n\nexport type QueryStatus = 'pending' | 'error' | 'success'\nexport type FetchStatus = 'fetching' | 'paused' | 'idle'\n\nexport interface QueryObserverBaseResult<\n TData = unknown,\n TError = DefaultError,\n> {\n /**\n * The last successfully resolved data for the query.\n */\n data: TData | undefined\n /**\n * The timestamp for when the query most recently returned the `status` as `\"success\"`.\n */\n dataUpdatedAt: number\n /**\n * The error object for the query, if an error was thrown.\n * - Defaults to `null`.\n */\n error: TError | null\n /**\n * The timestamp for when the query most recently returned the `status` as `\"error\"`.\n */\n errorUpdatedAt: number\n /**\n * The failure count for the query.\n * - Incremented every time the query fails.\n * - Reset to `0` when the query succeeds.\n */\n failureCount: number\n /**\n * The failure reason for the query retry.\n * - Reset to `null` when the query succeeds.\n */\n failureReason: TError | null\n /**\n * The sum of all errors.\n */\n errorUpdateCount: number\n /**\n * A derived boolean from the `status` variable, provided for convenience.\n * - `true` if the query attempt resulted in an error.\n */\n isError: boolean\n /**\n * Will be `true` if the query has been fetched.\n */\n isFetched: boolean\n /**\n * Will be `true` if the query has been fetched after the component mounted.\n * - This property can be used to not show any previously cached data.\n */\n isFetchedAfterMount: boolean\n /**\n * A derived boolean from the `fetchStatus` variable, provided for convenience.\n * - `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.\n */\n isFetching: boolean\n /**\n * Is `true` whenever the first fetch for a query is in-flight.\n * - Is the same as `isFetching && isPending`.\n */\n isLoading: boolean\n /**\n * Will be `pending` if there's no cached data and no query attempt was finished yet.\n */\n isPending: boolean\n /**\n * Will be `true` if the query failed while fetching for the first time.\n */\n isLoadingError: boolean\n /**\n * @deprecated `isInitialLoading` is being deprecated in favor of `isLoading`\n * and will be removed in the next major version.\n */\n isInitialLoading: boolean\n /**\n * A derived boolean from the `fetchStatus` variable, provided for convenience.\n * - The query wanted to fetch, but has been `paused`.\n */\n isPaused: boolean\n /**\n * Will be `true` if the data shown is the placeholder data.\n */\n isPlaceholderData: boolean\n /**\n * Will be `true` if the query failed while refetching.\n */\n isRefetchError: boolean\n /**\n * Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.\n * - Is the same as `isFetching && !isPending`.\n */\n isRefetching: boolean\n /**\n * Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.\n */\n isStale: boolean\n /**\n * A derived boolean from the `status` variable, provided for convenience.\n * - `true` if the query has received a response with no errors and is ready to display its data.\n */\n isSuccess: boolean\n /**\n * `true` if this observer is enabled, `false` otherwise.\n */\n isEnabled: boolean\n /**\n * A function to manually refetch the query.\n */\n refetch: (\n options?: RefetchOptions,\n ) => Promise>\n /**\n * The status of the query.\n * - Will be:\n * - `pending` if there's no cached data and no query attempt was finished yet.\n * - `error` if the query attempt resulted in an error.\n * - `success` if the query has received a response with no errors and is ready to display its data.\n */\n status: QueryStatus\n /**\n * The fetch status of the query.\n * - `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.\n * - `paused`: The query wanted to fetch, but has been `paused`.\n * - `idle`: The query is not fetching.\n * - See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.\n */\n fetchStatus: FetchStatus\n /**\n * A stable promise that will be resolved with the data of the query.\n * Requires the `experimental_prefetchInRender` feature flag to be enabled.\n * @example\n *\n * ### Enabling the feature flag\n * ```ts\n * const client = new QueryClient({\n * defaultOptions: {\n * queries: {\n * experimental_prefetchInRender: true,\n * },\n * },\n * })\n * ```\n *\n * ### Usage\n * ```tsx\n * import { useQuery } from '@tanstack/react-query'\n * import React from 'react'\n * import { fetchTodos, type Todo } from './api'\n *\n * function TodoList({ query }: { query: UseQueryResult }) {\n * const data = React.use(query.promise)\n *\n * return (\n *
    \n * {data.map(todo => (\n *
  • {todo.title}
    • \n * ))}\n *
\n * )\n * }\n *\n * export function App() {\n * const query = useQuery({ queryKey: ['todos'], queryFn: fetchTodos })\n *\n * return (\n * <>\n *

Todos

\n * Loading...}>\n * \n * \n * \n * )\n * }\n * ```\n */\n promise: Promise\n}\n\nexport interface QueryObserverPendingResult<\n TData = unknown,\n TError = DefaultError,\n> extends QueryObserverBaseResult {\n data: undefined\n error: null\n isError: false\n isPending: true\n isLoadingError: false\n isRefetchError: false\n isSuccess: false\n isPlaceholderData: false\n status: 'pending'\n}\n\nexport interface QueryObserverLoadingResult<\n TData = unknown,\n TError = DefaultError,\n> extends QueryObserverBaseResult {\n data: undefined\n error: null\n isError: false\n isPending: true\n isLoading: true\n isLoadingError: false\n isRefetchError: false\n isSuccess: false\n isPlaceholderData: false\n status: 'pending'\n}\n\nexport interface QueryObserverLoadingErrorResult<\n TData = unknown,\n TError = DefaultError,\n> extends QueryObserverBaseResult {\n data: undefined\n error: TError\n isError: true\n isPending: false\n isLoading: false\n isLoadingError: true\n isRefetchError: false\n isSuccess: false\n isPlaceholderData: false\n status: 'error'\n}\n\nexport interface QueryObserverRefetchErrorResult<\n TData = unknown,\n TError = DefaultError,\n> extends QueryObserverBaseResult {\n data: TData\n error: TError\n isError: true\n isPending: false\n isLoading: false\n isLoadingError: false\n isRefetchError: true\n isSuccess: false\n isPlaceholderData: false\n status: 'error'\n}\n\nexport interface QueryObserverSuccessResult<\n TData = unknown,\n TError = DefaultError,\n> extends QueryObserverBaseResult {\n data: TData\n error: null\n isError: false\n isPending: false\n isLoading: false\n isLoadingError: false\n isRefetchError: false\n isSuccess: true\n isPlaceholderData: false\n status: 'success'\n}\n\nexport interface QueryObserverPlaceholderResult<\n TData = unknown,\n TError = DefaultError,\n> extends QueryObserverBaseResult {\n data: TData\n isError: false\n error: null\n isPending: false\n isLoading: false\n isLoadingError: false\n isRefetchError: false\n isSuccess: true\n isPlaceholderData: true\n status: 'success'\n}\n\nexport type DefinedQueryObserverResult<\n TData = unknown,\n TError = DefaultError,\n> =\n | QueryObserverRefetchErrorResult\n | QueryObserverSuccessResult\n\nexport type QueryObserverResult =\n | DefinedQueryObserverResult\n | QueryObserverLoadingErrorResult\n | QueryObserverLoadingResult\n | QueryObserverPendingResult\n | QueryObserverPlaceholderResult\n\nexport interface InfiniteQueryObserverBaseResult<\n TData = unknown,\n TError = DefaultError,\n> extends QueryObserverBaseResult {\n /**\n * This function allows you to fetch the next \"page\" of results.\n */\n fetchNextPage: (\n options?: FetchNextPageOptions,\n ) => Promise>\n /**\n * This function allows you to fetch the previous \"page\" of results.\n */\n fetchPreviousPage: (\n options?: FetchPreviousPageOptions,\n ) => Promise>\n /**\n * Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).\n */\n hasNextPage: boolean\n /**\n * Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).\n */\n hasPreviousPage: boolean\n /**\n * Will be `true` if the query failed while fetching the next page.\n */\n isFetchNextPageError: boolean\n /**\n * Will be `true` while fetching the next page with `fetchNextPage`.\n */\n isFetchingNextPage: boolean\n /**\n * Will be `true` if the query failed while fetching the previous page.\n */\n isFetchPreviousPageError: boolean\n /**\n * Will be `true` while fetching the previous page with `fetchPreviousPage`.\n */\n isFetchingPreviousPage: boolean\n}\n\nexport interface InfiniteQueryObserverPendingResult<\n TData = unknown,\n TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult {\n data: undefined\n error: null\n isError: false\n isPending: true\n isLoadingError: false\n isRefetchError: false\n isFetchNextPageError: false\n isFetchPreviousPageError: false\n isSuccess: false\n isPlaceholderData: false\n status: 'pending'\n}\n\nexport interface InfiniteQueryObserverLoadingResult<\n TData = unknown,\n TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult {\n data: undefined\n error: null\n isError: false\n isPending: true\n isLoading: true\n isLoadingError: false\n isRefetchError: false\n isFetchNextPageError: false\n isFetchPreviousPageError: false\n isSuccess: false\n isPlaceholderData: false\n status: 'pending'\n}\n\nexport interface InfiniteQueryObserverLoadingErrorResult<\n TData = unknown,\n TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult {\n data: undefined\n error: TError\n isError: true\n isPending: false\n isLoading: false\n isLoadingError: true\n isRefetchError: false\n isFetchNextPageError: false\n isFetchPreviousPageError: false\n isSuccess: false\n isPlaceholderData: false\n status: 'error'\n}\n\nexport interface InfiniteQueryObserverRefetchErrorResult<\n TData = unknown,\n TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult {\n data: TData\n error: TError\n isError: true\n isPending: false\n isLoading: false\n isLoadingError: false\n isRefetchError: true\n isSuccess: false\n isPlaceholderData: false\n status: 'error'\n}\n\nexport interface InfiniteQueryObserverSuccessResult<\n TData = unknown,\n TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult {\n data: TData\n error: null\n isError: false\n isPending: false\n isLoading: false\n isLoadingError: false\n isRefetchError: false\n isFetchNextPageError: false\n isFetchPreviousPageError: false\n isSuccess: true\n isPlaceholderData: false\n status: 'success'\n}\n\nexport interface InfiniteQueryObserverPlaceholderResult<\n TData = unknown,\n TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult {\n data: TData\n isError: false\n error: null\n isPending: false\n isLoading: false\n isLoadingError: false\n isRefetchError: false\n isSuccess: true\n isPlaceholderData: true\n isFetchNextPageError: false\n isFetchPreviousPageError: false\n status: 'success'\n}\n\nexport type DefinedInfiniteQueryObserverResult<\n TData = unknown,\n TError = DefaultError,\n> =\n | InfiniteQueryObserverRefetchErrorResult\n | InfiniteQueryObserverSuccessResult\n\nexport type InfiniteQueryObserverResult<\n TData = unknown,\n TError = DefaultError,\n> =\n | DefinedInfiniteQueryObserverResult\n | InfiniteQueryObserverLoadingErrorResult\n | InfiniteQueryObserverLoadingResult\n | InfiniteQueryObserverPendingResult\n | InfiniteQueryObserverPlaceholderResult\n\nexport type MutationKey = Register extends {\n mutationKey: infer TMutationKey\n}\n ? TMutationKey extends ReadonlyArray\n ? TMutationKey\n : TMutationKey extends Array\n ? TMutationKey\n : ReadonlyArray\n : ReadonlyArray\n\nexport type MutationStatus = 'idle' | 'pending' | 'success' | 'error'\n\nexport type MutationScope = {\n id: string\n}\n\nexport type MutationMeta = Register extends {\n mutationMeta: infer TMutationMeta\n}\n ? TMutationMeta extends Record\n ? TMutationMeta\n : Record\n : Record\n\nexport type MutationFunctionContext = {\n client: QueryClient\n meta: MutationMeta | undefined\n mutationKey?: MutationKey\n}\n\nexport type MutationFunction = (\n variables: TVariables,\n context: MutationFunctionContext,\n) => Promise\n\nexport interface MutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> {\n mutationFn?: MutationFunction\n mutationKey?: MutationKey\n onMutate?: (\n variables: TVariables,\n context: MutationFunctionContext,\n ) => Promise | TOnMutateResult\n onSuccess?: (\n data: TData,\n variables: TVariables,\n onMutateResult: TOnMutateResult,\n context: MutationFunctionContext,\n ) => Promise | unknown\n onError?: (\n error: TError,\n variables: TVariables,\n onMutateResult: TOnMutateResult | undefined,\n context: MutationFunctionContext,\n ) => Promise | unknown\n onSettled?: (\n data: TData | undefined,\n error: TError | null,\n variables: TVariables,\n onMutateResult: TOnMutateResult | undefined,\n context: MutationFunctionContext,\n ) => Promise | unknown\n retry?: RetryValue\n retryDelay?: RetryDelayValue\n networkMode?: NetworkMode\n gcTime?: number\n _defaulted?: boolean\n meta?: MutationMeta\n scope?: MutationScope\n}\n\nexport interface MutationObserverOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends MutationOptions {\n throwOnError?: boolean | ((error: TError) => boolean)\n}\n\nexport interface MutateOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> {\n onSuccess?: (\n data: TData,\n variables: TVariables,\n onMutateResult: TOnMutateResult | undefined,\n context: MutationFunctionContext,\n ) => void\n onError?: (\n error: TError,\n variables: TVariables,\n onMutateResult: TOnMutateResult | undefined,\n context: MutationFunctionContext,\n ) => void\n onSettled?: (\n data: TData | undefined,\n error: TError | null,\n variables: TVariables,\n onMutateResult: TOnMutateResult | undefined,\n context: MutationFunctionContext,\n ) => void\n}\n\nexport type MutateFunction<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> = (\n variables: TVariables,\n options?: MutateOptions,\n) => Promise\n\nexport interface MutationObserverBaseResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends MutationState {\n /**\n * The last successfully resolved data for the mutation.\n */\n data: TData | undefined\n /**\n * The variables object passed to the `mutationFn`.\n */\n variables: TVariables | undefined\n /**\n * The error object for the mutation, if an error was encountered.\n * - Defaults to `null`.\n */\n error: TError | null\n /**\n * A boolean variable derived from `status`.\n * - `true` if the last mutation attempt resulted in an error.\n */\n isError: boolean\n /**\n * A boolean variable derived from `status`.\n * - `true` if the mutation is in its initial state prior to executing.\n */\n isIdle: boolean\n /**\n * A boolean variable derived from `status`.\n * - `true` if the mutation is currently executing.\n */\n isPending: boolean\n /**\n * A boolean variable derived from `status`.\n * - `true` if the last mutation attempt was successful.\n */\n isSuccess: boolean\n /**\n * The status of the mutation.\n * - Will be:\n * - `idle` initial status prior to the mutation function executing.\n * - `pending` if the mutation is currently executing.\n * - `error` if the last mutation attempt resulted in an error.\n * - `success` if the last mutation attempt was successful.\n */\n status: MutationStatus\n /**\n * The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.\n * @param variables - The variables object to pass to the `mutationFn`.\n * @param options.onSuccess - This function will fire when the mutation is successful and will be passed the mutation's result.\n * @param options.onError - This function will fire if the mutation encounters an error and will be passed the error.\n * @param options.onSettled - This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.\n * @remarks\n * - If you make multiple requests, `onSuccess` will fire only after the latest call you've made.\n * - All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.\n */\n mutate: MutateFunction\n /**\n * A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).\n */\n reset: () => void\n}\n\nexport interface MutationObserverIdleResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n> {\n data: undefined\n variables: undefined\n error: null\n isError: false\n isIdle: true\n isPending: false\n isSuccess: false\n status: 'idle'\n}\n\nexport interface MutationObserverLoadingResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n> {\n data: undefined\n variables: TVariables\n error: null\n isError: false\n isIdle: false\n isPending: true\n isSuccess: false\n status: 'pending'\n}\n\nexport interface MutationObserverErrorResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n> {\n data: undefined\n error: TError\n variables: TVariables\n isError: true\n isIdle: false\n isPending: false\n isSuccess: false\n status: 'error'\n}\n\nexport interface MutationObserverSuccessResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n TData,\n TError,\n TVariables,\n TOnMutateResult\n> {\n data: TData\n error: null\n variables: TVariables\n isError: false\n isIdle: false\n isPending: false\n isSuccess: true\n status: 'success'\n}\n\nexport type MutationObserverResult<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n> =\n | MutationObserverIdleResult\n | MutationObserverLoadingResult\n | MutationObserverErrorResult\n | MutationObserverSuccessResult\n\nexport interface QueryClientConfig {\n queryCache?: QueryCache\n mutationCache?: MutationCache\n defaultOptions?: DefaultOptions\n}\n\nexport interface DefaultOptions {\n queries?: OmitKeyof<\n QueryObserverOptions,\n 'suspense' | 'queryKey'\n >\n mutations?: MutationObserverOptions\n hydrate?: HydrateOptions['defaultOptions']\n dehydrate?: DehydrateOptions\n}\n\nexport interface CancelOptions {\n revert?: boolean\n silent?: boolean\n}\n\nexport interface SetDataOptions {\n updatedAt?: number\n}\n\nexport type NotifyEventType =\n | 'added'\n | 'removed'\n | 'updated'\n | 'observerAdded'\n | 'observerRemoved'\n | 'observerResultsUpdated'\n | 'observerOptionsUpdated'\n\nexport interface NotifyEvent {\n type: NotifyEventType\n}\n", "'use client'\nimport * as React from 'react'\n\nimport {\n QueriesObserver,\n QueryObserver,\n noop,\n notifyManager,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n} from './suspense'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefaultError,\n OmitKeyof,\n QueriesObserverOptions,\n QueriesPlaceholderDataFunction,\n QueryClient,\n QueryFunction,\n QueryKey,\n QueryObserverOptions,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.\n// `placeholderData` function always gets undefined passed\ntype UseQueryOptionsForUseQueries<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions,\n 'placeholderData' | 'subscribed'\n> & {\n placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction\n}\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseQueryOptionsForUseQueries =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseQueryOptionsForUseQueries\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseQueryOptionsForUseQueries\n : T extends { data: infer TData; error?: infer TError }\n ? UseQueryOptionsForUseQueries\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseQueryOptionsForUseQueries\n : T extends [infer TQueryFnData, infer TError]\n ? UseQueryOptionsForUseQueries\n : T extends [infer TQueryFnData]\n ? UseQueryOptionsForUseQueries\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError\n }\n ? UseQueryOptionsForUseQueries<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError,\n unknown extends TData ? TQueryFnData : TData,\n TQueryKey\n >\n : // Fallback\n UseQueryOptionsForUseQueries\n\n// A defined initialData setting should return a DefinedUseQueryResult rather than UseQueryResult\ntype GetDefinedOrUndefinedQueryResult = T extends {\n initialData?: infer TInitialData\n}\n ? unknown extends TInitialData\n ? UseQueryResult\n : TInitialData extends TData\n ? DefinedUseQueryResult\n : TInitialData extends () => infer TInitialDataResult\n ? unknown extends TInitialDataResult\n ? UseQueryResult\n : TInitialDataResult extends TData\n ? DefinedUseQueryResult\n : UseQueryResult\n : UseQueryResult\n : UseQueryResult\n\ntype GetUseQueryResult =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? GetDefinedOrUndefinedQueryResult\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult\n : T extends { data: infer TData; error?: infer TError }\n ? GetDefinedOrUndefinedQueryResult\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? GetDefinedOrUndefinedQueryResult\n : T extends [infer TQueryFnData, infer TError]\n ? GetDefinedOrUndefinedQueryResult\n : T extends [infer TQueryFnData]\n ? GetDefinedOrUndefinedQueryResult\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError\n }\n ? GetDefinedOrUndefinedQueryResult<\n T,\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseQueryResult\n\n/**\n * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n */\nexport type QueriesOptions<\n T extends Array,\n TResults extends Array = [],\n TDepth extends ReadonlyArray = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryOptionsForUseQueries]\n : T extends [infer Head, ...infer Tails]\n ? QueriesOptions<\n [...Tails],\n [...TResults, GetUseQueryOptionsForUseQueries],\n [...TDepth, 1]\n >\n : ReadonlyArray extends T\n ? T\n : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseQueryOptionsForUseQueries<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseQueryOptionsForUseQueries<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n >\n : // Fallback\n Array\n\n/**\n * QueriesResults reducer recursively maps type param to results\n */\nexport type QueriesResults<\n T extends Array,\n TResults extends Array = [],\n TDepth extends ReadonlyArray = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseQueryResult]\n : T extends [infer Head, ...infer Tails]\n ? QueriesResults<\n [...Tails],\n [...TResults, GetUseQueryResult],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseQueryResult }\n\nexport function useQueries<\n T extends Array,\n TCombinedResult = QueriesResults,\n>(\n {\n queries,\n ...options\n }: {\n queries:\n | readonly [...QueriesOptions]\n | readonly [...{ [K in keyof T]: GetUseQueryOptionsForUseQueries }]\n combine?: (result: QueriesResults) => TCombinedResult\n subscribed?: boolean\n },\n queryClient?: QueryClient,\n): TCombinedResult {\n const client = useQueryClient(queryClient)\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n\n const defaultedQueries = React.useMemo(\n () =>\n queries.map((opts) => {\n const defaultedOptions = client.defaultQueryOptions(\n opts as QueryObserverOptions,\n )\n\n // Make sure the results are already in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : 'optimistic'\n\n return defaultedOptions\n }),\n [queries, client, isRestoring],\n )\n\n defaultedQueries.forEach((queryOptions) => {\n ensureSuspenseTimers(queryOptions)\n const query = client.getQueryCache().get(queryOptions.queryHash)\n ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query)\n })\n\n useClearResetErrorBoundary(errorResetBoundary)\n\n const [observer] = React.useState(\n () =>\n new QueriesObserver(\n client,\n defaultedQueries,\n options as QueriesObserverOptions,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const [optimisticResult, getCombinedResult, trackResult] =\n observer.getOptimisticResult(\n defaultedQueries,\n (options as QueriesObserverOptions).combine,\n )\n\n const shouldSubscribe = !isRestoring && options.subscribed !== false\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop,\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setQueries(\n defaultedQueries,\n options as QueriesObserverOptions,\n )\n }, [defaultedQueries, options, observer])\n\n const shouldAtLeastOneSuspend = optimisticResult.some((result, index) =>\n shouldSuspend(defaultedQueries[index], result),\n )\n\n const suspensePromises = shouldAtLeastOneSuspend\n ? optimisticResult.flatMap((result, index) => {\n const opts = defaultedQueries[index]\n\n if (opts && shouldSuspend(opts, result)) {\n const queryObserver = new QueryObserver(client, opts)\n return fetchOptimistic(opts, queryObserver, errorResetBoundary)\n }\n return []\n })\n : []\n\n if (suspensePromises.length > 0) {\n throw Promise.all(suspensePromises)\n }\n const firstSingleResultWhichShouldThrow = optimisticResult.find(\n (result, index) => {\n const query = defaultedQueries[index]\n return (\n query &&\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: query.throwOnError,\n query: client.getQueryCache().get(query.queryHash),\n suspense: query.suspense,\n })\n )\n },\n )\n\n if (firstSingleResultWhichShouldThrow?.error) {\n throw firstSingleResultWhichShouldThrow.error\n }\n\n return getCombinedResult(trackResult())\n}\n", "'use client'\nimport * as React from 'react'\n\nimport type { QueryClient } from '@tanstack/query-core'\n\nexport const QueryClientContext = React.createContext(\n undefined,\n)\n\nexport const useQueryClient = (queryClient?: QueryClient) => {\n const client = React.useContext(QueryClientContext)\n\n if (queryClient) {\n return queryClient\n }\n\n if (!client) {\n throw new Error('No QueryClient set, use QueryClientProvider to set one')\n }\n\n return client\n}\n\nexport type QueryClientProviderProps = {\n client: QueryClient\n children?: React.ReactNode\n}\n\nexport const QueryClientProvider = ({\n client,\n children,\n}: QueryClientProviderProps): React.JSX.Element => {\n React.useEffect(() => {\n client.mount()\n return () => {\n client.unmount()\n }\n }, [client])\n\n return (\n \n {children}\n \n )\n}\n", "'use client'\nimport * as React from 'react'\n\nconst IsRestoringContext = React.createContext(false)\n\nexport const useIsRestoring = () => React.useContext(IsRestoringContext)\nexport const IsRestoringProvider = IsRestoringContext.Provider\n", "'use client'\nimport * as React from 'react'\n\n// CONTEXT\nexport type QueryErrorResetFunction = () => void\nexport type QueryErrorIsResetFunction = () => boolean\nexport type QueryErrorClearResetFunction = () => void\n\nexport interface QueryErrorResetBoundaryValue {\n clearReset: QueryErrorClearResetFunction\n isReset: QueryErrorIsResetFunction\n reset: QueryErrorResetFunction\n}\n\nfunction createValue(): QueryErrorResetBoundaryValue {\n let isReset = false\n return {\n clearReset: () => {\n isReset = false\n },\n reset: () => {\n isReset = true\n },\n isReset: () => {\n return isReset\n },\n }\n}\n\nconst QueryErrorResetBoundaryContext = React.createContext(createValue())\n\n// HOOK\n\nexport const useQueryErrorResetBoundary = () =>\n React.useContext(QueryErrorResetBoundaryContext)\n\n// COMPONENT\n\nexport type QueryErrorResetBoundaryFunction = (\n value: QueryErrorResetBoundaryValue,\n) => React.ReactNode\n\nexport interface QueryErrorResetBoundaryProps {\n children: QueryErrorResetBoundaryFunction | React.ReactNode\n}\n\nexport const QueryErrorResetBoundary = ({\n children,\n}: QueryErrorResetBoundaryProps) => {\n const [value] = React.useState(() => createValue())\n return (\n \n {typeof children === 'function' ? children(value) : children}\n \n )\n}\n", "'use client'\nimport * as React from 'react'\nimport { shouldThrowError } from '@tanstack/query-core'\nimport type {\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserverResult,\n ThrowOnError,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const ensurePreventErrorBoundaryRetry = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n query: Query | undefined,\n) => {\n const throwOnError =\n query?.state.error && typeof options.throwOnError === 'function'\n ? shouldThrowError(options.throwOnError, [query.state.error, query])\n : options.throwOnError\n\n if (\n options.suspense ||\n options.experimental_prefetchInRender ||\n throwOnError\n ) {\n // Prevent retrying failed query if the error boundary has not been reset yet\n if (!errorResetBoundary.isReset()) {\n options.retryOnMount = false\n }\n }\n}\n\nexport const useClearResetErrorBoundary = (\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) => {\n React.useEffect(() => {\n errorResetBoundary.clearReset()\n }, [errorResetBoundary])\n}\n\nexport const getHasError = <\n TData,\n TError,\n TQueryFnData,\n TQueryData,\n TQueryKey extends QueryKey,\n>({\n result,\n errorResetBoundary,\n throwOnError,\n query,\n suspense,\n}: {\n result: QueryObserverResult\n errorResetBoundary: QueryErrorResetBoundaryValue\n throwOnError: ThrowOnError\n query: Query | undefined\n suspense: boolean | undefined\n}) => {\n return (\n result.isError &&\n !errorResetBoundary.isReset() &&\n !result.isFetching &&\n query &&\n ((suspense && result.data === undefined) ||\n shouldThrowError(throwOnError, [result.error, query]))\n )\n}\n", "import type {\n DefaultError,\n DefaultedQueryObserverOptions,\n Query,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { QueryErrorResetBoundaryValue } from './QueryErrorResetBoundary'\n\nexport const defaultThrowOnError = <\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n _error: TError,\n query: Query,\n) => query.state.data === undefined\n\nexport const ensureSuspenseTimers = (\n defaultedOptions: DefaultedQueryObserverOptions,\n) => {\n if (defaultedOptions.suspense) {\n // Handle staleTime to ensure minimum 1000ms in Suspense mode\n // This prevents unnecessary refetching when components remount after suspending\n const MIN_SUSPENSE_TIME_MS = 1000\n\n const clamp = (value: number | 'static' | undefined) =>\n value === 'static'\n ? value\n : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS)\n\n const originalStaleTime = defaultedOptions.staleTime\n defaultedOptions.staleTime =\n typeof originalStaleTime === 'function'\n ? (...args) => clamp(originalStaleTime(...args))\n : clamp(originalStaleTime)\n\n if (typeof defaultedOptions.gcTime === 'number') {\n defaultedOptions.gcTime = Math.max(\n defaultedOptions.gcTime,\n MIN_SUSPENSE_TIME_MS,\n )\n }\n }\n}\n\nexport const willFetch = (\n result: QueryObserverResult,\n isRestoring: boolean,\n) => result.isLoading && result.isFetching && !isRestoring\n\nexport const shouldSuspend = (\n defaultedOptions:\n | DefaultedQueryObserverOptions\n | undefined,\n result: QueryObserverResult,\n) => defaultedOptions?.suspense && result.isPending\n\nexport const fetchOptimistic = <\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n defaultedOptions: DefaultedQueryObserverOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n observer: QueryObserver,\n errorResetBoundary: QueryErrorResetBoundaryValue,\n) =>\n observer.fetchOptimistic(defaultedOptions).catch(() => {\n errorResetBoundary.clearReset()\n })\n", "'use client'\nimport * as React from 'react'\n\nimport { isServer, noop, notifyManager } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary'\nimport {\n ensurePreventErrorBoundaryRetry,\n getHasError,\n useClearResetErrorBoundary,\n} from './errorBoundaryUtils'\nimport { useIsRestoring } from './IsRestoringProvider'\nimport {\n ensureSuspenseTimers,\n fetchOptimistic,\n shouldSuspend,\n willFetch,\n} from './suspense'\nimport type {\n QueryClient,\n QueryKey,\n QueryObserver,\n QueryObserverResult,\n} from '@tanstack/query-core'\nimport type { UseBaseQueryOptions } from './types'\n\nexport function useBaseQuery<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey extends QueryKey,\n>(\n options: UseBaseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryData,\n TQueryKey\n >,\n Observer: typeof QueryObserver,\n queryClient?: QueryClient,\n): QueryObserverResult {\n if (process.env.NODE_ENV !== 'production') {\n if (typeof options !== 'object' || Array.isArray(options)) {\n throw new Error(\n 'Bad argument type. Starting with v5, only the \"Object\" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object',\n )\n }\n }\n\n const isRestoring = useIsRestoring()\n const errorResetBoundary = useQueryErrorResetBoundary()\n const client = useQueryClient(queryClient)\n const defaultedOptions = client.defaultQueryOptions(options)\n ;(client.getDefaultOptions().queries as any)?._experimental_beforeQuery?.(\n defaultedOptions,\n )\n\n const query = client\n .getQueryCache()\n .get<\n TQueryFnData,\n TError,\n TQueryData,\n TQueryKey\n >(defaultedOptions.queryHash)\n\n if (process.env.NODE_ENV !== 'production') {\n if (!defaultedOptions.queryFn) {\n console.error(\n `[${defaultedOptions.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`,\n )\n }\n }\n\n // Make sure results are optimistically set in fetching state before subscribing or updating options\n defaultedOptions._optimisticResults = isRestoring\n ? 'isRestoring'\n : 'optimistic'\n\n ensureSuspenseTimers(defaultedOptions)\n ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query)\n useClearResetErrorBoundary(errorResetBoundary)\n\n // this needs to be invoked before creating the Observer because that can create a cache entry\n const isNewCacheEntry = !client\n .getQueryCache()\n .get(defaultedOptions.queryHash)\n\n const [observer] = React.useState(\n () =>\n new Observer(\n client,\n defaultedOptions,\n ),\n )\n\n // note: this must be called before useSyncExternalStore\n const result = observer.getOptimisticResult(defaultedOptions)\n\n const shouldSubscribe = !isRestoring && options.subscribed !== false\n React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) => {\n const unsubscribe = shouldSubscribe\n ? observer.subscribe(notifyManager.batchCalls(onStoreChange))\n : noop\n\n // Update result to make sure we did not miss any query updates\n // between creating the observer and subscribing to it.\n observer.updateResult()\n\n return unsubscribe\n },\n [observer, shouldSubscribe],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n React.useEffect(() => {\n observer.setOptions(defaultedOptions)\n }, [defaultedOptions, observer])\n\n // Handle suspense\n if (shouldSuspend(defaultedOptions, result)) {\n throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n }\n\n // Handle error boundary\n if (\n getHasError({\n result,\n errorResetBoundary,\n throwOnError: defaultedOptions.throwOnError,\n query,\n suspense: defaultedOptions.suspense,\n })\n ) {\n throw result.error\n }\n\n ;(client.getDefaultOptions().queries as any)?._experimental_afterQuery?.(\n defaultedOptions,\n result,\n )\n\n if (\n defaultedOptions.experimental_prefetchInRender &&\n !isServer &&\n willFetch(result, isRestoring)\n ) {\n const promise = isNewCacheEntry\n ? // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted\n fetchOptimistic(defaultedOptions, observer, errorResetBoundary)\n : // subscribe to the \"cache promise\" so that we can finalize the currentThenable once data comes in\n query?.promise\n\n promise?.catch(noop).finally(() => {\n // `.updateResult()` will trigger `.#currentThenable` to finalize\n observer.updateResult()\n })\n }\n\n // Handle result property usage tracking\n return !defaultedOptions.notifyOnChangeProps\n ? observer.trackResult(result)\n : result\n}\n", "'use client'\nimport { QueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n NoInfer,\n QueryClient,\n QueryKey,\n} from '@tanstack/query-core'\nimport type {\n DefinedUseQueryResult,\n UseQueryOptions,\n UseQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataOptions,\n UndefinedInitialDataOptions,\n} from './queryOptions'\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions,\n queryClient?: QueryClient,\n): DefinedUseQueryResult, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions,\n queryClient?: QueryClient,\n): UseQueryResult, TError>\n\nexport function useQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseQueryOptions,\n queryClient?: QueryClient,\n): UseQueryResult, TError>\n\nexport function useQuery(options: UseQueryOptions, queryClient?: QueryClient) {\n return useBaseQuery(options, QueryObserver, queryClient)\n}\n", "'use client'\nimport { QueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\n\nexport function useSuspenseQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UseSuspenseQueryOptions,\n queryClient?: QueryClient,\n): UseSuspenseQueryResult {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n placeholderData: undefined,\n },\n QueryObserver,\n queryClient,\n ) as UseSuspenseQueryResult\n}\n", "'use client'\nimport { InfiniteQueryObserver, skipToken } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport { defaultThrowOnError } from './suspense'\nimport type {\n DefaultError,\n InfiniteData,\n InfiniteQueryObserverSuccessResult,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n UseSuspenseInfiniteQueryOptions,\n UseSuspenseInfiniteQueryResult,\n} from './types'\n\nexport function useSuspenseInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseSuspenseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseSuspenseInfiniteQueryResult {\n if (process.env.NODE_ENV !== 'production') {\n if ((options.queryFn as any) === skipToken) {\n console.error('skipToken is not allowed for useSuspenseInfiniteQuery')\n }\n }\n\n return useBaseQuery(\n {\n ...options,\n enabled: true,\n suspense: true,\n throwOnError: defaultThrowOnError,\n },\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n ) as InfiniteQueryObserverSuccessResult\n}\n", "'use client'\nimport { skipToken } from '@tanstack/query-core'\nimport { useQueries } from './useQueries'\nimport { defaultThrowOnError } from './suspense'\nimport type { UseSuspenseQueryOptions, UseSuspenseQueryResult } from './types'\nimport type {\n DefaultError,\n QueryClient,\n QueryFunction,\n ThrowOnError,\n} from '@tanstack/query-core'\n\n// Avoid TS depth-limit error in case of large array literal\ntype MAXIMUM_DEPTH = 20\n\n// Widen the type of the symbol to enable type inference even if skipToken is not immutable.\ntype SkipTokenForUseQueries = symbol\n\ntype GetUseSuspenseQueryOptions =\n // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }\n T extends {\n queryFnData: infer TQueryFnData\n error?: infer TError\n data: infer TData\n }\n ? UseSuspenseQueryOptions\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryOptions\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryOptions\n : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]\n T extends [infer TQueryFnData, infer TError, infer TData]\n ? UseSuspenseQueryOptions\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryOptions\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryOptions\n : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided\n T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey\n >\n : T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n throwOnError?: ThrowOnError\n }\n ? UseSuspenseQueryOptions<\n TQueryFnData,\n TError,\n TQueryFnData,\n TQueryKey\n >\n : // Fallback\n UseSuspenseQueryOptions\n\ntype GetUseSuspenseQueryResult =\n // Part 1: responsible for mapping explicit type parameter to function result, if object\n T extends { queryFnData: any; error?: infer TError; data: infer TData }\n ? UseSuspenseQueryResult\n : T extends { queryFnData: infer TQueryFnData; error?: infer TError }\n ? UseSuspenseQueryResult\n : T extends { data: infer TData; error?: infer TError }\n ? UseSuspenseQueryResult\n : // Part 2: responsible for mapping explicit type parameter to function result, if tuple\n T extends [any, infer TError, infer TData]\n ? UseSuspenseQueryResult\n : T extends [infer TQueryFnData, infer TError]\n ? UseSuspenseQueryResult\n : T extends [infer TQueryFnData]\n ? UseSuspenseQueryResult\n : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided\n T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n select?: (data: any) => infer TData\n throwOnError?: ThrowOnError\n }\n ? UseSuspenseQueryResult<\n unknown extends TData ? TQueryFnData : TData,\n unknown extends TError ? DefaultError : TError\n >\n : T extends {\n queryFn?:\n | QueryFunction\n | SkipTokenForUseQueries\n throwOnError?: ThrowOnError\n }\n ? UseSuspenseQueryResult<\n TQueryFnData,\n unknown extends TError ? DefaultError : TError\n >\n : // Fallback\n UseSuspenseQueryResult\n\n/**\n * SuspenseQueriesOptions reducer recursively unwraps function arguments to infer/enforce type param\n */\nexport type SuspenseQueriesOptions<\n T extends Array,\n TResults extends Array = [],\n TDepth extends ReadonlyArray = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryOptions]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesOptions<\n [...Tails],\n [...TResults, GetUseSuspenseQueryOptions],\n [...TDepth, 1]\n >\n : Array extends T\n ? T\n : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!\n // use this to infer the param types in the case of Array.map() argument\n T extends Array<\n UseSuspenseQueryOptions<\n infer TQueryFnData,\n infer TError,\n infer TData,\n infer TQueryKey\n >\n >\n ? Array<\n UseSuspenseQueryOptions\n >\n : // Fallback\n Array\n\n/**\n * SuspenseQueriesResults reducer recursively maps type param to results\n */\nexport type SuspenseQueriesResults<\n T extends Array,\n TResults extends Array = [],\n TDepth extends ReadonlyArray = [],\n> = TDepth['length'] extends MAXIMUM_DEPTH\n ? Array\n : T extends []\n ? []\n : T extends [infer Head]\n ? [...TResults, GetUseSuspenseQueryResult]\n : T extends [infer Head, ...infer Tails]\n ? SuspenseQueriesResults<\n [...Tails],\n [...TResults, GetUseSuspenseQueryResult],\n [...TDepth, 1]\n >\n : { [K in keyof T]: GetUseSuspenseQueryResult }\n\nexport function useSuspenseQueries<\n T extends Array,\n TCombinedResult = SuspenseQueriesResults,\n>(\n options: {\n queries:\n | readonly [...SuspenseQueriesOptions]\n | readonly [...{ [K in keyof T]: GetUseSuspenseQueryOptions }]\n combine?: (result: SuspenseQueriesResults) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries<\n T extends Array,\n TCombinedResult = SuspenseQueriesResults,\n>(\n options: {\n queries: readonly [...SuspenseQueriesOptions]\n combine?: (result: SuspenseQueriesResults) => TCombinedResult\n },\n queryClient?: QueryClient,\n): TCombinedResult\n\nexport function useSuspenseQueries(options: any, queryClient?: QueryClient) {\n return useQueries(\n {\n ...options,\n queries: options.queries.map((query: any) => {\n if (process.env.NODE_ENV !== 'production') {\n if (query.queryFn === skipToken) {\n console.error('skipToken is not allowed for useSuspenseQueries')\n }\n }\n\n return {\n ...query,\n suspense: true,\n throwOnError: defaultThrowOnError,\n enabled: true,\n placeholderData: undefined,\n }\n }),\n },\n queryClient,\n )\n}\n", "import { useQueryClient } from './QueryClientProvider'\nimport type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'\nimport type { UsePrefetchQueryOptions } from './types'\n\nexport function usePrefetchQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UsePrefetchQueryOptions,\n queryClient?: QueryClient,\n) {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n client.prefetchQuery(options)\n }\n}\n", "import { useQueryClient } from './QueryClientProvider'\nimport type {\n DefaultError,\n FetchInfiniteQueryOptions,\n QueryClient,\n QueryKey,\n} from '@tanstack/query-core'\n\nexport function usePrefetchInfiniteQuery<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: FetchInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n) {\n const client = useQueryClient(queryClient)\n\n if (!client.getQueryState(options.queryKey)) {\n client.prefetchInfiniteQuery(options)\n }\n}\n", "import type {\n DataTag,\n DefaultError,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryFunction,\n QueryKey,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseQueryOptions } from './types'\n\nexport type UndefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = UseQueryOptions & {\n initialData?:\n | undefined\n | InitialDataFunction>\n | NonUndefinedGuard\n}\n\nexport type UnusedSkipTokenOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = OmitKeyof<\n UseQueryOptions,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseQueryOptions['queryFn'],\n SkipToken | undefined\n >\n}\n\nexport type DefinedInitialDataOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n> = Omit, 'queryFn'> & {\n initialData:\n | NonUndefinedGuard\n | (() => NonUndefinedGuard)\n queryFn?: QueryFunction\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: DefinedInitialDataOptions,\n): DefinedInitialDataOptions & {\n queryKey: DataTag\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UnusedSkipTokenOptions,\n): UnusedSkipTokenOptions & {\n queryKey: DataTag\n}\n\nexport function queryOptions<\n TQueryFnData = unknown,\n TError = DefaultError,\n TData = TQueryFnData,\n TQueryKey extends QueryKey = QueryKey,\n>(\n options: UndefinedInitialDataOptions,\n): UndefinedInitialDataOptions & {\n queryKey: DataTag\n}\n\nexport function queryOptions(options: unknown) {\n return options\n}\n", "import type {\n DataTag,\n DefaultError,\n InfiniteData,\n InitialDataFunction,\n NonUndefinedGuard,\n OmitKeyof,\n QueryKey,\n SkipToken,\n} from '@tanstack/query-core'\nimport type { UseInfiniteQueryOptions } from './types'\n\nexport type UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData?:\n | undefined\n | NonUndefinedGuard>\n | InitialDataFunction<\n NonUndefinedGuard>\n >\n}\n\nexport type UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = OmitKeyof<\n UseInfiniteQueryOptions,\n 'queryFn'\n> & {\n queryFn?: Exclude<\n UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >['queryFn'],\n SkipToken | undefined\n >\n}\n\nexport type DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n> = UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n initialData:\n | NonUndefinedGuard>\n | (() => NonUndefinedGuard>)\n | undefined\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag, TError>\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UnusedSkipTokenInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag, TError>\n}\n\nexport function infiniteQueryOptions<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n): UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n> & {\n queryKey: DataTag, TError>\n}\n\nexport function infiniteQueryOptions(options: unknown) {\n return options\n}\n", "'use client'\nimport * as React from 'react'\n\nimport { hydrate } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n DehydratedState,\n HydrateOptions,\n OmitKeyof,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport interface HydrationBoundaryProps {\n state: DehydratedState | null | undefined\n options?: OmitKeyof & {\n defaultOptions?: OmitKeyof<\n Exclude,\n 'mutations'\n >\n }\n children?: React.ReactNode\n queryClient?: QueryClient\n}\n\nexport const HydrationBoundary = ({\n children,\n options = {},\n state,\n queryClient,\n}: HydrationBoundaryProps) => {\n const client = useQueryClient(queryClient)\n\n const optionsRef = React.useRef(options)\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n // This useMemo is for performance reasons only, everything inside it must\n // be safe to run in every render and code here should be read as \"in render\".\n //\n // This code needs to happen during the render phase, because after initial\n // SSR, hydration needs to happen _before_ children render. Also, if hydrating\n // during a transition, we want to hydrate as much as is safe in render so\n // we can prerender as much as possible.\n //\n // For any queries that already exist in the cache, we want to hold back on\n // hydrating until _after_ the render phase. The reason for this is that during\n // transitions, we don't want the existing queries and observers to update to\n // the new data on the current page, only _after_ the transition is committed.\n // If the transition is aborted, we will have hydrated any _new_ queries, but\n // we throw away the fresh data for any existing ones to avoid unexpectedly\n // updating the UI.\n const hydrationQueue: DehydratedState['queries'] | undefined =\n React.useMemo(() => {\n if (state) {\n if (typeof state !== 'object') {\n return\n }\n\n const queryCache = client.getQueryCache()\n // State is supplied from the outside and we might as well fail\n // gracefully if it has the wrong shape, so while we type `queries`\n // as required, we still provide a fallback.\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n const queries = state.queries || []\n\n const newQueries: DehydratedState['queries'] = []\n const existingQueries: DehydratedState['queries'] = []\n for (const dehydratedQuery of queries) {\n const existingQuery = queryCache.get(dehydratedQuery.queryHash)\n\n if (!existingQuery) {\n newQueries.push(dehydratedQuery)\n } else {\n const hydrationIsNewer =\n dehydratedQuery.state.dataUpdatedAt >\n existingQuery.state.dataUpdatedAt ||\n (dehydratedQuery.promise &&\n existingQuery.state.status !== 'pending' &&\n existingQuery.state.fetchStatus !== 'fetching' &&\n dehydratedQuery.dehydratedAt !== undefined &&\n dehydratedQuery.dehydratedAt >\n existingQuery.state.dataUpdatedAt)\n\n if (hydrationIsNewer) {\n existingQueries.push(dehydratedQuery)\n }\n }\n }\n\n if (newQueries.length > 0) {\n // It's actually fine to call this with queries/state that already exists\n // in the cache, or is older. hydrate() is idempotent for queries.\n // eslint-disable-next-line react-hooks/refs\n hydrate(client, { queries: newQueries }, optionsRef.current)\n }\n if (existingQueries.length > 0) {\n return existingQueries\n }\n }\n return undefined\n }, [client, state])\n\n React.useEffect(() => {\n if (hydrationQueue) {\n hydrate(client, { queries: hydrationQueue }, optionsRef.current)\n }\n }, [client, hydrationQueue])\n\n return children as React.ReactElement\n}\n", "'use client'\nimport * as React from 'react'\nimport { notifyManager } from '@tanstack/query-core'\n\nimport { useQueryClient } from './QueryClientProvider'\nimport type { QueryClient, QueryFilters } from '@tanstack/query-core'\n\nexport function useIsFetching(\n filters?: QueryFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n const queryCache = client.getQueryCache()\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n queryCache.subscribe(notifyManager.batchCalls(onStoreChange)),\n [queryCache],\n ),\n () => client.isFetching(filters),\n () => client.isFetching(filters),\n )\n}\n", "'use client'\nimport * as React from 'react'\n\nimport { notifyManager, replaceEqualDeep } from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n Mutation,\n MutationCache,\n MutationFilters,\n MutationState,\n QueryClient,\n} from '@tanstack/query-core'\n\nexport function useIsMutating(\n filters?: MutationFilters,\n queryClient?: QueryClient,\n): number {\n const client = useQueryClient(queryClient)\n return useMutationState(\n { filters: { ...filters, status: 'pending' } },\n client,\n ).length\n}\n\ntype MutationStateOptions = {\n filters?: MutationFilters\n select?: (mutation: Mutation) => TResult\n}\n\nfunction getResult(\n mutationCache: MutationCache,\n options: MutationStateOptions,\n): Array {\n return mutationCache\n .findAll(options.filters)\n .map(\n (mutation): TResult =>\n (options.select ? options.select(mutation) : mutation.state) as TResult,\n )\n}\n\nexport function useMutationState(\n options: MutationStateOptions = {},\n queryClient?: QueryClient,\n): Array {\n const mutationCache = useQueryClient(queryClient).getMutationCache()\n const optionsRef = React.useRef(options)\n const result = React.useRef>(null)\n if (result.current === null) {\n result.current = getResult(mutationCache, options)\n }\n\n React.useEffect(() => {\n optionsRef.current = options\n })\n\n return React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n mutationCache.subscribe(() => {\n const nextResult = replaceEqualDeep(\n result.current,\n getResult(mutationCache, optionsRef.current),\n )\n if (result.current !== nextResult) {\n result.current = nextResult\n notifyManager.schedule(onStoreChange)\n }\n }),\n [mutationCache],\n ),\n () => result.current,\n () => result.current,\n )!\n}\n", "'use client'\nimport * as React from 'react'\nimport {\n MutationObserver,\n noop,\n notifyManager,\n shouldThrowError,\n} from '@tanstack/query-core'\nimport { useQueryClient } from './QueryClientProvider'\nimport type {\n UseMutateFunction,\n UseMutationOptions,\n UseMutationResult,\n} from './types'\nimport type { DefaultError, QueryClient } from '@tanstack/query-core'\n\n// HOOK\n\nexport function useMutation<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions,\n queryClient?: QueryClient,\n): UseMutationResult {\n const client = useQueryClient(queryClient)\n\n const [observer] = React.useState(\n () =>\n new MutationObserver(\n client,\n options,\n ),\n )\n\n React.useEffect(() => {\n observer.setOptions(options)\n }, [observer, options])\n\n const result = React.useSyncExternalStore(\n React.useCallback(\n (onStoreChange) =>\n observer.subscribe(notifyManager.batchCalls(onStoreChange)),\n [observer],\n ),\n () => observer.getCurrentResult(),\n () => observer.getCurrentResult(),\n )\n\n const mutate = React.useCallback<\n UseMutateFunction\n >(\n (variables, mutateOptions) => {\n observer.mutate(variables, mutateOptions).catch(noop)\n },\n [observer],\n )\n\n if (\n result.error &&\n shouldThrowError(observer.options.throwOnError, [result.error])\n ) {\n throw result.error\n }\n\n return { ...result, mutate, mutateAsync: result.mutate }\n}\n", "import type { DefaultError, WithRequired } from '@tanstack/query-core'\nimport type { UseMutationOptions } from './types'\n\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: WithRequired<\n UseMutationOptions,\n 'mutationKey'\n >,\n): WithRequired<\n UseMutationOptions,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: Omit<\n UseMutationOptions,\n 'mutationKey'\n >,\n): Omit<\n UseMutationOptions,\n 'mutationKey'\n>\nexport function mutationOptions<\n TData = unknown,\n TError = DefaultError,\n TVariables = void,\n TOnMutateResult = unknown,\n>(\n options: UseMutationOptions,\n): UseMutationOptions {\n return options\n}\n", "'use client'\nimport { InfiniteQueryObserver } from '@tanstack/query-core'\nimport { useBaseQuery } from './useBaseQuery'\nimport type {\n DefaultError,\n InfiniteData,\n QueryClient,\n QueryKey,\n QueryObserver,\n} from '@tanstack/query-core'\nimport type {\n DefinedUseInfiniteQueryResult,\n UseInfiniteQueryOptions,\n UseInfiniteQueryResult,\n} from './types'\nimport type {\n DefinedInitialDataInfiniteOptions,\n UndefinedInitialDataInfiniteOptions,\n} from './infiniteQueryOptions'\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: DefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): DefinedUseInfiniteQueryResult\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UndefinedInitialDataInfiniteOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult\n\nexport function useInfiniteQuery<\n TQueryFnData,\n TError = DefaultError,\n TData = InfiniteData,\n TQueryKey extends QueryKey = QueryKey,\n TPageParam = unknown,\n>(\n options: UseInfiniteQueryOptions<\n TQueryFnData,\n TError,\n TData,\n TQueryKey,\n TPageParam\n >,\n queryClient?: QueryClient,\n): UseInfiniteQueryResult\n\nexport function useInfiniteQuery(\n options: UseInfiniteQueryOptions,\n queryClient?: QueryClient,\n) {\n return useBaseQuery(\n options,\n InfiniteQueryObserver as typeof QueryObserver,\n queryClient,\n )\n}\n"], + "mappings": "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", + "names": ["mutationOptions", "queryFnContext", "context", "queryFnContext", "getDefaultState", "getDefaultState", "React", "React", "React", "import_jsx_runtime", "React", "queryOptions", "React", "React", "React", "React", "React"] +} diff --git a/factory/.context/vite-cache/deps/@tanstack_react-router.js b/factory/.context/vite-cache/deps/@tanstack_react-router.js new file mode 100644 index 0000000..8d218b5 --- /dev/null +++ b/factory/.context/vite-cache/deps/@tanstack_react-router.js @@ -0,0 +1,9377 @@ +import { + require_react_dom +} from "./chunk-JD3UC7WK.js"; +import { + require_jsx_runtime +} from "./chunk-L53IR3KW.js"; +import { + require_react +} from "./chunk-776SV3ZX.js"; +import { + __commonJS, + __toESM +} from "./chunk-V4OQ3NZ2.js"; + +// ../../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.4/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js +var require_use_sync_external_store_shim_development = __commonJS({ + "../../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.4/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js"(exports) { + "use strict"; + (function() { + function is(x, y) { + return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y; + } + function useSyncExternalStore$2(subscribe2, getSnapshot) { + didWarnOld18Alpha || void 0 === React18.startTransition || (didWarnOld18Alpha = true, console.error( + "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release." + )); + var value = getSnapshot(); + if (!didWarnUncachedGetSnapshot) { + var cachedValue = getSnapshot(); + objectIs(value, cachedValue) || (console.error( + "The result of getSnapshot should be cached to avoid an infinite loop" + ), didWarnUncachedGetSnapshot = true); + } + cachedValue = useState5({ + inst: { value, getSnapshot } + }); + var inst = cachedValue[0].inst, forceUpdate = cachedValue[1]; + useLayoutEffect3( + function() { + inst.value = value; + inst.getSnapshot = getSnapshot; + checkIfSnapshotChanged(inst) && forceUpdate({ inst }); + }, + [subscribe2, value, getSnapshot] + ); + useEffect7( + function() { + checkIfSnapshotChanged(inst) && forceUpdate({ inst }); + return subscribe2(function() { + checkIfSnapshotChanged(inst) && forceUpdate({ inst }); + }); + }, + [subscribe2] + ); + useDebugValue(value); + return value; + } + function checkIfSnapshotChanged(inst) { + var latestGetSnapshot = inst.getSnapshot; + inst = inst.value; + try { + var nextValue = latestGetSnapshot(); + return !objectIs(inst, nextValue); + } catch (error) { + return true; + } + } + function useSyncExternalStore$1(subscribe2, getSnapshot) { + return getSnapshot(); + } + "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error()); + var React18 = require_react(), objectIs = "function" === typeof Object.is ? Object.is : is, useState5 = React18.useState, useEffect7 = React18.useEffect, useLayoutEffect3 = React18.useLayoutEffect, useDebugValue = React18.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2; + exports.useSyncExternalStore = void 0 !== React18.useSyncExternalStore ? React18.useSyncExternalStore : shim; + "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error()); + })(); + } +}); + +// ../../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.4/node_modules/use-sync-external-store/shim/index.js +var require_shim = __commonJS({ + "../../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.4/node_modules/use-sync-external-store/shim/index.js"(exports, module) { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_use_sync_external_store_shim_development(); + } + } +}); + +// ../../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.4/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js +var require_with_selector_development = __commonJS({ + "../../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.4/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js"(exports) { + "use strict"; + (function() { + function is(x, y) { + return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y; + } + "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error()); + var React18 = require_react(), shim = require_shim(), objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = shim.useSyncExternalStore, useRef7 = React18.useRef, useEffect7 = React18.useEffect, useMemo4 = React18.useMemo, useDebugValue = React18.useDebugValue; + exports.useSyncExternalStoreWithSelector = function(subscribe2, getSnapshot, getServerSnapshot, selector, isEqual) { + var instRef = useRef7(null); + if (null === instRef.current) { + var inst = { hasValue: false, value: null }; + instRef.current = inst; + } else inst = instRef.current; + instRef = useMemo4( + function() { + function memoizedSelector(nextSnapshot) { + if (!hasMemo) { + hasMemo = true; + memoizedSnapshot = nextSnapshot; + nextSnapshot = selector(nextSnapshot); + if (void 0 !== isEqual && inst.hasValue) { + var currentSelection = inst.value; + if (isEqual(currentSelection, nextSnapshot)) + return memoizedSelection = currentSelection; + } + return memoizedSelection = nextSnapshot; + } + currentSelection = memoizedSelection; + if (objectIs(memoizedSnapshot, nextSnapshot)) + return currentSelection; + var nextSelection = selector(nextSnapshot); + if (void 0 !== isEqual && isEqual(currentSelection, nextSelection)) + return memoizedSnapshot = nextSnapshot, currentSelection; + memoizedSnapshot = nextSnapshot; + return memoizedSelection = nextSelection; + } + var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot; + return [ + function() { + return memoizedSelector(getSnapshot()); + }, + null === maybeGetServerSnapshot ? void 0 : function() { + return memoizedSelector(maybeGetServerSnapshot()); + } + ]; + }, + [getSnapshot, getServerSnapshot, selector, isEqual] + ); + var value = useSyncExternalStore(subscribe2, instRef[0], instRef[1]); + useEffect7( + function() { + inst.hasValue = true; + inst.value = value; + }, + [value] + ); + useDebugValue(value); + return value; + }; + "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error()); + })(); + } +}); + +// ../../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.4/node_modules/use-sync-external-store/shim/with-selector.js +var require_with_selector = __commonJS({ + "../../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.4/node_modules/use-sync-external-store/shim/with-selector.js"(exports, module) { + "use strict"; + if (false) { + module.exports = null; + } else { + module.exports = require_with_selector_development(); + } + } +}); + +// ../../../node_modules/.pnpm/@tanstack+store@0.9.2/node_modules/@tanstack/store/dist/esm/alien.js +var ReactiveFlags = ((ReactiveFlags2) => { + ReactiveFlags2[ReactiveFlags2["None"] = 0] = "None"; + ReactiveFlags2[ReactiveFlags2["Mutable"] = 1] = "Mutable"; + ReactiveFlags2[ReactiveFlags2["Watching"] = 2] = "Watching"; + ReactiveFlags2[ReactiveFlags2["RecursedCheck"] = 4] = "RecursedCheck"; + ReactiveFlags2[ReactiveFlags2["Recursed"] = 8] = "Recursed"; + ReactiveFlags2[ReactiveFlags2["Dirty"] = 16] = "Dirty"; + ReactiveFlags2[ReactiveFlags2["Pending"] = 32] = "Pending"; + return ReactiveFlags2; +})(ReactiveFlags || {}); +function createReactiveSystem({ + update, + notify, + unwatched +}) { + return { + link: link22, + unlink: unlink22, + propagate: propagate22, + checkDirty: checkDirty22, + shallowPropagate: shallowPropagate22 + }; + function link22(dep, sub, version) { + const prevDep = sub.depsTail; + if (prevDep !== void 0 && prevDep.dep === dep) { + return; + } + const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps; + if (nextDep !== void 0 && nextDep.dep === dep) { + nextDep.version = version; + sub.depsTail = nextDep; + return; + } + const prevSub = dep.subsTail; + if (prevSub !== void 0 && prevSub.version === version && prevSub.sub === sub) { + return; + } + const newLink = sub.depsTail = dep.subsTail = { + version, + dep, + sub, + prevDep, + nextDep, + prevSub, + nextSub: void 0 + }; + if (nextDep !== void 0) { + nextDep.prevDep = newLink; + } + if (prevDep !== void 0) { + prevDep.nextDep = newLink; + } else { + sub.deps = newLink; + } + if (prevSub !== void 0) { + prevSub.nextSub = newLink; + } else { + dep.subs = newLink; + } + } + function unlink22(link3, sub = link3.sub) { + const dep = link3.dep; + const prevDep = link3.prevDep; + const nextDep = link3.nextDep; + const nextSub = link3.nextSub; + const prevSub = link3.prevSub; + if (nextDep !== void 0) { + nextDep.prevDep = prevDep; + } else { + sub.depsTail = prevDep; + } + if (prevDep !== void 0) { + prevDep.nextDep = nextDep; + } else { + sub.deps = nextDep; + } + if (nextSub !== void 0) { + nextSub.prevSub = prevSub; + } else { + dep.subsTail = prevSub; + } + if (prevSub !== void 0) { + prevSub.nextSub = nextSub; + } else if ((dep.subs = nextSub) === void 0) { + unwatched(dep); + } + return nextDep; + } + function propagate22(link3) { + let next = link3.nextSub; + let stack; + top: do { + const sub = link3.sub; + let flags = sub.flags; + if (!(flags & (4 | 8 | 16 | 32))) { + sub.flags = flags | 32; + } else if (!(flags & (4 | 8))) { + flags = 0; + } else if (!(flags & 4)) { + sub.flags = flags & -9 | 32; + } else if (!(flags & (16 | 32)) && isValidLink(link3, sub)) { + sub.flags = flags | (8 | 32); + flags &= 1; + } else { + flags = 0; + } + if (flags & 2) { + notify(sub); + } + if (flags & 1) { + const subSubs = sub.subs; + if (subSubs !== void 0) { + const nextSub = (link3 = subSubs).nextSub; + if (nextSub !== void 0) { + stack = { value: next, prev: stack }; + next = nextSub; + } + continue; + } + } + if ((link3 = next) !== void 0) { + next = link3.nextSub; + continue; + } + while (stack !== void 0) { + link3 = stack.value; + stack = stack.prev; + if (link3 !== void 0) { + next = link3.nextSub; + continue top; + } + } + break; + } while (true); + } + function checkDirty22(link3, sub) { + let stack; + let checkDepth = 0; + let dirty = false; + top: do { + const dep = link3.dep; + const flags = dep.flags; + if (sub.flags & 16) { + dirty = true; + } else if ((flags & (1 | 16)) === (1 | 16)) { + if (update(dep)) { + const subs = dep.subs; + if (subs.nextSub !== void 0) { + shallowPropagate22(subs); + } + dirty = true; + } + } else if ((flags & (1 | 32)) === (1 | 32)) { + if (link3.nextSub !== void 0 || link3.prevSub !== void 0) { + stack = { value: link3, prev: stack }; + } + link3 = dep.deps; + sub = dep; + ++checkDepth; + continue; + } + if (!dirty) { + const nextDep = link3.nextDep; + if (nextDep !== void 0) { + link3 = nextDep; + continue; + } + } + while (checkDepth--) { + const firstSub = sub.subs; + const hasMultipleSubs = firstSub.nextSub !== void 0; + if (hasMultipleSubs) { + link3 = stack.value; + stack = stack.prev; + } else { + link3 = firstSub; + } + if (dirty) { + if (update(sub)) { + if (hasMultipleSubs) { + shallowPropagate22(firstSub); + } + sub = link3.sub; + continue; + } + dirty = false; + } else { + sub.flags &= -33; + } + sub = link3.sub; + const nextDep = link3.nextDep; + if (nextDep !== void 0) { + link3 = nextDep; + continue top; + } + } + return dirty; + } while (true); + } + function shallowPropagate22(link3) { + do { + const sub = link3.sub; + const flags = sub.flags; + if ((flags & (32 | 16)) === 32) { + sub.flags = flags | 16; + if ((flags & (2 | 4)) === 2) { + notify(sub); + } + } + } while ((link3 = link3.nextSub) !== void 0); + } + function isValidLink(checkLink, sub) { + let link3 = sub.depsTail; + while (link3 !== void 0) { + if (link3 === checkLink) { + return true; + } + link3 = link3.prevDep; + } + return false; + } +} +var batchDepth = 0; +var notifyIndex = 0; +var queuedLength = 0; +var queued = []; +var { link, unlink, propagate, checkDirty, shallowPropagate } = createReactiveSystem({ + update(node) { + if (node.depsTail !== void 0) { + return updateComputed(node); + } else { + return updateSignal(node); + } + }, + notify(effect2) { + let insertIndex = queuedLength; + let firstInsertedIndex = insertIndex; + do { + queued[insertIndex++] = effect2; + effect2.flags &= -3; + effect2 = effect2.subs?.sub; + if (effect2 === void 0 || !(effect2.flags & 2)) { + break; + } + } while (true); + queuedLength = insertIndex; + while (firstInsertedIndex < --insertIndex) { + const left = queued[firstInsertedIndex]; + queued[firstInsertedIndex++] = queued[insertIndex]; + queued[insertIndex] = left; + } + }, + unwatched(node) { + if (!(node.flags & 1)) { + effectScopeOper.call(node); + } else if (node.depsTail !== void 0) { + node.depsTail = void 0; + node.flags = 1 | 16; + purgeDeps(node); + } + } +}); +function getBatchDepth() { + return batchDepth; +} +function startBatch() { + ++batchDepth; +} +function endBatch() { + if (!--batchDepth) { + flush(); + } +} +function updateComputed(c) { + c.depsTail = void 0; + c.flags = 1 | 4; + try { + const oldValue = c.value; + return oldValue !== (c.value = c.getter(oldValue)); + } finally { + c.flags &= -5; + purgeDeps(c); + } +} +function updateSignal(s) { + s.flags = 1; + return s.currentValue !== (s.currentValue = s.pendingValue); +} +function run(e) { + const flags = e.flags; + if (flags & 16 || flags & 32 && checkDirty(e.deps, e)) { + e.depsTail = void 0; + e.flags = 2 | 4; + try { + ; + e.fn(); + } finally { + e.flags &= -5; + purgeDeps(e); + } + } else { + e.flags = 2; + } +} +function flush() { + try { + while (notifyIndex < queuedLength) { + const effect2 = queued[notifyIndex]; + queued[notifyIndex++] = void 0; + run(effect2); + } + } finally { + while (notifyIndex < queuedLength) { + const effect2 = queued[notifyIndex]; + queued[notifyIndex++] = void 0; + effect2.flags |= 2 | 8; + } + notifyIndex = 0; + queuedLength = 0; + } +} +function effectScopeOper() { + this.depsTail = void 0; + this.flags = 0; + purgeDeps(this); + const sub = this.subs; + if (sub !== void 0) { + unlink(sub); + } +} +function purgeDeps(sub) { + const depsTail = sub.depsTail; + let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps; + while (dep !== void 0) { + dep = unlink(dep, sub); + } +} + +// ../../../node_modules/.pnpm/@tanstack+store@0.9.2/node_modules/@tanstack/store/dist/esm/atom.js +function toObserver(nextHandler, errorHandler, completionHandler) { + const isObserver = typeof nextHandler === "object"; + const self2 = isObserver ? nextHandler : void 0; + return { + next: (isObserver ? nextHandler.next : nextHandler)?.bind(self2), + error: (isObserver ? nextHandler.error : errorHandler)?.bind(self2), + complete: (isObserver ? nextHandler.complete : completionHandler)?.bind( + self2 + ) + }; +} +var queuedEffects = []; +var cycle = 0; +var { link: link2, unlink: unlink2, propagate: propagate2, checkDirty: checkDirty2, shallowPropagate: shallowPropagate2 } = createReactiveSystem({ + update(atom) { + return atom._update(); + }, + // eslint-disable-next-line no-shadow + notify(effect2) { + queuedEffects[queuedEffectsLength++] = effect2; + effect2.flags &= ~ReactiveFlags.Watching; + }, + unwatched(atom) { + if (atom.depsTail !== void 0) { + atom.depsTail = void 0; + atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty; + purgeDeps2(atom); + } + } +}); +var notifyIndex2 = 0; +var queuedEffectsLength = 0; +var activeSub; +function purgeDeps2(sub) { + const depsTail = sub.depsTail; + let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps; + while (dep !== void 0) { + dep = unlink2(dep, sub); + } +} +function flush2() { + if (getBatchDepth() > 0) { + return; + } + while (notifyIndex2 < queuedEffectsLength) { + const effect2 = queuedEffects[notifyIndex2]; + queuedEffects[notifyIndex2++] = void 0; + effect2.notify(); + } + notifyIndex2 = 0; + queuedEffectsLength = 0; +} +function createAtom(valueOrFn, options) { + const isComputed = typeof valueOrFn === "function"; + const getter = valueOrFn; + const atom = { + _snapshot: isComputed ? void 0 : valueOrFn, + subs: void 0, + subsTail: void 0, + deps: void 0, + depsTail: void 0, + flags: isComputed ? ReactiveFlags.None : ReactiveFlags.Mutable, + get() { + if (activeSub !== void 0) { + link2(atom, activeSub, cycle); + } + return atom._snapshot; + }, + subscribe(observerOrFn) { + const obs = toObserver(observerOrFn); + const observed = { current: false }; + const e = effect(() => { + atom.get(); + if (!observed.current) { + observed.current = true; + } else { + obs.next?.(atom._snapshot); + } + }); + return { + unsubscribe: () => { + e.stop(); + } + }; + }, + _update(getValue) { + const prevSub = activeSub; + const compare = options?.compare ?? Object.is; + if (isComputed) { + activeSub = atom; + ++cycle; + atom.depsTail = void 0; + } else if (getValue === void 0) { + return false; + } + if (isComputed) { + atom.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck; + } + try { + const oldValue = atom._snapshot; + const newValue = typeof getValue === "function" ? getValue(oldValue) : getValue === void 0 && isComputed ? getter(oldValue) : getValue; + if (oldValue === void 0 || !compare(oldValue, newValue)) { + atom._snapshot = newValue; + return true; + } + return false; + } finally { + activeSub = prevSub; + if (isComputed) { + atom.flags &= ~ReactiveFlags.RecursedCheck; + } + purgeDeps2(atom); + } + } + }; + if (isComputed) { + atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty; + atom.get = function() { + const flags = atom.flags; + if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty2(atom.deps, atom)) { + if (atom._update()) { + const subs = atom.subs; + if (subs !== void 0) { + shallowPropagate2(subs); + } + } + } else if (flags & ReactiveFlags.Pending) { + atom.flags = flags & ~ReactiveFlags.Pending; + } + if (activeSub !== void 0) { + link2(atom, activeSub, cycle); + } + return atom._snapshot; + }; + } else { + atom.set = function(valueOrFn2) { + if (atom._update(valueOrFn2)) { + const subs = atom.subs; + if (subs !== void 0) { + propagate2(subs); + shallowPropagate2(subs); + flush2(); + } + } + }; + } + return atom; +} +function effect(fn) { + const run2 = () => { + const prevSub = activeSub; + activeSub = effectObj; + ++cycle; + effectObj.depsTail = void 0; + effectObj.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck; + try { + return fn(); + } finally { + activeSub = prevSub; + effectObj.flags &= ~ReactiveFlags.RecursedCheck; + purgeDeps2(effectObj); + } + }; + const effectObj = { + deps: void 0, + depsTail: void 0, + subs: void 0, + subsTail: void 0, + flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck, + notify() { + const flags = this.flags; + if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty2(this.deps, this)) { + run2(); + } else { + this.flags = ReactiveFlags.Watching; + } + }, + stop() { + this.flags = ReactiveFlags.None; + this.depsTail = void 0; + purgeDeps2(this); + } + }; + run2(); + return effectObj; +} + +// ../../../node_modules/.pnpm/@tanstack+store@0.9.2/node_modules/@tanstack/store/dist/esm/store.js +var Store = class { + constructor(valueOrFn) { + this.atom = createAtom( + valueOrFn + ); + } + setState(updater) { + this.atom.set(updater); + } + get state() { + return this.atom.get(); + } + get() { + return this.state; + } + subscribe(observerOrFn) { + return this.atom.subscribe(toObserver(observerOrFn)); + } +}; +var ReadonlyStore = class { + constructor(valueOrFn) { + this.atom = createAtom( + valueOrFn + ); + } + get state() { + return this.atom.get(); + } + get() { + return this.state; + } + subscribe(observerOrFn) { + return this.atom.subscribe(toObserver(observerOrFn)); + } +}; +function createStore(valueOrFn) { + if (typeof valueOrFn === "function") { + return new ReadonlyStore(valueOrFn); + } + return new Store(valueOrFn); +} + +// ../../../node_modules/.pnpm/@tanstack+store@0.9.2/node_modules/@tanstack/store/dist/esm/batch.js +function batch(fn) { + try { + startBatch(); + fn(); + } finally { + endBatch(); + flush2(); + } +} + +// ../../../node_modules/.pnpm/@tanstack+history@1.161.4/node_modules/@tanstack/history/dist/esm/index.js +var stateIndexKey = "__TSR_index"; +var popStateEvent = "popstate"; +var beforeUnloadEvent = "beforeunload"; +function createHistory(opts) { + let location = opts.getLocation(); + const subscribers = /* @__PURE__ */ new Set(); + const notify = (action) => { + location = opts.getLocation(); + subscribers.forEach((subscriber) => subscriber({ location, action })); + }; + const handleIndexChange = (action) => { + if (opts.notifyOnIndexChange ?? true) notify(action); + else location = opts.getLocation(); + }; + const tryNavigation = async ({ + task, + navigateOpts, + ...actionInfo + }) => { + const ignoreBlocker = navigateOpts?.ignoreBlocker ?? false; + if (ignoreBlocker) { + task(); + return; + } + const blockers = opts.getBlockers?.() ?? []; + const isPushOrReplace = actionInfo.type === "PUSH" || actionInfo.type === "REPLACE"; + if (typeof document !== "undefined" && blockers.length && isPushOrReplace) { + for (const blocker of blockers) { + const nextLocation = parseHref(actionInfo.path, actionInfo.state); + const isBlocked = await blocker.blockerFn({ + currentLocation: location, + nextLocation, + action: actionInfo.type + }); + if (isBlocked) { + opts.onBlocked?.(); + return; + } + } + } + task(); + }; + return { + get location() { + return location; + }, + get length() { + return opts.getLength(); + }, + subscribers, + subscribe: (cb) => { + subscribers.add(cb); + return () => { + subscribers.delete(cb); + }; + }, + push: (path, state, navigateOpts) => { + const currentIndex = location.state[stateIndexKey]; + state = assignKeyAndIndex(currentIndex + 1, state); + tryNavigation({ + task: () => { + opts.pushState(path, state); + notify({ type: "PUSH" }); + }, + navigateOpts, + type: "PUSH", + path, + state + }); + }, + replace: (path, state, navigateOpts) => { + const currentIndex = location.state[stateIndexKey]; + state = assignKeyAndIndex(currentIndex, state); + tryNavigation({ + task: () => { + opts.replaceState(path, state); + notify({ type: "REPLACE" }); + }, + navigateOpts, + type: "REPLACE", + path, + state + }); + }, + go: (index, navigateOpts) => { + tryNavigation({ + task: () => { + opts.go(index); + handleIndexChange({ type: "GO", index }); + }, + navigateOpts, + type: "GO" + }); + }, + back: (navigateOpts) => { + tryNavigation({ + task: () => { + opts.back(navigateOpts?.ignoreBlocker ?? false); + handleIndexChange({ type: "BACK" }); + }, + navigateOpts, + type: "BACK" + }); + }, + forward: (navigateOpts) => { + tryNavigation({ + task: () => { + opts.forward(navigateOpts?.ignoreBlocker ?? false); + handleIndexChange({ type: "FORWARD" }); + }, + navigateOpts, + type: "FORWARD" + }); + }, + canGoBack: () => location.state[stateIndexKey] !== 0, + createHref: (str) => opts.createHref(str), + block: (blocker) => { + if (!opts.setBlockers) return () => { + }; + const blockers = opts.getBlockers?.() ?? []; + opts.setBlockers([...blockers, blocker]); + return () => { + const blockers2 = opts.getBlockers?.() ?? []; + opts.setBlockers?.(blockers2.filter((b) => b !== blocker)); + }; + }, + flush: () => opts.flush?.(), + destroy: () => opts.destroy?.(), + notify + }; +} +function assignKeyAndIndex(index, state) { + if (!state) { + state = {}; + } + const key = createRandomKey(); + return { + ...state, + key, + // TODO: Remove in v2 - use __TSR_key instead + __TSR_key: key, + [stateIndexKey]: index + }; +} +function createBrowserHistory(opts) { + const win = opts?.window ?? (typeof document !== "undefined" ? window : void 0); + const originalPushState = win.history.pushState; + const originalReplaceState = win.history.replaceState; + let blockers = []; + const _getBlockers = () => blockers; + const _setBlockers = (newBlockers) => blockers = newBlockers; + const createHref = opts?.createHref ?? ((path) => path); + const parseLocation = opts?.parseLocation ?? (() => parseHref( + `${win.location.pathname}${win.location.search}${win.location.hash}`, + win.history.state + )); + if (!win.history.state?.__TSR_key && !win.history.state?.key) { + const addedKey = createRandomKey(); + win.history.replaceState( + { + [stateIndexKey]: 0, + key: addedKey, + // TODO: Remove in v2 - use __TSR_key instead + __TSR_key: addedKey + }, + "" + ); + } + let currentLocation = parseLocation(); + let rollbackLocation; + let nextPopIsGo = false; + let ignoreNextPop = false; + let skipBlockerNextPop = false; + let ignoreNextBeforeUnload = false; + const getLocation = () => currentLocation; + let next; + let scheduled; + const flush3 = () => { + if (!next) { + return; + } + history._ignoreSubscribers = true; + (next.isPush ? win.history.pushState : win.history.replaceState)( + next.state, + "", + next.href + ); + history._ignoreSubscribers = false; + next = void 0; + scheduled = void 0; + rollbackLocation = void 0; + }; + const queueHistoryAction = (type, destHref, state) => { + const href = createHref(destHref); + if (!scheduled) { + rollbackLocation = currentLocation; + } + currentLocation = parseHref(destHref, state); + next = { + href, + state, + isPush: next?.isPush || type === "push" + }; + if (!scheduled) { + scheduled = Promise.resolve().then(() => flush3()); + } + }; + const onPushPop = (type) => { + currentLocation = parseLocation(); + history.notify({ type }); + }; + const onPushPopEvent = async () => { + if (ignoreNextPop) { + ignoreNextPop = false; + return; + } + const nextLocation = parseLocation(); + const delta = nextLocation.state[stateIndexKey] - currentLocation.state[stateIndexKey]; + const isForward = delta === 1; + const isBack = delta === -1; + const isGo = !isForward && !isBack || nextPopIsGo; + nextPopIsGo = false; + const action = isGo ? "GO" : isBack ? "BACK" : "FORWARD"; + const notify = isGo ? { + type: "GO", + index: delta + } : { + type: isBack ? "BACK" : "FORWARD" + }; + if (skipBlockerNextPop) { + skipBlockerNextPop = false; + } else { + const blockers2 = _getBlockers(); + if (typeof document !== "undefined" && blockers2.length) { + for (const blocker of blockers2) { + const isBlocked = await blocker.blockerFn({ + currentLocation, + nextLocation, + action + }); + if (isBlocked) { + ignoreNextPop = true; + win.history.go(1); + history.notify(notify); + return; + } + } + } + } + currentLocation = parseLocation(); + history.notify(notify); + }; + const onBeforeUnload = (e) => { + if (ignoreNextBeforeUnload) { + ignoreNextBeforeUnload = false; + return; + } + let shouldBlock = false; + const blockers2 = _getBlockers(); + if (typeof document !== "undefined" && blockers2.length) { + for (const blocker of blockers2) { + const shouldHaveBeforeUnload = blocker.enableBeforeUnload ?? true; + if (shouldHaveBeforeUnload === true) { + shouldBlock = true; + break; + } + if (typeof shouldHaveBeforeUnload === "function" && shouldHaveBeforeUnload() === true) { + shouldBlock = true; + break; + } + } + } + if (shouldBlock) { + e.preventDefault(); + return e.returnValue = ""; + } + return; + }; + const history = createHistory({ + getLocation, + getLength: () => win.history.length, + pushState: (href, state) => queueHistoryAction("push", href, state), + replaceState: (href, state) => queueHistoryAction("replace", href, state), + back: (ignoreBlocker) => { + if (ignoreBlocker) skipBlockerNextPop = true; + ignoreNextBeforeUnload = true; + return win.history.back(); + }, + forward: (ignoreBlocker) => { + if (ignoreBlocker) skipBlockerNextPop = true; + ignoreNextBeforeUnload = true; + win.history.forward(); + }, + go: (n) => { + nextPopIsGo = true; + win.history.go(n); + }, + createHref: (href) => createHref(href), + flush: flush3, + destroy: () => { + win.history.pushState = originalPushState; + win.history.replaceState = originalReplaceState; + win.removeEventListener(beforeUnloadEvent, onBeforeUnload, { + capture: true + }); + win.removeEventListener(popStateEvent, onPushPopEvent); + }, + onBlocked: () => { + if (rollbackLocation && currentLocation !== rollbackLocation) { + currentLocation = rollbackLocation; + } + }, + getBlockers: _getBlockers, + setBlockers: _setBlockers, + notifyOnIndexChange: false + }); + win.addEventListener(beforeUnloadEvent, onBeforeUnload, { capture: true }); + win.addEventListener(popStateEvent, onPushPopEvent); + win.history.pushState = function(...args) { + const res = originalPushState.apply(win.history, args); + if (!history._ignoreSubscribers) onPushPop("PUSH"); + return res; + }; + win.history.replaceState = function(...args) { + const res = originalReplaceState.apply(win.history, args); + if (!history._ignoreSubscribers) onPushPop("REPLACE"); + return res; + }; + return history; +} +function createHashHistory(opts) { + const win = opts?.window ?? (typeof document !== "undefined" ? window : void 0); + return createBrowserHistory({ + window: win, + parseLocation: () => { + const hashSplit = win.location.hash.split("#").slice(1); + const pathPart = hashSplit[0] ?? "/"; + const searchPart = win.location.search; + const hashEntries = hashSplit.slice(1); + const hashPart = hashEntries.length === 0 ? "" : `#${hashEntries.join("#")}`; + const hashHref = `${pathPart}${searchPart}${hashPart}`; + return parseHref(hashHref, win.history.state); + }, + createHref: (href) => `${win.location.pathname}${win.location.search}#${href}` + }); +} +function createMemoryHistory(opts = { + initialEntries: ["/"] +}) { + const entries = opts.initialEntries; + let index = opts.initialIndex ? Math.min(Math.max(opts.initialIndex, 0), entries.length - 1) : entries.length - 1; + const states = entries.map( + (_entry, index2) => assignKeyAndIndex(index2, void 0) + ); + const getLocation = () => parseHref(entries[index], states[index]); + let blockers = []; + const _getBlockers = () => blockers; + const _setBlockers = (newBlockers) => blockers = newBlockers; + return createHistory({ + getLocation, + getLength: () => entries.length, + pushState: (path, state) => { + if (index < entries.length - 1) { + entries.splice(index + 1); + states.splice(index + 1); + } + states.push(state); + entries.push(path); + index = Math.max(entries.length - 1, 0); + }, + replaceState: (path, state) => { + states[index] = state; + entries[index] = path; + }, + back: () => { + index = Math.max(index - 1, 0); + }, + forward: () => { + index = Math.min(index + 1, entries.length - 1); + }, + go: (n) => { + index = Math.min(Math.max(index + n, 0), entries.length - 1); + }, + createHref: (path) => path, + getBlockers: _getBlockers, + setBlockers: _setBlockers + }); +} +function sanitizePath(path) { + let sanitized = path.replace(/[\x00-\x1f\x7f]/g, ""); + if (sanitized.startsWith("//")) { + sanitized = "/" + sanitized.replace(/^\/+/, ""); + } + return sanitized; +} +function parseHref(href, state) { + const sanitizedHref = sanitizePath(href); + const hashIndex = sanitizedHref.indexOf("#"); + const searchIndex = sanitizedHref.indexOf("?"); + const addedKey = createRandomKey(); + return { + href: sanitizedHref, + pathname: sanitizedHref.substring( + 0, + hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : sanitizedHref.length + ), + hash: hashIndex > -1 ? sanitizedHref.substring(hashIndex) : "", + search: searchIndex > -1 ? sanitizedHref.slice( + searchIndex, + hashIndex === -1 ? void 0 : hashIndex + ) : "", + state: state || { [stateIndexKey]: 0, key: addedKey, __TSR_key: addedKey } + }; +} +function createRandomKey() { + return (Math.random() + 1).toString(36).substring(7); +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/isServer/development.js +var isServer = void 0; + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/utils/batch.js +function batch2(fn) { + if (isServer) { + return fn(); + } + let result; + batch(() => { + result = fn(); + }); + return result; +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/utils.js +function last(arr) { + return arr[arr.length - 1]; +} +function isFunction(d) { + return typeof d === "function"; +} +function functionalUpdate(updater, previous) { + if (isFunction(updater)) { + return updater(previous); + } + return updater; +} +var hasOwn = Object.prototype.hasOwnProperty; +var isEnumerable = Object.prototype.propertyIsEnumerable; +function replaceEqualDeep(prev, _next, _depth = 0) { + if (isServer) { + return _next; + } + if (prev === _next) { + return prev; + } + if (_depth > 500) return _next; + const next = _next; + const array = isPlainArray(prev) && isPlainArray(next); + if (!array && !(isPlainObject(prev) && isPlainObject(next))) return next; + const prevItems = array ? prev : getEnumerableOwnKeys(prev); + if (!prevItems) return next; + const nextItems = array ? next : getEnumerableOwnKeys(next); + if (!nextItems) return next; + const prevSize = prevItems.length; + const nextSize = nextItems.length; + const copy = array ? new Array(nextSize) : {}; + let equalItems = 0; + for (let i = 0; i < nextSize; i++) { + const key = array ? i : nextItems[i]; + const p = prev[key]; + const n = next[key]; + if (p === n) { + copy[key] = p; + if (array ? i < prevSize : hasOwn.call(prev, key)) equalItems++; + continue; + } + if (p === null || n === null || typeof p !== "object" || typeof n !== "object") { + copy[key] = n; + continue; + } + const v = replaceEqualDeep(p, n, _depth + 1); + copy[key] = v; + if (v === p) equalItems++; + } + return prevSize === nextSize && equalItems === prevSize ? prev : copy; +} +function getEnumerableOwnKeys(o) { + const names = Object.getOwnPropertyNames(o); + for (const name of names) { + if (!isEnumerable.call(o, name)) return false; + } + const symbols = Object.getOwnPropertySymbols(o); + if (symbols.length === 0) return names; + const keys = names; + for (const symbol of symbols) { + if (!isEnumerable.call(o, symbol)) return false; + keys.push(symbol); + } + return keys; +} +function isPlainObject(o) { + if (!hasObjectPrototype(o)) { + return false; + } + const ctor = o.constructor; + if (typeof ctor === "undefined") { + return true; + } + const prot = ctor.prototype; + if (!hasObjectPrototype(prot)) { + return false; + } + if (!prot.hasOwnProperty("isPrototypeOf")) { + return false; + } + return true; +} +function hasObjectPrototype(o) { + return Object.prototype.toString.call(o) === "[object Object]"; +} +function isPlainArray(value) { + return Array.isArray(value) && value.length === Object.keys(value).length; +} +function deepEqual(a, b, opts) { + if (a === b) { + return true; + } + if (typeof a !== typeof b) { + return false; + } + if (Array.isArray(a) && Array.isArray(b)) { + if (a.length !== b.length) return false; + for (let i = 0, l = a.length; i < l; i++) { + if (!deepEqual(a[i], b[i], opts)) return false; + } + return true; + } + if (isPlainObject(a) && isPlainObject(b)) { + const ignoreUndefined = opts?.ignoreUndefined ?? true; + if (opts?.partial) { + for (const k in b) { + if (!ignoreUndefined || b[k] !== void 0) { + if (!deepEqual(a[k], b[k], opts)) return false; + } + } + return true; + } + let aCount = 0; + if (!ignoreUndefined) { + aCount = Object.keys(a).length; + } else { + for (const k in a) { + if (a[k] !== void 0) aCount++; + } + } + let bCount = 0; + for (const k in b) { + if (!ignoreUndefined || b[k] !== void 0) { + bCount++; + if (bCount > aCount || !deepEqual(a[k], b[k], opts)) return false; + } + } + return aCount === bCount; + } + return false; +} +function createControlledPromise(onResolve) { + let resolveLoadPromise; + let rejectLoadPromise; + const controlledPromise = new Promise((resolve, reject) => { + resolveLoadPromise = resolve; + rejectLoadPromise = reject; + }); + controlledPromise.status = "pending"; + controlledPromise.resolve = (value) => { + controlledPromise.status = "resolved"; + controlledPromise.value = value; + resolveLoadPromise(value); + onResolve?.(value); + }; + controlledPromise.reject = (e) => { + controlledPromise.status = "rejected"; + rejectLoadPromise(e); + }; + return controlledPromise; +} +function isModuleNotFoundError(error) { + if (typeof error?.message !== "string") return false; + return error.message.startsWith("Failed to fetch dynamically imported module") || error.message.startsWith("error loading dynamically imported module") || error.message.startsWith("Importing a module script failed"); +} +function isPromise(value) { + return Boolean( + value && typeof value === "object" && typeof value.then === "function" + ); +} +function findLast(array, predicate) { + for (let i = array.length - 1; i >= 0; i--) { + const item = array[i]; + if (predicate(item)) return item; + } + return void 0; +} +function sanitizePathSegment(segment) { + return segment.replace(/[\x00-\x1f\x7f]/g, ""); +} +function decodeSegment(segment) { + let decoded; + try { + decoded = decodeURI(segment); + } catch { + decoded = segment.replaceAll(/%[0-9A-F]{2}/gi, (match) => { + try { + return decodeURI(match); + } catch { + return match; + } + }); + } + return sanitizePathSegment(decoded); +} +var DEFAULT_PROTOCOL_ALLOWLIST = [ + // Standard web navigation + "http:", + "https:", + // Common browser-safe actions + "mailto:", + "tel:" +]; +function isDangerousProtocol(url, allowlist) { + if (!url) return false; + try { + const parsed = new URL(url); + return !allowlist.has(parsed.protocol); + } catch { + return false; + } +} +var HTML_ESCAPE_LOOKUP = { + "&": "\\u0026", + ">": "\\u003e", + "<": "\\u003c", + "\u2028": "\\u2028", + "\u2029": "\\u2029" +}; +var HTML_ESCAPE_REGEX = /[&><\u2028\u2029]/g; +function escapeHtml(str) { + return str.replace(HTML_ESCAPE_REGEX, (match) => HTML_ESCAPE_LOOKUP[match]); +} +function decodePath(path) { + if (!path) return { path, handledProtocolRelativeURL: false }; + if (!/[%\\\x00-\x1f\x7f]/.test(path) && !path.startsWith("//")) { + return { path, handledProtocolRelativeURL: false }; + } + const re = /%25|%5C/gi; + let cursor = 0; + let result = ""; + let match; + while (null !== (match = re.exec(path))) { + result += decodeSegment(path.slice(cursor, match.index)) + match[0]; + cursor = re.lastIndex; + } + result = result + decodeSegment(cursor ? path.slice(cursor) : path); + let handledProtocolRelativeURL = false; + if (result.startsWith("//")) { + handledProtocolRelativeURL = true; + result = "/" + result.replace(/^\/+/, ""); + } + return { path: result, handledProtocolRelativeURL }; +} +function encodePathLikeUrl(path) { + if (!/\s|[^\u0000-\u007F]/.test(path)) return path; + return path.replace(/\s|[^\u0000-\u007F]/gu, encodeURIComponent); +} + +// ../../../node_modules/.pnpm/tiny-invariant@1.3.3/node_modules/tiny-invariant/dist/esm/tiny-invariant.js +var isProduction = false; +var prefix = "Invariant failed"; +function invariant(condition, message) { + if (condition) { + return; + } + if (isProduction) { + throw new Error(prefix); + } + var provided = typeof message === "function" ? message() : message; + var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix; + throw new Error(value); +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/lru-cache.js +function createLRUCache(max) { + const cache = /* @__PURE__ */ new Map(); + let oldest; + let newest; + const touch = (entry) => { + if (!entry.next) return; + if (!entry.prev) { + entry.next.prev = void 0; + oldest = entry.next; + entry.next = void 0; + if (newest) { + entry.prev = newest; + newest.next = entry; + } + } else { + entry.prev.next = entry.next; + entry.next.prev = entry.prev; + entry.next = void 0; + if (newest) { + newest.next = entry; + entry.prev = newest; + } + } + newest = entry; + }; + return { + get(key) { + const entry = cache.get(key); + if (!entry) return void 0; + touch(entry); + return entry.value; + }, + set(key, value) { + if (cache.size >= max && oldest) { + const toDelete = oldest; + cache.delete(toDelete.key); + if (toDelete.next) { + oldest = toDelete.next; + toDelete.next.prev = void 0; + } + if (toDelete === newest) { + newest = void 0; + } + } + const existing = cache.get(key); + if (existing) { + existing.value = value; + touch(existing); + } else { + const entry = { key, value, prev: newest }; + if (newest) newest.next = entry; + newest = entry; + if (!oldest) oldest = entry; + cache.set(key, entry); + } + }, + clear() { + cache.clear(); + oldest = void 0; + newest = void 0; + } + }; +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/new-process-route-tree.js +var SEGMENT_TYPE_PATHNAME = 0; +var SEGMENT_TYPE_PARAM = 1; +var SEGMENT_TYPE_WILDCARD = 2; +var SEGMENT_TYPE_OPTIONAL_PARAM = 3; +var SEGMENT_TYPE_INDEX = 4; +var SEGMENT_TYPE_PATHLESS = 5; +function getOpenAndCloseBraces(part) { + const openBrace = part.indexOf("{"); + if (openBrace === -1) return null; + const closeBrace = part.indexOf("}", openBrace); + if (closeBrace === -1) return null; + const afterOpen = openBrace + 1; + if (afterOpen >= part.length) return null; + return [openBrace, closeBrace]; +} +function parseSegment(path, start, output = new Uint16Array(6)) { + const next = path.indexOf("/", start); + const end = next === -1 ? path.length : next; + const part = path.substring(start, end); + if (!part || !part.includes("$")) { + output[0] = SEGMENT_TYPE_PATHNAME; + output[1] = start; + output[2] = start; + output[3] = end; + output[4] = end; + output[5] = end; + return output; + } + if (part === "$") { + const total = path.length; + output[0] = SEGMENT_TYPE_WILDCARD; + output[1] = start; + output[2] = start; + output[3] = total; + output[4] = total; + output[5] = total; + return output; + } + if (part.charCodeAt(0) === 36) { + output[0] = SEGMENT_TYPE_PARAM; + output[1] = start; + output[2] = start + 1; + output[3] = end; + output[4] = end; + output[5] = end; + return output; + } + const braces = getOpenAndCloseBraces(part); + if (braces) { + const [openBrace, closeBrace] = braces; + const firstChar = part.charCodeAt(openBrace + 1); + if (firstChar === 45) { + if (openBrace + 2 < part.length && part.charCodeAt(openBrace + 2) === 36) { + const paramStart = openBrace + 3; + const paramEnd = closeBrace; + if (paramStart < paramEnd) { + output[0] = SEGMENT_TYPE_OPTIONAL_PARAM; + output[1] = start + openBrace; + output[2] = start + paramStart; + output[3] = start + paramEnd; + output[4] = start + closeBrace + 1; + output[5] = end; + return output; + } + } + } else if (firstChar === 36) { + const dollarPos = openBrace + 1; + const afterDollar = openBrace + 2; + if (afterDollar === closeBrace) { + output[0] = SEGMENT_TYPE_WILDCARD; + output[1] = start + openBrace; + output[2] = start + dollarPos; + output[3] = start + afterDollar; + output[4] = start + closeBrace + 1; + output[5] = path.length; + return output; + } + output[0] = SEGMENT_TYPE_PARAM; + output[1] = start + openBrace; + output[2] = start + afterDollar; + output[3] = start + closeBrace; + output[4] = start + closeBrace + 1; + output[5] = end; + return output; + } + } + output[0] = SEGMENT_TYPE_PATHNAME; + output[1] = start; + output[2] = start; + output[3] = end; + output[4] = end; + output[5] = end; + return output; +} +function parseSegments(defaultCaseSensitive, data, route, start, node, depth, onRoute) { + onRoute?.(route); + let cursor = start; + { + const path = route.fullPath ?? route.from; + const length = path.length; + const caseSensitive = route.options?.caseSensitive ?? defaultCaseSensitive; + const skipOnParamError = !!(route.options?.params?.parse && route.options?.skipRouteOnParseError?.params); + while (cursor < length) { + const segment = parseSegment(path, cursor, data); + let nextNode; + const start2 = cursor; + const end = segment[5]; + cursor = end + 1; + depth++; + const kind = segment[0]; + switch (kind) { + case SEGMENT_TYPE_PATHNAME: { + const value = path.substring(segment[2], segment[3]); + if (caseSensitive) { + const existingNode = node.static?.get(value); + if (existingNode) { + nextNode = existingNode; + } else { + node.static ??= /* @__PURE__ */ new Map(); + const next = createStaticNode( + route.fullPath ?? route.from + ); + next.parent = node; + next.depth = depth; + nextNode = next; + node.static.set(value, next); + } + } else { + const name = value.toLowerCase(); + const existingNode = node.staticInsensitive?.get(name); + if (existingNode) { + nextNode = existingNode; + } else { + node.staticInsensitive ??= /* @__PURE__ */ new Map(); + const next = createStaticNode( + route.fullPath ?? route.from + ); + next.parent = node; + next.depth = depth; + nextNode = next; + node.staticInsensitive.set(name, next); + } + } + break; + } + case SEGMENT_TYPE_PARAM: { + const prefix_raw = path.substring(start2, segment[1]); + const suffix_raw = path.substring(segment[4], end); + const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw); + const prefix2 = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase(); + const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase(); + const existingNode = !skipOnParamError && node.dynamic?.find( + (s) => !s.skipOnParamError && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix2 && s.suffix === suffix + ); + if (existingNode) { + nextNode = existingNode; + } else { + const next = createDynamicNode( + SEGMENT_TYPE_PARAM, + route.fullPath ?? route.from, + actuallyCaseSensitive, + prefix2, + suffix + ); + nextNode = next; + next.depth = depth; + next.parent = node; + node.dynamic ??= []; + node.dynamic.push(next); + } + break; + } + case SEGMENT_TYPE_OPTIONAL_PARAM: { + const prefix_raw = path.substring(start2, segment[1]); + const suffix_raw = path.substring(segment[4], end); + const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw); + const prefix2 = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase(); + const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase(); + const existingNode = !skipOnParamError && node.optional?.find( + (s) => !s.skipOnParamError && s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix2 && s.suffix === suffix + ); + if (existingNode) { + nextNode = existingNode; + } else { + const next = createDynamicNode( + SEGMENT_TYPE_OPTIONAL_PARAM, + route.fullPath ?? route.from, + actuallyCaseSensitive, + prefix2, + suffix + ); + nextNode = next; + next.parent = node; + next.depth = depth; + node.optional ??= []; + node.optional.push(next); + } + break; + } + case SEGMENT_TYPE_WILDCARD: { + const prefix_raw = path.substring(start2, segment[1]); + const suffix_raw = path.substring(segment[4], end); + const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw); + const prefix2 = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase(); + const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase(); + const next = createDynamicNode( + SEGMENT_TYPE_WILDCARD, + route.fullPath ?? route.from, + actuallyCaseSensitive, + prefix2, + suffix + ); + nextNode = next; + next.parent = node; + next.depth = depth; + node.wildcard ??= []; + node.wildcard.push(next); + } + } + node = nextNode; + } + if (skipOnParamError && route.children && !route.isRoot && route.id && route.id.charCodeAt(route.id.lastIndexOf("/") + 1) === 95) { + const pathlessNode = createStaticNode( + route.fullPath ?? route.from + ); + pathlessNode.kind = SEGMENT_TYPE_PATHLESS; + pathlessNode.parent = node; + depth++; + pathlessNode.depth = depth; + node.pathless ??= []; + node.pathless.push(pathlessNode); + node = pathlessNode; + } + const isLeaf = (route.path || !route.children) && !route.isRoot; + if (isLeaf && path.endsWith("/")) { + const indexNode = createStaticNode( + route.fullPath ?? route.from + ); + indexNode.kind = SEGMENT_TYPE_INDEX; + indexNode.parent = node; + depth++; + indexNode.depth = depth; + node.index = indexNode; + node = indexNode; + } + node.parse = route.options?.params?.parse ?? null; + node.skipOnParamError = skipOnParamError; + node.parsingPriority = route.options?.skipRouteOnParseError?.priority ?? 0; + if (isLeaf && !node.route) { + node.route = route; + node.fullPath = route.fullPath ?? route.from; + } + } + if (route.children) + for (const child of route.children) { + parseSegments( + defaultCaseSensitive, + data, + child, + cursor, + node, + depth, + onRoute + ); + } +} +function sortDynamic(a, b) { + if (a.skipOnParamError && !b.skipOnParamError) return -1; + if (!a.skipOnParamError && b.skipOnParamError) return 1; + if (a.skipOnParamError && b.skipOnParamError && (a.parsingPriority || b.parsingPriority)) + return b.parsingPriority - a.parsingPriority; + if (a.prefix && b.prefix && a.prefix !== b.prefix) { + if (a.prefix.startsWith(b.prefix)) return -1; + if (b.prefix.startsWith(a.prefix)) return 1; + } + if (a.suffix && b.suffix && a.suffix !== b.suffix) { + if (a.suffix.endsWith(b.suffix)) return -1; + if (b.suffix.endsWith(a.suffix)) return 1; + } + if (a.prefix && !b.prefix) return -1; + if (!a.prefix && b.prefix) return 1; + if (a.suffix && !b.suffix) return -1; + if (!a.suffix && b.suffix) return 1; + if (a.caseSensitive && !b.caseSensitive) return -1; + if (!a.caseSensitive && b.caseSensitive) return 1; + return 0; +} +function sortTreeNodes(node) { + if (node.pathless) { + for (const child of node.pathless) { + sortTreeNodes(child); + } + } + if (node.static) { + for (const child of node.static.values()) { + sortTreeNodes(child); + } + } + if (node.staticInsensitive) { + for (const child of node.staticInsensitive.values()) { + sortTreeNodes(child); + } + } + if (node.dynamic?.length) { + node.dynamic.sort(sortDynamic); + for (const child of node.dynamic) { + sortTreeNodes(child); + } + } + if (node.optional?.length) { + node.optional.sort(sortDynamic); + for (const child of node.optional) { + sortTreeNodes(child); + } + } + if (node.wildcard?.length) { + node.wildcard.sort(sortDynamic); + for (const child of node.wildcard) { + sortTreeNodes(child); + } + } +} +function createStaticNode(fullPath) { + return { + kind: SEGMENT_TYPE_PATHNAME, + depth: 0, + pathless: null, + index: null, + static: null, + staticInsensitive: null, + dynamic: null, + optional: null, + wildcard: null, + route: null, + fullPath, + parent: null, + parse: null, + skipOnParamError: false, + parsingPriority: 0 + }; +} +function createDynamicNode(kind, fullPath, caseSensitive, prefix2, suffix) { + return { + kind, + depth: 0, + pathless: null, + index: null, + static: null, + staticInsensitive: null, + dynamic: null, + optional: null, + wildcard: null, + route: null, + fullPath, + parent: null, + parse: null, + skipOnParamError: false, + parsingPriority: 0, + caseSensitive, + prefix: prefix2, + suffix + }; +} +function processRouteMasks(routeList, processedTree) { + const segmentTree = createStaticNode("/"); + const data = new Uint16Array(6); + for (const route of routeList) { + parseSegments(false, data, route, 1, segmentTree, 0); + } + sortTreeNodes(segmentTree); + processedTree.masksTree = segmentTree; + processedTree.flatCache = createLRUCache(1e3); +} +function findFlatMatch(path, processedTree) { + path ||= "/"; + const cached = processedTree.flatCache.get(path); + if (cached) return cached; + const result = findMatch(path, processedTree.masksTree); + processedTree.flatCache.set(path, result); + return result; +} +function findSingleMatch(from, caseSensitive, fuzzy, path, processedTree) { + from ||= "/"; + path ||= "/"; + const key = caseSensitive ? `case\0${from}` : from; + let tree = processedTree.singleCache.get(key); + if (!tree) { + tree = createStaticNode("/"); + const data = new Uint16Array(6); + parseSegments(caseSensitive, data, { from }, 1, tree, 0); + processedTree.singleCache.set(key, tree); + } + return findMatch(path, tree, fuzzy); +} +function findRouteMatch(path, processedTree, fuzzy = false) { + const key = fuzzy ? path : `nofuzz\0${path}`; + const cached = processedTree.matchCache.get(key); + if (cached !== void 0) return cached; + path ||= "/"; + let result; + try { + result = findMatch( + path, + processedTree.segmentTree, + fuzzy + ); + } catch (err) { + if (err instanceof URIError) { + result = null; + } else { + throw err; + } + } + if (result) result.branch = buildRouteBranch(result.route); + processedTree.matchCache.set(key, result); + return result; +} +function trimPathRight(path) { + return path === "/" ? path : path.replace(/\/{1,}$/, ""); +} +function processRouteTree(routeTree, caseSensitive = false, initRoute) { + const segmentTree = createStaticNode(routeTree.fullPath); + const data = new Uint16Array(6); + const routesById = {}; + const routesByPath = {}; + let index = 0; + parseSegments(caseSensitive, data, routeTree, 1, segmentTree, 0, (route) => { + initRoute?.(route, index); + invariant( + !(route.id in routesById), + `Duplicate routes found with id: ${String(route.id)}` + ); + routesById[route.id] = route; + if (index !== 0 && route.path) { + const trimmedFullPath = trimPathRight(route.fullPath); + if (!routesByPath[trimmedFullPath] || route.fullPath.endsWith("/")) { + routesByPath[trimmedFullPath] = route; + } + } + index++; + }); + sortTreeNodes(segmentTree); + const processedTree = { + segmentTree, + singleCache: createLRUCache(1e3), + matchCache: createLRUCache(1e3), + flatCache: null, + masksTree: null + }; + return { + processedTree, + routesById, + routesByPath + }; +} +function findMatch(path, segmentTree, fuzzy = false) { + const parts = path.split("/"); + const leaf = getNodeMatch(path, parts, segmentTree, fuzzy); + if (!leaf) return null; + const [rawParams] = extractParams(path, parts, leaf); + return { + route: leaf.node.route, + rawParams, + parsedParams: leaf.parsedParams + }; +} +function extractParams(path, parts, leaf) { + const list = buildBranch(leaf.node); + let nodeParts = null; + const rawParams = {}; + let partIndex = leaf.extract?.part ?? 0; + let nodeIndex = leaf.extract?.node ?? 0; + let pathIndex = leaf.extract?.path ?? 0; + let segmentCount = leaf.extract?.segment ?? 0; + for (; nodeIndex < list.length; partIndex++, nodeIndex++, pathIndex++, segmentCount++) { + const node = list[nodeIndex]; + if (node.kind === SEGMENT_TYPE_INDEX) break; + if (node.kind === SEGMENT_TYPE_PATHLESS) { + segmentCount--; + partIndex--; + pathIndex--; + continue; + } + const part = parts[partIndex]; + const currentPathIndex = pathIndex; + if (part) pathIndex += part.length; + if (node.kind === SEGMENT_TYPE_PARAM) { + nodeParts ??= leaf.node.fullPath.split("/"); + const nodePart = nodeParts[segmentCount]; + const preLength = node.prefix?.length ?? 0; + const isCurlyBraced = nodePart.charCodeAt(preLength) === 123; + if (isCurlyBraced) { + const sufLength = node.suffix?.length ?? 0; + const name = nodePart.substring( + preLength + 2, + nodePart.length - sufLength - 1 + ); + const value = part.substring(preLength, part.length - sufLength); + rawParams[name] = decodeURIComponent(value); + } else { + const name = nodePart.substring(1); + rawParams[name] = decodeURIComponent(part); + } + } else if (node.kind === SEGMENT_TYPE_OPTIONAL_PARAM) { + if (leaf.skipped & 1 << nodeIndex) { + partIndex--; + pathIndex = currentPathIndex - 1; + continue; + } + nodeParts ??= leaf.node.fullPath.split("/"); + const nodePart = nodeParts[segmentCount]; + const preLength = node.prefix?.length ?? 0; + const sufLength = node.suffix?.length ?? 0; + const name = nodePart.substring( + preLength + 3, + nodePart.length - sufLength - 1 + ); + const value = node.suffix || node.prefix ? part.substring(preLength, part.length - sufLength) : part; + if (value) rawParams[name] = decodeURIComponent(value); + } else if (node.kind === SEGMENT_TYPE_WILDCARD) { + const n = node; + const value = path.substring( + currentPathIndex + (n.prefix?.length ?? 0), + path.length - (n.suffix?.length ?? 0) + ); + const splat = decodeURIComponent(value); + rawParams["*"] = splat; + rawParams._splat = splat; + break; + } + } + if (leaf.rawParams) Object.assign(rawParams, leaf.rawParams); + return [ + rawParams, + { + part: partIndex, + node: nodeIndex, + path: pathIndex, + segment: segmentCount + } + ]; +} +function buildRouteBranch(route) { + const list = [route]; + while (route.parentRoute) { + route = route.parentRoute; + list.push(route); + } + list.reverse(); + return list; +} +function buildBranch(node) { + const list = Array(node.depth + 1); + do { + list[node.depth] = node; + node = node.parent; + } while (node); + return list; +} +function getNodeMatch(path, parts, segmentTree, fuzzy) { + if (path === "/" && segmentTree.index) + return { node: segmentTree.index, skipped: 0 }; + const trailingSlash = !last(parts); + const pathIsIndex = trailingSlash && path !== "/"; + const partsLength = parts.length - (trailingSlash ? 1 : 0); + const stack = [ + { + node: segmentTree, + index: 1, + skipped: 0, + depth: 1, + statics: 1, + dynamics: 0, + optionals: 0 + } + ]; + let wildcardMatch = null; + let bestFuzzy = null; + let bestMatch = null; + while (stack.length) { + const frame = stack.pop(); + const { node, index, skipped, depth, statics, dynamics, optionals } = frame; + let { extract, rawParams, parsedParams } = frame; + if (node.skipOnParamError) { + const result = validateMatchParams(path, parts, frame); + if (!result) continue; + rawParams = frame.rawParams; + extract = frame.extract; + parsedParams = frame.parsedParams; + } + if (fuzzy && node.route && node.kind !== SEGMENT_TYPE_INDEX && isFrameMoreSpecific(bestFuzzy, frame)) { + bestFuzzy = frame; + } + const isBeyondPath = index === partsLength; + if (isBeyondPath) { + if (node.route && !pathIsIndex && isFrameMoreSpecific(bestMatch, frame)) { + bestMatch = frame; + } + if (!node.optional && !node.wildcard && !node.index && !node.pathless) + continue; + } + const part = isBeyondPath ? void 0 : parts[index]; + let lowerPart; + if (isBeyondPath && node.index) { + const indexFrame = { + node: node.index, + index, + skipped, + depth: depth + 1, + statics, + dynamics, + optionals, + extract, + rawParams, + parsedParams + }; + let indexValid = true; + if (node.index.skipOnParamError) { + const result = validateMatchParams(path, parts, indexFrame); + if (!result) indexValid = false; + } + if (indexValid) { + if (statics === partsLength && !dynamics && !optionals && !skipped) { + return indexFrame; + } + if (isFrameMoreSpecific(bestMatch, indexFrame)) { + bestMatch = indexFrame; + } + } + } + if (node.wildcard && isFrameMoreSpecific(wildcardMatch, frame)) { + for (const segment of node.wildcard) { + const { prefix: prefix2, suffix } = segment; + if (prefix2) { + if (isBeyondPath) continue; + const casePart = segment.caseSensitive ? part : lowerPart ??= part.toLowerCase(); + if (!casePart.startsWith(prefix2)) continue; + } + if (suffix) { + if (isBeyondPath) continue; + const end = parts.slice(index).join("/").slice(-suffix.length); + const casePart = segment.caseSensitive ? end : end.toLowerCase(); + if (casePart !== suffix) continue; + } + const frame2 = { + node: segment, + index: partsLength, + skipped, + depth, + statics, + dynamics, + optionals, + extract, + rawParams, + parsedParams + }; + if (segment.skipOnParamError) { + const result = validateMatchParams(path, parts, frame2); + if (!result) continue; + } + wildcardMatch = frame2; + break; + } + } + if (node.optional) { + const nextSkipped = skipped | 1 << depth; + const nextDepth = depth + 1; + for (let i = node.optional.length - 1; i >= 0; i--) { + const segment = node.optional[i]; + stack.push({ + node: segment, + index, + skipped: nextSkipped, + depth: nextDepth, + statics, + dynamics, + optionals, + extract, + rawParams, + parsedParams + }); + } + if (!isBeyondPath) { + for (let i = node.optional.length - 1; i >= 0; i--) { + const segment = node.optional[i]; + const { prefix: prefix2, suffix } = segment; + if (prefix2 || suffix) { + const casePart = segment.caseSensitive ? part : lowerPart ??= part.toLowerCase(); + if (prefix2 && !casePart.startsWith(prefix2)) continue; + if (suffix && !casePart.endsWith(suffix)) continue; + } + stack.push({ + node: segment, + index: index + 1, + skipped, + depth: nextDepth, + statics, + dynamics, + optionals: optionals + 1, + extract, + rawParams, + parsedParams + }); + } + } + } + if (!isBeyondPath && node.dynamic && part) { + for (let i = node.dynamic.length - 1; i >= 0; i--) { + const segment = node.dynamic[i]; + const { prefix: prefix2, suffix } = segment; + if (prefix2 || suffix) { + const casePart = segment.caseSensitive ? part : lowerPart ??= part.toLowerCase(); + if (prefix2 && !casePart.startsWith(prefix2)) continue; + if (suffix && !casePart.endsWith(suffix)) continue; + } + stack.push({ + node: segment, + index: index + 1, + skipped, + depth: depth + 1, + statics, + dynamics: dynamics + 1, + optionals, + extract, + rawParams, + parsedParams + }); + } + } + if (!isBeyondPath && node.staticInsensitive) { + const match = node.staticInsensitive.get( + lowerPart ??= part.toLowerCase() + ); + if (match) { + stack.push({ + node: match, + index: index + 1, + skipped, + depth: depth + 1, + statics: statics + 1, + dynamics, + optionals, + extract, + rawParams, + parsedParams + }); + } + } + if (!isBeyondPath && node.static) { + const match = node.static.get(part); + if (match) { + stack.push({ + node: match, + index: index + 1, + skipped, + depth: depth + 1, + statics: statics + 1, + dynamics, + optionals, + extract, + rawParams, + parsedParams + }); + } + } + if (node.pathless) { + const nextDepth = depth + 1; + for (let i = node.pathless.length - 1; i >= 0; i--) { + const segment = node.pathless[i]; + stack.push({ + node: segment, + index, + skipped, + depth: nextDepth, + statics, + dynamics, + optionals, + extract, + rawParams, + parsedParams + }); + } + } + } + if (bestMatch && wildcardMatch) { + return isFrameMoreSpecific(wildcardMatch, bestMatch) ? bestMatch : wildcardMatch; + } + if (bestMatch) return bestMatch; + if (wildcardMatch) return wildcardMatch; + if (fuzzy && bestFuzzy) { + let sliceIndex = bestFuzzy.index; + for (let i = 0; i < bestFuzzy.index; i++) { + sliceIndex += parts[i].length; + } + const splat = sliceIndex === path.length ? "/" : path.slice(sliceIndex); + bestFuzzy.rawParams ??= {}; + bestFuzzy.rawParams["**"] = decodeURIComponent(splat); + return bestFuzzy; + } + return null; +} +function validateMatchParams(path, parts, frame) { + try { + const [rawParams, state] = extractParams(path, parts, frame); + frame.rawParams = rawParams; + frame.extract = state; + const parsed = frame.node.parse(rawParams); + frame.parsedParams = Object.assign({}, frame.parsedParams, parsed); + return true; + } catch { + return null; + } +} +function isFrameMoreSpecific(prev, next) { + if (!prev) return true; + return next.statics > prev.statics || next.statics === prev.statics && (next.dynamics > prev.dynamics || next.dynamics === prev.dynamics && (next.optionals > prev.optionals || next.optionals === prev.optionals && ((next.node.kind === SEGMENT_TYPE_INDEX) > (prev.node.kind === SEGMENT_TYPE_INDEX) || next.node.kind === SEGMENT_TYPE_INDEX === (prev.node.kind === SEGMENT_TYPE_INDEX) && next.depth > prev.depth))); +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/path.js +function joinPaths(paths) { + return cleanPath( + paths.filter((val) => { + return val !== void 0; + }).join("/") + ); +} +function cleanPath(path) { + return path.replace(/\/{2,}/g, "/"); +} +function trimPathLeft(path) { + return path === "/" ? path : path.replace(/^\/{1,}/, ""); +} +function trimPathRight2(path) { + const len = path.length; + return len > 1 && path[len - 1] === "/" ? path.replace(/\/{1,}$/, "") : path; +} +function trimPath(path) { + return trimPathRight2(trimPathLeft(path)); +} +function removeTrailingSlash(value, basepath) { + if (value?.endsWith("/") && value !== "/" && value !== `${basepath}/`) { + return value.slice(0, -1); + } + return value; +} +function exactPathTest(pathName1, pathName2, basepath) { + return removeTrailingSlash(pathName1, basepath) === removeTrailingSlash(pathName2, basepath); +} +function resolvePath({ + base, + to, + trailingSlash = "never", + cache +}) { + const isAbsolute = to.startsWith("/"); + const isBase = !isAbsolute && to === "."; + let key; + if (cache) { + key = isAbsolute ? to : isBase ? base : base + "\0" + to; + const cached = cache.get(key); + if (cached) return cached; + } + let baseSegments; + if (isBase) { + baseSegments = base.split("/"); + } else if (isAbsolute) { + baseSegments = to.split("/"); + } else { + baseSegments = base.split("/"); + while (baseSegments.length > 1 && last(baseSegments) === "") { + baseSegments.pop(); + } + const toSegments = to.split("/"); + for (let index = 0, length = toSegments.length; index < length; index++) { + const value = toSegments[index]; + if (value === "") { + if (!index) { + baseSegments = [value]; + } else if (index === length - 1) { + baseSegments.push(value); + } else ; + } else if (value === "..") { + baseSegments.pop(); + } else if (value === ".") ; + else { + baseSegments.push(value); + } + } + } + if (baseSegments.length > 1) { + if (last(baseSegments) === "") { + if (trailingSlash === "never") { + baseSegments.pop(); + } + } else if (trailingSlash === "always") { + baseSegments.push(""); + } + } + let segment; + let joined = ""; + for (let i = 0; i < baseSegments.length; i++) { + if (i > 0) joined += "/"; + const part = baseSegments[i]; + if (!part) continue; + segment = parseSegment(part, 0, segment); + const kind = segment[0]; + if (kind === SEGMENT_TYPE_PATHNAME) { + joined += part; + continue; + } + const end = segment[5]; + const prefix2 = part.substring(0, segment[1]); + const suffix = part.substring(segment[4], end); + const value = part.substring(segment[2], segment[3]); + if (kind === SEGMENT_TYPE_PARAM) { + joined += prefix2 || suffix ? `${prefix2}{$${value}}${suffix}` : `$${value}`; + } else if (kind === SEGMENT_TYPE_WILDCARD) { + joined += prefix2 || suffix ? `${prefix2}{$}${suffix}` : "$"; + } else { + joined += `${prefix2}{-$${value}}${suffix}`; + } + } + joined = cleanPath(joined); + const result = joined || "/"; + if (key && cache) cache.set(key, result); + return result; +} +function compileDecodeCharMap(pathParamsAllowedCharacters) { + const charMap = new Map( + pathParamsAllowedCharacters.map((char) => [encodeURIComponent(char), char]) + ); + const pattern = Array.from(charMap.keys()).map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"); + const regex = new RegExp(pattern, "g"); + return (encoded) => encoded.replace(regex, (match) => charMap.get(match) ?? match); +} +function encodeParam(key, params, decoder) { + const value = params[key]; + if (typeof value !== "string") return value; + if (key === "_splat") { + if (/^[a-zA-Z0-9\-._~!/]*$/.test(value)) return value; + return value.split("/").map((segment) => encodePathParam(segment, decoder)).join("/"); + } else { + return encodePathParam(value, decoder); + } +} +function interpolatePath({ + path, + params, + decoder, + // `server` is marked @internal and stripped from .d.ts by `stripInternal`. + // We avoid destructuring it in the function signature so the emitted + // declaration doesn't reference a property that no longer exists. + ...rest +}) { + let isMissingParams = false; + const usedParams = {}; + if (!path || path === "/") + return { interpolatedPath: "/", usedParams, isMissingParams }; + if (!path.includes("$")) + return { interpolatedPath: path, usedParams, isMissingParams }; + if (isServer ?? rest.server) { + if (path.indexOf("{") === -1) { + const length2 = path.length; + let cursor2 = 0; + let joined2 = ""; + while (cursor2 < length2) { + while (cursor2 < length2 && path.charCodeAt(cursor2) === 47) cursor2++; + if (cursor2 >= length2) break; + const start = cursor2; + let end = path.indexOf("/", cursor2); + if (end === -1) end = length2; + cursor2 = end; + const part = path.substring(start, end); + if (!part) continue; + if (part.charCodeAt(0) === 36) { + if (part.length === 1) { + const splat = params._splat; + usedParams._splat = splat; + usedParams["*"] = splat; + if (!splat) { + isMissingParams = true; + continue; + } + const value = encodeParam("_splat", params, decoder); + joined2 += "/" + value; + } else { + const key = part.substring(1); + if (!isMissingParams && !(key in params)) { + isMissingParams = true; + } + usedParams[key] = params[key]; + const value = encodeParam(key, params, decoder) ?? "undefined"; + joined2 += "/" + value; + } + } else { + joined2 += "/" + part; + } + } + if (path.endsWith("/")) joined2 += "/"; + const interpolatedPath2 = joined2 || "/"; + return { usedParams, interpolatedPath: interpolatedPath2, isMissingParams }; + } + } + const length = path.length; + let cursor = 0; + let segment; + let joined = ""; + while (cursor < length) { + const start = cursor; + segment = parseSegment(path, start, segment); + const end = segment[5]; + cursor = end + 1; + if (start === end) continue; + const kind = segment[0]; + if (kind === SEGMENT_TYPE_PATHNAME) { + joined += "/" + path.substring(start, end); + continue; + } + if (kind === SEGMENT_TYPE_WILDCARD) { + const splat = params._splat; + usedParams._splat = splat; + usedParams["*"] = splat; + const prefix2 = path.substring(start, segment[1]); + const suffix = path.substring(segment[4], end); + if (!splat) { + isMissingParams = true; + if (prefix2 || suffix) { + joined += "/" + prefix2 + suffix; + } + continue; + } + const value = encodeParam("_splat", params, decoder); + joined += "/" + prefix2 + value + suffix; + continue; + } + if (kind === SEGMENT_TYPE_PARAM) { + const key = path.substring(segment[2], segment[3]); + if (!isMissingParams && !(key in params)) { + isMissingParams = true; + } + usedParams[key] = params[key]; + const prefix2 = path.substring(start, segment[1]); + const suffix = path.substring(segment[4], end); + const value = encodeParam(key, params, decoder) ?? "undefined"; + joined += "/" + prefix2 + value + suffix; + continue; + } + if (kind === SEGMENT_TYPE_OPTIONAL_PARAM) { + const key = path.substring(segment[2], segment[3]); + const valueRaw = params[key]; + if (valueRaw == null) continue; + usedParams[key] = valueRaw; + const prefix2 = path.substring(start, segment[1]); + const suffix = path.substring(segment[4], end); + const value = encodeParam(key, params, decoder) ?? ""; + joined += "/" + prefix2 + value + suffix; + continue; + } + } + if (path.endsWith("/")) joined += "/"; + const interpolatedPath = joined || "/"; + return { usedParams, interpolatedPath, isMissingParams }; +} +function encodePathParam(value, decoder) { + const encoded = encodeURIComponent(value); + return decoder?.(encoded) ?? encoded; +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/not-found.js +function notFound(options = {}) { + options.isNotFound = true; + if (options.throw) throw options; + return options; +} +function isNotFound(obj) { + return !!obj?.isNotFound; +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/scroll-restoration.js +function getSafeSessionStorage() { + try { + if (typeof window !== "undefined" && typeof window.sessionStorage === "object") { + return window.sessionStorage; + } + } catch { + } + return void 0; +} +var storageKey = "tsr-scroll-restoration-v1_3"; +var throttle = (fn, wait) => { + let timeout; + return (...args) => { + if (!timeout) { + timeout = setTimeout(() => { + fn(...args); + timeout = null; + }, wait); + } + }; +}; +function createScrollRestorationCache() { + const safeSessionStorage = getSafeSessionStorage(); + if (!safeSessionStorage) { + return null; + } + const persistedState = safeSessionStorage.getItem(storageKey); + let state = persistedState ? JSON.parse(persistedState) : {}; + return { + state, + // This setter is simply to make sure that we set the sessionStorage right + // after the state is updated. It doesn't necessarily need to be a functional + // update. + set: (updater) => { + state = functionalUpdate(updater, state) || state; + try { + safeSessionStorage.setItem(storageKey, JSON.stringify(state)); + } catch { + console.warn( + "[ts-router] Could not persist scroll restoration state to sessionStorage." + ); + } + } + }; +} +var scrollRestorationCache = createScrollRestorationCache(); +var defaultGetScrollRestorationKey = (location) => { + return location.state.__TSR_key || location.href; +}; +function getCssSelector(el) { + const path = []; + let parent; + while (parent = el.parentNode) { + path.push( + `${el.tagName}:nth-child(${Array.prototype.indexOf.call(parent.children, el) + 1})` + ); + el = parent; + } + return `${path.reverse().join(" > ")}`.toLowerCase(); +} +var ignoreScroll = false; +function restoreScroll({ + storageKey: storageKey2, + key, + behavior, + shouldScrollRestoration, + scrollToTopSelectors, + location +}) { + let byKey; + try { + byKey = JSON.parse(sessionStorage.getItem(storageKey2) || "{}"); + } catch (error) { + console.error(error); + return; + } + const resolvedKey = key || window.history.state?.__TSR_key; + const elementEntries = byKey[resolvedKey]; + ignoreScroll = true; + scroll: { + if (shouldScrollRestoration && elementEntries && Object.keys(elementEntries).length > 0) { + for (const elementSelector in elementEntries) { + const entry = elementEntries[elementSelector]; + if (elementSelector === "window") { + window.scrollTo({ + top: entry.scrollY, + left: entry.scrollX, + behavior + }); + } else if (elementSelector) { + const element = document.querySelector(elementSelector); + if (element) { + element.scrollLeft = entry.scrollX; + element.scrollTop = entry.scrollY; + } + } + } + break scroll; + } + const hash = (location ?? window.location).hash.split("#", 2)[1]; + if (hash) { + const hashScrollIntoViewOptions = window.history.state?.__hashScrollIntoViewOptions ?? true; + if (hashScrollIntoViewOptions) { + const el = document.getElementById(hash); + if (el) { + el.scrollIntoView(hashScrollIntoViewOptions); + } + } + break scroll; + } + const scrollOptions = { top: 0, left: 0, behavior }; + window.scrollTo(scrollOptions); + if (scrollToTopSelectors) { + for (const selector of scrollToTopSelectors) { + if (selector === "window") continue; + const element = typeof selector === "function" ? selector() : document.querySelector(selector); + if (element) element.scrollTo(scrollOptions); + } + } + } + ignoreScroll = false; +} +function setupScrollRestoration(router, force) { + if (!scrollRestorationCache && !(isServer ?? router.isServer)) { + return; + } + const shouldScrollRestoration = force ?? router.options.scrollRestoration ?? false; + if (shouldScrollRestoration) { + router.isScrollRestoring = true; + } + if ((isServer ?? router.isServer) || router.isScrollRestorationSetup || !scrollRestorationCache) { + return; + } + router.isScrollRestorationSetup = true; + ignoreScroll = false; + const getKey = router.options.getScrollRestorationKey || defaultGetScrollRestorationKey; + window.history.scrollRestoration = "manual"; + const onScroll = (event) => { + if (ignoreScroll || !router.isScrollRestoring) { + return; + } + let elementSelector = ""; + if (event.target === document || event.target === window) { + elementSelector = "window"; + } else { + const attrId = event.target.getAttribute( + "data-scroll-restoration-id" + ); + if (attrId) { + elementSelector = `[data-scroll-restoration-id="${attrId}"]`; + } else { + elementSelector = getCssSelector(event.target); + } + } + const restoreKey = getKey(router.state.location); + scrollRestorationCache.set((state) => { + const keyEntry = state[restoreKey] ||= {}; + const elementEntry = keyEntry[elementSelector] ||= {}; + if (elementSelector === "window") { + elementEntry.scrollX = window.scrollX || 0; + elementEntry.scrollY = window.scrollY || 0; + } else if (elementSelector) { + const element = document.querySelector(elementSelector); + if (element) { + elementEntry.scrollX = element.scrollLeft || 0; + elementEntry.scrollY = element.scrollTop || 0; + } + } + return state; + }); + }; + if (typeof document !== "undefined") { + document.addEventListener("scroll", throttle(onScroll, 100), true); + } + router.subscribe("onRendered", (event) => { + const cacheKey = getKey(event.toLocation); + if (!router.resetNextScroll) { + router.resetNextScroll = true; + return; + } + if (typeof router.options.scrollRestoration === "function") { + const shouldRestore = router.options.scrollRestoration({ + location: router.latestLocation + }); + if (!shouldRestore) { + return; + } + } + restoreScroll({ + storageKey, + key: cacheKey, + behavior: router.options.scrollRestorationBehavior, + shouldScrollRestoration: router.isScrollRestoring, + scrollToTopSelectors: router.options.scrollToTopSelectors, + location: router.history.location + }); + if (router.isScrollRestoring) { + scrollRestorationCache.set((state) => { + state[cacheKey] ||= {}; + return state; + }); + } + }); +} +function handleHashScroll(router) { + if (typeof document !== "undefined" && document.querySelector) { + const hashScrollIntoViewOptions = router.state.location.state.__hashScrollIntoViewOptions ?? true; + if (hashScrollIntoViewOptions && router.state.location.hash !== "") { + const el = document.getElementById(router.state.location.hash); + if (el) { + el.scrollIntoView(hashScrollIntoViewOptions); + } + } + } +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/qss.js +function encode(obj, stringify = String) { + const result = new URLSearchParams(); + for (const key in obj) { + const val = obj[key]; + if (val !== void 0) { + result.set(key, stringify(val)); + } + } + return result.toString(); +} +function toValue(str) { + if (!str) return ""; + if (str === "false") return false; + if (str === "true") return true; + return +str * 0 === 0 && +str + "" === str ? +str : str; +} +function decode(str) { + const searchParams = new URLSearchParams(str); + const result = {}; + for (const [key, value] of searchParams.entries()) { + const previousValue = result[key]; + if (previousValue == null) { + result[key] = toValue(value); + } else if (Array.isArray(previousValue)) { + previousValue.push(toValue(value)); + } else { + result[key] = [previousValue, toValue(value)]; + } + } + return result; +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/searchParams.js +var defaultParseSearch = parseSearchWith(JSON.parse); +var defaultStringifySearch = stringifySearchWith( + JSON.stringify, + JSON.parse +); +function parseSearchWith(parser) { + return (searchStr) => { + if (searchStr[0] === "?") { + searchStr = searchStr.substring(1); + } + const query = decode(searchStr); + for (const key in query) { + const value = query[key]; + if (typeof value === "string") { + try { + query[key] = parser(value); + } catch (_err) { + } + } + } + return query; + }; +} +function stringifySearchWith(stringify, parser) { + const hasParser = typeof parser === "function"; + function stringifyValue(val) { + if (typeof val === "object" && val !== null) { + try { + return stringify(val); + } catch (_err) { + } + } else if (hasParser && typeof val === "string") { + try { + parser(val); + return stringify(val); + } catch (_err) { + } + } + return val; + } + return (search) => { + const searchStr = encode(search, stringifyValue); + return searchStr ? `?${searchStr}` : ""; + }; +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/root.js +var rootRouteId = "__root__"; + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/redirect.js +function redirect(opts) { + opts.statusCode = opts.statusCode || opts.code || 307; + if (!opts._builtLocation && !opts.reloadDocument && typeof opts.href === "string") { + try { + new URL(opts.href); + opts.reloadDocument = true; + } catch { + } + } + const headers = new Headers(opts.headers); + if (opts.href && headers.get("Location") === null) { + headers.set("Location", opts.href); + } + const response = new Response(null, { + status: opts.statusCode, + headers + }); + response.options = opts; + if (opts.throw) { + throw response; + } + return response; +} +function isRedirect(obj) { + return obj instanceof Response && !!obj.options; +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/load-matches.js +var triggerOnReady = (inner) => { + if (!inner.rendered) { + inner.rendered = true; + return inner.onReady?.(); + } +}; +var resolvePreload = (inner, matchId) => { + return !!(inner.preload && !inner.router.state.matches.some((d) => d.id === matchId)); +}; +var buildMatchContext = (inner, index, includeCurrentMatch = true) => { + const context = { + ...inner.router.options.context ?? {} + }; + const end = includeCurrentMatch ? index : index - 1; + for (let i = 0; i <= end; i++) { + const innerMatch = inner.matches[i]; + if (!innerMatch) continue; + const m = inner.router.getMatch(innerMatch.id); + if (!m) continue; + Object.assign(context, m.__routeContext, m.__beforeLoadContext); + } + return context; +}; +var getNotFoundBoundaryIndex = (inner, err) => { + if (!inner.matches.length) { + return void 0; + } + const requestedRouteId = err.routeId; + const matchedRootIndex = inner.matches.findIndex( + (m) => m.routeId === inner.router.routeTree.id + ); + const rootIndex = matchedRootIndex >= 0 ? matchedRootIndex : 0; + let startIndex = requestedRouteId ? inner.matches.findIndex((match) => match.routeId === requestedRouteId) : inner.firstBadMatchIndex ?? inner.matches.length - 1; + if (startIndex < 0) { + startIndex = rootIndex; + } + for (let i = startIndex; i >= 0; i--) { + const match = inner.matches[i]; + const route = inner.router.looseRoutesById[match.routeId]; + if (route.options.notFoundComponent) { + return i; + } + } + return requestedRouteId ? startIndex : rootIndex; +}; +var handleRedirectAndNotFound = (inner, match, err) => { + if (!isRedirect(err) && !isNotFound(err)) return; + if (isRedirect(err) && err.redirectHandled && !err.options.reloadDocument) { + throw err; + } + if (match) { + match._nonReactive.beforeLoadPromise?.resolve(); + match._nonReactive.loaderPromise?.resolve(); + match._nonReactive.beforeLoadPromise = void 0; + match._nonReactive.loaderPromise = void 0; + match._nonReactive.error = err; + inner.updateMatch(match.id, (prev) => ({ + ...prev, + status: isRedirect(err) ? "redirected" : prev.status === "pending" ? "success" : prev.status, + context: buildMatchContext(inner, match.index), + isFetching: false, + error: err + })); + if (isNotFound(err) && !err.routeId) { + err.routeId = match.routeId; + } + match._nonReactive.loadPromise?.resolve(); + } + if (isRedirect(err)) { + inner.rendered = true; + err.options._fromLocation = inner.location; + err.redirectHandled = true; + err = inner.router.resolveRedirect(err); + } + throw err; +}; +var shouldSkipLoader = (inner, matchId) => { + const match = inner.router.getMatch(matchId); + if (!match) { + return true; + } + if (!(isServer ?? inner.router.isServer) && match._nonReactive.dehydrated) { + return true; + } + if ((isServer ?? inner.router.isServer) && match.ssr === false) { + return true; + } + return false; +}; +var syncMatchContext = (inner, matchId, index) => { + const nextContext = buildMatchContext(inner, index); + inner.updateMatch(matchId, (prev) => { + return { + ...prev, + context: nextContext + }; + }); +}; +var handleSerialError = (inner, index, err, routerCode) => { + const { id: matchId, routeId } = inner.matches[index]; + const route = inner.router.looseRoutesById[routeId]; + if (err instanceof Promise) { + throw err; + } + err.routerCode = routerCode; + inner.firstBadMatchIndex ??= index; + handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err); + try { + route.options.onError?.(err); + } catch (errorHandlerErr) { + err = errorHandlerErr; + handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err); + } + inner.updateMatch(matchId, (prev) => { + prev._nonReactive.beforeLoadPromise?.resolve(); + prev._nonReactive.beforeLoadPromise = void 0; + prev._nonReactive.loadPromise?.resolve(); + return { + ...prev, + error: err, + status: "error", + isFetching: false, + updatedAt: Date.now(), + abortController: new AbortController() + }; + }); + if (!inner.preload && !isRedirect(err) && !isNotFound(err)) { + inner.serialError ??= err; + } +}; +var isBeforeLoadSsr = (inner, matchId, index, route) => { + const existingMatch = inner.router.getMatch(matchId); + const parentMatchId = inner.matches[index - 1]?.id; + const parentMatch = parentMatchId ? inner.router.getMatch(parentMatchId) : void 0; + if (inner.router.isShell()) { + existingMatch.ssr = route.id === rootRouteId; + return; + } + if (parentMatch?.ssr === false) { + existingMatch.ssr = false; + return; + } + const parentOverride = (tempSsr2) => { + if (tempSsr2 === true && parentMatch?.ssr === "data-only") { + return "data-only"; + } + return tempSsr2; + }; + const defaultSsr = inner.router.options.defaultSsr ?? true; + if (route.options.ssr === void 0) { + existingMatch.ssr = parentOverride(defaultSsr); + return; + } + if (typeof route.options.ssr !== "function") { + existingMatch.ssr = parentOverride(route.options.ssr); + return; + } + const { search, params } = existingMatch; + const ssrFnContext = { + search: makeMaybe(search, existingMatch.searchError), + params: makeMaybe(params, existingMatch.paramsError), + location: inner.location, + matches: inner.matches.map((match) => ({ + index: match.index, + pathname: match.pathname, + fullPath: match.fullPath, + staticData: match.staticData, + id: match.id, + routeId: match.routeId, + search: makeMaybe(match.search, match.searchError), + params: makeMaybe(match.params, match.paramsError), + ssr: match.ssr + })) + }; + const tempSsr = route.options.ssr(ssrFnContext); + if (isPromise(tempSsr)) { + return tempSsr.then((ssr) => { + existingMatch.ssr = parentOverride(ssr ?? defaultSsr); + }); + } + existingMatch.ssr = parentOverride(tempSsr ?? defaultSsr); + return; +}; +var setupPendingTimeout = (inner, matchId, route, match) => { + if (match._nonReactive.pendingTimeout !== void 0) return; + const pendingMs = route.options.pendingMs ?? inner.router.options.defaultPendingMs; + const shouldPending = !!(inner.onReady && !(isServer ?? inner.router.isServer) && !resolvePreload(inner, matchId) && (route.options.loader || route.options.beforeLoad || routeNeedsPreload(route)) && typeof pendingMs === "number" && pendingMs !== Infinity && (route.options.pendingComponent ?? inner.router.options?.defaultPendingComponent)); + if (shouldPending) { + const pendingTimeout = setTimeout(() => { + triggerOnReady(inner); + }, pendingMs); + match._nonReactive.pendingTimeout = pendingTimeout; + } +}; +var preBeforeLoadSetup = (inner, matchId, route) => { + const existingMatch = inner.router.getMatch(matchId); + if (!existingMatch._nonReactive.beforeLoadPromise && !existingMatch._nonReactive.loaderPromise) + return; + setupPendingTimeout(inner, matchId, route, existingMatch); + const then = () => { + const match = inner.router.getMatch(matchId); + if (match.preload && (match.status === "redirected" || match.status === "notFound")) { + handleRedirectAndNotFound(inner, match, match.error); + } + }; + return existingMatch._nonReactive.beforeLoadPromise ? existingMatch._nonReactive.beforeLoadPromise.then(then) : then(); +}; +var executeBeforeLoad = (inner, matchId, index, route) => { + const match = inner.router.getMatch(matchId); + const prevLoadPromise = match._nonReactive.loadPromise; + match._nonReactive.loadPromise = createControlledPromise(() => { + prevLoadPromise?.resolve(); + }); + const { paramsError, searchError } = match; + if (paramsError) { + handleSerialError(inner, index, paramsError, "PARSE_PARAMS"); + } + if (searchError) { + handleSerialError(inner, index, searchError, "VALIDATE_SEARCH"); + } + setupPendingTimeout(inner, matchId, route, match); + const abortController = new AbortController(); + let isPending = false; + const pending = () => { + if (isPending) return; + isPending = true; + inner.updateMatch(matchId, (prev) => ({ + ...prev, + isFetching: "beforeLoad", + fetchCount: prev.fetchCount + 1, + abortController + // Note: We intentionally don't update context here. + // Context should only be updated after beforeLoad resolves to avoid + // components seeing incomplete context during async beforeLoad execution. + })); + }; + const resolve = () => { + match._nonReactive.beforeLoadPromise?.resolve(); + match._nonReactive.beforeLoadPromise = void 0; + inner.updateMatch(matchId, (prev) => ({ + ...prev, + isFetching: false + })); + }; + if (!route.options.beforeLoad) { + batch2(() => { + pending(); + resolve(); + }); + return; + } + match._nonReactive.beforeLoadPromise = createControlledPromise(); + const context = { + ...buildMatchContext(inner, index, false), + ...match.__routeContext + }; + const { search, params, cause } = match; + const preload = resolvePreload(inner, matchId); + const beforeLoadFnContext = { + search, + abortController, + params, + preload, + context, + location: inner.location, + navigate: (opts) => inner.router.navigate({ + ...opts, + _fromLocation: inner.location + }), + buildLocation: inner.router.buildLocation, + cause: preload ? "preload" : cause, + matches: inner.matches, + routeId: route.id, + ...inner.router.options.additionalContext + }; + const updateContext = (beforeLoadContext2) => { + if (beforeLoadContext2 === void 0) { + batch2(() => { + pending(); + resolve(); + }); + return; + } + if (isRedirect(beforeLoadContext2) || isNotFound(beforeLoadContext2)) { + pending(); + handleSerialError(inner, index, beforeLoadContext2, "BEFORE_LOAD"); + } + batch2(() => { + pending(); + inner.updateMatch(matchId, (prev) => ({ + ...prev, + __beforeLoadContext: beforeLoadContext2 + })); + resolve(); + }); + }; + let beforeLoadContext; + try { + beforeLoadContext = route.options.beforeLoad(beforeLoadFnContext); + if (isPromise(beforeLoadContext)) { + pending(); + return beforeLoadContext.catch((err) => { + handleSerialError(inner, index, err, "BEFORE_LOAD"); + }).then(updateContext); + } + } catch (err) { + pending(); + handleSerialError(inner, index, err, "BEFORE_LOAD"); + } + updateContext(beforeLoadContext); + return; +}; +var handleBeforeLoad = (inner, index) => { + const { id: matchId, routeId } = inner.matches[index]; + const route = inner.router.looseRoutesById[routeId]; + const serverSsr = () => { + if (isServer ?? inner.router.isServer) { + const maybePromise = isBeforeLoadSsr(inner, matchId, index, route); + if (isPromise(maybePromise)) return maybePromise.then(queueExecution); + } + return queueExecution(); + }; + const execute = () => executeBeforeLoad(inner, matchId, index, route); + const queueExecution = () => { + if (shouldSkipLoader(inner, matchId)) return; + const result = preBeforeLoadSetup(inner, matchId, route); + return isPromise(result) ? result.then(execute) : execute(); + }; + return serverSsr(); +}; +var executeHead = (inner, matchId, route) => { + const match = inner.router.getMatch(matchId); + if (!match) { + return; + } + if (!route.options.head && !route.options.scripts && !route.options.headers) { + return; + } + const assetContext = { + ssr: inner.router.options.ssr, + matches: inner.matches, + match, + params: match.params, + loaderData: match.loaderData + }; + return Promise.all([ + route.options.head?.(assetContext), + route.options.scripts?.(assetContext), + route.options.headers?.(assetContext) + ]).then(([headFnContent, scripts, headers]) => { + const meta = headFnContent?.meta; + const links = headFnContent?.links; + const headScripts = headFnContent?.scripts; + const styles = headFnContent?.styles; + return { + meta, + links, + headScripts, + headers, + scripts, + styles + }; + }); +}; +var getLoaderContext = (inner, matchPromises, matchId, index, route) => { + const parentMatchPromise = matchPromises[index - 1]; + const { params, loaderDeps, abortController, cause } = inner.router.getMatch(matchId); + const context = buildMatchContext(inner, index); + const preload = resolvePreload(inner, matchId); + return { + params, + deps: loaderDeps, + preload: !!preload, + parentMatchPromise, + abortController, + context, + location: inner.location, + navigate: (opts) => inner.router.navigate({ + ...opts, + _fromLocation: inner.location + }), + cause: preload ? "preload" : cause, + route, + ...inner.router.options.additionalContext + }; +}; +var runLoader = async (inner, matchPromises, matchId, index, route) => { + try { + const match = inner.router.getMatch(matchId); + try { + if (!(isServer ?? inner.router.isServer) || match.ssr === true) { + loadRouteChunk(route); + } + const loaderResult = route.options.loader?.( + getLoaderContext(inner, matchPromises, matchId, index, route) + ); + const loaderResultIsPromise = route.options.loader && isPromise(loaderResult); + const willLoadSomething = !!(loaderResultIsPromise || route._lazyPromise || route._componentsPromise || route.options.head || route.options.scripts || route.options.headers || match._nonReactive.minPendingPromise); + if (willLoadSomething) { + inner.updateMatch(matchId, (prev) => ({ + ...prev, + isFetching: "loader" + })); + } + if (route.options.loader) { + const loaderData = loaderResultIsPromise ? await loaderResult : loaderResult; + handleRedirectAndNotFound( + inner, + inner.router.getMatch(matchId), + loaderData + ); + if (loaderData !== void 0) { + inner.updateMatch(matchId, (prev) => ({ + ...prev, + loaderData + })); + } + } + if (route._lazyPromise) await route._lazyPromise; + const pendingPromise = match._nonReactive.minPendingPromise; + if (pendingPromise) await pendingPromise; + if (route._componentsPromise) await route._componentsPromise; + inner.updateMatch(matchId, (prev) => ({ + ...prev, + error: void 0, + context: buildMatchContext(inner, index), + status: "success", + isFetching: false, + updatedAt: Date.now() + })); + } catch (e) { + let error = e; + if (error?.name === "AbortError") { + if (match.abortController.signal.aborted) { + match._nonReactive.loaderPromise?.resolve(); + match._nonReactive.loaderPromise = void 0; + return; + } + inner.updateMatch(matchId, (prev) => ({ + ...prev, + status: prev.status === "pending" ? "success" : prev.status, + isFetching: false, + context: buildMatchContext(inner, index) + })); + return; + } + const pendingPromise = match._nonReactive.minPendingPromise; + if (pendingPromise) await pendingPromise; + if (isNotFound(e)) { + await route.options.notFoundComponent?.preload?.(); + } + handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), e); + try { + route.options.onError?.(e); + } catch (onErrorError) { + error = onErrorError; + handleRedirectAndNotFound( + inner, + inner.router.getMatch(matchId), + onErrorError + ); + } + inner.updateMatch(matchId, (prev) => ({ + ...prev, + error, + context: buildMatchContext(inner, index), + status: "error", + isFetching: false + })); + } + } catch (err) { + const match = inner.router.getMatch(matchId); + if (match) { + match._nonReactive.loaderPromise = void 0; + } + handleRedirectAndNotFound(inner, match, err); + } +}; +var loadRouteMatch = async (inner, matchPromises, index) => { + async function handleLoader(preload, prevMatch, previousRouteMatchId, match2, route2) { + const age = Date.now() - prevMatch.updatedAt; + const staleAge = preload ? route2.options.preloadStaleTime ?? inner.router.options.defaultPreloadStaleTime ?? 3e4 : route2.options.staleTime ?? inner.router.options.defaultStaleTime ?? 0; + const shouldReloadOption = route2.options.shouldReload; + const shouldReload = typeof shouldReloadOption === "function" ? shouldReloadOption( + getLoaderContext(inner, matchPromises, matchId, index, route2) + ) : shouldReloadOption; + const { status, invalid } = match2; + const staleMatchShouldReload = age > staleAge && (!!inner.forceStaleReload || match2.cause === "enter" || previousRouteMatchId !== void 0 && previousRouteMatchId !== match2.id); + loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? staleMatchShouldReload)); + if (preload && route2.options.preload === false) ; + else if (loaderShouldRunAsync && !inner.sync) { + loaderIsRunningAsync = true; + (async () => { + try { + await runLoader(inner, matchPromises, matchId, index, route2); + const match3 = inner.router.getMatch(matchId); + match3._nonReactive.loaderPromise?.resolve(); + match3._nonReactive.loadPromise?.resolve(); + match3._nonReactive.loaderPromise = void 0; + } catch (err) { + if (isRedirect(err)) { + await inner.router.navigate(err.options); + } + } + })(); + } else if (status !== "success" || loaderShouldRunAsync && inner.sync) { + await runLoader(inner, matchPromises, matchId, index, route2); + } else { + syncMatchContext(inner, matchId, index); + } + } + const { id: matchId, routeId } = inner.matches[index]; + let loaderShouldRunAsync = false; + let loaderIsRunningAsync = false; + const route = inner.router.looseRoutesById[routeId]; + if (shouldSkipLoader(inner, matchId)) { + const match2 = inner.router.getMatch(matchId); + if (!match2) { + return inner.matches[index]; + } + syncMatchContext(inner, matchId, index); + if (isServer ?? inner.router.isServer) { + return inner.router.getMatch(matchId); + } + } else { + const prevMatch = inner.router.getMatch(matchId); + const previousRouteMatchId = inner.router.state.matches[index]?.routeId === routeId ? inner.router.state.matches[index].id : inner.router.state.matches.find((d) => d.routeId === routeId)?.id; + const preload = resolvePreload(inner, matchId); + if (prevMatch._nonReactive.loaderPromise) { + if (prevMatch.status === "success" && !inner.sync && !prevMatch.preload) { + return prevMatch; + } + await prevMatch._nonReactive.loaderPromise; + const match2 = inner.router.getMatch(matchId); + const error = match2._nonReactive.error || match2.error; + if (error) { + handleRedirectAndNotFound(inner, match2, error); + } + if (match2.status === "pending") { + await handleLoader( + preload, + prevMatch, + previousRouteMatchId, + match2, + route + ); + } + } else { + const nextPreload = preload && !inner.router.state.matches.some((d) => d.id === matchId); + const match2 = inner.router.getMatch(matchId); + match2._nonReactive.loaderPromise = createControlledPromise(); + if (nextPreload !== match2.preload) { + inner.updateMatch(matchId, (prev) => ({ + ...prev, + preload: nextPreload + })); + } + await handleLoader(preload, prevMatch, previousRouteMatchId, match2, route); + } + } + const match = inner.router.getMatch(matchId); + if (!loaderIsRunningAsync) { + match._nonReactive.loaderPromise?.resolve(); + match._nonReactive.loadPromise?.resolve(); + } + clearTimeout(match._nonReactive.pendingTimeout); + match._nonReactive.pendingTimeout = void 0; + if (!loaderIsRunningAsync) match._nonReactive.loaderPromise = void 0; + match._nonReactive.dehydrated = void 0; + const nextIsFetching = loaderIsRunningAsync ? match.isFetching : false; + if (nextIsFetching !== match.isFetching || match.invalid !== false) { + inner.updateMatch(matchId, (prev) => ({ + ...prev, + isFetching: nextIsFetching, + invalid: false + })); + return inner.router.getMatch(matchId); + } else { + return match; + } +}; +async function loadMatches(arg) { + const inner = arg; + const matchPromises = []; + if (!(isServer ?? inner.router.isServer) && inner.router.state.matches.some((d) => d._forcePending)) { + triggerOnReady(inner); + } + let beforeLoadNotFound; + for (let i = 0; i < inner.matches.length; i++) { + try { + const beforeLoad = handleBeforeLoad(inner, i); + if (isPromise(beforeLoad)) await beforeLoad; + } catch (err) { + if (isRedirect(err)) { + throw err; + } + if (isNotFound(err)) { + beforeLoadNotFound = err; + } else { + if (!inner.preload) throw err; + } + break; + } + if (inner.serialError) { + break; + } + } + const baseMaxIndexExclusive = inner.firstBadMatchIndex ?? inner.matches.length; + const boundaryIndex = beforeLoadNotFound && !inner.preload ? getNotFoundBoundaryIndex(inner, beforeLoadNotFound) : void 0; + const maxIndexExclusive = beforeLoadNotFound && inner.preload ? 0 : boundaryIndex !== void 0 ? Math.min(boundaryIndex + 1, baseMaxIndexExclusive) : baseMaxIndexExclusive; + let firstNotFound; + let firstUnhandledRejection; + for (let i = 0; i < maxIndexExclusive; i++) { + matchPromises.push(loadRouteMatch(inner, matchPromises, i)); + } + try { + await Promise.all(matchPromises); + } catch { + const settled = await Promise.allSettled(matchPromises); + for (const result of settled) { + if (result.status !== "rejected") continue; + const reason = result.reason; + if (isRedirect(reason)) { + throw reason; + } + if (isNotFound(reason)) { + firstNotFound ??= reason; + } else { + firstUnhandledRejection ??= reason; + } + } + if (firstUnhandledRejection !== void 0) { + throw firstUnhandledRejection; + } + } + const notFoundToThrow = firstNotFound ?? (beforeLoadNotFound && !inner.preload ? beforeLoadNotFound : void 0); + let headMaxIndex = inner.serialError ? inner.firstBadMatchIndex ?? 0 : inner.matches.length - 1; + if (!notFoundToThrow && beforeLoadNotFound && inner.preload) { + return inner.matches; + } + if (notFoundToThrow) { + const renderedBoundaryIndex = getNotFoundBoundaryIndex( + inner, + notFoundToThrow + ); + invariant( + renderedBoundaryIndex !== void 0, + "Could not find match for notFound boundary" + ); + const boundaryMatch = inner.matches[renderedBoundaryIndex]; + const boundaryRoute = inner.router.looseRoutesById[boundaryMatch.routeId]; + const defaultNotFoundComponent = inner.router.options?.defaultNotFoundComponent; + if (!boundaryRoute.options.notFoundComponent && defaultNotFoundComponent) { + boundaryRoute.options.notFoundComponent = defaultNotFoundComponent; + } + notFoundToThrow.routeId = boundaryMatch.routeId; + const boundaryIsRoot = boundaryMatch.routeId === inner.router.routeTree.id; + inner.updateMatch(boundaryMatch.id, (prev) => ({ + ...prev, + ...boundaryIsRoot ? ( + // For root boundary, use globalNotFound so the root component's + // shell still renders and handles the not-found display, + // instead of replacing the entire root shell via status='notFound'. + { status: "success", globalNotFound: true, error: void 0 } + ) : ( + // For non-root boundaries, set status:'notFound' so MatchInner + // renders the notFoundComponent directly. + { status: "notFound", error: notFoundToThrow } + ), + isFetching: false + })); + headMaxIndex = renderedBoundaryIndex; + await loadRouteChunk(boundaryRoute); + } else if (!inner.preload) { + const rootMatch = inner.matches[0]; + if (!rootMatch.globalNotFound) { + const currentRootMatch = inner.router.getMatch(rootMatch.id); + if (currentRootMatch?.globalNotFound) { + inner.updateMatch(rootMatch.id, (prev) => ({ + ...prev, + globalNotFound: false, + error: void 0 + })); + } + } + } + if (inner.serialError && inner.firstBadMatchIndex !== void 0) { + const errorRoute = inner.router.looseRoutesById[inner.matches[inner.firstBadMatchIndex].routeId]; + await loadRouteChunk(errorRoute); + } + for (let i = 0; i <= headMaxIndex; i++) { + const match = inner.matches[i]; + const { id: matchId, routeId } = match; + const route = inner.router.looseRoutesById[routeId]; + try { + const headResult = executeHead(inner, matchId, route); + if (headResult) { + const head = await headResult; + inner.updateMatch(matchId, (prev) => ({ + ...prev, + ...head + })); + } + } catch (err) { + console.error(`Error executing head for route ${routeId}:`, err); + } + } + const readyPromise = triggerOnReady(inner); + if (isPromise(readyPromise)) { + await readyPromise; + } + if (notFoundToThrow) { + throw notFoundToThrow; + } + if (inner.serialError && !inner.preload && !inner.onReady) { + throw inner.serialError; + } + return inner.matches; +} +async function loadRouteChunk(route) { + if (!route._lazyLoaded && route._lazyPromise === void 0) { + if (route.lazyFn) { + route._lazyPromise = route.lazyFn().then((lazyRoute) => { + const { id: _id, ...options } = lazyRoute.options; + Object.assign(route.options, options); + route._lazyLoaded = true; + route._lazyPromise = void 0; + }); + } else { + route._lazyLoaded = true; + } + } + if (!route._componentsLoaded && route._componentsPromise === void 0) { + const loadComponents = () => { + const preloads = []; + for (const type of componentTypes) { + const preload = route.options[type]?.preload; + if (preload) preloads.push(preload()); + } + if (preloads.length) + return Promise.all(preloads).then(() => { + route._componentsLoaded = true; + route._componentsPromise = void 0; + }); + route._componentsLoaded = true; + route._componentsPromise = void 0; + return; + }; + route._componentsPromise = route._lazyPromise ? route._lazyPromise.then(loadComponents) : loadComponents(); + } + return route._componentsPromise; +} +function makeMaybe(value, error) { + if (error) { + return { status: "error", error }; + } + return { status: "success", value }; +} +function routeNeedsPreload(route) { + for (const componentType of componentTypes) { + if (route.options[componentType]?.preload) { + return true; + } + } + return false; +} +var componentTypes = [ + "component", + "errorComponent", + "pendingComponent", + "notFoundComponent" +]; + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/rewrite.js +function composeRewrites(rewrites) { + return { + input: ({ url }) => { + for (const rewrite of rewrites) { + url = executeRewriteInput(rewrite, url); + } + return url; + }, + output: ({ url }) => { + for (let i = rewrites.length - 1; i >= 0; i--) { + url = executeRewriteOutput(rewrites[i], url); + } + return url; + } + }; +} +function rewriteBasepath(opts) { + const trimmedBasepath = trimPath(opts.basepath); + const normalizedBasepath = `/${trimmedBasepath}`; + const normalizedBasepathWithSlash = `${normalizedBasepath}/`; + const checkBasepath = opts.caseSensitive ? normalizedBasepath : normalizedBasepath.toLowerCase(); + const checkBasepathWithSlash = opts.caseSensitive ? normalizedBasepathWithSlash : normalizedBasepathWithSlash.toLowerCase(); + return { + input: ({ url }) => { + const pathname = opts.caseSensitive ? url.pathname : url.pathname.toLowerCase(); + if (pathname === checkBasepath) { + url.pathname = "/"; + } else if (pathname.startsWith(checkBasepathWithSlash)) { + url.pathname = url.pathname.slice(normalizedBasepath.length); + } + return url; + }, + output: ({ url }) => { + url.pathname = joinPaths(["/", trimmedBasepath, url.pathname]); + return url; + } + }; +} +function executeRewriteInput(rewrite, url) { + const res = rewrite?.input?.({ url }); + if (res) { + if (typeof res === "string") { + return new URL(res); + } else if (res instanceof URL) { + return res; + } + } + return url; +} +function executeRewriteOutput(rewrite, url) { + const res = rewrite?.output?.({ url }); + if (res) { + if (typeof res === "string") { + return new URL(res); + } else if (res instanceof URL) { + return res; + } + } + return url; +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/router.js +function defaultSerializeError(err) { + if (err instanceof Error) { + const obj = { + name: err.name, + message: err.message + }; + if (true) { + obj.stack = err.stack; + } + return obj; + } + return { + data: err + }; +} +function getLocationChangeInfo(routerState) { + const fromLocation = routerState.resolvedLocation; + const toLocation = routerState.location; + const pathChanged = fromLocation?.pathname !== toLocation.pathname; + const hrefChanged = fromLocation?.href !== toLocation.href; + const hashChanged = fromLocation?.hash !== toLocation.hash; + return { fromLocation, toLocation, pathChanged, hrefChanged, hashChanged }; +} +function filterRedirectedCachedMatches(matches) { + const filtered = matches.filter((d) => d.status !== "redirected"); + return filtered.length === matches.length ? matches : filtered; +} +function createServerStore(initialState) { + const store = { + state: initialState, + setState: (updater) => { + store.state = updater(store.state); + } + }; + return store; +} +var RouterCore = class { + /** + * @deprecated Use the `createRouter` function instead + */ + constructor(options) { + this.tempLocationKey = `${Math.round( + Math.random() * 1e7 + )}`; + this.resetNextScroll = true; + this.shouldViewTransition = void 0; + this.isViewTransitionTypesSupported = void 0; + this.subscribers = /* @__PURE__ */ new Set(); + this.isScrollRestoring = false; + this.isScrollRestorationSetup = false; + this.startTransition = (fn) => fn(); + this.update = (newOptions) => { + if (true) { + if (newOptions.notFoundRoute) { + console.warn( + "The notFoundRoute API is deprecated and will be removed in the next major version. See https://tanstack.com/router/v1/docs/framework/react/guide/not-found-errors#migrating-from-notfoundroute for more info." + ); + } + } + const prevOptions = this.options; + const prevBasepath = this.basepath ?? prevOptions?.basepath ?? "/"; + const basepathWasUnset = this.basepath === void 0; + const prevRewriteOption = prevOptions?.rewrite; + this.options = { + ...prevOptions, + ...newOptions + }; + this.isServer = this.options.isServer ?? typeof document === "undefined"; + this.protocolAllowlist = new Set(this.options.protocolAllowlist); + if (this.options.pathParamsAllowedCharacters) + this.pathParamsDecoder = compileDecodeCharMap( + this.options.pathParamsAllowedCharacters + ); + if (!this.history || this.options.history && this.options.history !== this.history) { + if (!this.options.history) { + if (!(isServer ?? this.isServer)) { + this.history = createBrowserHistory(); + } + } else { + this.history = this.options.history; + } + } + this.origin = this.options.origin; + if (!this.origin) { + if (!(isServer ?? this.isServer) && window?.origin && window.origin !== "null") { + this.origin = window.origin; + } else { + this.origin = "http://localhost"; + } + } + if (this.history) { + this.updateLatestLocation(); + } + if (this.options.routeTree !== this.routeTree) { + this.routeTree = this.options.routeTree; + let processRouteTreeResult; + if ((isServer ?? this.isServer) && false) { + const cached = globalThis.__TSR_CACHE__; + this.resolvePathCache = cached.resolvePathCache; + processRouteTreeResult = cached.processRouteTreeResult; + } else { + this.resolvePathCache = createLRUCache(1e3); + processRouteTreeResult = this.buildRouteTree(); + if ((isServer ?? this.isServer) && false) { + globalThis.__TSR_CACHE__ = { + routeTree: this.routeTree, + processRouteTreeResult, + resolvePathCache: this.resolvePathCache + }; + } + } + this.setRoutes(processRouteTreeResult); + } + if (!this.__store && this.latestLocation) { + if (isServer ?? this.isServer) { + this.__store = createServerStore( + getInitialRouterState(this.latestLocation) + ); + } else { + this.__store = createStore(getInitialRouterState(this.latestLocation)); + setupScrollRestoration(this); + } + } + let needsLocationUpdate = false; + const nextBasepath = this.options.basepath ?? "/"; + const nextRewriteOption = this.options.rewrite; + const basepathChanged = basepathWasUnset || prevBasepath !== nextBasepath; + const rewriteChanged = prevRewriteOption !== nextRewriteOption; + if (basepathChanged || rewriteChanged) { + this.basepath = nextBasepath; + const rewrites = []; + const trimmed = trimPath(nextBasepath); + if (trimmed && trimmed !== "/") { + rewrites.push( + rewriteBasepath({ + basepath: nextBasepath + }) + ); + } + if (nextRewriteOption) { + rewrites.push(nextRewriteOption); + } + this.rewrite = rewrites.length === 0 ? void 0 : rewrites.length === 1 ? rewrites[0] : composeRewrites(rewrites); + if (this.history) { + this.updateLatestLocation(); + } + needsLocationUpdate = true; + } + if (needsLocationUpdate && this.__store) { + this.__store.setState((s) => ({ + ...s, + location: this.latestLocation + })); + } + if (typeof window !== "undefined" && "CSS" in window && typeof window.CSS?.supports === "function") { + this.isViewTransitionTypesSupported = window.CSS.supports( + "selector(:active-view-transition-type(a)" + ); + } + }; + this.updateLatestLocation = () => { + this.latestLocation = this.parseLocation( + this.history.location, + this.latestLocation + ); + }; + this.buildRouteTree = () => { + const result = processRouteTree( + this.routeTree, + this.options.caseSensitive, + (route, i) => { + route.init({ + originalIndex: i + }); + } + ); + if (this.options.routeMasks) { + processRouteMasks(this.options.routeMasks, result.processedTree); + } + return result; + }; + this.subscribe = (eventType, fn) => { + const listener = { + eventType, + fn + }; + this.subscribers.add(listener); + return () => { + this.subscribers.delete(listener); + }; + }; + this.emit = (routerEvent) => { + this.subscribers.forEach((listener) => { + if (listener.eventType === routerEvent.type) { + listener.fn(routerEvent); + } + }); + }; + this.parseLocation = (locationToParse, previousLocation) => { + const parse = ({ + pathname, + search, + hash, + href, + state + }) => { + if (!this.rewrite && !/[ \x00-\x1f\x7f\u0080-\uffff]/.test(pathname)) { + const parsedSearch2 = this.options.parseSearch(search); + const searchStr2 = this.options.stringifySearch(parsedSearch2); + return { + href: pathname + searchStr2 + hash, + publicHref: href, + pathname: decodePath(pathname).path, + external: false, + searchStr: searchStr2, + search: replaceEqualDeep( + previousLocation?.search, + parsedSearch2 + ), + hash: decodePath(hash.slice(1)).path, + state: replaceEqualDeep(previousLocation?.state, state) + }; + } + const fullUrl = new URL(href, this.origin); + const url = executeRewriteInput(this.rewrite, fullUrl); + const parsedSearch = this.options.parseSearch(url.search); + const searchStr = this.options.stringifySearch(parsedSearch); + url.search = searchStr; + const fullPath = url.href.replace(url.origin, ""); + return { + href: fullPath, + publicHref: href, + pathname: decodePath(url.pathname).path, + external: !!this.rewrite && url.origin !== this.origin, + searchStr, + search: replaceEqualDeep(previousLocation?.search, parsedSearch), + hash: decodePath(url.hash.slice(1)).path, + state: replaceEqualDeep(previousLocation?.state, state) + }; + }; + const location = parse(locationToParse); + const { __tempLocation, __tempKey } = location.state; + if (__tempLocation && (!__tempKey || __tempKey === this.tempLocationKey)) { + const parsedTempLocation = parse(__tempLocation); + parsedTempLocation.state.key = location.state.key; + parsedTempLocation.state.__TSR_key = location.state.__TSR_key; + delete parsedTempLocation.state.__tempLocation; + return { + ...parsedTempLocation, + maskedLocation: location + }; + } + return location; + }; + this.resolvePathWithBase = (from, path) => { + const resolvedPath = resolvePath({ + base: from, + to: cleanPath(path), + trailingSlash: this.options.trailingSlash, + cache: this.resolvePathCache + }); + return resolvedPath; + }; + this.matchRoutes = (pathnameOrNext, locationSearchOrOpts, opts) => { + if (typeof pathnameOrNext === "string") { + return this.matchRoutesInternal( + { + pathname: pathnameOrNext, + search: locationSearchOrOpts + }, + opts + ); + } + return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts); + }; + this.getMatchedRoutes = (pathname) => { + return getMatchedRoutes({ + pathname, + routesById: this.routesById, + processedTree: this.processedTree + }); + }; + this.cancelMatch = (id) => { + const match = this.getMatch(id); + if (!match) return; + match.abortController.abort(); + clearTimeout(match._nonReactive.pendingTimeout); + match._nonReactive.pendingTimeout = void 0; + }; + this.cancelMatches = () => { + const currentPendingMatches = this.state.matches.filter( + (match) => match.status === "pending" + ); + const currentLoadingMatches = this.state.matches.filter( + (match) => match.isFetching === "loader" + ); + const matchesToCancelArray = /* @__PURE__ */ new Set([ + ...this.state.pendingMatches ?? [], + ...currentPendingMatches, + ...currentLoadingMatches + ]); + matchesToCancelArray.forEach((match) => { + this.cancelMatch(match.id); + }); + }; + this.buildLocation = (opts) => { + const build = (dest = {}) => { + const currentLocation = dest._fromLocation || this.pendingBuiltLocation || this.latestLocation; + const lightweightResult = this.matchRoutesLightweight(currentLocation); + if (dest.from && true && dest._isNavigate) { + const allFromMatches = this.getMatchedRoutes(dest.from).matchedRoutes; + const matchedFrom = findLast(lightweightResult.matchedRoutes, (d) => { + return comparePaths(d.fullPath, dest.from); + }); + const matchedCurrent = findLast(allFromMatches, (d) => { + return comparePaths(d.fullPath, lightweightResult.fullPath); + }); + if (!matchedFrom && !matchedCurrent) { + console.warn(`Could not find match for from: ${dest.from}`); + } + } + const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lightweightResult.fullPath; + const fromPath = this.resolvePathWithBase(defaultedFromPath, "."); + const fromSearch = lightweightResult.search; + const fromParams = { ...lightweightResult.params }; + const nextTo = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, "."); + const nextParams = dest.params === false || dest.params === null ? {} : (dest.params ?? true) === true ? fromParams : Object.assign( + fromParams, + functionalUpdate(dest.params, fromParams) + ); + const destMatchResult = this.getMatchedRoutes(nextTo); + let destRoutes = destMatchResult.matchedRoutes; + const isGlobalNotFound = !destMatchResult.foundRoute || destMatchResult.foundRoute.path !== "/" && destMatchResult.routeParams["**"]; + if (isGlobalNotFound && this.options.notFoundRoute) { + destRoutes = [...destRoutes, this.options.notFoundRoute]; + } + if (Object.keys(nextParams).length > 0) { + for (const route of destRoutes) { + const fn = route.options.params?.stringify ?? route.options.stringifyParams; + if (fn) { + try { + Object.assign(nextParams, fn(nextParams)); + } catch { + } + } + } + } + const nextPathname = opts.leaveParams ? ( + // Use the original template path for interpolation + // This preserves the original parameter syntax including optional parameters + nextTo + ) : decodePath( + interpolatePath({ + path: nextTo, + params: nextParams, + decoder: this.pathParamsDecoder, + server: this.isServer + }).interpolatedPath + ).path; + let nextSearch = fromSearch; + if (opts._includeValidateSearch && this.options.search?.strict) { + const validatedSearch = {}; + destRoutes.forEach((route) => { + if (route.options.validateSearch) { + try { + Object.assign( + validatedSearch, + validateSearch(route.options.validateSearch, { + ...validatedSearch, + ...nextSearch + }) + ); + } catch { + } + } + }); + nextSearch = validatedSearch; + } + nextSearch = applySearchMiddleware({ + search: nextSearch, + dest, + destRoutes, + _includeValidateSearch: opts._includeValidateSearch + }); + nextSearch = replaceEqualDeep(fromSearch, nextSearch); + const searchStr = this.options.stringifySearch(nextSearch); + const hash = dest.hash === true ? currentLocation.hash : dest.hash ? functionalUpdate(dest.hash, currentLocation.hash) : void 0; + const hashStr = hash ? `#${hash}` : ""; + let nextState = dest.state === true ? currentLocation.state : dest.state ? functionalUpdate(dest.state, currentLocation.state) : {}; + nextState = replaceEqualDeep(currentLocation.state, nextState); + const fullPath = `${nextPathname}${searchStr}${hashStr}`; + let href; + let publicHref; + let external = false; + if (this.rewrite) { + const url = new URL(fullPath, this.origin); + const rewrittenUrl = executeRewriteOutput(this.rewrite, url); + href = url.href.replace(url.origin, ""); + if (rewrittenUrl.origin !== this.origin) { + publicHref = rewrittenUrl.href; + external = true; + } else { + publicHref = rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash; + } + } else { + href = encodePathLikeUrl(fullPath); + publicHref = href; + } + return { + publicHref, + href, + pathname: nextPathname, + search: nextSearch, + searchStr, + state: nextState, + hash: hash ?? "", + external, + unmaskOnReload: dest.unmaskOnReload + }; + }; + const buildWithMatches = (dest = {}, maskedDest) => { + const next = build(dest); + let maskedNext = maskedDest ? build(maskedDest) : void 0; + if (!maskedNext) { + const params = {}; + if (this.options.routeMasks) { + const match = findFlatMatch( + next.pathname, + this.processedTree + ); + if (match) { + Object.assign(params, match.rawParams); + const { + from: _from, + params: maskParams, + ...maskProps + } = match.route; + const nextParams = maskParams === false || maskParams === null ? {} : (maskParams ?? true) === true ? params : Object.assign(params, functionalUpdate(maskParams, params)); + maskedDest = { + from: opts.from, + ...maskProps, + params: nextParams + }; + maskedNext = build(maskedDest); + } + } + } + if (maskedNext) { + next.maskedLocation = maskedNext; + } + return next; + }; + if (opts.mask) { + return buildWithMatches(opts, { + from: opts.from, + ...opts.mask + }); + } + return buildWithMatches(opts); + }; + this.commitLocation = async ({ + viewTransition, + ignoreBlocker, + ...next + }) => { + const isSameState = () => { + const ignoredProps = [ + "key", + // TODO: Remove in v2 - use __TSR_key instead + "__TSR_key", + "__TSR_index", + "__hashScrollIntoViewOptions" + ]; + ignoredProps.forEach((prop) => { + next.state[prop] = this.latestLocation.state[prop]; + }); + const isEqual = deepEqual(next.state, this.latestLocation.state); + ignoredProps.forEach((prop) => { + delete next.state[prop]; + }); + return isEqual; + }; + const isSameUrl = trimPathRight2(this.latestLocation.href) === trimPathRight2(next.href); + const previousCommitPromise = this.commitLocationPromise; + this.commitLocationPromise = createControlledPromise(() => { + previousCommitPromise?.resolve(); + }); + if (isSameUrl && isSameState()) { + this.load(); + } else { + let { + // eslint-disable-next-line prefer-const + maskedLocation, + // eslint-disable-next-line prefer-const + hashScrollIntoView, + ...nextHistory + } = next; + if (maskedLocation) { + nextHistory = { + ...maskedLocation, + state: { + ...maskedLocation.state, + __tempKey: void 0, + __tempLocation: { + ...nextHistory, + search: nextHistory.searchStr, + state: { + ...nextHistory.state, + __tempKey: void 0, + __tempLocation: void 0, + __TSR_key: void 0, + key: void 0 + // TODO: Remove in v2 - use __TSR_key instead + } + } + } + }; + if (nextHistory.unmaskOnReload ?? this.options.unmaskOnReload ?? false) { + nextHistory.state.__tempKey = this.tempLocationKey; + } + } + nextHistory.state.__hashScrollIntoViewOptions = hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true; + this.shouldViewTransition = viewTransition; + this.history[next.replace ? "replace" : "push"]( + nextHistory.publicHref, + nextHistory.state, + { ignoreBlocker } + ); + } + this.resetNextScroll = next.resetScroll ?? true; + if (!this.history.subscribers.size) { + this.load(); + } + return this.commitLocationPromise; + }; + this.buildAndCommitLocation = ({ + replace, + resetScroll, + hashScrollIntoView, + viewTransition, + ignoreBlocker, + href, + ...rest + } = {}) => { + if (href) { + const currentIndex = this.history.location.state.__TSR_index; + const parsed = parseHref(href, { + __TSR_index: replace ? currentIndex : currentIndex + 1 + }); + const hrefUrl = new URL(parsed.pathname, this.origin); + const rewrittenUrl = executeRewriteInput(this.rewrite, hrefUrl); + rest.to = rewrittenUrl.pathname; + rest.search = this.options.parseSearch(parsed.search); + rest.hash = parsed.hash.slice(1); + } + const location = this.buildLocation({ + ...rest, + _includeValidateSearch: true + }); + this.pendingBuiltLocation = location; + const commitPromise = this.commitLocation({ + ...location, + viewTransition, + replace, + resetScroll, + hashScrollIntoView, + ignoreBlocker + }); + Promise.resolve().then(() => { + if (this.pendingBuiltLocation === location) { + this.pendingBuiltLocation = void 0; + } + }); + return commitPromise; + }; + this.navigate = async ({ + to, + reloadDocument, + href, + publicHref, + ...rest + }) => { + let hrefIsUrl = false; + if (href) { + try { + new URL(`${href}`); + hrefIsUrl = true; + } catch { + } + } + if (hrefIsUrl && !reloadDocument) { + reloadDocument = true; + } + if (reloadDocument) { + if (to !== void 0 || !href) { + const location = this.buildLocation({ to, ...rest }); + href = href ?? location.publicHref; + publicHref = publicHref ?? location.publicHref; + } + const reloadHref = !hrefIsUrl && publicHref ? publicHref : href; + if (isDangerousProtocol(reloadHref, this.protocolAllowlist)) { + if (true) { + console.warn( + `Blocked navigation to dangerous protocol: ${reloadHref}` + ); + } + return Promise.resolve(); + } + if (!rest.ignoreBlocker) { + const historyWithBlockers = this.history; + const blockers = historyWithBlockers.getBlockers?.() ?? []; + for (const blocker of blockers) { + if (blocker?.blockerFn) { + const shouldBlock = await blocker.blockerFn({ + currentLocation: this.latestLocation, + nextLocation: this.latestLocation, + // External URLs don't have a next location in our router + action: "PUSH" + }); + if (shouldBlock) { + return Promise.resolve(); + } + } + } + } + if (rest.replace) { + window.location.replace(reloadHref); + } else { + window.location.href = reloadHref; + } + return Promise.resolve(); + } + return this.buildAndCommitLocation({ + ...rest, + href, + to, + _isNavigate: true + }); + }; + this.beforeLoad = () => { + this.cancelMatches(); + this.updateLatestLocation(); + if (isServer ?? this.isServer) { + const nextLocation = this.buildLocation({ + to: this.latestLocation.pathname, + search: true, + params: true, + hash: true, + state: true, + _includeValidateSearch: true + }); + if (this.latestLocation.publicHref !== nextLocation.publicHref) { + const href = this.getParsedLocationHref(nextLocation); + if (nextLocation.external) { + throw redirect({ href }); + } else { + throw redirect({ href, _builtLocation: nextLocation }); + } + } + } + const pendingMatches = this.matchRoutes(this.latestLocation); + this.__store.setState((s) => ({ + ...s, + status: "pending", + statusCode: 200, + isLoading: true, + location: this.latestLocation, + pendingMatches, + // If a cached moved to pendingMatches, remove it from cachedMatches + cachedMatches: s.cachedMatches.filter( + (d) => !pendingMatches.some((e) => e.id === d.id) + ) + })); + }; + this.load = async (opts) => { + let redirect2; + let notFound2; + let loadPromise; + const previousLocation = this.state.resolvedLocation ?? this.state.location; + loadPromise = new Promise((resolve) => { + this.startTransition(async () => { + try { + this.beforeLoad(); + const next = this.latestLocation; + const prevLocation = this.state.resolvedLocation; + if (!this.state.redirect) { + this.emit({ + type: "onBeforeNavigate", + ...getLocationChangeInfo({ + resolvedLocation: prevLocation, + location: next + }) + }); + } + this.emit({ + type: "onBeforeLoad", + ...getLocationChangeInfo({ + resolvedLocation: prevLocation, + location: next + }) + }); + await loadMatches({ + router: this, + sync: opts?.sync, + forceStaleReload: previousLocation.href === next.href, + matches: this.state.pendingMatches, + location: next, + updateMatch: this.updateMatch, + // eslint-disable-next-line @typescript-eslint/require-await + onReady: async () => { + this.startTransition(() => { + this.startViewTransition(async () => { + let exitingMatches = []; + let hookExitingMatches = []; + let hookEnteringMatches = []; + let hookStayingMatches = []; + batch2(() => { + this.__store.setState((s) => { + const previousMatches = s.matches; + const newMatches = s.pendingMatches || s.matches; + exitingMatches = previousMatches.filter( + (match) => !newMatches.some((d) => d.id === match.id) + ); + hookExitingMatches = previousMatches.filter( + (match) => !newMatches.some((d) => d.routeId === match.routeId) + ); + hookEnteringMatches = newMatches.filter( + (match) => !previousMatches.some( + (d) => d.routeId === match.routeId + ) + ); + hookStayingMatches = newMatches.filter( + (match) => previousMatches.some( + (d) => d.routeId === match.routeId + ) + ); + return { + ...s, + isLoading: false, + loadedAt: Date.now(), + matches: newMatches, + pendingMatches: void 0, + /** + * When committing new matches, cache any exiting matches that are still usable. + * Routes that resolved with `status: 'error'` or `status: 'notFound'` are + * deliberately excluded from `cachedMatches` so that subsequent invalidations + * or reloads re-run their loaders instead of reusing the failed/not-found data. + */ + cachedMatches: [ + ...s.cachedMatches, + ...exitingMatches.filter( + (d) => d.status !== "error" && d.status !== "notFound" && d.status !== "redirected" + ) + ] + }; + }); + this.clearExpiredCache(); + }); + [ + [hookExitingMatches, "onLeave"], + [hookEnteringMatches, "onEnter"], + [hookStayingMatches, "onStay"] + ].forEach(([matches, hook]) => { + matches.forEach((match) => { + this.looseRoutesById[match.routeId].options[hook]?.( + match + ); + }); + }); + }); + }); + } + }); + } catch (err) { + if (isRedirect(err)) { + redirect2 = err; + if (!(isServer ?? this.isServer)) { + this.navigate({ + ...redirect2.options, + replace: true, + ignoreBlocker: true + }); + } + } else if (isNotFound(err)) { + notFound2 = err; + } + this.__store.setState((s) => ({ + ...s, + statusCode: redirect2 ? redirect2.status : notFound2 ? 404 : s.matches.some((d) => d.status === "error") ? 500 : 200, + redirect: redirect2 + })); + } + if (this.latestLoadPromise === loadPromise) { + this.commitLocationPromise?.resolve(); + this.latestLoadPromise = void 0; + this.commitLocationPromise = void 0; + } + resolve(); + }); + }); + this.latestLoadPromise = loadPromise; + await loadPromise; + while (this.latestLoadPromise && loadPromise !== this.latestLoadPromise) { + await this.latestLoadPromise; + } + let newStatusCode = void 0; + if (this.hasNotFoundMatch()) { + newStatusCode = 404; + } else if (this.__store.state.matches.some((d) => d.status === "error")) { + newStatusCode = 500; + } + if (newStatusCode !== void 0) { + this.__store.setState((s) => ({ + ...s, + statusCode: newStatusCode + })); + } + }; + this.startViewTransition = (fn) => { + const shouldViewTransition = this.shouldViewTransition ?? this.options.defaultViewTransition; + this.shouldViewTransition = void 0; + if (shouldViewTransition && typeof document !== "undefined" && "startViewTransition" in document && typeof document.startViewTransition === "function") { + let startViewTransitionParams; + if (typeof shouldViewTransition === "object" && this.isViewTransitionTypesSupported) { + const next = this.latestLocation; + const prevLocation = this.state.resolvedLocation; + const resolvedViewTransitionTypes = typeof shouldViewTransition.types === "function" ? shouldViewTransition.types( + getLocationChangeInfo({ + resolvedLocation: prevLocation, + location: next + }) + ) : shouldViewTransition.types; + if (resolvedViewTransitionTypes === false) { + fn(); + return; + } + startViewTransitionParams = { + update: fn, + types: resolvedViewTransitionTypes + }; + } else { + startViewTransitionParams = fn; + } + document.startViewTransition(startViewTransitionParams); + } else { + fn(); + } + }; + this.updateMatch = (id, updater) => { + this.startTransition(() => { + const matchesKey = this.state.pendingMatches?.some((d) => d.id === id) ? "pendingMatches" : this.state.matches.some((d) => d.id === id) ? "matches" : this.state.cachedMatches.some((d) => d.id === id) ? "cachedMatches" : ""; + if (matchesKey) { + if (matchesKey === "cachedMatches") { + this.__store.setState((s) => ({ + ...s, + cachedMatches: filterRedirectedCachedMatches( + s.cachedMatches.map((d) => d.id === id ? updater(d) : d) + ) + })); + } else { + this.__store.setState((s) => ({ + ...s, + [matchesKey]: s[matchesKey]?.map( + (d) => d.id === id ? updater(d) : d + ) + })); + } + } + }); + }; + this.getMatch = (matchId) => { + const findFn = (d) => d.id === matchId; + return this.state.cachedMatches.find(findFn) ?? this.state.pendingMatches?.find(findFn) ?? this.state.matches.find(findFn); + }; + this.invalidate = (opts) => { + const invalidate = (d) => { + if (opts?.filter?.(d) ?? true) { + return { + ...d, + invalid: true, + ...opts?.forcePending || d.status === "error" || d.status === "notFound" ? { status: "pending", error: void 0 } : void 0 + }; + } + return d; + }; + this.__store.setState((s) => ({ + ...s, + matches: s.matches.map(invalidate), + cachedMatches: s.cachedMatches.map(invalidate), + pendingMatches: s.pendingMatches?.map(invalidate) + })); + this.shouldViewTransition = false; + return this.load({ sync: opts?.sync }); + }; + this.getParsedLocationHref = (location) => { + return location.publicHref || "/"; + }; + this.resolveRedirect = (redirect2) => { + const locationHeader = redirect2.headers.get("Location"); + if (!redirect2.options.href || redirect2.options._builtLocation) { + const location = redirect2.options._builtLocation ?? this.buildLocation(redirect2.options); + const href = this.getParsedLocationHref(location); + redirect2.options.href = href; + redirect2.headers.set("Location", href); + } else if (locationHeader) { + try { + const url = new URL(locationHeader); + if (this.origin && url.origin === this.origin) { + const href = url.pathname + url.search + url.hash; + redirect2.options.href = href; + redirect2.headers.set("Location", href); + } + } catch { + } + } + if (redirect2.options.href && !redirect2.options._builtLocation && // Check for dangerous protocols before processing the redirect + isDangerousProtocol(redirect2.options.href, this.protocolAllowlist)) { + throw new Error( + true ? `Redirect blocked: unsafe protocol in href "${redirect2.options.href}". Allowed protocols: ${Array.from(this.protocolAllowlist).join(", ")}.` : "Redirect blocked: unsafe protocol" + ); + } + if (!redirect2.headers.get("Location")) { + redirect2.headers.set("Location", redirect2.options.href); + } + return redirect2; + }; + this.clearCache = (opts) => { + const filter = opts?.filter; + if (filter !== void 0) { + this.__store.setState((s) => { + return { + ...s, + cachedMatches: s.cachedMatches.filter( + (m) => !filter(m) + ) + }; + }); + } else { + this.__store.setState((s) => { + return { + ...s, + cachedMatches: [] + }; + }); + } + }; + this.clearExpiredCache = () => { + const filter = (d) => { + const route = this.looseRoutesById[d.routeId]; + if (!route.options.loader) { + return true; + } + const gcTime = (d.preload ? route.options.preloadGcTime ?? this.options.defaultPreloadGcTime : route.options.gcTime ?? this.options.defaultGcTime) ?? 5 * 60 * 1e3; + const isError = d.status === "error"; + if (isError) return true; + const gcEligible = Date.now() - d.updatedAt >= gcTime; + return gcEligible; + }; + this.clearCache({ filter }); + }; + this.loadRouteChunk = loadRouteChunk; + this.preloadRoute = async (opts) => { + const next = opts._builtLocation ?? this.buildLocation(opts); + let matches = this.matchRoutes(next, { + throwOnError: true, + preload: true, + dest: opts + }); + const activeMatchIds = new Set( + [...this.state.matches, ...this.state.pendingMatches ?? []].map( + (d) => d.id + ) + ); + const loadedMatchIds = /* @__PURE__ */ new Set([ + ...activeMatchIds, + ...this.state.cachedMatches.map((d) => d.id) + ]); + batch2(() => { + matches.forEach((match) => { + if (!loadedMatchIds.has(match.id)) { + this.__store.setState((s) => ({ + ...s, + cachedMatches: [...s.cachedMatches, match] + })); + } + }); + }); + try { + matches = await loadMatches({ + router: this, + matches, + location: next, + preload: true, + updateMatch: (id, updater) => { + if (activeMatchIds.has(id)) { + matches = matches.map((d) => d.id === id ? updater(d) : d); + } else { + this.updateMatch(id, updater); + } + } + }); + return matches; + } catch (err) { + if (isRedirect(err)) { + if (err.options.reloadDocument) { + return void 0; + } + return await this.preloadRoute({ + ...err.options, + _fromLocation: next + }); + } + if (!isNotFound(err)) { + console.error(err); + } + return void 0; + } + }; + this.matchRoute = (location, opts) => { + const matchLocation = { + ...location, + to: location.to ? this.resolvePathWithBase(location.from || "", location.to) : void 0, + params: location.params || {}, + leaveParams: true + }; + const next = this.buildLocation(matchLocation); + if (opts?.pending && this.state.status !== "pending") { + return false; + } + const pending = opts?.pending === void 0 ? !this.state.isLoading : opts.pending; + const baseLocation = pending ? this.latestLocation : this.state.resolvedLocation || this.state.location; + const match = findSingleMatch( + next.pathname, + opts?.caseSensitive ?? false, + opts?.fuzzy ?? false, + baseLocation.pathname, + this.processedTree + ); + if (!match) { + return false; + } + if (location.params) { + if (!deepEqual(match.rawParams, location.params, { partial: true })) { + return false; + } + } + if (opts?.includeSearch ?? true) { + return deepEqual(baseLocation.search, next.search, { partial: true }) ? match.rawParams : false; + } + return match.rawParams; + }; + this.hasNotFoundMatch = () => { + return this.__store.state.matches.some( + (d) => d.status === "notFound" || d.globalNotFound + ); + }; + this.update({ + defaultPreloadDelay: 50, + defaultPendingMs: 1e3, + defaultPendingMinMs: 500, + context: void 0, + ...options, + caseSensitive: options.caseSensitive ?? false, + notFoundMode: options.notFoundMode ?? "fuzzy", + stringifySearch: options.stringifySearch ?? defaultStringifySearch, + parseSearch: options.parseSearch ?? defaultParseSearch, + protocolAllowlist: options.protocolAllowlist ?? DEFAULT_PROTOCOL_ALLOWLIST + }); + if (typeof document !== "undefined") { + self.__TSR_ROUTER__ = this; + } + } + isShell() { + return !!this.options.isShell; + } + isPrerendering() { + return !!this.options.isPrerendering; + } + get state() { + return this.__store.state; + } + setRoutes({ + routesById, + routesByPath, + processedTree + }) { + this.routesById = routesById; + this.routesByPath = routesByPath; + this.processedTree = processedTree; + const notFoundRoute = this.options.notFoundRoute; + if (notFoundRoute) { + notFoundRoute.init({ + originalIndex: 99999999999 + }); + this.routesById[notFoundRoute.id] = notFoundRoute; + } + } + get looseRoutesById() { + return this.routesById; + } + getParentContext(parentMatch) { + const parentMatchId = parentMatch?.id; + const parentContext = !parentMatchId ? this.options.context ?? void 0 : parentMatch.context ?? this.options.context ?? void 0; + return parentContext; + } + matchRoutesInternal(next, opts) { + const matchedRoutesResult = this.getMatchedRoutes(next.pathname); + const { foundRoute, routeParams, parsedParams } = matchedRoutesResult; + let { matchedRoutes } = matchedRoutesResult; + let isGlobalNotFound = false; + if ( + // If we found a route, and it's not an index route and we have left over path + foundRoute ? foundRoute.path !== "/" && routeParams["**"] : ( + // Or if we didn't find a route and we have left over path + trimPathRight2(next.pathname) + ) + ) { + if (this.options.notFoundRoute) { + matchedRoutes = [...matchedRoutes, this.options.notFoundRoute]; + } else { + isGlobalNotFound = true; + } + } + const globalNotFoundRouteId = isGlobalNotFound ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes) : void 0; + const matches = new Array(matchedRoutes.length); + const previousMatchesByRouteId = new Map( + this.state.matches.map((match) => [match.routeId, match]) + ); + for (let index = 0; index < matchedRoutes.length; index++) { + const route = matchedRoutes[index]; + const parentMatch = matches[index - 1]; + let preMatchSearch; + let strictMatchSearch; + let searchError; + { + const parentSearch = parentMatch?.search ?? next.search; + const parentStrictSearch = parentMatch?._strictSearch ?? void 0; + try { + const strictSearch = validateSearch(route.options.validateSearch, { ...parentSearch }) ?? void 0; + preMatchSearch = { + ...parentSearch, + ...strictSearch + }; + strictMatchSearch = { ...parentStrictSearch, ...strictSearch }; + searchError = void 0; + } catch (err) { + let searchParamError = err; + if (!(err instanceof SearchParamError)) { + searchParamError = new SearchParamError(err.message, { + cause: err + }); + } + if (opts?.throwOnError) { + throw searchParamError; + } + preMatchSearch = parentSearch; + strictMatchSearch = {}; + searchError = searchParamError; + } + } + const loaderDeps = route.options.loaderDeps?.({ + search: preMatchSearch + }) ?? ""; + const loaderDepsHash = loaderDeps ? JSON.stringify(loaderDeps) : ""; + const { interpolatedPath, usedParams } = interpolatePath({ + path: route.fullPath, + params: routeParams, + decoder: this.pathParamsDecoder, + server: this.isServer + }); + const matchId = ( + // route.id for disambiguation + route.id + // interpolatedPath for param changes + interpolatedPath + // explicit deps + loaderDepsHash + ); + const existingMatch = this.getMatch(matchId); + const previousMatch = previousMatchesByRouteId.get(route.id); + const strictParams = existingMatch?._strictParams ?? usedParams; + let paramsError = void 0; + if (!existingMatch) { + try { + extractStrictParams(route, usedParams, parsedParams, strictParams); + } catch (err) { + if (isNotFound(err) || isRedirect(err)) { + paramsError = err; + } else { + paramsError = new PathParamError(err.message, { + cause: err + }); + } + if (opts?.throwOnError) { + throw paramsError; + } + } + } + Object.assign(routeParams, strictParams); + const cause = previousMatch ? "stay" : "enter"; + let match; + if (existingMatch) { + match = { + ...existingMatch, + cause, + params: previousMatch?.params ?? routeParams, + _strictParams: strictParams, + search: previousMatch ? replaceEqualDeep(previousMatch.search, preMatchSearch) : replaceEqualDeep(existingMatch.search, preMatchSearch), + _strictSearch: strictMatchSearch + }; + } else { + const status = route.options.loader || route.options.beforeLoad || route.lazyFn || routeNeedsPreload(route) ? "pending" : "success"; + match = { + id: matchId, + ssr: isServer ?? this.isServer ? void 0 : route.options.ssr, + index, + routeId: route.id, + params: previousMatch?.params ?? routeParams, + _strictParams: strictParams, + pathname: interpolatedPath, + updatedAt: Date.now(), + search: previousMatch ? replaceEqualDeep(previousMatch.search, preMatchSearch) : preMatchSearch, + _strictSearch: strictMatchSearch, + searchError: void 0, + status, + isFetching: false, + error: void 0, + paramsError, + __routeContext: void 0, + _nonReactive: { + loadPromise: createControlledPromise() + }, + __beforeLoadContext: void 0, + context: {}, + abortController: new AbortController(), + fetchCount: 0, + cause, + loaderDeps: previousMatch ? replaceEqualDeep(previousMatch.loaderDeps, loaderDeps) : loaderDeps, + invalid: false, + preload: false, + links: void 0, + scripts: void 0, + headScripts: void 0, + meta: void 0, + staticData: route.options.staticData || {}, + fullPath: route.fullPath + }; + } + if (!opts?.preload) { + match.globalNotFound = globalNotFoundRouteId === route.id; + } + match.searchError = searchError; + const parentContext = this.getParentContext(parentMatch); + match.context = { + ...parentContext, + ...match.__routeContext, + ...match.__beforeLoadContext + }; + matches[index] = match; + } + for (let index = 0; index < matches.length; index++) { + const match = matches[index]; + const route = this.looseRoutesById[match.routeId]; + const existingMatch = this.getMatch(match.id); + const previousMatch = previousMatchesByRouteId.get(match.routeId); + match.params = previousMatch ? replaceEqualDeep(previousMatch.params, routeParams) : routeParams; + if (!existingMatch) { + const parentMatch = matches[index - 1]; + const parentContext = this.getParentContext(parentMatch); + if (route.options.context) { + const contextFnContext = { + deps: match.loaderDeps, + params: match.params, + context: parentContext ?? {}, + location: next, + navigate: (opts2) => this.navigate({ ...opts2, _fromLocation: next }), + buildLocation: this.buildLocation, + cause: match.cause, + abortController: match.abortController, + preload: !!match.preload, + matches, + routeId: route.id + }; + match.__routeContext = route.options.context(contextFnContext) ?? void 0; + } + match.context = { + ...parentContext, + ...match.__routeContext, + ...match.__beforeLoadContext + }; + } + } + return matches; + } + /** + * Lightweight route matching for buildLocation. + * Only computes fullPath, accumulated search, and params - skipping expensive + * operations like AbortController, ControlledPromise, loaderDeps, and full match objects. + */ + matchRoutesLightweight(location) { + const { matchedRoutes, routeParams, parsedParams } = this.getMatchedRoutes( + location.pathname + ); + const lastRoute = last(matchedRoutes); + const accumulatedSearch = { ...location.search }; + for (const route of matchedRoutes) { + try { + Object.assign( + accumulatedSearch, + validateSearch(route.options.validateSearch, accumulatedSearch) + ); + } catch { + } + } + const lastStateMatch = last(this.state.matches); + const canReuseParams = lastStateMatch && lastStateMatch.routeId === lastRoute.id && location.pathname === this.state.location.pathname; + let params; + if (canReuseParams) { + params = lastStateMatch.params; + } else { + const strictParams = { ...routeParams }; + for (const route of matchedRoutes) { + try { + extractStrictParams( + route, + routeParams, + parsedParams ?? {}, + strictParams + ); + } catch { + } + } + params = strictParams; + } + return { + matchedRoutes, + fullPath: lastRoute.fullPath, + search: accumulatedSearch, + params + }; + } +}; +var SearchParamError = class extends Error { +}; +var PathParamError = class extends Error { +}; +var normalize = (str) => str.endsWith("/") && str.length > 1 ? str.slice(0, -1) : str; +function comparePaths(a, b) { + return normalize(a) === normalize(b); +} +function lazyFn(fn, key) { + return async (...args) => { + const imported = await fn(); + return imported[key || "default"](...args); + }; +} +function getInitialRouterState(location) { + return { + loadedAt: 0, + isLoading: false, + isTransitioning: false, + status: "idle", + resolvedLocation: void 0, + location, + matches: [], + pendingMatches: [], + cachedMatches: [], + statusCode: 200 + }; +} +function validateSearch(validateSearch2, input) { + if (validateSearch2 == null) return {}; + if ("~standard" in validateSearch2) { + const result = validateSearch2["~standard"].validate(input); + if (result instanceof Promise) + throw new SearchParamError("Async validation not supported"); + if (result.issues) + throw new SearchParamError(JSON.stringify(result.issues, void 0, 2), { + cause: result + }); + return result.value; + } + if ("parse" in validateSearch2) { + return validateSearch2.parse(input); + } + if (typeof validateSearch2 === "function") { + return validateSearch2(input); + } + return {}; +} +function getMatchedRoutes({ + pathname, + routesById, + processedTree +}) { + const routeParams = {}; + const trimmedPath = trimPathRight2(pathname); + let foundRoute = void 0; + let parsedParams = void 0; + const match = findRouteMatch(trimmedPath, processedTree, true); + if (match) { + foundRoute = match.route; + Object.assign(routeParams, match.rawParams); + parsedParams = Object.assign({}, match.parsedParams); + } + const matchedRoutes = match?.branch || [routesById[rootRouteId]]; + return { matchedRoutes, routeParams, foundRoute, parsedParams }; +} +function applySearchMiddleware({ + search, + dest, + destRoutes, + _includeValidateSearch +}) { + const middleware = buildMiddlewareChain(destRoutes); + return middleware(search, dest, _includeValidateSearch ?? false); +} +function buildMiddlewareChain(destRoutes) { + const context = { + dest: null, + _includeValidateSearch: false, + middlewares: [] + }; + for (const route of destRoutes) { + if ("search" in route.options) { + if (route.options.search?.middlewares) { + context.middlewares.push(...route.options.search.middlewares); + } + } else if (route.options.preSearchFilters || route.options.postSearchFilters) { + const legacyMiddleware = ({ search, next }) => { + let nextSearch = search; + if ("preSearchFilters" in route.options && route.options.preSearchFilters) { + nextSearch = route.options.preSearchFilters.reduce( + (prev, next2) => next2(prev), + search + ); + } + const result = next(nextSearch); + if ("postSearchFilters" in route.options && route.options.postSearchFilters) { + return route.options.postSearchFilters.reduce( + (prev, next2) => next2(prev), + result + ); + } + return result; + }; + context.middlewares.push(legacyMiddleware); + } + if (route.options.validateSearch) { + const validate = ({ search, next }) => { + const result = next(search); + if (!context._includeValidateSearch) return result; + try { + const validatedSearch = { + ...result, + ...validateSearch(route.options.validateSearch, result) ?? void 0 + }; + return validatedSearch; + } catch { + return result; + } + }; + context.middlewares.push(validate); + } + } + const final = ({ search }) => { + const dest = context.dest; + if (!dest.search) { + return {}; + } + if (dest.search === true) { + return search; + } + return functionalUpdate(dest.search, search); + }; + context.middlewares.push(final); + const applyNext = (index, currentSearch, middlewares) => { + if (index >= middlewares.length) { + return currentSearch; + } + const middleware = middlewares[index]; + const next = (newSearch) => { + return applyNext(index + 1, newSearch, middlewares); + }; + return middleware({ search: currentSearch, next }); + }; + return function middleware(search, dest, _includeValidateSearch) { + context.dest = dest; + context._includeValidateSearch = _includeValidateSearch; + return applyNext(0, search, context.middlewares); + }; +} +function findGlobalNotFoundRouteId(notFoundMode, routes) { + if (notFoundMode !== "root") { + for (let i = routes.length - 1; i >= 0; i--) { + const route = routes[i]; + if (route.children) { + return route.id; + } + } + } + return rootRouteId; +} +function extractStrictParams(route, referenceParams, parsedParams, accumulatedParams) { + const parseParams = route.options.params?.parse ?? route.options.parseParams; + if (parseParams) { + if (route.options.skipRouteOnParseError) { + for (const key in referenceParams) { + if (key in parsedParams) { + accumulatedParams[key] = parsedParams[key]; + } + } + } else { + const result = parseParams(accumulatedParams); + Object.assign(accumulatedParams, result); + } + } +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/defer.js +var TSR_DEFERRED_PROMISE = /* @__PURE__ */ Symbol.for("TSR_DEFERRED_PROMISE"); +function defer(_promise, options) { + const promise = _promise; + if (promise[TSR_DEFERRED_PROMISE]) { + return promise; + } + promise[TSR_DEFERRED_PROMISE] = { status: "pending" }; + promise.then((data) => { + promise[TSR_DEFERRED_PROMISE].status = "success"; + promise[TSR_DEFERRED_PROMISE].data = data; + }).catch((error) => { + promise[TSR_DEFERRED_PROMISE].status = "error"; + promise[TSR_DEFERRED_PROMISE].error = { + data: (options?.serializeError ?? defaultSerializeError)(error), + __isServerError: true + }; + }); + return promise; +} + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/link.js +var preloadWarning = "Error preloading route! ☝️"; + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/Matches.js +var isMatch = (match, path) => { + const parts = path.split("."); + let part; + let i = 0; + let value = match; + while ((part = parts[i++]) != null && value != null) { + value = value[part]; + } + return value != null; +}; + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/route.js +var BaseRoute = class { + constructor(options) { + this.init = (opts) => { + this.originalIndex = opts.originalIndex; + const options2 = this.options; + const isRoot = !options2?.path && !options2?.id; + this.parentRoute = this.options.getParentRoute?.(); + if (isRoot) { + this._path = rootRouteId; + } else if (!this.parentRoute) { + invariant( + false, + `Child Route instances must pass a 'getParentRoute: () => ParentRoute' option that returns a Route instance.` + ); + } + let path = isRoot ? rootRouteId : options2?.path; + if (path && path !== "/") { + path = trimPathLeft(path); + } + const customId = options2?.id || path; + let id = isRoot ? rootRouteId : joinPaths([ + this.parentRoute.id === rootRouteId ? "" : this.parentRoute.id, + customId + ]); + if (path === rootRouteId) { + path = "/"; + } + if (id !== rootRouteId) { + id = joinPaths(["/", id]); + } + const fullPath = id === rootRouteId ? "/" : joinPaths([this.parentRoute.fullPath, path]); + this._path = path; + this._id = id; + this._fullPath = fullPath; + this._to = trimPathRight2(fullPath); + }; + this.addChildren = (children) => { + return this._addFileChildren(children); + }; + this._addFileChildren = (children) => { + if (Array.isArray(children)) { + this.children = children; + } + if (typeof children === "object" && children !== null) { + this.children = Object.values(children); + } + return this; + }; + this._addFileTypes = () => { + return this; + }; + this.updateLoader = (options2) => { + Object.assign(this.options, options2); + return this; + }; + this.update = (options2) => { + Object.assign(this.options, options2); + return this; + }; + this.lazy = (lazyFn2) => { + this.lazyFn = lazyFn2; + return this; + }; + this.redirect = (opts) => redirect({ from: this.fullPath, ...opts }); + this.options = options || {}; + this.isRoot = !options?.getParentRoute; + if (options?.id && options?.path) { + throw new Error(`Route cannot have both an 'id' and a 'path' option.`); + } + } + get to() { + return this._to; + } + get id() { + return this._id; + } + get path() { + return this._path; + } + get fullPath() { + return this._fullPath; + } +}; +var BaseRouteApi = class { + constructor({ id }) { + this.notFound = (opts) => { + return notFound({ routeId: this.id, ...opts }); + }; + this.redirect = (opts) => redirect({ from: this.id, ...opts }); + this.id = id; + } +}; +var BaseRootRoute = class extends BaseRoute { + constructor(options) { + super(options); + } +}; + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/config.js +var createRouterConfig = (options) => { + return { + serializationAdapters: options.serializationAdapters, + defaultSsr: options.defaultSsr + }; +}; + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/searchMiddleware.js +function retainSearchParams(keys) { + return ({ search, next }) => { + const result = next(search); + if (keys === true) { + return { ...search, ...result }; + } + const copy = { ...result }; + keys.forEach((key) => { + if (!(key in copy)) { + copy[key] = search[key]; + } + }); + return copy; + }; +} +function stripSearchParams(input) { + return ({ search, next }) => { + if (input === true) { + return {}; + } + const result = { ...next(search) }; + if (Array.isArray(input)) { + input.forEach((key) => { + delete result[key]; + }); + } else { + Object.entries(input).forEach( + ([key, value]) => { + if (deepEqual(result[key], value)) { + delete result[key]; + } + } + ); + } + return result; + }; +} + +// ../../../node_modules/.pnpm/seroval@1.5.1/node_modules/seroval/dist/esm/development/index.mjs +var Feature = ((Feature2) => { + Feature2[Feature2["AggregateError"] = 1] = "AggregateError"; + Feature2[Feature2["ArrowFunction"] = 2] = "ArrowFunction"; + Feature2[Feature2["ErrorPrototypeStack"] = 4] = "ErrorPrototypeStack"; + Feature2[Feature2["ObjectAssign"] = 8] = "ObjectAssign"; + Feature2[Feature2["BigIntTypedArray"] = 16] = "BigIntTypedArray"; + Feature2[Feature2["RegExp"] = 32] = "RegExp"; + return Feature2; +})(Feature || {}); +var ALL_ENABLED = 1 | 2 | 4 | 8 | 16 | 32; +var SYM_ASYNC_ITERATOR = Symbol.asyncIterator; +var SYM_HAS_INSTANCE = Symbol.hasInstance; +var SYM_IS_CONCAT_SPREADABLE = Symbol.isConcatSpreadable; +var SYM_ITERATOR = Symbol.iterator; +var SYM_MATCH = Symbol.match; +var SYM_MATCH_ALL = Symbol.matchAll; +var SYM_REPLACE = Symbol.replace; +var SYM_SEARCH = Symbol.search; +var SYM_SPECIES = Symbol.species; +var SYM_SPLIT = Symbol.split; +var SYM_TO_PRIMITIVE = Symbol.toPrimitive; +var SYM_TO_STRING_TAG = Symbol.toStringTag; +var SYM_UNSCOPABLES = Symbol.unscopables; +var INV_SYMBOL_REF = { + [SYM_ASYNC_ITERATOR]: 0, + [SYM_HAS_INSTANCE]: 1, + [SYM_IS_CONCAT_SPREADABLE]: 2, + [SYM_ITERATOR]: 3, + [SYM_MATCH]: 4, + [SYM_MATCH_ALL]: 5, + [SYM_REPLACE]: 6, + [SYM_SEARCH]: 7, + [SYM_SPECIES]: 8, + [SYM_SPLIT]: 9, + [SYM_TO_PRIMITIVE]: 10, + [SYM_TO_STRING_TAG]: 11, + [SYM_UNSCOPABLES]: 12 + /* Unscopables */ +}; +var NIL = void 0; +var CONSTANT_VAL = { + [ + 2 + /* True */ + ]: true, + [ + 3 + /* False */ + ]: false, + [ + 1 + /* Undefined */ + ]: NIL, + [ + 0 + /* Null */ + ]: null, + [ + 4 + /* NegZero */ + ]: -0, + [ + 5 + /* Inf */ + ]: Number.POSITIVE_INFINITY, + [ + 6 + /* NegInf */ + ]: Number.NEGATIVE_INFINITY, + [ + 7 + /* Nan */ + ]: Number.NaN +}; +function createSerovalNode(t, i, s, c, m, p, e, a, f, b, o, l) { + return { + t, + i, + s, + c, + m, + p, + e, + a, + f, + b, + o, + l + }; +} +function createConstantNode(value) { + return createSerovalNode( + 2, + NIL, + value, + NIL, + NIL, + NIL, + NIL, + NIL, + NIL, + NIL, + NIL, + NIL + ); +} +var TRUE_NODE = createConstantNode( + 2 + /* True */ +); +var FALSE_NODE = createConstantNode( + 3 + /* False */ +); +var UNDEFINED_NODE = createConstantNode( + 1 + /* Undefined */ +); +var NULL_NODE = createConstantNode( + 0 + /* Null */ +); +var NEG_ZERO_NODE = createConstantNode( + 4 + /* NegZero */ +); +var INFINITY_NODE = createConstantNode( + 5 + /* Inf */ +); +var NEG_INFINITY_NODE = createConstantNode( + 6 + /* NegInf */ +); +var NAN_NODE = createConstantNode( + 7 + /* Nan */ +); +var REFERENCES_KEY = "__SEROVAL_REFS__"; +var GLOBAL_CONTEXT_REFERENCES = "$R"; +var GLOBAL_CONTEXT_R = `self.${GLOBAL_CONTEXT_REFERENCES}`; +var INV_REFERENCE = /* @__PURE__ */ new Map(); +if (typeof globalThis !== "undefined") { + Object.defineProperty(globalThis, REFERENCES_KEY, { + value: INV_REFERENCE, + configurable: true, + writable: false, + enumerable: false + }); +} else if (typeof window !== "undefined") { + Object.defineProperty(window, REFERENCES_KEY, { + value: INV_REFERENCE, + configurable: true, + writable: false, + enumerable: false + }); +} else if (typeof self !== "undefined") { + Object.defineProperty(self, REFERENCES_KEY, { + value: INV_REFERENCE, + configurable: true, + writable: false, + enumerable: false + }); +} else if (typeof global !== "undefined") { + Object.defineProperty(global, REFERENCES_KEY, { + value: INV_REFERENCE, + configurable: true, + writable: false, + enumerable: false + }); +} +var { toString: objectToString } = Object.prototype; +var PROMISE_CONSTRUCTOR = () => { + const resolver = { + p: 0, + s: 0, + f: 0 + }; + resolver.p = new Promise((resolve, reject) => { + resolver.s = resolve; + resolver.f = reject; + }); + return resolver; +}; +var PROMISE_SUCCESS = (resolver, data) => { + resolver.s(data); + resolver.p.s = 1; + resolver.p.v = data; +}; +var PROMISE_FAILURE = (resolver, data) => { + resolver.f(data); + resolver.p.s = 2; + resolver.p.v = data; +}; +var SERIALIZED_PROMISE_CONSTRUCTOR = PROMISE_CONSTRUCTOR.toString(); +var SERIALIZED_PROMISE_SUCCESS = PROMISE_SUCCESS.toString(); +var SERIALIZED_PROMISE_FAILURE = PROMISE_FAILURE.toString(); +var STREAM_CONSTRUCTOR = () => { + const buffer = []; + const listeners = []; + let alive = true; + let success = false; + let count = 0; + const flush3 = (value, mode, x) => { + for (x = 0; x < count; x++) { + if (listeners[x]) { + listeners[x][mode](value); + } + } + }; + const up = (listener, x, z, current) => { + for (x = 0, z = buffer.length; x < z; x++) { + current = buffer[x]; + if (!alive && x === z - 1) { + listener[success ? "return" : "throw"](current); + } else { + listener.next(current); + } + } + }; + const on = (listener, temp) => { + if (alive) { + temp = count++; + listeners[temp] = listener; + } + up(listener); + return () => { + if (alive) { + listeners[temp] = listeners[count]; + listeners[count--] = void 0; + } + }; + }; + return { + __SEROVAL_STREAM__: true, + on: (listener) => on(listener), + next: (value) => { + if (alive) { + buffer.push(value); + flush3(value, "next"); + } + }, + throw: (value) => { + if (alive) { + buffer.push(value); + flush3(value, "throw"); + alive = false; + success = false; + listeners.length = 0; + } + }, + return: (value) => { + if (alive) { + buffer.push(value); + flush3(value, "return"); + alive = false; + success = true; + listeners.length = 0; + } + } + }; +}; +var SERIALIZED_STREAM_CONSTRUCTOR = STREAM_CONSTRUCTOR.toString(); +var ITERATOR_CONSTRUCTOR = (symbol) => (sequence) => () => { + let index = 0; + const instance = { + [symbol]: () => instance, + next: () => { + if (index > sequence.d) { + return { + done: true, + value: void 0 + }; + } + const currentIndex = index++; + const data = sequence.v[currentIndex]; + if (currentIndex === sequence.t) { + throw data; + } + return { + done: currentIndex === sequence.d, + value: data + }; + } + }; + return instance; +}; +var SERIALIZED_ITERATOR_CONSTRUCTOR = ITERATOR_CONSTRUCTOR.toString(); +var ASYNC_ITERATOR_CONSTRUCTOR = (symbol, createPromise) => (stream) => () => { + let count = 0; + let doneAt = -1; + let isThrow = false; + const buffer = []; + const pending = []; + const finalize = (i = 0, len = pending.length) => { + for (; i < len; i++) { + pending[i].s({ + done: true, + value: void 0 + }); + } + }; + stream.on({ + next: (value) => { + const temp = pending.shift(); + if (temp) { + temp.s({ done: false, value }); + } + buffer.push(value); + }, + throw: (value) => { + const temp = pending.shift(); + if (temp) { + temp.f(value); + } + finalize(); + doneAt = buffer.length; + isThrow = true; + buffer.push(value); + }, + return: (value) => { + const temp = pending.shift(); + if (temp) { + temp.s({ done: true, value }); + } + finalize(); + doneAt = buffer.length; + buffer.push(value); + } + }); + const instance = { + [symbol]: () => instance, + next: () => { + if (doneAt === -1) { + const index2 = count++; + if (index2 >= buffer.length) { + const temp = createPromise(); + pending.push(temp); + return temp.p; + } + return { + done: false, + value: buffer[index2] + }; + } + if (count > doneAt) { + return { + done: true, + value: void 0 + }; + } + const index = count++; + const value = buffer[index]; + if (index !== doneAt) { + return { + done: false, + value + }; + } + if (isThrow) { + throw value; + } + return { + done: true, + value + }; + } + }; + return instance; +}; +var SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR = ASYNC_ITERATOR_CONSTRUCTOR.toString(); +var ARRAY_BUFFER_CONSTRUCTOR = (b64) => { + const decoded = atob(b64); + const length = decoded.length; + const arr = new Uint8Array(length); + for (let i = 0; i < length; i++) { + arr[i] = decoded.charCodeAt(i); + } + return arr.buffer; +}; +var SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR = ARRAY_BUFFER_CONSTRUCTOR.toString(); +var createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR); +function createStream() { + return STREAM_CONSTRUCTOR(); +} +var createAsyncIterable = ASYNC_ITERATOR_CONSTRUCTOR( + SYM_ASYNC_ITERATOR, + PROMISE_CONSTRUCTOR +); +var SerovalMode = ((SerovalMode2) => { + SerovalMode2[SerovalMode2["Vanilla"] = 1] = "Vanilla"; + SerovalMode2[SerovalMode2["Cross"] = 2] = "Cross"; + return SerovalMode2; +})(SerovalMode || {}); +function createPlugin(plugin) { + return plugin; +} +var RETURN = () => T; +var SERIALIZED_RETURN = RETURN.toString(); +var IS_MODERN = /=>/.test(SERIALIZED_RETURN); +var REF_START_CHARS = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_"; +var REF_START_CHARS_LEN = REF_START_CHARS.length; +var REF_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_"; +var REF_CHARS_LEN = REF_CHARS.length; + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/transformer.js +function createSerializationAdapter(opts) { + return opts; +} + +// ../../../node_modules/.pnpm/seroval-plugins@1.5.1_seroval@1.5.1/node_modules/seroval-plugins/dist/esm/development/web.mjs +var PROMISE_TO_ABORT_SIGNAL = (promise) => { + const controller = new AbortController(); + const abort = controller.abort.bind(controller); + promise.then(abort, abort); + return controller; +}; +function resolveAbortSignalResult(resolve) { + resolve(this.reason); +} +function resolveAbortSignal(resolve) { + this.addEventListener("abort", resolveAbortSignalResult.bind(this, resolve), { + once: true + }); +} +function abortSignalToPromise(signal) { + return new Promise(resolveAbortSignal.bind(signal)); +} +var ABORT_CONTROLLER = {}; +var AbortControllerFactoryPlugin = createPlugin({ + tag: "seroval-plugins/web/AbortControllerFactoryPlugin", + test(value) { + return value === ABORT_CONTROLLER; + }, + parse: { + sync() { + return ABORT_CONTROLLER; + }, + async async() { + return await Promise.resolve(ABORT_CONTROLLER); + }, + stream() { + return ABORT_CONTROLLER; + } + }, + serialize() { + return PROMISE_TO_ABORT_SIGNAL.toString(); + }, + deserialize() { + return PROMISE_TO_ABORT_SIGNAL; + } +}); +var AbortSignalPlugin = createPlugin({ + tag: "seroval-plugins/web/AbortSignal", + extends: [AbortControllerFactoryPlugin], + test(value) { + if (typeof AbortSignal === "undefined") { + return false; + } + return value instanceof AbortSignal; + }, + parse: { + sync(value, ctx) { + if (value.aborted) { + return { + reason: ctx.parse(value.reason) + }; + } + return {}; + }, + async async(value, ctx) { + if (value.aborted) { + return { + reason: await ctx.parse(value.reason) + }; + } + const result = await abortSignalToPromise(value); + return { + reason: await ctx.parse(result) + }; + }, + stream(value, ctx) { + if (value.aborted) { + return { + reason: ctx.parse(value.reason) + }; + } + const promise = abortSignalToPromise(value); + return { + factory: ctx.parse(ABORT_CONTROLLER), + controller: ctx.parse(promise) + }; + } + }, + serialize(node, ctx) { + if (node.reason) { + return "AbortSignal.abort(" + ctx.serialize(node.reason) + ")"; + } + if (node.controller && node.factory) { + return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.controller) + ").signal"; + } + return "(new AbortController).signal"; + }, + deserialize(node, ctx) { + if (node.reason) { + return AbortSignal.abort(ctx.deserialize(node.reason)); + } + if (node.controller) { + return PROMISE_TO_ABORT_SIGNAL(ctx.deserialize(node.controller)).signal; + } + const controller = new AbortController(); + return controller.signal; + } +}); +var BlobPlugin = createPlugin({ + tag: "seroval-plugins/web/Blob", + test(value) { + if (typeof Blob === "undefined") { + return false; + } + return value instanceof Blob; + }, + parse: { + async async(value, ctx) { + return { + type: await ctx.parse(value.type), + buffer: await ctx.parse(await value.arrayBuffer()) + }; + } + }, + serialize(node, ctx) { + return "new Blob([" + ctx.serialize(node.buffer) + "],{type:" + ctx.serialize(node.type) + "})"; + }, + deserialize(node, ctx) { + return new Blob([ctx.deserialize(node.buffer)], { + type: ctx.deserialize(node.type) + }); + } +}); +function createCustomEventOptions(current) { + return { + detail: current.detail, + bubbles: current.bubbles, + cancelable: current.cancelable, + composed: current.composed + }; +} +var CustomEventPlugin = createPlugin({ + tag: "seroval-plugins/web/CustomEvent", + test(value) { + if (typeof CustomEvent === "undefined") { + return false; + } + return value instanceof CustomEvent; + }, + parse: { + sync(value, ctx) { + return { + type: ctx.parse(value.type), + options: ctx.parse(createCustomEventOptions(value)) + }; + }, + async async(value, ctx) { + return { + type: await ctx.parse(value.type), + options: await ctx.parse(createCustomEventOptions(value)) + }; + }, + stream(value, ctx) { + return { + type: ctx.parse(value.type), + options: ctx.parse(createCustomEventOptions(value)) + }; + } + }, + serialize(node, ctx) { + return "new CustomEvent(" + ctx.serialize(node.type) + "," + ctx.serialize(node.options) + ")"; + }, + deserialize(node, ctx) { + return new CustomEvent( + ctx.deserialize(node.type), + ctx.deserialize(node.options) + ); + } +}); +var DOMExceptionPlugin = createPlugin({ + tag: "seroval-plugins/web/DOMException", + test(value) { + if (typeof DOMException === "undefined") { + return false; + } + return value instanceof DOMException; + }, + parse: { + sync(value, ctx) { + return { + name: ctx.parse(value.name), + message: ctx.parse(value.message) + }; + }, + async async(value, ctx) { + return { + name: await ctx.parse(value.name), + message: await ctx.parse(value.message) + }; + }, + stream(value, ctx) { + return { + name: ctx.parse(value.name), + message: ctx.parse(value.message) + }; + } + }, + serialize(node, ctx) { + return "new DOMException(" + ctx.serialize(node.message) + "," + ctx.serialize(node.name) + ")"; + }, + deserialize(node, ctx) { + return new DOMException( + ctx.deserialize(node.message), + ctx.deserialize(node.name) + ); + } +}); +function createEventOptions(current) { + return { + bubbles: current.bubbles, + cancelable: current.cancelable, + composed: current.composed + }; +} +var EventPlugin = createPlugin({ + tag: "seroval-plugins/web/Event", + test(value) { + if (typeof Event === "undefined") { + return false; + } + return value instanceof Event; + }, + parse: { + sync(value, ctx) { + return { + type: ctx.parse(value.type), + options: ctx.parse(createEventOptions(value)) + }; + }, + async async(value, ctx) { + return { + type: await ctx.parse(value.type), + options: await ctx.parse(createEventOptions(value)) + }; + }, + stream(value, ctx) { + return { + type: ctx.parse(value.type), + options: ctx.parse(createEventOptions(value)) + }; + } + }, + serialize(node, ctx) { + return "new Event(" + ctx.serialize(node.type) + "," + ctx.serialize(node.options) + ")"; + }, + deserialize(node, ctx) { + return new Event( + ctx.deserialize(node.type), + ctx.deserialize(node.options) + ); + } +}); +var FilePlugin = createPlugin({ + tag: "seroval-plugins/web/File", + test(value) { + if (typeof File === "undefined") { + return false; + } + return value instanceof File; + }, + parse: { + async async(value, ctx) { + return { + name: await ctx.parse(value.name), + options: await ctx.parse({ + type: value.type, + lastModified: value.lastModified + }), + buffer: await ctx.parse(await value.arrayBuffer()) + }; + } + }, + serialize(node, ctx) { + return "new File([" + ctx.serialize(node.buffer) + "]," + ctx.serialize(node.name) + "," + ctx.serialize(node.options) + ")"; + }, + deserialize(node, ctx) { + return new File( + [ctx.deserialize(node.buffer)], + ctx.deserialize(node.name), + ctx.deserialize(node.options) + ); + } +}); +var file_default = FilePlugin; +function convertFormData(instance) { + const items = []; + instance.forEach((value, key) => { + items.push([key, value]); + }); + return items; +} +var FORM_DATA_FACTORY = {}; +var FORM_DATA_FACTORY_CONSTRUCTOR = (e, f = new FormData(), i = 0, s = e.length, t) => { + for (; i < s; i++) { + t = e[i]; + f.append(t[0], t[1]); + } + return f; +}; +var FormDataFactoryPlugin = createPlugin({ + tag: "seroval-plugins/web/FormDataFactory", + test(value) { + return value === FORM_DATA_FACTORY; + }, + parse: { + sync() { + return FORM_DATA_FACTORY; + }, + async async() { + return await Promise.resolve(FORM_DATA_FACTORY); + }, + stream() { + return FORM_DATA_FACTORY; + } + }, + serialize() { + return FORM_DATA_FACTORY_CONSTRUCTOR.toString(); + }, + deserialize() { + return FORM_DATA_FACTORY; + } +}); +var FormDataPlugin = createPlugin({ + tag: "seroval-plugins/web/FormData", + extends: [file_default, FormDataFactoryPlugin], + test(value) { + if (typeof FormData === "undefined") { + return false; + } + return value instanceof FormData; + }, + parse: { + sync(value, ctx) { + return { + factory: ctx.parse(FORM_DATA_FACTORY), + entries: ctx.parse(convertFormData(value)) + }; + }, + async async(value, ctx) { + return { + factory: await ctx.parse(FORM_DATA_FACTORY), + entries: await ctx.parse(convertFormData(value)) + }; + }, + stream(value, ctx) { + return { + factory: ctx.parse(FORM_DATA_FACTORY), + entries: ctx.parse(convertFormData(value)) + }; + } + }, + serialize(node, ctx) { + return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.entries) + ")"; + }, + deserialize(node, ctx) { + return FORM_DATA_FACTORY_CONSTRUCTOR( + ctx.deserialize(node.entries) + ); + } +}); +function convertHeaders(instance) { + const items = []; + instance.forEach((value, key) => { + items.push([key, value]); + }); + return items; +} +var HeadersPlugin = createPlugin({ + tag: "seroval-plugins/web/Headers", + test(value) { + if (typeof Headers === "undefined") { + return false; + } + return value instanceof Headers; + }, + parse: { + sync(value, ctx) { + return { + value: ctx.parse(convertHeaders(value)) + }; + }, + async async(value, ctx) { + return { + value: await ctx.parse(convertHeaders(value)) + }; + }, + stream(value, ctx) { + return { + value: ctx.parse(convertHeaders(value)) + }; + } + }, + serialize(node, ctx) { + return "new Headers(" + ctx.serialize(node.value) + ")"; + }, + deserialize(node, ctx) { + return new Headers(ctx.deserialize(node.value)); + } +}); +var headers_default = HeadersPlugin; +var ImageDataPlugin = createPlugin({ + tag: "seroval-plugins/web/ImageData", + test(value) { + if (typeof ImageData === "undefined") { + return false; + } + return value instanceof ImageData; + }, + parse: { + sync(value, ctx) { + return { + data: ctx.parse(value.data), + width: ctx.parse(value.width), + height: ctx.parse(value.height), + options: ctx.parse({ + colorSpace: value.colorSpace + }) + }; + }, + async async(value, ctx) { + return { + data: await ctx.parse(value.data), + width: await ctx.parse(value.width), + height: await ctx.parse(value.height), + options: await ctx.parse({ + colorSpace: value.colorSpace + }) + }; + }, + stream(value, ctx) { + return { + data: ctx.parse(value.data), + width: ctx.parse(value.width), + height: ctx.parse(value.height), + options: ctx.parse({ + colorSpace: value.colorSpace + }) + }; + } + }, + serialize(node, ctx) { + return "new ImageData(" + ctx.serialize(node.data) + "," + ctx.serialize(node.width) + "," + ctx.serialize(node.height) + "," + ctx.serialize(node.options) + ")"; + }, + deserialize(node, ctx) { + return new ImageData( + ctx.deserialize(node.data), + ctx.deserialize(node.width), + ctx.deserialize(node.height), + ctx.deserialize(node.options) + ); + } +}); +var READABLE_STREAM_FACTORY = {}; +var READABLE_STREAM_FACTORY_CONSTRUCTOR = (stream) => new ReadableStream({ + start: (controller) => { + stream.on({ + next: (value) => { + try { + controller.enqueue(value); + } catch (_error) { + } + }, + throw: (value) => { + controller.error(value); + }, + return: () => { + try { + controller.close(); + } catch (_error) { + } + } + }); + } +}); +var ReadableStreamFactoryPlugin = createPlugin({ + tag: "seroval-plugins/web/ReadableStreamFactory", + test(value) { + return value === READABLE_STREAM_FACTORY; + }, + parse: { + sync() { + return READABLE_STREAM_FACTORY; + }, + async async() { + return await Promise.resolve(READABLE_STREAM_FACTORY); + }, + stream() { + return READABLE_STREAM_FACTORY; + } + }, + serialize() { + return READABLE_STREAM_FACTORY_CONSTRUCTOR.toString(); + }, + deserialize() { + return READABLE_STREAM_FACTORY; + } +}); +function toStream(value) { + const stream = createStream(); + const reader = value.getReader(); + async function push() { + try { + const result = await reader.read(); + if (result.done) { + stream.return(result.value); + } else { + stream.next(result.value); + await push(); + } + } catch (error) { + stream.throw(error); + } + } + push().catch(() => { + }); + return stream; +} +var ReadableStreamPlugin = createPlugin({ + tag: "seroval/plugins/web/ReadableStream", + extends: [ReadableStreamFactoryPlugin], + test(value) { + if (typeof ReadableStream === "undefined") { + return false; + } + return value instanceof ReadableStream; + }, + parse: { + sync(_value, ctx) { + return { + factory: ctx.parse(READABLE_STREAM_FACTORY), + stream: ctx.parse(createStream()) + }; + }, + async async(value, ctx) { + return { + factory: await ctx.parse(READABLE_STREAM_FACTORY), + stream: await ctx.parse(toStream(value)) + }; + }, + stream(value, ctx) { + return { + factory: ctx.parse(READABLE_STREAM_FACTORY), + stream: ctx.parse(toStream(value)) + }; + } + }, + serialize(node, ctx) { + return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.stream) + ")"; + }, + deserialize(node, ctx) { + const stream = ctx.deserialize(node.stream); + return READABLE_STREAM_FACTORY_CONSTRUCTOR(stream); + } +}); +var readable_stream_default = ReadableStreamPlugin; +function createRequestOptions(current, body) { + return { + body, + cache: current.cache, + credentials: current.credentials, + headers: current.headers, + integrity: current.integrity, + keepalive: current.keepalive, + method: current.method, + mode: current.mode, + redirect: current.redirect, + referrer: current.referrer, + referrerPolicy: current.referrerPolicy + }; +} +var RequestPlugin = createPlugin({ + tag: "seroval-plugins/web/Request", + extends: [readable_stream_default, headers_default], + test(value) { + if (typeof Request === "undefined") { + return false; + } + return value instanceof Request; + }, + parse: { + async async(value, ctx) { + return { + url: await ctx.parse(value.url), + options: await ctx.parse( + createRequestOptions( + value, + value.body && !value.bodyUsed ? await value.clone().arrayBuffer() : null + ) + ) + }; + }, + stream(value, ctx) { + return { + url: ctx.parse(value.url), + options: ctx.parse( + createRequestOptions( + value, + value.body && !value.bodyUsed ? value.clone().body : null + ) + ) + }; + } + }, + serialize(node, ctx) { + return "new Request(" + ctx.serialize(node.url) + "," + ctx.serialize(node.options) + ")"; + }, + deserialize(node, ctx) { + return new Request( + ctx.deserialize(node.url), + ctx.deserialize(node.options) + ); + } +}); +function createResponseOptions(current) { + return { + headers: current.headers, + status: current.status, + statusText: current.statusText + }; +} +var ResponsePlugin = createPlugin({ + tag: "seroval-plugins/web/Response", + extends: [readable_stream_default, headers_default], + test(value) { + if (typeof Response === "undefined") { + return false; + } + return value instanceof Response; + }, + parse: { + async async(value, ctx) { + return { + body: await ctx.parse( + value.body && !value.bodyUsed ? await value.clone().arrayBuffer() : null + ), + options: await ctx.parse(createResponseOptions(value)) + }; + }, + stream(value, ctx) { + return { + body: ctx.parse( + value.body && !value.bodyUsed ? value.clone().body : null + ), + options: ctx.parse(createResponseOptions(value)) + }; + } + }, + serialize(node, ctx) { + return "new Response(" + ctx.serialize(node.body) + "," + ctx.serialize(node.options) + ")"; + }, + deserialize(node, ctx) { + return new Response( + ctx.deserialize(node.body), + ctx.deserialize(node.options) + ); + } +}); +var URLPlugin = createPlugin({ + tag: "seroval-plugins/web/URL", + test(value) { + if (typeof URL === "undefined") { + return false; + } + return value instanceof URL; + }, + parse: { + sync(value, ctx) { + return { + value: ctx.parse(value.href) + }; + }, + async async(value, ctx) { + return { + value: await ctx.parse(value.href) + }; + }, + stream(value, ctx) { + return { + value: ctx.parse(value.href) + }; + } + }, + serialize(node, ctx) { + return "new URL(" + ctx.serialize(node.value) + ")"; + }, + deserialize(node, ctx) { + return new URL(ctx.deserialize(node.value)); + } +}); +var URLSearchParamsPlugin = createPlugin({ + tag: "seroval-plugins/web/URLSearchParams", + test(value) { + if (typeof URLSearchParams === "undefined") { + return false; + } + return value instanceof URLSearchParams; + }, + parse: { + sync(value, ctx) { + return { + value: ctx.parse(value.toString()) + }; + }, + async async(value, ctx) { + return { + value: await ctx.parse(value.toString()) + }; + }, + stream(value, ctx) { + return { + value: ctx.parse(value.toString()) + }; + } + }, + serialize(node, ctx) { + return "new URLSearchParams(" + ctx.serialize(node.value) + ")"; + }, + deserialize(node, ctx) { + return new URLSearchParams(ctx.deserialize(node.value)); + } +}); + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/ShallowErrorPlugin.js +var ShallowErrorPlugin = createPlugin({ + tag: "$TSR/Error", + test(value) { + return value instanceof Error; + }, + parse: { + sync(value, ctx) { + return { + message: ctx.parse(value.message) + }; + }, + async async(value, ctx) { + return { + message: await ctx.parse(value.message) + }; + }, + stream(value, ctx) { + return { + message: ctx.parse(value.message) + }; + } + }, + serialize(node, ctx) { + return "new Error(" + ctx.serialize(node.message) + ")"; + }, + deserialize(node, ctx) { + return new Error(ctx.deserialize(node.message)); + } +}); + +// ../../../node_modules/.pnpm/@tanstack+router-core@1.166.4/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/RawStream.js +var RawStream = class { + constructor(stream, options) { + this.stream = stream; + this.hint = options?.hint ?? "binary"; + } +}; +var BufferCtor = globalThis.Buffer; +var hasNodeBuffer = !!BufferCtor && typeof BufferCtor.from === "function"; +function uint8ArrayToBase64(bytes) { + if (bytes.length === 0) return ""; + if (hasNodeBuffer) { + return BufferCtor.from(bytes).toString("base64"); + } + const CHUNK_SIZE = 32768; + const chunks = []; + for (let i = 0; i < bytes.length; i += CHUNK_SIZE) { + const chunk = bytes.subarray(i, i + CHUNK_SIZE); + chunks.push(String.fromCharCode.apply(null, chunk)); + } + return btoa(chunks.join("")); +} +function base64ToUint8Array(base64) { + if (base64.length === 0) return new Uint8Array(0); + if (hasNodeBuffer) { + const buf = BufferCtor.from(base64, "base64"); + return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength); + } + const binary = atob(base64); + const bytes = new Uint8Array(binary.length); + for (let i = 0; i < binary.length; i++) { + bytes[i] = binary.charCodeAt(i); + } + return bytes; +} +var RAW_STREAM_FACTORY_BINARY = /* @__PURE__ */ Object.create(null); +var RAW_STREAM_FACTORY_TEXT = /* @__PURE__ */ Object.create(null); +var RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY = (stream) => new ReadableStream({ + start(controller) { + stream.on({ + next(base64) { + try { + controller.enqueue(base64ToUint8Array(base64)); + } catch { + } + }, + throw(error) { + controller.error(error); + }, + return() { + try { + controller.close(); + } catch { + } + } + }); + } +}); +var textEncoderForFactory = new TextEncoder(); +var RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT = (stream) => { + return new ReadableStream({ + start(controller) { + stream.on({ + next(value) { + try { + if (typeof value === "string") { + controller.enqueue(textEncoderForFactory.encode(value)); + } else { + controller.enqueue(base64ToUint8Array(value.$b64)); + } + } catch { + } + }, + throw(error) { + controller.error(error); + }, + return() { + try { + controller.close(); + } catch { + } + } + }); + } + }); +}; +var FACTORY_BINARY = `(s=>new ReadableStream({start(c){s.on({next(b){try{const d=atob(b),a=new Uint8Array(d.length);for(let i=0;i{const e=new TextEncoder();return new ReadableStream({start(c){s.on({next(v){try{if(typeof v==='string'){c.enqueue(e.encode(v))}else{const d=atob(v.$b64),a=new Uint8Array(d.length);for(let i=0;i { + try { + while (true) { + const { done, value } = await reader.read(); + if (done) { + stream.return(void 0); + break; + } + stream.next(uint8ArrayToBase64(value)); + } + } catch (error) { + stream.throw(error); + } finally { + reader.releaseLock(); + } + })(); + return stream; +} +function toTextStream(readable) { + const stream = createStream(); + const reader = readable.getReader(); + const decoder = new TextDecoder("utf-8", { fatal: true }); + (async () => { + try { + while (true) { + const { done, value } = await reader.read(); + if (done) { + try { + const remaining = decoder.decode(); + if (remaining.length > 0) { + stream.next(remaining); + } + } catch { + } + stream.return(void 0); + break; + } + try { + const text = decoder.decode(value, { stream: true }); + if (text.length > 0) { + stream.next(text); + } + } catch { + stream.next({ $b64: uint8ArrayToBase64(value) }); + } + } + } catch (error) { + stream.throw(error); + } finally { + reader.releaseLock(); + } + })(); + return stream; +} +var RawStreamFactoryBinaryPlugin = createPlugin({ + tag: "tss/RawStreamFactory", + test(value) { + return value === RAW_STREAM_FACTORY_BINARY; + }, + parse: { + sync() { + return void 0; + }, + async() { + return Promise.resolve(void 0); + }, + stream() { + return void 0; + } + }, + serialize() { + return FACTORY_BINARY; + }, + deserialize() { + return RAW_STREAM_FACTORY_BINARY; + } +}); +var RawStreamFactoryTextPlugin = createPlugin({ + tag: "tss/RawStreamFactoryText", + test(value) { + return value === RAW_STREAM_FACTORY_TEXT; + }, + parse: { + sync() { + return void 0; + }, + async() { + return Promise.resolve(void 0); + }, + stream() { + return void 0; + } + }, + serialize() { + return FACTORY_TEXT; + }, + deserialize() { + return RAW_STREAM_FACTORY_TEXT; + } +}); +var RawStreamSSRPlugin = createPlugin({ + tag: "tss/RawStream", + extends: [RawStreamFactoryBinaryPlugin, RawStreamFactoryTextPlugin], + test(value) { + return value instanceof RawStream; + }, + parse: { + sync(value, ctx) { + const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY; + return { + hint: value.hint, + factory: ctx.parse(factory), + stream: ctx.parse(createStream()) + }; + }, + async async(value, ctx) { + const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY; + const encodedStream = value.hint === "text" ? toTextStream(value.stream) : toBinaryStream(value.stream); + return { + hint: value.hint, + factory: await ctx.parse(factory), + stream: await ctx.parse(encodedStream) + }; + }, + stream(value, ctx) { + const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY; + const encodedStream = value.hint === "text" ? toTextStream(value.stream) : toBinaryStream(value.stream); + return { + hint: value.hint, + factory: ctx.parse(factory), + stream: ctx.parse(encodedStream) + }; + } + }, + serialize(node, ctx) { + return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.stream) + ")"; + }, + deserialize(node, ctx) { + const stream = ctx.deserialize(node.stream); + return node.hint === "text" ? RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT(stream) : RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY(stream); + } +}); + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/awaited.js +var import_jsx_runtime = __toESM(require_jsx_runtime(), 1); +var React2 = __toESM(require_react(), 1); + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/utils.js +var React = __toESM(require_react(), 1); +var REACT_USE = "use"; +var reactUse = React[REACT_USE]; +var useLayoutEffect2 = typeof window !== "undefined" ? React.useLayoutEffect : React.useEffect; +function usePrevious(value) { + const ref = React.useRef({ + value, + prev: null + }); + const current = ref.current.value; + if (value !== current) { + ref.current = { + value, + prev: current + }; + } + return ref.current.prev; +} +function useIntersectionObserver(ref, callback, intersectionObserverOptions2 = {}, options = {}) { + React.useEffect(() => { + if (!ref.current || options.disabled || typeof IntersectionObserver !== "function") { + return; + } + const observer = new IntersectionObserver(([entry]) => { + callback(entry); + }, intersectionObserverOptions2); + observer.observe(ref.current); + return () => { + observer.disconnect(); + }; + }, [callback, intersectionObserverOptions2, options.disabled, ref]); +} +function useForwardedRef(ref) { + const innerRef = React.useRef(null); + React.useImperativeHandle(ref, () => innerRef.current, []); + return innerRef; +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/awaited.js +function useAwaited({ promise: _promise }) { + if (reactUse) { + const data = reactUse(_promise); + return data; + } + const promise = defer(_promise); + if (promise[TSR_DEFERRED_PROMISE].status === "pending") { + throw promise; + } + if (promise[TSR_DEFERRED_PROMISE].status === "error") { + throw promise[TSR_DEFERRED_PROMISE].error; + } + return promise[TSR_DEFERRED_PROMISE].data; +} +function Await(props) { + const inner = (0, import_jsx_runtime.jsx)(AwaitInner, { ...props }); + if (props.fallback) { + return (0, import_jsx_runtime.jsx)(React2.Suspense, { fallback: props.fallback, children: inner }); + } + return inner; +} +function AwaitInner(props) { + const data = useAwaited(props); + return props.children(data); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/CatchBoundary.js +var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1); +var React3 = __toESM(require_react(), 1); +function CatchBoundary(props) { + const errorComponent = props.errorComponent ?? ErrorComponent; + return (0, import_jsx_runtime2.jsx)( + CatchBoundaryImpl, + { + getResetKey: props.getResetKey, + onCatch: props.onCatch, + children: ({ error, reset }) => { + if (error) { + return React3.createElement(errorComponent, { + error, + reset + }); + } + return props.children; + } + } + ); +} +var CatchBoundaryImpl = class extends React3.Component { + constructor() { + super(...arguments); + this.state = { error: null }; + } + static getDerivedStateFromProps(props) { + return { resetKey: props.getResetKey() }; + } + static getDerivedStateFromError(error) { + return { error }; + } + reset() { + this.setState({ error: null }); + } + componentDidUpdate(prevProps, prevState) { + if (prevState.error && prevState.resetKey !== this.state.resetKey) { + this.reset(); + } + } + componentDidCatch(error, errorInfo) { + if (this.props.onCatch) { + this.props.onCatch(error, errorInfo); + } + } + render() { + return this.props.children({ + error: this.state.resetKey !== this.props.getResetKey() ? null : this.state.error, + reset: () => { + this.reset(); + } + }); + } +}; +function ErrorComponent({ error }) { + const [show, setShow] = React3.useState(true); + return (0, import_jsx_runtime2.jsxs)("div", { style: { padding: ".5rem", maxWidth: "100%" }, children: [ + (0, import_jsx_runtime2.jsxs)("div", { style: { display: "flex", alignItems: "center", gap: ".5rem" }, children: [ + (0, import_jsx_runtime2.jsx)("strong", { style: { fontSize: "1rem" }, children: "Something went wrong!" }), + (0, import_jsx_runtime2.jsx)( + "button", + { + style: { + appearance: "none", + fontSize: ".6em", + border: "1px solid currentColor", + padding: ".1rem .2rem", + fontWeight: "bold", + borderRadius: ".25rem" + }, + onClick: () => setShow((d) => !d), + children: show ? "Hide Error" : "Show Error" + } + ) + ] }), + (0, import_jsx_runtime2.jsx)("div", { style: { height: ".25rem" } }), + show ? (0, import_jsx_runtime2.jsx)("div", { children: (0, import_jsx_runtime2.jsx)( + "pre", + { + style: { + fontSize: ".7em", + border: "1px solid red", + borderRadius: ".25rem", + padding: ".3rem", + color: "red", + overflow: "auto" + }, + children: error.message ? (0, import_jsx_runtime2.jsx)("code", { children: error.message }) : null + } + ) }) : null + ] }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/ClientOnly.js +var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1); +var import_react = __toESM(require_react(), 1); +function ClientOnly({ children, fallback = null }) { + return useHydrated() ? (0, import_jsx_runtime3.jsx)(import_react.default.Fragment, { children }) : (0, import_jsx_runtime3.jsx)(import_react.default.Fragment, { children: fallback }); +} +function useHydrated() { + return import_react.default.useSyncExternalStore( + subscribe, + () => true, + () => false + ); +} +function subscribe() { + return () => { + }; +} + +// ../../../node_modules/.pnpm/tiny-warning@1.0.3/node_modules/tiny-warning/dist/tiny-warning.esm.js +var isProduction2 = false; +function warning(condition, message) { + if (!isProduction2) { + if (condition) { + return; + } + var text = "Warning: " + message; + if (typeof console !== "undefined") { + console.warn(text); + } + try { + throw Error(text); + } catch (x) { + } + } +} +var tiny_warning_esm_default = warning; + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/route.js +var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1); +var import_react4 = __toESM(require_react(), 1); + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useMatch.js +var React7 = __toESM(require_react(), 1); + +// ../../../node_modules/.pnpm/@tanstack+react-store@0.9.2_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-store/dist/esm/useStore.js +var import_react2 = __toESM(require_react(), 1); +var import_with_selector = __toESM(require_with_selector(), 1); +function defaultCompare(a, b) { + return a === b; +} +function useStore(atom, selector, compare = defaultCompare) { + const subscribe2 = (0, import_react2.useCallback)( + (handleStoreChange) => { + if (!atom) { + return () => { + }; + } + const { unsubscribe } = atom.subscribe(handleStoreChange); + return unsubscribe; + }, + [atom] + ); + const boundGetSnapshot = (0, import_react2.useCallback)(() => atom?.get(), [atom]); + const selectedSnapshot = (0, import_with_selector.useSyncExternalStoreWithSelector)( + subscribe2, + boundGetSnapshot, + boundGetSnapshot, + selector, + compare + ); + return selectedSnapshot; +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useRouterState.js +var import_react3 = __toESM(require_react(), 1); + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useRouter.js +var React5 = __toESM(require_react(), 1); + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/routerContext.js +var React4 = __toESM(require_react(), 1); +var routerContext = React4.createContext(null); + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useRouter.js +function useRouter(opts) { + const value = React5.useContext(routerContext); + tiny_warning_esm_default( + !((opts?.warn ?? true) && !value), + "useRouter must be used inside a component!" + ); + return value; +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useRouterState.js +function useRouterState(opts) { + const contextRouter = useRouter({ + warn: opts?.router === void 0 + }); + const router = opts?.router || contextRouter; + const _isServer = isServer ?? router.isServer; + if (_isServer) { + const state = router.state; + return opts?.select ? opts.select(state) : state; + } + const previousResult = ( + // eslint-disable-next-line react-hooks/rules-of-hooks + (0, import_react3.useRef)(void 0) + ); + return useStore(router.__store, (state) => { + if (opts?.select) { + if (opts.structuralSharing ?? router.options.defaultStructuralSharing) { + const newSlice = replaceEqualDeep( + previousResult.current, + opts.select(state) + ); + previousResult.current = newSlice; + return newSlice; + } + return opts.select(state); + } + return state; + }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/matchContext.js +var React6 = __toESM(require_react(), 1); +var matchContext = React6.createContext(void 0); +var dummyMatchContext = React6.createContext( + void 0 +); + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useMatch.js +function useMatch(opts) { + const nearestMatchId = React7.useContext( + opts.from ? dummyMatchContext : matchContext + ); + const matchSelection = useRouterState({ + select: (state) => { + const match = state.matches.find( + (d) => opts.from ? opts.from === d.routeId : d.id === nearestMatchId + ); + invariant( + !((opts.shouldThrow ?? true) && !match), + `Could not find ${opts.from ? `an active match from "${opts.from}"` : "a nearest match!"}` + ); + if (match === void 0) { + return void 0; + } + return opts.select ? opts.select(match) : match; + }, + structuralSharing: opts.structuralSharing + }); + return matchSelection; +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useLoaderData.js +function useLoaderData(opts) { + return useMatch({ + from: opts.from, + strict: opts.strict, + structuralSharing: opts.structuralSharing, + select: (s) => { + return opts.select ? opts.select(s.loaderData) : s.loaderData; + } + }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useLoaderDeps.js +function useLoaderDeps(opts) { + const { select, ...rest } = opts; + return useMatch({ + ...rest, + select: (s) => { + return select ? select(s.loaderDeps) : s.loaderDeps; + } + }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useParams.js +function useParams(opts) { + return useMatch({ + from: opts.from, + shouldThrow: opts.shouldThrow, + structuralSharing: opts.structuralSharing, + strict: opts.strict, + select: (match) => { + const params = opts.strict === false ? match.params : match._strictParams; + return opts.select ? opts.select(params) : params; + } + }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useSearch.js +function useSearch(opts) { + return useMatch({ + from: opts.from, + strict: opts.strict, + shouldThrow: opts.shouldThrow, + structuralSharing: opts.structuralSharing, + select: (match) => { + return opts.select ? opts.select(match.search) : match.search; + } + }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useNavigate.js +var React8 = __toESM(require_react(), 1); +function useNavigate(_defaultOpts) { + const router = useRouter(); + return React8.useCallback( + (options) => { + return router.navigate({ + ...options, + from: options.from ?? _defaultOpts?.from + }); + }, + [_defaultOpts?.from, router] + ); +} +function Navigate(props) { + const router = useRouter(); + const navigate = useNavigate(); + const previousPropsRef = React8.useRef(null); + useLayoutEffect2(() => { + if (previousPropsRef.current !== props) { + navigate(props); + previousPropsRef.current = props; + } + }, [router, props, navigate]); + return null; +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useRouteContext.js +function useRouteContext(opts) { + return useMatch({ + ...opts, + select: (match) => opts.select ? opts.select(match.context) : match.context + }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/link.js +var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1); +var React9 = __toESM(require_react(), 1); +var import_react_dom = __toESM(require_react_dom(), 1); +function useLinkProps(options, forwardedRef) { + const router = useRouter(); + const innerRef = useForwardedRef(forwardedRef); + const _isServer = isServer ?? router.isServer; + const { + // custom props + activeProps, + inactiveProps, + activeOptions, + to, + preload: userPreload, + preloadDelay: userPreloadDelay, + hashScrollIntoView, + replace, + startTransition: startTransition2, + resetScroll, + viewTransition, + // element props + children, + target, + disabled, + style, + className, + onClick, + onBlur, + onFocus, + onMouseEnter, + onMouseLeave, + onTouchStart, + ignoreBlocker, + // prevent these from being returned + params: _params, + search: _search, + hash: _hash, + state: _state, + mask: _mask, + reloadDocument: _reloadDocument, + unsafeRelative: _unsafeRelative, + from: _from, + _fromLocation, + ...propsSafeToSpread + } = options; + if (_isServer) { + const safeInternal = isSafeInternal(to); + if (typeof to === "string" && !safeInternal && // Quick checks to avoid `new URL` in common internal-like cases + to.indexOf(":") > -1) { + try { + new URL(to); + if (isDangerousProtocol(to, router.protocolAllowlist)) { + if (true) { + console.warn(`Blocked Link with dangerous protocol: ${to}`); + } + return { + ...propsSafeToSpread, + ref: innerRef, + href: void 0, + ...children && { children }, + ...target && { target }, + ...disabled && { disabled }, + ...style && { style }, + ...className && { className } + }; + } + return { + ...propsSafeToSpread, + ref: innerRef, + href: to, + ...children && { children }, + ...target && { target }, + ...disabled && { disabled }, + ...style && { style }, + ...className && { className } + }; + } catch { + } + } + const next2 = router.buildLocation({ ...options, from: options.from }); + const hrefOptionPublicHref2 = next2.maskedLocation ? next2.maskedLocation.publicHref : next2.publicHref; + const hrefOptionExternal2 = next2.maskedLocation ? next2.maskedLocation.external : next2.external; + const hrefOption2 = getHrefOption( + hrefOptionPublicHref2, + hrefOptionExternal2, + router.history, + disabled + ); + const externalLink2 = (() => { + if (hrefOption2?.external) { + if (isDangerousProtocol(hrefOption2.href, router.protocolAllowlist)) { + if (true) { + console.warn( + `Blocked Link with dangerous protocol: ${hrefOption2.href}` + ); + } + return void 0; + } + return hrefOption2.href; + } + if (safeInternal) return void 0; + if (typeof to === "string" && to.indexOf(":") > -1) { + try { + new URL(to); + if (isDangerousProtocol(to, router.protocolAllowlist)) { + if (true) { + console.warn(`Blocked Link with dangerous protocol: ${to}`); + } + return void 0; + } + return to; + } catch { + } + } + return void 0; + })(); + const isActive2 = (() => { + if (externalLink2) return false; + const currentLocation = router.state.location; + const exact = activeOptions?.exact ?? false; + if (exact) { + const testExact = exactPathTest( + currentLocation.pathname, + next2.pathname, + router.basepath + ); + if (!testExact) { + return false; + } + } else { + const currentPathSplit = removeTrailingSlash( + currentLocation.pathname, + router.basepath + ); + const nextPathSplit = removeTrailingSlash( + next2.pathname, + router.basepath + ); + const pathIsFuzzyEqual = currentPathSplit.startsWith(nextPathSplit) && (currentPathSplit.length === nextPathSplit.length || currentPathSplit[nextPathSplit.length] === "/"); + if (!pathIsFuzzyEqual) { + return false; + } + } + const includeSearch = activeOptions?.includeSearch ?? true; + if (includeSearch) { + if (currentLocation.search !== next2.search) { + const currentSearchEmpty = !currentLocation.search || typeof currentLocation.search === "object" && Object.keys(currentLocation.search).length === 0; + const nextSearchEmpty = !next2.search || typeof next2.search === "object" && Object.keys(next2.search).length === 0; + if (!(currentSearchEmpty && nextSearchEmpty)) { + const searchTest = deepEqual(currentLocation.search, next2.search, { + partial: !exact, + ignoreUndefined: !activeOptions?.explicitUndefined + }); + if (!searchTest) { + return false; + } + } + } + } + if (activeOptions?.includeHash) { + return false; + } + return true; + })(); + if (externalLink2) { + return { + ...propsSafeToSpread, + ref: innerRef, + href: externalLink2, + ...children && { children }, + ...target && { target }, + ...disabled && { disabled }, + ...style && { style }, + ...className && { className } + }; + } + const resolvedActiveProps2 = isActive2 ? functionalUpdate(activeProps, {}) ?? STATIC_ACTIVE_OBJECT : STATIC_EMPTY_OBJECT; + const resolvedInactiveProps2 = isActive2 ? STATIC_EMPTY_OBJECT : functionalUpdate(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT; + const resolvedStyle2 = (() => { + const baseStyle = style; + const activeStyle = resolvedActiveProps2.style; + const inactiveStyle = resolvedInactiveProps2.style; + if (!baseStyle && !activeStyle && !inactiveStyle) { + return void 0; + } + if (baseStyle && !activeStyle && !inactiveStyle) { + return baseStyle; + } + if (!baseStyle && activeStyle && !inactiveStyle) { + return activeStyle; + } + if (!baseStyle && !activeStyle && inactiveStyle) { + return inactiveStyle; + } + return { + ...baseStyle, + ...activeStyle, + ...inactiveStyle + }; + })(); + const resolvedClassName2 = (() => { + const baseClassName = className; + const activeClassName = resolvedActiveProps2.className; + const inactiveClassName = resolvedInactiveProps2.className; + if (!baseClassName && !activeClassName && !inactiveClassName) { + return ""; + } + let out = ""; + if (baseClassName) { + out = baseClassName; + } + if (activeClassName) { + out = out ? `${out} ${activeClassName}` : activeClassName; + } + if (inactiveClassName) { + out = out ? `${out} ${inactiveClassName}` : inactiveClassName; + } + return out; + })(); + return { + ...propsSafeToSpread, + ...resolvedActiveProps2, + ...resolvedInactiveProps2, + href: hrefOption2?.href, + ref: innerRef, + disabled: !!disabled, + target, + ...resolvedStyle2 && { style: resolvedStyle2 }, + ...resolvedClassName2 && { className: resolvedClassName2 }, + ...disabled && STATIC_DISABLED_PROPS, + ...isActive2 && STATIC_ACTIVE_PROPS + }; + } + const isHydrated = useHydrated(); + const currentLocationState = useRouterState({ + select: (s) => { + const leaf = s.matches[s.matches.length - 1]; + return { + search: leaf?.search, + hash: s.location.hash, + path: leaf?.pathname + // path + params + }; + }, + structuralSharing: true + }); + const from = options.from; + const _options = React9.useMemo( + () => { + return { ...options, from }; + }, + // eslint-disable-next-line react-hooks/exhaustive-deps + [ + router, + currentLocationState, + from, + options._fromLocation, + options.hash, + options.to, + options.search, + options.params, + options.state, + options.mask, + options.unsafeRelative + ] + ); + const next = React9.useMemo( + () => router.buildLocation({ ..._options }), + [router, _options] + ); + const hrefOptionPublicHref = next.maskedLocation ? next.maskedLocation.publicHref : next.publicHref; + const hrefOptionExternal = next.maskedLocation ? next.maskedLocation.external : next.external; + const hrefOption = React9.useMemo( + () => getHrefOption( + hrefOptionPublicHref, + hrefOptionExternal, + router.history, + disabled + ), + [disabled, hrefOptionExternal, hrefOptionPublicHref, router.history] + ); + const externalLink = React9.useMemo(() => { + if (hrefOption?.external) { + if (isDangerousProtocol(hrefOption.href, router.protocolAllowlist)) { + if (true) { + console.warn( + `Blocked Link with dangerous protocol: ${hrefOption.href}` + ); + } + return void 0; + } + return hrefOption.href; + } + const safeInternal = isSafeInternal(to); + if (safeInternal) return void 0; + if (typeof to !== "string" || to.indexOf(":") === -1) return void 0; + try { + new URL(to); + if (isDangerousProtocol(to, router.protocolAllowlist)) { + if (true) { + console.warn(`Blocked Link with dangerous protocol: ${to}`); + } + return void 0; + } + return to; + } catch { + } + return void 0; + }, [to, hrefOption, router.protocolAllowlist]); + const isActive = useRouterState({ + select: (s) => { + if (externalLink) return false; + if (activeOptions?.exact) { + const testExact = exactPathTest( + s.location.pathname, + next.pathname, + router.basepath + ); + if (!testExact) { + return false; + } + } else { + const currentPathSplit = removeTrailingSlash( + s.location.pathname, + router.basepath + ); + const nextPathSplit = removeTrailingSlash( + next.pathname, + router.basepath + ); + const pathIsFuzzyEqual = currentPathSplit.startsWith(nextPathSplit) && (currentPathSplit.length === nextPathSplit.length || currentPathSplit[nextPathSplit.length] === "/"); + if (!pathIsFuzzyEqual) { + return false; + } + } + if (activeOptions?.includeSearch ?? true) { + const searchTest = deepEqual(s.location.search, next.search, { + partial: !activeOptions?.exact, + ignoreUndefined: !activeOptions?.explicitUndefined + }); + if (!searchTest) { + return false; + } + } + if (activeOptions?.includeHash) { + return isHydrated && s.location.hash === next.hash; + } + return true; + } + }); + const resolvedActiveProps = isActive ? functionalUpdate(activeProps, {}) ?? STATIC_ACTIVE_OBJECT : STATIC_EMPTY_OBJECT; + const resolvedInactiveProps = isActive ? STATIC_EMPTY_OBJECT : functionalUpdate(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT; + const resolvedClassName = [ + className, + resolvedActiveProps.className, + resolvedInactiveProps.className + ].filter(Boolean).join(" "); + const resolvedStyle = (style || resolvedActiveProps.style || resolvedInactiveProps.style) && { + ...style, + ...resolvedActiveProps.style, + ...resolvedInactiveProps.style + }; + const [isTransitioning, setIsTransitioning] = React9.useState(false); + const hasRenderFetched = React9.useRef(false); + const preload = options.reloadDocument || externalLink ? false : userPreload ?? router.options.defaultPreload; + const preloadDelay = userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0; + const doPreload = React9.useCallback(() => { + router.preloadRoute({ ..._options, _builtLocation: next }).catch((err) => { + console.warn(err); + console.warn(preloadWarning); + }); + }, [router, _options, next]); + const preloadViewportIoCallback = React9.useCallback( + (entry) => { + if (entry?.isIntersecting) { + doPreload(); + } + }, + [doPreload] + ); + useIntersectionObserver( + innerRef, + preloadViewportIoCallback, + intersectionObserverOptions, + { disabled: !!disabled || !(preload === "viewport") } + ); + React9.useEffect(() => { + if (hasRenderFetched.current) { + return; + } + if (!disabled && preload === "render") { + doPreload(); + hasRenderFetched.current = true; + } + }, [disabled, doPreload, preload]); + const handleClick = (e) => { + const elementTarget = e.currentTarget.getAttribute("target"); + const effectiveTarget = target !== void 0 ? target : elementTarget; + if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!effectiveTarget || effectiveTarget === "_self") && e.button === 0) { + e.preventDefault(); + (0, import_react_dom.flushSync)(() => { + setIsTransitioning(true); + }); + const unsub = router.subscribe("onResolved", () => { + unsub(); + setIsTransitioning(false); + }); + router.navigate({ + ..._options, + replace, + resetScroll, + hashScrollIntoView, + startTransition: startTransition2, + viewTransition, + ignoreBlocker + }); + } + }; + if (externalLink) { + return { + ...propsSafeToSpread, + ref: innerRef, + href: externalLink, + ...children && { children }, + ...target && { target }, + ...disabled && { disabled }, + ...style && { style }, + ...className && { className }, + ...onClick && { onClick }, + ...onBlur && { onBlur }, + ...onFocus && { onFocus }, + ...onMouseEnter && { onMouseEnter }, + ...onMouseLeave && { onMouseLeave }, + ...onTouchStart && { onTouchStart } + }; + } + const enqueueIntentPreload = (e) => { + if (disabled || preload !== "intent") return; + if (!preloadDelay) { + doPreload(); + return; + } + const eventTarget = e.currentTarget; + if (timeoutMap.has(eventTarget)) { + return; + } + const id = setTimeout(() => { + timeoutMap.delete(eventTarget); + doPreload(); + }, preloadDelay); + timeoutMap.set(eventTarget, id); + }; + const handleTouchStart = (_) => { + if (disabled || preload !== "intent") return; + doPreload(); + }; + const handleLeave = (e) => { + if (disabled || !preload || !preloadDelay) return; + const eventTarget = e.currentTarget; + const id = timeoutMap.get(eventTarget); + if (id) { + clearTimeout(id); + timeoutMap.delete(eventTarget); + } + }; + return { + ...propsSafeToSpread, + ...resolvedActiveProps, + ...resolvedInactiveProps, + href: hrefOption?.href, + ref: innerRef, + onClick: composeHandlers([onClick, handleClick]), + onBlur: composeHandlers([onBlur, handleLeave]), + onFocus: composeHandlers([onFocus, enqueueIntentPreload]), + onMouseEnter: composeHandlers([onMouseEnter, enqueueIntentPreload]), + onMouseLeave: composeHandlers([onMouseLeave, handleLeave]), + onTouchStart: composeHandlers([onTouchStart, handleTouchStart]), + disabled: !!disabled, + target, + ...resolvedStyle && { style: resolvedStyle }, + ...resolvedClassName && { className: resolvedClassName }, + ...disabled && STATIC_DISABLED_PROPS, + ...isActive && STATIC_ACTIVE_PROPS, + ...isHydrated && isTransitioning && STATIC_TRANSITIONING_PROPS + }; +} +var STATIC_EMPTY_OBJECT = {}; +var STATIC_ACTIVE_OBJECT = { className: "active" }; +var STATIC_DISABLED_PROPS = { role: "link", "aria-disabled": true }; +var STATIC_ACTIVE_PROPS = { "data-status": "active", "aria-current": "page" }; +var STATIC_TRANSITIONING_PROPS = { "data-transitioning": "transitioning" }; +var timeoutMap = /* @__PURE__ */ new WeakMap(); +var intersectionObserverOptions = { + rootMargin: "100px" +}; +var composeHandlers = (handlers) => (e) => { + for (const handler of handlers) { + if (!handler) continue; + if (e.defaultPrevented) return; + handler(e); + } +}; +function getHrefOption(publicHref, external, history, disabled) { + if (disabled) return void 0; + if (external) { + return { href: publicHref, external: true }; + } + return { + href: history.createHref(publicHref) || "/", + external: false + }; +} +function isSafeInternal(to) { + if (typeof to !== "string") return false; + const zero = to.charCodeAt(0); + if (zero === 47) return to.charCodeAt(1) !== 47; + return zero === 46; +} +function createLink(Comp) { + return React9.forwardRef(function CreatedLink(props, ref) { + return (0, import_jsx_runtime4.jsx)(Link, { ...props, _asChild: Comp, ref }); + }); +} +var Link = React9.forwardRef( + (props, ref) => { + const { _asChild, ...rest } = props; + const { type: _type, ...linkProps } = useLinkProps(rest, ref); + const children = typeof rest.children === "function" ? rest.children({ + isActive: linkProps["data-status"] === "active" + }) : rest.children; + if (!_asChild) { + const { disabled: _, ...rest2 } = linkProps; + return React9.createElement("a", rest2, children); + } + return React9.createElement(_asChild, linkProps, children); + } +); +function isCtrlEvent(e) { + return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey); +} +var linkOptions = (options) => { + return options; +}; + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/route.js +function getRouteApi(id) { + return new RouteApi({ id }); +} +var RouteApi = class extends BaseRouteApi { + /** + * @deprecated Use the `getRouteApi` function instead. + */ + constructor({ id }) { + super({ id }); + this.useMatch = (opts) => { + return useMatch({ + select: opts?.select, + from: this.id, + structuralSharing: opts?.structuralSharing + }); + }; + this.useRouteContext = (opts) => { + return useRouteContext({ ...opts, from: this.id }); + }; + this.useSearch = (opts) => { + return useSearch({ + select: opts?.select, + structuralSharing: opts?.structuralSharing, + from: this.id + }); + }; + this.useParams = (opts) => { + return useParams({ + select: opts?.select, + structuralSharing: opts?.structuralSharing, + from: this.id + }); + }; + this.useLoaderDeps = (opts) => { + return useLoaderDeps({ ...opts, from: this.id, strict: false }); + }; + this.useLoaderData = (opts) => { + return useLoaderData({ ...opts, from: this.id, strict: false }); + }; + this.useNavigate = () => { + const router = useRouter(); + return useNavigate({ from: router.routesById[this.id].fullPath }); + }; + this.notFound = (opts) => { + return notFound({ routeId: this.id, ...opts }); + }; + this.Link = import_react4.default.forwardRef((props, ref) => { + const router = useRouter(); + const fullPath = router.routesById[this.id].fullPath; + return (0, import_jsx_runtime5.jsx)(Link, { ref, from: fullPath, ...props }); + }); + } +}; +var Route = class extends BaseRoute { + /** + * @deprecated Use the `createRoute` function instead. + */ + constructor(options) { + super(options); + this.useMatch = (opts) => { + return useMatch({ + select: opts?.select, + from: this.id, + structuralSharing: opts?.structuralSharing + }); + }; + this.useRouteContext = (opts) => { + return useRouteContext({ ...opts, from: this.id }); + }; + this.useSearch = (opts) => { + return useSearch({ + select: opts?.select, + structuralSharing: opts?.structuralSharing, + from: this.id + }); + }; + this.useParams = (opts) => { + return useParams({ + select: opts?.select, + structuralSharing: opts?.structuralSharing, + from: this.id + }); + }; + this.useLoaderDeps = (opts) => { + return useLoaderDeps({ ...opts, from: this.id }); + }; + this.useLoaderData = (opts) => { + return useLoaderData({ ...opts, from: this.id }); + }; + this.useNavigate = () => { + return useNavigate({ from: this.fullPath }); + }; + this.Link = import_react4.default.forwardRef( + (props, ref) => { + return (0, import_jsx_runtime5.jsx)(Link, { ref, from: this.fullPath, ...props }); + } + ); + this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo"); + } +}; +function createRoute(options) { + return new Route( + // TODO: Help us TypeChris, you're our only hope! + options + ); +} +function createRootRouteWithContext() { + return (options) => { + return createRootRoute(options); + }; +} +var rootRouteWithContext = createRootRouteWithContext; +var RootRoute = class extends BaseRootRoute { + /** + * @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead. + */ + constructor(options) { + super(options); + this.useMatch = (opts) => { + return useMatch({ + select: opts?.select, + from: this.id, + structuralSharing: opts?.structuralSharing + }); + }; + this.useRouteContext = (opts) => { + return useRouteContext({ ...opts, from: this.id }); + }; + this.useSearch = (opts) => { + return useSearch({ + select: opts?.select, + structuralSharing: opts?.structuralSharing, + from: this.id + }); + }; + this.useParams = (opts) => { + return useParams({ + select: opts?.select, + structuralSharing: opts?.structuralSharing, + from: this.id + }); + }; + this.useLoaderDeps = (opts) => { + return useLoaderDeps({ ...opts, from: this.id }); + }; + this.useLoaderData = (opts) => { + return useLoaderData({ ...opts, from: this.id }); + }; + this.useNavigate = () => { + return useNavigate({ from: this.fullPath }); + }; + this.Link = import_react4.default.forwardRef( + (props, ref) => { + return (0, import_jsx_runtime5.jsx)(Link, { ref, from: this.fullPath, ...props }); + } + ); + this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo"); + } +}; +function createRootRoute(options) { + return new RootRoute(options); +} +function createRouteMask(opts) { + return opts; +} +var NotFoundRoute = class extends Route { + constructor(options) { + super({ + ...options, + id: "404" + }); + } +}; + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/fileRoute.js +function createFileRoute(path) { + if (typeof path === "object") { + return new FileRoute(path, { + silent: true + }).createRoute(path); + } + return new FileRoute(path, { + silent: true + }).createRoute; +} +var FileRoute = class { + constructor(path, _opts) { + this.path = path; + this.createRoute = (options) => { + if (true) { + tiny_warning_esm_default( + this.silent, + "FileRoute is deprecated and will be removed in the next major version. Use the createFileRoute(path)(options) function instead." + ); + } + const route = createRoute(options); + route.isRoot = false; + return route; + }; + this.silent = _opts?.silent; + } +}; +function FileRouteLoader(_path) { + if (true) { + tiny_warning_esm_default( + false, + `FileRouteLoader is deprecated and will be removed in the next major version. Please place the loader function in the the main route file, inside the \`createFileRoute('/path/to/file')(options)\` options` + ); + } + return (loaderFn) => loaderFn; +} +var LazyRoute = class { + constructor(opts) { + this.useMatch = (opts2) => { + return useMatch({ + select: opts2?.select, + from: this.options.id, + structuralSharing: opts2?.structuralSharing + }); + }; + this.useRouteContext = (opts2) => { + return useRouteContext({ ...opts2, from: this.options.id }); + }; + this.useSearch = (opts2) => { + return useSearch({ + select: opts2?.select, + structuralSharing: opts2?.structuralSharing, + from: this.options.id + }); + }; + this.useParams = (opts2) => { + return useParams({ + select: opts2?.select, + structuralSharing: opts2?.structuralSharing, + from: this.options.id + }); + }; + this.useLoaderDeps = (opts2) => { + return useLoaderDeps({ ...opts2, from: this.options.id }); + }; + this.useLoaderData = (opts2) => { + return useLoaderData({ ...opts2, from: this.options.id }); + }; + this.useNavigate = () => { + const router = useRouter(); + return useNavigate({ from: router.routesById[this.options.id].fullPath }); + }; + this.options = opts; + this.$$typeof = /* @__PURE__ */ Symbol.for("react.memo"); + } +}; +function createLazyRoute(id) { + return (opts) => { + return new LazyRoute({ + id, + ...opts + }); + }; +} +function createLazyFileRoute(id) { + if (typeof id === "object") { + return new LazyRoute(id); + } + return (opts) => new LazyRoute({ id, ...opts }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/lazyRouteComponent.js +var React10 = __toESM(require_react(), 1); +function lazyRouteComponent(importer, exportName) { + let loadPromise; + let comp; + let error; + let reload; + const load = () => { + if (!loadPromise) { + loadPromise = importer().then((res) => { + loadPromise = void 0; + comp = res[exportName ?? "default"]; + }).catch((err) => { + error = err; + if (isModuleNotFoundError(error)) { + if (error instanceof Error && typeof window !== "undefined" && typeof sessionStorage !== "undefined") { + const storageKey2 = `tanstack_router_reload:${error.message}`; + if (!sessionStorage.getItem(storageKey2)) { + sessionStorage.setItem(storageKey2, "1"); + reload = true; + } + } + } + }); + } + return loadPromise; + }; + const lazyComp = function Lazy(props) { + if (reload) { + window.location.reload(); + throw new Promise(() => { + }); + } + if (error) { + throw error; + } + if (!comp) { + if (reactUse) { + reactUse(load()); + } else { + throw load(); + } + } + return React10.createElement(comp, props); + }; + lazyComp.preload = load; + return lazyComp; +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/Matches.js +var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1); +var React13 = __toESM(require_react(), 1); + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/Transitioner.js +var React11 = __toESM(require_react(), 1); +function Transitioner() { + const router = useRouter(); + const mountLoadForRouter = React11.useRef({ router, mounted: false }); + const [isTransitioning, setIsTransitioning] = React11.useState(false); + const { hasPendingMatches, isLoading } = useRouterState({ + select: (s) => ({ + isLoading: s.isLoading, + hasPendingMatches: s.matches.some((d) => d.status === "pending") + }), + structuralSharing: true + }); + const previousIsLoading = usePrevious(isLoading); + const isAnyPending = isLoading || isTransitioning || hasPendingMatches; + const previousIsAnyPending = usePrevious(isAnyPending); + const isPagePending = isLoading || hasPendingMatches; + const previousIsPagePending = usePrevious(isPagePending); + router.startTransition = (fn) => { + setIsTransitioning(true); + React11.startTransition(() => { + fn(); + setIsTransitioning(false); + }); + }; + React11.useEffect(() => { + const unsub = router.history.subscribe(router.load); + const nextLocation = router.buildLocation({ + to: router.latestLocation.pathname, + search: true, + params: true, + hash: true, + state: true, + _includeValidateSearch: true + }); + if (trimPathRight2(router.latestLocation.publicHref) !== trimPathRight2(nextLocation.publicHref)) { + router.commitLocation({ ...nextLocation, replace: true }); + } + return () => { + unsub(); + }; + }, [router, router.history]); + useLayoutEffect2(() => { + if ( + // if we are hydrating from SSR, loading is triggered in ssr-client + typeof window !== "undefined" && router.ssr || mountLoadForRouter.current.router === router && mountLoadForRouter.current.mounted + ) { + return; + } + mountLoadForRouter.current = { router, mounted: true }; + const tryLoad = async () => { + try { + await router.load(); + } catch (err) { + console.error(err); + } + }; + tryLoad(); + }, [router]); + useLayoutEffect2(() => { + if (previousIsLoading && !isLoading) { + router.emit({ + type: "onLoad", + // When the new URL has committed, when the new matches have been loaded into state.matches + ...getLocationChangeInfo(router.state) + }); + } + }, [previousIsLoading, router, isLoading]); + useLayoutEffect2(() => { + if (previousIsPagePending && !isPagePending) { + router.emit({ + type: "onBeforeRouteMount", + ...getLocationChangeInfo(router.state) + }); + } + }, [isPagePending, previousIsPagePending, router]); + useLayoutEffect2(() => { + if (previousIsAnyPending && !isAnyPending) { + const changeInfo = getLocationChangeInfo(router.state); + router.emit({ + type: "onResolved", + ...changeInfo + }); + router.__store.setState((s) => ({ + ...s, + status: "idle", + resolvedLocation: s.location + })); + if (changeInfo.hrefChanged) { + handleHashScroll(router); + } + } + }, [isAnyPending, previousIsAnyPending, router]); + return null; +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/Match.js +var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1); +var React12 = __toESM(require_react(), 1); + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/not-found.js +var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1); +function CatchNotFound(props) { + const resetKey = useRouterState({ + select: (s) => `not-found-${s.location.pathname}-${s.status}` + }); + return (0, import_jsx_runtime6.jsx)( + CatchBoundary, + { + getResetKey: () => resetKey, + onCatch: (error, errorInfo) => { + if (isNotFound(error)) { + props.onCatch?.(error, errorInfo); + } else { + throw error; + } + }, + errorComponent: ({ error }) => { + if (isNotFound(error)) { + return props.fallback?.(error); + } else { + throw error; + } + }, + children: props.children + } + ); +} +function DefaultGlobalNotFound() { + return (0, import_jsx_runtime6.jsx)("p", { children: "Not Found" }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/SafeFragment.js +var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1); +function SafeFragment(props) { + return (0, import_jsx_runtime7.jsx)(import_jsx_runtime7.Fragment, { children: props.children }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/renderRouteNotFound.js +var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1); +function renderRouteNotFound(router, route, data) { + if (!route.options.notFoundComponent) { + if (router.options.defaultNotFoundComponent) { + return (0, import_jsx_runtime8.jsx)(router.options.defaultNotFoundComponent, { ...data }); + } + if (true) { + tiny_warning_esm_default( + route.options.notFoundComponent, + `A notFoundError was encountered on the route with ID "${route.id}", but a notFoundComponent option was not configured, nor was a router level defaultNotFoundComponent configured. Consider configuring at least one of these to avoid TanStack Router's overly generic defaultNotFoundComponent (

Not Found

)` + ); + } + return (0, import_jsx_runtime8.jsx)(DefaultGlobalNotFound, {}); + } + return (0, import_jsx_runtime8.jsx)(route.options.notFoundComponent, { ...data }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/scroll-restoration.js +var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1); + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/ScriptOnce.js +var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1); +function ScriptOnce({ children }) { + const router = useRouter(); + if (!(isServer ?? router.isServer)) { + return null; + } + return (0, import_jsx_runtime9.jsx)( + "script", + { + nonce: router.options.ssr?.nonce, + dangerouslySetInnerHTML: { + __html: children + ";document.currentScript.remove()" + } + } + ); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/scroll-restoration.js +function ScrollRestoration() { + const router = useRouter(); + if (!router.isScrollRestoring || !(isServer ?? router.isServer)) { + return null; + } + if (typeof router.options.scrollRestoration === "function") { + const shouldRestore = router.options.scrollRestoration({ + location: router.latestLocation + }); + if (!shouldRestore) { + return null; + } + } + const getKey = router.options.getScrollRestorationKey || defaultGetScrollRestorationKey; + const userKey = getKey(router.latestLocation); + const resolvedKey = userKey !== defaultGetScrollRestorationKey(router.latestLocation) ? userKey : void 0; + const restoreScrollOptions = { + storageKey, + shouldScrollRestoration: true + }; + if (resolvedKey) { + restoreScrollOptions.key = resolvedKey; + } + return (0, import_jsx_runtime10.jsx)( + ScriptOnce, + { + children: `(${restoreScroll.toString()})(${escapeHtml(JSON.stringify(restoreScrollOptions))})` + } + ); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/Match.js +var Match = React12.memo(function MatchImpl({ + matchId +}) { + const router = useRouter(); + const matchState = useRouterState({ + select: (s) => { + const matchIndex = s.matches.findIndex((d) => d.id === matchId); + const match = s.matches[matchIndex]; + invariant( + match, + `Could not find match for matchId "${matchId}". Please file an issue!` + ); + return { + routeId: match.routeId, + ssr: match.ssr, + _displayPending: match._displayPending, + resetKey: s.loadedAt, + parentRouteId: s.matches[matchIndex - 1]?.routeId + }; + }, + structuralSharing: true + }); + const route = router.routesById[matchState.routeId]; + const PendingComponent = route.options.pendingComponent ?? router.options.defaultPendingComponent; + const pendingElement = PendingComponent ? (0, import_jsx_runtime11.jsx)(PendingComponent, {}) : null; + const routeErrorComponent = route.options.errorComponent ?? router.options.defaultErrorComponent; + const routeOnCatch = route.options.onCatch ?? router.options.defaultOnCatch; + const routeNotFoundComponent = route.isRoot ? ( + // If it's the root route, use the globalNotFound option, with fallback to the notFoundRoute's component + route.options.notFoundComponent ?? router.options.notFoundRoute?.options.component + ) : route.options.notFoundComponent; + const resolvedNoSsr = matchState.ssr === false || matchState.ssr === "data-only"; + const ResolvedSuspenseBoundary = ( + // If we're on the root route, allow forcefully wrapping in suspense + (!route.isRoot || route.options.wrapInSuspense || resolvedNoSsr) && (route.options.wrapInSuspense ?? PendingComponent ?? (route.options.errorComponent?.preload || resolvedNoSsr)) ? React12.Suspense : SafeFragment + ); + const ResolvedCatchBoundary = routeErrorComponent ? CatchBoundary : SafeFragment; + const ResolvedNotFoundBoundary = routeNotFoundComponent ? CatchNotFound : SafeFragment; + const ShellComponent = route.isRoot ? route.options.shellComponent ?? SafeFragment : SafeFragment; + return (0, import_jsx_runtime11.jsxs)(ShellComponent, { children: [ + (0, import_jsx_runtime11.jsx)(matchContext.Provider, { value: matchId, children: (0, import_jsx_runtime11.jsx)(ResolvedSuspenseBoundary, { fallback: pendingElement, children: (0, import_jsx_runtime11.jsx)( + ResolvedCatchBoundary, + { + getResetKey: () => matchState.resetKey, + errorComponent: routeErrorComponent || ErrorComponent, + onCatch: (error, errorInfo) => { + if (isNotFound(error)) throw error; + tiny_warning_esm_default(false, `Error in route match: ${matchId}`); + routeOnCatch?.(error, errorInfo); + }, + children: (0, import_jsx_runtime11.jsx)( + ResolvedNotFoundBoundary, + { + fallback: (error) => { + if (!routeNotFoundComponent || error.routeId && error.routeId !== matchState.routeId || !error.routeId && !route.isRoot) + throw error; + return React12.createElement(routeNotFoundComponent, error); + }, + children: resolvedNoSsr || matchState._displayPending ? (0, import_jsx_runtime11.jsx)(ClientOnly, { fallback: pendingElement, children: (0, import_jsx_runtime11.jsx)(MatchInner, { matchId }) }) : (0, import_jsx_runtime11.jsx)(MatchInner, { matchId }) + } + ) + } + ) }) }), + matchState.parentRouteId === rootRouteId && router.options.scrollRestoration ? (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [ + (0, import_jsx_runtime11.jsx)(OnRendered, {}), + (0, import_jsx_runtime11.jsx)(ScrollRestoration, {}) + ] }) : null + ] }); +}); +function OnRendered() { + const router = useRouter(); + const prevLocationRef = React12.useRef( + void 0 + ); + return (0, import_jsx_runtime11.jsx)( + "script", + { + suppressHydrationWarning: true, + ref: (el) => { + if (el && (prevLocationRef.current === void 0 || prevLocationRef.current.href !== router.latestLocation.href)) { + router.emit({ + type: "onRendered", + ...getLocationChangeInfo(router.state) + }); + prevLocationRef.current = router.latestLocation; + } + } + }, + router.latestLocation.state.__TSR_key + ); +} +var MatchInner = React12.memo(function MatchInnerImpl({ + matchId +}) { + const router = useRouter(); + const { match, key, routeId } = useRouterState({ + select: (s) => { + const match2 = s.matches.find((d) => d.id === matchId); + const routeId2 = match2.routeId; + const remountFn = router.routesById[routeId2].options.remountDeps ?? router.options.defaultRemountDeps; + const remountDeps = remountFn?.({ + routeId: routeId2, + loaderDeps: match2.loaderDeps, + params: match2._strictParams, + search: match2._strictSearch + }); + const key2 = remountDeps ? JSON.stringify(remountDeps) : void 0; + return { + key: key2, + routeId: routeId2, + match: { + id: match2.id, + status: match2.status, + error: match2.error, + invalid: match2.invalid, + _forcePending: match2._forcePending, + _displayPending: match2._displayPending + } + }; + }, + structuralSharing: true + }); + const route = router.routesById[routeId]; + const out = React12.useMemo(() => { + const Comp = route.options.component ?? router.options.defaultComponent; + if (Comp) { + return (0, import_jsx_runtime11.jsx)(Comp, {}, key); + } + return (0, import_jsx_runtime11.jsx)(Outlet, {}); + }, [key, route.options.component, router.options.defaultComponent]); + if (match._displayPending) { + throw router.getMatch(match.id)?._nonReactive.displayPendingPromise; + } + if (match._forcePending) { + throw router.getMatch(match.id)?._nonReactive.minPendingPromise; + } + if (match.status === "pending") { + const pendingMinMs = route.options.pendingMinMs ?? router.options.defaultPendingMinMs; + if (pendingMinMs) { + const routerMatch = router.getMatch(match.id); + if (routerMatch && !routerMatch._nonReactive.minPendingPromise) { + if (!(isServer ?? router.isServer)) { + const minPendingPromise = createControlledPromise(); + routerMatch._nonReactive.minPendingPromise = minPendingPromise; + setTimeout(() => { + minPendingPromise.resolve(); + routerMatch._nonReactive.minPendingPromise = void 0; + }, pendingMinMs); + } + } + } + throw router.getMatch(match.id)?._nonReactive.loadPromise; + } + if (match.status === "notFound") { + invariant(isNotFound(match.error), "Expected a notFound error"); + return renderRouteNotFound(router, route, match.error); + } + if (match.status === "redirected") { + invariant(isRedirect(match.error), "Expected a redirect error"); + throw router.getMatch(match.id)?._nonReactive.loadPromise; + } + if (match.status === "error") { + if (isServer ?? router.isServer) { + const RouteErrorComponent = (route.options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent; + return (0, import_jsx_runtime11.jsx)( + RouteErrorComponent, + { + error: match.error, + reset: void 0, + info: { + componentStack: "" + } + } + ); + } + throw match.error; + } + return out; +}); +var Outlet = React12.memo(function OutletImpl() { + const router = useRouter(); + const matchId = React12.useContext(matchContext); + const routeId = useRouterState({ + select: (s) => s.matches.find((d) => d.id === matchId)?.routeId + }); + const route = router.routesById[routeId]; + const parentGlobalNotFound = useRouterState({ + select: (s) => { + const matches = s.matches; + const parentMatch = matches.find((d) => d.id === matchId); + invariant( + parentMatch, + `Could not find parent match for matchId "${matchId}"` + ); + return parentMatch.globalNotFound; + } + }); + const childMatchId = useRouterState({ + select: (s) => { + const matches = s.matches; + const index = matches.findIndex((d) => d.id === matchId); + return matches[index + 1]?.id; + } + }); + const pendingElement = router.options.defaultPendingComponent ? (0, import_jsx_runtime11.jsx)(router.options.defaultPendingComponent, {}) : null; + if (parentGlobalNotFound) { + return renderRouteNotFound(router, route, void 0); + } + if (!childMatchId) { + return null; + } + const nextMatch = (0, import_jsx_runtime11.jsx)(Match, { matchId: childMatchId }); + if (routeId === rootRouteId) { + return (0, import_jsx_runtime11.jsx)(React12.Suspense, { fallback: pendingElement, children: nextMatch }); + } + return nextMatch; +}); + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/Matches.js +function Matches() { + const router = useRouter(); + const rootRoute = router.routesById[rootRouteId]; + const PendingComponent = rootRoute.options.pendingComponent ?? router.options.defaultPendingComponent; + const pendingElement = PendingComponent ? (0, import_jsx_runtime12.jsx)(PendingComponent, {}) : null; + const ResolvedSuspense = (isServer ?? router.isServer) || typeof document !== "undefined" && router.ssr ? SafeFragment : React13.Suspense; + const inner = (0, import_jsx_runtime12.jsxs)(ResolvedSuspense, { fallback: pendingElement, children: [ + !(isServer ?? router.isServer) && (0, import_jsx_runtime12.jsx)(Transitioner, {}), + (0, import_jsx_runtime12.jsx)(MatchesInner, {}) + ] }); + return router.options.InnerWrap ? (0, import_jsx_runtime12.jsx)(router.options.InnerWrap, { children: inner }) : inner; +} +function MatchesInner() { + const router = useRouter(); + const matchId = useRouterState({ + select: (s) => { + return s.matches[0]?.id; + } + }); + const resetKey = useRouterState({ + select: (s) => s.loadedAt + }); + const matchComponent = matchId ? (0, import_jsx_runtime12.jsx)(Match, { matchId }) : null; + return (0, import_jsx_runtime12.jsx)(matchContext.Provider, { value: matchId, children: router.options.disableGlobalCatchBoundary ? matchComponent : (0, import_jsx_runtime12.jsx)( + CatchBoundary, + { + getResetKey: () => resetKey, + errorComponent: ErrorComponent, + onCatch: true ? (error) => { + tiny_warning_esm_default( + false, + `The following error wasn't caught by any route! At the very least, consider setting an 'errorComponent' in your RootRoute!` + ); + tiny_warning_esm_default(false, error.message || error.toString()); + } : void 0, + children: matchComponent + } + ) }); +} +function useMatchRoute() { + const router = useRouter(); + useRouterState({ + select: (s) => [s.location.href, s.resolvedLocation?.href, s.status], + structuralSharing: true + }); + return React13.useCallback( + (opts) => { + const { pending, caseSensitive, fuzzy, includeSearch, ...rest } = opts; + return router.matchRoute(rest, { + pending, + caseSensitive, + fuzzy, + includeSearch + }); + }, + [router] + ); +} +function MatchRoute(props) { + const matchRoute = useMatchRoute(); + const params = matchRoute(props); + if (typeof props.children === "function") { + return props.children(params); + } + return params ? props.children : null; +} +function useMatches(opts) { + return useRouterState({ + select: (state) => { + const matches = state.matches; + return opts?.select ? opts.select(matches) : matches; + }, + structuralSharing: opts?.structuralSharing + }); +} +function useParentMatches(opts) { + const contextMatchId = React13.useContext(matchContext); + return useMatches({ + select: (matches) => { + matches = matches.slice( + 0, + matches.findIndex((d) => d.id === contextMatchId) + ); + return opts?.select ? opts.select(matches) : matches; + }, + structuralSharing: opts?.structuralSharing + }); +} +function useChildMatches(opts) { + const contextMatchId = React13.useContext(matchContext); + return useMatches({ + select: (matches) => { + matches = matches.slice( + matches.findIndex((d) => d.id === contextMatchId) + 1 + ); + return opts?.select ? opts.select(matches) : matches; + }, + structuralSharing: opts?.structuralSharing + }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/router.js +var createRouter = (options) => { + return new Router(options); +}; +var Router = class extends RouterCore { + constructor(options) { + super(options); + } +}; +if (typeof globalThis !== "undefined") { + globalThis.createFileRoute = createFileRoute; + globalThis.createLazyFileRoute = createLazyFileRoute; +} else if (typeof window !== "undefined") { + window.createFileRoute = createFileRoute; + window.createLazyFileRoute = createLazyFileRoute; +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/RouterProvider.js +var import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1); +function RouterContextProvider({ + router, + children, + ...rest +}) { + if (Object.keys(rest).length > 0) { + router.update({ + ...router.options, + ...rest, + context: { + ...router.options.context, + ...rest.context + } + }); + } + const provider = (0, import_jsx_runtime13.jsx)(routerContext.Provider, { value: router, children }); + if (router.options.Wrap) { + return (0, import_jsx_runtime13.jsx)(router.options.Wrap, { children: provider }); + } + return provider; +} +function RouterProvider({ router, ...rest }) { + return (0, import_jsx_runtime13.jsx)(RouterContextProvider, { router, ...rest, children: (0, import_jsx_runtime13.jsx)(Matches, {}) }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/ScrollRestoration.js +function useScrollRestoration() { + const router = useRouter(); + setupScrollRestoration(router, true); +} +function ScrollRestoration2(_props) { + useScrollRestoration(); + if (true) { + console.warn( + "The ScrollRestoration component is deprecated. Use createRouter's `scrollRestoration` option instead." + ); + } + return null; +} +function useElementScrollRestoration(options) { + useScrollRestoration(); + const router = useRouter(); + const getKey = options.getKey || defaultGetScrollRestorationKey; + let elementSelector = ""; + if (options.id) { + elementSelector = `[data-scroll-restoration-id="${options.id}"]`; + } else { + const element = options.getElement?.(); + if (!element) { + return; + } + elementSelector = element instanceof Window ? "window" : getCssSelector(element); + } + const restoreKey = getKey(router.latestLocation); + const byKey = scrollRestorationCache?.state[restoreKey]; + return byKey?.[elementSelector]; +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useBlocker.js +var React14 = __toESM(require_react(), 1); +function _resolveBlockerOpts(opts, condition) { + if (opts === void 0) { + return { + shouldBlockFn: () => true, + withResolver: false + }; + } + if ("shouldBlockFn" in opts) { + return opts; + } + if (typeof opts === "function") { + const shouldBlock2 = Boolean(condition ?? true); + const _customBlockerFn2 = async () => { + if (shouldBlock2) return await opts(); + return false; + }; + return { + shouldBlockFn: _customBlockerFn2, + enableBeforeUnload: shouldBlock2, + withResolver: false + }; + } + const shouldBlock = Boolean(opts.condition ?? true); + const fn = opts.blockerFn; + const _customBlockerFn = async () => { + if (shouldBlock && fn !== void 0) { + return await fn(); + } + return shouldBlock; + }; + return { + shouldBlockFn: _customBlockerFn, + enableBeforeUnload: shouldBlock, + withResolver: fn === void 0 + }; +} +function useBlocker(opts, condition) { + const { + shouldBlockFn, + enableBeforeUnload = true, + disabled = false, + withResolver = false + } = _resolveBlockerOpts(opts, condition); + const router = useRouter(); + const { history } = router; + const [resolver, setResolver] = React14.useState({ + status: "idle", + current: void 0, + next: void 0, + action: void 0, + proceed: void 0, + reset: void 0 + }); + React14.useEffect(() => { + const blockerFnComposed = async (blockerFnArgs) => { + function getLocation(location) { + const parsedLocation = router.parseLocation(location); + const matchedRoutes = router.getMatchedRoutes(parsedLocation.pathname); + if (matchedRoutes.foundRoute === void 0) { + return { + routeId: "__notFound__", + fullPath: parsedLocation.pathname, + pathname: parsedLocation.pathname, + params: matchedRoutes.routeParams, + search: router.options.parseSearch(location.search) + }; + } + return { + routeId: matchedRoutes.foundRoute.id, + fullPath: matchedRoutes.foundRoute.fullPath, + pathname: parsedLocation.pathname, + params: matchedRoutes.routeParams, + search: router.options.parseSearch(location.search) + }; + } + const current = getLocation(blockerFnArgs.currentLocation); + const next = getLocation(blockerFnArgs.nextLocation); + if (current.routeId === "__notFound__" && next.routeId !== "__notFound__") { + return false; + } + const shouldBlock = await shouldBlockFn({ + action: blockerFnArgs.action, + current, + next + }); + if (!withResolver) { + return shouldBlock; + } + if (!shouldBlock) { + return false; + } + const promise = new Promise((resolve) => { + setResolver({ + status: "blocked", + current, + next, + action: blockerFnArgs.action, + proceed: () => resolve(false), + reset: () => resolve(true) + }); + }); + const canNavigateAsync = await promise; + setResolver({ + status: "idle", + current: void 0, + next: void 0, + action: void 0, + proceed: void 0, + reset: void 0 + }); + return canNavigateAsync; + }; + return disabled ? void 0 : history.block({ blockerFn: blockerFnComposed, enableBeforeUnload }); + }, [ + shouldBlockFn, + enableBeforeUnload, + disabled, + withResolver, + history, + router + ]); + return resolver; +} +var _resolvePromptBlockerArgs = (props) => { + if ("shouldBlockFn" in props) { + return { ...props }; + } + const shouldBlock = Boolean(props.condition ?? true); + const fn = props.blockerFn; + const _customBlockerFn = async () => { + if (shouldBlock && fn !== void 0) { + return await fn(); + } + return shouldBlock; + }; + return { + shouldBlockFn: _customBlockerFn, + enableBeforeUnload: shouldBlock, + withResolver: fn === void 0 + }; +}; +function Block(opts) { + const { children, ...rest } = opts; + const args = _resolvePromptBlockerArgs(rest); + const resolver = useBlocker(args); + return children ? typeof children === "function" ? children(resolver) : children : null; +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useLocation.js +function useLocation(opts) { + return useRouterState({ + select: (state) => opts?.select ? opts.select(state.location) : state.location + }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useCanGoBack.js +function useCanGoBack() { + return useRouterState({ select: (s) => s.location.state.__TSR_index !== 0 }); +} + +// ../../../node_modules/.pnpm/@tanstack+react-router@1.166.4_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/Asset.js +var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1); +var React15 = __toESM(require_react(), 1); +function Asset({ + tag, + attrs, + children, + nonce +}) { + switch (tag) { + case "title": + return (0, import_jsx_runtime14.jsx)("title", { ...attrs, suppressHydrationWarning: true, children }); + case "meta": + return (0, import_jsx_runtime14.jsx)("meta", { ...attrs, suppressHydrationWarning: true }); + case "link": + return (0, import_jsx_runtime14.jsx)("link", { ...attrs, nonce, suppressHydrationWarning: true }); + case "style": + return (0, import_jsx_runtime14.jsx)( + "style", + { + ...attrs, + dangerouslySetInnerHTML: { __html: children }, + nonce + } + ); + case "script": + return (0, import_jsx_runtime14.jsx)(Script, { attrs, children }); + default: + return null; + } +} +function Script({ + attrs, + children +}) { + const router = useRouter(); + const hydrated = useHydrated(); + const dataScript = typeof attrs?.type === "string" && attrs.type !== "" && attrs.type !== "text/javascript" && attrs.type !== "module"; + if (attrs?.src && typeof children === "string" && children.trim().length) { + console.warn( + "[TanStack Router] \" and \"\\\" to avoid invalid escapes in the output.\n// http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4\nexport function serializeString(str: string): string {\n let result = '';\n let lastPos = 0;\n let replacement: string | undefined;\n for (let i = 0, len = str.length; i < len; i++) {\n replacement = serializeChar(str[i]);\n if (replacement) {\n result += str.slice(lastPos, i) + replacement;\n lastPos = i + 1;\n }\n }\n if (lastPos === 0) {\n result = str;\n } else {\n result += str.slice(lastPos);\n }\n return result;\n}\n\nfunction deserializeReplacer(str: string): string {\n switch (str) {\n case '\\\\\\\\':\n return '\\\\';\n case '\\\\\"':\n return '\"';\n case '\\\\n':\n return '\\n';\n case '\\\\r':\n return '\\r';\n case '\\\\b':\n return '\\b';\n case '\\\\t':\n return '\\t';\n case '\\\\f':\n return '\\f';\n case '\\\\x3C':\n return '\\x3C';\n case '\\\\u2028':\n return '\\u2028';\n case '\\\\u2029':\n return '\\u2029';\n default:\n return str;\n }\n}\n\nexport function deserializeString(str: string): string {\n return str.replace(\n /(\\\\\\\\|\\\\\"|\\\\n|\\\\r|\\\\b|\\\\t|\\\\f|\\\\u2028|\\\\u2029|\\\\x3C)/g,\n deserializeReplacer,\n );\n}\n", "import { serializeString } from './string';\n\n// Used for mapping isomorphic references\nexport const REFERENCES_KEY = '__SEROVAL_REFS__';\n\nexport const GLOBAL_CONTEXT_REFERENCES = '$R';\n\nconst GLOBAL_CONTEXT_R = `self.${GLOBAL_CONTEXT_REFERENCES}`;\n\nexport function getCrossReferenceHeader(id?: string): string {\n if (id == null) {\n return `${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||[]`;\n }\n return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})[\"${serializeString(\n id,\n )}\"]=[]`;\n}\n", "import {\n SerovalMissingReferenceError,\n SerovalMissingReferenceForIdError,\n} from '..';\nimport { REFERENCES_KEY } from './keys';\n\nconst REFERENCE = new Map();\nconst INV_REFERENCE = new Map();\n\nexport function createReference(id: string, value: T): T {\n REFERENCE.set(value, id);\n INV_REFERENCE.set(id, value);\n return value;\n}\n\nexport function hasReferenceID(value: T): boolean {\n return REFERENCE.has(value);\n}\n\nexport function hasReference(id: string): boolean {\n return INV_REFERENCE.has(id);\n}\n\nexport function getReferenceID(value: T): string {\n if (hasReferenceID(value)) {\n return REFERENCE.get(value)!;\n }\n throw new SerovalMissingReferenceError(value);\n}\n\nexport function getReference(id: string): T {\n if (hasReference(id)) {\n return INV_REFERENCE.get(id) as T;\n }\n throw new SerovalMissingReferenceForIdError(id);\n}\n\nif (typeof globalThis !== 'undefined') {\n Object.defineProperty(globalThis, REFERENCES_KEY, {\n value: INV_REFERENCE,\n configurable: true,\n writable: false,\n enumerable: false,\n });\n} else if (typeof window !== 'undefined') {\n Object.defineProperty(window, REFERENCES_KEY, {\n value: INV_REFERENCE,\n configurable: true,\n writable: false,\n enumerable: false,\n });\n} else if (typeof self !== 'undefined') {\n Object.defineProperty(self, REFERENCES_KEY, {\n value: INV_REFERENCE,\n configurable: true,\n writable: false,\n enumerable: false,\n });\n} else if (typeof global !== 'undefined') {\n Object.defineProperty(global, REFERENCES_KEY, {\n value: INV_REFERENCE,\n configurable: true,\n writable: false,\n enumerable: false,\n });\n}\n", "import { Feature } from '../compat';\nimport { ERROR_CONSTRUCTOR_STRING, ErrorConstructorTag } from '../constants';\n\ntype ErrorValue =\n | Error\n | AggregateError\n | EvalError\n | RangeError\n | ReferenceError\n | TypeError\n | SyntaxError\n | URIError;\n\nexport function getErrorConstructor(error: ErrorValue): ErrorConstructorTag {\n if (error instanceof EvalError) {\n return ErrorConstructorTag.EvalError;\n }\n if (error instanceof RangeError) {\n return ErrorConstructorTag.RangeError;\n }\n if (error instanceof ReferenceError) {\n return ErrorConstructorTag.ReferenceError;\n }\n if (error instanceof SyntaxError) {\n return ErrorConstructorTag.SyntaxError;\n }\n if (error instanceof TypeError) {\n return ErrorConstructorTag.TypeError;\n }\n if (error instanceof URIError) {\n return ErrorConstructorTag.URIError;\n }\n return ErrorConstructorTag.Error;\n}\n\nfunction getInitialErrorOptions(\n error: Error,\n): Record | undefined {\n const construct = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];\n // Name has been modified\n if (error.name !== construct) {\n return { name: error.name };\n }\n if (error.constructor.name !== construct) {\n // Otherwise, name is overriden because\n // the Error class is extended\n return { name: error.constructor.name };\n }\n return {};\n}\n\nexport function getErrorOptions(\n error: Error,\n features: number,\n): Record | undefined {\n let options = getInitialErrorOptions(error);\n const names = Object.getOwnPropertyNames(error);\n for (let i = 0, len = names.length, name: string; i < len; i++) {\n name = names[i];\n if (name !== 'name' && name !== 'message') {\n if (name === 'stack') {\n if (features & Feature.ErrorPrototypeStack) {\n options = options || {};\n options[name] = error[name as keyof Error];\n }\n } else {\n options = options || {};\n options[name] = error[name as keyof Error];\n }\n }\n }\n return options;\n}\n", "import { SerovalObjectFlags } from '../constants';\n\nexport function getObjectFlag(obj: unknown): SerovalObjectFlags {\n if (Object.isFrozen(obj)) {\n return SerovalObjectFlags.Frozen;\n }\n if (Object.isSealed(obj)) {\n return SerovalObjectFlags.Sealed;\n }\n if (Object.isExtensible(obj)) {\n return SerovalObjectFlags.None;\n }\n return SerovalObjectFlags.NonExtensible;\n}\n", "import type { WellKnownSymbols } from './constants';\nimport { INV_SYMBOL_REF, NIL, SerovalNodeType } from './constants';\nimport {\n INFINITY_NODE,\n NAN_NODE,\n NEG_INFINITY_NODE,\n NEG_ZERO_NODE,\n} from './literals';\nimport { createSerovalNode } from './node';\nimport { getReferenceID } from './reference';\nimport { serializeString } from './string';\nimport type {\n SerovalAggregateErrorNode,\n SerovalArrayNode,\n SerovalAsyncIteratorFactoryInstanceNode,\n SerovalBigIntNode,\n SerovalBigIntTypedArrayNode,\n SerovalBoxedNode,\n SerovalConstantNode,\n SerovalDataViewNode,\n SerovalDateNode,\n SerovalErrorNode,\n SerovalIndexedValueNode,\n SerovalIteratorFactoryInstanceNode,\n SerovalNode,\n SerovalNodeWithID,\n SerovalNumberNode,\n SerovalObjectRecordNode,\n SerovalPluginNode,\n SerovalReferenceNode,\n SerovalRegExpNode,\n SerovalSequenceNode,\n SerovalSetNode,\n SerovalStreamConstructorNode,\n SerovalStreamNextNode,\n SerovalStreamReturnNode,\n SerovalStreamThrowNode,\n SerovalStringNode,\n SerovalTypedArrayNode,\n SerovalWKSymbolNode,\n} from './types';\nimport { getErrorConstructor } from './utils/error';\nimport { getObjectFlag } from './utils/get-object-flag';\nimport type {\n BigIntTypedArrayValue,\n TypedArrayValue,\n} from './utils/typed-array';\n\nexport function createNumberNode(\n value: number,\n): SerovalConstantNode | SerovalNumberNode {\n switch (value) {\n case Number.POSITIVE_INFINITY:\n return INFINITY_NODE;\n case Number.NEGATIVE_INFINITY:\n return NEG_INFINITY_NODE;\n }\n if (value !== value) {\n return NAN_NODE;\n }\n if (Object.is(value, -0)) {\n return NEG_ZERO_NODE;\n }\n return createSerovalNode(\n SerovalNodeType.Number,\n NIL,\n value,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createStringNode(value: string): SerovalStringNode {\n return createSerovalNode(\n SerovalNodeType.String,\n NIL,\n serializeString(value),\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createBigIntNode(current: bigint): SerovalBigIntNode {\n return createSerovalNode(\n SerovalNodeType.BigInt,\n NIL,\n '' + current,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createIndexedValueNode(id: number): SerovalIndexedValueNode {\n return createSerovalNode(\n SerovalNodeType.IndexedValue,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createDateNode(id: number, current: Date): SerovalDateNode {\n const timestamp = current.valueOf();\n return createSerovalNode(\n SerovalNodeType.Date,\n id,\n timestamp !== timestamp ? '' : current.toISOString(),\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createRegExpNode(\n id: number,\n current: RegExp,\n): SerovalRegExpNode {\n return createSerovalNode(\n SerovalNodeType.RegExp,\n id,\n NIL,\n serializeString(current.source),\n current.flags,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createWKSymbolNode(\n id: number,\n current: WellKnownSymbols,\n): SerovalWKSymbolNode {\n return createSerovalNode(\n SerovalNodeType.WKSymbol,\n id,\n INV_SYMBOL_REF[current],\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createReferenceNode(\n id: number,\n ref: T,\n): SerovalReferenceNode {\n return createSerovalNode(\n SerovalNodeType.Reference,\n id,\n serializeString(getReferenceID(ref)),\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createPluginNode(\n id: number,\n tag: string,\n value: Record,\n): SerovalPluginNode {\n return createSerovalNode(\n SerovalNodeType.Plugin,\n id,\n value,\n serializeString(tag),\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createArrayNode(\n id: number,\n current: unknown[],\n parsedItems: SerovalArrayNode['a'],\n): SerovalArrayNode {\n return createSerovalNode(\n SerovalNodeType.Array,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parsedItems,\n NIL,\n NIL,\n getObjectFlag(current),\n NIL,\n );\n}\n\nexport function createBoxedNode(\n id: number,\n boxed: SerovalNode,\n): SerovalBoxedNode {\n return createSerovalNode(\n SerovalNodeType.Boxed,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n boxed,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createTypedArrayNode(\n id: number,\n current: TypedArrayValue,\n buffer: SerovalNode,\n): SerovalTypedArrayNode {\n return createSerovalNode(\n SerovalNodeType.TypedArray,\n id,\n NIL,\n current.constructor.name,\n NIL,\n NIL,\n NIL,\n NIL,\n buffer,\n current.byteOffset,\n NIL,\n current.length,\n );\n}\n\nexport function createBigIntTypedArrayNode(\n id: number,\n current: BigIntTypedArrayValue,\n buffer: SerovalNode,\n): SerovalBigIntTypedArrayNode {\n return createSerovalNode(\n SerovalNodeType.BigIntTypedArray,\n id,\n NIL,\n current.constructor.name,\n NIL,\n NIL,\n NIL,\n NIL,\n buffer,\n current.byteOffset,\n NIL,\n current.byteLength,\n );\n}\n\nexport function createDataViewNode(\n id: number,\n current: DataView,\n buffer: SerovalNode,\n): SerovalDataViewNode {\n return createSerovalNode(\n SerovalNodeType.DataView,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n buffer,\n current.byteOffset,\n NIL,\n current.byteLength,\n );\n}\n\nexport function createErrorNode(\n id: number,\n current: Error,\n options: SerovalObjectRecordNode | undefined,\n): SerovalErrorNode {\n return createSerovalNode(\n SerovalNodeType.Error,\n id,\n getErrorConstructor(current),\n NIL,\n serializeString(current.message),\n options,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createAggregateErrorNode(\n id: number,\n current: AggregateError,\n options: SerovalObjectRecordNode | undefined,\n): SerovalAggregateErrorNode {\n return createSerovalNode(\n SerovalNodeType.AggregateError,\n id,\n getErrorConstructor(current),\n NIL,\n serializeString(current.message),\n options,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createSetNode(\n id: number,\n items: SerovalNode[],\n): SerovalSetNode {\n return createSerovalNode(\n SerovalNodeType.Set,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n items,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createIteratorFactoryInstanceNode(\n factory: SerovalNodeWithID,\n items: SerovalNodeWithID,\n): SerovalIteratorFactoryInstanceNode {\n return createSerovalNode(\n SerovalNodeType.IteratorFactoryInstance,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n [factory, items],\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createAsyncIteratorFactoryInstanceNode(\n factory: SerovalNodeWithID,\n items: SerovalNodeWithID,\n): SerovalAsyncIteratorFactoryInstanceNode {\n return createSerovalNode(\n SerovalNodeType.AsyncIteratorFactoryInstance,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n [factory, items],\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createStreamConstructorNode(\n id: number,\n factory: SerovalNodeWithID,\n sequence: SerovalNode[],\n): SerovalStreamConstructorNode {\n return createSerovalNode(\n SerovalNodeType.StreamConstructor,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n sequence,\n factory,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createStreamNextNode(\n id: number,\n parsed: SerovalNode,\n): SerovalStreamNextNode {\n return createSerovalNode(\n SerovalNodeType.StreamNext,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parsed,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createStreamThrowNode(\n id: number,\n parsed: SerovalNode,\n): SerovalStreamThrowNode {\n return createSerovalNode(\n SerovalNodeType.StreamThrow,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parsed,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createStreamReturnNode(\n id: number,\n parsed: SerovalNode,\n): SerovalStreamReturnNode {\n return createSerovalNode(\n SerovalNodeType.StreamReturn,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parsed,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createSequenceNode(\n id: number,\n sequence: SerovalNode[],\n throwAt: number,\n doneAt: number,\n): SerovalSequenceNode {\n return createSerovalNode(\n SerovalNodeType.Sequence,\n id,\n throwAt,\n NIL,\n NIL,\n NIL,\n NIL,\n sequence,\n NIL,\n NIL,\n NIL,\n doneAt,\n );\n}\n", "/// \n\nimport { serializeString } from './string';\nimport type { SerovalNode } from './types';\n\nconst { toString: objectToString } = /* @__PURE__ */ Object.prototype;\n\nconst enum StepErrorCodes {\n Parse = 1,\n Serialize = 2,\n Deserialize = 3,\n}\n\nfunction getErrorMessageDev(type: string, cause: unknown): string {\n if (cause instanceof Error) {\n return `Seroval caught an error during the ${type} process.\n\n${cause.name}\n${cause.message}\n\n- For more information, please check the \"cause\" property of this error.\n- If you believe this is an error in Seroval, please submit an issue at https://github.com/lxsmnsyc/seroval/issues/new`;\n }\n return `Seroval caught an error during the ${type} process.\n\n\"${objectToString.call(cause)}\"\n\nFor more information, please check the \"cause\" property of this error.`;\n}\n\nconst STEP_ERROR_CODES: Record = {\n parsing: StepErrorCodes.Parse,\n serialization: StepErrorCodes.Serialize,\n deserialization: StepErrorCodes.Deserialize,\n};\n\nfunction getErrorMessageProd(type: string): string {\n return `Seroval Error (step: ${STEP_ERROR_CODES[type]})`;\n}\n\nconst getErrorMessage = (type: string, cause: any) =>\n import.meta.env.PROD\n ? getErrorMessageProd(type)\n : getErrorMessageDev(type, cause);\n\nexport class SerovalError extends Error {\n constructor(\n type: string,\n public cause: unknown,\n ) {\n super(getErrorMessage(type, cause));\n }\n}\n\nexport class SerovalParserError extends SerovalError {\n constructor(cause: unknown) {\n super('parsing', cause);\n }\n}\n\nexport class SerovalSerializationError extends SerovalError {\n constructor(cause: unknown) {\n super('serialization', cause);\n }\n}\n\nexport class SerovalDeserializationError extends SerovalError {\n constructor(cause: unknown) {\n super('deserialization', cause);\n }\n}\n\nconst enum SpecificErrorCodes {\n UnsupportedType = 1,\n UnsupportedNode = 2,\n MissingPlugin = 3,\n MissingInstance = 4,\n MissingReference = 5,\n MissingReferenceForId = 6,\n UnknownTypedArray = 7,\n MalformedNode = 8,\n ConflictedNodeId = 9,\n DepthLimit = 10,\n}\n\nfunction getSpecificErrorMessage(code: SpecificErrorCodes): string {\n return `Seroval Error (specific: ${code})`;\n}\n\nexport class SerovalUnsupportedTypeError extends Error {\n constructor(public value: unknown) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.UnsupportedType)\n : `The value ${objectToString.call(value)} of type \"${typeof value}\" cannot be parsed/serialized.\n \nThere are few workarounds for this problem:\n- Transform the value in a way that it can be serialized.\n- If the reference is present on multiple runtimes (isomorphic), you can use the Reference API to map the references.`,\n );\n }\n}\n\nexport class SerovalUnsupportedNodeError extends Error {\n constructor(node: SerovalNode) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.UnsupportedNode)\n : 'Unsupported node type \"' + node.t + '\".',\n );\n }\n}\n\nexport class SerovalMissingPluginError extends Error {\n constructor(tag: string) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.MissingPlugin)\n : 'Missing plugin for tag \"' + tag + '\".',\n );\n }\n}\n\nexport class SerovalMissingInstanceError extends Error {\n constructor(tag: string) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.MissingInstance)\n : 'Missing \"' + tag + '\" instance.',\n );\n }\n}\n\nexport class SerovalMissingReferenceError extends Error {\n constructor(public value: unknown) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.MissingReference)\n : 'Missing reference for the value \"' +\n objectToString.call(value) +\n '\" of type \"' +\n typeof value +\n '\"',\n );\n }\n}\n\nexport class SerovalMissingReferenceForIdError extends Error {\n constructor(id: string) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.MissingReferenceForId)\n : 'Missing reference for id \"' + serializeString(id) + '\"',\n );\n }\n}\n\nexport class SerovalUnknownTypedArrayError extends Error {\n constructor(name: string) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.UnknownTypedArray)\n : 'Unknown TypedArray \"' + name + '\"',\n );\n }\n}\n\nexport class SerovalMalformedNodeError extends Error {\n constructor(node: SerovalNode) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.MalformedNode)\n : 'Malformed node type \"' + node.t + '\".',\n );\n }\n}\n\nexport class SerovalConflictedNodeIdError extends Error {\n constructor(node: SerovalNode) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.ConflictedNodeId)\n : 'Conflicted node id \"' + node.i + '\".',\n );\n }\n}\n\nexport class SerovalDepthLimitError extends Error {\n constructor(limit: number) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.ConflictedNodeId)\n : 'Depth limit of ' + limit + ' reached',\n );\n }\n}\n", "/**\n * An opaque reference allows hiding values from the serializer.\n */\nexport class OpaqueReference {\n constructor(\n public readonly value: V,\n public readonly replacement?: R,\n ) {}\n}\n", "import { Sequence } from './sequence';\nimport type { Stream } from './stream';\n\ntype SpecialPromise = Promise & { s?: 1 | 2; v?: unknown };\n\nexport interface PromiseConstructorResolver {\n p: SpecialPromise;\n s: (value: unknown) => void;\n f: (value: unknown) => void;\n}\n\nexport const PROMISE_CONSTRUCTOR = (): PromiseConstructorResolver => {\n const resolver = {\n p: 0,\n s: 0,\n f: 0,\n } as unknown as PromiseConstructorResolver;\n resolver.p = new Promise((resolve, reject) => {\n resolver.s = resolve;\n resolver.f = reject;\n });\n return resolver;\n};\n\nexport const PROMISE_SUCCESS = (\n resolver: PromiseConstructorResolver,\n data: unknown,\n): void => {\n resolver.s(data);\n resolver.p.s = 1;\n resolver.p.v = data;\n};\n\nexport const PROMISE_FAILURE = (\n resolver: PromiseConstructorResolver,\n data: unknown,\n): void => {\n resolver.f(data);\n resolver.p.s = 2;\n resolver.p.v = data;\n};\n\nexport const SERIALIZED_PROMISE_CONSTRUCTOR =\n /* @__PURE__ */ PROMISE_CONSTRUCTOR.toString();\nexport const SERIALIZED_PROMISE_SUCCESS =\n /* @__PURE__ */ PROMISE_SUCCESS.toString();\nexport const SERIALIZED_PROMISE_FAILURE =\n /* @__PURE__ */ PROMISE_FAILURE.toString();\n\ninterface StreamListener {\n next(value: T): void;\n throw(value: unknown): void;\n return(value: T): void;\n}\n\nexport const STREAM_CONSTRUCTOR = () => {\n const buffer: unknown[] = [];\n const listeners: StreamListener[] = [];\n let alive = true;\n let success = false;\n let count = 0;\n const flush = (\n value: unknown,\n mode: keyof StreamListener,\n x?: number,\n ) => {\n for (x = 0; x < count; x++) {\n if (listeners[x]) {\n listeners[x][mode](value);\n }\n }\n };\n const up = (\n listener: StreamListener,\n x?: number,\n z?: number,\n current?: unknown,\n ) => {\n for (x = 0, z = buffer.length; x < z; x++) {\n current = buffer[x];\n if (!alive && x === z - 1) {\n listener[success ? 'return' : 'throw'](current);\n } else {\n listener.next(current);\n }\n }\n };\n const on = (listener: StreamListener, temp?: number) => {\n if (alive) {\n temp = count++;\n listeners[temp] = listener;\n }\n up(listener);\n return () => {\n if (alive) {\n listeners[temp!] = listeners[count];\n listeners[count--] = undefined as any;\n }\n };\n };\n return {\n __SEROVAL_STREAM__: true,\n on: (listener: StreamListener) => on(listener),\n next: (value: unknown) => {\n if (alive) {\n buffer.push(value);\n flush(value, 'next');\n }\n },\n throw: (value: unknown) => {\n if (alive) {\n buffer.push(value);\n flush(value, 'throw');\n alive = false;\n success = false;\n listeners.length = 0;\n }\n },\n return: (value: unknown) => {\n if (alive) {\n buffer.push(value);\n flush(value, 'return');\n alive = false;\n success = true;\n listeners.length = 0;\n }\n },\n };\n};\n\nexport const SERIALIZED_STREAM_CONSTRUCTOR =\n /* @__PURE__ */ STREAM_CONSTRUCTOR.toString();\n\nexport const ITERATOR_CONSTRUCTOR =\n (symbol: symbol) => (sequence: Sequence) => () => {\n let index = 0;\n const instance = {\n [symbol]: () => instance,\n next: () => {\n if (index > sequence.d) {\n return {\n done: true,\n value: undefined,\n };\n }\n const currentIndex = index++;\n const data = sequence.v[currentIndex];\n if (currentIndex === sequence.t) {\n throw data;\n }\n return {\n done: currentIndex === sequence.d,\n value: data,\n };\n },\n };\n return instance;\n };\n\nexport const SERIALIZED_ITERATOR_CONSTRUCTOR =\n /* @__PURE__ */ ITERATOR_CONSTRUCTOR.toString();\n\nexport const ASYNC_ITERATOR_CONSTRUCTOR =\n (symbol: symbol, createPromise: typeof PROMISE_CONSTRUCTOR) =>\n (stream: Stream) =>\n () => {\n let count = 0;\n let doneAt = -1;\n let isThrow = false;\n const buffer: unknown[] = [];\n const pending: PromiseConstructorResolver[] = [];\n const finalize = (i = 0, len = pending.length) => {\n for (; i < len; i++) {\n pending[i].s({\n done: true,\n value: undefined,\n });\n }\n };\n stream.on({\n next: value => {\n const temp = pending.shift();\n if (temp) {\n temp.s({ done: false, value });\n }\n buffer.push(value);\n },\n throw: value => {\n const temp = pending.shift();\n if (temp) {\n temp.f(value);\n }\n finalize();\n doneAt = buffer.length;\n isThrow = true;\n buffer.push(value);\n },\n return: value => {\n const temp = pending.shift();\n if (temp) {\n temp.s({ done: true, value });\n }\n finalize();\n doneAt = buffer.length;\n buffer.push(value);\n },\n });\n\n const instance = {\n [symbol]: () => instance,\n next: () => {\n if (doneAt === -1) {\n const index = count++;\n if (index >= buffer.length) {\n const temp = createPromise();\n pending.push(temp);\n return temp.p;\n }\n return {\n done: false,\n value: buffer[index],\n };\n }\n if (count > doneAt) {\n return {\n done: true,\n value: undefined,\n };\n }\n const index = count++;\n const value = buffer[index];\n if (index !== doneAt) {\n return {\n done: false,\n value,\n };\n }\n if (isThrow) {\n throw value;\n }\n return {\n done: true,\n value,\n };\n },\n };\n\n return instance;\n };\n\nexport const SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR =\n /* @__PURE__ */ ASYNC_ITERATOR_CONSTRUCTOR.toString();\n\nexport const ARRAY_BUFFER_CONSTRUCTOR = (b64: string) => {\n const decoded = atob(b64);\n const length = decoded.length;\n const arr = new Uint8Array(length);\n for (let i = 0; i < length; i++) {\n arr[i] = decoded.charCodeAt(i);\n }\n return arr.buffer;\n};\n\nexport const SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR =\n /* @__PURE__ */ ARRAY_BUFFER_CONSTRUCTOR.toString();\n", "import { ITERATOR_CONSTRUCTOR } from \"./constructors\";\nimport { SYM_ITERATOR } from \"./symbols\";\n\nexport interface Sequence {\n __SEROVAL_SEQUENCE__: true;\n\n v: unknown[];\n t: number;\n d: number;\n}\n\nexport function isSequence(value: object): value is Sequence {\n return '__SEROVAL_SEQUENCE__' in value;\n}\n\nexport function createSequence(values: unknown[], throwAt: number, doneAt: number): Sequence {\n return {\n __SEROVAL_SEQUENCE__: true,\n\n v: values,\n t: throwAt,\n d: doneAt,\n };\n}\n\nexport function createSequenceFromIterable(source: Iterable): Sequence {\n const values: unknown[] = [];\n let throwsAt = -1;\n let doneAt = -1;\n const iterator = source[SYM_ITERATOR]();\n\n while (true) {\n try {\n const value = iterator.next();\n values.push(value.value);\n if (value.done) {\n doneAt = values.length - 1;\n break;\n }\n } catch (error) {\n throwsAt = values.length;\n values.push(error);\n }\n }\n\n return createSequence(values, throwsAt, doneAt);\n}\n\nconst createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR);\n\nexport function sequenceToIterator(\n sequence: Sequence,\n): () => IterableIterator {\n return createIterator(sequence) as unknown as () => IterableIterator;\n}\n", "import {\n SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,\n SERIALIZED_PROMISE_CONSTRUCTOR,\n SERIALIZED_PROMISE_FAILURE,\n SERIALIZED_PROMISE_SUCCESS,\n SERIALIZED_STREAM_CONSTRUCTOR,\n} from './constructors';\n\nexport const ITERATOR = {};\n\nexport const ASYNC_ITERATOR = {};\n\nexport const enum SpecialReference {\n MapSentinel = 0,\n PromiseConstructor = 1,\n PromiseSuccess = 2,\n PromiseFailure = 3,\n StreamConstructor = 4,\n ArrayBufferConstructor = 5,\n}\n\n/**\n * Placeholder references\n */\nexport const SPECIAL_REFS: Record = {\n [SpecialReference.MapSentinel]: {},\n [SpecialReference.PromiseConstructor]: {},\n [SpecialReference.PromiseSuccess]: {},\n [SpecialReference.PromiseFailure]: {},\n [SpecialReference.StreamConstructor]: {},\n [SpecialReference.ArrayBufferConstructor]: {},\n};\n\nexport const SPECIAL_REF_STRING: Record = {\n [SpecialReference.MapSentinel]: '[]',\n [SpecialReference.PromiseConstructor]: SERIALIZED_PROMISE_CONSTRUCTOR,\n [SpecialReference.PromiseSuccess]: SERIALIZED_PROMISE_SUCCESS,\n [SpecialReference.PromiseFailure]: SERIALIZED_PROMISE_FAILURE,\n [SpecialReference.StreamConstructor]: SERIALIZED_STREAM_CONSTRUCTOR,\n [SpecialReference.ArrayBufferConstructor]:\n SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,\n};\n", "import {\n ASYNC_ITERATOR_CONSTRUCTOR,\n PROMISE_CONSTRUCTOR,\n STREAM_CONSTRUCTOR,\n} from './constructors';\nimport { SYM_ASYNC_ITERATOR } from './symbols';\n\nexport interface StreamListener {\n next(value: T): void;\n throw(value: unknown): void;\n return(value: T): void;\n}\n\nexport interface Stream {\n __SEROVAL_STREAM__: true;\n\n on(listener: StreamListener): () => void;\n\n next(value: T): void;\n throw(value: unknown): void;\n return(value: T): void;\n}\n\nexport function isStream(value: object): value is Stream {\n return '__SEROVAL_STREAM__' in value;\n}\n\nexport function createStream(): Stream {\n return STREAM_CONSTRUCTOR() as unknown as Stream;\n}\n\nexport function createStreamFromAsyncIterable(\n iterable: AsyncIterable,\n): Stream {\n const stream = createStream();\n\n const iterator = iterable[SYM_ASYNC_ITERATOR]();\n\n async function push(): Promise {\n try {\n const value = await iterator.next();\n if (value.done) {\n stream.return(value.value as T);\n } else {\n stream.next(value.value);\n await push();\n }\n } catch (error) {\n stream.throw(error);\n }\n }\n\n push().catch(() => {\n // no-op\n });\n\n return stream;\n}\n\nconst createAsyncIterable = ASYNC_ITERATOR_CONSTRUCTOR(\n SYM_ASYNC_ITERATOR,\n PROMISE_CONSTRUCTOR,\n);\n\nexport function streamToAsyncIterable(\n stream: Stream,\n): () => AsyncIterableIterator {\n return createAsyncIterable(\n stream,\n ) as unknown as () => AsyncIterableIterator;\n}\n", "export default async function promiseToResult(\n current: Promise,\n): Promise<[0 | 1, unknown]> {\n try {\n return [1, await current];\n } catch (e) {\n return [0, e];\n }\n}\n", "import {\n createIndexedValueNode,\n createReferenceNode,\n createWKSymbolNode,\n} from '../base-primitives';\nimport { ALL_ENABLED } from '../compat';\nimport type { WellKnownSymbols } from '../constants';\nimport { INV_SYMBOL_REF, NIL, SerovalNodeType } from '../constants';\nimport { SerovalUnsupportedTypeError } from '../errors';\nimport { createSerovalNode } from '../node';\nimport type { PluginAccessOptions, SerovalMode } from '../plugin';\nimport { hasReferenceID } from '../reference';\nimport {\n ASYNC_ITERATOR,\n ITERATOR,\n SPECIAL_REFS,\n SpecialReference,\n} from '../special-reference';\nimport { serializeString } from '../string';\nimport { SYM_ASYNC_ITERATOR, SYM_ITERATOR } from '../symbols';\nimport type {\n SerovalArrayBufferNode,\n SerovalAsyncIteratorFactoryNode,\n SerovalIndexedValueNode,\n SerovalIteratorFactoryNode,\n SerovalMapNode,\n SerovalNode,\n SerovalNullConstructorNode,\n SerovalObjectNode,\n SerovalObjectRecordNode,\n SerovalPromiseConstructorNode,\n SerovalReferenceNode,\n SerovalSpecialReferenceNode,\n SerovalWKSymbolNode,\n} from '../types';\nimport { getObjectFlag } from '../utils/get-object-flag';\n\nexport interface BaseParserContextOptions extends PluginAccessOptions {\n disabledFeatures?: number;\n refs?: Map;\n depthLimit?: number;\n}\n\nexport const enum ParserNodeType {\n Fresh = 0,\n Indexed = 1,\n Referenced = 2,\n}\n\nexport interface FreshNode {\n type: ParserNodeType.Fresh;\n value: number;\n}\n\nexport interface IndexedNode {\n type: ParserNodeType.Indexed;\n value: SerovalIndexedValueNode;\n}\n\nexport interface ReferencedNode {\n type: ParserNodeType.Referenced;\n value: SerovalReferenceNode;\n}\n\ntype ObjectNode = FreshNode | IndexedNode | ReferencedNode;\n\nexport interface BaseParserContext extends PluginAccessOptions {\n readonly mode: SerovalMode;\n\n marked: Set;\n\n refs: Map;\n\n features: number;\n\n depthLimit: number;\n}\n\nexport function createBaseParserContext(\n mode: SerovalMode,\n options: BaseParserContextOptions,\n): BaseParserContext {\n return {\n plugins: options.plugins,\n mode,\n marked: new Set(),\n features: ALL_ENABLED ^ (options.disabledFeatures || 0),\n refs: options.refs || new Map(),\n depthLimit: options.depthLimit || 1000,\n };\n}\n\n/**\n * Ensures that the value (based on an identifier) has been visited by the parser.\n * @param ctx\n * @param id\n */\nexport function markParserRef(ctx: BaseParserContext, id: number): void {\n ctx.marked.add(id);\n}\n\nexport function isParserRefMarked(ctx: BaseParserContext, id: number): boolean {\n return ctx.marked.has(id);\n}\n\n/**\n * Creates an identifier for a value\n * @param ctx\n * @param current\n */\nexport function createIndexForValue(\n ctx: BaseParserContext,\n current: T,\n): number {\n const id = ctx.refs.size;\n ctx.refs.set(current, id);\n return id;\n}\n\nexport function getNodeForIndexedValue(\n ctx: BaseParserContext,\n current: T,\n): FreshNode | IndexedNode {\n const registeredId = ctx.refs.get(current);\n if (registeredId != null) {\n markParserRef(ctx, registeredId);\n return {\n type: ParserNodeType.Indexed,\n value: createIndexedValueNode(registeredId),\n };\n }\n return {\n type: ParserNodeType.Fresh,\n value: createIndexForValue(ctx, current),\n };\n}\n\nexport function getReferenceNode(\n ctx: BaseParserContext,\n current: T,\n): ObjectNode {\n const indexed = getNodeForIndexedValue(ctx, current);\n if (indexed.type === ParserNodeType.Indexed) {\n return indexed;\n }\n // Special references are special ;)\n if (hasReferenceID(current)) {\n return {\n type: ParserNodeType.Referenced,\n value: createReferenceNode(indexed.value, current),\n };\n }\n return indexed;\n}\n\n/**\n * Parsing methods\n */\nexport function parseWellKnownSymbol(\n ctx: BaseParserContext,\n current: symbol,\n): SerovalIndexedValueNode | SerovalWKSymbolNode | SerovalReferenceNode {\n const ref = getReferenceNode(ctx, current);\n if (ref.type !== ParserNodeType.Fresh) {\n return ref.value;\n }\n if (current in INV_SYMBOL_REF) {\n return createWKSymbolNode(ref.value, current as WellKnownSymbols);\n }\n throw new SerovalUnsupportedTypeError(current);\n}\n\nexport function parseSpecialReference(\n ctx: BaseParserContext,\n ref: SpecialReference,\n): SerovalIndexedValueNode | SerovalSpecialReferenceNode {\n const result = getNodeForIndexedValue(ctx, SPECIAL_REFS[ref]);\n if (result.type === ParserNodeType.Indexed) {\n return result.value;\n }\n return createSerovalNode(\n SerovalNodeType.SpecialReference,\n result.value,\n ref,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function parseIteratorFactory(\n ctx: BaseParserContext,\n): SerovalIndexedValueNode | SerovalIteratorFactoryNode {\n const result = getNodeForIndexedValue(ctx, ITERATOR);\n if (result.type === ParserNodeType.Indexed) {\n return result.value;\n }\n return createSerovalNode(\n SerovalNodeType.IteratorFactory,\n result.value,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parseWellKnownSymbol(ctx, SYM_ITERATOR),\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function parseAsyncIteratorFactory(\n ctx: BaseParserContext,\n): SerovalIndexedValueNode | SerovalAsyncIteratorFactoryNode {\n const result = getNodeForIndexedValue(ctx, ASYNC_ITERATOR);\n if (result.type === ParserNodeType.Indexed) {\n return result.value;\n }\n return createSerovalNode(\n SerovalNodeType.AsyncIteratorFactory,\n result.value,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n [\n parseSpecialReference(ctx, SpecialReference.PromiseConstructor),\n parseWellKnownSymbol(ctx, SYM_ASYNC_ITERATOR),\n ],\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createObjectNode(\n id: number,\n current: Record,\n empty: boolean,\n record: SerovalObjectRecordNode,\n): SerovalObjectNode | SerovalNullConstructorNode {\n return createSerovalNode(\n empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,\n id,\n NIL,\n NIL,\n NIL,\n record,\n NIL,\n NIL,\n NIL,\n NIL,\n getObjectFlag(current),\n NIL,\n );\n}\n\nexport function createMapNode(\n ctx: BaseParserContext,\n id: number,\n k: SerovalNode[],\n v: SerovalNode[],\n): SerovalMapNode {\n return createSerovalNode(\n SerovalNodeType.Map,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n { k, v },\n NIL,\n parseSpecialReference(ctx, SpecialReference.MapSentinel),\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createPromiseConstructorNode(\n ctx: BaseParserContext,\n id: number,\n resolver: number,\n): SerovalPromiseConstructorNode {\n return createSerovalNode(\n SerovalNodeType.PromiseConstructor,\n id,\n resolver,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parseSpecialReference(ctx, SpecialReference.PromiseConstructor),\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createArrayBufferNode(\n ctx: BaseParserContext,\n id: number,\n current: ArrayBuffer,\n): SerovalArrayBufferNode {\n const bytes = new Uint8Array(current);\n let result = '';\n for (let i = 0, len = bytes.length; i < len; i++) {\n result += String.fromCharCode(bytes[i]);\n }\n return createSerovalNode(\n SerovalNodeType.ArrayBuffer,\n id,\n serializeString(btoa(result)),\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parseSpecialReference(ctx, SpecialReference.ArrayBufferConstructor),\n NIL,\n NIL,\n NIL,\n );\n}\n", "import {\n createAggregateErrorNode,\n createArrayNode,\n createAsyncIteratorFactoryInstanceNode,\n createBigIntNode,\n createBigIntTypedArrayNode,\n createBoxedNode,\n createDataViewNode,\n createDateNode,\n createErrorNode,\n createIteratorFactoryInstanceNode,\n createNumberNode,\n createPluginNode,\n createRegExpNode,\n createSequenceNode,\n createSetNode,\n createStreamConstructorNode,\n createStreamNextNode,\n createStreamReturnNode,\n createStreamThrowNode,\n createStringNode,\n createTypedArrayNode,\n} from '../base-primitives';\nimport { Feature } from '../compat';\nimport { NIL, SerovalNodeType } from '../constants';\nimport { SerovalParserError, SerovalUnsupportedTypeError } from '../errors';\nimport { FALSE_NODE, NULL_NODE, TRUE_NODE, UNDEFINED_NODE } from '../literals';\nimport { createSerovalNode } from '../node';\nimport { OpaqueReference } from '../opaque-reference';\nimport type { SerovalMode } from '../plugin';\nimport {\n createSequenceFromIterable,\n isSequence,\n type Sequence,\n} from '../sequence';\nimport { SpecialReference } from '../special-reference';\nimport type { Stream } from '../stream';\nimport { createStreamFromAsyncIterable, isStream } from '../stream';\nimport { serializeString } from '../string';\nimport {\n SYM_ASYNC_ITERATOR,\n SYM_IS_CONCAT_SPREADABLE,\n SYM_ITERATOR,\n SYM_TO_STRING_TAG,\n} from '../symbols';\nimport type {\n SerovalAggregateErrorNode,\n SerovalArrayNode,\n SerovalBigIntTypedArrayNode,\n SerovalBoxedNode,\n SerovalDataViewNode,\n SerovalErrorNode,\n SerovalMapNode,\n SerovalNode,\n SerovalNodeWithID,\n SerovalNullConstructorNode,\n SerovalObjectNode,\n SerovalObjectRecordKey,\n SerovalObjectRecordNode,\n SerovalPluginNode,\n SerovalPromiseNode,\n SerovalSequenceNode,\n SerovalSetNode,\n SerovalStreamConstructorNode,\n SerovalTypedArrayNode,\n} from '../types';\nimport { getErrorOptions } from '../utils/error';\nimport promiseToResult from '../utils/promise-to-result';\nimport type {\n BigIntTypedArrayValue,\n TypedArrayValue,\n} from '../utils/typed-array';\nimport type { BaseParserContext, BaseParserContextOptions } from './parser';\nimport {\n createArrayBufferNode,\n createBaseParserContext,\n createMapNode,\n createObjectNode,\n getReferenceNode,\n markParserRef,\n parseAsyncIteratorFactory,\n parseIteratorFactory,\n ParserNodeType,\n parseSpecialReference,\n parseWellKnownSymbol,\n} from './parser';\n\ntype ObjectLikeNode =\n | SerovalObjectNode\n | SerovalNullConstructorNode\n | SerovalPromiseNode;\n\nexport type AsyncParserContextOptions = BaseParserContextOptions;\n\nexport interface AsyncParserContext {\n base: BaseParserContext;\n child: AsyncParsePluginContext | undefined;\n}\n\nexport function createAsyncParserContext(\n mode: SerovalMode,\n options: AsyncParserContextOptions,\n): AsyncParserContext {\n return {\n base: createBaseParserContext(mode, options),\n child: undefined,\n };\n}\n\nexport class AsyncParsePluginContext {\n constructor(\n private _p: AsyncParserContext,\n private depth: number,\n ) {}\n\n parse(current: T): Promise {\n return parseAsync(this._p, this.depth, current);\n }\n}\n\nasync function parseItems(\n ctx: AsyncParserContext,\n depth: number,\n current: unknown[],\n): Promise<(SerovalNode | 0)[]> {\n const nodes: (SerovalNode | 0)[] = [];\n for (let i = 0, len = current.length; i < len; i++) {\n // For consistency in holes\n if (i in current) {\n nodes[i] = await parseAsync(ctx, depth, current[i]);\n } else {\n nodes[i] = 0;\n }\n }\n return nodes;\n}\n\nasync function parseArray(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: unknown[],\n): Promise {\n return createArrayNode(id, current, await parseItems(ctx, depth, current));\n}\n\nasync function parseProperties(\n ctx: AsyncParserContext,\n depth: number,\n properties: Record,\n): Promise {\n const entries = Object.entries(properties);\n const keyNodes: SerovalObjectRecordKey[] = [];\n const valueNodes: SerovalNode[] = [];\n for (let i = 0, len = entries.length; i < len; i++) {\n keyNodes.push(serializeString(entries[i][0]));\n valueNodes.push(await parseAsync(ctx, depth, entries[i][1]));\n }\n // Check special properties\n if (SYM_ITERATOR in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));\n valueNodes.push(\n createIteratorFactoryInstanceNode(\n parseIteratorFactory(ctx.base),\n (await parseAsync(\n ctx,\n depth,\n createSequenceFromIterable(\n properties as unknown as Iterable,\n ),\n )) as SerovalNodeWithID,\n ),\n );\n }\n if (SYM_ASYNC_ITERATOR in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ASYNC_ITERATOR));\n valueNodes.push(\n createAsyncIteratorFactoryInstanceNode(\n parseAsyncIteratorFactory(ctx.base),\n (await parseAsync(\n ctx,\n depth,\n createStreamFromAsyncIterable(\n properties as unknown as AsyncIterable,\n ),\n )) as SerovalNodeWithID,\n ),\n );\n }\n if (SYM_TO_STRING_TAG in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_TO_STRING_TAG));\n valueNodes.push(createStringNode(properties[SYM_TO_STRING_TAG] as string));\n }\n if (SYM_IS_CONCAT_SPREADABLE in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_IS_CONCAT_SPREADABLE));\n valueNodes.push(\n properties[SYM_IS_CONCAT_SPREADABLE] ? TRUE_NODE : FALSE_NODE,\n );\n }\n return {\n k: keyNodes,\n v: valueNodes,\n };\n}\n\nasync function parsePlainObject(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Record,\n empty: boolean,\n): Promise {\n return createObjectNode(\n id,\n current,\n empty,\n await parseProperties(ctx, depth, current),\n );\n}\n\n// TODO: check if parseBoxedSync can be used\nasync function parseBoxed(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: object,\n): Promise {\n return createBoxedNode(id, await parseAsync(ctx, depth, current.valueOf()));\n}\n\nasync function parseTypedArray(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: TypedArrayValue,\n): Promise {\n return createTypedArrayNode(\n id,\n current,\n await parseAsync(ctx, depth, current.buffer),\n );\n}\n\nasync function parseBigIntTypedArray(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: BigIntTypedArrayValue,\n): Promise {\n return createBigIntTypedArrayNode(\n id,\n current,\n await parseAsync(ctx, depth, current.buffer),\n );\n}\n\nasync function parseDataView(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: DataView,\n): Promise {\n return createDataViewNode(\n id,\n current,\n await parseAsync(ctx, depth, current.buffer),\n );\n}\n\nasync function parseError(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Error,\n): Promise {\n const options = getErrorOptions(current, ctx.base.features);\n return createErrorNode(\n id,\n current,\n options ? await parseProperties(ctx, depth, options) : NIL,\n );\n}\n\nasync function parseAggregateError(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: AggregateError,\n): Promise {\n const options = getErrorOptions(current, ctx.base.features);\n return createAggregateErrorNode(\n id,\n current,\n options ? await parseProperties(ctx, depth, options) : NIL,\n );\n}\n\nasync function parseMap(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Map,\n): Promise {\n const keyNodes: SerovalNode[] = [];\n const valueNodes: SerovalNode[] = [];\n for (const [key, value] of current.entries()) {\n keyNodes.push(await parseAsync(ctx, depth, key));\n valueNodes.push(await parseAsync(ctx, depth, value));\n }\n return createMapNode(ctx.base, id, keyNodes, valueNodes);\n}\n\nasync function parseSet(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Set,\n): Promise {\n const items: SerovalNode[] = [];\n for (const item of current.keys()) {\n items.push(await parseAsync(ctx, depth, item));\n }\n return createSetNode(id, items);\n}\n\nasync function parsePlugin(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: unknown,\n): Promise {\n const currentPlugins = ctx.base.plugins;\n if (currentPlugins) {\n for (let i = 0, len = currentPlugins.length; i < len; i++) {\n const plugin = currentPlugins[i];\n if (plugin.parse.async && plugin.test(current)) {\n return createPluginNode(\n id,\n plugin.tag,\n await plugin.parse.async(\n current,\n new AsyncParsePluginContext(ctx, depth),\n {\n id,\n },\n ),\n );\n }\n }\n }\n return NIL;\n}\n\nasync function parsePromise(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Promise,\n): Promise {\n const [status, result] = await promiseToResult(current);\n\n return createSerovalNode(\n SerovalNodeType.Promise,\n id,\n status,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n await parseAsync(ctx, depth, result),\n NIL,\n NIL,\n NIL,\n );\n}\n\nfunction parseStreamHandle(\n this: AsyncParserContext,\n depth: number,\n id: number,\n current: Stream,\n resolve: (value: SerovalNode[] | PromiseLike) => void,\n reject: (reason?: any) => void,\n): void {\n const sequence: SerovalNode[] = [];\n // TODO Optimizable\n const cleanup = current.on({\n next: value => {\n markParserRef(this.base, id);\n parseAsync(this, depth, value).then(\n data => {\n sequence.push(createStreamNextNode(id, data));\n },\n data => {\n reject(data);\n cleanup();\n },\n );\n },\n throw: value => {\n markParserRef(this.base, id);\n parseAsync(this, depth, value).then(\n data => {\n sequence.push(createStreamThrowNode(id, data));\n resolve(sequence);\n cleanup();\n },\n data => {\n reject(data);\n cleanup();\n },\n );\n },\n return: value => {\n markParserRef(this.base, id);\n parseAsync(this, depth, value).then(\n data => {\n sequence.push(createStreamReturnNode(id, data));\n resolve(sequence);\n cleanup();\n },\n data => {\n reject(data);\n cleanup();\n },\n );\n },\n });\n}\n\nasync function parseStream(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Stream,\n): Promise {\n return createStreamConstructorNode(\n id,\n parseSpecialReference(ctx.base, SpecialReference.StreamConstructor),\n await new Promise(\n parseStreamHandle.bind(ctx, depth, id, current),\n ),\n );\n}\n\nasync function parseSequence(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Sequence,\n): Promise {\n const nodes: SerovalNode[] = [];\n for (let i = 0, len = current.v.length; i < len; i++) {\n nodes[i] = await parseAsync(ctx, depth, current.v[i]);\n }\n return createSequenceNode(id, nodes, current.t, current.d);\n}\n\nexport async function parseObjectAsync(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: object,\n): Promise {\n if (Array.isArray(current)) {\n return parseArray(ctx, depth, id, current);\n }\n if (isStream(current)) {\n return parseStream(ctx, depth, id, current);\n }\n if (isSequence(current)) {\n return parseSequence(ctx, depth, id, current);\n }\n const currentClass = current.constructor;\n if (currentClass === OpaqueReference) {\n return parseAsync(\n ctx,\n depth,\n (current as OpaqueReference).replacement,\n );\n }\n const parsed = await parsePlugin(ctx, depth, id, current);\n if (parsed) {\n return parsed;\n }\n switch (currentClass) {\n case Object:\n return parsePlainObject(\n ctx,\n depth,\n id,\n current as Record,\n false,\n );\n case NIL:\n return parsePlainObject(\n ctx,\n depth,\n id,\n current as Record,\n true,\n );\n case Date:\n return createDateNode(id, current as unknown as Date);\n case Error:\n case EvalError:\n case RangeError:\n case ReferenceError:\n case SyntaxError:\n case TypeError:\n case URIError:\n return parseError(ctx, depth, id, current as unknown as Error);\n case Number:\n case Boolean:\n case String:\n case BigInt:\n return parseBoxed(ctx, depth, id, current);\n case ArrayBuffer:\n return createArrayBufferNode(\n ctx.base,\n id,\n current as unknown as ArrayBuffer,\n );\n case Int8Array:\n case Int16Array:\n case Int32Array:\n case Uint8Array:\n case Uint16Array:\n case Uint32Array:\n case Uint8ClampedArray:\n case Float32Array:\n case Float64Array:\n return parseTypedArray(\n ctx,\n depth,\n id,\n current as unknown as TypedArrayValue,\n );\n case DataView:\n return parseDataView(ctx, depth, id, current as unknown as DataView);\n case Map:\n return parseMap(\n ctx,\n depth,\n id,\n current as unknown as Map,\n );\n case Set:\n return parseSet(ctx, depth, id, current as unknown as Set);\n default:\n break;\n }\n // Promises\n if (currentClass === Promise || current instanceof Promise) {\n return parsePromise(ctx, depth, id, current as unknown as Promise);\n }\n const currentFeatures = ctx.base.features;\n if (currentFeatures & Feature.RegExp && currentClass === RegExp) {\n return createRegExpNode(id, current as unknown as RegExp);\n }\n // BigInt Typed Arrays\n if (currentFeatures & Feature.BigIntTypedArray) {\n switch (currentClass) {\n case BigInt64Array:\n case BigUint64Array:\n return parseBigIntTypedArray(\n ctx,\n depth,\n id,\n current as unknown as BigIntTypedArrayValue,\n );\n default:\n break;\n }\n }\n if (\n currentFeatures & Feature.AggregateError &&\n typeof AggregateError !== 'undefined' &&\n (currentClass === AggregateError || current instanceof AggregateError)\n ) {\n return parseAggregateError(\n ctx,\n depth,\n id,\n current as unknown as AggregateError,\n );\n }\n // Slow path. We only need to handle Errors and Iterators\n // since they have very broad implementations.\n if (current instanceof Error) {\n return parseError(ctx, depth, id, current);\n }\n // Generator functions don't have a global constructor\n // despite existing\n if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) {\n return parsePlainObject(ctx, depth, id, current, !!currentClass);\n }\n throw new SerovalUnsupportedTypeError(current);\n}\n\nexport async function parseFunctionAsync(\n ctx: AsyncParserContext,\n depth: number,\n current: unknown,\n): Promise {\n const ref = getReferenceNode(ctx.base, current);\n if (ref.type !== ParserNodeType.Fresh) {\n return ref.value;\n }\n const plugin = await parsePlugin(ctx, depth, ref.value, current);\n if (plugin) {\n return plugin;\n }\n throw new SerovalUnsupportedTypeError(current);\n}\n\nexport async function parseAsync(\n ctx: AsyncParserContext,\n depth: number,\n current: T,\n): Promise {\n switch (typeof current) {\n case 'boolean':\n return current ? TRUE_NODE : FALSE_NODE;\n case 'undefined':\n return UNDEFINED_NODE;\n case 'string':\n return createStringNode(current as string);\n case 'number':\n return createNumberNode(current as number);\n case 'bigint':\n return createBigIntNode(current as bigint);\n case 'object': {\n if (current) {\n const ref = getReferenceNode(ctx.base, current);\n return ref.type === 0\n ? await parseObjectAsync(ctx, depth + 1, ref.value, current as object)\n : ref.value;\n }\n return NULL_NODE;\n }\n case 'symbol':\n return parseWellKnownSymbol(ctx.base, current);\n case 'function':\n return parseFunctionAsync(ctx, depth, current);\n default:\n throw new SerovalUnsupportedTypeError(current);\n }\n}\n\nexport async function parseTopAsync(\n ctx: AsyncParserContext,\n current: T,\n): Promise {\n try {\n return await parseAsync(ctx, 0, current);\n } catch (error) {\n throw error instanceof SerovalParserError\n ? error\n : new SerovalParserError(error);\n }\n}\n", "import type { AsyncParsePluginContext } from './context/async-parser';\nimport type { DeserializePluginContext } from './context/deserializer';\nimport type { SerializePluginContext } from './context/serializer';\nimport type {\n StreamParsePluginContext,\n SyncParsePluginContext,\n} from './context/sync-parser';\nimport type { SerovalNode } from './types';\n\nexport const enum SerovalMode {\n Vanilla = 1,\n Cross = 2,\n}\n\nexport interface PluginData {\n id: number;\n}\n\nexport type PluginInfo = {\n [key: string]: SerovalNode;\n};\n\nexport interface Plugin {\n /**\n * A unique string that helps idenfity the plugin\n */\n tag: string;\n /**\n * List of dependency plugins\n */\n extends?: Plugin[];\n /**\n * Method to test if a value is an expected value of the plugin\n * @param value\n */\n test(value: unknown): boolean;\n /**\n * Parsing modes\n */\n parse: {\n sync?: (\n value: Value,\n ctx: SyncParsePluginContext,\n data: PluginData,\n ) => Info;\n async?: (\n value: Value,\n ctx: AsyncParsePluginContext,\n data: PluginData,\n ) => Promise;\n stream?: (\n value: Value,\n ctx: StreamParsePluginContext,\n data: PluginData,\n ) => Info;\n };\n /**\n * Convert the parsed node into a JS string\n */\n serialize(node: Info, ctx: SerializePluginContext, data: PluginData): string;\n /**\n * Convert the parsed node into its runtime equivalent.\n */\n deserialize(\n node: Info,\n ctx: DeserializePluginContext,\n data: PluginData,\n ): Value;\n}\n\nexport function createPlugin(\n plugin: Plugin,\n): Plugin {\n return plugin;\n}\n\nexport interface PluginAccessOptions {\n plugins?: Plugin[];\n}\n\nfunction dedupePlugins(\n deduped: Set>,\n plugins: Plugin[],\n): void {\n for (let i = 0, len = plugins.length; i < len; i++) {\n const current = plugins[i];\n if (!deduped.has(current)) {\n deduped.add(current);\n if (current.extends) {\n dedupePlugins(deduped, current.extends);\n }\n }\n }\n}\n\nexport function resolvePlugins(\n plugins?: Plugin[],\n): Plugin[] | undefined {\n if (plugins) {\n const deduped = new Set>();\n dedupePlugins(deduped, plugins);\n return [...deduped];\n }\n return undefined;\n}\n", "import { SerovalUnknownTypedArrayError } from '../errors';\n\ntype TypedArrayConstructor =\n | Int8ArrayConstructor\n | Int16ArrayConstructor\n | Int32ArrayConstructor\n | Uint8ArrayConstructor\n | Uint16ArrayConstructor\n | Uint32ArrayConstructor\n | Uint8ClampedArrayConstructor\n | Float32ArrayConstructor\n | Float64ArrayConstructor\n | BigInt64ArrayConstructor\n | BigUint64ArrayConstructor;\n\nexport type TypedArrayValue =\n | Int8Array\n | Int16Array\n | Int32Array\n | Uint8Array\n | Uint16Array\n | Uint32Array\n | Uint8ClampedArray\n | Float32Array\n | Float64Array;\n\nexport type BigIntTypedArrayValue = BigInt64Array | BigUint64Array;\n\nexport function getTypedArrayConstructor(name: string): TypedArrayConstructor {\n switch (name) {\n case 'Int8Array':\n return Int8Array;\n case 'Int16Array':\n return Int16Array;\n case 'Int32Array':\n return Int32Array;\n case 'Uint8Array':\n return Uint8Array;\n case 'Uint16Array':\n return Uint16Array;\n case 'Uint32Array':\n return Uint32Array;\n case 'Uint8ClampedArray':\n return Uint8ClampedArray;\n case 'Float32Array':\n return Float32Array;\n case 'Float64Array':\n return Float64Array;\n case 'BigInt64Array':\n return BigInt64Array;\n case 'BigUint64Array':\n return BigUint64Array;\n default:\n throw new SerovalUnknownTypedArrayError(name);\n }\n}\n", "import { ALL_ENABLED, Feature } from '../compat';\nimport {\n CONSTANT_VAL,\n ERROR_CONSTRUCTOR,\n NIL,\n SerovalNodeType,\n SerovalObjectFlags,\n SYMBOL_REF,\n} from '../constants';\nimport {\n ARRAY_BUFFER_CONSTRUCTOR,\n PROMISE_CONSTRUCTOR,\n type PromiseConstructorResolver,\n} from '../constructors';\nimport {\n SerovalDepthLimitError,\n SerovalDeserializationError,\n SerovalMalformedNodeError,\n SerovalMissingInstanceError,\n SerovalMissingPluginError,\n SerovalUnsupportedNodeError,\n} from '../errors';\nimport type { PluginAccessOptions } from '../plugin';\nimport { SerovalMode } from '../plugin';\nimport { getReference } from '../reference';\nimport { createSequence, type Sequence, sequenceToIterator } from '../sequence';\nimport type { Stream } from '../stream';\nimport { createStream, isStream, streamToAsyncIterable } from '../stream';\nimport { deserializeString } from '../string';\nimport {\n SYM_ASYNC_ITERATOR,\n SYM_IS_CONCAT_SPREADABLE,\n SYM_ITERATOR,\n SYM_TO_STRING_TAG,\n} from '../symbols';\nimport type {\n SerovalAggregateErrorNode,\n SerovalArrayBufferNode,\n SerovalArrayNode,\n SerovalAsyncIteratorFactoryInstanceNode,\n SerovalAsyncIteratorFactoryNode,\n SerovalBigIntTypedArrayNode,\n SerovalBoxedNode,\n SerovalDataViewNode,\n SerovalDateNode,\n SerovalErrorNode,\n SerovalIteratorFactoryInstanceNode,\n SerovalIteratorFactoryNode,\n SerovalMapNode,\n SerovalNode,\n SerovalNullConstructorNode,\n SerovalObjectNode,\n SerovalObjectRecordNode,\n SerovalPluginNode,\n SerovalPromiseConstructorNode,\n SerovalPromiseNode,\n SerovalPromiseRejectNode,\n SerovalPromiseResolveNode,\n SerovalReferenceNode,\n SerovalRegExpNode,\n SerovalSequenceNode,\n SerovalSetNode,\n SerovalStreamConstructorNode,\n SerovalStreamNextNode,\n SerovalStreamReturnNode,\n SerovalStreamThrowNode,\n SerovalTypedArrayNode,\n} from '../types';\nimport type {\n BigIntTypedArrayValue,\n TypedArrayValue,\n} from '../utils/typed-array';\nimport { getTypedArrayConstructor } from '../utils/typed-array';\n\nconst MAX_BASE64_LENGTH = 1_000_000; // ~0.75MB decoded\nconst MAX_BIGINT_LENGTH = 10_000;\nconst MAX_REGEXP_SOURCE_LENGTH = 20_000;\n\nfunction applyObjectFlag(obj: unknown, flag: SerovalObjectFlags): unknown {\n switch (flag) {\n case SerovalObjectFlags.Frozen:\n return Object.freeze(obj);\n case SerovalObjectFlags.NonExtensible:\n return Object.preventExtensions(obj);\n case SerovalObjectFlags.Sealed:\n return Object.seal(obj);\n default:\n return obj;\n }\n}\n\ntype AssignableValue = AggregateError | Error | Iterable;\ntype AssignableNode = SerovalAggregateErrorNode | SerovalErrorNode;\n\nexport interface BaseDeserializerContextOptions extends PluginAccessOptions {\n refs?: Map;\n features?: number;\n disabledFeatures?: number;\n depthLimit?: number;\n}\n\nexport interface BaseDeserializerContext extends PluginAccessOptions {\n readonly mode: SerovalMode;\n /**\n * Mapping ids to values\n */\n refs: Map;\n features: number;\n depthLimit: number;\n}\n\nconst DEFAULT_DEPTH_LIMIT = 1000;\n\nexport function createBaseDeserializerContext(\n mode: SerovalMode,\n options: BaseDeserializerContextOptions,\n): BaseDeserializerContext {\n return {\n mode,\n plugins: options.plugins,\n refs: options.refs || new Map(),\n features: options.features ?? ALL_ENABLED ^ (options.disabledFeatures || 0),\n depthLimit: options.depthLimit || DEFAULT_DEPTH_LIMIT,\n };\n}\n\nexport interface VanillaDeserializerContextOptions\n extends Omit {\n markedRefs: number[] | Set;\n}\n\nexport interface VanillaDeserializerState {\n marked: Set;\n}\n\nexport interface VanillaDeserializerContext {\n mode: SerovalMode.Vanilla;\n base: BaseDeserializerContext;\n child: DeserializePluginContext | undefined;\n state: VanillaDeserializerState;\n}\n\nexport function createVanillaDeserializerContext(\n options: VanillaDeserializerContextOptions,\n): VanillaDeserializerContext {\n return {\n mode: SerovalMode.Vanilla,\n base: createBaseDeserializerContext(SerovalMode.Vanilla, options),\n child: NIL,\n state: {\n marked: new Set(options.markedRefs),\n },\n };\n}\n\nexport interface CrossDeserializerContext {\n mode: SerovalMode.Cross;\n base: BaseDeserializerContext;\n child: DeserializePluginContext | undefined;\n}\n\nexport type CrossDeserializerContextOptions = BaseDeserializerContextOptions;\n\nexport function createCrossDeserializerContext(\n options: CrossDeserializerContextOptions,\n): CrossDeserializerContext {\n return {\n mode: SerovalMode.Cross,\n base: createBaseDeserializerContext(SerovalMode.Cross, options),\n child: NIL,\n };\n}\n\ntype DeserializerContext =\n | VanillaDeserializerContext\n | CrossDeserializerContext;\n\nexport class DeserializePluginContext {\n constructor(\n private _p: DeserializerContext,\n private depth: number,\n ) {}\n\n deserialize(node: SerovalNode): T {\n return deserialize(this._p, this.depth, node) as T;\n }\n}\n\nfunction guardIndexedValue(ctx: BaseDeserializerContext, id: number): void {\n if (id < 0 || !Number.isFinite(id) || !Number.isInteger(id)) {\n throw new SerovalMalformedNodeError({\n t: SerovalNodeType.IndexedValue,\n i: id,\n } as SerovalNode);\n }\n if (ctx.refs.has(id)) {\n throw new Error('Conflicted ref id: ' + id);\n }\n}\n\nfunction assignIndexedValueVanilla(\n ctx: VanillaDeserializerContext,\n id: number,\n value: T,\n): T {\n guardIndexedValue(ctx.base, id);\n if (ctx.state.marked.has(id)) {\n ctx.base.refs.set(id, value);\n }\n return value;\n}\n\nfunction assignIndexedValueCross(\n ctx: CrossDeserializerContext,\n id: number,\n value: T,\n): T {\n guardIndexedValue(ctx.base, id);\n ctx.base.refs.set(id, value);\n return value;\n}\n\nfunction assignIndexedValue(\n ctx: DeserializerContext,\n id: number,\n value: T,\n): T {\n return ctx.mode === SerovalMode.Vanilla\n ? assignIndexedValueVanilla(ctx, id, value)\n : assignIndexedValueCross(ctx, id, value);\n}\n\nfunction deserializeKnownValue<\n T extends Record,\n K extends keyof T,\n>(node: SerovalNode, record: T, key: K): T[K] {\n if (Object.hasOwn(record, key)) {\n return record[key];\n }\n throw new SerovalMalformedNodeError(node);\n}\n\nfunction deserializeReference(\n ctx: DeserializerContext,\n node: SerovalReferenceNode,\n): unknown {\n return assignIndexedValue(\n ctx,\n node.i,\n getReference(deserializeString(node.s)),\n );\n}\n\nfunction deserializeArray(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalArrayNode,\n): unknown[] {\n const items = node.a;\n const len = items.length;\n const result: unknown[] = assignIndexedValue(\n ctx,\n node.i,\n new Array(len),\n );\n for (let i = 0, item: SerovalNode | 0; i < len; i++) {\n item = items[i];\n if (item) {\n result[i] = deserialize(ctx, depth, item);\n }\n }\n applyObjectFlag(result, node.o);\n return result;\n}\n\nfunction isValidKey(key: string): boolean {\n switch (key) {\n case 'constructor':\n case '__proto__':\n case 'prototype':\n case '__defineGetter__':\n case '__defineSetter__':\n case '__lookupGetter__':\n case '__lookupSetter__':\n // case 'then':\n return false;\n default:\n return true;\n }\n}\n\nfunction isValidSymbol(symbol: symbol): boolean {\n switch (symbol) {\n case SYM_ASYNC_ITERATOR:\n case SYM_IS_CONCAT_SPREADABLE:\n case SYM_TO_STRING_TAG:\n case SYM_ITERATOR:\n return true;\n default:\n return false;\n }\n}\n\nfunction assignStringProperty(\n object: Record,\n key: string,\n value: unknown,\n): void {\n if (isValidKey(key)) {\n object[key] = value;\n } else {\n Object.defineProperty(object, key, {\n value,\n configurable: true,\n enumerable: true,\n writable: true,\n });\n }\n}\n\nfunction assignProperty(\n ctx: DeserializerContext,\n depth: number,\n object: Record,\n key: string | SerovalNode,\n value: SerovalNode,\n): void {\n if (typeof key === 'string') {\n assignStringProperty(object, key, deserialize(ctx, depth, value));\n } else {\n const actual = deserialize(ctx, depth, key);\n switch (typeof actual) {\n case 'string':\n assignStringProperty(object, actual, deserialize(ctx, depth, value));\n break;\n case 'symbol':\n if (isValidSymbol(actual)) {\n object[actual] = deserialize(ctx, depth, value);\n }\n break;\n default:\n throw new SerovalMalformedNodeError(key);\n }\n }\n}\n\nfunction deserializeProperties(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalObjectRecordNode,\n result: Record,\n): Record {\n const keys = node.k;\n const len = keys.length;\n if (len > 0) {\n for (let i = 0, vals = node.v, len = keys.length; i < len; i++) {\n assignProperty(ctx, depth, result, keys[i], vals[i]);\n }\n }\n return result;\n}\n\nfunction deserializeObject(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalObjectNode | SerovalNullConstructorNode,\n): Record {\n const result = assignIndexedValue(\n ctx,\n node.i,\n (node.t === SerovalNodeType.Object ? {} : Object.create(null)) as Record<\n string,\n unknown\n >,\n );\n deserializeProperties(ctx, depth, node.p, result);\n applyObjectFlag(result, node.o);\n return result;\n}\n\nfunction deserializeDate(\n ctx: DeserializerContext,\n node: SerovalDateNode,\n): Date {\n return assignIndexedValue(ctx, node.i, new Date(node.s));\n}\n\nfunction deserializeRegExp(\n ctx: DeserializerContext,\n node: SerovalRegExpNode,\n): RegExp {\n if (ctx.base.features & Feature.RegExp) {\n const source = deserializeString(node.c);\n if (source.length > MAX_REGEXP_SOURCE_LENGTH) {\n throw new SerovalMalformedNodeError(node);\n }\n return assignIndexedValue(ctx, node.i, new RegExp(source, node.m));\n }\n throw new SerovalUnsupportedNodeError(node);\n}\n\nfunction deserializeSet(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalSetNode,\n): Set {\n const result = assignIndexedValue(ctx, node.i, new Set());\n for (let i = 0, items = node.a, len = items.length; i < len; i++) {\n result.add(deserialize(ctx, depth, items[i]));\n }\n return result;\n}\n\nfunction deserializeMap(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalMapNode,\n): Map {\n const result = assignIndexedValue(ctx, node.i, new Map());\n for (\n let i = 0, keys = node.e.k, vals = node.e.v, len = keys.length;\n i < len;\n i++\n ) {\n result.set(\n deserialize(ctx, depth, keys[i]),\n deserialize(ctx, depth, vals[i]),\n );\n }\n return result;\n}\n\nfunction deserializeArrayBuffer(\n ctx: DeserializerContext,\n node: SerovalArrayBufferNode,\n): ArrayBuffer {\n if (node.s.length > MAX_BASE64_LENGTH) {\n throw new SerovalMalformedNodeError(node);\n }\n const result = assignIndexedValue(\n ctx,\n node.i,\n ARRAY_BUFFER_CONSTRUCTOR(deserializeString(node.s)),\n );\n return result;\n}\n\nfunction deserializeTypedArray(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,\n): TypedArrayValue | BigIntTypedArrayValue {\n const construct = getTypedArrayConstructor(node.c) as Int8ArrayConstructor;\n const source = deserialize(ctx, depth, node.f) as ArrayBuffer;\n const offset = node.b ?? 0;\n if (offset < 0 || offset > source.byteLength) {\n throw new SerovalMalformedNodeError(node);\n }\n const result = assignIndexedValue(\n ctx,\n node.i,\n new construct(source, offset, node.l),\n );\n return result;\n}\n\nfunction deserializeDataView(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalDataViewNode,\n): DataView {\n const source = deserialize(ctx, depth, node.f) as ArrayBuffer;\n const offset = node.b ?? 0;\n if (offset < 0 || offset > source.byteLength) {\n throw new SerovalMalformedNodeError(node);\n }\n const result = assignIndexedValue(\n ctx,\n node.i,\n new DataView(source, offset, node.l),\n );\n return result;\n}\n\nfunction deserializeDictionary(\n ctx: DeserializerContext,\n depth: number,\n node: AssignableNode,\n result: T,\n): T {\n if (node.p) {\n const fields = deserializeProperties(ctx, depth, node.p, {});\n Object.defineProperties(result, Object.getOwnPropertyDescriptors(fields));\n }\n return result;\n}\n\nfunction deserializeAggregateError(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalAggregateErrorNode,\n): AggregateError {\n // Serialize the required arguments\n const result = assignIndexedValue(\n ctx,\n node.i,\n new AggregateError([], deserializeString(node.m)),\n );\n // `AggregateError` might've been extended\n // either through class or custom properties\n // Make sure to assign extra properties\n return deserializeDictionary(ctx, depth, node, result);\n}\n\nfunction deserializeError(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalErrorNode,\n): Error {\n const construct = deserializeKnownValue(node, ERROR_CONSTRUCTOR, node.s);\n const result = assignIndexedValue(\n ctx,\n node.i,\n new construct(deserializeString(node.m)),\n );\n return deserializeDictionary(ctx, depth, node, result);\n}\n\nfunction deserializePromise(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalPromiseNode,\n): Promise {\n const deferred = PROMISE_CONSTRUCTOR();\n const result = assignIndexedValue(ctx, node.i, deferred.p);\n const deserialized = deserialize(ctx, depth, node.f);\n if (node.s) {\n deferred.s(deserialized);\n } else {\n deferred.f(deserialized);\n }\n return result;\n}\n\nfunction deserializeBoxed(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalBoxedNode,\n): unknown {\n return assignIndexedValue(\n ctx,\n node.i,\n // biome-ignore lint/style/useConsistentBuiltinInstantiation: intended\n Object(deserialize(ctx, depth, node.f)),\n );\n}\n\nfunction deserializePlugin(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalPluginNode,\n): unknown {\n const currentPlugins = ctx.base.plugins;\n if (currentPlugins) {\n const tag = deserializeString(node.c);\n for (let i = 0, len = currentPlugins.length; i < len; i++) {\n const plugin = currentPlugins[i];\n if (plugin.tag === tag) {\n return assignIndexedValue(\n ctx,\n node.i,\n plugin.deserialize(node.s, new DeserializePluginContext(ctx, depth), {\n id: node.i,\n }),\n );\n }\n }\n }\n throw new SerovalMissingPluginError(node.c);\n}\n\nfunction deserializePromiseConstructor(\n ctx: DeserializerContext,\n node: SerovalPromiseConstructorNode,\n): unknown {\n return assignIndexedValue(\n ctx,\n node.i,\n assignIndexedValue(ctx, node.s, PROMISE_CONSTRUCTOR()).p,\n );\n}\n\nfunction deserializePromiseResolve(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalPromiseResolveNode,\n): unknown {\n const deferred = ctx.base.refs.get(node.i) as\n | PromiseConstructorResolver\n | undefined;\n if (deferred) {\n deferred.s(deserialize(ctx, depth, node.a[1]));\n return NIL;\n }\n throw new SerovalMissingInstanceError('Promise');\n}\n\nfunction deserializePromiseReject(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalPromiseRejectNode,\n): unknown {\n const deferred = ctx.base.refs.get(node.i) as\n | PromiseConstructorResolver\n | undefined;\n if (deferred) {\n deferred.f(deserialize(ctx, depth, node.a[1]));\n return NIL;\n }\n throw new SerovalMissingInstanceError('Promise');\n}\n\nfunction deserializeIteratorFactoryInstance(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalIteratorFactoryInstanceNode,\n): unknown {\n deserialize(ctx, depth, node.a[0]);\n const source = deserialize(ctx, depth, node.a[1]);\n return sequenceToIterator(source as Sequence);\n}\n\nfunction deserializeAsyncIteratorFactoryInstance(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalAsyncIteratorFactoryInstanceNode,\n): unknown {\n deserialize(ctx, depth, node.a[0]);\n const source = deserialize(ctx, depth, node.a[1]);\n return streamToAsyncIterable(source as Stream);\n}\n\nfunction deserializeStreamConstructor(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalStreamConstructorNode,\n): unknown {\n const result = assignIndexedValue(ctx, node.i, createStream());\n const items = node.a;\n const len = items.length;\n if (len) {\n for (let i = 0; i < len; i++) {\n deserialize(ctx, depth, items[i]);\n }\n }\n return result;\n}\n\nfunction deserializeStreamNext(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalStreamNextNode,\n): unknown {\n const deferred = ctx.base.refs.get(node.i) as Stream | undefined;\n if (deferred && isStream(deferred)) {\n deferred.next(deserialize(ctx, depth, node.f));\n return NIL;\n }\n throw new SerovalMissingInstanceError('Stream');\n}\n\nfunction deserializeStreamThrow(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalStreamThrowNode,\n): unknown {\n const deferred = ctx.base.refs.get(node.i) as Stream | undefined;\n if (deferred && isStream(deferred)) {\n deferred.throw(deserialize(ctx, depth, node.f));\n return NIL;\n }\n throw new SerovalMissingInstanceError('Stream');\n}\n\nfunction deserializeStreamReturn(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalStreamReturnNode,\n): unknown {\n const deferred = ctx.base.refs.get(node.i) as Stream | undefined;\n if (deferred && isStream(deferred)) {\n deferred.return(deserialize(ctx, depth, node.f));\n return NIL;\n }\n throw new SerovalMissingInstanceError('Stream');\n}\n\nfunction deserializeIteratorFactory(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalIteratorFactoryNode,\n): unknown {\n deserialize(ctx, depth, node.f);\n return NIL;\n}\n\nfunction deserializeAsyncIteratorFactory(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalAsyncIteratorFactoryNode,\n): unknown {\n deserialize(ctx, depth, node.a[1]);\n return NIL;\n}\n\nfunction deserializeSequence(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalSequenceNode,\n): Sequence {\n const result = assignIndexedValue(\n ctx,\n node.i,\n createSequence([], node.s, node.l),\n );\n for (let i = 0, len = node.a.length; i < len; i++) {\n result.v[i] = deserialize(ctx, depth, node.a[i]);\n }\n return result;\n}\n\nfunction deserialize(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalNode,\n): unknown {\n if (depth > ctx.base.depthLimit) {\n throw new SerovalDepthLimitError(ctx.base.depthLimit);\n }\n depth += 1;\n switch (node.t) {\n case SerovalNodeType.Constant:\n return deserializeKnownValue(node, CONSTANT_VAL, node.s);\n case SerovalNodeType.Number:\n return Number(node.s);\n case SerovalNodeType.String:\n return deserializeString(String(node.s));\n case SerovalNodeType.BigInt:\n if (String(node.s).length > MAX_BIGINT_LENGTH) {\n throw new SerovalMalformedNodeError(node);\n }\n return BigInt(node.s);\n case SerovalNodeType.IndexedValue:\n return ctx.base.refs.get(node.i);\n case SerovalNodeType.Reference:\n return deserializeReference(ctx, node);\n case SerovalNodeType.Array:\n return deserializeArray(ctx, depth, node);\n case SerovalNodeType.Object:\n case SerovalNodeType.NullConstructor:\n return deserializeObject(ctx, depth, node);\n case SerovalNodeType.Date:\n return deserializeDate(ctx, node);\n case SerovalNodeType.RegExp:\n return deserializeRegExp(ctx, node);\n case SerovalNodeType.Set:\n return deserializeSet(ctx, depth, node);\n case SerovalNodeType.Map:\n return deserializeMap(ctx, depth, node);\n case SerovalNodeType.ArrayBuffer:\n return deserializeArrayBuffer(ctx, node);\n case SerovalNodeType.BigIntTypedArray:\n case SerovalNodeType.TypedArray:\n return deserializeTypedArray(ctx, depth, node);\n case SerovalNodeType.DataView:\n return deserializeDataView(ctx, depth, node);\n case SerovalNodeType.AggregateError:\n return deserializeAggregateError(ctx, depth, node);\n case SerovalNodeType.Error:\n return deserializeError(ctx, depth, node);\n case SerovalNodeType.Promise:\n return deserializePromise(ctx, depth, node);\n case SerovalNodeType.WKSymbol:\n return deserializeKnownValue(node, SYMBOL_REF, node.s);\n case SerovalNodeType.Boxed:\n return deserializeBoxed(ctx, depth, node);\n case SerovalNodeType.Plugin:\n return deserializePlugin(ctx, depth, node);\n case SerovalNodeType.PromiseConstructor:\n return deserializePromiseConstructor(ctx, node);\n case SerovalNodeType.PromiseSuccess:\n return deserializePromiseResolve(ctx, depth, node);\n case SerovalNodeType.PromiseFailure:\n return deserializePromiseReject(ctx, depth, node);\n case SerovalNodeType.IteratorFactoryInstance:\n return deserializeIteratorFactoryInstance(ctx, depth, node);\n case SerovalNodeType.AsyncIteratorFactoryInstance:\n return deserializeAsyncIteratorFactoryInstance(ctx, depth, node);\n case SerovalNodeType.StreamConstructor:\n return deserializeStreamConstructor(ctx, depth, node);\n case SerovalNodeType.StreamNext:\n return deserializeStreamNext(ctx, depth, node);\n case SerovalNodeType.StreamThrow:\n return deserializeStreamThrow(ctx, depth, node);\n case SerovalNodeType.StreamReturn:\n return deserializeStreamReturn(ctx, depth, node);\n case SerovalNodeType.IteratorFactory:\n return deserializeIteratorFactory(ctx, depth, node);\n case SerovalNodeType.AsyncIteratorFactory:\n return deserializeAsyncIteratorFactory(ctx, depth, node);\n // case SerovalNodeType.SpecialReference:\n case SerovalNodeType.Sequence:\n return deserializeSequence(ctx, depth, node);\n default:\n throw new SerovalUnsupportedNodeError(node);\n }\n}\n\nexport function deserializeTop(\n ctx: DeserializerContext,\n node: SerovalNode,\n): unknown {\n try {\n return deserialize(ctx, 0, node);\n } catch (error) {\n throw new SerovalDeserializationError(error);\n }\n}\n", "\ndeclare const T: unknown;\n\nconst RETURN = () => T;\nconst SERIALIZED_RETURN = /* @__PURE__ */ RETURN.toString();\n\nconst IS_MODERN = /* @__PURE__ */ /=>/.test(SERIALIZED_RETURN);\n\nexport function createFunction(parameters: string[], body: string): string {\n if (IS_MODERN) {\n const joined =\n parameters.length === 1\n ? parameters[0]\n : '(' + parameters.join(',') + ')';\n return joined + '=>' + (body.startsWith('{') ? '(' + body + ')' : body);\n }\n return 'function(' + parameters.join(',') + '){return ' + body + '}';\n}\n\nexport function createEffectfulFunction(\n parameters: string[],\n body: string,\n): string {\n if (IS_MODERN) {\n const joined =\n parameters.length === 1\n ? parameters[0]\n : '(' + parameters.join(',') + ')';\n return joined + '=>{' + body + '}';\n }\n return 'function(' + parameters.join(',') + '){' + body + '}';\n}", "// Written by https://github.com/DylanPiercey and is distributed under the MIT license.\nconst REF_START_CHARS = /* @__PURE__ */ 'hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_'; // Avoids chars that could evaluate to a reserved word.\nconst REF_START_CHARS_LEN = /* @__PURE__ */ REF_START_CHARS.length;\nconst REF_CHARS =\n /* @__PURE__ */ 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_';\nconst REF_CHARS_LEN = /* @__PURE__ */ REF_CHARS.length;\n\nexport default function getIdentifier(index: number): string {\n let mod = index % REF_START_CHARS_LEN;\n let ref = REF_START_CHARS[mod];\n index = (index - mod) / REF_START_CHARS_LEN;\n while (index > 0) {\n mod = index % REF_CHARS_LEN;\n ref += REF_CHARS[mod];\n index = (index - mod) / REF_CHARS_LEN;\n }\n return ref;\n}\n", "const IDENTIFIER_CHECK = /^[$A-Z_][0-9A-Z_$]*$/i;\n\nexport function isValidIdentifier(name: string): boolean {\n const char = name[0];\n return (\n (char === '$' ||\n char === '_' ||\n (char >= 'A' && char <= 'Z') ||\n (char >= 'a' && char <= 'z')) &&\n IDENTIFIER_CHECK.test(name)\n );\n}\n", "import { Feature } from '../compat';\nimport {\n CONSTANT_STRING,\n ERROR_CONSTRUCTOR_STRING,\n NIL,\n SerovalNodeType,\n SerovalObjectFlags,\n SYMBOL_STRING,\n} from '../constants';\nimport {\n SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR,\n SERIALIZED_ITERATOR_CONSTRUCTOR,\n} from '../constructors';\nimport {\n SerovalMissingPluginError,\n SerovalSerializationError,\n SerovalUnsupportedNodeError,\n} from '../errors';\nimport { createEffectfulFunction, createFunction } from '../function-string';\nimport { GLOBAL_CONTEXT_REFERENCES, REFERENCES_KEY } from '../keys';\nimport type { PluginAccessOptions } from '../plugin';\nimport { SerovalMode } from '../plugin';\nimport { SPECIAL_REF_STRING } from '../special-reference';\nimport { serializeString } from '../string';\nimport type {\n SerovalAggregateErrorNode,\n SerovalArrayBufferNode,\n SerovalArrayNode,\n SerovalAsyncIteratorFactoryInstanceNode,\n SerovalAsyncIteratorFactoryNode,\n SerovalBigIntTypedArrayNode,\n SerovalBoxedNode,\n SerovalDataViewNode,\n SerovalDateNode,\n SerovalErrorNode,\n SerovalIndexedValueNode,\n SerovalIteratorFactoryInstanceNode,\n SerovalIteratorFactoryNode,\n SerovalMapNode,\n SerovalNode,\n SerovalNodeWithID,\n SerovalNullConstructorNode,\n SerovalObjectNode,\n SerovalObjectRecordKey,\n SerovalObjectRecordNode,\n SerovalPluginNode,\n SerovalPromiseConstructorNode,\n SerovalPromiseNode,\n SerovalPromiseRejectNode,\n SerovalPromiseResolveNode,\n SerovalReferenceNode,\n SerovalRegExpNode,\n SerovalSequenceNode,\n SerovalSetNode,\n SerovalStreamConstructorNode,\n SerovalStreamNextNode,\n SerovalStreamReturnNode,\n SerovalStreamThrowNode,\n SerovalTypedArrayNode,\n} from '../types';\nimport getIdentifier from '../utils/get-identifier';\nimport { isValidIdentifier } from '../utils/is-valid-identifier';\n\nconst enum AssignmentType {\n Index = 0,\n Add = 1,\n Set = 2,\n Delete = 3,\n}\n\ninterface IndexAssignment {\n t: AssignmentType.Index;\n s: string;\n k: undefined;\n v: string;\n}\n\ninterface SetAssignment {\n t: AssignmentType.Set;\n s: string;\n k: string;\n v: string;\n}\n\ninterface AddAssignment {\n t: AssignmentType.Add;\n s: string;\n k: undefined;\n v: string;\n}\n\ninterface DeleteAssignment {\n t: AssignmentType.Delete;\n s: string;\n k: string;\n v: undefined;\n}\n\n// Array of assignments to be done (used for recursion)\ntype Assignment =\n | IndexAssignment\n | AddAssignment\n | SetAssignment\n | DeleteAssignment;\n\nexport interface FlaggedObject {\n type: SerovalObjectFlags;\n value: string;\n}\n\nfunction getAssignmentExpression(assignment: Assignment): string {\n switch (assignment.t) {\n case AssignmentType.Index:\n return assignment.s + '=' + assignment.v;\n case AssignmentType.Set:\n return assignment.s + '.set(' + assignment.k + ',' + assignment.v + ')';\n case AssignmentType.Add:\n return assignment.s + '.add(' + assignment.v + ')';\n case AssignmentType.Delete:\n return assignment.s + '.delete(' + assignment.k + ')';\n }\n}\n\nfunction mergeAssignments(assignments: Assignment[]): Assignment[] {\n const newAssignments: Assignment[] = [];\n let current = assignments[0];\n for (\n let i = 1, len = assignments.length, item: Assignment, prev = current;\n i < len;\n i++\n ) {\n item = assignments[i];\n if (item.t === AssignmentType.Index && item.v === prev.v) {\n // Merge if the right-hand value is the same\n // saves at least 2 chars\n current = {\n t: AssignmentType.Index,\n s: item.s,\n k: NIL,\n v: getAssignmentExpression(current),\n } as IndexAssignment;\n } else if (item.t === AssignmentType.Set && item.s === prev.s) {\n // Maps has chaining methods, merge if source is the same\n current = {\n t: AssignmentType.Set,\n s: getAssignmentExpression(current),\n k: item.k,\n v: item.v,\n } as SetAssignment;\n } else if (item.t === AssignmentType.Add && item.s === prev.s) {\n // Sets has chaining methods too\n current = {\n t: AssignmentType.Add,\n s: getAssignmentExpression(current),\n k: NIL,\n v: item.v,\n } as AddAssignment;\n } else if (item.t === AssignmentType.Delete && item.s === prev.s) {\n // Maps has chaining methods, merge if source is the same\n current = {\n t: AssignmentType.Delete,\n s: getAssignmentExpression(current),\n k: item.k,\n v: NIL,\n } as DeleteAssignment;\n } else {\n // Different assignment, push current\n newAssignments.push(current);\n current = item;\n }\n prev = item;\n }\n\n newAssignments.push(current);\n\n return newAssignments;\n}\n\nfunction resolveAssignments(assignments: Assignment[]): string | undefined {\n if (assignments.length) {\n let result = '';\n const merged = mergeAssignments(assignments);\n for (let i = 0, len = merged.length; i < len; i++) {\n result += getAssignmentExpression(merged[i]) + ',';\n }\n return result;\n }\n return NIL;\n}\n\nconst NULL_CONSTRUCTOR = 'Object.create(null)';\nconst SET_CONSTRUCTOR = 'new Set';\nconst MAP_CONSTRUCTOR = 'new Map';\n\nconst PROMISE_RESOLVE = 'Promise.resolve';\nconst PROMISE_REJECT = 'Promise.reject';\n\nconst OBJECT_FLAG_CONSTRUCTOR: Record =\n {\n [SerovalObjectFlags.Frozen]: 'Object.freeze',\n [SerovalObjectFlags.Sealed]: 'Object.seal',\n [SerovalObjectFlags.NonExtensible]: 'Object.preventExtensions',\n [SerovalObjectFlags.None]: NIL,\n };\n\ntype SerovalNodeWithProperties =\n | SerovalObjectNode\n | SerovalNullConstructorNode\n | SerovalAggregateErrorNode\n | SerovalErrorNode;\n\nexport interface BaseSerializerContextOptions extends PluginAccessOptions {\n features: number;\n markedRefs: number[] | Set;\n}\n\nexport interface BaseSerializerContext extends PluginAccessOptions {\n readonly mode: SerovalMode;\n\n features: number;\n /*\n * To check if an object is synchronously referencing itself\n */\n stack: number[];\n /**\n * Array of object mutations\n */\n flags: FlaggedObject[];\n /**\n * Array of assignments to be done (used for recursion)\n */\n assignments: Assignment[];\n /**\n * Refs that are...referenced\n */\n marked: Set;\n}\n\nexport interface CrossContextOptions {\n scopeId?: string;\n}\n\nexport function createBaseSerializerContext(\n mode: SerovalMode,\n options: BaseSerializerContextOptions,\n): BaseSerializerContext {\n return {\n mode,\n plugins: options.plugins,\n features: options.features,\n marked: new Set(options.markedRefs),\n stack: [],\n flags: [],\n assignments: [],\n };\n}\n\nexport interface VanillaSerializerState {\n valid: Map;\n vars: string[];\n}\n\nfunction createVanillaSerializerState(): VanillaSerializerState {\n return {\n valid: new Map(),\n vars: [],\n };\n}\n\nexport interface VanillaSerializerContext {\n mode: SerovalMode.Vanilla;\n base: BaseSerializerContext;\n state: VanillaSerializerState;\n child: SerializePluginContext | undefined;\n}\n\nexport type VanillaSerializerContextOptions = BaseSerializerContextOptions;\n\nexport function createVanillaSerializerContext(\n options: VanillaSerializerContextOptions,\n): VanillaSerializerContext {\n return {\n mode: SerovalMode.Vanilla,\n base: createBaseSerializerContext(SerovalMode.Vanilla, options),\n state: createVanillaSerializerState(),\n child: NIL,\n };\n}\n\nexport interface CrossSerializerContext {\n mode: SerovalMode.Cross;\n base: BaseSerializerContext;\n state: CrossContextOptions;\n child: SerializePluginContext | undefined;\n}\n\nexport interface CrossSerializerContextOptions\n extends BaseSerializerContextOptions,\n CrossContextOptions {\n // empty\n}\n\nexport function createCrossSerializerContext(\n options: CrossSerializerContextOptions,\n): CrossSerializerContext {\n return {\n mode: SerovalMode.Cross,\n base: createBaseSerializerContext(SerovalMode.Cross, options),\n state: options,\n child: NIL,\n };\n}\n\ntype SerializerContext = VanillaSerializerContext | CrossSerializerContext;\n\nexport class SerializePluginContext {\n constructor(private _p: SerializerContext) {}\n\n serialize(node: SerovalNode) {\n return serialize(this._p, node);\n }\n}\n\n/**\n * Creates the reference param (identifier) from the given reference ID\n * Calling this function means the value has been referenced somewhere\n */\nfunction getVanillaRefParam(\n state: VanillaSerializerState,\n index: number,\n): string {\n /**\n * Creates a new reference ID from a given reference ID\n * This new reference ID means that the reference itself\n * has been referenced at least once, and is used to generate\n * the variables\n */\n let actualIndex = state.valid.get(index);\n if (actualIndex == null) {\n actualIndex = state.valid.size;\n state.valid.set(index, actualIndex);\n }\n let identifier = state.vars[actualIndex];\n if (identifier == null) {\n identifier = getIdentifier(actualIndex);\n state.vars[actualIndex] = identifier;\n }\n return identifier;\n}\n\nfunction getCrossRefParam(id: number): string {\n return GLOBAL_CONTEXT_REFERENCES + '[' + id + ']';\n}\n\n/**\n * Converts the ID of a reference into a identifier string\n * that is used to refer to the object instance in the\n * generated script.\n */\nfunction getRefParam(ctx: SerializerContext, id: number): string {\n return ctx.mode === SerovalMode.Vanilla\n ? getVanillaRefParam(ctx.state, id)\n : getCrossRefParam(id);\n}\n\nfunction markSerializerRef(ctx: BaseSerializerContext, id: number): void {\n ctx.marked.add(id);\n}\n\nfunction isSerializerRefMarked(\n ctx: BaseSerializerContext,\n id: number,\n): boolean {\n return ctx.marked.has(id);\n}\n\nfunction pushObjectFlag(\n ctx: SerializerContext,\n flag: SerovalObjectFlags,\n id: number,\n): void {\n if (flag !== SerovalObjectFlags.None) {\n markSerializerRef(ctx.base, id);\n ctx.base.flags.push({\n type: flag,\n value: getRefParam(ctx, id),\n });\n }\n}\n\nfunction resolveFlags(ctx: BaseSerializerContext): string | undefined {\n let result = '';\n for (let i = 0, current = ctx.flags, len = current.length; i < len; i++) {\n const flag = current[i];\n result += OBJECT_FLAG_CONSTRUCTOR[flag.type] + '(' + flag.value + '),';\n }\n return result;\n}\n\nfunction resolvePatches(ctx: BaseSerializerContext): string | undefined {\n const assignments = resolveAssignments(ctx.assignments);\n const flags = resolveFlags(ctx);\n if (assignments) {\n if (flags) {\n return assignments + flags;\n }\n return assignments;\n }\n return flags;\n}\n\n/**\n * Generates the inlined assignment for the reference\n * This is different from the assignments array as this one\n * signifies creation rather than mutation\n */\nfunction createAssignment(\n ctx: BaseSerializerContext,\n source: string,\n value: string,\n): void {\n ctx.assignments.push({\n t: AssignmentType.Index,\n s: source,\n k: NIL,\n v: value,\n });\n}\n\nfunction createAddAssignment(\n ctx: SerializerContext,\n ref: number,\n value: string,\n): void {\n ctx.base.assignments.push({\n t: AssignmentType.Add,\n s: getRefParam(ctx, ref),\n k: NIL,\n v: value,\n });\n}\n\nfunction createSetAssignment(\n ctx: SerializerContext,\n ref: number,\n key: string,\n value: string,\n): void {\n ctx.base.assignments.push({\n t: AssignmentType.Set,\n s: getRefParam(ctx, ref),\n k: key,\n v: value,\n });\n}\n\nfunction createDeleteAssignment(\n ctx: SerializerContext,\n ref: number,\n key: string,\n): void {\n ctx.base.assignments.push({\n t: AssignmentType.Delete,\n s: getRefParam(ctx, ref),\n k: key,\n v: NIL,\n });\n}\n\nfunction createArrayAssign(\n ctx: SerializerContext,\n ref: number,\n index: number | string,\n value: string,\n): void {\n createAssignment(ctx.base, getRefParam(ctx, ref) + '[' + index + ']', value);\n}\n\nfunction createObjectAssign(\n ctx: SerializerContext,\n ref: number,\n key: string,\n value: string,\n): void {\n createAssignment(ctx.base, getRefParam(ctx, ref) + '.' + key, value);\n}\n\nfunction createSequenceAssign(\n ctx: SerializerContext,\n ref: number,\n index: number | string,\n value: string,\n): void {\n createAssignment(ctx.base, getRefParam(ctx, ref) + '.v[' + index + ']', value);\n}\n\n/**\n * Checks if the value is in the stack. Stack here is a reference\n * structure to know if a object is to be accessed in a TDZ.\n */\nfunction isIndexedValueInStack(\n ctx: BaseSerializerContext,\n node: SerovalNode,\n): boolean {\n return node.t === SerovalNodeType.IndexedValue && ctx.stack.includes(node.i);\n}\n\n/**\n * Produces an assignment expression. `id` generates a reference\n * parameter (through `getRefParam`) and has the option to\n * return the reference parameter directly or assign a value to\n * it.\n */\nfunction assignIndexedValue(\n ctx: SerializerContext,\n index: number,\n value: string,\n): string {\n if (\n ctx.mode === SerovalMode.Vanilla &&\n !isSerializerRefMarked(ctx.base, index)\n ) {\n return value;\n }\n /**\n * In cross-reference, we have to assume that\n * every reference are going to be referenced\n * in the future, and so we need to store\n * all of it into the reference array.\n *\n * otherwise in vanilla, we only do this if it\n * is actually referenced\n */\n return getRefParam(ctx, index) + '=' + value;\n}\n\nfunction serializeReference(node: SerovalReferenceNode): string {\n return REFERENCES_KEY + '.get(\"' + node.s + '\")';\n}\n\nfunction serializeArrayItem(\n ctx: SerializerContext,\n id: number,\n item: SerovalNode | 0,\n index: number,\n): string {\n // Check if index is a hole\n if (item) {\n // Check if item is a parent\n if (isIndexedValueInStack(ctx.base, item)) {\n markSerializerRef(ctx.base, id);\n createArrayAssign(\n ctx,\n id,\n index,\n getRefParam(ctx, (item as SerovalIndexedValueNode).i),\n );\n return '';\n }\n return serialize(ctx, item);\n }\n return '';\n}\n\nfunction serializeArray(\n ctx: SerializerContext,\n node: SerovalArrayNode,\n): string {\n const id = node.i;\n const list = node.a;\n const len = list.length;\n if (len > 0) {\n ctx.base.stack.push(id);\n let values = serializeArrayItem(ctx, id, list[0], 0);\n // This is different than Map and Set\n // because we also need to serialize\n // the holes of the Array\n let isHoley = values === '';\n for (let i = 1, item: string; i < len; i++) {\n item = serializeArrayItem(ctx, id, list[i], i);\n values += ',' + item;\n isHoley = item === '';\n }\n ctx.base.stack.pop();\n pushObjectFlag(ctx, node.o, node.i);\n return '[' + values + (isHoley ? ',]' : ']');\n }\n return '[]';\n}\n\nfunction serializeProperty(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n key: SerovalObjectRecordKey,\n val: SerovalNode,\n): string {\n if (typeof key === 'string') {\n const check = Number(key);\n const isIdentifier =\n // Test if key is a valid positive number or JS identifier\n // so that we don't have to serialize the key and wrap with brackets\n (check >= 0 &&\n // It's also important to consider that if the key is\n // indeed numeric, we need to make sure that when\n // converted back into a string, it's still the same\n // to the original key. This allows us to differentiate\n // keys that has numeric formats but in a different\n // format, which can cause unintentional key declaration\n // Example: { 0x1: 1 } vs { '0x1': 1 }\n check.toString() === key) ||\n isValidIdentifier(key);\n if (isIndexedValueInStack(ctx.base, val)) {\n const refParam = getRefParam(ctx, (val as SerovalIndexedValueNode).i);\n markSerializerRef(ctx.base, source.i);\n // Strict identifier check, make sure\n // that it isn't numeric (except NaN)\n if (isIdentifier && check !== check) {\n createObjectAssign(ctx, source.i, key, refParam);\n } else {\n createArrayAssign(\n ctx,\n source.i,\n isIdentifier ? key : '\"' + key + '\"',\n refParam,\n );\n }\n return '';\n }\n return (isIdentifier ? key : '\"' + key + '\"') + ':' + serialize(ctx, val);\n }\n return '[' + serialize(ctx, key) + ']:' + serialize(ctx, val);\n}\n\nfunction serializeProperties(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n record: SerovalObjectRecordNode,\n): string {\n const keys = record.k;\n const len = keys.length;\n if (len > 0) {\n const values = record.v;\n ctx.base.stack.push(source.i);\n let result = serializeProperty(ctx, source, keys[0], values[0]);\n for (let i = 1, item = result; i < len; i++) {\n item = serializeProperty(ctx, source, keys[i], values[i]);\n result += (item && result && ',') + item;\n }\n ctx.base.stack.pop();\n return '{' + result + '}';\n }\n return '{}';\n}\n\nfunction serializeObject(\n ctx: SerializerContext,\n node: SerovalObjectNode,\n): string {\n pushObjectFlag(ctx, node.o, node.i);\n return serializeProperties(ctx, node, node.p);\n}\n\nfunction serializeWithObjectAssign(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n value: SerovalObjectRecordNode,\n serialized: string,\n): string {\n const fields = serializeProperties(ctx, source, value);\n if (fields !== '{}') {\n return 'Object.assign(' + serialized + ',' + fields + ')';\n }\n return serialized;\n}\n\nfunction serializeStringKeyAssignment(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n mainAssignments: Assignment[],\n key: string,\n value: SerovalNode,\n): void {\n const base = ctx.base;\n const serialized = serialize(ctx, value);\n const check = Number(key);\n const isIdentifier =\n // Test if key is a valid positive number or JS identifier\n // so that we don't have to serialize the key and wrap with brackets\n (check >= 0 &&\n // It's also important to consider that if the key is\n // indeed numeric, we need to make sure that when\n // converted back into a string, it's still the same\n // to the original key. This allows us to differentiate\n // keys that has numeric formats but in a different\n // format, which can cause unintentional key declaration\n // Example: { 0x1: 1 } vs { '0x1': 1 }\n check.toString() === key) ||\n isValidIdentifier(key);\n if (isIndexedValueInStack(base, value)) {\n // Strict identifier check, make sure\n // that it isn't numeric (except NaN)\n if (isIdentifier && check !== check) {\n createObjectAssign(ctx, source.i, key, serialized);\n } else {\n createArrayAssign(\n ctx,\n source.i,\n isIdentifier ? key : '\"' + key + '\"',\n serialized,\n );\n }\n } else {\n const parentAssignment = base.assignments;\n base.assignments = mainAssignments;\n if (isIdentifier && check !== check) {\n createObjectAssign(ctx, source.i, key, serialized);\n } else {\n createArrayAssign(\n ctx,\n source.i,\n isIdentifier ? key : '\"' + key + '\"',\n serialized,\n );\n }\n base.assignments = parentAssignment;\n }\n}\n\nfunction serializeAssignment(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n mainAssignments: Assignment[],\n key: SerovalObjectRecordKey,\n value: SerovalNode,\n): void {\n if (typeof key === 'string') {\n serializeStringKeyAssignment(ctx, source, mainAssignments, key, value);\n } else {\n const base = ctx.base;\n const parent = base.stack;\n base.stack = [];\n const serialized = serialize(ctx, value);\n base.stack = parent;\n const parentAssignment = base.assignments;\n base.assignments = mainAssignments;\n createArrayAssign(ctx, source.i, serialize(ctx, key), serialized);\n base.assignments = parentAssignment;\n }\n}\n\nfunction serializeAssignments(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n node: SerovalObjectRecordNode,\n): string | undefined {\n const keys = node.k;\n const len = keys.length;\n if (len > 0) {\n const mainAssignments: Assignment[] = [];\n const values = node.v;\n ctx.base.stack.push(source.i);\n for (let i = 0; i < len; i++) {\n serializeAssignment(ctx, source, mainAssignments, keys[i], values[i]);\n }\n ctx.base.stack.pop();\n return resolveAssignments(mainAssignments);\n }\n return NIL;\n}\n\nfunction serializeDictionary(\n ctx: SerializerContext,\n node: SerovalNodeWithProperties,\n init: string,\n): string {\n if (node.p) {\n const base = ctx.base;\n if (base.features & Feature.ObjectAssign) {\n init = serializeWithObjectAssign(ctx, node, node.p, init);\n } else {\n markSerializerRef(base, node.i);\n const assignments = serializeAssignments(ctx, node, node.p);\n if (assignments) {\n return (\n '(' +\n assignIndexedValue(ctx, node.i, init) +\n ',' +\n assignments +\n getRefParam(ctx, node.i) +\n ')'\n );\n }\n }\n }\n return init;\n}\n\nfunction serializeNullConstructor(\n ctx: SerializerContext,\n node: SerovalNullConstructorNode,\n): string {\n pushObjectFlag(ctx, node.o, node.i);\n return serializeDictionary(ctx, node, NULL_CONSTRUCTOR);\n}\n\nfunction serializeDate(node: SerovalDateNode): string {\n return 'new Date(\"' + node.s + '\")';\n}\n\nfunction serializeRegExp(\n ctx: SerializerContext,\n node: SerovalRegExpNode,\n): string {\n if (ctx.base.features & Feature.RegExp) {\n return '/' + node.c + '/' + node.m;\n }\n throw new SerovalUnsupportedNodeError(node);\n}\n\nfunction serializeSetItem(\n ctx: SerializerContext,\n id: number,\n item: SerovalNode,\n): string {\n const base = ctx.base;\n if (isIndexedValueInStack(base, item)) {\n markSerializerRef(base, id);\n createAddAssignment(\n ctx,\n id,\n getRefParam(ctx, (item as SerovalIndexedValueNode).i),\n );\n return '';\n }\n return serialize(ctx, item);\n}\n\nfunction serializeSet(ctx: SerializerContext, node: SerovalSetNode): string {\n let serialized = SET_CONSTRUCTOR;\n const items = node.a;\n const size = items.length;\n const id = node.i;\n if (size > 0) {\n ctx.base.stack.push(id);\n let result = serializeSetItem(ctx, id, items[0]);\n for (let i = 1, item = result; i < size; i++) {\n item = serializeSetItem(ctx, id, items[i]);\n result += (item && result && ',') + item;\n }\n ctx.base.stack.pop();\n if (result) {\n serialized += '([' + result + '])';\n }\n }\n return serialized;\n}\n\nfunction serializeMapEntry(\n ctx: SerializerContext,\n id: number,\n key: SerovalNode,\n val: SerovalNode,\n sentinel: string,\n): string {\n const base = ctx.base;\n if (isIndexedValueInStack(base, key)) {\n // Create reference for the map instance\n const keyRef = getRefParam(ctx, (key as SerovalIndexedValueNode).i);\n markSerializerRef(base, id);\n // Check if value is a parent\n if (isIndexedValueInStack(base, val)) {\n const valueRef = getRefParam(ctx, (val as SerovalIndexedValueNode).i);\n // Register an assignment since\n // both key and value are a parent of this\n // Map instance\n createSetAssignment(ctx, id, keyRef, valueRef);\n return '';\n }\n // Reset the stack\n // This is required because the serialized\n // value is no longer part of the expression\n // tree and has been moved to the deferred\n // assignment\n if (\n val.t !== SerovalNodeType.IndexedValue &&\n val.i != null &&\n isSerializerRefMarked(base, val.i)\n ) {\n // We use a trick here using sequence (or comma) expressions\n // basically we serialize the intended object in place WITHOUT\n // actually returning it, this is by returning a placeholder\n // value that we will remove sometime after.\n const serialized =\n '(' + serialize(ctx, val) + ',[' + sentinel + ',' + sentinel + '])';\n createSetAssignment(ctx, id, keyRef, getRefParam(ctx, val.i));\n createDeleteAssignment(ctx, id, sentinel);\n return serialized;\n }\n const parent = base.stack;\n base.stack = [];\n createSetAssignment(ctx, id, keyRef, serialize(ctx, val));\n base.stack = parent;\n return '';\n }\n if (isIndexedValueInStack(base, val)) {\n // Create ref for the Map instance\n const valueRef = getRefParam(ctx, (val as SerovalIndexedValueNode).i);\n markSerializerRef(base, id);\n if (\n key.t !== SerovalNodeType.IndexedValue &&\n key.i != null &&\n isSerializerRefMarked(base, key.i)\n ) {\n const serialized =\n '(' + serialize(ctx, key) + ',[' + sentinel + ',' + sentinel + '])';\n createSetAssignment(ctx, id, getRefParam(ctx, key.i), valueRef);\n createDeleteAssignment(ctx, id, sentinel);\n return serialized;\n }\n // Reset stack for the key serialization\n const parent = base.stack;\n base.stack = [];\n createSetAssignment(ctx, id, serialize(ctx, key), valueRef);\n base.stack = parent;\n return '';\n }\n\n return '[' + serialize(ctx, key) + ',' + serialize(ctx, val) + ']';\n}\n\nfunction serializeMap(ctx: SerializerContext, node: SerovalMapNode): string {\n let serialized = MAP_CONSTRUCTOR;\n const keys = node.e.k;\n const size = keys.length;\n const id = node.i;\n const sentinel = node.f;\n const sentinelId = getRefParam(ctx, sentinel.i);\n const base = ctx.base;\n if (size > 0) {\n const vals = node.e.v;\n base.stack.push(id);\n let result = serializeMapEntry(ctx, id, keys[0], vals[0], sentinelId);\n for (let i = 1, item = result; i < size; i++) {\n item = serializeMapEntry(ctx, id, keys[i], vals[i], sentinelId);\n result += (item && result && ',') + item;\n }\n base.stack.pop();\n // Check if there are any values\n // so that the empty Map constructor\n // can be used instead\n if (result) {\n serialized += '([' + result + '])';\n }\n }\n if (sentinel.t === SerovalNodeType.SpecialReference) {\n markSerializerRef(base, sentinel.i);\n serialized = '(' + serialize(ctx, sentinel) + ',' + serialized + ')';\n }\n return serialized;\n}\n\nfunction serializeArrayBuffer(\n ctx: SerializerContext,\n node: SerovalArrayBufferNode,\n): string {\n return getConstructor(ctx, node.f) + '(\"' + node.s + '\")';\n}\n\nfunction serializeTypedArray(\n ctx: SerializerContext,\n node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,\n): string {\n return 'new ' + node.c + '(' + serialize(ctx, node.f) + ',' + node.b + ',' + node.l + ')';\n}\n\nfunction serializeDataView(\n ctx: SerializerContext,\n node: SerovalDataViewNode,\n): string {\n return 'new DataView(' + serialize(ctx, node.f) + ',' + node.b + ',' + node.l + ')';\n}\n\nfunction serializeAggregateError(\n ctx: SerializerContext,\n node: SerovalAggregateErrorNode,\n): string {\n const id = node.i;\n // `AggregateError` might've been extended\n // either through class or custom properties\n // Make sure to assign extra properties\n ctx.base.stack.push(id);\n const serialized = serializeDictionary(\n ctx,\n node,\n 'new AggregateError([],\"' + node.m + '\")',\n );\n ctx.base.stack.pop();\n return serialized;\n}\n\nfunction serializeError(\n ctx: SerializerContext,\n node: SerovalErrorNode,\n): string {\n return serializeDictionary(\n ctx,\n node,\n 'new ' + ERROR_CONSTRUCTOR_STRING[node.s] + '(\"' + node.m + '\")',\n );\n}\n\nfunction serializePromise(\n ctx: SerializerContext,\n node: SerovalPromiseNode,\n): string {\n let serialized: string;\n // Check if resolved value is a parent expression\n const fulfilled = node.f;\n const id = node.i;\n const promiseConstructor = node.s ? PROMISE_RESOLVE : PROMISE_REJECT;\n const base = ctx.base;\n if (isIndexedValueInStack(base, fulfilled)) {\n // A Promise trick, reference the value\n // inside the `then` expression so that\n // the Promise evaluates after the parent\n // has initialized\n const ref = getRefParam(ctx, (fulfilled as SerovalIndexedValueNode).i);\n serialized =\n promiseConstructor +\n (node.s\n ? '().then(' + createFunction([], ref) + ')'\n : '().catch(' + createEffectfulFunction([], 'throw ' + ref) + ')');\n } else {\n base.stack.push(id);\n const result = serialize(ctx, fulfilled);\n base.stack.pop();\n // just inline the value/reference here\n serialized = promiseConstructor + '(' + result + ')';\n }\n return serialized;\n}\n\nfunction serializeBoxed(\n ctx: SerializerContext,\n node: SerovalBoxedNode,\n): string {\n return 'Object(' + serialize(ctx, node.f) + ')';\n}\n\nfunction getConstructor(\n ctx: SerializerContext,\n node: SerovalNodeWithID,\n): string {\n const current = serialize(ctx, node);\n return node.t === SerovalNodeType.IndexedValue\n ? current\n : '(' + current + ')';\n}\n\nfunction serializePromiseConstructor(\n ctx: SerializerContext,\n node: SerovalPromiseConstructorNode,\n): string {\n if (ctx.mode === SerovalMode.Vanilla) {\n throw new SerovalUnsupportedNodeError(node);\n }\n const resolver = assignIndexedValue(\n ctx,\n node.s,\n getConstructor(ctx, node.f) + '()',\n );\n return '(' + resolver + ').p';\n}\n\nfunction serializePromiseResolve(\n ctx: SerializerContext,\n node: SerovalPromiseResolveNode,\n): string {\n if (ctx.mode === SerovalMode.Vanilla) {\n throw new SerovalUnsupportedNodeError(node);\n }\n return (\n getConstructor(ctx, node.a[0]) +\n '(' +\n getRefParam(ctx, node.i) +\n ',' +\n serialize(ctx, node.a[1]) +\n ')'\n );\n}\n\nfunction serializePromiseReject(\n ctx: SerializerContext,\n node: SerovalPromiseRejectNode,\n): string {\n if (ctx.mode === SerovalMode.Vanilla) {\n throw new SerovalUnsupportedNodeError(node);\n }\n return (\n getConstructor(ctx, node.a[0]) +\n '(' +\n getRefParam(ctx, node.i) +\n ',' +\n serialize(ctx, node.a[1]) +\n ')'\n );\n}\n\nfunction serializePlugin(\n ctx: SerializerContext,\n node: SerovalPluginNode,\n): string {\n const currentPlugins = ctx.base.plugins;\n if (currentPlugins) {\n for (let i = 0, len = currentPlugins.length; i < len; i++) {\n const plugin = currentPlugins[i];\n if (plugin.tag === node.c) {\n if (ctx.child == null) {\n ctx.child = new SerializePluginContext(ctx);\n }\n return plugin.serialize(node.s, ctx.child, {\n id: node.i,\n });\n }\n }\n }\n throw new SerovalMissingPluginError(node.c);\n}\n\nfunction serializeIteratorFactory(\n ctx: SerializerContext,\n node: SerovalIteratorFactoryNode,\n): string {\n let result = '';\n let initialized = false;\n if (node.f.t !== SerovalNodeType.IndexedValue) {\n markSerializerRef(ctx.base, node.f.i);\n result = '(' + serialize(ctx, node.f) + ',';\n initialized = true;\n }\n result += assignIndexedValue(\n ctx,\n node.i,\n '(' +\n SERIALIZED_ITERATOR_CONSTRUCTOR +\n ')(' +\n getRefParam(ctx, node.f.i) +\n ')',\n );\n if (initialized) {\n result += ')';\n }\n return result;\n}\n\nfunction serializeIteratorFactoryInstance(\n ctx: SerializerContext,\n node: SerovalIteratorFactoryInstanceNode,\n): string {\n return getConstructor(ctx, node.a[0]) + '(' + serialize(ctx, node.a[1]) + ')';\n}\n\nfunction serializeAsyncIteratorFactory(\n ctx: SerializerContext,\n node: SerovalAsyncIteratorFactoryNode,\n): string {\n const promise = node.a[0];\n const symbol = node.a[1];\n const base = ctx.base;\n\n let result = '';\n\n if (promise.t !== SerovalNodeType.IndexedValue) {\n markSerializerRef(base, promise.i);\n result += '(' + serialize(ctx, promise);\n }\n if (symbol.t !== SerovalNodeType.IndexedValue) {\n markSerializerRef(base, symbol.i);\n result += (result ? ',' : '(') + serialize(ctx, symbol);\n }\n if (result) {\n result += ',';\n }\n\n const iterator = assignIndexedValue(\n ctx,\n node.i,\n '(' +\n SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR +\n ')(' +\n getRefParam(ctx, symbol.i) +\n ',' +\n getRefParam(ctx, promise.i) +\n ')',\n );\n\n if (result) {\n return result + iterator + ')';\n }\n\n return iterator;\n}\n\nfunction serializeAsyncIteratorFactoryInstance(\n ctx: SerializerContext,\n node: SerovalAsyncIteratorFactoryInstanceNode,\n): string {\n return getConstructor(ctx, node.a[0]) + '(' + serialize(ctx, node.a[1]) + ')';\n}\n\nfunction serializeStreamConstructor(\n ctx: SerializerContext,\n node: SerovalStreamConstructorNode,\n): string {\n const result = assignIndexedValue(\n ctx,\n node.i,\n getConstructor(ctx, node.f) + '()',\n );\n const len = node.a.length;\n if (len) {\n let values = serialize(ctx, node.a[0]);\n for (let i = 1; i < len; i++) {\n values += ',' + serialize(ctx, node.a[i]);\n }\n return '(' + result + ',' + values + ',' + getRefParam(ctx, node.i) + ')';\n }\n return result;\n}\n\nfunction serializeStreamNext(\n ctx: SerializerContext,\n node: SerovalStreamNextNode,\n): string {\n return getRefParam(ctx, node.i) + '.next(' + serialize(ctx, node.f) + ')';\n}\n\nfunction serializeStreamThrow(\n ctx: SerializerContext,\n node: SerovalStreamThrowNode,\n): string {\n return getRefParam(ctx, node.i) + '.throw(' + serialize(ctx, node.f) + ')';\n}\n\nfunction serializeStreamReturn(\n ctx: SerializerContext,\n node: SerovalStreamReturnNode,\n): string {\n return getRefParam(ctx, node.i) + '.return(' + serialize(ctx, node.f) + ')';\n}\n\nfunction serializeSequenceItem(\n ctx: SerializerContext,\n id: number,\n index: number,\n item: SerovalNode,\n): string {\n const base = ctx.base;\n if (isIndexedValueInStack(base, item)) {\n markSerializerRef(base, id);\n createSequenceAssign(\n ctx,\n id,\n index,\n getRefParam(ctx, (item as SerovalIndexedValueNode).i),\n );\n return '';\n }\n return serialize(ctx, item);\n}\n\nfunction serializeSequence(\n ctx: SerializerContext,\n node: SerovalSequenceNode,\n): string {\n const items = node.a;\n const size = items.length;\n const id = node.i;\n if (size > 0) {\n ctx.base.stack.push(id);\n let result = serializeSequenceItem(ctx, id, 0, items[0]);\n for (let i = 1, item = result; i < size; i++) {\n item = serializeSequenceItem(ctx, id, i, items[i]);\n result += (item && result && ',') + item;\n }\n ctx.base.stack.pop();\n if (result) {\n return '{__SEROVAL_SEQUENCE__:!0,v:[' + result + '],t:' + node.s + ',d:' + node.l + '}';\n }\n }\n return '{__SEROVAL_SEQUENCE__:!0,v:[],t:-1,d:0}';\n}\n\nfunction serializeAssignable(\n ctx: SerializerContext,\n node: SerovalNode,\n): string {\n switch (node.t) {\n case SerovalNodeType.WKSymbol:\n return SYMBOL_STRING[node.s];\n case SerovalNodeType.Reference:\n return serializeReference(node);\n case SerovalNodeType.Array:\n return serializeArray(ctx, node);\n case SerovalNodeType.Object:\n return serializeObject(ctx, node);\n case SerovalNodeType.NullConstructor:\n return serializeNullConstructor(ctx, node);\n case SerovalNodeType.Date:\n return serializeDate(node);\n case SerovalNodeType.RegExp:\n return serializeRegExp(ctx, node);\n case SerovalNodeType.Set:\n return serializeSet(ctx, node);\n case SerovalNodeType.Map:\n return serializeMap(ctx, node);\n case SerovalNodeType.ArrayBuffer:\n return serializeArrayBuffer(ctx, node);\n case SerovalNodeType.BigIntTypedArray:\n case SerovalNodeType.TypedArray:\n return serializeTypedArray(ctx, node);\n case SerovalNodeType.DataView:\n return serializeDataView(ctx, node);\n case SerovalNodeType.AggregateError:\n return serializeAggregateError(ctx, node);\n case SerovalNodeType.Error:\n return serializeError(ctx, node);\n case SerovalNodeType.Promise:\n return serializePromise(ctx, node);\n case SerovalNodeType.Boxed:\n return serializeBoxed(ctx, node);\n case SerovalNodeType.PromiseConstructor:\n return serializePromiseConstructor(ctx, node);\n case SerovalNodeType.Plugin:\n return serializePlugin(ctx, node);\n case SerovalNodeType.SpecialReference:\n return SPECIAL_REF_STRING[node.s];\n case SerovalNodeType.Sequence:\n return serializeSequence(ctx, node);\n default:\n throw new SerovalUnsupportedNodeError(node);\n }\n}\n\nfunction serialize(ctx: SerializerContext, node: SerovalNode): string {\n switch (node.t) {\n case SerovalNodeType.Constant:\n return CONSTANT_STRING[node.s];\n case SerovalNodeType.Number:\n return '' + node.s;\n case SerovalNodeType.String:\n return '\"' + node.s + '\"';\n case SerovalNodeType.BigInt:\n return node.s + 'n';\n case SerovalNodeType.IndexedValue:\n return getRefParam(ctx, node.i);\n case SerovalNodeType.PromiseSuccess:\n return serializePromiseResolve(ctx, node);\n case SerovalNodeType.PromiseFailure:\n return serializePromiseReject(ctx, node);\n case SerovalNodeType.IteratorFactory:\n return serializeIteratorFactory(ctx, node);\n case SerovalNodeType.IteratorFactoryInstance:\n return serializeIteratorFactoryInstance(ctx, node);\n case SerovalNodeType.AsyncIteratorFactory:\n return serializeAsyncIteratorFactory(ctx, node);\n case SerovalNodeType.AsyncIteratorFactoryInstance:\n return serializeAsyncIteratorFactoryInstance(ctx, node);\n case SerovalNodeType.StreamConstructor:\n return serializeStreamConstructor(ctx, node);\n case SerovalNodeType.StreamNext:\n return serializeStreamNext(ctx, node);\n case SerovalNodeType.StreamThrow:\n return serializeStreamThrow(ctx, node);\n case SerovalNodeType.StreamReturn:\n return serializeStreamReturn(ctx, node);\n default:\n return assignIndexedValue(ctx, node.i, serializeAssignable(ctx, node));\n }\n}\n\nexport function serializeRoot(\n ctx: SerializerContext,\n node: SerovalNode,\n): string {\n try {\n return serialize(ctx, node);\n } catch (error) {\n throw error instanceof SerovalSerializationError\n ? error\n : new SerovalSerializationError(error);\n }\n}\n\nexport function serializeTopVanilla(\n ctx: VanillaSerializerContext,\n tree: SerovalNode,\n): string {\n const result = serialize(ctx, tree);\n // Shared references detected\n if (tree.i != null && ctx.state.vars.length) {\n const patches = resolvePatches(ctx.base);\n let body = result;\n if (patches) {\n // Get (or create) a ref from the source\n const index = getRefParam(ctx, tree.i);\n body = result + ',' + patches + index;\n if (!result.startsWith(index + '=')) {\n body = index + '=' + body;\n }\n body = '(' + body + ')';\n }\n return '(' + createFunction(ctx.state.vars, body) + ')()';\n }\n if (tree.t === SerovalNodeType.Object) {\n return '(' + result + ')';\n }\n return result;\n}\n\nexport function serializeTopCross(\n ctx: CrossSerializerContext,\n tree: SerovalNode,\n): string {\n // Get the serialized result\n const result = serialize(ctx, tree);\n // If the node is a non-reference, return\n // the result immediately\n const id = tree.i;\n if (id == null) {\n return result;\n }\n // Get the patches\n const patches = resolvePatches(ctx.base);\n // Get the variable that represents the root\n const ref = getRefParam(ctx, id);\n const scopeId = ctx.state.scopeId;\n // Parameters needed for scoping\n const params = scopeId == null ? '' : GLOBAL_CONTEXT_REFERENCES;\n // If there are patches, append it after the result\n const body = patches ? '(' + result + ',' + patches + ref + ')' : result;\n // If there are no params, there's no need to generate a function\n if (params === '') {\n if (tree.t === SerovalNodeType.Object && !patches) {\n return '(' + body + ')';\n }\n return body;\n }\n // Get the arguments for the IIFE\n const args =\n scopeId == null\n ? '()'\n : '(' +\n GLOBAL_CONTEXT_REFERENCES +\n '[\"' +\n serializeString(scopeId) +\n '\"])';\n // Create the IIFE\n return '(' + createFunction([params], body) + ')' + args;\n}\n", "import {\n createAggregateErrorNode,\n createArrayNode,\n createAsyncIteratorFactoryInstanceNode,\n createBigIntNode,\n createBigIntTypedArrayNode,\n createBoxedNode,\n createDataViewNode,\n createDateNode,\n createErrorNode,\n createIteratorFactoryInstanceNode,\n createNumberNode,\n createPluginNode,\n createRegExpNode,\n createSequenceNode,\n createSetNode,\n createStreamConstructorNode,\n createStreamNextNode,\n createStreamReturnNode,\n createStreamThrowNode,\n createStringNode,\n createTypedArrayNode,\n} from '../base-primitives';\nimport { Feature } from '../compat';\nimport { NIL, SerovalNodeType } from '../constants';\nimport {\n SerovalDepthLimitError,\n SerovalParserError,\n SerovalUnsupportedTypeError,\n} from '../errors';\nimport { FALSE_NODE, NULL_NODE, TRUE_NODE, UNDEFINED_NODE } from '../literals';\nimport { createSerovalNode } from '../node';\nimport { OpaqueReference } from '../opaque-reference';\nimport { type Plugin, SerovalMode } from '../plugin';\nimport {\n createSequenceFromIterable,\n isSequence,\n type Sequence,\n} from '../sequence';\nimport { SpecialReference } from '../special-reference';\nimport type { Stream } from '../stream';\nimport {\n createStream,\n createStreamFromAsyncIterable,\n isStream,\n} from '../stream';\nimport { serializeString } from '../string';\nimport {\n SYM_ASYNC_ITERATOR,\n SYM_IS_CONCAT_SPREADABLE,\n SYM_ITERATOR,\n SYM_TO_STRING_TAG,\n} from '../symbols';\nimport type {\n SerovalAggregateErrorNode,\n SerovalArrayNode,\n SerovalBigIntTypedArrayNode,\n SerovalBoxedNode,\n SerovalDataViewNode,\n SerovalErrorNode,\n SerovalMapNode,\n SerovalNode,\n SerovalNodeWithID,\n SerovalNullConstructorNode,\n SerovalObjectNode,\n SerovalObjectRecordKey,\n SerovalObjectRecordNode,\n SerovalPluginNode,\n SerovalPromiseConstructorNode,\n SerovalSequenceNode,\n SerovalSetNode,\n SerovalTypedArrayNode,\n} from '../types';\nimport { getErrorOptions } from '../utils/error';\nimport type {\n BigIntTypedArrayValue,\n TypedArrayValue,\n} from '../utils/typed-array';\nimport type { BaseParserContext, BaseParserContextOptions } from './parser';\nimport {\n createArrayBufferNode,\n createBaseParserContext,\n createIndexForValue,\n createMapNode,\n createObjectNode,\n createPromiseConstructorNode,\n getReferenceNode,\n parseAsyncIteratorFactory,\n parseIteratorFactory,\n ParserNodeType,\n parseSpecialReference,\n parseWellKnownSymbol,\n} from './parser';\n\ntype ObjectLikeNode = SerovalObjectNode | SerovalNullConstructorNode;\n\nexport type SyncParserContextOptions = BaseParserContextOptions;\n\nconst enum ParserMode {\n Sync = 1,\n Stream = 2,\n}\n\nexport interface SyncParserContext {\n type: ParserMode.Sync;\n base: BaseParserContext;\n child: SyncParsePluginContext | undefined;\n}\n\nexport function createSyncParserContext(\n mode: SerovalMode,\n options: SyncParserContextOptions,\n): SyncParserContext {\n return {\n type: ParserMode.Sync,\n base: createBaseParserContext(mode, options),\n child: NIL,\n };\n}\n\nexport class SyncParsePluginContext {\n constructor(\n private _p: SyncParserContext,\n private depth: number,\n ) {}\n\n parse(current: T): SerovalNode {\n return parseSOS(this._p, this.depth, current);\n }\n}\n\nexport interface StreamParserContextOptions extends SyncParserContextOptions {\n onParse: (node: SerovalNode, initial: boolean) => void;\n onError?: (error: unknown) => void;\n onDone?: () => void;\n}\n\nexport interface StreamParserContext {\n type: ParserMode.Stream;\n base: BaseParserContext;\n state: StreamParserState;\n}\nexport class StreamParsePluginContext {\n constructor(\n private _p: StreamParserContext,\n private depth: number,\n ) {}\n\n parse(current: T): SerovalNode {\n return parseSOS(this._p, this.depth, current);\n }\n\n parseWithError(current: T): SerovalNode | undefined {\n return parseWithError(this._p, this.depth, current);\n }\n\n isAlive(): boolean {\n return this._p.state.alive;\n }\n\n pushPendingState(): void {\n pushPendingState(this._p);\n }\n\n popPendingState(): void {\n popPendingState(this._p);\n }\n\n onParse(node: SerovalNode): void {\n onParse(this._p, node);\n }\n\n onError(error: unknown): void {\n onError(this._p, error);\n }\n}\n\ninterface StreamParserState {\n // Life cycle\n alive: boolean;\n // Number of pending things\n pending: number;\n //\n initial: boolean;\n //\n buffer: SerovalNode[];\n // Callbacks\n onParse: (node: SerovalNode, initial: boolean) => void;\n onError?: (error: unknown) => void;\n onDone?: () => void;\n}\n\nfunction createStreamParserState(\n options: StreamParserContextOptions,\n): StreamParserState {\n return {\n alive: true,\n pending: 0,\n initial: true,\n buffer: [],\n onParse: options.onParse,\n onError: options.onError,\n onDone: options.onDone,\n };\n}\n\nexport function createStreamParserContext(\n options: StreamParserContextOptions,\n): StreamParserContext {\n return {\n type: ParserMode.Stream,\n base: createBaseParserContext(SerovalMode.Cross, options),\n state: createStreamParserState(options),\n };\n}\n\ntype SOSParserContext = SyncParserContext | StreamParserContext;\n\nfunction parseItems(\n ctx: SOSParserContext,\n depth: number,\n current: unknown[],\n): (SerovalNode | 0)[] {\n const nodes: (SerovalNode | 0)[] = [];\n for (let i = 0, len = current.length; i < len; i++) {\n if (i in current) {\n nodes[i] = parseSOS(ctx, depth, current[i]);\n } else {\n nodes[i] = 0;\n }\n }\n return nodes;\n}\n\nfunction parseArray(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: unknown[],\n): SerovalArrayNode {\n return createArrayNode(id, current, parseItems(ctx, depth, current));\n}\n\nfunction parseProperties(\n ctx: SOSParserContext,\n depth: number,\n properties: Record,\n): SerovalObjectRecordNode {\n const entries = Object.entries(properties);\n const keyNodes: SerovalObjectRecordKey[] = [];\n const valueNodes: SerovalNode[] = [];\n for (let i = 0, len = entries.length; i < len; i++) {\n keyNodes.push(serializeString(entries[i][0]));\n valueNodes.push(parseSOS(ctx, depth, entries[i][1]));\n }\n // Check special properties, symbols in this case\n if (SYM_ITERATOR in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));\n valueNodes.push(\n createIteratorFactoryInstanceNode(\n parseIteratorFactory(ctx.base),\n parseSOS(\n ctx,\n depth,\n createSequenceFromIterable(\n properties as unknown as Iterable,\n ),\n ) as SerovalNodeWithID,\n ),\n );\n }\n if (SYM_ASYNC_ITERATOR in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ASYNC_ITERATOR));\n valueNodes.push(\n createAsyncIteratorFactoryInstanceNode(\n parseAsyncIteratorFactory(ctx.base),\n parseSOS(\n ctx,\n depth,\n ctx.type === ParserMode.Sync\n ? createStream()\n : createStreamFromAsyncIterable(\n properties as unknown as AsyncIterable,\n ),\n ) as SerovalNodeWithID,\n ),\n );\n }\n if (SYM_TO_STRING_TAG in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_TO_STRING_TAG));\n valueNodes.push(createStringNode(properties[SYM_TO_STRING_TAG] as string));\n }\n if (SYM_IS_CONCAT_SPREADABLE in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_IS_CONCAT_SPREADABLE));\n valueNodes.push(\n properties[SYM_IS_CONCAT_SPREADABLE] ? TRUE_NODE : FALSE_NODE,\n );\n }\n return {\n k: keyNodes,\n v: valueNodes,\n };\n}\n\nfunction parsePlainObject(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Record,\n empty: boolean,\n): ObjectLikeNode {\n return createObjectNode(\n id,\n current,\n empty,\n parseProperties(ctx, depth, current),\n );\n}\n\nfunction parseBoxed(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: object,\n): SerovalBoxedNode {\n return createBoxedNode(id, parseSOS(ctx, depth, current.valueOf()));\n}\n\nfunction parseTypedArray(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: TypedArrayValue,\n): SerovalTypedArrayNode {\n return createTypedArrayNode(\n id,\n current,\n parseSOS(ctx, depth, current.buffer),\n );\n}\n\nfunction parseBigIntTypedArray(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: BigIntTypedArrayValue,\n): SerovalBigIntTypedArrayNode {\n return createBigIntTypedArrayNode(\n id,\n current,\n parseSOS(ctx, depth, current.buffer),\n );\n}\n\nfunction parseDataView(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: DataView,\n): SerovalDataViewNode {\n return createDataViewNode(id, current, parseSOS(ctx, depth, current.buffer));\n}\n\nfunction parseError(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Error,\n): SerovalErrorNode {\n const options = getErrorOptions(current, ctx.base.features);\n return createErrorNode(\n id,\n current,\n options ? parseProperties(ctx, depth, options) : NIL,\n );\n}\n\nfunction parseAggregateError(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: AggregateError,\n): SerovalAggregateErrorNode {\n const options = getErrorOptions(current, ctx.base.features);\n return createAggregateErrorNode(\n id,\n current,\n options ? parseProperties(ctx, depth, options) : NIL,\n );\n}\n\nfunction parseMap(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Map,\n): SerovalMapNode {\n const keyNodes: SerovalNode[] = [];\n const valueNodes: SerovalNode[] = [];\n for (const [key, value] of current.entries()) {\n keyNodes.push(parseSOS(ctx, depth, key));\n valueNodes.push(parseSOS(ctx, depth, value));\n }\n return createMapNode(ctx.base, id, keyNodes, valueNodes);\n}\n\nfunction parseSet(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Set,\n): SerovalSetNode {\n const items: SerovalNode[] = [];\n for (const item of current.keys()) {\n items.push(parseSOS(ctx, depth, item));\n }\n return createSetNode(id, items);\n}\n\nfunction parseStream(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Stream,\n): SerovalNode {\n const result = createStreamConstructorNode(\n id,\n parseSpecialReference(ctx.base, SpecialReference.StreamConstructor),\n [],\n );\n if (ctx.type === ParserMode.Sync) {\n return result;\n }\n pushPendingState(ctx);\n current.on({\n next: value => {\n if (ctx.state.alive) {\n const parsed = parseWithError(ctx, depth, value);\n if (parsed) {\n onParse(ctx, createStreamNextNode(id, parsed));\n }\n }\n },\n throw: value => {\n if (ctx.state.alive) {\n const parsed = parseWithError(ctx, depth, value);\n if (parsed) {\n onParse(ctx, createStreamThrowNode(id, parsed));\n }\n }\n popPendingState(ctx);\n },\n return: value => {\n if (ctx.state.alive) {\n const parsed = parseWithError(ctx, depth, value);\n if (parsed) {\n onParse(ctx, createStreamReturnNode(id, parsed));\n }\n }\n popPendingState(ctx);\n },\n });\n return result;\n}\n\nfunction handlePromiseSuccess(\n this: StreamParserContext,\n id: number,\n depth: number,\n data: unknown,\n): void {\n if (this.state.alive) {\n const parsed = parseWithError(this, depth, data);\n if (parsed) {\n onParse(\n this,\n createSerovalNode(\n SerovalNodeType.PromiseSuccess,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n [\n parseSpecialReference(this.base, SpecialReference.PromiseSuccess),\n parsed,\n ],\n NIL,\n NIL,\n NIL,\n NIL,\n ),\n );\n }\n popPendingState(this);\n }\n}\n\nfunction handlePromiseFailure(\n this: StreamParserContext,\n id: number,\n depth: number,\n data: unknown,\n): void {\n if (this.state.alive) {\n const parsed = parseWithError(this, depth, data);\n if (parsed) {\n onParse(\n this,\n createSerovalNode(\n SerovalNodeType.PromiseFailure,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n [\n parseSpecialReference(this.base, SpecialReference.PromiseFailure),\n parsed,\n ],\n NIL,\n NIL,\n NIL,\n NIL,\n ),\n );\n }\n }\n popPendingState(this);\n}\n\nfunction parsePromise(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Promise,\n): SerovalPromiseConstructorNode {\n // Creates a unique reference for the promise resolver\n const resolver = createIndexForValue(ctx.base, {});\n if (ctx.type === ParserMode.Stream) {\n pushPendingState(ctx);\n current.then(\n handlePromiseSuccess.bind(ctx, resolver, depth),\n handlePromiseFailure.bind(ctx, resolver, depth),\n );\n }\n return createPromiseConstructorNode(ctx.base, id, resolver);\n}\n\nfunction parsePluginSync(\n ctx: SyncParserContext,\n depth: number,\n id: number,\n current: unknown,\n currentPlugins: Plugin[],\n): SerovalPluginNode | undefined {\n for (let i = 0, len = currentPlugins.length; i < len; i++) {\n const plugin = currentPlugins[i];\n if (plugin.parse.sync && plugin.test(current)) {\n return createPluginNode(\n id,\n plugin.tag,\n plugin.parse.sync(current, new SyncParsePluginContext(ctx, depth), {\n id,\n }),\n );\n }\n }\n return NIL;\n}\n\nfunction parsePluginStream(\n ctx: StreamParserContext,\n depth: number,\n id: number,\n current: unknown,\n currentPlugins: Plugin[],\n): SerovalPluginNode | undefined {\n for (let i = 0, len = currentPlugins.length; i < len; i++) {\n const plugin = currentPlugins[i];\n if (plugin.parse.stream && plugin.test(current)) {\n return createPluginNode(\n id,\n plugin.tag,\n plugin.parse.stream(current, new StreamParsePluginContext(ctx, depth), {\n id,\n }),\n );\n }\n }\n return NIL;\n}\n\nfunction parsePlugin(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: unknown,\n): SerovalPluginNode | undefined {\n const currentPlugins = ctx.base.plugins;\n if (currentPlugins) {\n return ctx.type === ParserMode.Sync\n ? parsePluginSync(ctx, depth, id, current, currentPlugins)\n : parsePluginStream(ctx, depth, id, current, currentPlugins);\n }\n return NIL;\n}\n\nfunction parseSequence(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Sequence,\n): SerovalSequenceNode {\n const nodes: SerovalNode[] = [];\n for (let i = 0, len = current.v.length; i < len; i++) {\n nodes[i] = parseSOS(ctx, depth, current.v[i]);\n }\n return createSequenceNode(id, nodes, current.t, current.d);\n}\n\nfunction parseObjectPhase2(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: object,\n currentClass: unknown,\n): SerovalNode {\n switch (currentClass) {\n case Object:\n return parsePlainObject(\n ctx,\n depth,\n id,\n current as Record,\n false,\n );\n case NIL:\n return parsePlainObject(\n ctx,\n depth,\n id,\n current as Record,\n true,\n );\n case Date:\n return createDateNode(id, current as unknown as Date);\n case Error:\n case EvalError:\n case RangeError:\n case ReferenceError:\n case SyntaxError:\n case TypeError:\n case URIError:\n return parseError(ctx, depth, id, current as unknown as Error);\n case Number:\n case Boolean:\n case String:\n case BigInt:\n return parseBoxed(ctx, depth, id, current);\n case ArrayBuffer:\n return createArrayBufferNode(\n ctx.base,\n id,\n current as unknown as ArrayBuffer,\n );\n case Int8Array:\n case Int16Array:\n case Int32Array:\n case Uint8Array:\n case Uint16Array:\n case Uint32Array:\n case Uint8ClampedArray:\n case Float32Array:\n case Float64Array:\n return parseTypedArray(\n ctx,\n depth,\n id,\n current as unknown as TypedArrayValue,\n );\n case DataView:\n return parseDataView(ctx, depth, id, current as unknown as DataView);\n case Map:\n return parseMap(\n ctx,\n depth,\n id,\n current as unknown as Map,\n );\n case Set:\n return parseSet(ctx, depth, id, current as unknown as Set);\n default:\n break;\n }\n // Promises\n if (currentClass === Promise || current instanceof Promise) {\n return parsePromise(ctx, depth, id, current as unknown as Promise);\n }\n const currentFeatures = ctx.base.features;\n if (currentFeatures & Feature.RegExp && currentClass === RegExp) {\n return createRegExpNode(id, current as unknown as RegExp);\n }\n // BigInt Typed Arrays\n if (currentFeatures & Feature.BigIntTypedArray) {\n switch (currentClass) {\n case BigInt64Array:\n case BigUint64Array:\n return parseBigIntTypedArray(\n ctx,\n depth,\n id,\n current as unknown as BigIntTypedArrayValue,\n );\n default:\n break;\n }\n }\n if (\n currentFeatures & Feature.AggregateError &&\n typeof AggregateError !== 'undefined' &&\n (currentClass === AggregateError || current instanceof AggregateError)\n ) {\n return parseAggregateError(\n ctx,\n depth,\n id,\n current as unknown as AggregateError,\n );\n }\n // Slow path. We only need to handle Errors and Iterators\n // since they have very broad implementations.\n if (current instanceof Error) {\n return parseError(ctx, depth, id, current);\n }\n // Generator functions don't have a global constructor\n // despite existing\n if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) {\n return parsePlainObject(ctx, depth, id, current, !!currentClass);\n }\n throw new SerovalUnsupportedTypeError(current);\n}\n\nfunction parseObject(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: object,\n): SerovalNode {\n if (Array.isArray(current)) {\n return parseArray(ctx, depth, id, current);\n }\n if (isStream(current)) {\n return parseStream(ctx, depth, id, current);\n }\n if (isSequence(current)) {\n return parseSequence(ctx, depth, id, current);\n }\n const currentClass = current.constructor;\n if (currentClass === OpaqueReference) {\n return parseSOS(\n ctx,\n depth,\n (current as OpaqueReference).replacement,\n );\n }\n const parsed = parsePlugin(ctx, depth, id, current);\n if (parsed) {\n return parsed;\n }\n return parseObjectPhase2(ctx, depth, id, current, currentClass);\n}\n\nfunction parseFunction(\n ctx: SOSParserContext,\n depth: number,\n current: unknown,\n): SerovalNode {\n const ref = getReferenceNode(ctx.base, current);\n if (ref.type !== ParserNodeType.Fresh) {\n return ref.value;\n }\n const plugin = parsePlugin(ctx, depth, ref.value, current);\n if (plugin) {\n return plugin;\n }\n throw new SerovalUnsupportedTypeError(current);\n}\n\nexport function parseSOS(\n ctx: SOSParserContext,\n depth: number,\n current: T,\n): SerovalNode {\n if (depth >= ctx.base.depthLimit) {\n throw new SerovalDepthLimitError(ctx.base.depthLimit);\n }\n switch (typeof current) {\n case 'boolean':\n return current ? TRUE_NODE : FALSE_NODE;\n case 'undefined':\n return UNDEFINED_NODE;\n case 'string':\n return createStringNode(current as string);\n case 'number':\n return createNumberNode(current as number);\n case 'bigint':\n return createBigIntNode(current as bigint);\n case 'object': {\n if (current) {\n const ref = getReferenceNode(ctx.base, current);\n return ref.type === ParserNodeType.Fresh\n ? parseObject(ctx, depth + 1, ref.value, current as object)\n : ref.value;\n }\n return NULL_NODE;\n }\n case 'symbol':\n return parseWellKnownSymbol(ctx.base, current);\n case 'function': {\n return parseFunction(ctx, depth, current);\n }\n default:\n throw new SerovalUnsupportedTypeError(current);\n }\n}\n\nexport function parseTop(ctx: SyncParserContext, current: T): SerovalNode {\n try {\n return parseSOS(ctx, 0, current);\n } catch (error) {\n throw error instanceof SerovalParserError\n ? error\n : new SerovalParserError(error);\n }\n}\n\nfunction onParse(ctx: StreamParserContext, node: SerovalNode): void {\n // If the value emitted happens to be during parsing, we push to the\n // buffer and emit after the initial parsing is done.\n if (ctx.state.initial) {\n ctx.state.buffer.push(node);\n } else {\n onParseInternal(ctx, node, false);\n }\n}\n\nfunction onError(ctx: StreamParserContext, error: unknown): void {\n if (ctx.state.onError) {\n ctx.state.onError(error);\n } else {\n throw error instanceof SerovalParserError\n ? error\n : new SerovalParserError(error);\n }\n}\n\nfunction onDone(ctx: StreamParserContext): void {\n if (ctx.state.onDone) {\n ctx.state.onDone();\n }\n}\n\nfunction onParseInternal(\n ctx: StreamParserContext,\n node: SerovalNode,\n initial: boolean,\n): void {\n try {\n ctx.state.onParse(node, initial);\n } catch (error) {\n onError(ctx, error);\n }\n}\n\nfunction pushPendingState(ctx: StreamParserContext): void {\n ctx.state.pending++;\n}\n\nfunction popPendingState(ctx: StreamParserContext): void {\n if (--ctx.state.pending <= 0) {\n onDone(ctx);\n }\n}\n\nfunction parseWithError(\n ctx: StreamParserContext,\n depth: number,\n current: T,\n): SerovalNode | undefined {\n try {\n return parseSOS(ctx, depth, current);\n } catch (err) {\n onError(ctx, err);\n return NIL;\n }\n}\n\nexport function startStreamParse(\n ctx: StreamParserContext,\n current: T,\n): void {\n const parsed = parseWithError(ctx, 0, current);\n if (parsed) {\n onParseInternal(ctx, parsed, true);\n ctx.state.initial = false;\n flushStreamParse(ctx, ctx.state);\n\n // Check if there's any pending pushes\n if (ctx.state.pending <= 0) {\n destroyStreamParse(ctx);\n }\n }\n}\n\nfunction flushStreamParse(\n ctx: StreamParserContext,\n state: StreamParserState,\n): void {\n for (let i = 0, len = state.buffer.length; i < len; i++) {\n onParseInternal(ctx, state.buffer[i], false);\n }\n}\n\nexport function destroyStreamParse(ctx: StreamParserContext): void {\n if (ctx.state.alive) {\n onDone(ctx);\n ctx.state.alive = false;\n }\n}\n", "import type { AsyncParserContextOptions } from '../context/async-parser';\nimport {\n createAsyncParserContext,\n parseTopAsync,\n} from '../context/async-parser';\nimport type { CrossDeserializerContextOptions } from '../context/deserializer';\nimport {\n createCrossDeserializerContext,\n deserializeTop,\n} from '../context/deserializer';\nimport type { CrossContextOptions } from '../context/serializer';\nimport {\n createCrossSerializerContext,\n serializeTopCross,\n} from '../context/serializer';\nimport type {\n StreamParserContextOptions,\n SyncParserContextOptions,\n} from '../context/sync-parser';\nimport {\n createStreamParserContext,\n createSyncParserContext,\n destroyStreamParse,\n parseTop,\n startStreamParse,\n} from '../context/sync-parser';\nimport { resolvePlugins, SerovalMode } from '../plugin';\nimport type { SerovalNode } from '../types';\n\nexport interface CrossSerializeOptions\n extends SyncParserContextOptions,\n CrossContextOptions {}\n\nexport function crossSerialize(\n source: T,\n options: CrossSerializeOptions = {},\n): string {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createSyncParserContext(SerovalMode.Cross, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n refs: options.refs,\n });\n const tree = parseTop(ctx, source);\n const serial = createCrossSerializerContext({\n plugins,\n features: ctx.base.features,\n scopeId: options.scopeId,\n markedRefs: ctx.base.marked,\n });\n return serializeTopCross(serial, tree);\n}\n\nexport interface CrossSerializeAsyncOptions\n extends AsyncParserContextOptions,\n CrossContextOptions {}\n\nexport async function crossSerializeAsync(\n source: T,\n options: CrossSerializeAsyncOptions = {},\n): Promise {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createAsyncParserContext(SerovalMode.Cross, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n refs: options.refs,\n });\n const tree = await parseTopAsync(ctx, source);\n const serial = createCrossSerializerContext({\n plugins,\n features: ctx.base.features,\n scopeId: options.scopeId,\n markedRefs: ctx.base.marked,\n });\n return serializeTopCross(serial, tree);\n}\n\nexport type ToCrossJSONOptions = SyncParserContextOptions;\n\nexport function toCrossJSON(\n source: T,\n options: ToCrossJSONOptions = {},\n): SerovalNode {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createSyncParserContext(SerovalMode.Cross, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n refs: options.refs,\n });\n return parseTop(ctx, source);\n}\n\nexport type ToCrossJSONAsyncOptions = AsyncParserContextOptions;\n\nexport async function toCrossJSONAsync(\n source: T,\n options: ToCrossJSONAsyncOptions = {},\n): Promise {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createAsyncParserContext(SerovalMode.Cross, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n refs: options.refs,\n });\n return await parseTopAsync(ctx, source);\n}\n\nexport interface CrossSerializeStreamOptions\n extends Omit,\n CrossContextOptions {\n onSerialize: (data: string, initial: boolean) => void;\n}\n\nexport function crossSerializeStream(\n source: T,\n options: CrossSerializeStreamOptions,\n): () => void {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createStreamParserContext({\n plugins,\n refs: options.refs,\n disabledFeatures: options.disabledFeatures,\n onParse(node, initial): void {\n const serial = createCrossSerializerContext({\n plugins,\n features: ctx.base.features,\n scopeId: options.scopeId,\n markedRefs: ctx.base.marked,\n });\n\n let serialized: string;\n\n try {\n serialized = serializeTopCross(serial, node);\n } catch (err) {\n if (options.onError) {\n options.onError(err);\n }\n return;\n }\n\n options.onSerialize(serialized, initial);\n },\n onError: options.onError,\n onDone: options.onDone,\n });\n\n startStreamParse(ctx, source);\n\n return destroyStreamParse.bind(null, ctx);\n}\n\nexport type ToCrossJSONStreamOptions = StreamParserContextOptions;\n\nexport function toCrossJSONStream(\n source: T,\n options: ToCrossJSONStreamOptions,\n): () => void {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createStreamParserContext({\n plugins,\n refs: options.refs,\n disabledFeatures: options.disabledFeatures,\n depthLimit: options.depthLimit,\n onParse: options.onParse,\n onError: options.onError,\n onDone: options.onDone,\n });\n\n startStreamParse(ctx, source);\n\n return destroyStreamParse.bind(null, ctx);\n}\n\nexport type FromCrossJSONOptions = CrossDeserializerContextOptions;\n\nexport function fromCrossJSON(\n source: SerovalNode,\n options: FromCrossJSONOptions,\n): T {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createCrossDeserializerContext({\n plugins,\n refs: options.refs,\n features: options.features,\n disabledFeatures: options.disabledFeatures,\n depthLimit: options.depthLimit,\n });\n return deserializeTop(ctx, source) as T;\n}\n", "import { crossSerializeStream } from './cross';\nimport {\n resolvePlugins,\n type Plugin,\n type PluginAccessOptions,\n} from './plugin';\nimport { serializeString } from './string';\n\nexport interface SerializerOptions extends PluginAccessOptions {\n globalIdentifier: string;\n scopeId?: string;\n disabledFeatures?: number;\n onData: (result: string) => void;\n onError: (error: unknown) => void;\n onDone?: () => void;\n}\n\nexport default class Serializer {\n private alive = true;\n\n private flushed = false;\n\n private done = false;\n\n private pending = 0;\n\n private cleanups: (() => void)[] = [];\n\n private refs = new Map();\n\n private plugins?: Plugin[];\n\n constructor(private options: SerializerOptions) {\n this.plugins = resolvePlugins(options.plugins);\n }\n\n keys = new Set();\n\n write(key: string, value: unknown): void {\n if (this.alive && !this.flushed) {\n this.pending++;\n this.keys.add(key);\n this.cleanups.push(\n crossSerializeStream(value, {\n plugins: this.plugins,\n scopeId: this.options.scopeId,\n refs: this.refs,\n disabledFeatures: this.options.disabledFeatures,\n onError: this.options.onError,\n onSerialize: (data, initial) => {\n if (this.alive) {\n this.options.onData(\n initial\n ? this.options.globalIdentifier +\n '[\"' +\n serializeString(key) +\n '\"]=' +\n data\n : data,\n );\n }\n },\n onDone: () => {\n if (this.alive) {\n this.pending--;\n if (\n this.pending <= 0 &&\n this.flushed &&\n !this.done &&\n this.options.onDone\n ) {\n this.options.onDone();\n this.done = true;\n }\n }\n },\n }),\n );\n }\n }\n\n ids = 0;\n\n private getNextID(): string {\n while (this.keys.has('' + this.ids)) {\n this.ids++;\n }\n return '' + this.ids;\n }\n\n push(value: unknown): string {\n const newID = this.getNextID();\n this.write(newID, value);\n return newID;\n }\n\n flush(): void {\n if (this.alive) {\n this.flushed = true;\n if (this.pending <= 0 && !this.done && this.options.onDone) {\n this.options.onDone();\n this.done = true;\n }\n }\n }\n\n close(): void {\n if (this.alive) {\n for (let i = 0, len = this.cleanups.length; i < len; i++) {\n this.cleanups[i]();\n }\n if (!this.done && this.options.onDone) {\n this.options.onDone();\n this.done = true;\n }\n this.alive = false;\n }\n }\n}\n", "import {\n createAsyncParserContext,\n parseTopAsync,\n} from '../context/async-parser';\nimport {\n createVanillaDeserializerContext,\n deserializeTop,\n} from '../context/deserializer';\nimport type { BaseParserContextOptions } from '../context/parser';\nimport {\n createVanillaSerializerContext,\n serializeTopVanilla,\n} from '../context/serializer';\nimport { createSyncParserContext, parseTop } from '../context/sync-parser';\nimport {\n type PluginAccessOptions,\n resolvePlugins,\n SerovalMode,\n} from '../plugin';\nimport type { SerovalNode } from '../types';\nimport { ALL_ENABLED } from '../compat';\nexport type SyncParserContextOptions = Omit;\nexport type AsyncParserContextOptions = Omit;\n\nexport function serialize(\n source: T,\n options: SyncParserContextOptions = {},\n): string {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createSyncParserContext(SerovalMode.Vanilla, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n });\n const tree = parseTop(ctx, source);\n const serial = createVanillaSerializerContext({\n plugins,\n features: ctx.base.features,\n markedRefs: ctx.base.marked,\n });\n return serializeTopVanilla(serial, tree);\n}\n\nexport async function serializeAsync(\n source: T,\n options: AsyncParserContextOptions = {},\n): Promise {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createAsyncParserContext(SerovalMode.Vanilla, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n });\n const tree = await parseTopAsync(ctx, source);\n const serial = createVanillaSerializerContext({\n plugins,\n features: ctx.base.features,\n markedRefs: ctx.base.marked,\n });\n return serializeTopVanilla(serial, tree);\n}\n\nexport function deserialize(source: string): T {\n return (0, eval)(source) as T;\n}\n\nexport interface SerovalJSON {\n t: SerovalNode;\n f: number;\n m: number[];\n}\n\nexport interface FromJSONOptions extends PluginAccessOptions {\n disabledFeatures?: number;\n}\n\nexport function toJSON(\n source: T,\n options: SyncParserContextOptions = {},\n): SerovalJSON {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createSyncParserContext(SerovalMode.Vanilla, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n });\n return {\n t: parseTop(ctx, source),\n f: ctx.base.features,\n m: Array.from(ctx.base.marked),\n };\n}\n\nexport async function toJSONAsync(\n source: T,\n options: AsyncParserContextOptions = {},\n): Promise {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createAsyncParserContext(SerovalMode.Vanilla, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n });\n return {\n t: await parseTopAsync(ctx, source),\n f: ctx.base.features,\n m: Array.from(ctx.base.marked),\n };\n}\n\nexport function compileJSON(\n source: SerovalJSON,\n options: PluginAccessOptions = {},\n): string {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createVanillaSerializerContext({\n plugins,\n features: source.f,\n markedRefs: source.m,\n });\n return serializeTopVanilla(ctx, source.t);\n}\n\nexport function fromJSON(\n source: SerovalJSON,\n options: FromJSONOptions = {},\n): T {\n const plugins = resolvePlugins(options.plugins);\n const disabledFeatures = options.disabledFeatures || 0;\n const sourceFeatures = source.f ?? ALL_ENABLED;\n const ctx = createVanillaDeserializerContext({\n plugins,\n markedRefs: source.m,\n features: sourceFeatures & ~disabledFeatures,\n disabledFeatures,\n });\n return deserializeTop(ctx, source.t) as T;\n}\n", "import { createPlugin } from 'seroval'\nimport { GLOBAL_TSR } from '../constants'\nimport type { Plugin, SerovalNode } from 'seroval'\nimport type {\n RegisteredConfigType,\n RegisteredSsr,\n SSROption,\n} from '../../router'\nimport type { LooseReturnType } from '../../utils'\nimport type { AnyRoute, ResolveAllSSR } from '../../route'\nimport type { RawStream } from './RawStream'\n\ndeclare const TSR_SERIALIZABLE: unique symbol\nexport type TSR_SERIALIZABLE = typeof TSR_SERIALIZABLE\n\nexport type TsrSerializable = { [TSR_SERIALIZABLE]: true }\nexport interface DefaultSerializable {\n number: number\n string: string\n boolean: boolean\n null: null\n undefined: undefined\n bigint: bigint\n Date: Date\n Uint8Array: Uint8Array\n RawStream: RawStream\n TsrSerializable: TsrSerializable\n}\n\nexport interface SerializableExtensions extends DefaultSerializable {}\n\nexport type Serializable = SerializableExtensions[keyof SerializableExtensions]\n\nexport type UnionizeSerializationAdaptersInput<\n TAdapters extends ReadonlyArray,\n> = TAdapters[number]['~types']['input']\n\n/**\n * Create a strongly-typed serialization adapter for SSR hydration.\n * Use to register custom types with the router serializer.\n */\nexport function createSerializationAdapter<\n TInput = unknown,\n TOutput = unknown,\n const TExtendsAdapters extends\n | ReadonlyArray\n | never = never,\n>(\n opts: CreateSerializationAdapterOptions,\n): SerializationAdapter {\n return opts as unknown as SerializationAdapter<\n TInput,\n TOutput,\n TExtendsAdapters\n >\n}\n\nexport interface CreateSerializationAdapterOptions<\n TInput,\n TOutput,\n TExtendsAdapters extends ReadonlyArray | never,\n> {\n key: string\n extends?: TExtendsAdapters\n test: (value: unknown) => value is TInput\n toSerializable: (\n value: TInput,\n ) => ValidateSerializable<\n TOutput,\n Serializable | UnionizeSerializationAdaptersInput\n >\n fromSerializable: (value: TOutput) => TInput\n}\n\nexport type ValidateSerializable =\n T extends ReadonlyArray\n ? ResolveArrayShape\n : T extends TSerializable\n ? T\n : T extends (...args: Array) => any\n ? 'Function is not serializable'\n : T extends Promise\n ? ValidateSerializablePromise\n : T extends ReadableStream\n ? ValidateReadableStream\n : T extends Set\n ? ValidateSerializableSet\n : T extends Map\n ? ValidateSerializableMap\n : T extends AsyncGenerator\n ? ValidateSerializableAsyncGenerator\n : {\n [K in keyof T]: ValidateSerializable\n }\n\nexport type ValidateSerializableAsyncGenerator =\n T extends AsyncGenerator\n ? AsyncGenerator<\n ValidateSerializable,\n ValidateSerializable,\n TNext\n >\n : never\n\nexport type ValidateSerializablePromise =\n T extends Promise\n ? Promise>\n : never\n\nexport type ValidateReadableStream =\n T extends ReadableStream\n ? ReadableStream>\n : never\n\nexport type ValidateSerializableSet =\n T extends Set\n ? Set>\n : never\n\nexport type ValidateSerializableMap =\n T extends Map\n ? Map<\n ValidateSerializable,\n ValidateSerializable\n >\n : never\n\nexport type RegisteredReadableStream =\n unknown extends SerializerExtensions['ReadableStream']\n ? never\n : SerializerExtensions['ReadableStream']\n\nexport interface DefaultSerializerExtensions {\n ReadableStream: unknown\n}\n\nexport interface SerializerExtensions extends DefaultSerializerExtensions {}\n\nexport interface SerializationAdapter<\n TInput,\n TOutput,\n TExtendsAdapters extends ReadonlyArray,\n> {\n '~types': SerializationAdapterTypes\n key: string\n extends?: TExtendsAdapters\n test: (value: unknown) => value is TInput\n toSerializable: (value: TInput) => TOutput\n fromSerializable: (value: TOutput) => TInput\n}\n\nexport interface SerializationAdapterTypes<\n TInput,\n TOutput,\n TExtendsAdapters extends ReadonlyArray,\n> {\n input: TInput | UnionizeSerializationAdaptersInput\n output: TOutput\n extends: TExtendsAdapters\n}\n\nexport type AnySerializationAdapter = SerializationAdapter\n\n/** Create a Seroval plugin for server-side serialization only. */\nexport function makeSsrSerovalPlugin(\n serializationAdapter: AnySerializationAdapter,\n options: { didRun: boolean },\n): Plugin {\n return createPlugin({\n tag: '$TSR/t/' + serializationAdapter.key,\n test: serializationAdapter.test,\n parse: {\n stream(value, ctx) {\n return ctx.parse(serializationAdapter.toSerializable(value))\n },\n },\n serialize(node, ctx) {\n options.didRun = true\n return (\n GLOBAL_TSR +\n '.t.get(\"' +\n serializationAdapter.key +\n '\")(' +\n ctx.serialize(node) +\n ')'\n )\n },\n // we never deserialize on the server during SSR\n deserialize: undefined as never,\n })\n}\n\n/** Create a Seroval plugin for client/server symmetric (de)serialization. */\nexport function makeSerovalPlugin(\n serializationAdapter: AnySerializationAdapter,\n): Plugin {\n return createPlugin({\n tag: '$TSR/t/' + serializationAdapter.key,\n test: serializationAdapter.test,\n parse: {\n sync(value, ctx) {\n return ctx.parse(serializationAdapter.toSerializable(value))\n },\n async async(value, ctx) {\n return await ctx.parse(serializationAdapter.toSerializable(value))\n },\n stream(value, ctx) {\n return ctx.parse(serializationAdapter.toSerializable(value))\n },\n },\n // we don't generate JS code outside of SSR (for now)\n serialize: undefined as never,\n deserialize(node, ctx) {\n return serializationAdapter.fromSerializable(ctx.deserialize(node))\n },\n })\n}\n\nexport type ValidateSerializableInput = ValidateSerializable<\n T,\n RegisteredSerializableInput\n>\n\nexport type RegisteredSerializableInput =\n | (unknown extends RegisteredSerializationAdapters\n ? never\n : RegisteredSerializationAdapters extends ReadonlyArray\n ? RegisteredSerializationAdapters[number]['~types']['input']\n : never)\n | Serializable\n\nexport type RegisteredSerializationAdapters = RegisteredConfigType<\n TRegister,\n 'serializationAdapters'\n>\n\nexport type ValidateSerializableInputResult =\n ValidateSerializableResult>\n\nexport type ValidateSerializableResult =\n T extends ReadonlyArray\n ? ResolveArrayShape\n : T extends TSerializable\n ? T\n : unknown extends SerializerExtensions['ReadableStream']\n ? { [K in keyof T]: ValidateSerializableResult }\n : T extends SerializerExtensions['ReadableStream']\n ? ReadableStream\n : { [K in keyof T]: ValidateSerializableResult }\n\nexport type RegisteredSSROption =\n unknown extends RegisteredConfigType\n ? SSROption\n : RegisteredConfigType\n\nexport type ValidateSerializableLifecycleResult<\n TRegister,\n TParentRoute extends AnyRoute,\n TSSR,\n TFn,\n> =\n false extends RegisteredSsr\n ? any\n : ValidateSerializableLifecycleResultSSR<\n TRegister,\n TParentRoute,\n TSSR,\n TFn\n > extends infer TInput\n ? TInput\n : never\n\nexport type ValidateSerializableLifecycleResultSSR<\n TRegister,\n TParentRoute extends AnyRoute,\n TSSR,\n TFn,\n> =\n ResolveAllSSR extends false\n ? any\n : RegisteredSSROption extends false\n ? any\n : ValidateSerializableInput>\n\ntype ResolveArrayShape<\n T extends ReadonlyArray,\n TSerializable,\n TMode extends 'input' | 'result',\n> = number extends T['length']\n ? T extends Array\n ? Array>\n : ReadonlyArray>\n : ResolveTupleShape\n\ntype ResolveTupleShape<\n T extends ReadonlyArray,\n TSerializable,\n TMode extends 'input' | 'result',\n> = T extends readonly [infer THead, ...infer TTail]\n ? readonly [\n ArrayModeResult,\n ...ResolveTupleShape, TSerializable, TMode>,\n ]\n : T\n\ntype ArrayModeResult<\n TMode extends 'input' | 'result',\n TValue,\n TSerializable,\n> = TMode extends 'input'\n ? ValidateSerializable\n : ValidateSerializableResult\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nconst PROMISE_TO_ABORT_SIGNAL = (promise: Promise) => {\n const controller = new AbortController();\n const abort = controller.abort.bind(controller);\n promise.then(abort, abort);\n return controller;\n};\n\nfunction resolveAbortSignalResult(\n this: AbortSignal,\n resolve: (value: unknown) => void,\n): void {\n resolve(this.reason);\n}\n\nfunction resolveAbortSignal(\n this: AbortSignal,\n resolve: (value: unknown) => void,\n): void {\n this.addEventListener('abort', resolveAbortSignalResult.bind(this, resolve), {\n once: true,\n });\n}\n\nfunction abortSignalToPromise(signal: AbortSignal): Promise {\n return new Promise(resolveAbortSignal.bind(signal));\n}\n\nconst ABORT_CONTROLLER = {};\n\nconst AbortControllerFactoryPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/AbortControllerFactoryPlugin',\n test(value) {\n return value === ABORT_CONTROLLER;\n },\n parse: {\n sync() {\n return ABORT_CONTROLLER;\n },\n async async() {\n return await Promise.resolve(ABORT_CONTROLLER);\n },\n stream() {\n return ABORT_CONTROLLER;\n },\n },\n serialize() {\n return PROMISE_TO_ABORT_SIGNAL.toString();\n },\n deserialize() {\n return PROMISE_TO_ABORT_SIGNAL;\n },\n});\n\nconst AbortSignalPlugin = /* @__PURE__ */ createPlugin<\n AbortSignal,\n { reason?: SerovalNode; controller?: SerovalNode; factory?: SerovalNode }\n>({\n tag: 'seroval-plugins/web/AbortSignal',\n extends: [AbortControllerFactoryPlugin],\n test(value) {\n if (typeof AbortSignal === 'undefined') {\n return false;\n }\n return value instanceof AbortSignal;\n },\n parse: {\n sync(value, ctx) {\n if (value.aborted) {\n return {\n reason: ctx.parse(value.reason),\n };\n }\n return {};\n },\n async async(value, ctx) {\n if (value.aborted) {\n return {\n reason: await ctx.parse(value.reason),\n };\n }\n const result = await abortSignalToPromise(value);\n return {\n reason: await ctx.parse(result),\n };\n },\n stream(value, ctx) {\n if (value.aborted) {\n return {\n reason: ctx.parse(value.reason),\n };\n }\n\n const promise = abortSignalToPromise(value);\n\n return {\n factory: ctx.parse(ABORT_CONTROLLER),\n controller: ctx.parse(promise),\n };\n },\n },\n serialize(node, ctx) {\n if (node.reason) {\n return 'AbortSignal.abort(' + ctx.serialize(node.reason) + ')';\n }\n if (node.controller && node.factory) {\n return (\n '(' +\n ctx.serialize(node.factory) +\n ')(' +\n ctx.serialize(node.controller) +\n ').signal'\n );\n }\n return '(new AbortController).signal';\n },\n deserialize(node, ctx) {\n if (node.reason) {\n return AbortSignal.abort(ctx.deserialize(node.reason));\n }\n if (node.controller) {\n return PROMISE_TO_ABORT_SIGNAL(ctx.deserialize(node.controller)).signal;\n }\n const controller = new AbortController();\n return controller.signal;\n },\n});\n\nexport default AbortSignalPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\ntype BlobNode = {\n type: SerovalNode;\n buffer: SerovalNode;\n};\n\nconst BlobPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/Blob',\n test(value) {\n if (typeof Blob === 'undefined') {\n return false;\n }\n return value instanceof Blob;\n },\n parse: {\n async async(value, ctx) {\n return {\n type: await ctx.parse(value.type),\n buffer: await ctx.parse(await value.arrayBuffer()),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new Blob([' +\n ctx.serialize(node.buffer) +\n '],{type:' +\n ctx.serialize(node.type) +\n '})'\n );\n },\n deserialize(node, ctx) {\n return new Blob([ctx.deserialize(node.buffer) as ArrayBuffer], {\n type: ctx.deserialize(node.type) as string,\n });\n },\n});\n\nexport default BlobPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nfunction createCustomEventOptions(current: CustomEvent): CustomEventInit {\n return {\n detail: current.detail as unknown,\n bubbles: current.bubbles,\n cancelable: current.cancelable,\n composed: current.composed,\n };\n}\n\ntype CustomEventNode = {\n type: SerovalNode;\n options: SerovalNode;\n};\n\nconst CustomEventPlugin = /* @__PURE__ */ createPlugin<\n CustomEvent,\n CustomEventNode\n>({\n tag: 'seroval-plugins/web/CustomEvent',\n test(value) {\n if (typeof CustomEvent === 'undefined') {\n return false;\n }\n return value instanceof CustomEvent;\n },\n parse: {\n sync(value, ctx) {\n return {\n type: ctx.parse(value.type),\n options: ctx.parse(createCustomEventOptions(value)),\n };\n },\n async async(value, ctx) {\n return {\n type: await ctx.parse(value.type),\n options: await ctx.parse(createCustomEventOptions(value)),\n };\n },\n stream(value, ctx) {\n return {\n type: ctx.parse(value.type),\n options: ctx.parse(createCustomEventOptions(value)),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new CustomEvent(' +\n ctx.serialize(node.type) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new CustomEvent(\n ctx.deserialize(node.type) as string,\n ctx.deserialize(node.options) as CustomEventInit,\n );\n },\n});\n\nexport default CustomEventPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\ntype DOMExceptionNode = {\n name: SerovalNode;\n message: SerovalNode;\n};\n\nconst DOMExceptionPlugin = /* @__PURE__ */ createPlugin<\n DOMException,\n DOMExceptionNode\n>({\n tag: 'seroval-plugins/web/DOMException',\n test(value) {\n if (typeof DOMException === 'undefined') {\n return false;\n }\n return value instanceof DOMException;\n },\n parse: {\n sync(value, ctx) {\n return {\n name: ctx.parse(value.name),\n message: ctx.parse(value.message),\n };\n },\n async async(value, ctx) {\n return {\n name: await ctx.parse(value.name),\n message: await ctx.parse(value.message),\n };\n },\n stream(value, ctx) {\n return {\n name: ctx.parse(value.name),\n message: ctx.parse(value.message),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new DOMException(' +\n ctx.serialize(node.message) +\n ',' +\n ctx.serialize(node.name) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new DOMException(\n ctx.deserialize(node.message) as string,\n ctx.deserialize(node.name) as string,\n );\n },\n});\n\nexport default DOMExceptionPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nfunction createEventOptions(current: Event): EventInit {\n return {\n bubbles: current.bubbles,\n cancelable: current.cancelable,\n composed: current.composed,\n };\n}\n\ntype EventNode = {\n type: SerovalNode;\n options: SerovalNode;\n};\n\nconst EventPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/Event',\n test(value) {\n if (typeof Event === 'undefined') {\n return false;\n }\n return value instanceof Event;\n },\n parse: {\n sync(value, ctx) {\n return {\n type: ctx.parse(value.type),\n options: ctx.parse(createEventOptions(value)),\n };\n },\n async async(value, ctx) {\n return {\n type: await ctx.parse(value.type),\n options: await ctx.parse(createEventOptions(value)),\n };\n },\n stream(value, ctx) {\n return {\n type: ctx.parse(value.type),\n options: ctx.parse(createEventOptions(value)),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new Event(' +\n ctx.serialize(node.type) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new Event(\n ctx.deserialize(node.type) as string,\n ctx.deserialize(node.options) as EventInit,\n );\n },\n});\n\nexport default EventPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\ntype FileNode = {\n name: SerovalNode;\n options: SerovalNode;\n buffer: SerovalNode;\n};\n\nconst FilePlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/File',\n test(value) {\n if (typeof File === 'undefined') {\n return false;\n }\n return value instanceof File;\n },\n parse: {\n async async(value, ctx) {\n return {\n name: await ctx.parse(value.name),\n options: await ctx.parse({\n type: value.type,\n lastModified: value.lastModified,\n }),\n buffer: await ctx.parse(await value.arrayBuffer()),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new File([' +\n ctx.serialize(node.buffer) +\n '],' +\n ctx.serialize(node.name) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new File(\n [ctx.deserialize(node.buffer) as ArrayBuffer],\n ctx.deserialize(node.name) as string,\n ctx.deserialize(node.options) as FilePropertyBag,\n );\n },\n});\n\nexport default FilePlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\nimport FilePlugin from './file';\n\ntype FormDataInit = [key: string, value: FormDataEntryValue][];\n\nfunction convertFormData(instance: FormData): FormDataInit {\n const items: FormDataInit = [];\n instance.forEach((value, key) => {\n items.push([key, value]);\n });\n return items;\n}\n\nconst FORM_DATA_FACTORY = {};\n\nconst FORM_DATA_FACTORY_CONSTRUCTOR = (\n e: [key: string, value: FormDataEntryValue][],\n f = new FormData(),\n i = 0,\n s = e.length,\n t?: [key: string, value: FormDataEntryValue],\n) => {\n for (; i < s; i++) {\n t = e[i];\n f.append(t[0], t[1]);\n }\n return f;\n};\n\nconst FormDataFactoryPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/FormDataFactory',\n test(value) {\n return value === FORM_DATA_FACTORY;\n },\n parse: {\n sync() {\n return FORM_DATA_FACTORY;\n },\n async async() {\n return await Promise.resolve(FORM_DATA_FACTORY);\n },\n stream() {\n return FORM_DATA_FACTORY;\n },\n },\n serialize() {\n return FORM_DATA_FACTORY_CONSTRUCTOR.toString();\n },\n deserialize() {\n return FORM_DATA_FACTORY;\n },\n});\n\ntype FormDataNode = {\n factory: SerovalNode;\n entries: SerovalNode;\n};\n\nconst FormDataPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/FormData',\n extends: [FilePlugin, FormDataFactoryPlugin],\n test(value) {\n if (typeof FormData === 'undefined') {\n return false;\n }\n return value instanceof FormData;\n },\n parse: {\n sync(value, ctx) {\n return {\n factory: ctx.parse(FORM_DATA_FACTORY),\n entries: ctx.parse(convertFormData(value)),\n };\n },\n async async(value, ctx) {\n return {\n factory: await ctx.parse(FORM_DATA_FACTORY),\n entries: await ctx.parse(convertFormData(value)),\n };\n },\n stream(value, ctx) {\n return {\n factory: ctx.parse(FORM_DATA_FACTORY),\n entries: ctx.parse(convertFormData(value)),\n };\n },\n },\n serialize(node, ctx) {\n return (\n '(' +\n ctx.serialize(node.factory) +\n ')(' +\n ctx.serialize(node.entries) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return FORM_DATA_FACTORY_CONSTRUCTOR(\n ctx.deserialize(node.entries) as FormDataInit,\n );\n },\n});\n\nexport default FormDataPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nfunction convertHeaders(instance: Headers): HeadersInit {\n const items: HeadersInit = [];\n // biome-ignore lint/complexity/noForEach: \n instance.forEach((value, key) => {\n items.push([key, value]);\n });\n return items;\n}\n\nconst HeadersPlugin = /* @__PURE__ */ createPlugin<\n Headers,\n { value: SerovalNode }\n>({\n tag: 'seroval-plugins/web/Headers',\n test(value) {\n if (typeof Headers === 'undefined') {\n return false;\n }\n return value instanceof Headers;\n },\n parse: {\n sync(value, ctx) {\n return {\n value: ctx.parse(convertHeaders(value)),\n };\n },\n async async(value, ctx) {\n return {\n value: await ctx.parse(convertHeaders(value)),\n };\n },\n stream(value, ctx) {\n return {\n value: ctx.parse(convertHeaders(value)),\n };\n },\n },\n serialize(node, ctx) {\n return 'new Headers(' + ctx.serialize(node.value) + ')';\n },\n deserialize(node, ctx) {\n return new Headers(ctx.deserialize(node.value) as HeadersInit);\n },\n});\n\nexport default HeadersPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\ntype ImageDataNode = {\n data: SerovalNode;\n width: SerovalNode;\n height: SerovalNode;\n options: SerovalNode;\n};\n\nconst ImageDataPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/ImageData',\n test(value) {\n if (typeof ImageData === 'undefined') {\n return false;\n }\n return value instanceof ImageData;\n },\n parse: {\n sync(value, ctx) {\n return {\n data: ctx.parse(value.data),\n width: ctx.parse(value.width),\n height: ctx.parse(value.height),\n options: ctx.parse({\n colorSpace: value.colorSpace,\n }),\n };\n },\n async async(value, ctx) {\n return {\n data: await ctx.parse(value.data),\n width: await ctx.parse(value.width),\n height: await ctx.parse(value.height),\n options: await ctx.parse({\n colorSpace: value.colorSpace,\n }),\n };\n },\n stream(value, ctx) {\n return {\n data: ctx.parse(value.data),\n width: ctx.parse(value.width),\n height: ctx.parse(value.height),\n options: ctx.parse({\n colorSpace: value.colorSpace,\n }),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new ImageData(' +\n ctx.serialize(node.data) +\n ',' +\n ctx.serialize(node.width) +\n ',' +\n ctx.serialize(node.height) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new ImageData(\n ctx.deserialize(node.data) as Uint8ClampedArray,\n ctx.deserialize(node.width) as number,\n ctx.deserialize(node.height) as number,\n ctx.deserialize(node.options) as ImageDataSettings,\n );\n },\n});\n\nexport default ImageDataPlugin;\n", "import type { SerovalNode, Stream } from 'seroval';\nimport { createPlugin, createStream } from 'seroval';\n\nconst READABLE_STREAM_FACTORY = {};\n\nconst READABLE_STREAM_FACTORY_CONSTRUCTOR = (stream: Stream) =>\n new ReadableStream({\n start: controller => {\n stream.on({\n next: value => {\n try {\n controller.enqueue(value);\n } catch (_error) {\n // no-op\n }\n },\n throw: value => {\n controller.error(value);\n },\n return: () => {\n try {\n controller.close();\n } catch (_error) {\n // no-op\n }\n },\n });\n },\n });\n\nconst ReadableStreamFactoryPlugin = /* @__PURE__ */ createPlugin<\n object,\n {}\n>({\n tag: 'seroval-plugins/web/ReadableStreamFactory',\n test(value) {\n return value === READABLE_STREAM_FACTORY;\n },\n parse: {\n sync() {\n return READABLE_STREAM_FACTORY;\n },\n async async() {\n return await Promise.resolve(READABLE_STREAM_FACTORY);\n },\n stream() {\n return READABLE_STREAM_FACTORY;\n },\n },\n serialize() {\n return READABLE_STREAM_FACTORY_CONSTRUCTOR.toString();\n },\n deserialize() {\n return READABLE_STREAM_FACTORY;\n },\n});\n\nfunction toStream(value: ReadableStream): Stream {\n const stream = createStream();\n\n const reader = value.getReader();\n\n async function push(): Promise {\n try {\n const result = await reader.read();\n if (result.done) {\n stream.return(result.value);\n } else {\n stream.next(result.value);\n await push();\n }\n } catch (error) {\n stream.throw(error);\n }\n }\n\n push().catch(() => {\n //\n });\n\n return stream;\n}\n\ntype ReadableStreamNode = {\n factory: SerovalNode;\n stream: SerovalNode;\n};\n\nconst ReadableStreamPlugin = /* @__PURE__ */ createPlugin<\n ReadableStream,\n ReadableStreamNode\n>({\n tag: 'seroval/plugins/web/ReadableStream',\n extends: [ReadableStreamFactoryPlugin],\n test(value) {\n if (typeof ReadableStream === 'undefined') {\n return false;\n }\n return value instanceof ReadableStream;\n },\n parse: {\n sync(_value, ctx) {\n return {\n factory: ctx.parse(READABLE_STREAM_FACTORY),\n stream: ctx.parse(createStream()),\n };\n },\n async async(value, ctx) {\n return {\n factory: await ctx.parse(READABLE_STREAM_FACTORY),\n stream: await ctx.parse(toStream(value)),\n };\n },\n stream(value, ctx) {\n return {\n factory: ctx.parse(READABLE_STREAM_FACTORY),\n stream: ctx.parse(toStream(value)),\n };\n },\n },\n serialize(node, ctx) {\n return (\n '(' +\n ctx.serialize(node.factory) +\n ')(' +\n ctx.serialize(node.stream) +\n ')'\n );\n },\n deserialize(node, ctx) {\n const stream = ctx.deserialize(node.stream) as Stream;\n return READABLE_STREAM_FACTORY_CONSTRUCTOR(stream);\n },\n});\n\nexport default ReadableStreamPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\nimport HeadersPlugin from './headers';\nimport ReadableStreamPlugin from './readable-stream';\n\nfunction createRequestOptions(\n current: Request,\n body: ArrayBuffer | ReadableStream | null,\n): RequestInit {\n return {\n body,\n cache: current.cache,\n credentials: current.credentials,\n headers: current.headers,\n integrity: current.integrity,\n keepalive: current.keepalive,\n method: current.method,\n mode: current.mode,\n redirect: current.redirect,\n referrer: current.referrer,\n referrerPolicy: current.referrerPolicy,\n };\n}\n\ntype RequestNode = {\n url: SerovalNode;\n options: SerovalNode;\n};\n\nconst RequestPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/Request',\n extends: [ReadableStreamPlugin, HeadersPlugin],\n test(value) {\n if (typeof Request === 'undefined') {\n return false;\n }\n return value instanceof Request;\n },\n parse: {\n async async(value, ctx) {\n return {\n url: await ctx.parse(value.url),\n options: await ctx.parse(\n createRequestOptions(\n value,\n value.body && !value.bodyUsed\n ? await value.clone().arrayBuffer()\n : null,\n ),\n ),\n };\n },\n stream(value, ctx) {\n return {\n url: ctx.parse(value.url),\n options: ctx.parse(\n createRequestOptions(\n value,\n value.body && !value.bodyUsed ? value.clone().body : null,\n ),\n ),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new Request(' +\n ctx.serialize(node.url) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new Request(\n ctx.deserialize(node.url) as string,\n ctx.deserialize(node.options) as RequestInit,\n );\n },\n});\n\nexport default RequestPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\nimport HeadersPlugin from './headers';\nimport ReadableStreamPlugin from './readable-stream';\n\nfunction createResponseOptions(current: Response): ResponseInit {\n return {\n headers: current.headers,\n status: current.status,\n statusText: current.statusText,\n };\n}\n\ntype ResponseNode = {\n body: SerovalNode;\n options: SerovalNode;\n};\n\nconst ResponsePlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/Response',\n extends: [ReadableStreamPlugin, HeadersPlugin],\n test(value) {\n if (typeof Response === 'undefined') {\n return false;\n }\n return value instanceof Response;\n },\n parse: {\n async async(value, ctx) {\n return {\n body: await ctx.parse(\n value.body && !value.bodyUsed\n ? await value.clone().arrayBuffer()\n : null,\n ),\n options: await ctx.parse(createResponseOptions(value)),\n };\n },\n stream(value, ctx) {\n return {\n body: ctx.parse(\n value.body && !value.bodyUsed ? value.clone().body : null,\n ),\n options: ctx.parse(createResponseOptions(value)),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new Response(' +\n ctx.serialize(node.body) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new Response(\n ctx.deserialize(node.body) as BodyInit,\n ctx.deserialize(node.options) as ResponseInit,\n );\n },\n});\n\nexport default ResponsePlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nconst URLPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/URL',\n test(value) {\n if (typeof URL === 'undefined') {\n return false;\n }\n return value instanceof URL;\n },\n parse: {\n sync(value, ctx) {\n return {\n value: ctx.parse(value.href),\n };\n },\n async async(value, ctx) {\n return {\n value: await ctx.parse(value.href),\n };\n },\n stream(value, ctx) {\n return {\n value: ctx.parse(value.href),\n };\n },\n },\n serialize(node, ctx) {\n return 'new URL(' + ctx.serialize(node.value) + ')';\n },\n deserialize(node, ctx) {\n return new URL(ctx.deserialize(node.value) as string);\n },\n});\n\nexport default URLPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nconst URLSearchParamsPlugin = /* @__PURE__ */ createPlugin<\n URLSearchParams,\n { value: SerovalNode }\n>({\n tag: 'seroval-plugins/web/URLSearchParams',\n test(value) {\n if (typeof URLSearchParams === 'undefined') {\n return false;\n }\n return value instanceof URLSearchParams;\n },\n parse: {\n sync(value, ctx) {\n return {\n value: ctx.parse(value.toString()),\n };\n },\n async async(value, ctx) {\n return {\n value: await ctx.parse(value.toString()),\n };\n },\n stream(value, ctx) {\n return {\n value: ctx.parse(value.toString()),\n };\n },\n },\n serialize(node, ctx) {\n return 'new URLSearchParams(' + ctx.serialize(node.value) + ')';\n },\n deserialize(node, ctx) {\n return new URLSearchParams(ctx.deserialize(node.value) as string);\n },\n});\n\nexport default URLSearchParamsPlugin;\n", "import { createPlugin } from 'seroval'\nimport type { SerovalNode } from 'seroval'\n\nexport interface ErrorNode {\n message: SerovalNode\n}\n\n/**\n * this plugin serializes only the `message` part of an Error\n * this helps with serializing e.g. a ZodError which has functions attached that cannot be serialized\n */\nexport const ShallowErrorPlugin = /* @__PURE__ */ createPlugin<\n Error,\n ErrorNode\n>({\n tag: '$TSR/Error',\n test(value) {\n return value instanceof Error\n },\n parse: {\n sync(value, ctx) {\n return {\n message: ctx.parse(value.message),\n }\n },\n async async(value, ctx) {\n return {\n message: await ctx.parse(value.message),\n }\n },\n stream(value, ctx) {\n return {\n message: ctx.parse(value.message),\n }\n },\n },\n serialize(node, ctx) {\n return 'new Error(' + ctx.serialize(node.message) + ')'\n },\n deserialize(node, ctx) {\n return new Error(ctx.deserialize(node.message))\n },\n})\n", "import { createPlugin, createStream } from 'seroval'\nimport type { Plugin } from 'seroval'\n\n/**\n * Hint for RawStream encoding strategy during SSR serialization.\n * - 'binary': Always use base64 encoding (best for binary data like files, images)\n * - 'text': Try UTF-8 first, fallback to base64 (best for text-heavy data like RSC payloads)\n */\nexport type RawStreamHint = 'binary' | 'text'\n\n/**\n * Options for RawStream configuration.\n */\nexport interface RawStreamOptions {\n /**\n * Encoding hint for SSR serialization.\n * - 'binary' (default): Always use base64 encoding\n * - 'text': Try UTF-8 first, fallback to base64 for invalid UTF-8 chunks\n */\n hint?: RawStreamHint\n}\n\n/**\n * Marker class for ReadableStream that should be serialized\n * with base64 encoding (SSR) or binary framing (server functions).\n *\n * Wrap your binary streams with this to get efficient serialization:\n * ```ts\n * // For binary data (files, images, etc.)\n * return { data: new RawStream(file.stream()) }\n *\n * // For text-heavy data (RSC payloads, etc.)\n * return { data: new RawStream(rscStream, { hint: 'text' }) }\n * ```\n */\nexport class RawStream {\n public readonly hint: RawStreamHint\n\n constructor(\n public readonly stream: ReadableStream,\n options?: RawStreamOptions,\n ) {\n this.hint = options?.hint ?? 'binary'\n }\n}\n\n/**\n * Callback type for RPC plugin to register raw streams with multiplexer\n */\nexport type OnRawStreamCallback = (\n streamId: number,\n stream: ReadableStream,\n) => void\n\n// Base64 helpers used in both Node and browser.\n// In Node-like runtimes, prefer Buffer for speed and compatibility.\nconst BufferCtor: any = (globalThis as any).Buffer\nconst hasNodeBuffer = !!BufferCtor && typeof BufferCtor.from === 'function'\n\nfunction uint8ArrayToBase64(bytes: Uint8Array): string {\n if (bytes.length === 0) return ''\n\n if (hasNodeBuffer) {\n return BufferCtor.from(bytes).toString('base64')\n }\n\n // Browser fallback: chunked String.fromCharCode + btoa\n const CHUNK_SIZE = 0x8000 // 32KB chunks to avoid stack overflow\n const chunks: Array = []\n for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {\n const chunk = bytes.subarray(i, i + CHUNK_SIZE)\n chunks.push(String.fromCharCode.apply(null, chunk as any))\n }\n return btoa(chunks.join(''))\n}\n\nfunction base64ToUint8Array(base64: string): Uint8Array {\n if (base64.length === 0) return new Uint8Array(0)\n\n if (hasNodeBuffer) {\n const buf = BufferCtor.from(base64, 'base64')\n return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength)\n }\n\n const binary = atob(base64)\n const bytes = new Uint8Array(binary.length)\n for (let i = 0; i < binary.length; i++) {\n bytes[i] = binary.charCodeAt(i)\n }\n return bytes\n}\n\n// Factory sentinels - use null-proto objects to avoid prototype surprises\nconst RAW_STREAM_FACTORY_BINARY: Record = Object.create(null)\nconst RAW_STREAM_FACTORY_TEXT: Record = Object.create(null)\n\n// Factory constructor for binary mode - converts seroval stream to ReadableStream\n// All chunks are base64 encoded strings\nconst RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY = (\n stream: ReturnType,\n) =>\n new ReadableStream({\n start(controller) {\n stream.on({\n next(base64: string) {\n try {\n controller.enqueue(base64ToUint8Array(base64))\n } catch {\n // Stream may be closed\n }\n },\n throw(error: unknown) {\n controller.error(error)\n },\n return() {\n try {\n controller.close()\n } catch {\n // Stream may already be closed\n }\n },\n })\n },\n })\n\n// Factory constructor for text mode - converts seroval stream to ReadableStream\n// Chunks are either strings (UTF-8) or { $b64: string } (base64 fallback)\n// Use module-level TextEncoder to avoid per-factory allocation\nconst textEncoderForFactory = new TextEncoder()\nconst RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT = (\n stream: ReturnType,\n) => {\n return new ReadableStream({\n start(controller) {\n stream.on({\n next(value: string | { $b64: string }) {\n try {\n if (typeof value === 'string') {\n controller.enqueue(textEncoderForFactory.encode(value))\n } else {\n controller.enqueue(base64ToUint8Array(value.$b64))\n }\n } catch {\n // Stream may be closed\n }\n },\n throw(error: unknown) {\n controller.error(error)\n },\n return() {\n try {\n controller.close()\n } catch {\n // Stream may already be closed\n }\n },\n })\n },\n })\n}\n\n// Minified factory function for binary mode - all chunks are base64 strings\n// This must be self-contained since it's injected into the HTML\nconst FACTORY_BINARY = `(s=>new ReadableStream({start(c){s.on({next(b){try{const d=atob(b),a=new Uint8Array(d.length);for(let i=0;i{const e=new TextEncoder();return new ReadableStream({start(c){s.on({next(v){try{if(typeof v==='string'){c.enqueue(e.encode(v))}else{const d=atob(v.$b64),a=new Uint8Array(d.length);for(let i=0;i to seroval stream with base64-encoded chunks (binary mode)\nfunction toBinaryStream(readable: ReadableStream) {\n const stream = createStream()\n const reader = readable.getReader()\n\n // Use iterative loop instead of recursive async to avoid stack accumulation\n ;(async () => {\n try {\n while (true) {\n const { done, value } = await reader.read()\n if (done) {\n stream.return(undefined)\n break\n }\n stream.next(uint8ArrayToBase64(value))\n }\n } catch (error) {\n stream.throw(error)\n } finally {\n reader.releaseLock()\n }\n })()\n\n return stream\n}\n\n// Convert ReadableStream to seroval stream with UTF-8 first, base64 fallback (text mode)\nfunction toTextStream(readable: ReadableStream) {\n const stream = createStream()\n const reader = readable.getReader()\n const decoder = new TextDecoder('utf-8', { fatal: true })\n\n // Use iterative loop instead of recursive async to avoid stack accumulation\n ;(async () => {\n try {\n while (true) {\n const { done, value } = await reader.read()\n if (done) {\n // Flush any remaining bytes in the decoder\n try {\n const remaining = decoder.decode()\n if (remaining.length > 0) {\n stream.next(remaining)\n }\n } catch {\n // Ignore decode errors on flush\n }\n stream.return(undefined)\n break\n }\n\n try {\n // Try UTF-8 decode first\n const text = decoder.decode(value, { stream: true })\n if (text.length > 0) {\n stream.next(text)\n }\n } catch {\n // UTF-8 decode failed, fallback to base64\n stream.next({ $b64: uint8ArrayToBase64(value) })\n }\n }\n } catch (error) {\n stream.throw(error)\n } finally {\n reader.releaseLock()\n }\n })()\n\n return stream\n}\n\n// Factory plugin for binary mode\nconst RawStreamFactoryBinaryPlugin = createPlugin<\n Record,\n undefined\n>({\n tag: 'tss/RawStreamFactory',\n test(value) {\n return value === RAW_STREAM_FACTORY_BINARY\n },\n parse: {\n sync() {\n return undefined\n },\n async() {\n return Promise.resolve(undefined)\n },\n stream() {\n return undefined\n },\n },\n serialize() {\n return FACTORY_BINARY\n },\n deserialize() {\n return RAW_STREAM_FACTORY_BINARY\n },\n})\n\n// Factory plugin for text mode\nconst RawStreamFactoryTextPlugin = createPlugin<\n Record,\n undefined\n>({\n tag: 'tss/RawStreamFactoryText',\n test(value) {\n return value === RAW_STREAM_FACTORY_TEXT\n },\n parse: {\n sync() {\n return undefined\n },\n async() {\n return Promise.resolve(undefined)\n },\n stream() {\n return undefined\n },\n },\n serialize() {\n return FACTORY_TEXT\n },\n deserialize() {\n return RAW_STREAM_FACTORY_TEXT\n },\n})\n\n/**\n * SSR Plugin - uses base64 or UTF-8+base64 encoding for chunks, delegates to seroval's stream mechanism.\n * Used during SSR when serializing to JavaScript code for HTML injection.\n *\n * Supports two modes based on RawStream hint:\n * - 'binary': Always base64 encode (default)\n * - 'text': Try UTF-8 first, fallback to base64 for invalid UTF-8\n */\nexport const RawStreamSSRPlugin: Plugin = createPlugin({\n tag: 'tss/RawStream',\n extends: [RawStreamFactoryBinaryPlugin, RawStreamFactoryTextPlugin],\n\n test(value: unknown) {\n return value instanceof RawStream\n },\n\n parse: {\n sync(value: RawStream, ctx) {\n // Sync parse not really supported for streams, return empty stream\n const factory =\n value.hint === 'text'\n ? RAW_STREAM_FACTORY_TEXT\n : RAW_STREAM_FACTORY_BINARY\n return {\n hint: value.hint,\n factory: ctx.parse(factory),\n stream: ctx.parse(createStream()),\n }\n },\n async async(value: RawStream, ctx) {\n const factory =\n value.hint === 'text'\n ? RAW_STREAM_FACTORY_TEXT\n : RAW_STREAM_FACTORY_BINARY\n const encodedStream =\n value.hint === 'text'\n ? toTextStream(value.stream)\n : toBinaryStream(value.stream)\n return {\n hint: value.hint,\n factory: await ctx.parse(factory),\n stream: await ctx.parse(encodedStream),\n }\n },\n stream(value: RawStream, ctx) {\n const factory =\n value.hint === 'text'\n ? RAW_STREAM_FACTORY_TEXT\n : RAW_STREAM_FACTORY_BINARY\n const encodedStream =\n value.hint === 'text'\n ? toTextStream(value.stream)\n : toBinaryStream(value.stream)\n return {\n hint: value.hint,\n factory: ctx.parse(factory),\n stream: ctx.parse(encodedStream),\n }\n },\n },\n\n serialize(node: { hint: RawStreamHint; factory: any; stream: any }, ctx) {\n return (\n '(' +\n ctx.serialize(node.factory) +\n ')(' +\n ctx.serialize(node.stream) +\n ')'\n )\n },\n\n deserialize(\n node: { hint: RawStreamHint; factory: any; stream: any },\n ctx,\n ): any {\n const stream: ReturnType = ctx.deserialize(node.stream)\n return node.hint === 'text'\n ? RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT(stream)\n : RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY(stream)\n },\n}) as Plugin\n\n/**\n * Node type for RPC plugin serialization\n */\ninterface RawStreamRPCNode {\n streamId: number\n}\n\n/**\n * Creates an RPC plugin instance that registers raw streams with a multiplexer.\n * Used for server function responses where we want binary framing.\n * Note: RPC always uses binary framing regardless of hint.\n *\n * @param onRawStream Callback invoked when a RawStream is encountered during serialization\n */\nexport function createRawStreamRPCPlugin(\n onRawStream: OnRawStreamCallback,\n): Plugin {\n // Own stream counter - sequential IDs starting at 1, independent of seroval internals\n let nextStreamId = 1\n\n return createPlugin({\n tag: 'tss/RawStream',\n\n test(value: unknown) {\n return value instanceof RawStream\n },\n\n parse: {\n async(value: RawStream) {\n const streamId = nextStreamId++\n onRawStream(streamId, value.stream)\n return Promise.resolve({ streamId })\n },\n stream(value: RawStream) {\n const streamId = nextStreamId++\n onRawStream(streamId, value.stream)\n return { streamId }\n },\n },\n\n serialize(): never {\n // RPC uses toCrossJSONStream which produces JSON nodes, not JS code.\n // This method is only called by crossSerialize* which we don't use.\n throw new Error(\n 'RawStreamRPCPlugin.serialize should not be called. RPC uses JSON serialization, not JS code generation.',\n )\n },\n\n deserialize(): never {\n // Client uses createRawStreamDeserializePlugin instead\n throw new Error(\n 'RawStreamRPCPlugin.deserialize should not be called. Use createRawStreamDeserializePlugin on client.',\n )\n },\n }) as Plugin\n}\n\n/**\n * Creates a deserialize-only plugin for client-side stream reconstruction.\n * Used in serverFnFetcher to wire up streams from frame decoder.\n *\n * @param getOrCreateStream Function to get/create a stream by ID from frame decoder\n */\nexport function createRawStreamDeserializePlugin(\n getOrCreateStream: (id: number) => ReadableStream,\n): Plugin {\n return createPlugin({\n tag: 'tss/RawStream',\n\n test: () => false, // Client never serializes RawStream\n\n parse: {}, // Client only deserializes, never parses\n\n serialize(): never {\n // Client never serializes RawStream back to server\n throw new Error(\n 'RawStreamDeserializePlugin.serialize should not be called. Client only deserializes.',\n )\n },\n\n deserialize(node: RawStreamRPCNode) {\n return getOrCreateStream(node.streamId)\n },\n }) as Plugin\n}\n", "import * as React from 'react'\n\n// Safe version of React.use() that will not cause compilation errors against\n// React 18 with Webpack, which statically analyzes imports and fails when it\n// sees React.use referenced (since 'use' is not exported from React 18).\n// This uses a dynamic string lookup to avoid the static analysis.\nconst REACT_USE = 'use'\n\n/**\n * React.use if available (React 19+), undefined otherwise.\n * Use dynamic lookup to avoid Webpack compilation errors with React 18.\n */\nexport const reactUse:\n | ((usable: Promise | React.Context) => T)\n | undefined = (React as any)[REACT_USE]\n\nexport function useStableCallback) => any>(\n fn: T,\n): T {\n const fnRef = React.useRef(fn)\n fnRef.current = fn\n\n const ref = React.useRef((...args: Array) => fnRef.current(...args))\n return ref.current as T\n}\n\nexport const useLayoutEffect =\n typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\n/**\n * Taken from https://www.developerway.com/posts/implementing-advanced-use-previous-hook#part3\n */\nexport function usePrevious(value: T): T | null {\n // initialise the ref with previous and current values\n const ref = React.useRef<{ value: T; prev: T | null }>({\n value: value,\n prev: null,\n })\n\n const current = ref.current.value\n\n // if the value passed into hook doesn't match what we store as \"current\"\n // move the \"current\" to the \"previous\"\n // and store the passed value as \"current\"\n if (value !== current) {\n ref.current = {\n value: value,\n prev: current,\n }\n }\n\n // return the previous value only\n return ref.current.prev\n}\n\n/**\n * React hook to wrap `IntersectionObserver`.\n *\n * This hook will create an `IntersectionObserver` and observe the ref passed to it.\n *\n * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.\n *\n * @param ref - The ref to observe\n * @param intersectionObserverOptions - The options to pass to the IntersectionObserver\n * @param options - The options to pass to the hook\n * @param callback - The callback to call when the intersection changes\n * @returns The IntersectionObserver instance\n * @example\n * ```tsx\n * const MyComponent = () => {\n * const ref = React.useRef(null)\n * useIntersectionObserver(\n * ref,\n * (entry) => { doSomething(entry) },\n * { rootMargin: '10px' },\n * { disabled: false }\n * )\n * return
\n * ```\n */\nexport function useIntersectionObserver(\n ref: React.RefObject,\n callback: (entry: IntersectionObserverEntry | undefined) => void,\n intersectionObserverOptions: IntersectionObserverInit = {},\n options: { disabled?: boolean } = {},\n) {\n React.useEffect(() => {\n if (\n !ref.current ||\n options.disabled ||\n typeof IntersectionObserver !== 'function'\n ) {\n return\n }\n\n const observer = new IntersectionObserver(([entry]) => {\n callback(entry)\n }, intersectionObserverOptions)\n\n observer.observe(ref.current)\n\n return () => {\n observer.disconnect()\n }\n }, [callback, intersectionObserverOptions, options.disabled, ref])\n}\n\n/**\n * React hook to take a `React.ForwardedRef` and returns a `ref` that can be used on a DOM element.\n *\n * @param ref - The forwarded ref\n * @returns The inner ref returned by `useRef`\n * @example\n * ```tsx\n * const MyComponent = React.forwardRef((props, ref) => {\n * const innerRef = useForwardedRef(ref)\n * return
\n * })\n * ```\n */\nexport function useForwardedRef(ref?: React.ForwardedRef) {\n const innerRef = React.useRef(null)\n React.useImperativeHandle(ref, () => innerRef.current!, [])\n return innerRef\n}\n", "import * as React from 'react'\n\nimport { TSR_DEFERRED_PROMISE, defer } from '@tanstack/router-core'\nimport { reactUse } from './utils'\n\nexport type AwaitOptions = {\n promise: Promise\n}\n\n/** Suspend until a deferred promise resolves or rejects and return its data. */\nexport function useAwaited({ promise: _promise }: AwaitOptions): T {\n if (reactUse) {\n const data = reactUse(_promise)\n return data\n }\n const promise = defer(_promise)\n\n if (promise[TSR_DEFERRED_PROMISE].status === 'pending') {\n throw promise\n }\n\n if (promise[TSR_DEFERRED_PROMISE].status === 'error') {\n throw promise[TSR_DEFERRED_PROMISE].error\n }\n\n return promise[TSR_DEFERRED_PROMISE].data\n}\n\n/**\n * Component that suspends on a deferred promise and renders its child with\n * the resolved value. Optionally provides a Suspense fallback.\n */\nexport function Await(\n props: AwaitOptions & {\n fallback?: React.ReactNode\n children: (result: T) => React.ReactNode\n },\n) {\n const inner = \n if (props.fallback) {\n return {inner}\n }\n return inner\n}\n\nfunction AwaitInner(\n props: AwaitOptions & {\n fallback?: React.ReactNode\n children: (result: T) => React.ReactNode\n },\n): React.JSX.Element {\n const data = useAwaited(props)\n\n return props.children(data) as React.JSX.Element\n}\n", "import * as React from 'react'\nimport type { ErrorRouteComponent } from './route'\nimport type { ErrorInfo } from 'react'\n\nexport function CatchBoundary(props: {\n getResetKey: () => number | string\n children: React.ReactNode\n errorComponent?: ErrorRouteComponent\n onCatch?: (error: Error, errorInfo: ErrorInfo) => void\n}) {\n const errorComponent = props.errorComponent ?? ErrorComponent\n\n return (\n {\n if (error) {\n return React.createElement(errorComponent, {\n error,\n reset,\n })\n }\n\n return props.children\n }}\n />\n )\n}\n\nclass CatchBoundaryImpl extends React.Component<{\n getResetKey: () => number | string\n children: (props: {\n error: Error | null\n reset: () => void\n }) => React.ReactNode\n onCatch?: (error: Error, errorInfo: ErrorInfo) => void\n}> {\n state = { error: null } as { error: Error | null; resetKey: string }\n static getDerivedStateFromProps(props: any) {\n return { resetKey: props.getResetKey() }\n }\n static getDerivedStateFromError(error: Error) {\n return { error }\n }\n reset() {\n this.setState({ error: null })\n }\n componentDidUpdate(\n prevProps: Readonly<{\n getResetKey: () => string\n children: (props: { error: any; reset: () => void }) => any\n onCatch?: ((error: any, info: any) => void) | undefined\n }>,\n prevState: any,\n ): void {\n if (prevState.error && prevState.resetKey !== this.state.resetKey) {\n this.reset()\n }\n }\n componentDidCatch(error: Error, errorInfo: ErrorInfo) {\n if (this.props.onCatch) {\n this.props.onCatch(error, errorInfo)\n }\n }\n render() {\n // If the resetKey has changed, don't render the error\n return this.props.children({\n error:\n this.state.resetKey !== this.props.getResetKey()\n ? null\n : this.state.error,\n reset: () => {\n this.reset()\n },\n })\n }\n}\n\nexport function ErrorComponent({ error }: { error: any }) {\n const [show, setShow] = React.useState(process.env.NODE_ENV !== 'production')\n\n return (\n
\n
\n Something went wrong!\n setShow((d) => !d)}\n >\n {show ? 'Hide Error' : 'Show Error'}\n \n
\n
\n {show ? (\n
\n \n {error.message ? {error.message} : null}\n \n
\n ) : null}\n
\n )\n}\n", "import React from 'react'\n\nexport interface ClientOnlyProps {\n /**\n * The children to render when the JS is loaded.\n */\n children: React.ReactNode\n /**\n * The fallback component to render if the JS is not yet loaded.\n */\n fallback?: React.ReactNode\n}\n\n/**\n * Render the children only after the JS has loaded client-side. Use an optional\n * fallback component if the JS is not yet loaded.\n *\n * @example\n * Render a Chart component if JS loads, renders a simple FakeChart\n * component server-side or if there is no JS. The FakeChart can have only the\n * UI without the behavior or be a loading spinner or skeleton.\n *\n * ```tsx\n * return (\n * }>\n * \n * \n * )\n * ```\n */\nexport function ClientOnly({ children, fallback = null }: ClientOnlyProps) {\n return useHydrated() ? (\n {children}\n ) : (\n {fallback}\n )\n}\n\n/**\n * Return a boolean indicating if the JS has been hydrated already.\n * When doing Server-Side Rendering, the result will always be false.\n * When doing Client-Side Rendering, the result will always be false on the\n * first render and true from then on. Even if a new component renders it will\n * always start with true.\n *\n * @example\n * ```tsx\n * // Disable a button that needs JS to work.\n * let hydrated = useHydrated()\n * return (\n * \n * )\n * ```\n * @returns True if the JS has been hydrated already, false otherwise.\n */\nexport function useHydrated(): boolean {\n return React.useSyncExternalStore(\n subscribe,\n () => true,\n () => false,\n )\n}\n\nfunction subscribe() {\n return () => {}\n}\n", "var isProduction = process.env.NODE_ENV === 'production';\nfunction warning(condition, message) {\n if (!isProduction) {\n if (condition) {\n return;\n }\n\n var text = \"Warning: \" + message;\n\n if (typeof console !== 'undefined') {\n console.warn(text);\n }\n\n try {\n throw Error(text);\n } catch (x) {}\n }\n}\n\nexport default warning;\n", "import { useCallback } from 'react'\nimport { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector'\nimport type { AnyAtom } from '@tanstack/store'\n\ntype SyncExternalStoreSubscribe = Parameters<\n typeof useSyncExternalStoreWithSelector\n>[0]\n\nfunction defaultCompare(a: T, b: T) {\n return a === b\n}\n\nexport function useStore(\n atom: TAtom,\n selector: (\n snapshot: TAtom extends { get: () => infer TSnapshot }\n ? TSnapshot\n : undefined,\n ) => T,\n compare: (a: T, b: T) => boolean = defaultCompare,\n): T {\n const subscribe: SyncExternalStoreSubscribe = useCallback(\n (handleStoreChange) => {\n if (!atom) {\n return () => {}\n }\n const { unsubscribe } = atom.subscribe(handleStoreChange)\n return unsubscribe\n },\n [atom],\n )\n\n const boundGetSnapshot = useCallback(() => atom?.get(), [atom])\n\n const selectedSnapshot = useSyncExternalStoreWithSelector(\n subscribe,\n boundGetSnapshot,\n boundGetSnapshot,\n selector,\n compare,\n )\n\n return selectedSnapshot\n}\n", "import * as React from 'react'\nimport type { AnyRouter } from '@tanstack/router-core'\n\nexport const routerContext = React.createContext(null!)\n", "import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { routerContext } from './routerContext'\nimport type { AnyRouter, RegisteredRouter } from '@tanstack/router-core'\n\n/**\n * Access the current TanStack Router instance from React context.\n * Must be used within a `RouterProvider`.\n *\n * Options:\n * - `warn`: Log a warning if no router context is found (default: true).\n *\n * @returns The registered router instance.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useRouterHook\n */\nexport function useRouter(opts?: {\n warn?: boolean\n}): TRouter {\n const value = React.useContext(routerContext)\n warning(\n !((opts?.warn ?? true) && !value),\n 'useRouter must be used inside a component!',\n )\n return value as any\n}\n", "import { useStore } from '@tanstack/react-store'\nimport { useRef } from 'react'\nimport { replaceEqualDeep } from '@tanstack/router-core'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { useRouter } from './useRouter'\nimport type {\n AnyRouter,\n RegisteredRouter,\n RouterState,\n} from '@tanstack/router-core'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\n\nexport type UseRouterStateOptions<\n TRouter extends AnyRouter,\n TSelected,\n TStructuralSharing,\n> = {\n router?: TRouter\n select?: (\n state: RouterState,\n ) => ValidateSelected\n} & StructuralSharingOption\n\nexport type UseRouterStateResult<\n TRouter extends AnyRouter,\n TSelected,\n> = unknown extends TSelected ? RouterState : TSelected\n\n/**\n * Subscribe to the router's state store with optional selection and\n * structural sharing for render optimization.\n *\n * Options:\n * - `select`: Project the full router state to a derived slice\n * - `structuralSharing`: Replace-equal semantics for stable references\n * - `router`: Read state from a specific router instance instead of context\n *\n * @returns The selected router state (or the full state by default).\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useRouterStateHook\n */\nexport function useRouterState<\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseRouterStateOptions,\n): UseRouterStateResult {\n const contextRouter = useRouter({\n warn: opts?.router === undefined,\n })\n const router = opts?.router || contextRouter\n\n // During SSR we render exactly once and do not need reactivity.\n // Avoid subscribing to the store (and any structural sharing work) on the server.\n const _isServer = isServer ?? router.isServer\n if (_isServer) {\n const state = router.state as RouterState\n return (opts?.select ? opts.select(state) : state) as UseRouterStateResult<\n TRouter,\n TSelected\n >\n }\n\n const previousResult =\n // eslint-disable-next-line react-hooks/rules-of-hooks\n useRef>(undefined)\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n return useStore(router.__store, (state) => {\n if (opts?.select) {\n if (opts.structuralSharing ?? router.options.defaultStructuralSharing) {\n const newSlice = replaceEqualDeep(\n previousResult.current,\n opts.select(state),\n )\n previousResult.current = newSlice\n return newSlice\n }\n return opts.select(state)\n }\n return state\n }) as UseRouterStateResult\n}\n", "import * as React from 'react'\n\nexport const matchContext = React.createContext(undefined)\n\n// N.B. this only exists so we can conditionally call useContext on it when we are not interested in the nearest match\nexport const dummyMatchContext = React.createContext(\n undefined,\n)\n", "import * as React from 'react'\nimport invariant from 'tiny-invariant'\nimport { useRouterState } from './useRouterState'\nimport { dummyMatchContext, matchContext } from './matchContext'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n MakeRouteMatch,\n MakeRouteMatchUnion,\n RegisteredRouter,\n StrictOrFrom,\n ThrowConstraint,\n ThrowOrOptional,\n} from '@tanstack/router-core'\n\nexport interface UseMatchBaseOptions<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing extends boolean,\n> {\n select?: (\n match: MakeRouteMatch,\n ) => ValidateSelected\n shouldThrow?: TThrow\n}\n\nexport type UseMatchRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseMatchBaseOptions<\n TRouter,\n TFrom,\n true,\n true,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption,\n) => UseMatchResult\n\nexport type UseMatchOptions<\n TRouter extends AnyRouter,\n TFrom extends string | undefined,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing extends boolean,\n> = StrictOrFrom &\n UseMatchBaseOptions<\n TRouter,\n TFrom,\n TStrict,\n TThrow,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption\n\nexport type UseMatchResult<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TSelected,\n> = unknown extends TSelected\n ? TStrict extends true\n ? MakeRouteMatch\n : MakeRouteMatchUnion\n : TSelected\n\n/**\n * Read and select the nearest or targeted route match.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useMatchHook\n */\nexport function useMatch<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TStrict extends boolean = true,\n TThrow extends boolean = true,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts: UseMatchOptions<\n TRouter,\n TFrom,\n TStrict,\n ThrowConstraint,\n TSelected,\n TStructuralSharing\n >,\n): ThrowOrOptional, TThrow> {\n const nearestMatchId = React.useContext(\n opts.from ? dummyMatchContext : matchContext,\n )\n\n const matchSelection = useRouterState({\n select: (state: any) => {\n const match = state.matches.find((d: any) =>\n opts.from ? opts.from === d.routeId : d.id === nearestMatchId,\n )\n invariant(\n !((opts.shouldThrow ?? true) && !match),\n `Could not find ${opts.from ? `an active match from \"${opts.from}\"` : 'a nearest match!'}`,\n )\n\n if (match === undefined) {\n return undefined\n }\n\n return opts.select ? opts.select(match) : match\n },\n structuralSharing: opts.structuralSharing,\n } as any)\n\n return matchSelection as any\n}\n", "import { useMatch } from './useMatch'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n RegisteredRouter,\n ResolveUseLoaderData,\n StrictOrFrom,\n UseLoaderDataResult,\n} from '@tanstack/router-core'\n\nexport interface UseLoaderDataBaseOptions<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TSelected,\n TStructuralSharing,\n> {\n select?: (\n match: ResolveUseLoaderData,\n ) => ValidateSelected\n}\n\nexport type UseLoaderDataOptions<\n TRouter extends AnyRouter,\n TFrom extends string | undefined,\n TStrict extends boolean,\n TSelected,\n TStructuralSharing,\n> = StrictOrFrom &\n UseLoaderDataBaseOptions<\n TRouter,\n TFrom,\n TStrict,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption\n\nexport type UseLoaderDataRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseLoaderDataBaseOptions<\n TRouter,\n TId,\n true,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption,\n) => UseLoaderDataResult\n\n/**\n * Read and select the current route's loader data with type‑safety.\n *\n * Options:\n * - `from`/`strict`: Choose which route's data to read and strictness\n * - `select`: Map the loader data to a derived value\n * - `structuralSharing`: Enable structural sharing for stable references\n *\n * @returns The loader data (or selected value) for the matched route.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useLoaderDataHook\n */\nexport function useLoaderData<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TStrict extends boolean = true,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts: UseLoaderDataOptions<\n TRouter,\n TFrom,\n TStrict,\n TSelected,\n TStructuralSharing\n >,\n): UseLoaderDataResult {\n return useMatch({\n from: opts.from!,\n strict: opts.strict,\n structuralSharing: opts.structuralSharing,\n select: (s: any) => {\n return opts.select ? opts.select(s.loaderData) : s.loaderData\n },\n } as any) as UseLoaderDataResult\n}\n", "import { useMatch } from './useMatch'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n RegisteredRouter,\n ResolveUseLoaderDeps,\n StrictOrFrom,\n UseLoaderDepsResult,\n} from '@tanstack/router-core'\n\nexport interface UseLoaderDepsBaseOptions<\n TRouter extends AnyRouter,\n TFrom,\n TSelected,\n TStructuralSharing,\n> {\n select?: (\n deps: ResolveUseLoaderDeps,\n ) => ValidateSelected\n}\n\nexport type UseLoaderDepsOptions<\n TRouter extends AnyRouter,\n TFrom extends string | undefined,\n TSelected,\n TStructuralSharing,\n> = StrictOrFrom &\n UseLoaderDepsBaseOptions &\n StructuralSharingOption\n\nexport type UseLoaderDepsRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseLoaderDepsBaseOptions &\n StructuralSharingOption,\n) => UseLoaderDepsResult\n\n/**\n * Read and select the current route's loader dependencies object.\n *\n * Options:\n * - `from`: Choose which route's loader deps to read\n * - `select`: Map the deps to a derived value\n * - `structuralSharing`: Enable structural sharing for stable references\n *\n * @returns The loader deps (or selected value) for the matched route.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useLoaderDepsHook\n */\nexport function useLoaderDeps<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts: UseLoaderDepsOptions,\n): UseLoaderDepsResult {\n const { select, ...rest } = opts\n return useMatch({\n ...rest,\n select: (s) => {\n return select ? select(s.loaderDeps) : s.loaderDeps\n },\n }) as UseLoaderDepsResult\n}\n", "import { useMatch } from './useMatch'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n RegisteredRouter,\n ResolveUseParams,\n StrictOrFrom,\n ThrowConstraint,\n ThrowOrOptional,\n UseParamsResult,\n} from '@tanstack/router-core'\n\nexport interface UseParamsBaseOptions<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing,\n> {\n select?: (\n params: ResolveUseParams,\n ) => ValidateSelected\n shouldThrow?: TThrow\n}\n\nexport type UseParamsOptions<\n TRouter extends AnyRouter,\n TFrom extends string | undefined,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing,\n> = StrictOrFrom &\n UseParamsBaseOptions<\n TRouter,\n TFrom,\n TStrict,\n TThrow,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption\n\nexport type UseParamsRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseParamsBaseOptions<\n TRouter,\n TFrom,\n /* TStrict */ true,\n /* TThrow */ true,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption,\n) => UseParamsResult\n\n/**\n * Access the current route's path parameters with type-safety.\n *\n * Options:\n * - `from`/`strict`: Specify the matched route and whether to enforce strict typing\n * - `select`: Project the params object to a derived value for memoized renders\n * - `structuralSharing`: Enable structural sharing for stable references\n * - `shouldThrow`: Throw if the route is not found in strict contexts\n *\n * @returns The params object (or selected value) for the matched route.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useParamsHook\n */\nexport function useParams<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TStrict extends boolean = true,\n TThrow extends boolean = true,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts: UseParamsOptions<\n TRouter,\n TFrom,\n TStrict,\n ThrowConstraint,\n TSelected,\n TStructuralSharing\n >,\n): ThrowOrOptional<\n UseParamsResult,\n TThrow\n> {\n return useMatch({\n from: opts.from!,\n shouldThrow: opts.shouldThrow,\n structuralSharing: opts.structuralSharing,\n strict: opts.strict,\n select: (match) => {\n const params = opts.strict === false ? match.params : match._strictParams\n\n return opts.select ? opts.select(params) : params\n },\n }) as any\n}\n", "import { useMatch } from './useMatch'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n RegisteredRouter,\n ResolveUseSearch,\n StrictOrFrom,\n ThrowConstraint,\n ThrowOrOptional,\n UseSearchResult,\n} from '@tanstack/router-core'\n\nexport interface UseSearchBaseOptions<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing,\n> {\n select?: (\n state: ResolveUseSearch,\n ) => ValidateSelected\n shouldThrow?: TThrow\n}\n\nexport type UseSearchOptions<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing,\n> = StrictOrFrom &\n UseSearchBaseOptions<\n TRouter,\n TFrom,\n TStrict,\n TThrow,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption\n\nexport type UseSearchRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseSearchBaseOptions<\n TRouter,\n TFrom,\n /* TStrict */ true,\n /* TThrow */ true,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption,\n) => UseSearchResult\n\n/**\n * Read and select the current route's search parameters with type-safety.\n *\n * Options:\n * - `from`/`strict`: Control which route's search is read and how strictly it's typed\n * - `select`: Map the search object to a derived value for render optimization\n * - `structuralSharing`: Enable structural sharing for stable references\n * - `shouldThrow`: Throw when the route is not found (strict contexts)\n *\n * @returns The search object (or selected value) for the matched route.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useSearchHook\n */\nexport function useSearch<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TStrict extends boolean = true,\n TThrow extends boolean = true,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts: UseSearchOptions<\n TRouter,\n TFrom,\n TStrict,\n ThrowConstraint,\n TSelected,\n TStructuralSharing\n >,\n): ThrowOrOptional<\n UseSearchResult,\n TThrow\n> {\n return useMatch({\n from: opts.from!,\n strict: opts.strict,\n shouldThrow: opts.shouldThrow,\n structuralSharing: opts.structuralSharing,\n select: (match: any) => {\n return opts.select ? opts.select(match.search) : match.search\n },\n }) as any\n}\n", "import * as React from 'react'\nimport { useLayoutEffect } from './utils'\nimport { useRouter } from './useRouter'\nimport type {\n AnyRouter,\n FromPathOption,\n NavigateOptions,\n RegisteredRouter,\n UseNavigateResult,\n} from '@tanstack/router-core'\n\n/**\n * Imperative navigation hook.\n *\n * Returns a stable `navigate(options)` function to change the current location\n * programmatically. Prefer the `Link` component for user-initiated navigation,\n * and use this hook from effects, callbacks, or handlers where imperative\n * navigation is required.\n *\n * Options:\n * - `from`: Optional route base used to resolve relative `to` paths.\n *\n * @returns A function that accepts `NavigateOptions`.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useNavigateHook\n */\nexport function useNavigate<\n TRouter extends AnyRouter = RegisteredRouter,\n TDefaultFrom extends string = string,\n>(_defaultOpts?: {\n from?: FromPathOption\n}): UseNavigateResult {\n const router = useRouter()\n\n return React.useCallback(\n (options: NavigateOptions) => {\n return router.navigate({\n ...options,\n from: options.from ?? _defaultOpts?.from,\n })\n },\n [_defaultOpts?.from, router],\n ) as UseNavigateResult\n}\n\n/**\n * Component that triggers a navigation when rendered. Navigation executes\n * in an effect after mount/update.\n *\n * Props are the same as `NavigateOptions` used by `navigate()`.\n *\n * @returns null\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/navigateComponent\n */\nexport function Navigate<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string = string,\n const TTo extends string | undefined = undefined,\n const TMaskFrom extends string = TFrom,\n const TMaskTo extends string = '',\n>(props: NavigateOptions): null {\n const router = useRouter()\n const navigate = useNavigate()\n\n const previousPropsRef = React.useRef | null>(null)\n useLayoutEffect(() => {\n if (previousPropsRef.current !== props) {\n navigate(props)\n previousPropsRef.current = props\n }\n }, [router, props, navigate])\n return null\n}\n", "import { useMatch } from './useMatch'\nimport type {\n AnyRouter,\n RegisteredRouter,\n UseRouteContextBaseOptions,\n UseRouteContextOptions,\n UseRouteContextResult,\n} from '@tanstack/router-core'\n\nexport type UseRouteContextRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n>(\n opts?: UseRouteContextBaseOptions,\n) => UseRouteContextResult\n\nexport function useRouteContext<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TStrict extends boolean = true,\n TSelected = unknown,\n>(\n opts: UseRouteContextOptions,\n): UseRouteContextResult {\n return useMatch({\n ...(opts as any),\n select: (match) =>\n opts.select ? opts.select(match.context) : match.context,\n }) as UseRouteContextResult\n}\n", "import * as React from 'react'\nimport { flushSync } from 'react-dom'\nimport {\n deepEqual,\n exactPathTest,\n functionalUpdate,\n isDangerousProtocol,\n preloadWarning,\n removeTrailingSlash,\n} from '@tanstack/router-core'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { useRouterState } from './useRouterState'\nimport { useRouter } from './useRouter'\n\nimport { useForwardedRef, useIntersectionObserver } from './utils'\n\nimport { useHydrated } from './ClientOnly'\nimport type {\n AnyRouter,\n Constrain,\n LinkOptions,\n RegisteredRouter,\n RoutePaths,\n} from '@tanstack/router-core'\nimport type { ReactNode } from 'react'\nimport type {\n ValidateLinkOptions,\n ValidateLinkOptionsArray,\n} from './typePrimitives'\n\n/**\n * Build anchor-like props for declarative navigation and preloading.\n *\n * Returns stable `href`, event handlers and accessibility props derived from\n * router options and active state. Used internally by `Link` and custom links.\n *\n * Options cover `to`, `params`, `search`, `hash`, `state`, `preload`,\n * `activeProps`, `inactiveProps`, and more.\n *\n * @returns React anchor props suitable for `` or custom components.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useLinkPropsHook\n */\nexport function useLinkProps<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string = string,\n const TTo extends string | undefined = undefined,\n const TMaskFrom extends string = TFrom,\n const TMaskTo extends string = '',\n>(\n options: UseLinkPropsOptions,\n forwardedRef?: React.ForwardedRef,\n): React.ComponentPropsWithRef<'a'> {\n const router = useRouter()\n const innerRef = useForwardedRef(forwardedRef)\n\n // Determine if we're on the server - used for tree-shaking client-only code\n const _isServer = isServer ?? router.isServer\n\n const {\n // custom props\n activeProps,\n inactiveProps,\n activeOptions,\n to,\n preload: userPreload,\n preloadDelay: userPreloadDelay,\n hashScrollIntoView,\n replace,\n startTransition,\n resetScroll,\n viewTransition,\n // element props\n children,\n target,\n disabled,\n style,\n className,\n onClick,\n onBlur,\n onFocus,\n onMouseEnter,\n onMouseLeave,\n onTouchStart,\n ignoreBlocker,\n // prevent these from being returned\n params: _params,\n search: _search,\n hash: _hash,\n state: _state,\n mask: _mask,\n reloadDocument: _reloadDocument,\n unsafeRelative: _unsafeRelative,\n from: _from,\n _fromLocation,\n ...propsSafeToSpread\n } = options\n\n // ==========================================================================\n // SERVER EARLY RETURN\n // On the server, we return static props without any event handlers,\n // effects, or client-side interactivity.\n //\n // For SSR parity (to avoid hydration errors), we still compute the link's\n // active status on the server, but we avoid creating any router-state\n // subscriptions by reading from `router.state` directly.\n //\n // Note: `location.hash` is not available on the server.\n // ==========================================================================\n if (_isServer) {\n const safeInternal = isSafeInternal(to)\n\n // If `to` is obviously an absolute URL, treat as external and avoid\n // computing the internal location via `buildLocation`.\n if (\n typeof to === 'string' &&\n !safeInternal &&\n // Quick checks to avoid `new URL` in common internal-like cases\n to.indexOf(':') > -1\n ) {\n try {\n new URL(to)\n if (isDangerousProtocol(to, router.protocolAllowlist)) {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(`Blocked Link with dangerous protocol: ${to}`)\n }\n return {\n ...propsSafeToSpread,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n href: undefined,\n ...(children && { children }),\n ...(target && { target }),\n ...(disabled && { disabled }),\n ...(style && { style }),\n ...(className && { className }),\n }\n }\n\n return {\n ...propsSafeToSpread,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n href: to,\n ...(children && { children }),\n ...(target && { target }),\n ...(disabled && { disabled }),\n ...(style && { style }),\n ...(className && { className }),\n }\n } catch {\n // Not an absolute URL\n }\n }\n\n const next = router.buildLocation({ ...options, from: options.from } as any)\n\n // Use publicHref - it contains the correct href for display\n // When a rewrite changes the origin, publicHref is the full URL\n // Otherwise it's the origin-stripped path\n // This avoids constructing URL objects in the hot path\n const hrefOptionPublicHref = next.maskedLocation\n ? next.maskedLocation.publicHref\n : next.publicHref\n const hrefOptionExternal = next.maskedLocation\n ? next.maskedLocation.external\n : next.external\n const hrefOption = getHrefOption(\n hrefOptionPublicHref,\n hrefOptionExternal,\n router.history,\n disabled,\n )\n\n const externalLink = (() => {\n if (hrefOption?.external) {\n if (isDangerousProtocol(hrefOption.href, router.protocolAllowlist)) {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(\n `Blocked Link with dangerous protocol: ${hrefOption.href}`,\n )\n }\n return undefined\n }\n return hrefOption.href\n }\n\n if (safeInternal) return undefined\n\n // Only attempt URL parsing when it looks like an absolute URL.\n if (typeof to === 'string' && to.indexOf(':') > -1) {\n try {\n new URL(to)\n if (isDangerousProtocol(to, router.protocolAllowlist)) {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(`Blocked Link with dangerous protocol: ${to}`)\n }\n return undefined\n }\n return to\n } catch {}\n }\n\n return undefined\n })()\n\n const isActive = (() => {\n if (externalLink) return false\n\n const currentLocation = router.state.location\n\n const exact = activeOptions?.exact ?? false\n\n if (exact) {\n const testExact = exactPathTest(\n currentLocation.pathname,\n next.pathname,\n router.basepath,\n )\n if (!testExact) {\n return false\n }\n } else {\n const currentPathSplit = removeTrailingSlash(\n currentLocation.pathname,\n router.basepath,\n )\n const nextPathSplit = removeTrailingSlash(\n next.pathname,\n router.basepath,\n )\n\n const pathIsFuzzyEqual =\n currentPathSplit.startsWith(nextPathSplit) &&\n (currentPathSplit.length === nextPathSplit.length ||\n currentPathSplit[nextPathSplit.length] === '/')\n\n if (!pathIsFuzzyEqual) {\n return false\n }\n }\n\n const includeSearch = activeOptions?.includeSearch ?? true\n if (includeSearch) {\n if (currentLocation.search !== next.search) {\n const currentSearchEmpty =\n !currentLocation.search ||\n (typeof currentLocation.search === 'object' &&\n Object.keys(currentLocation.search).length === 0)\n const nextSearchEmpty =\n !next.search ||\n (typeof next.search === 'object' &&\n Object.keys(next.search).length === 0)\n\n if (!(currentSearchEmpty && nextSearchEmpty)) {\n const searchTest = deepEqual(currentLocation.search, next.search, {\n partial: !exact,\n ignoreUndefined: !activeOptions?.explicitUndefined,\n })\n if (!searchTest) {\n return false\n }\n }\n }\n }\n\n // Hash is not available on the server\n if (activeOptions?.includeHash) {\n return false\n }\n\n return true\n })()\n\n if (externalLink) {\n return {\n ...propsSafeToSpread,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n href: externalLink,\n ...(children && { children }),\n ...(target && { target }),\n ...(disabled && { disabled }),\n ...(style && { style }),\n ...(className && { className }),\n }\n }\n\n const resolvedActiveProps: React.HTMLAttributes =\n isActive\n ? (functionalUpdate(activeProps as any, {}) ?? STATIC_ACTIVE_OBJECT)\n : STATIC_EMPTY_OBJECT\n\n const resolvedInactiveProps: React.HTMLAttributes =\n isActive\n ? STATIC_EMPTY_OBJECT\n : (functionalUpdate(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT)\n\n const resolvedStyle = (() => {\n const baseStyle = style\n const activeStyle = resolvedActiveProps.style\n const inactiveStyle = resolvedInactiveProps.style\n\n if (!baseStyle && !activeStyle && !inactiveStyle) {\n return undefined\n }\n\n if (baseStyle && !activeStyle && !inactiveStyle) {\n return baseStyle\n }\n\n if (!baseStyle && activeStyle && !inactiveStyle) {\n return activeStyle\n }\n\n if (!baseStyle && !activeStyle && inactiveStyle) {\n return inactiveStyle\n }\n\n return {\n ...baseStyle,\n ...activeStyle,\n ...inactiveStyle,\n }\n })()\n\n const resolvedClassName = (() => {\n const baseClassName = className\n const activeClassName = resolvedActiveProps.className\n const inactiveClassName = resolvedInactiveProps.className\n\n if (!baseClassName && !activeClassName && !inactiveClassName) {\n return ''\n }\n\n let out = ''\n\n if (baseClassName) {\n out = baseClassName\n }\n\n if (activeClassName) {\n out = out ? `${out} ${activeClassName}` : activeClassName\n }\n\n if (inactiveClassName) {\n out = out ? `${out} ${inactiveClassName}` : inactiveClassName\n }\n\n return out\n })()\n\n return {\n ...propsSafeToSpread,\n ...resolvedActiveProps,\n ...resolvedInactiveProps,\n href: hrefOption?.href,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n disabled: !!disabled,\n target,\n ...(resolvedStyle && { style: resolvedStyle }),\n ...(resolvedClassName && { className: resolvedClassName }),\n ...(disabled && STATIC_DISABLED_PROPS),\n ...(isActive && STATIC_ACTIVE_PROPS),\n }\n }\n\n // ==========================================================================\n // CLIENT-ONLY CODE\n // Everything below this point only runs on the client. The `isServer` check\n // above is a compile-time constant that bundlers use for dead code elimination,\n // so this entire section is removed from server bundles.\n //\n // We disable the rules-of-hooks lint rule because these hooks appear after\n // an early return. This is safe because:\n // 1. `isServer` is a compile-time constant from conditional exports\n // 2. In server bundles, this code is completely eliminated by the bundler\n // 3. In client bundles, `isServer` is `false`, so the early return never executes\n // ==========================================================================\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const isHydrated = useHydrated()\n\n // subscribe to path/search/hash/params to re-build location when they change\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const currentLocationState = useRouterState({\n select: (s) => {\n const leaf = s.matches[s.matches.length - 1]\n return {\n search: leaf?.search,\n hash: s.location.hash,\n path: leaf?.pathname, // path + params\n }\n },\n structuralSharing: true as any,\n })\n\n const from = options.from\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const _options = React.useMemo(\n () => {\n return { ...options, from }\n },\n // eslint-disable-next-line react-hooks/exhaustive-deps\n [\n router,\n currentLocationState,\n from,\n options._fromLocation,\n options.hash,\n options.to,\n options.search,\n options.params,\n options.state,\n options.mask,\n options.unsafeRelative,\n ],\n )\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const next = React.useMemo(\n () => router.buildLocation({ ..._options } as any),\n [router, _options],\n )\n\n // Use publicHref - it contains the correct href for display\n // When a rewrite changes the origin, publicHref is the full URL\n // Otherwise it's the origin-stripped path\n // This avoids constructing URL objects in the hot path\n const hrefOptionPublicHref = next.maskedLocation\n ? next.maskedLocation.publicHref\n : next.publicHref\n const hrefOptionExternal = next.maskedLocation\n ? next.maskedLocation.external\n : next.external\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const hrefOption = React.useMemo(\n () =>\n getHrefOption(\n hrefOptionPublicHref,\n hrefOptionExternal,\n router.history,\n disabled,\n ),\n [disabled, hrefOptionExternal, hrefOptionPublicHref, router.history],\n )\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const externalLink = React.useMemo(() => {\n if (hrefOption?.external) {\n // Block dangerous protocols for external links\n if (isDangerousProtocol(hrefOption.href, router.protocolAllowlist)) {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(\n `Blocked Link with dangerous protocol: ${hrefOption.href}`,\n )\n }\n return undefined\n }\n return hrefOption.href\n }\n const safeInternal = isSafeInternal(to)\n if (safeInternal) return undefined\n if (typeof to !== 'string' || to.indexOf(':') === -1) return undefined\n try {\n new URL(to as any)\n // Block dangerous protocols like javascript:, blob:, data:\n if (isDangerousProtocol(to, router.protocolAllowlist)) {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(`Blocked Link with dangerous protocol: ${to}`)\n }\n return undefined\n }\n return to\n } catch {}\n return undefined\n }, [to, hrefOption, router.protocolAllowlist])\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const isActive = useRouterState({\n select: (s) => {\n if (externalLink) return false\n if (activeOptions?.exact) {\n const testExact = exactPathTest(\n s.location.pathname,\n next.pathname,\n router.basepath,\n )\n if (!testExact) {\n return false\n }\n } else {\n const currentPathSplit = removeTrailingSlash(\n s.location.pathname,\n router.basepath,\n )\n const nextPathSplit = removeTrailingSlash(\n next.pathname,\n router.basepath,\n )\n\n const pathIsFuzzyEqual =\n currentPathSplit.startsWith(nextPathSplit) &&\n (currentPathSplit.length === nextPathSplit.length ||\n currentPathSplit[nextPathSplit.length] === '/')\n\n if (!pathIsFuzzyEqual) {\n return false\n }\n }\n\n if (activeOptions?.includeSearch ?? true) {\n const searchTest = deepEqual(s.location.search, next.search, {\n partial: !activeOptions?.exact,\n ignoreUndefined: !activeOptions?.explicitUndefined,\n })\n if (!searchTest) {\n return false\n }\n }\n\n if (activeOptions?.includeHash) {\n return isHydrated && s.location.hash === next.hash\n }\n return true\n },\n })\n\n // Get the active props\n const resolvedActiveProps: React.HTMLAttributes = isActive\n ? (functionalUpdate(activeProps as any, {}) ?? STATIC_ACTIVE_OBJECT)\n : STATIC_EMPTY_OBJECT\n\n // Get the inactive props\n const resolvedInactiveProps: React.HTMLAttributes =\n isActive\n ? STATIC_EMPTY_OBJECT\n : (functionalUpdate(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT)\n\n const resolvedClassName = [\n className,\n resolvedActiveProps.className,\n resolvedInactiveProps.className,\n ]\n .filter(Boolean)\n .join(' ')\n\n const resolvedStyle = (style ||\n resolvedActiveProps.style ||\n resolvedInactiveProps.style) && {\n ...style,\n ...resolvedActiveProps.style,\n ...resolvedInactiveProps.style,\n }\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const [isTransitioning, setIsTransitioning] = React.useState(false)\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const hasRenderFetched = React.useRef(false)\n\n const preload =\n options.reloadDocument || externalLink\n ? false\n : (userPreload ?? router.options.defaultPreload)\n const preloadDelay =\n userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const doPreload = React.useCallback(() => {\n router\n .preloadRoute({ ..._options, _builtLocation: next } as any)\n .catch((err) => {\n console.warn(err)\n console.warn(preloadWarning)\n })\n }, [router, _options, next])\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const preloadViewportIoCallback = React.useCallback(\n (entry: IntersectionObserverEntry | undefined) => {\n if (entry?.isIntersecting) {\n doPreload()\n }\n },\n [doPreload],\n )\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n useIntersectionObserver(\n innerRef,\n preloadViewportIoCallback,\n intersectionObserverOptions,\n { disabled: !!disabled || !(preload === 'viewport') },\n )\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n React.useEffect(() => {\n if (hasRenderFetched.current) {\n return\n }\n if (!disabled && preload === 'render') {\n doPreload()\n hasRenderFetched.current = true\n }\n }, [disabled, doPreload, preload])\n\n // The click handler\n const handleClick = (e: React.MouseEvent) => {\n // Check actual element's target attribute as fallback\n const elementTarget = (\n e.currentTarget as HTMLAnchorElement | SVGAElement\n ).getAttribute('target')\n const effectiveTarget = target !== undefined ? target : elementTarget\n\n if (\n !disabled &&\n !isCtrlEvent(e) &&\n !e.defaultPrevented &&\n (!effectiveTarget || effectiveTarget === '_self') &&\n e.button === 0\n ) {\n e.preventDefault()\n\n flushSync(() => {\n setIsTransitioning(true)\n })\n\n const unsub = router.subscribe('onResolved', () => {\n unsub()\n setIsTransitioning(false)\n })\n\n // All is well? Navigate!\n // N.B. we don't call `router.commitLocation(next) here because we want to run `validateSearch` before committing\n router.navigate({\n ..._options,\n replace,\n resetScroll,\n hashScrollIntoView,\n startTransition,\n viewTransition,\n ignoreBlocker,\n })\n }\n }\n\n if (externalLink) {\n return {\n ...propsSafeToSpread,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n href: externalLink,\n ...(children && { children }),\n ...(target && { target }),\n ...(disabled && { disabled }),\n ...(style && { style }),\n ...(className && { className }),\n ...(onClick && { onClick }),\n ...(onBlur && { onBlur }),\n ...(onFocus && { onFocus }),\n ...(onMouseEnter && { onMouseEnter }),\n ...(onMouseLeave && { onMouseLeave }),\n ...(onTouchStart && { onTouchStart }),\n }\n }\n\n const enqueueIntentPreload = (e: React.MouseEvent | React.FocusEvent) => {\n if (disabled || preload !== 'intent') return\n\n if (!preloadDelay) {\n doPreload()\n return\n }\n\n const eventTarget = e.currentTarget\n\n if (timeoutMap.has(eventTarget)) {\n return\n }\n\n const id = setTimeout(() => {\n timeoutMap.delete(eventTarget)\n doPreload()\n }, preloadDelay)\n timeoutMap.set(eventTarget, id)\n }\n\n const handleTouchStart = (_: React.TouchEvent) => {\n if (disabled || preload !== 'intent') return\n doPreload()\n }\n\n const handleLeave = (e: React.MouseEvent | React.FocusEvent) => {\n if (disabled || !preload || !preloadDelay) return\n const eventTarget = e.currentTarget\n const id = timeoutMap.get(eventTarget)\n if (id) {\n clearTimeout(id)\n timeoutMap.delete(eventTarget)\n }\n }\n\n return {\n ...propsSafeToSpread,\n ...resolvedActiveProps,\n ...resolvedInactiveProps,\n href: hrefOption?.href,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n onClick: composeHandlers([onClick, handleClick]),\n onBlur: composeHandlers([onBlur, handleLeave]),\n onFocus: composeHandlers([onFocus, enqueueIntentPreload]),\n onMouseEnter: composeHandlers([onMouseEnter, enqueueIntentPreload]),\n onMouseLeave: composeHandlers([onMouseLeave, handleLeave]),\n onTouchStart: composeHandlers([onTouchStart, handleTouchStart]),\n disabled: !!disabled,\n target,\n ...(resolvedStyle && { style: resolvedStyle }),\n ...(resolvedClassName && { className: resolvedClassName }),\n ...(disabled && STATIC_DISABLED_PROPS),\n ...(isActive && STATIC_ACTIVE_PROPS),\n ...(isHydrated && isTransitioning && STATIC_TRANSITIONING_PROPS),\n }\n}\n\nconst STATIC_EMPTY_OBJECT = {}\nconst STATIC_ACTIVE_OBJECT = { className: 'active' }\nconst STATIC_DISABLED_PROPS = { role: 'link', 'aria-disabled': true }\nconst STATIC_ACTIVE_PROPS = { 'data-status': 'active', 'aria-current': 'page' }\nconst STATIC_TRANSITIONING_PROPS = { 'data-transitioning': 'transitioning' }\n\nconst timeoutMap = new WeakMap>()\n\nconst intersectionObserverOptions: IntersectionObserverInit = {\n rootMargin: '100px',\n}\n\nconst composeHandlers =\n (handlers: Array>) =>\n (e: React.SyntheticEvent) => {\n for (const handler of handlers) {\n if (!handler) continue\n if (e.defaultPrevented) return\n handler(e)\n }\n }\n\nfunction getHrefOption(\n publicHref: string,\n external: boolean,\n history: AnyRouter['history'],\n disabled: boolean | undefined,\n) {\n if (disabled) return undefined\n // Full URL means rewrite changed the origin - treat as external-like\n if (external) {\n return { href: publicHref, external: true }\n }\n return {\n href: history.createHref(publicHref) || '/',\n external: false,\n }\n}\n\nfunction isSafeInternal(to: unknown) {\n if (typeof to !== 'string') return false\n const zero = to.charCodeAt(0)\n if (zero === 47) return to.charCodeAt(1) !== 47 // '/' but not '//'\n return zero === 46 // '.', '..', './', '../'\n}\n\ntype UseLinkReactProps = TComp extends keyof React.JSX.IntrinsicElements\n ? React.JSX.IntrinsicElements[TComp]\n : TComp extends React.ComponentType\n ? React.ComponentPropsWithoutRef &\n React.RefAttributes>\n : never\n\nexport type UseLinkPropsOptions<\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends RoutePaths | string = string,\n TTo extends string | undefined = '.',\n TMaskFrom extends RoutePaths | string = TFrom,\n TMaskTo extends string = '.',\n> = ActiveLinkOptions<'a', TRouter, TFrom, TTo, TMaskFrom, TMaskTo> &\n UseLinkReactProps<'a'>\n\nexport type ActiveLinkOptions<\n TComp = 'a',\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends string = string,\n TTo extends string | undefined = '.',\n TMaskFrom extends string = TFrom,\n TMaskTo extends string = '.',\n> = LinkOptions &\n ActiveLinkOptionProps\n\ntype ActiveLinkProps = Partial<\n LinkComponentReactProps & {\n [key: `data-${string}`]: unknown\n }\n>\n\nexport interface ActiveLinkOptionProps {\n /**\n * A function that returns additional props for the `active` state of this link.\n * These props override other props passed to the link (`style`'s are merged, `className`'s are concatenated)\n */\n activeProps?: ActiveLinkProps | (() => ActiveLinkProps)\n /**\n * A function that returns additional props for the `inactive` state of this link.\n * These props override other props passed to the link (`style`'s are merged, `className`'s are concatenated)\n */\n inactiveProps?: ActiveLinkProps | (() => ActiveLinkProps)\n}\n\nexport type LinkProps<\n TComp = 'a',\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends string = string,\n TTo extends string | undefined = '.',\n TMaskFrom extends string = TFrom,\n TMaskTo extends string = '.',\n> = ActiveLinkOptions &\n LinkPropsChildren\n\nexport interface LinkPropsChildren {\n // If a function is passed as a child, it will be given the `isActive` boolean to aid in further styling on the element it returns\n children?:\n | React.ReactNode\n | ((state: {\n isActive: boolean\n isTransitioning: boolean\n }) => React.ReactNode)\n}\n\ntype LinkComponentReactProps = Omit<\n UseLinkReactProps,\n keyof CreateLinkProps\n>\n\nexport type LinkComponentProps<\n TComp = 'a',\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends string = string,\n TTo extends string | undefined = '.',\n TMaskFrom extends string = TFrom,\n TMaskTo extends string = '.',\n> = LinkComponentReactProps &\n LinkProps\n\nexport type CreateLinkProps = LinkProps<\n any,\n any,\n string,\n string,\n string,\n string\n>\n\nexport type LinkComponent<\n in out TComp,\n in out TDefaultFrom extends string = string,\n> = <\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string = TDefaultFrom,\n const TTo extends string | undefined = undefined,\n const TMaskFrom extends string = TFrom,\n const TMaskTo extends string = '',\n>(\n props: LinkComponentProps,\n) => React.ReactElement\n\nexport interface LinkComponentRoute<\n in out TDefaultFrom extends string = string,\n> {\n defaultFrom: TDefaultFrom;\n <\n TRouter extends AnyRouter = RegisteredRouter,\n const TTo extends string | undefined = undefined,\n const TMaskTo extends string = '',\n >(\n props: LinkComponentProps<\n 'a',\n TRouter,\n this['defaultFrom'],\n TTo,\n this['defaultFrom'],\n TMaskTo\n >,\n ): React.ReactElement\n}\n\n/**\n * Creates a typed Link-like component that preserves TanStack Router's\n * navigation semantics and type-safety while delegating rendering to the\n * provided host component.\n *\n * Useful for integrating design system anchors/buttons while keeping\n * router-aware props (eg. `to`, `params`, `search`, `preload`).\n *\n * @param Comp The host component to render (eg. a design-system Link/Button)\n * @returns A router-aware component with the same API as `Link`.\n * @link https://tanstack.com/router/latest/docs/framework/react/guide/custom-link\n */\nexport function createLink(\n Comp: Constrain ReactNode>,\n): LinkComponent {\n return React.forwardRef(function CreatedLink(props, ref) {\n return \n }) as any\n}\n\n/**\n * A strongly-typed anchor component for declarative navigation.\n * Handles path, search, hash and state updates with optional route preloading\n * and active-state styling.\n *\n * Props:\n * - `preload`: Controls route preloading (eg. 'intent', 'render', 'viewport', true/false)\n * - `preloadDelay`: Delay in ms before preloading on hover\n * - `activeProps`/`inactiveProps`: Additional props merged when link is active/inactive\n * - `resetScroll`/`hashScrollIntoView`: Control scroll behavior on navigation\n * - `viewTransition`/`startTransition`: Use View Transitions/React transitions for navigation\n * - `ignoreBlocker`: Bypass registered blockers\n *\n * @returns An anchor-like element that navigates without full page reloads.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/linkComponent\n */\nexport const Link: LinkComponent<'a'> = React.forwardRef(\n (props, ref) => {\n const { _asChild, ...rest } = props\n const { type: _type, ...linkProps } = useLinkProps(rest as any, ref)\n\n const children =\n typeof rest.children === 'function'\n ? rest.children({\n isActive: (linkProps as any)['data-status'] === 'active',\n })\n : rest.children\n\n if (!_asChild) {\n // the ReturnType of useLinkProps returns the correct type for a element, not a general component that has a disabled prop\n // @ts-expect-error\n const { disabled: _, ...rest } = linkProps\n return React.createElement('a', rest, children)\n }\n return React.createElement(_asChild, linkProps, children)\n },\n) as any\n\nfunction isCtrlEvent(e: React.MouseEvent) {\n return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey)\n}\n\nexport type LinkOptionsFnOptions<\n TOptions,\n TComp,\n TRouter extends AnyRouter = RegisteredRouter,\n> =\n TOptions extends ReadonlyArray\n ? ValidateLinkOptionsArray\n : ValidateLinkOptions\n\nexport type LinkOptionsFn = <\n const TOptions,\n TRouter extends AnyRouter = RegisteredRouter,\n>(\n options: LinkOptionsFnOptions,\n) => TOptions\n\n/**\n * Validate and reuse navigation options for `Link`, `navigate` or `redirect`.\n * Accepts a literal options object and returns it typed for later spreading.\n * @example\n * const opts = linkOptions({ to: '/dashboard', search: { tab: 'home' } })\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/linkOptions\n */\nexport const linkOptions: LinkOptionsFn<'a'> = (options) => {\n return options as any\n}\n\n/**\n * Type-check a literal object for use with `Link`, `navigate` or `redirect`.\n * Use to validate and reuse navigation options across your app.\n * @example\n * const opts = linkOptions({ to: '/dashboard', search: { tab: 'home' } })\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/linkOptions\n */\n", "import {\n BaseRootRoute,\n BaseRoute,\n BaseRouteApi,\n notFound,\n} from '@tanstack/router-core'\nimport React from 'react'\nimport { useLoaderData } from './useLoaderData'\nimport { useLoaderDeps } from './useLoaderDeps'\nimport { useParams } from './useParams'\nimport { useSearch } from './useSearch'\nimport { useNavigate } from './useNavigate'\nimport { useMatch } from './useMatch'\nimport { useRouteContext } from './useRouteContext'\nimport { useRouter } from './useRouter'\nimport { Link } from './link'\nimport type {\n AnyContext,\n AnyRoute,\n AnyRouter,\n ConstrainLiteral,\n ErrorComponentProps,\n NotFoundError,\n NotFoundRouteProps,\n Register,\n RegisteredRouter,\n ResolveFullPath,\n ResolveId,\n ResolveParams,\n RootRoute as RootRouteCore,\n RootRouteId,\n RootRouteOptions,\n RouteConstraints,\n Route as RouteCore,\n RouteIds,\n RouteMask,\n RouteOptions,\n RouteTypesById,\n RouterCore,\n ToMaskOptions,\n UseNavigateResult,\n} from '@tanstack/router-core'\nimport type { UseLoaderDataRoute } from './useLoaderData'\nimport type { UseMatchRoute } from './useMatch'\nimport type { UseLoaderDepsRoute } from './useLoaderDeps'\nimport type { UseParamsRoute } from './useParams'\nimport type { UseSearchRoute } from './useSearch'\nimport type { UseRouteContextRoute } from './useRouteContext'\nimport type { LinkComponentRoute } from './link'\n\ndeclare module '@tanstack/router-core' {\n export interface UpdatableRouteOptionsExtensions {\n component?: RouteComponent\n errorComponent?: false | null | undefined | ErrorRouteComponent\n notFoundComponent?: NotFoundRouteComponent\n pendingComponent?: RouteComponent\n }\n\n export interface RootRouteOptionsExtensions {\n shellComponent?: ({\n children,\n }: {\n children: React.ReactNode\n }) => React.ReactNode\n }\n\n export interface RouteExtensions<\n in out TId extends string,\n in out TFullPath extends string,\n > {\n useMatch: UseMatchRoute\n useRouteContext: UseRouteContextRoute\n useSearch: UseSearchRoute\n useParams: UseParamsRoute\n useLoaderDeps: UseLoaderDepsRoute\n useLoaderData: UseLoaderDataRoute\n useNavigate: () => UseNavigateResult\n Link: LinkComponentRoute\n }\n}\n\n/**\n * Returns a route-specific API that exposes type-safe hooks pre-bound\n * to a single route ID. Useful for consuming a route's APIs from files\n * where the route object isn't directly imported (e.g. code-split files).\n *\n * @param id Route ID string literal for the target route.\n * @returns A `RouteApi` instance bound to the given route ID.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/getRouteApiFunction\n */\nexport function getRouteApi<\n const TId,\n TRouter extends AnyRouter = RegisteredRouter,\n>(id: ConstrainLiteral>) {\n return new RouteApi({ id })\n}\n\nexport class RouteApi<\n TId,\n TRouter extends AnyRouter = RegisteredRouter,\n> extends BaseRouteApi {\n /**\n * @deprecated Use the `getRouteApi` function instead.\n */\n constructor({ id }: { id: TId }) {\n super({ id })\n }\n\n useMatch: UseMatchRoute = (opts) => {\n return useMatch({\n select: opts?.select,\n from: this.id,\n structuralSharing: opts?.structuralSharing,\n } as any) as any\n }\n\n useRouteContext: UseRouteContextRoute = (opts) => {\n return useRouteContext({ ...(opts as any), from: this.id as any })\n }\n\n useSearch: UseSearchRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useSearch({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useParams: UseParamsRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useParams({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useLoaderDeps: UseLoaderDepsRoute = (opts) => {\n return useLoaderDeps({ ...opts, from: this.id, strict: false } as any)\n }\n\n useLoaderData: UseLoaderDataRoute = (opts) => {\n return useLoaderData({ ...opts, from: this.id, strict: false } as any)\n }\n\n useNavigate = (): UseNavigateResult<\n RouteTypesById['fullPath']\n > => {\n const router = useRouter()\n return useNavigate({ from: router.routesById[this.id as string].fullPath })\n }\n\n notFound = (opts?: NotFoundError) => {\n return notFound({ routeId: this.id as string, ...opts })\n }\n\n Link: LinkComponentRoute['fullPath']> =\n React.forwardRef((props, ref: React.ForwardedRef) => {\n const router = useRouter()\n const fullPath = router.routesById[this.id as string].fullPath\n return \n }) as unknown as LinkComponentRoute<\n RouteTypesById['fullPath']\n >\n}\n\nexport class Route<\n in out TRegister = unknown,\n in out TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute,\n in out TPath extends RouteConstraints['TPath'] = '/',\n in out TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<\n TParentRoute,\n TPath\n >,\n in out TCustomId extends RouteConstraints['TCustomId'] = string,\n in out TId extends RouteConstraints['TId'] = ResolveId<\n TParentRoute,\n TCustomId,\n TPath\n >,\n in out TSearchValidator = undefined,\n in out TParams = ResolveParams,\n in out TRouterContext = AnyContext,\n in out TRouteContextFn = AnyContext,\n in out TBeforeLoadFn = AnyContext,\n in out TLoaderDeps extends Record = {},\n in out TLoaderFn = undefined,\n in out TChildren = unknown,\n in out TFileRouteTypes = unknown,\n in out TSSR = unknown,\n in out TServerMiddlewares = unknown,\n in out THandlers = undefined,\n>\n extends BaseRoute<\n TRegister,\n TParentRoute,\n TPath,\n TFullPath,\n TCustomId,\n TId,\n TSearchValidator,\n TParams,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TFileRouteTypes,\n TSSR,\n TServerMiddlewares,\n THandlers\n >\n implements\n RouteCore<\n TRegister,\n TParentRoute,\n TPath,\n TFullPath,\n TCustomId,\n TId,\n TSearchValidator,\n TParams,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TFileRouteTypes,\n TSSR,\n TServerMiddlewares,\n THandlers\n >\n{\n /**\n * @deprecated Use the `createRoute` function instead.\n */\n constructor(\n options?: RouteOptions<\n TRegister,\n TParentRoute,\n TId,\n TCustomId,\n TFullPath,\n TPath,\n TSearchValidator,\n TParams,\n TLoaderDeps,\n TLoaderFn,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TSSR,\n TServerMiddlewares,\n THandlers\n >,\n ) {\n super(options)\n ;(this as any).$$typeof = Symbol.for('react.memo')\n }\n\n useMatch: UseMatchRoute = (opts) => {\n return useMatch({\n select: opts?.select,\n from: this.id,\n structuralSharing: opts?.structuralSharing,\n } as any) as any\n }\n\n useRouteContext: UseRouteContextRoute = (opts?) => {\n return useRouteContext({ ...(opts as any), from: this.id })\n }\n\n useSearch: UseSearchRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useSearch({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useParams: UseParamsRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useParams({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useLoaderDeps: UseLoaderDepsRoute = (opts) => {\n return useLoaderDeps({ ...opts, from: this.id } as any)\n }\n\n useLoaderData: UseLoaderDataRoute = (opts) => {\n return useLoaderData({ ...opts, from: this.id } as any)\n }\n\n useNavigate = (): UseNavigateResult => {\n return useNavigate({ from: this.fullPath })\n }\n\n Link: LinkComponentRoute = React.forwardRef(\n (props, ref: React.ForwardedRef) => {\n return \n },\n ) as unknown as LinkComponentRoute\n}\n\n/**\n * Creates a non-root Route instance for code-based routing.\n *\n * Use this to define a route that will be composed into a route tree\n * (typically via a parent route's `addChildren`). If you're using file-based\n * routing, prefer `createFileRoute`.\n *\n * @param options Route options (path, component, loader, context, etc.).\n * @returns A Route instance to be attached to the route tree.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouteFunction\n */\nexport function createRoute<\n TRegister = unknown,\n TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute,\n TPath extends RouteConstraints['TPath'] = '/',\n TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<\n TParentRoute,\n TPath\n >,\n TCustomId extends RouteConstraints['TCustomId'] = string,\n TId extends RouteConstraints['TId'] = ResolveId<\n TParentRoute,\n TCustomId,\n TPath\n >,\n TSearchValidator = undefined,\n TParams = ResolveParams,\n TRouteContextFn = AnyContext,\n TBeforeLoadFn = AnyContext,\n TLoaderDeps extends Record = {},\n TLoaderFn = undefined,\n TChildren = unknown,\n TSSR = unknown,\n const TServerMiddlewares = unknown,\n>(\n options: RouteOptions<\n TRegister,\n TParentRoute,\n TId,\n TCustomId,\n TFullPath,\n TPath,\n TSearchValidator,\n TParams,\n TLoaderDeps,\n TLoaderFn,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TSSR,\n TServerMiddlewares\n >,\n): Route<\n TRegister,\n TParentRoute,\n TPath,\n TFullPath,\n TCustomId,\n TId,\n TSearchValidator,\n TParams,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TSSR,\n TServerMiddlewares\n> {\n return new Route<\n TRegister,\n TParentRoute,\n TPath,\n TFullPath,\n TCustomId,\n TId,\n TSearchValidator,\n TParams,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TSSR,\n TServerMiddlewares\n >(\n // TODO: Help us TypeChris, you're our only hope!\n options as any,\n )\n}\n\nexport type AnyRootRoute = RootRoute<\n any,\n any,\n any,\n any,\n any,\n any,\n any,\n any,\n any,\n any,\n any\n>\n\n/**\n * Creates a root route factory that requires a router context type.\n *\n * Use when your root route expects `context` to be provided to `createRouter`.\n * The returned function behaves like `createRootRoute` but enforces a context type.\n *\n * @returns A factory function to configure and return a root route.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRootRouteWithContextFunction\n */\nexport function createRootRouteWithContext() {\n return <\n TRegister = Register,\n TRouteContextFn = AnyContext,\n TBeforeLoadFn = AnyContext,\n TSearchValidator = undefined,\n TLoaderDeps extends Record = {},\n TLoaderFn = undefined,\n TSSR = unknown,\n TServerMiddlewares = unknown,\n >(\n options?: RootRouteOptions<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TSSR,\n TServerMiddlewares\n >,\n ) => {\n return createRootRoute<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TSSR,\n TServerMiddlewares\n >(options)\n }\n}\n\n/**\n * @deprecated Use the `createRootRouteWithContext` function instead.\n */\nexport const rootRouteWithContext = createRootRouteWithContext\n\nexport class RootRoute<\n in out TRegister = unknown,\n in out TSearchValidator = undefined,\n in out TRouterContext = {},\n in out TRouteContextFn = AnyContext,\n in out TBeforeLoadFn = AnyContext,\n in out TLoaderDeps extends Record = {},\n in out TLoaderFn = undefined,\n in out TChildren = unknown,\n in out TFileRouteTypes = unknown,\n in out TSSR = unknown,\n in out TServerMiddlewares = unknown,\n in out THandlers = undefined,\n>\n extends BaseRootRoute<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TFileRouteTypes,\n TSSR,\n TServerMiddlewares,\n THandlers\n >\n implements\n RootRouteCore<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TFileRouteTypes,\n TSSR,\n TServerMiddlewares,\n THandlers\n >\n{\n /**\n * @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.\n */\n constructor(\n options?: RootRouteOptions<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TSSR,\n TServerMiddlewares,\n THandlers\n >,\n ) {\n super(options)\n ;(this as any).$$typeof = Symbol.for('react.memo')\n }\n\n useMatch: UseMatchRoute = (opts) => {\n return useMatch({\n select: opts?.select,\n from: this.id,\n structuralSharing: opts?.structuralSharing,\n } as any) as any\n }\n\n useRouteContext: UseRouteContextRoute = (opts) => {\n return useRouteContext({ ...(opts as any), from: this.id })\n }\n\n useSearch: UseSearchRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useSearch({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useParams: UseParamsRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useParams({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useLoaderDeps: UseLoaderDepsRoute = (opts) => {\n return useLoaderDeps({ ...opts, from: this.id } as any)\n }\n\n useLoaderData: UseLoaderDataRoute = (opts) => {\n return useLoaderData({ ...opts, from: this.id } as any)\n }\n\n useNavigate = (): UseNavigateResult<'/'> => {\n return useNavigate({ from: this.fullPath })\n }\n\n Link: LinkComponentRoute<'/'> = React.forwardRef(\n (props, ref: React.ForwardedRef) => {\n return \n },\n ) as unknown as LinkComponentRoute<'/'>\n}\n\n/**\n * Creates a root Route instance used to build your route tree.\n *\n * Typically paired with `createRouter({ routeTree })`. If you need to require\n * a typed router context, use `createRootRouteWithContext` instead.\n *\n * @param options Root route options (component, error, pending, etc.).\n * @returns A root route instance.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRootRouteFunction\n */\nexport function createRootRoute<\n TRegister = Register,\n TSearchValidator = undefined,\n TRouterContext = {},\n TRouteContextFn = AnyContext,\n TBeforeLoadFn = AnyContext,\n TLoaderDeps extends Record = {},\n TLoaderFn = undefined,\n TSSR = unknown,\n const TServerMiddlewares = unknown,\n THandlers = undefined,\n>(\n options?: RootRouteOptions<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TSSR,\n TServerMiddlewares,\n THandlers\n >,\n): RootRoute<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n unknown,\n unknown,\n TSSR,\n TServerMiddlewares,\n THandlers\n> {\n return new RootRoute<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n unknown,\n unknown,\n TSSR,\n TServerMiddlewares,\n THandlers\n >(options)\n}\n\nexport function createRouteMask<\n TRouteTree extends AnyRoute,\n TFrom extends string,\n TTo extends string,\n>(\n opts: {\n routeTree: TRouteTree\n } & ToMaskOptions, TFrom, TTo>,\n): RouteMask {\n return opts as any\n}\n\nexport interface DefaultRouteTypes {\n component:\n | ((props: TProps) => any)\n | React.LazyExoticComponent<(props: TProps) => any>\n}\nexport interface RouteTypes extends DefaultRouteTypes {}\n\nexport type AsyncRouteComponent = RouteTypes['component'] & {\n preload?: () => Promise\n}\n\nexport type RouteComponent = AsyncRouteComponent<{}>\n\nexport type ErrorRouteComponent = AsyncRouteComponent\n\nexport type NotFoundRouteComponent = RouteTypes['component']\n\nexport class NotFoundRoute<\n TRegister,\n TParentRoute extends AnyRootRoute,\n TRouterContext = AnyContext,\n TRouteContextFn = AnyContext,\n TBeforeLoadFn = AnyContext,\n TSearchValidator = undefined,\n TLoaderDeps extends Record = {},\n TLoaderFn = undefined,\n TChildren = unknown,\n TSSR = unknown,\n TServerMiddlewares = unknown,\n> extends Route<\n TRegister,\n TParentRoute,\n '/404',\n '/404',\n '404',\n '404',\n TSearchValidator,\n {},\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TSSR,\n TServerMiddlewares\n> {\n constructor(\n options: Omit<\n RouteOptions<\n TRegister,\n TParentRoute,\n string,\n string,\n string,\n string,\n TSearchValidator,\n {},\n TLoaderDeps,\n TLoaderFn,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TSSR,\n TServerMiddlewares\n >,\n | 'caseSensitive'\n | 'parseParams'\n | 'stringifyParams'\n | 'path'\n | 'id'\n | 'params'\n >,\n ) {\n super({\n ...(options as any),\n id: '404',\n })\n }\n}\n", "import warning from 'tiny-warning'\nimport { createRoute } from './route'\n\nimport { useMatch } from './useMatch'\nimport { useLoaderDeps } from './useLoaderDeps'\nimport { useLoaderData } from './useLoaderData'\nimport { useSearch } from './useSearch'\nimport { useParams } from './useParams'\nimport { useNavigate } from './useNavigate'\nimport { useRouter } from './useRouter'\nimport { useRouteContext } from './useRouteContext'\nimport type { UseParamsRoute } from './useParams'\nimport type { UseMatchRoute } from './useMatch'\nimport type { UseSearchRoute } from './useSearch'\nimport type {\n AnyContext,\n AnyRoute,\n AnyRouter,\n Constrain,\n ConstrainLiteral,\n FileBaseRouteOptions,\n FileRoutesByPath,\n LazyRouteOptions,\n Register,\n RegisteredRouter,\n ResolveParams,\n Route,\n RouteById,\n RouteConstraints,\n RouteIds,\n RouteLoaderFn,\n UpdatableRouteOptions,\n UseNavigateResult,\n} from '@tanstack/router-core'\nimport type { UseLoaderDepsRoute } from './useLoaderDeps'\nimport type { UseLoaderDataRoute } from './useLoaderData'\nimport type { UseRouteContextRoute } from './useRouteContext'\n\n/**\n * Creates a file-based Route factory for a given path.\n *\n * Used by TanStack Router's file-based routing to associate a file with a\n * route. The returned function accepts standard route options. In normal usage\n * the `path` string is inserted and maintained by the `tsr` generator.\n *\n * @param path File path literal for the route (usually auto-generated).\n * @returns A function that accepts Route options and returns a Route instance.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createFileRouteFunction\n */\nexport function createFileRoute<\n TFilePath extends keyof FileRoutesByPath,\n TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],\n TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'],\n TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'],\n TFullPath extends RouteConstraints['TFullPath'] =\n FileRoutesByPath[TFilePath]['fullPath'],\n>(\n path?: TFilePath,\n): FileRoute['createRoute'] {\n if (typeof path === 'object') {\n return new FileRoute(path, {\n silent: true,\n }).createRoute(path) as any\n }\n return new FileRoute(path, {\n silent: true,\n }).createRoute\n}\n\n/** \n @deprecated It's no longer recommended to use the `FileRoute` class directly.\n Instead, use `createFileRoute('/path/to/file')(options)` to create a file route.\n*/\nexport class FileRoute<\n TFilePath extends keyof FileRoutesByPath,\n TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],\n TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'],\n TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'],\n TFullPath extends RouteConstraints['TFullPath'] =\n FileRoutesByPath[TFilePath]['fullPath'],\n> {\n silent?: boolean\n\n constructor(\n public path?: TFilePath,\n _opts?: { silent: boolean },\n ) {\n this.silent = _opts?.silent\n }\n\n createRoute = <\n TRegister = Register,\n TSearchValidator = undefined,\n TParams = ResolveParams,\n TRouteContextFn = AnyContext,\n TBeforeLoadFn = AnyContext,\n TLoaderDeps extends Record = {},\n TLoaderFn = undefined,\n TChildren = unknown,\n TSSR = unknown,\n const TMiddlewares = unknown,\n THandlers = undefined,\n >(\n options?: FileBaseRouteOptions<\n TRegister,\n TParentRoute,\n TId,\n TPath,\n TSearchValidator,\n TParams,\n TLoaderDeps,\n TLoaderFn,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn,\n AnyContext,\n TSSR,\n TMiddlewares,\n THandlers\n > &\n UpdatableRouteOptions<\n TParentRoute,\n TId,\n TFullPath,\n TParams,\n TSearchValidator,\n TLoaderFn,\n TLoaderDeps,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn\n >,\n ): Route<\n TRegister,\n TParentRoute,\n TPath,\n TFullPath,\n TFilePath,\n TId,\n TSearchValidator,\n TParams,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n unknown,\n TSSR,\n TMiddlewares,\n THandlers\n > => {\n if (process.env.NODE_ENV !== 'production') {\n warning(\n this.silent,\n 'FileRoute is deprecated and will be removed in the next major version. Use the createFileRoute(path)(options) function instead.',\n )\n }\n const route = createRoute(options as any)\n ;(route as any).isRoot = false\n return route as any\n }\n}\n\n/**\n @deprecated It's recommended not to split loaders into separate files.\n Instead, place the loader function in the main route file via `createFileRoute`.\n*/\nexport function FileRouteLoader<\n TFilePath extends keyof FileRoutesByPath,\n TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute'],\n>(\n _path: TFilePath,\n): (\n loaderFn: Constrain<\n TLoaderFn,\n RouteLoaderFn<\n Register,\n TRoute['parentRoute'],\n TRoute['types']['id'],\n TRoute['types']['params'],\n TRoute['types']['loaderDeps'],\n TRoute['types']['routerContext'],\n TRoute['types']['routeContextFn'],\n TRoute['types']['beforeLoadFn']\n >\n >,\n) => TLoaderFn {\n if (process.env.NODE_ENV !== 'production') {\n warning(\n false,\n `FileRouteLoader is deprecated and will be removed in the next major version. Please place the loader function in the the main route file, inside the \\`createFileRoute('/path/to/file')(options)\\` options`,\n )\n }\n return (loaderFn) => loaderFn as any\n}\n\ndeclare module '@tanstack/router-core' {\n export interface LazyRoute {\n useMatch: UseMatchRoute\n useRouteContext: UseRouteContextRoute\n useSearch: UseSearchRoute\n useParams: UseParamsRoute\n useLoaderDeps: UseLoaderDepsRoute\n useLoaderData: UseLoaderDataRoute\n useNavigate: () => UseNavigateResult\n }\n}\n\nexport class LazyRoute {\n options: {\n id: string\n } & LazyRouteOptions\n\n constructor(\n opts: {\n id: string\n } & LazyRouteOptions,\n ) {\n this.options = opts\n ;(this as any).$$typeof = Symbol.for('react.memo')\n }\n\n useMatch: UseMatchRoute = (opts) => {\n return useMatch({\n select: opts?.select,\n from: this.options.id,\n structuralSharing: opts?.structuralSharing,\n } as any) as any\n }\n\n useRouteContext: UseRouteContextRoute = (opts) => {\n return useRouteContext({ ...(opts as any), from: this.options.id })\n }\n\n useSearch: UseSearchRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useSearch({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.options.id,\n } as any) as any\n }\n\n useParams: UseParamsRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useParams({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.options.id,\n } as any) as any\n }\n\n useLoaderDeps: UseLoaderDepsRoute = (opts) => {\n return useLoaderDeps({ ...opts, from: this.options.id } as any)\n }\n\n useLoaderData: UseLoaderDataRoute = (opts) => {\n return useLoaderData({ ...opts, from: this.options.id } as any)\n }\n\n useNavigate = (): UseNavigateResult => {\n const router = useRouter()\n return useNavigate({ from: router.routesById[this.options.id].fullPath })\n }\n}\n\n/**\n * Creates a lazily-configurable code-based route stub by ID.\n *\n * Use this for code-splitting with code-based routes. The returned function\n * accepts only non-critical route options like `component`, `pendingComponent`,\n * `errorComponent`, and `notFoundComponent` which are applied when the route\n * is matched.\n *\n * @param id Route ID string literal to associate with the lazy route.\n * @returns A function that accepts lazy route options and returns a `LazyRoute`.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createLazyRouteFunction\n */\nexport function createLazyRoute<\n TRouter extends AnyRouter = RegisteredRouter,\n TId extends string = string,\n TRoute extends AnyRoute = RouteById,\n>(id: ConstrainLiteral>) {\n return (opts: LazyRouteOptions) => {\n return new LazyRoute({\n id: id,\n ...opts,\n })\n }\n}\n\n/**\n * Creates a lazily-configurable file-based route stub by file path.\n *\n * Use this for code-splitting with file-based routes (eg. `.lazy.tsx` files).\n * The returned function accepts only non-critical route options like\n * `component`, `pendingComponent`, `errorComponent`, and `notFoundComponent`.\n *\n * @param id File path literal for the route file.\n * @returns A function that accepts lazy route options and returns a `LazyRoute`.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createLazyFileRouteFunction\n */\nexport function createLazyFileRoute<\n TFilePath extends keyof FileRoutesByPath,\n TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute'],\n>(id: TFilePath): (opts: LazyRouteOptions) => LazyRoute {\n if (typeof id === 'object') {\n return new LazyRoute(id) as any\n }\n\n return (opts: LazyRouteOptions) => new LazyRoute({ id, ...opts })\n}\n", "import * as React from 'react'\nimport { isModuleNotFoundError } from '@tanstack/router-core'\nimport { reactUse } from './utils'\nimport type { AsyncRouteComponent } from './route'\n\n/**\n * Wrap a dynamic import to create a route component that supports\n * `.preload()` and friendly reload-on-module-missing behavior.\n *\n * @param importer Function returning a module promise\n * @param exportName Named export to use (default: `default`)\n * @returns A lazy route component compatible with TanStack Router\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/lazyRouteComponentFunction\n */\nexport function lazyRouteComponent<\n T extends Record,\n TKey extends keyof T = 'default',\n>(\n importer: () => Promise,\n exportName?: TKey,\n): T[TKey] extends (props: infer TProps) => any\n ? AsyncRouteComponent\n : never {\n let loadPromise: Promise | undefined\n let comp: T[TKey] | T['default']\n let error: any\n let reload: boolean\n\n const load = () => {\n if (!loadPromise) {\n loadPromise = importer()\n .then((res) => {\n loadPromise = undefined\n comp = res[exportName ?? 'default']\n })\n .catch((err) => {\n // We don't want an error thrown from preload in this case, because\n // there's nothing we want to do about module not found during preload.\n // Record the error, the rest is handled during the render path.\n error = err\n // If the load fails due to module not found, it may mean a new version of\n // the build was deployed and the user's browser is still using an old version.\n // If this happens, the old version in the user's browser would have an outdated\n // URL to the lazy module.\n // In that case, we want to attempt one window refresh to get the latest.\n if (isModuleNotFoundError(error)) {\n if (\n error instanceof Error &&\n typeof window !== 'undefined' &&\n typeof sessionStorage !== 'undefined'\n ) {\n // Again, we want to reload one time on module not found error and not enter\n // a reload loop if there is some other issue besides an old deploy.\n // That's why we store our reload attempt in sessionStorage.\n // Use error.message as key because it contains the module path that failed.\n const storageKey = `tanstack_router_reload:${error.message}`\n if (!sessionStorage.getItem(storageKey)) {\n sessionStorage.setItem(storageKey, '1')\n reload = true\n }\n }\n }\n })\n }\n\n return loadPromise\n }\n\n const lazyComp = function Lazy(props: any) {\n // Now that we're out of preload and into actual render path,\n if (reload) {\n // If it was a module loading error,\n // throw eternal suspense while we wait for window to reload\n window.location.reload()\n throw new Promise(() => {})\n }\n if (error) {\n // Otherwise, just throw the error\n throw error\n }\n\n if (!comp) {\n if (reactUse) {\n reactUse(load())\n } else {\n throw load()\n }\n }\n\n return React.createElement(comp, props)\n }\n\n ;(lazyComp as any).preload = load\n\n return lazyComp as any\n}\n", "import * as React from 'react'\nimport {\n getLocationChangeInfo,\n handleHashScroll,\n trimPathRight,\n} from '@tanstack/router-core'\nimport { useLayoutEffect, usePrevious } from './utils'\nimport { useRouter } from './useRouter'\nimport { useRouterState } from './useRouterState'\n\nexport function Transitioner() {\n const router = useRouter()\n const mountLoadForRouter = React.useRef({ router, mounted: false })\n\n const [isTransitioning, setIsTransitioning] = React.useState(false)\n // Track pending state changes\n const { hasPendingMatches, isLoading } = useRouterState({\n select: (s) => ({\n isLoading: s.isLoading,\n hasPendingMatches: s.matches.some((d) => d.status === 'pending'),\n }),\n structuralSharing: true,\n })\n\n const previousIsLoading = usePrevious(isLoading)\n\n const isAnyPending = isLoading || isTransitioning || hasPendingMatches\n const previousIsAnyPending = usePrevious(isAnyPending)\n\n const isPagePending = isLoading || hasPendingMatches\n const previousIsPagePending = usePrevious(isPagePending)\n\n router.startTransition = (fn: () => void) => {\n setIsTransitioning(true)\n React.startTransition(() => {\n fn()\n setIsTransitioning(false)\n })\n }\n\n // Subscribe to location changes\n // and try to load the new location\n React.useEffect(() => {\n const unsub = router.history.subscribe(router.load)\n\n const nextLocation = router.buildLocation({\n to: router.latestLocation.pathname,\n search: true,\n params: true,\n hash: true,\n state: true,\n _includeValidateSearch: true,\n })\n\n // Check if the current URL matches the canonical form.\n // Compare publicHref (browser-facing URL) for consistency with\n // the server-side redirect check in router.beforeLoad.\n if (\n trimPathRight(router.latestLocation.publicHref) !==\n trimPathRight(nextLocation.publicHref)\n ) {\n router.commitLocation({ ...nextLocation, replace: true })\n }\n\n return () => {\n unsub()\n }\n }, [router, router.history])\n\n // Try to load the initial location\n useLayoutEffect(() => {\n if (\n // if we are hydrating from SSR, loading is triggered in ssr-client\n (typeof window !== 'undefined' && router.ssr) ||\n (mountLoadForRouter.current.router === router &&\n mountLoadForRouter.current.mounted)\n ) {\n return\n }\n mountLoadForRouter.current = { router, mounted: true }\n\n const tryLoad = async () => {\n try {\n await router.load()\n } catch (err) {\n console.error(err)\n }\n }\n\n tryLoad()\n }, [router])\n\n useLayoutEffect(() => {\n // The router was loading and now it's not\n if (previousIsLoading && !isLoading) {\n router.emit({\n type: 'onLoad', // When the new URL has committed, when the new matches have been loaded into state.matches\n ...getLocationChangeInfo(router.state),\n })\n }\n }, [previousIsLoading, router, isLoading])\n\n useLayoutEffect(() => {\n // emit onBeforeRouteMount\n if (previousIsPagePending && !isPagePending) {\n router.emit({\n type: 'onBeforeRouteMount',\n ...getLocationChangeInfo(router.state),\n })\n }\n }, [isPagePending, previousIsPagePending, router])\n\n useLayoutEffect(() => {\n if (previousIsAnyPending && !isAnyPending) {\n const changeInfo = getLocationChangeInfo(router.state)\n router.emit({\n type: 'onResolved',\n ...changeInfo,\n })\n\n router.__store.setState((s: typeof router.state) => ({\n ...s,\n status: 'idle',\n resolvedLocation: s.location,\n }))\n\n if (changeInfo.hrefChanged) {\n handleHashScroll(router)\n }\n }\n }, [isAnyPending, previousIsAnyPending, router])\n\n return null\n}\n", "import * as React from 'react'\nimport { isNotFound } from '@tanstack/router-core'\nimport { CatchBoundary } from './CatchBoundary'\nimport { useRouterState } from './useRouterState'\nimport type { ErrorInfo } from 'react'\nimport type { NotFoundError } from '@tanstack/router-core'\n\nexport function CatchNotFound(props: {\n fallback?: (error: NotFoundError) => React.ReactElement\n onCatch?: (error: Error, errorInfo: ErrorInfo) => void\n children: React.ReactNode\n}) {\n // TODO: Some way for the user to programmatically reset the not-found boundary?\n const resetKey = useRouterState({\n select: (s) => `not-found-${s.location.pathname}-${s.status}`,\n })\n\n return (\n resetKey}\n onCatch={(error, errorInfo) => {\n if (isNotFound(error)) {\n props.onCatch?.(error, errorInfo)\n } else {\n throw error\n }\n }}\n errorComponent={({ error }) => {\n if (isNotFound(error)) {\n return props.fallback?.(error)\n } else {\n throw error\n }\n }}\n >\n {props.children}\n \n )\n}\n\nexport function DefaultGlobalNotFound() {\n return

Not Found

\n}\n", "import * as React from 'react'\n\nexport function SafeFragment(props: any) {\n return <>{props.children}\n}\n", "import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { DefaultGlobalNotFound } from './not-found'\nimport type { AnyRoute, AnyRouter } from '@tanstack/router-core'\n\n/**\n * Renders a not found component for a route when no matching route is found.\n *\n * @param router - The router instance containing the route configuration\n * @param route - The route that triggered the not found state\n * @param data - Additional data to pass to the not found component\n * @returns The rendered not found component or a default fallback component\n */\nexport function renderRouteNotFound(\n router: AnyRouter,\n route: AnyRoute,\n data: any,\n) {\n if (!route.options.notFoundComponent) {\n if (router.options.defaultNotFoundComponent) {\n return \n }\n\n if (process.env.NODE_ENV === 'development') {\n warning(\n route.options.notFoundComponent,\n `A notFoundError was encountered on the route with ID \"${route.id}\", but a notFoundComponent option was not configured, nor was a router level defaultNotFoundComponent configured. Consider configuring at least one of these to avoid TanStack Router's overly generic defaultNotFoundComponent (

Not Found

)`,\n )\n }\n\n return \n }\n\n return \n}\n", "import { isServer } from '@tanstack/router-core/isServer'\nimport { useRouter } from './useRouter'\n\n/**\n * Server-only helper to emit a script tag exactly once during SSR.\n */\nexport function ScriptOnce({ children }: { children: string }) {\n const router = useRouter()\n if (!(isServer ?? router.isServer)) {\n return null\n }\n\n return (\n \n )\n}\n", "import {\n defaultGetScrollRestorationKey,\n escapeHtml,\n restoreScroll,\n storageKey,\n} from '@tanstack/router-core'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { useRouter } from './useRouter'\nimport { ScriptOnce } from './ScriptOnce'\n\nexport function ScrollRestoration() {\n const router = useRouter()\n if (!router.isScrollRestoring || !(isServer ?? router.isServer)) {\n return null\n }\n if (typeof router.options.scrollRestoration === 'function') {\n const shouldRestore = router.options.scrollRestoration({\n location: router.latestLocation,\n })\n if (!shouldRestore) {\n return null\n }\n }\n const getKey =\n router.options.getScrollRestorationKey || defaultGetScrollRestorationKey\n const userKey = getKey(router.latestLocation)\n const resolvedKey =\n userKey !== defaultGetScrollRestorationKey(router.latestLocation)\n ? userKey\n : undefined\n\n const restoreScrollOptions: Parameters[0] = {\n storageKey,\n shouldScrollRestoration: true,\n }\n if (resolvedKey) {\n restoreScrollOptions.key = resolvedKey\n }\n\n return (\n \n )\n}\n", "import * as React from 'react'\nimport invariant from 'tiny-invariant'\nimport warning from 'tiny-warning'\nimport {\n createControlledPromise,\n getLocationChangeInfo,\n isNotFound,\n isRedirect,\n rootRouteId,\n} from '@tanstack/router-core'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { CatchBoundary, ErrorComponent } from './CatchBoundary'\nimport { useRouterState } from './useRouterState'\nimport { useRouter } from './useRouter'\nimport { CatchNotFound } from './not-found'\nimport { matchContext } from './matchContext'\nimport { SafeFragment } from './SafeFragment'\nimport { renderRouteNotFound } from './renderRouteNotFound'\nimport { ScrollRestoration } from './scroll-restoration'\nimport { ClientOnly } from './ClientOnly'\nimport type {\n AnyRoute,\n ParsedLocation,\n RootRouteOptions,\n} from '@tanstack/router-core'\n\nexport const Match = React.memo(function MatchImpl({\n matchId,\n}: {\n matchId: string\n}) {\n const router = useRouter()\n const matchState = useRouterState({\n select: (s) => {\n const matchIndex = s.matches.findIndex((d) => d.id === matchId)\n const match = s.matches[matchIndex]\n invariant(\n match,\n `Could not find match for matchId \"${matchId}\". Please file an issue!`,\n )\n return {\n routeId: match.routeId,\n ssr: match.ssr,\n _displayPending: match._displayPending,\n resetKey: s.loadedAt,\n parentRouteId: s.matches[matchIndex - 1]?.routeId as string,\n }\n },\n structuralSharing: true as any,\n })\n\n const route: AnyRoute = router.routesById[matchState.routeId]\n\n const PendingComponent =\n route.options.pendingComponent ?? router.options.defaultPendingComponent\n\n const pendingElement = PendingComponent ? : null\n\n const routeErrorComponent =\n route.options.errorComponent ?? router.options.defaultErrorComponent\n\n const routeOnCatch = route.options.onCatch ?? router.options.defaultOnCatch\n\n const routeNotFoundComponent = route.isRoot\n ? // If it's the root route, use the globalNotFound option, with fallback to the notFoundRoute's component\n (route.options.notFoundComponent ??\n router.options.notFoundRoute?.options.component)\n : route.options.notFoundComponent\n\n const resolvedNoSsr =\n matchState.ssr === false || matchState.ssr === 'data-only'\n const ResolvedSuspenseBoundary =\n // If we're on the root route, allow forcefully wrapping in suspense\n (!route.isRoot || route.options.wrapInSuspense || resolvedNoSsr) &&\n (route.options.wrapInSuspense ??\n PendingComponent ??\n ((route.options.errorComponent as any)?.preload || resolvedNoSsr))\n ? React.Suspense\n : SafeFragment\n\n const ResolvedCatchBoundary = routeErrorComponent\n ? CatchBoundary\n : SafeFragment\n\n const ResolvedNotFoundBoundary = routeNotFoundComponent\n ? CatchNotFound\n : SafeFragment\n\n const ShellComponent = route.isRoot\n ? ((route.options as RootRouteOptions).shellComponent ?? SafeFragment)\n : SafeFragment\n return (\n \n \n \n matchState.resetKey}\n errorComponent={routeErrorComponent || ErrorComponent}\n onCatch={(error, errorInfo) => {\n // Forward not found errors (we don't want to show the error component for these)\n if (isNotFound(error)) throw error\n warning(false, `Error in route match: ${matchId}`)\n routeOnCatch?.(error, errorInfo)\n }}\n >\n {\n // If the current not found handler doesn't exist or it has a\n // route ID which doesn't match the current route, rethrow the error\n if (\n !routeNotFoundComponent ||\n (error.routeId && error.routeId !== matchState.routeId) ||\n (!error.routeId && !route.isRoot)\n )\n throw error\n\n return React.createElement(routeNotFoundComponent, error as any)\n }}\n >\n {resolvedNoSsr || matchState._displayPending ? (\n \n \n \n ) : (\n \n )}\n \n \n \n \n {matchState.parentRouteId === rootRouteId &&\n router.options.scrollRestoration ? (\n <>\n \n \n \n ) : null}\n \n )\n})\n\n// On Rendered can't happen above the root layout because it actually\n// renders a dummy dom element to track the rendered state of the app.\n// We render a script tag with a key that changes based on the current\n// location state.__TSR_key. Also, because it's below the root layout, it\n// allows us to fire onRendered events even after a hydration mismatch\n// error that occurred above the root layout (like bad head/link tags,\n// which is common).\nfunction OnRendered() {\n const router = useRouter()\n\n const prevLocationRef = React.useRef>(\n undefined,\n )\n\n return (\n {\n if (\n el &&\n (prevLocationRef.current === undefined ||\n prevLocationRef.current.href !== router.latestLocation.href)\n ) {\n router.emit({\n type: 'onRendered',\n ...getLocationChangeInfo(router.state),\n })\n prevLocationRef.current = router.latestLocation\n }\n }}\n />\n )\n}\n\nexport const MatchInner = React.memo(function MatchInnerImpl({\n matchId,\n}: {\n matchId: string\n}): any {\n const router = useRouter()\n\n const { match, key, routeId } = useRouterState({\n select: (s) => {\n const match = s.matches.find((d) => d.id === matchId)!\n const routeId = match.routeId as string\n\n const remountFn =\n (router.routesById[routeId] as AnyRoute).options.remountDeps ??\n router.options.defaultRemountDeps\n const remountDeps = remountFn?.({\n routeId,\n loaderDeps: match.loaderDeps,\n params: match._strictParams,\n search: match._strictSearch,\n })\n const key = remountDeps ? JSON.stringify(remountDeps) : undefined\n\n return {\n key,\n routeId,\n match: {\n id: match.id,\n status: match.status,\n error: match.error,\n invalid: match.invalid,\n _forcePending: match._forcePending,\n _displayPending: match._displayPending,\n },\n }\n },\n structuralSharing: true as any,\n })\n\n const route = router.routesById[routeId] as AnyRoute\n\n const out = React.useMemo(() => {\n const Comp = route.options.component ?? router.options.defaultComponent\n if (Comp) {\n return \n }\n return \n }, [key, route.options.component, router.options.defaultComponent])\n\n if (match._displayPending) {\n throw router.getMatch(match.id)?._nonReactive.displayPendingPromise\n }\n\n if (match._forcePending) {\n throw router.getMatch(match.id)?._nonReactive.minPendingPromise\n }\n\n // see also hydrate() in packages/router-core/src/ssr/ssr-client.ts\n if (match.status === 'pending') {\n // We're pending, and if we have a minPendingMs, we need to wait for it\n const pendingMinMs =\n route.options.pendingMinMs ?? router.options.defaultPendingMinMs\n if (pendingMinMs) {\n const routerMatch = router.getMatch(match.id)\n if (routerMatch && !routerMatch._nonReactive.minPendingPromise) {\n // Create a promise that will resolve after the minPendingMs\n if (!(isServer ?? router.isServer)) {\n const minPendingPromise = createControlledPromise()\n\n routerMatch._nonReactive.minPendingPromise = minPendingPromise\n\n setTimeout(() => {\n minPendingPromise.resolve()\n // We've handled the minPendingPromise, so we can delete it\n routerMatch._nonReactive.minPendingPromise = undefined\n }, pendingMinMs)\n }\n }\n }\n throw router.getMatch(match.id)?._nonReactive.loadPromise\n }\n\n if (match.status === 'notFound') {\n invariant(isNotFound(match.error), 'Expected a notFound error')\n return renderRouteNotFound(router, route, match.error)\n }\n\n if (match.status === 'redirected') {\n // Redirects should be handled by the router transition. If we happen to\n // encounter a redirect here, it's a bug. Let's warn, but render nothing.\n invariant(isRedirect(match.error), 'Expected a redirect error')\n\n // warning(\n // false,\n // 'Tried to render a redirected route match! This is a weird circumstance, please file an issue!',\n // )\n throw router.getMatch(match.id)?._nonReactive.loadPromise\n }\n\n if (match.status === 'error') {\n // If we're on the server, we need to use React's new and super\n // wonky api for throwing errors from a server side render inside\n // of a suspense boundary. This is the only way to get\n // renderToPipeableStream to not hang indefinitely.\n // We'll serialize the error and rethrow it on the client.\n if (isServer ?? router.isServer) {\n const RouteErrorComponent =\n (route.options.errorComponent ??\n router.options.defaultErrorComponent) ||\n ErrorComponent\n return (\n \n )\n }\n\n throw match.error\n }\n\n return out\n})\n\n/**\n * Render the next child match in the route tree. Typically used inside\n * a route component to render nested routes.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/outletComponent\n */\nexport const Outlet = React.memo(function OutletImpl() {\n const router = useRouter()\n const matchId = React.useContext(matchContext)\n const routeId = useRouterState({\n select: (s) => s.matches.find((d) => d.id === matchId)?.routeId as string,\n })\n\n const route = router.routesById[routeId]!\n\n const parentGlobalNotFound = useRouterState({\n select: (s) => {\n const matches = s.matches\n const parentMatch = matches.find((d) => d.id === matchId)\n invariant(\n parentMatch,\n `Could not find parent match for matchId \"${matchId}\"`,\n )\n return parentMatch.globalNotFound\n },\n })\n\n const childMatchId = useRouterState({\n select: (s) => {\n const matches = s.matches\n const index = matches.findIndex((d) => d.id === matchId)\n return matches[index + 1]?.id\n },\n })\n\n const pendingElement = router.options.defaultPendingComponent ? (\n \n ) : null\n\n if (parentGlobalNotFound) {\n return renderRouteNotFound(router, route, undefined)\n }\n\n if (!childMatchId) {\n return null\n }\n\n const nextMatch = \n\n if (routeId === rootRouteId) {\n return (\n {nextMatch}\n )\n }\n\n return nextMatch\n})\n", "import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { rootRouteId } from '@tanstack/router-core'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { CatchBoundary, ErrorComponent } from './CatchBoundary'\nimport { useRouterState } from './useRouterState'\nimport { useRouter } from './useRouter'\nimport { Transitioner } from './Transitioner'\nimport { matchContext } from './matchContext'\nimport { Match } from './Match'\nimport { SafeFragment } from './SafeFragment'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRoute,\n AnyRouter,\n DeepPartial,\n Expand,\n MakeOptionalPathParams,\n MakeOptionalSearchParams,\n MakeRouteMatchUnion,\n MaskOptions,\n MatchRouteOptions,\n NoInfer,\n RegisteredRouter,\n ResolveRelativePath,\n ResolveRoute,\n RouteByPath,\n RouterState,\n ToSubOptionsProps,\n} from '@tanstack/router-core'\n\ndeclare module '@tanstack/router-core' {\n export interface RouteMatchExtensions {\n meta?: Array\n links?: Array\n scripts?: Array\n styles?: Array\n headScripts?: Array\n }\n}\n\n/**\n * Internal component that renders the router's active match tree with\n * suspense, error, and not-found boundaries. Rendered by `RouterProvider`.\n */\nexport function Matches() {\n const router = useRouter()\n const rootRoute: AnyRoute = router.routesById[rootRouteId]\n\n const PendingComponent =\n rootRoute.options.pendingComponent ?? router.options.defaultPendingComponent\n\n const pendingElement = PendingComponent ? : null\n\n // Do not render a root Suspense during SSR or hydrating from SSR\n const ResolvedSuspense =\n (isServer ?? router.isServer) ||\n (typeof document !== 'undefined' && router.ssr)\n ? SafeFragment\n : React.Suspense\n\n const inner = (\n \n {!(isServer ?? router.isServer) && }\n \n \n )\n\n return router.options.InnerWrap ? (\n {inner}\n ) : (\n inner\n )\n}\n\nfunction MatchesInner() {\n const router = useRouter()\n const matchId = useRouterState({\n select: (s) => {\n return s.matches[0]?.id\n },\n })\n\n const resetKey = useRouterState({\n select: (s) => s.loadedAt,\n })\n\n const matchComponent = matchId ? : null\n\n return (\n \n {router.options.disableGlobalCatchBoundary ? (\n matchComponent\n ) : (\n resetKey}\n errorComponent={ErrorComponent}\n onCatch={\n process.env.NODE_ENV !== 'production'\n ? (error) => {\n warning(\n false,\n `The following error wasn't caught by any route! At the very least, consider setting an 'errorComponent' in your RootRoute!`,\n )\n warning(false, error.message || error.toString())\n }\n : undefined\n }\n >\n {matchComponent}\n \n )}\n \n )\n}\n\nexport type UseMatchRouteOptions<\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends string = string,\n TTo extends string | undefined = undefined,\n TMaskFrom extends string = TFrom,\n TMaskTo extends string = '',\n> = ToSubOptionsProps &\n DeepPartial> &\n DeepPartial> &\n MaskOptions &\n MatchRouteOptions\n\n/**\n * Create a matcher function for testing locations against route definitions.\n *\n * The returned function accepts standard navigation options (`to`, `params`,\n * `search`, etc.) and returns either `false` (no match) or the matched params\n * object when the route matches the current or pending location.\n *\n * Useful for conditional rendering and active UI states.\n *\n * @returns A `matchRoute(options)` function that returns `false` or params.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useMatchRouteHook\n */\nexport function useMatchRoute() {\n const router = useRouter()\n\n useRouterState({\n select: (s) => [s.location.href, s.resolvedLocation?.href, s.status],\n structuralSharing: true as any,\n })\n\n return React.useCallback(\n <\n const TFrom extends string = string,\n const TTo extends string | undefined = undefined,\n const TMaskFrom extends string = TFrom,\n const TMaskTo extends string = '',\n >(\n opts: UseMatchRouteOptions,\n ):\n | false\n | Expand['types']['allParams']> => {\n const { pending, caseSensitive, fuzzy, includeSearch, ...rest } = opts\n\n return router.matchRoute(rest as any, {\n pending,\n caseSensitive,\n fuzzy,\n includeSearch,\n })\n },\n [router],\n )\n}\n\nexport type MakeMatchRouteOptions<\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends string = string,\n TTo extends string | undefined = undefined,\n TMaskFrom extends string = TFrom,\n TMaskTo extends string = '',\n> = UseMatchRouteOptions & {\n // If a function is passed as a child, it will be given the `isActive` boolean to aid in further styling on the element it returns\n children?:\n | ((\n params?: RouteByPath<\n TRouter['routeTree'],\n ResolveRelativePath>\n >['types']['allParams'],\n ) => React.ReactNode)\n | React.ReactNode\n}\n\n/**\n * Component that conditionally renders its children based on whether a route\n * matches the provided `from`/`to` options. If `children` is a function, it\n * receives the matched params object.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/matchRouteComponent\n */\nexport function MatchRoute<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string = string,\n const TTo extends string | undefined = undefined,\n const TMaskFrom extends string = TFrom,\n const TMaskTo extends string = '',\n>(props: MakeMatchRouteOptions): any {\n const matchRoute = useMatchRoute()\n const params = matchRoute(props as any) as boolean\n\n if (typeof props.children === 'function') {\n return (props.children as any)(params)\n }\n\n return params ? props.children : null\n}\n\nexport interface UseMatchesBaseOptions<\n TRouter extends AnyRouter,\n TSelected,\n TStructuralSharing,\n> {\n select?: (\n matches: Array>,\n ) => ValidateSelected\n}\n\nexport type UseMatchesResult<\n TRouter extends AnyRouter,\n TSelected,\n> = unknown extends TSelected ? Array> : TSelected\n\nexport function useMatches<\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseMatchesBaseOptions &\n StructuralSharingOption,\n): UseMatchesResult {\n return useRouterState({\n select: (state: RouterState) => {\n const matches = state.matches\n return opts?.select\n ? opts.select(matches as Array>)\n : matches\n },\n structuralSharing: opts?.structuralSharing,\n } as any) as UseMatchesResult\n}\n\n/**\n * Read the full array of active route matches or select a derived subset.\n *\n * Useful for debugging, breadcrumbs, or aggregating metadata across matches.\n *\n * @returns The array of matches (or the selected value).\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useMatchesHook\n */\n\n/**\n * Read the full array of active route matches or select a derived subset.\n *\n * Useful for debugging, breadcrumbs, or aggregating metadata across matches.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useMatchesHook\n */\nexport function useParentMatches<\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseMatchesBaseOptions &\n StructuralSharingOption,\n): UseMatchesResult {\n const contextMatchId = React.useContext(matchContext)\n\n return useMatches({\n select: (matches: Array>) => {\n matches = matches.slice(\n 0,\n matches.findIndex((d) => d.id === contextMatchId),\n )\n return opts?.select ? opts.select(matches) : matches\n },\n structuralSharing: opts?.structuralSharing,\n } as any)\n}\n\n/**\n * Read the array of active route matches that are children of the current\n * match (or selected parent) in the match tree.\n */\nexport function useChildMatches<\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseMatchesBaseOptions &\n StructuralSharingOption,\n): UseMatchesResult {\n const contextMatchId = React.useContext(matchContext)\n\n return useMatches({\n select: (matches: Array>) => {\n matches = matches.slice(\n matches.findIndex((d) => d.id === contextMatchId) + 1,\n )\n return opts?.select ? opts.select(matches) : matches\n },\n structuralSharing: opts?.structuralSharing,\n } as any)\n}\n", "import { RouterCore } from '@tanstack/router-core'\nimport { createFileRoute, createLazyFileRoute } from './fileRoute'\nimport type { RouterHistory } from '@tanstack/history'\nimport type {\n AnyRoute,\n CreateRouterFn,\n RouterConstructorOptions,\n TrailingSlashOption,\n} from '@tanstack/router-core'\n\nimport type {\n ErrorRouteComponent,\n NotFoundRouteComponent,\n RouteComponent,\n} from './route'\n\ndeclare module '@tanstack/router-core' {\n export interface RouterOptionsExtensions {\n /**\n * The default `component` a route should use if no component is provided.\n *\n * @default Outlet\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultcomponent-property)\n */\n defaultComponent?: RouteComponent\n /**\n * The default `errorComponent` a route should use if no error component is provided.\n *\n * @default ErrorComponent\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaulterrorcomponent-property)\n * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#handling-errors-with-routeoptionserrorcomponent)\n */\n defaultErrorComponent?: ErrorRouteComponent\n /**\n * The default `pendingComponent` a route should use if no pending component is provided.\n *\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpendingcomponent-property)\n * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#showing-a-pending-component)\n */\n defaultPendingComponent?: RouteComponent\n /**\n * The default `notFoundComponent` a route should use if no notFound component is provided.\n *\n * @default NotFound\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultnotfoundcomponent-property)\n * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/not-found-errors#default-router-wide-not-found-handling)\n */\n defaultNotFoundComponent?: NotFoundRouteComponent\n /**\n * A component that will be used to wrap the entire router.\n *\n * This is useful for providing a context to the entire router.\n *\n * Only non-DOM-rendering components like providers should be used, anything else will cause a hydration error.\n *\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#wrap-property)\n */\n Wrap?: (props: { children: any }) => React.JSX.Element\n /**\n * A component that will be used to wrap the inner contents of the router.\n *\n * This is useful for providing a context to the inner contents of the router where you also need access to the router context and hooks.\n *\n * Only non-DOM-rendering components like providers should be used, anything else will cause a hydration error.\n *\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#innerwrap-property)\n */\n InnerWrap?: (props: { children: any }) => React.JSX.Element\n\n /**\n * The default `onCatch` handler for errors caught by the Router ErrorBoundary\n *\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultoncatch-property)\n * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#handling-errors-with-routeoptionsoncatch)\n */\n defaultOnCatch?: (error: Error, errorInfo: React.ErrorInfo) => void\n }\n}\n\n/**\n * Creates a new Router instance for React.\n *\n * Pass the returned router to `RouterProvider` to enable routing.\n * Notable options: `routeTree` (your route definitions) and `context`\n * (required if the root route was created with `createRootRouteWithContext`).\n *\n * @param options Router options used to configure the router.\n * @returns A Router instance to be provided to `RouterProvider`.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouterFunction\n */\nexport const createRouter: CreateRouterFn = (options) => {\n return new Router(options)\n}\n\nexport class Router<\n in out TRouteTree extends AnyRoute,\n in out TTrailingSlashOption extends TrailingSlashOption = 'never',\n in out TDefaultStructuralSharingOption extends boolean = false,\n in out TRouterHistory extends RouterHistory = RouterHistory,\n in out TDehydrated extends Record = Record,\n> extends RouterCore<\n TRouteTree,\n TTrailingSlashOption,\n TDefaultStructuralSharingOption,\n TRouterHistory,\n TDehydrated\n> {\n constructor(\n options: RouterConstructorOptions<\n TRouteTree,\n TTrailingSlashOption,\n TDefaultStructuralSharingOption,\n TRouterHistory,\n TDehydrated\n >,\n ) {\n super(options)\n }\n}\n\nif (typeof globalThis !== 'undefined') {\n ;(globalThis as any).createFileRoute = createFileRoute\n ;(globalThis as any).createLazyFileRoute = createLazyFileRoute\n} else if (typeof window !== 'undefined') {\n ;(window as any).createFileRoute = createFileRoute\n ;(window as any).createLazyFileRoute = createLazyFileRoute\n}\n", "import * as React from 'react'\nimport { Matches } from './Matches'\nimport { routerContext } from './routerContext'\nimport type {\n AnyRouter,\n RegisteredRouter,\n RouterOptions,\n} from '@tanstack/router-core'\n\n/**\n * Low-level provider that places the router into React context and optionally\n * updates router options from props. Most apps should use `RouterProvider`.\n */\nexport function RouterContextProvider<\n TRouter extends AnyRouter = RegisteredRouter,\n TDehydrated extends Record = Record,\n>({\n router,\n children,\n ...rest\n}: RouterProps & {\n children: React.ReactNode\n}) {\n if (Object.keys(rest).length > 0) {\n // Allow the router to update options on the router instance\n router.update({\n ...router.options,\n ...rest,\n context: {\n ...router.options.context,\n ...rest.context,\n },\n })\n }\n\n const provider = (\n \n {children}\n \n )\n\n if (router.options.Wrap) {\n return {provider}\n }\n\n return provider\n}\n\n/**\n * Top-level component that renders the active route matches and provides the\n * router to the React tree via context.\n *\n * Accepts the same options as `createRouter` via props to update the router\n * instance after creation.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouterFunction\n */\nexport function RouterProvider<\n TRouter extends AnyRouter = RegisteredRouter,\n TDehydrated extends Record = Record,\n>({ router, ...rest }: RouterProps) {\n return (\n \n \n \n )\n}\n\nexport type RouterProps<\n TRouter extends AnyRouter = RegisteredRouter,\n TDehydrated extends Record = Record,\n> = Omit<\n RouterOptions<\n TRouter['routeTree'],\n NonNullable,\n NonNullable,\n TRouter['history'],\n TDehydrated\n >,\n 'context'\n> & {\n router: TRouter\n context?: Partial<\n RouterOptions<\n TRouter['routeTree'],\n NonNullable,\n NonNullable,\n TRouter['history'],\n TDehydrated\n >['context']\n >\n}\n", "import {\n defaultGetScrollRestorationKey,\n getCssSelector,\n scrollRestorationCache,\n setupScrollRestoration,\n} from '@tanstack/router-core'\nimport { useRouter } from './useRouter'\nimport type {\n ParsedLocation,\n ScrollRestorationEntry,\n ScrollRestorationOptions,\n} from '@tanstack/router-core'\n\nfunction useScrollRestoration() {\n const router = useRouter()\n setupScrollRestoration(router, true)\n}\n\n/**\n * @deprecated Use the `scrollRestoration` router option instead.\n */\nexport function ScrollRestoration(_props: ScrollRestorationOptions) {\n useScrollRestoration()\n\n if (process.env.NODE_ENV === 'development') {\n console.warn(\n \"The ScrollRestoration component is deprecated. Use createRouter's `scrollRestoration` option instead.\",\n )\n }\n\n return null\n}\n\nexport function useElementScrollRestoration(\n options: (\n | {\n id: string\n getElement?: () => Window | Element | undefined | null\n }\n | {\n id?: string\n getElement: () => Window | Element | undefined | null\n }\n ) & {\n getKey?: (location: ParsedLocation) => string\n },\n): ScrollRestorationEntry | undefined {\n useScrollRestoration()\n\n const router = useRouter()\n const getKey = options.getKey || defaultGetScrollRestorationKey\n\n let elementSelector = ''\n\n if (options.id) {\n elementSelector = `[data-scroll-restoration-id=\"${options.id}\"]`\n } else {\n const element = options.getElement?.()\n if (!element) {\n return\n }\n elementSelector =\n element instanceof Window ? 'window' : getCssSelector(element)\n }\n\n const restoreKey = getKey(router.latestLocation)\n const byKey = scrollRestorationCache?.state[restoreKey]\n return byKey?.[elementSelector]\n}\n", "import * as React from 'react'\nimport { useRouter } from './useRouter'\nimport type {\n BlockerFnArgs,\n HistoryAction,\n HistoryLocation,\n} from '@tanstack/history'\nimport type {\n AnyRoute,\n AnyRouter,\n ParseRoute,\n RegisteredRouter,\n} from '@tanstack/router-core'\n\ninterface ShouldBlockFnLocation<\n out TRouteId,\n out TFullPath,\n out TAllParams,\n out TFullSearchSchema,\n> {\n routeId: TRouteId\n fullPath: TFullPath\n pathname: string\n params: TAllParams\n search: TFullSearchSchema\n}\n\ntype AnyShouldBlockFnLocation = ShouldBlockFnLocation\ntype MakeShouldBlockFnLocationUnion<\n TRouter extends AnyRouter = RegisteredRouter,\n TRoute extends AnyRoute = ParseRoute,\n> = TRoute extends any\n ? ShouldBlockFnLocation<\n TRoute['id'],\n TRoute['fullPath'],\n TRoute['types']['allParams'],\n TRoute['types']['fullSearchSchema']\n >\n : never\n\ntype BlockerResolver =\n | {\n status: 'blocked'\n current: MakeShouldBlockFnLocationUnion\n next: MakeShouldBlockFnLocationUnion\n action: HistoryAction\n proceed: () => void\n reset: () => void\n }\n | {\n status: 'idle'\n current: undefined\n next: undefined\n action: undefined\n proceed: undefined\n reset: undefined\n }\n\ntype ShouldBlockFnArgs = {\n current: MakeShouldBlockFnLocationUnion\n next: MakeShouldBlockFnLocationUnion\n action: HistoryAction\n}\n\nexport type ShouldBlockFn = (\n args: ShouldBlockFnArgs,\n) => boolean | Promise\nexport type UseBlockerOpts<\n TRouter extends AnyRouter = RegisteredRouter,\n TWithResolver extends boolean = boolean,\n> = {\n shouldBlockFn: ShouldBlockFn\n enableBeforeUnload?: boolean | (() => boolean)\n disabled?: boolean\n withResolver?: TWithResolver\n}\n\ntype LegacyBlockerFn = () => Promise | any\ntype LegacyBlockerOpts = {\n blockerFn?: LegacyBlockerFn\n condition?: boolean | any\n}\n\nfunction _resolveBlockerOpts(\n opts?: UseBlockerOpts | LegacyBlockerOpts | LegacyBlockerFn,\n condition?: boolean | any,\n): UseBlockerOpts {\n if (opts === undefined) {\n return {\n shouldBlockFn: () => true,\n withResolver: false,\n }\n }\n\n if ('shouldBlockFn' in opts) {\n return opts\n }\n\n if (typeof opts === 'function') {\n const shouldBlock = Boolean(condition ?? true)\n\n const _customBlockerFn = async () => {\n if (shouldBlock) return await opts()\n return false\n }\n\n return {\n shouldBlockFn: _customBlockerFn,\n enableBeforeUnload: shouldBlock,\n withResolver: false,\n }\n }\n\n const shouldBlock = Boolean(opts.condition ?? true)\n const fn = opts.blockerFn\n\n const _customBlockerFn = async () => {\n if (shouldBlock && fn !== undefined) {\n return await fn()\n }\n return shouldBlock\n }\n\n return {\n shouldBlockFn: _customBlockerFn,\n enableBeforeUnload: shouldBlock,\n withResolver: fn === undefined,\n }\n}\n\nexport function useBlocker<\n TRouter extends AnyRouter = RegisteredRouter,\n TWithResolver extends boolean = false,\n>(\n opts: UseBlockerOpts,\n): TWithResolver extends true ? BlockerResolver : void\n\n/**\n * @deprecated Use the shouldBlockFn property instead\n */\nexport function useBlocker(blockerFnOrOpts?: LegacyBlockerOpts): BlockerResolver\n\n/**\n * @deprecated Use the UseBlockerOpts object syntax instead\n */\nexport function useBlocker(\n blockerFn?: LegacyBlockerFn,\n condition?: boolean | any,\n): BlockerResolver\n\nexport function useBlocker(\n opts?: UseBlockerOpts | LegacyBlockerOpts | LegacyBlockerFn,\n condition?: boolean | any,\n): BlockerResolver | void {\n const {\n shouldBlockFn,\n enableBeforeUnload = true,\n disabled = false,\n withResolver = false,\n } = _resolveBlockerOpts(opts, condition)\n\n const router = useRouter()\n const { history } = router\n\n const [resolver, setResolver] = React.useState({\n status: 'idle',\n current: undefined,\n next: undefined,\n action: undefined,\n proceed: undefined,\n reset: undefined,\n })\n\n React.useEffect(() => {\n const blockerFnComposed = async (blockerFnArgs: BlockerFnArgs) => {\n function getLocation(\n location: HistoryLocation,\n ): AnyShouldBlockFnLocation {\n const parsedLocation = router.parseLocation(location)\n const matchedRoutes = router.getMatchedRoutes(parsedLocation.pathname)\n if (matchedRoutes.foundRoute === undefined) {\n return {\n routeId: '__notFound__',\n fullPath: parsedLocation.pathname,\n pathname: parsedLocation.pathname,\n params: matchedRoutes.routeParams,\n search: router.options.parseSearch(location.search),\n }\n }\n\n return {\n routeId: matchedRoutes.foundRoute.id,\n fullPath: matchedRoutes.foundRoute.fullPath,\n pathname: parsedLocation.pathname,\n params: matchedRoutes.routeParams,\n search: router.options.parseSearch(location.search),\n }\n }\n\n const current = getLocation(blockerFnArgs.currentLocation)\n const next = getLocation(blockerFnArgs.nextLocation)\n\n if (\n current.routeId === '__notFound__' &&\n next.routeId !== '__notFound__'\n ) {\n return false\n }\n\n const shouldBlock = await shouldBlockFn({\n action: blockerFnArgs.action,\n current,\n next,\n })\n if (!withResolver) {\n return shouldBlock\n }\n\n if (!shouldBlock) {\n return false\n }\n\n const promise = new Promise((resolve) => {\n setResolver({\n status: 'blocked',\n current,\n next,\n action: blockerFnArgs.action,\n proceed: () => resolve(false),\n reset: () => resolve(true),\n })\n })\n\n const canNavigateAsync = await promise\n setResolver({\n status: 'idle',\n current: undefined,\n next: undefined,\n action: undefined,\n proceed: undefined,\n reset: undefined,\n })\n\n return canNavigateAsync\n }\n\n return disabled\n ? undefined\n : history.block({ blockerFn: blockerFnComposed, enableBeforeUnload })\n }, [\n shouldBlockFn,\n enableBeforeUnload,\n disabled,\n withResolver,\n history,\n router,\n ])\n\n return resolver\n}\n\nconst _resolvePromptBlockerArgs = (\n props: PromptProps | LegacyPromptProps,\n): UseBlockerOpts => {\n if ('shouldBlockFn' in props) {\n return { ...props }\n }\n\n const shouldBlock = Boolean(props.condition ?? true)\n const fn = props.blockerFn\n\n const _customBlockerFn = async () => {\n if (shouldBlock && fn !== undefined) {\n return await fn()\n }\n return shouldBlock\n }\n\n return {\n shouldBlockFn: _customBlockerFn,\n enableBeforeUnload: shouldBlock,\n withResolver: fn === undefined,\n }\n}\n\nexport function Block<\n TRouter extends AnyRouter = RegisteredRouter,\n TWithResolver extends boolean = boolean,\n>(opts: PromptProps): React.ReactNode\n\n/**\n * @deprecated Use the UseBlockerOpts property instead\n */\nexport function Block(opts: LegacyPromptProps): React.ReactNode\n\nexport function Block(opts: PromptProps | LegacyPromptProps): React.ReactNode {\n const { children, ...rest } = opts\n const args = _resolvePromptBlockerArgs(rest)\n\n const resolver = useBlocker(args)\n return children\n ? typeof children === 'function'\n ? children(resolver as any)\n : children\n : null\n}\n\ntype LegacyPromptProps = {\n blockerFn?: LegacyBlockerFn\n condition?: boolean | any\n children?: React.ReactNode | ((params: BlockerResolver) => React.ReactNode)\n}\n\ntype PromptProps<\n TRouter extends AnyRouter = RegisteredRouter,\n TWithResolver extends boolean = boolean,\n TParams = TWithResolver extends true ? BlockerResolver : void,\n> = UseBlockerOpts & {\n children?: React.ReactNode | ((params: TParams) => React.ReactNode)\n}\n", "import { useRouterState } from './useRouterState'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n RegisteredRouter,\n RouterState,\n} from '@tanstack/router-core'\n\nexport interface UseLocationBaseOptions<\n TRouter extends AnyRouter,\n TSelected,\n TStructuralSharing extends boolean = boolean,\n> {\n select?: (\n state: RouterState['location'],\n ) => ValidateSelected\n}\n\nexport type UseLocationResult<\n TRouter extends AnyRouter,\n TSelected,\n> = unknown extends TSelected\n ? RouterState['location']\n : TSelected\n\n/**\n * Read the current location from the router state with optional selection.\n * Useful for subscribing to just the pieces of location you care about.\n *\n * Options:\n * - `select`: Project the `location` object to a derived value\n * - `structuralSharing`: Enable structural sharing for stable references\n *\n * @returns The current location (or selected value).\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useLocationHook\n */\nexport function useLocation<\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseLocationBaseOptions &\n StructuralSharingOption,\n): UseLocationResult {\n return useRouterState({\n select: (state: any) =>\n opts?.select ? opts.select(state.location) : state.location,\n } as any) as UseLocationResult\n}\n", "import { useRouterState } from './useRouterState'\n\nexport function useCanGoBack() {\n return useRouterState({ select: (s) => s.location.state.__TSR_index !== 0 })\n}\n", "import * as React from 'react'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { useRouter } from './useRouter'\nimport { useHydrated } from './ClientOnly'\nimport type { RouterManagedTag } from '@tanstack/router-core'\n\ninterface ScriptAttrs {\n [key: string]: string | boolean | undefined\n src?: string\n suppressHydrationWarning?: boolean\n}\n\nexport function Asset({\n tag,\n attrs,\n children,\n nonce,\n}: RouterManagedTag & { nonce?: string }): React.ReactElement | null {\n switch (tag) {\n case 'title':\n return (\n \n {children}\n \n )\n case 'meta':\n return \n case 'link':\n return \n case 'style':\n return (\n \n )\n case 'script':\n return \n default:\n return null\n }\n}\n\nfunction Script({\n attrs,\n children,\n}: {\n attrs?: ScriptAttrs\n children?: string\n}) {\n const router = useRouter()\n const hydrated = useHydrated()\n const dataScript =\n typeof attrs?.type === 'string' &&\n attrs.type !== '' &&\n attrs.type !== 'text/javascript' &&\n attrs.type !== 'module'\n\n if (\n process.env.NODE_ENV !== 'production' &&\n attrs?.src &&\n typeof children === 'string' &&\n children.trim().length\n ) {\n console.warn(\n '[TanStack Router] \" and \"\\\" to avoid invalid escapes in the output.\n// http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4\nexport function serializeString(str: string): string {\n let result = '';\n let lastPos = 0;\n let replacement: string | undefined;\n for (let i = 0, len = str.length; i < len; i++) {\n replacement = serializeChar(str[i]);\n if (replacement) {\n result += str.slice(lastPos, i) + replacement;\n lastPos = i + 1;\n }\n }\n if (lastPos === 0) {\n result = str;\n } else {\n result += str.slice(lastPos);\n }\n return result;\n}\n\nfunction deserializeReplacer(str: string): string {\n switch (str) {\n case '\\\\\\\\':\n return '\\\\';\n case '\\\\\"':\n return '\"';\n case '\\\\n':\n return '\\n';\n case '\\\\r':\n return '\\r';\n case '\\\\b':\n return '\\b';\n case '\\\\t':\n return '\\t';\n case '\\\\f':\n return '\\f';\n case '\\\\x3C':\n return '\\x3C';\n case '\\\\u2028':\n return '\\u2028';\n case '\\\\u2029':\n return '\\u2029';\n default:\n return str;\n }\n}\n\nexport function deserializeString(str: string): string {\n return str.replace(\n /(\\\\\\\\|\\\\\"|\\\\n|\\\\r|\\\\b|\\\\t|\\\\f|\\\\u2028|\\\\u2029|\\\\x3C)/g,\n deserializeReplacer,\n );\n}\n", "import { serializeString } from './string';\n\n// Used for mapping isomorphic references\nexport const REFERENCES_KEY = '__SEROVAL_REFS__';\n\nexport const GLOBAL_CONTEXT_REFERENCES = '$R';\n\nconst GLOBAL_CONTEXT_R = `self.${GLOBAL_CONTEXT_REFERENCES}`;\n\nexport function getCrossReferenceHeader(id?: string): string {\n if (id == null) {\n return `${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||[]`;\n }\n return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})[\"${serializeString(\n id,\n )}\"]=[]`;\n}\n", "import {\n SerovalMissingReferenceError,\n SerovalMissingReferenceForIdError,\n} from '..';\nimport { REFERENCES_KEY } from './keys';\n\nconst REFERENCE = new Map();\nconst INV_REFERENCE = new Map();\n\nexport function createReference(id: string, value: T): T {\n REFERENCE.set(value, id);\n INV_REFERENCE.set(id, value);\n return value;\n}\n\nexport function hasReferenceID(value: T): boolean {\n return REFERENCE.has(value);\n}\n\nexport function hasReference(id: string): boolean {\n return INV_REFERENCE.has(id);\n}\n\nexport function getReferenceID(value: T): string {\n if (hasReferenceID(value)) {\n return REFERENCE.get(value)!;\n }\n throw new SerovalMissingReferenceError(value);\n}\n\nexport function getReference(id: string): T {\n if (hasReference(id)) {\n return INV_REFERENCE.get(id) as T;\n }\n throw new SerovalMissingReferenceForIdError(id);\n}\n\nif (typeof globalThis !== 'undefined') {\n Object.defineProperty(globalThis, REFERENCES_KEY, {\n value: INV_REFERENCE,\n configurable: true,\n writable: false,\n enumerable: false,\n });\n} else if (typeof window !== 'undefined') {\n Object.defineProperty(window, REFERENCES_KEY, {\n value: INV_REFERENCE,\n configurable: true,\n writable: false,\n enumerable: false,\n });\n} else if (typeof self !== 'undefined') {\n Object.defineProperty(self, REFERENCES_KEY, {\n value: INV_REFERENCE,\n configurable: true,\n writable: false,\n enumerable: false,\n });\n} else if (typeof global !== 'undefined') {\n Object.defineProperty(global, REFERENCES_KEY, {\n value: INV_REFERENCE,\n configurable: true,\n writable: false,\n enumerable: false,\n });\n}\n", "import { Feature } from '../compat';\nimport { ERROR_CONSTRUCTOR_STRING, ErrorConstructorTag } from '../constants';\n\ntype ErrorValue =\n | Error\n | AggregateError\n | EvalError\n | RangeError\n | ReferenceError\n | TypeError\n | SyntaxError\n | URIError;\n\nexport function getErrorConstructor(error: ErrorValue): ErrorConstructorTag {\n if (error instanceof EvalError) {\n return ErrorConstructorTag.EvalError;\n }\n if (error instanceof RangeError) {\n return ErrorConstructorTag.RangeError;\n }\n if (error instanceof ReferenceError) {\n return ErrorConstructorTag.ReferenceError;\n }\n if (error instanceof SyntaxError) {\n return ErrorConstructorTag.SyntaxError;\n }\n if (error instanceof TypeError) {\n return ErrorConstructorTag.TypeError;\n }\n if (error instanceof URIError) {\n return ErrorConstructorTag.URIError;\n }\n return ErrorConstructorTag.Error;\n}\n\nfunction getInitialErrorOptions(\n error: Error,\n): Record | undefined {\n const construct = ERROR_CONSTRUCTOR_STRING[getErrorConstructor(error)];\n // Name has been modified\n if (error.name !== construct) {\n return { name: error.name };\n }\n if (error.constructor.name !== construct) {\n // Otherwise, name is overriden because\n // the Error class is extended\n return { name: error.constructor.name };\n }\n return {};\n}\n\nexport function getErrorOptions(\n error: Error,\n features: number,\n): Record | undefined {\n let options = getInitialErrorOptions(error);\n const names = Object.getOwnPropertyNames(error);\n for (let i = 0, len = names.length, name: string; i < len; i++) {\n name = names[i];\n if (name !== 'name' && name !== 'message') {\n if (name === 'stack') {\n if (features & Feature.ErrorPrototypeStack) {\n options = options || {};\n options[name] = error[name as keyof Error];\n }\n } else {\n options = options || {};\n options[name] = error[name as keyof Error];\n }\n }\n }\n return options;\n}\n", "import { SerovalObjectFlags } from '../constants';\n\nexport function getObjectFlag(obj: unknown): SerovalObjectFlags {\n if (Object.isFrozen(obj)) {\n return SerovalObjectFlags.Frozen;\n }\n if (Object.isSealed(obj)) {\n return SerovalObjectFlags.Sealed;\n }\n if (Object.isExtensible(obj)) {\n return SerovalObjectFlags.None;\n }\n return SerovalObjectFlags.NonExtensible;\n}\n", "import type { WellKnownSymbols } from './constants';\nimport { INV_SYMBOL_REF, NIL, SerovalNodeType } from './constants';\nimport {\n INFINITY_NODE,\n NAN_NODE,\n NEG_INFINITY_NODE,\n NEG_ZERO_NODE,\n} from './literals';\nimport { createSerovalNode } from './node';\nimport { getReferenceID } from './reference';\nimport { serializeString } from './string';\nimport type {\n SerovalAggregateErrorNode,\n SerovalArrayNode,\n SerovalAsyncIteratorFactoryInstanceNode,\n SerovalBigIntNode,\n SerovalBigIntTypedArrayNode,\n SerovalBoxedNode,\n SerovalConstantNode,\n SerovalDataViewNode,\n SerovalDateNode,\n SerovalErrorNode,\n SerovalIndexedValueNode,\n SerovalIteratorFactoryInstanceNode,\n SerovalNode,\n SerovalNodeWithID,\n SerovalNumberNode,\n SerovalObjectRecordNode,\n SerovalPluginNode,\n SerovalReferenceNode,\n SerovalRegExpNode,\n SerovalSequenceNode,\n SerovalSetNode,\n SerovalStreamConstructorNode,\n SerovalStreamNextNode,\n SerovalStreamReturnNode,\n SerovalStreamThrowNode,\n SerovalStringNode,\n SerovalTypedArrayNode,\n SerovalWKSymbolNode,\n} from './types';\nimport { getErrorConstructor } from './utils/error';\nimport { getObjectFlag } from './utils/get-object-flag';\nimport type {\n BigIntTypedArrayValue,\n TypedArrayValue,\n} from './utils/typed-array';\n\nexport function createNumberNode(\n value: number,\n): SerovalConstantNode | SerovalNumberNode {\n switch (value) {\n case Number.POSITIVE_INFINITY:\n return INFINITY_NODE;\n case Number.NEGATIVE_INFINITY:\n return NEG_INFINITY_NODE;\n }\n if (value !== value) {\n return NAN_NODE;\n }\n if (Object.is(value, -0)) {\n return NEG_ZERO_NODE;\n }\n return createSerovalNode(\n SerovalNodeType.Number,\n NIL,\n value,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createStringNode(value: string): SerovalStringNode {\n return createSerovalNode(\n SerovalNodeType.String,\n NIL,\n serializeString(value),\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createBigIntNode(current: bigint): SerovalBigIntNode {\n return createSerovalNode(\n SerovalNodeType.BigInt,\n NIL,\n '' + current,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createIndexedValueNode(id: number): SerovalIndexedValueNode {\n return createSerovalNode(\n SerovalNodeType.IndexedValue,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createDateNode(id: number, current: Date): SerovalDateNode {\n const timestamp = current.valueOf();\n return createSerovalNode(\n SerovalNodeType.Date,\n id,\n timestamp !== timestamp ? '' : current.toISOString(),\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createRegExpNode(\n id: number,\n current: RegExp,\n): SerovalRegExpNode {\n return createSerovalNode(\n SerovalNodeType.RegExp,\n id,\n NIL,\n serializeString(current.source),\n current.flags,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createWKSymbolNode(\n id: number,\n current: WellKnownSymbols,\n): SerovalWKSymbolNode {\n return createSerovalNode(\n SerovalNodeType.WKSymbol,\n id,\n INV_SYMBOL_REF[current],\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createReferenceNode(\n id: number,\n ref: T,\n): SerovalReferenceNode {\n return createSerovalNode(\n SerovalNodeType.Reference,\n id,\n serializeString(getReferenceID(ref)),\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createPluginNode(\n id: number,\n tag: string,\n value: Record,\n): SerovalPluginNode {\n return createSerovalNode(\n SerovalNodeType.Plugin,\n id,\n value,\n serializeString(tag),\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createArrayNode(\n id: number,\n current: unknown[],\n parsedItems: SerovalArrayNode['a'],\n): SerovalArrayNode {\n return createSerovalNode(\n SerovalNodeType.Array,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parsedItems,\n NIL,\n NIL,\n getObjectFlag(current),\n NIL,\n );\n}\n\nexport function createBoxedNode(\n id: number,\n boxed: SerovalNode,\n): SerovalBoxedNode {\n return createSerovalNode(\n SerovalNodeType.Boxed,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n boxed,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createTypedArrayNode(\n id: number,\n current: TypedArrayValue,\n buffer: SerovalNode,\n): SerovalTypedArrayNode {\n return createSerovalNode(\n SerovalNodeType.TypedArray,\n id,\n NIL,\n current.constructor.name,\n NIL,\n NIL,\n NIL,\n NIL,\n buffer,\n current.byteOffset,\n NIL,\n current.length,\n );\n}\n\nexport function createBigIntTypedArrayNode(\n id: number,\n current: BigIntTypedArrayValue,\n buffer: SerovalNode,\n): SerovalBigIntTypedArrayNode {\n return createSerovalNode(\n SerovalNodeType.BigIntTypedArray,\n id,\n NIL,\n current.constructor.name,\n NIL,\n NIL,\n NIL,\n NIL,\n buffer,\n current.byteOffset,\n NIL,\n current.byteLength,\n );\n}\n\nexport function createDataViewNode(\n id: number,\n current: DataView,\n buffer: SerovalNode,\n): SerovalDataViewNode {\n return createSerovalNode(\n SerovalNodeType.DataView,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n buffer,\n current.byteOffset,\n NIL,\n current.byteLength,\n );\n}\n\nexport function createErrorNode(\n id: number,\n current: Error,\n options: SerovalObjectRecordNode | undefined,\n): SerovalErrorNode {\n return createSerovalNode(\n SerovalNodeType.Error,\n id,\n getErrorConstructor(current),\n NIL,\n serializeString(current.message),\n options,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createAggregateErrorNode(\n id: number,\n current: AggregateError,\n options: SerovalObjectRecordNode | undefined,\n): SerovalAggregateErrorNode {\n return createSerovalNode(\n SerovalNodeType.AggregateError,\n id,\n getErrorConstructor(current),\n NIL,\n serializeString(current.message),\n options,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createSetNode(\n id: number,\n items: SerovalNode[],\n): SerovalSetNode {\n return createSerovalNode(\n SerovalNodeType.Set,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n items,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createIteratorFactoryInstanceNode(\n factory: SerovalNodeWithID,\n items: SerovalNodeWithID,\n): SerovalIteratorFactoryInstanceNode {\n return createSerovalNode(\n SerovalNodeType.IteratorFactoryInstance,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n [factory, items],\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createAsyncIteratorFactoryInstanceNode(\n factory: SerovalNodeWithID,\n items: SerovalNodeWithID,\n): SerovalAsyncIteratorFactoryInstanceNode {\n return createSerovalNode(\n SerovalNodeType.AsyncIteratorFactoryInstance,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n [factory, items],\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createStreamConstructorNode(\n id: number,\n factory: SerovalNodeWithID,\n sequence: SerovalNode[],\n): SerovalStreamConstructorNode {\n return createSerovalNode(\n SerovalNodeType.StreamConstructor,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n sequence,\n factory,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createStreamNextNode(\n id: number,\n parsed: SerovalNode,\n): SerovalStreamNextNode {\n return createSerovalNode(\n SerovalNodeType.StreamNext,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parsed,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createStreamThrowNode(\n id: number,\n parsed: SerovalNode,\n): SerovalStreamThrowNode {\n return createSerovalNode(\n SerovalNodeType.StreamThrow,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parsed,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createStreamReturnNode(\n id: number,\n parsed: SerovalNode,\n): SerovalStreamReturnNode {\n return createSerovalNode(\n SerovalNodeType.StreamReturn,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parsed,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createSequenceNode(\n id: number,\n sequence: SerovalNode[],\n throwAt: number,\n doneAt: number,\n): SerovalSequenceNode {\n return createSerovalNode(\n SerovalNodeType.Sequence,\n id,\n throwAt,\n NIL,\n NIL,\n NIL,\n NIL,\n sequence,\n NIL,\n NIL,\n NIL,\n doneAt,\n );\n}\n", "/// \n\nimport { serializeString } from './string';\nimport type { SerovalNode } from './types';\n\nconst { toString: objectToString } = /* @__PURE__ */ Object.prototype;\n\nconst enum StepErrorCodes {\n Parse = 1,\n Serialize = 2,\n Deserialize = 3,\n}\n\nfunction getErrorMessageDev(type: string, cause: unknown): string {\n if (cause instanceof Error) {\n return `Seroval caught an error during the ${type} process.\n\n${cause.name}\n${cause.message}\n\n- For more information, please check the \"cause\" property of this error.\n- If you believe this is an error in Seroval, please submit an issue at https://github.com/lxsmnsyc/seroval/issues/new`;\n }\n return `Seroval caught an error during the ${type} process.\n\n\"${objectToString.call(cause)}\"\n\nFor more information, please check the \"cause\" property of this error.`;\n}\n\nconst STEP_ERROR_CODES: Record = {\n parsing: StepErrorCodes.Parse,\n serialization: StepErrorCodes.Serialize,\n deserialization: StepErrorCodes.Deserialize,\n};\n\nfunction getErrorMessageProd(type: string): string {\n return `Seroval Error (step: ${STEP_ERROR_CODES[type]})`;\n}\n\nconst getErrorMessage = (type: string, cause: any) =>\n import.meta.env.PROD\n ? getErrorMessageProd(type)\n : getErrorMessageDev(type, cause);\n\nexport class SerovalError extends Error {\n constructor(\n type: string,\n public cause: unknown,\n ) {\n super(getErrorMessage(type, cause));\n }\n}\n\nexport class SerovalParserError extends SerovalError {\n constructor(cause: unknown) {\n super('parsing', cause);\n }\n}\n\nexport class SerovalSerializationError extends SerovalError {\n constructor(cause: unknown) {\n super('serialization', cause);\n }\n}\n\nexport class SerovalDeserializationError extends SerovalError {\n constructor(cause: unknown) {\n super('deserialization', cause);\n }\n}\n\nconst enum SpecificErrorCodes {\n UnsupportedType = 1,\n UnsupportedNode = 2,\n MissingPlugin = 3,\n MissingInstance = 4,\n MissingReference = 5,\n MissingReferenceForId = 6,\n UnknownTypedArray = 7,\n MalformedNode = 8,\n ConflictedNodeId = 9,\n DepthLimit = 10,\n}\n\nfunction getSpecificErrorMessage(code: SpecificErrorCodes): string {\n return `Seroval Error (specific: ${code})`;\n}\n\nexport class SerovalUnsupportedTypeError extends Error {\n constructor(public value: unknown) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.UnsupportedType)\n : `The value ${objectToString.call(value)} of type \"${typeof value}\" cannot be parsed/serialized.\n \nThere are few workarounds for this problem:\n- Transform the value in a way that it can be serialized.\n- If the reference is present on multiple runtimes (isomorphic), you can use the Reference API to map the references.`,\n );\n }\n}\n\nexport class SerovalUnsupportedNodeError extends Error {\n constructor(node: SerovalNode) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.UnsupportedNode)\n : 'Unsupported node type \"' + node.t + '\".',\n );\n }\n}\n\nexport class SerovalMissingPluginError extends Error {\n constructor(tag: string) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.MissingPlugin)\n : 'Missing plugin for tag \"' + tag + '\".',\n );\n }\n}\n\nexport class SerovalMissingInstanceError extends Error {\n constructor(tag: string) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.MissingInstance)\n : 'Missing \"' + tag + '\" instance.',\n );\n }\n}\n\nexport class SerovalMissingReferenceError extends Error {\n constructor(public value: unknown) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.MissingReference)\n : 'Missing reference for the value \"' +\n objectToString.call(value) +\n '\" of type \"' +\n typeof value +\n '\"',\n );\n }\n}\n\nexport class SerovalMissingReferenceForIdError extends Error {\n constructor(id: string) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.MissingReferenceForId)\n : 'Missing reference for id \"' + serializeString(id) + '\"',\n );\n }\n}\n\nexport class SerovalUnknownTypedArrayError extends Error {\n constructor(name: string) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.UnknownTypedArray)\n : 'Unknown TypedArray \"' + name + '\"',\n );\n }\n}\n\nexport class SerovalMalformedNodeError extends Error {\n constructor(node: SerovalNode) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.MalformedNode)\n : 'Malformed node type \"' + node.t + '\".',\n );\n }\n}\n\nexport class SerovalConflictedNodeIdError extends Error {\n constructor(node: SerovalNode) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.ConflictedNodeId)\n : 'Conflicted node id \"' + node.i + '\".',\n );\n }\n}\n\nexport class SerovalDepthLimitError extends Error {\n constructor(limit: number) {\n super(\n import.meta.env.PROD\n ? getSpecificErrorMessage(SpecificErrorCodes.ConflictedNodeId)\n : 'Depth limit of ' + limit + ' reached',\n );\n }\n}\n", "/**\n * An opaque reference allows hiding values from the serializer.\n */\nexport class OpaqueReference {\n constructor(\n public readonly value: V,\n public readonly replacement?: R,\n ) {}\n}\n", "import { Sequence } from './sequence';\nimport type { Stream } from './stream';\n\ntype SpecialPromise = Promise & { s?: 1 | 2; v?: unknown };\n\nexport interface PromiseConstructorResolver {\n p: SpecialPromise;\n s: (value: unknown) => void;\n f: (value: unknown) => void;\n}\n\nexport const PROMISE_CONSTRUCTOR = (): PromiseConstructorResolver => {\n const resolver = {\n p: 0,\n s: 0,\n f: 0,\n } as unknown as PromiseConstructorResolver;\n resolver.p = new Promise((resolve, reject) => {\n resolver.s = resolve;\n resolver.f = reject;\n });\n return resolver;\n};\n\nexport const PROMISE_SUCCESS = (\n resolver: PromiseConstructorResolver,\n data: unknown,\n): void => {\n resolver.s(data);\n resolver.p.s = 1;\n resolver.p.v = data;\n};\n\nexport const PROMISE_FAILURE = (\n resolver: PromiseConstructorResolver,\n data: unknown,\n): void => {\n resolver.f(data);\n resolver.p.s = 2;\n resolver.p.v = data;\n};\n\nexport const SERIALIZED_PROMISE_CONSTRUCTOR =\n /* @__PURE__ */ PROMISE_CONSTRUCTOR.toString();\nexport const SERIALIZED_PROMISE_SUCCESS =\n /* @__PURE__ */ PROMISE_SUCCESS.toString();\nexport const SERIALIZED_PROMISE_FAILURE =\n /* @__PURE__ */ PROMISE_FAILURE.toString();\n\ninterface StreamListener {\n next(value: T): void;\n throw(value: unknown): void;\n return(value: T): void;\n}\n\nexport const STREAM_CONSTRUCTOR = () => {\n const buffer: unknown[] = [];\n const listeners: StreamListener[] = [];\n let alive = true;\n let success = false;\n let count = 0;\n const flush = (\n value: unknown,\n mode: keyof StreamListener,\n x?: number,\n ) => {\n for (x = 0; x < count; x++) {\n if (listeners[x]) {\n listeners[x][mode](value);\n }\n }\n };\n const up = (\n listener: StreamListener,\n x?: number,\n z?: number,\n current?: unknown,\n ) => {\n for (x = 0, z = buffer.length; x < z; x++) {\n current = buffer[x];\n if (!alive && x === z - 1) {\n listener[success ? 'return' : 'throw'](current);\n } else {\n listener.next(current);\n }\n }\n };\n const on = (listener: StreamListener, temp?: number) => {\n if (alive) {\n temp = count++;\n listeners[temp] = listener;\n }\n up(listener);\n return () => {\n if (alive) {\n listeners[temp!] = listeners[count];\n listeners[count--] = undefined as any;\n }\n };\n };\n return {\n __SEROVAL_STREAM__: true,\n on: (listener: StreamListener) => on(listener),\n next: (value: unknown) => {\n if (alive) {\n buffer.push(value);\n flush(value, 'next');\n }\n },\n throw: (value: unknown) => {\n if (alive) {\n buffer.push(value);\n flush(value, 'throw');\n alive = false;\n success = false;\n listeners.length = 0;\n }\n },\n return: (value: unknown) => {\n if (alive) {\n buffer.push(value);\n flush(value, 'return');\n alive = false;\n success = true;\n listeners.length = 0;\n }\n },\n };\n};\n\nexport const SERIALIZED_STREAM_CONSTRUCTOR =\n /* @__PURE__ */ STREAM_CONSTRUCTOR.toString();\n\nexport const ITERATOR_CONSTRUCTOR =\n (symbol: symbol) => (sequence: Sequence) => () => {\n let index = 0;\n const instance = {\n [symbol]: () => instance,\n next: () => {\n if (index > sequence.d) {\n return {\n done: true,\n value: undefined,\n };\n }\n const currentIndex = index++;\n const data = sequence.v[currentIndex];\n if (currentIndex === sequence.t) {\n throw data;\n }\n return {\n done: currentIndex === sequence.d,\n value: data,\n };\n },\n };\n return instance;\n };\n\nexport const SERIALIZED_ITERATOR_CONSTRUCTOR =\n /* @__PURE__ */ ITERATOR_CONSTRUCTOR.toString();\n\nexport const ASYNC_ITERATOR_CONSTRUCTOR =\n (symbol: symbol, createPromise: typeof PROMISE_CONSTRUCTOR) =>\n (stream: Stream) =>\n () => {\n let count = 0;\n let doneAt = -1;\n let isThrow = false;\n const buffer: unknown[] = [];\n const pending: PromiseConstructorResolver[] = [];\n const finalize = (i = 0, len = pending.length) => {\n for (; i < len; i++) {\n pending[i].s({\n done: true,\n value: undefined,\n });\n }\n };\n stream.on({\n next: value => {\n const temp = pending.shift();\n if (temp) {\n temp.s({ done: false, value });\n }\n buffer.push(value);\n },\n throw: value => {\n const temp = pending.shift();\n if (temp) {\n temp.f(value);\n }\n finalize();\n doneAt = buffer.length;\n isThrow = true;\n buffer.push(value);\n },\n return: value => {\n const temp = pending.shift();\n if (temp) {\n temp.s({ done: true, value });\n }\n finalize();\n doneAt = buffer.length;\n buffer.push(value);\n },\n });\n\n const instance = {\n [symbol]: () => instance,\n next: () => {\n if (doneAt === -1) {\n const index = count++;\n if (index >= buffer.length) {\n const temp = createPromise();\n pending.push(temp);\n return temp.p;\n }\n return {\n done: false,\n value: buffer[index],\n };\n }\n if (count > doneAt) {\n return {\n done: true,\n value: undefined,\n };\n }\n const index = count++;\n const value = buffer[index];\n if (index !== doneAt) {\n return {\n done: false,\n value,\n };\n }\n if (isThrow) {\n throw value;\n }\n return {\n done: true,\n value,\n };\n },\n };\n\n return instance;\n };\n\nexport const SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR =\n /* @__PURE__ */ ASYNC_ITERATOR_CONSTRUCTOR.toString();\n\nexport const ARRAY_BUFFER_CONSTRUCTOR = (b64: string) => {\n const decoded = atob(b64);\n const length = decoded.length;\n const arr = new Uint8Array(length);\n for (let i = 0; i < length; i++) {\n arr[i] = decoded.charCodeAt(i);\n }\n return arr.buffer;\n};\n\nexport const SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR =\n /* @__PURE__ */ ARRAY_BUFFER_CONSTRUCTOR.toString();\n", "import { ITERATOR_CONSTRUCTOR } from \"./constructors\";\nimport { SYM_ITERATOR } from \"./symbols\";\n\nexport interface Sequence {\n __SEROVAL_SEQUENCE__: true;\n\n v: unknown[];\n t: number;\n d: number;\n}\n\nexport function isSequence(value: object): value is Sequence {\n return '__SEROVAL_SEQUENCE__' in value;\n}\n\nexport function createSequence(values: unknown[], throwAt: number, doneAt: number): Sequence {\n return {\n __SEROVAL_SEQUENCE__: true,\n\n v: values,\n t: throwAt,\n d: doneAt,\n };\n}\n\nexport function createSequenceFromIterable(source: Iterable): Sequence {\n const values: unknown[] = [];\n let throwsAt = -1;\n let doneAt = -1;\n const iterator = source[SYM_ITERATOR]();\n\n while (true) {\n try {\n const value = iterator.next();\n values.push(value.value);\n if (value.done) {\n doneAt = values.length - 1;\n break;\n }\n } catch (error) {\n throwsAt = values.length;\n values.push(error);\n }\n }\n\n return createSequence(values, throwsAt, doneAt);\n}\n\nconst createIterator = ITERATOR_CONSTRUCTOR(SYM_ITERATOR);\n\nexport function sequenceToIterator(\n sequence: Sequence,\n): () => IterableIterator {\n return createIterator(sequence) as unknown as () => IterableIterator;\n}\n", "import {\n SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,\n SERIALIZED_PROMISE_CONSTRUCTOR,\n SERIALIZED_PROMISE_FAILURE,\n SERIALIZED_PROMISE_SUCCESS,\n SERIALIZED_STREAM_CONSTRUCTOR,\n} from './constructors';\n\nexport const ITERATOR = {};\n\nexport const ASYNC_ITERATOR = {};\n\nexport const enum SpecialReference {\n MapSentinel = 0,\n PromiseConstructor = 1,\n PromiseSuccess = 2,\n PromiseFailure = 3,\n StreamConstructor = 4,\n ArrayBufferConstructor = 5,\n}\n\n/**\n * Placeholder references\n */\nexport const SPECIAL_REFS: Record = {\n [SpecialReference.MapSentinel]: {},\n [SpecialReference.PromiseConstructor]: {},\n [SpecialReference.PromiseSuccess]: {},\n [SpecialReference.PromiseFailure]: {},\n [SpecialReference.StreamConstructor]: {},\n [SpecialReference.ArrayBufferConstructor]: {},\n};\n\nexport const SPECIAL_REF_STRING: Record = {\n [SpecialReference.MapSentinel]: '[]',\n [SpecialReference.PromiseConstructor]: SERIALIZED_PROMISE_CONSTRUCTOR,\n [SpecialReference.PromiseSuccess]: SERIALIZED_PROMISE_SUCCESS,\n [SpecialReference.PromiseFailure]: SERIALIZED_PROMISE_FAILURE,\n [SpecialReference.StreamConstructor]: SERIALIZED_STREAM_CONSTRUCTOR,\n [SpecialReference.ArrayBufferConstructor]:\n SERIALIZED_ARRAY_BUFFER_CONSTRUCTOR,\n};\n", "import {\n ASYNC_ITERATOR_CONSTRUCTOR,\n PROMISE_CONSTRUCTOR,\n STREAM_CONSTRUCTOR,\n} from './constructors';\nimport { SYM_ASYNC_ITERATOR } from './symbols';\n\nexport interface StreamListener {\n next(value: T): void;\n throw(value: unknown): void;\n return(value: T): void;\n}\n\nexport interface Stream {\n __SEROVAL_STREAM__: true;\n\n on(listener: StreamListener): () => void;\n\n next(value: T): void;\n throw(value: unknown): void;\n return(value: T): void;\n}\n\nexport function isStream(value: object): value is Stream {\n return '__SEROVAL_STREAM__' in value;\n}\n\nexport function createStream(): Stream {\n return STREAM_CONSTRUCTOR() as unknown as Stream;\n}\n\nexport function createStreamFromAsyncIterable(\n iterable: AsyncIterable,\n): Stream {\n const stream = createStream();\n\n const iterator = iterable[SYM_ASYNC_ITERATOR]();\n\n async function push(): Promise {\n try {\n const value = await iterator.next();\n if (value.done) {\n stream.return(value.value as T);\n } else {\n stream.next(value.value);\n await push();\n }\n } catch (error) {\n stream.throw(error);\n }\n }\n\n push().catch(() => {\n // no-op\n });\n\n return stream;\n}\n\nconst createAsyncIterable = ASYNC_ITERATOR_CONSTRUCTOR(\n SYM_ASYNC_ITERATOR,\n PROMISE_CONSTRUCTOR,\n);\n\nexport function streamToAsyncIterable(\n stream: Stream,\n): () => AsyncIterableIterator {\n return createAsyncIterable(\n stream,\n ) as unknown as () => AsyncIterableIterator;\n}\n", "export default async function promiseToResult(\n current: Promise,\n): Promise<[0 | 1, unknown]> {\n try {\n return [1, await current];\n } catch (e) {\n return [0, e];\n }\n}\n", "import {\n createIndexedValueNode,\n createReferenceNode,\n createWKSymbolNode,\n} from '../base-primitives';\nimport { ALL_ENABLED } from '../compat';\nimport type { WellKnownSymbols } from '../constants';\nimport { INV_SYMBOL_REF, NIL, SerovalNodeType } from '../constants';\nimport { SerovalUnsupportedTypeError } from '../errors';\nimport { createSerovalNode } from '../node';\nimport type { PluginAccessOptions, SerovalMode } from '../plugin';\nimport { hasReferenceID } from '../reference';\nimport {\n ASYNC_ITERATOR,\n ITERATOR,\n SPECIAL_REFS,\n SpecialReference,\n} from '../special-reference';\nimport { serializeString } from '../string';\nimport { SYM_ASYNC_ITERATOR, SYM_ITERATOR } from '../symbols';\nimport type {\n SerovalArrayBufferNode,\n SerovalAsyncIteratorFactoryNode,\n SerovalIndexedValueNode,\n SerovalIteratorFactoryNode,\n SerovalMapNode,\n SerovalNode,\n SerovalNullConstructorNode,\n SerovalObjectNode,\n SerovalObjectRecordNode,\n SerovalPromiseConstructorNode,\n SerovalReferenceNode,\n SerovalSpecialReferenceNode,\n SerovalWKSymbolNode,\n} from '../types';\nimport { getObjectFlag } from '../utils/get-object-flag';\n\nexport interface BaseParserContextOptions extends PluginAccessOptions {\n disabledFeatures?: number;\n refs?: Map;\n depthLimit?: number;\n}\n\nexport const enum ParserNodeType {\n Fresh = 0,\n Indexed = 1,\n Referenced = 2,\n}\n\nexport interface FreshNode {\n type: ParserNodeType.Fresh;\n value: number;\n}\n\nexport interface IndexedNode {\n type: ParserNodeType.Indexed;\n value: SerovalIndexedValueNode;\n}\n\nexport interface ReferencedNode {\n type: ParserNodeType.Referenced;\n value: SerovalReferenceNode;\n}\n\ntype ObjectNode = FreshNode | IndexedNode | ReferencedNode;\n\nexport interface BaseParserContext extends PluginAccessOptions {\n readonly mode: SerovalMode;\n\n marked: Set;\n\n refs: Map;\n\n features: number;\n\n depthLimit: number;\n}\n\nexport function createBaseParserContext(\n mode: SerovalMode,\n options: BaseParserContextOptions,\n): BaseParserContext {\n return {\n plugins: options.plugins,\n mode,\n marked: new Set(),\n features: ALL_ENABLED ^ (options.disabledFeatures || 0),\n refs: options.refs || new Map(),\n depthLimit: options.depthLimit || 1000,\n };\n}\n\n/**\n * Ensures that the value (based on an identifier) has been visited by the parser.\n * @param ctx\n * @param id\n */\nexport function markParserRef(ctx: BaseParserContext, id: number): void {\n ctx.marked.add(id);\n}\n\nexport function isParserRefMarked(ctx: BaseParserContext, id: number): boolean {\n return ctx.marked.has(id);\n}\n\n/**\n * Creates an identifier for a value\n * @param ctx\n * @param current\n */\nexport function createIndexForValue(\n ctx: BaseParserContext,\n current: T,\n): number {\n const id = ctx.refs.size;\n ctx.refs.set(current, id);\n return id;\n}\n\nexport function getNodeForIndexedValue(\n ctx: BaseParserContext,\n current: T,\n): FreshNode | IndexedNode {\n const registeredId = ctx.refs.get(current);\n if (registeredId != null) {\n markParserRef(ctx, registeredId);\n return {\n type: ParserNodeType.Indexed,\n value: createIndexedValueNode(registeredId),\n };\n }\n return {\n type: ParserNodeType.Fresh,\n value: createIndexForValue(ctx, current),\n };\n}\n\nexport function getReferenceNode(\n ctx: BaseParserContext,\n current: T,\n): ObjectNode {\n const indexed = getNodeForIndexedValue(ctx, current);\n if (indexed.type === ParserNodeType.Indexed) {\n return indexed;\n }\n // Special references are special ;)\n if (hasReferenceID(current)) {\n return {\n type: ParserNodeType.Referenced,\n value: createReferenceNode(indexed.value, current),\n };\n }\n return indexed;\n}\n\n/**\n * Parsing methods\n */\nexport function parseWellKnownSymbol(\n ctx: BaseParserContext,\n current: symbol,\n): SerovalIndexedValueNode | SerovalWKSymbolNode | SerovalReferenceNode {\n const ref = getReferenceNode(ctx, current);\n if (ref.type !== ParserNodeType.Fresh) {\n return ref.value;\n }\n if (current in INV_SYMBOL_REF) {\n return createWKSymbolNode(ref.value, current as WellKnownSymbols);\n }\n throw new SerovalUnsupportedTypeError(current);\n}\n\nexport function parseSpecialReference(\n ctx: BaseParserContext,\n ref: SpecialReference,\n): SerovalIndexedValueNode | SerovalSpecialReferenceNode {\n const result = getNodeForIndexedValue(ctx, SPECIAL_REFS[ref]);\n if (result.type === ParserNodeType.Indexed) {\n return result.value;\n }\n return createSerovalNode(\n SerovalNodeType.SpecialReference,\n result.value,\n ref,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function parseIteratorFactory(\n ctx: BaseParserContext,\n): SerovalIndexedValueNode | SerovalIteratorFactoryNode {\n const result = getNodeForIndexedValue(ctx, ITERATOR);\n if (result.type === ParserNodeType.Indexed) {\n return result.value;\n }\n return createSerovalNode(\n SerovalNodeType.IteratorFactory,\n result.value,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parseWellKnownSymbol(ctx, SYM_ITERATOR),\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function parseAsyncIteratorFactory(\n ctx: BaseParserContext,\n): SerovalIndexedValueNode | SerovalAsyncIteratorFactoryNode {\n const result = getNodeForIndexedValue(ctx, ASYNC_ITERATOR);\n if (result.type === ParserNodeType.Indexed) {\n return result.value;\n }\n return createSerovalNode(\n SerovalNodeType.AsyncIteratorFactory,\n result.value,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n [\n parseSpecialReference(ctx, SpecialReference.PromiseConstructor),\n parseWellKnownSymbol(ctx, SYM_ASYNC_ITERATOR),\n ],\n NIL,\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createObjectNode(\n id: number,\n current: Record,\n empty: boolean,\n record: SerovalObjectRecordNode,\n): SerovalObjectNode | SerovalNullConstructorNode {\n return createSerovalNode(\n empty ? SerovalNodeType.NullConstructor : SerovalNodeType.Object,\n id,\n NIL,\n NIL,\n NIL,\n record,\n NIL,\n NIL,\n NIL,\n NIL,\n getObjectFlag(current),\n NIL,\n );\n}\n\nexport function createMapNode(\n ctx: BaseParserContext,\n id: number,\n k: SerovalNode[],\n v: SerovalNode[],\n): SerovalMapNode {\n return createSerovalNode(\n SerovalNodeType.Map,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n { k, v },\n NIL,\n parseSpecialReference(ctx, SpecialReference.MapSentinel),\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createPromiseConstructorNode(\n ctx: BaseParserContext,\n id: number,\n resolver: number,\n): SerovalPromiseConstructorNode {\n return createSerovalNode(\n SerovalNodeType.PromiseConstructor,\n id,\n resolver,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parseSpecialReference(ctx, SpecialReference.PromiseConstructor),\n NIL,\n NIL,\n NIL,\n );\n}\n\nexport function createArrayBufferNode(\n ctx: BaseParserContext,\n id: number,\n current: ArrayBuffer,\n): SerovalArrayBufferNode {\n const bytes = new Uint8Array(current);\n let result = '';\n for (let i = 0, len = bytes.length; i < len; i++) {\n result += String.fromCharCode(bytes[i]);\n }\n return createSerovalNode(\n SerovalNodeType.ArrayBuffer,\n id,\n serializeString(btoa(result)),\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n parseSpecialReference(ctx, SpecialReference.ArrayBufferConstructor),\n NIL,\n NIL,\n NIL,\n );\n}\n", "import {\n createAggregateErrorNode,\n createArrayNode,\n createAsyncIteratorFactoryInstanceNode,\n createBigIntNode,\n createBigIntTypedArrayNode,\n createBoxedNode,\n createDataViewNode,\n createDateNode,\n createErrorNode,\n createIteratorFactoryInstanceNode,\n createNumberNode,\n createPluginNode,\n createRegExpNode,\n createSequenceNode,\n createSetNode,\n createStreamConstructorNode,\n createStreamNextNode,\n createStreamReturnNode,\n createStreamThrowNode,\n createStringNode,\n createTypedArrayNode,\n} from '../base-primitives';\nimport { Feature } from '../compat';\nimport { NIL, SerovalNodeType } from '../constants';\nimport { SerovalParserError, SerovalUnsupportedTypeError } from '../errors';\nimport { FALSE_NODE, NULL_NODE, TRUE_NODE, UNDEFINED_NODE } from '../literals';\nimport { createSerovalNode } from '../node';\nimport { OpaqueReference } from '../opaque-reference';\nimport type { SerovalMode } from '../plugin';\nimport {\n createSequenceFromIterable,\n isSequence,\n type Sequence,\n} from '../sequence';\nimport { SpecialReference } from '../special-reference';\nimport type { Stream } from '../stream';\nimport { createStreamFromAsyncIterable, isStream } from '../stream';\nimport { serializeString } from '../string';\nimport {\n SYM_ASYNC_ITERATOR,\n SYM_IS_CONCAT_SPREADABLE,\n SYM_ITERATOR,\n SYM_TO_STRING_TAG,\n} from '../symbols';\nimport type {\n SerovalAggregateErrorNode,\n SerovalArrayNode,\n SerovalBigIntTypedArrayNode,\n SerovalBoxedNode,\n SerovalDataViewNode,\n SerovalErrorNode,\n SerovalMapNode,\n SerovalNode,\n SerovalNodeWithID,\n SerovalNullConstructorNode,\n SerovalObjectNode,\n SerovalObjectRecordKey,\n SerovalObjectRecordNode,\n SerovalPluginNode,\n SerovalPromiseNode,\n SerovalSequenceNode,\n SerovalSetNode,\n SerovalStreamConstructorNode,\n SerovalTypedArrayNode,\n} from '../types';\nimport { getErrorOptions } from '../utils/error';\nimport promiseToResult from '../utils/promise-to-result';\nimport type {\n BigIntTypedArrayValue,\n TypedArrayValue,\n} from '../utils/typed-array';\nimport type { BaseParserContext, BaseParserContextOptions } from './parser';\nimport {\n createArrayBufferNode,\n createBaseParserContext,\n createMapNode,\n createObjectNode,\n getReferenceNode,\n markParserRef,\n parseAsyncIteratorFactory,\n parseIteratorFactory,\n ParserNodeType,\n parseSpecialReference,\n parseWellKnownSymbol,\n} from './parser';\n\ntype ObjectLikeNode =\n | SerovalObjectNode\n | SerovalNullConstructorNode\n | SerovalPromiseNode;\n\nexport type AsyncParserContextOptions = BaseParserContextOptions;\n\nexport interface AsyncParserContext {\n base: BaseParserContext;\n child: AsyncParsePluginContext | undefined;\n}\n\nexport function createAsyncParserContext(\n mode: SerovalMode,\n options: AsyncParserContextOptions,\n): AsyncParserContext {\n return {\n base: createBaseParserContext(mode, options),\n child: undefined,\n };\n}\n\nexport class AsyncParsePluginContext {\n constructor(\n private _p: AsyncParserContext,\n private depth: number,\n ) {}\n\n parse(current: T): Promise {\n return parseAsync(this._p, this.depth, current);\n }\n}\n\nasync function parseItems(\n ctx: AsyncParserContext,\n depth: number,\n current: unknown[],\n): Promise<(SerovalNode | 0)[]> {\n const nodes: (SerovalNode | 0)[] = [];\n for (let i = 0, len = current.length; i < len; i++) {\n // For consistency in holes\n if (i in current) {\n nodes[i] = await parseAsync(ctx, depth, current[i]);\n } else {\n nodes[i] = 0;\n }\n }\n return nodes;\n}\n\nasync function parseArray(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: unknown[],\n): Promise {\n return createArrayNode(id, current, await parseItems(ctx, depth, current));\n}\n\nasync function parseProperties(\n ctx: AsyncParserContext,\n depth: number,\n properties: Record,\n): Promise {\n const entries = Object.entries(properties);\n const keyNodes: SerovalObjectRecordKey[] = [];\n const valueNodes: SerovalNode[] = [];\n for (let i = 0, len = entries.length; i < len; i++) {\n keyNodes.push(serializeString(entries[i][0]));\n valueNodes.push(await parseAsync(ctx, depth, entries[i][1]));\n }\n // Check special properties\n if (SYM_ITERATOR in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));\n valueNodes.push(\n createIteratorFactoryInstanceNode(\n parseIteratorFactory(ctx.base),\n (await parseAsync(\n ctx,\n depth,\n createSequenceFromIterable(\n properties as unknown as Iterable,\n ),\n )) as SerovalNodeWithID,\n ),\n );\n }\n if (SYM_ASYNC_ITERATOR in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ASYNC_ITERATOR));\n valueNodes.push(\n createAsyncIteratorFactoryInstanceNode(\n parseAsyncIteratorFactory(ctx.base),\n (await parseAsync(\n ctx,\n depth,\n createStreamFromAsyncIterable(\n properties as unknown as AsyncIterable,\n ),\n )) as SerovalNodeWithID,\n ),\n );\n }\n if (SYM_TO_STRING_TAG in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_TO_STRING_TAG));\n valueNodes.push(createStringNode(properties[SYM_TO_STRING_TAG] as string));\n }\n if (SYM_IS_CONCAT_SPREADABLE in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_IS_CONCAT_SPREADABLE));\n valueNodes.push(\n properties[SYM_IS_CONCAT_SPREADABLE] ? TRUE_NODE : FALSE_NODE,\n );\n }\n return {\n k: keyNodes,\n v: valueNodes,\n };\n}\n\nasync function parsePlainObject(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Record,\n empty: boolean,\n): Promise {\n return createObjectNode(\n id,\n current,\n empty,\n await parseProperties(ctx, depth, current),\n );\n}\n\n// TODO: check if parseBoxedSync can be used\nasync function parseBoxed(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: object,\n): Promise {\n return createBoxedNode(id, await parseAsync(ctx, depth, current.valueOf()));\n}\n\nasync function parseTypedArray(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: TypedArrayValue,\n): Promise {\n return createTypedArrayNode(\n id,\n current,\n await parseAsync(ctx, depth, current.buffer),\n );\n}\n\nasync function parseBigIntTypedArray(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: BigIntTypedArrayValue,\n): Promise {\n return createBigIntTypedArrayNode(\n id,\n current,\n await parseAsync(ctx, depth, current.buffer),\n );\n}\n\nasync function parseDataView(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: DataView,\n): Promise {\n return createDataViewNode(\n id,\n current,\n await parseAsync(ctx, depth, current.buffer),\n );\n}\n\nasync function parseError(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Error,\n): Promise {\n const options = getErrorOptions(current, ctx.base.features);\n return createErrorNode(\n id,\n current,\n options ? await parseProperties(ctx, depth, options) : NIL,\n );\n}\n\nasync function parseAggregateError(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: AggregateError,\n): Promise {\n const options = getErrorOptions(current, ctx.base.features);\n return createAggregateErrorNode(\n id,\n current,\n options ? await parseProperties(ctx, depth, options) : NIL,\n );\n}\n\nasync function parseMap(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Map,\n): Promise {\n const keyNodes: SerovalNode[] = [];\n const valueNodes: SerovalNode[] = [];\n for (const [key, value] of current.entries()) {\n keyNodes.push(await parseAsync(ctx, depth, key));\n valueNodes.push(await parseAsync(ctx, depth, value));\n }\n return createMapNode(ctx.base, id, keyNodes, valueNodes);\n}\n\nasync function parseSet(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Set,\n): Promise {\n const items: SerovalNode[] = [];\n for (const item of current.keys()) {\n items.push(await parseAsync(ctx, depth, item));\n }\n return createSetNode(id, items);\n}\n\nasync function parsePlugin(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: unknown,\n): Promise {\n const currentPlugins = ctx.base.plugins;\n if (currentPlugins) {\n for (let i = 0, len = currentPlugins.length; i < len; i++) {\n const plugin = currentPlugins[i];\n if (plugin.parse.async && plugin.test(current)) {\n return createPluginNode(\n id,\n plugin.tag,\n await plugin.parse.async(\n current,\n new AsyncParsePluginContext(ctx, depth),\n {\n id,\n },\n ),\n );\n }\n }\n }\n return NIL;\n}\n\nasync function parsePromise(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Promise,\n): Promise {\n const [status, result] = await promiseToResult(current);\n\n return createSerovalNode(\n SerovalNodeType.Promise,\n id,\n status,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n await parseAsync(ctx, depth, result),\n NIL,\n NIL,\n NIL,\n );\n}\n\nfunction parseStreamHandle(\n this: AsyncParserContext,\n depth: number,\n id: number,\n current: Stream,\n resolve: (value: SerovalNode[] | PromiseLike) => void,\n reject: (reason?: any) => void,\n): void {\n const sequence: SerovalNode[] = [];\n // TODO Optimizable\n const cleanup = current.on({\n next: value => {\n markParserRef(this.base, id);\n parseAsync(this, depth, value).then(\n data => {\n sequence.push(createStreamNextNode(id, data));\n },\n data => {\n reject(data);\n cleanup();\n },\n );\n },\n throw: value => {\n markParserRef(this.base, id);\n parseAsync(this, depth, value).then(\n data => {\n sequence.push(createStreamThrowNode(id, data));\n resolve(sequence);\n cleanup();\n },\n data => {\n reject(data);\n cleanup();\n },\n );\n },\n return: value => {\n markParserRef(this.base, id);\n parseAsync(this, depth, value).then(\n data => {\n sequence.push(createStreamReturnNode(id, data));\n resolve(sequence);\n cleanup();\n },\n data => {\n reject(data);\n cleanup();\n },\n );\n },\n });\n}\n\nasync function parseStream(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Stream,\n): Promise {\n return createStreamConstructorNode(\n id,\n parseSpecialReference(ctx.base, SpecialReference.StreamConstructor),\n await new Promise(\n parseStreamHandle.bind(ctx, depth, id, current),\n ),\n );\n}\n\nasync function parseSequence(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: Sequence,\n): Promise {\n const nodes: SerovalNode[] = [];\n for (let i = 0, len = current.v.length; i < len; i++) {\n nodes[i] = await parseAsync(ctx, depth, current.v[i]);\n }\n return createSequenceNode(id, nodes, current.t, current.d);\n}\n\nexport async function parseObjectAsync(\n ctx: AsyncParserContext,\n depth: number,\n id: number,\n current: object,\n): Promise {\n if (Array.isArray(current)) {\n return parseArray(ctx, depth, id, current);\n }\n if (isStream(current)) {\n return parseStream(ctx, depth, id, current);\n }\n if (isSequence(current)) {\n return parseSequence(ctx, depth, id, current);\n }\n const currentClass = current.constructor;\n if (currentClass === OpaqueReference) {\n return parseAsync(\n ctx,\n depth,\n (current as OpaqueReference).replacement,\n );\n }\n const parsed = await parsePlugin(ctx, depth, id, current);\n if (parsed) {\n return parsed;\n }\n switch (currentClass) {\n case Object:\n return parsePlainObject(\n ctx,\n depth,\n id,\n current as Record,\n false,\n );\n case NIL:\n return parsePlainObject(\n ctx,\n depth,\n id,\n current as Record,\n true,\n );\n case Date:\n return createDateNode(id, current as unknown as Date);\n case Error:\n case EvalError:\n case RangeError:\n case ReferenceError:\n case SyntaxError:\n case TypeError:\n case URIError:\n return parseError(ctx, depth, id, current as unknown as Error);\n case Number:\n case Boolean:\n case String:\n case BigInt:\n return parseBoxed(ctx, depth, id, current);\n case ArrayBuffer:\n return createArrayBufferNode(\n ctx.base,\n id,\n current as unknown as ArrayBuffer,\n );\n case Int8Array:\n case Int16Array:\n case Int32Array:\n case Uint8Array:\n case Uint16Array:\n case Uint32Array:\n case Uint8ClampedArray:\n case Float32Array:\n case Float64Array:\n return parseTypedArray(\n ctx,\n depth,\n id,\n current as unknown as TypedArrayValue,\n );\n case DataView:\n return parseDataView(ctx, depth, id, current as unknown as DataView);\n case Map:\n return parseMap(\n ctx,\n depth,\n id,\n current as unknown as Map,\n );\n case Set:\n return parseSet(ctx, depth, id, current as unknown as Set);\n default:\n break;\n }\n // Promises\n if (currentClass === Promise || current instanceof Promise) {\n return parsePromise(ctx, depth, id, current as unknown as Promise);\n }\n const currentFeatures = ctx.base.features;\n if (currentFeatures & Feature.RegExp && currentClass === RegExp) {\n return createRegExpNode(id, current as unknown as RegExp);\n }\n // BigInt Typed Arrays\n if (currentFeatures & Feature.BigIntTypedArray) {\n switch (currentClass) {\n case BigInt64Array:\n case BigUint64Array:\n return parseBigIntTypedArray(\n ctx,\n depth,\n id,\n current as unknown as BigIntTypedArrayValue,\n );\n default:\n break;\n }\n }\n if (\n currentFeatures & Feature.AggregateError &&\n typeof AggregateError !== 'undefined' &&\n (currentClass === AggregateError || current instanceof AggregateError)\n ) {\n return parseAggregateError(\n ctx,\n depth,\n id,\n current as unknown as AggregateError,\n );\n }\n // Slow path. We only need to handle Errors and Iterators\n // since they have very broad implementations.\n if (current instanceof Error) {\n return parseError(ctx, depth, id, current);\n }\n // Generator functions don't have a global constructor\n // despite existing\n if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) {\n return parsePlainObject(ctx, depth, id, current, !!currentClass);\n }\n throw new SerovalUnsupportedTypeError(current);\n}\n\nexport async function parseFunctionAsync(\n ctx: AsyncParserContext,\n depth: number,\n current: unknown,\n): Promise {\n const ref = getReferenceNode(ctx.base, current);\n if (ref.type !== ParserNodeType.Fresh) {\n return ref.value;\n }\n const plugin = await parsePlugin(ctx, depth, ref.value, current);\n if (plugin) {\n return plugin;\n }\n throw new SerovalUnsupportedTypeError(current);\n}\n\nexport async function parseAsync(\n ctx: AsyncParserContext,\n depth: number,\n current: T,\n): Promise {\n switch (typeof current) {\n case 'boolean':\n return current ? TRUE_NODE : FALSE_NODE;\n case 'undefined':\n return UNDEFINED_NODE;\n case 'string':\n return createStringNode(current as string);\n case 'number':\n return createNumberNode(current as number);\n case 'bigint':\n return createBigIntNode(current as bigint);\n case 'object': {\n if (current) {\n const ref = getReferenceNode(ctx.base, current);\n return ref.type === 0\n ? await parseObjectAsync(ctx, depth + 1, ref.value, current as object)\n : ref.value;\n }\n return NULL_NODE;\n }\n case 'symbol':\n return parseWellKnownSymbol(ctx.base, current);\n case 'function':\n return parseFunctionAsync(ctx, depth, current);\n default:\n throw new SerovalUnsupportedTypeError(current);\n }\n}\n\nexport async function parseTopAsync(\n ctx: AsyncParserContext,\n current: T,\n): Promise {\n try {\n return await parseAsync(ctx, 0, current);\n } catch (error) {\n throw error instanceof SerovalParserError\n ? error\n : new SerovalParserError(error);\n }\n}\n", "import type { AsyncParsePluginContext } from './context/async-parser';\nimport type { DeserializePluginContext } from './context/deserializer';\nimport type { SerializePluginContext } from './context/serializer';\nimport type {\n StreamParsePluginContext,\n SyncParsePluginContext,\n} from './context/sync-parser';\nimport type { SerovalNode } from './types';\n\nexport const enum SerovalMode {\n Vanilla = 1,\n Cross = 2,\n}\n\nexport interface PluginData {\n id: number;\n}\n\nexport type PluginInfo = {\n [key: string]: SerovalNode;\n};\n\nexport interface Plugin {\n /**\n * A unique string that helps idenfity the plugin\n */\n tag: string;\n /**\n * List of dependency plugins\n */\n extends?: Plugin[];\n /**\n * Method to test if a value is an expected value of the plugin\n * @param value\n */\n test(value: unknown): boolean;\n /**\n * Parsing modes\n */\n parse: {\n sync?: (\n value: Value,\n ctx: SyncParsePluginContext,\n data: PluginData,\n ) => Info;\n async?: (\n value: Value,\n ctx: AsyncParsePluginContext,\n data: PluginData,\n ) => Promise;\n stream?: (\n value: Value,\n ctx: StreamParsePluginContext,\n data: PluginData,\n ) => Info;\n };\n /**\n * Convert the parsed node into a JS string\n */\n serialize(node: Info, ctx: SerializePluginContext, data: PluginData): string;\n /**\n * Convert the parsed node into its runtime equivalent.\n */\n deserialize(\n node: Info,\n ctx: DeserializePluginContext,\n data: PluginData,\n ): Value;\n}\n\nexport function createPlugin(\n plugin: Plugin,\n): Plugin {\n return plugin;\n}\n\nexport interface PluginAccessOptions {\n plugins?: Plugin[];\n}\n\nfunction dedupePlugins(\n deduped: Set>,\n plugins: Plugin[],\n): void {\n for (let i = 0, len = plugins.length; i < len; i++) {\n const current = plugins[i];\n if (!deduped.has(current)) {\n deduped.add(current);\n if (current.extends) {\n dedupePlugins(deduped, current.extends);\n }\n }\n }\n}\n\nexport function resolvePlugins(\n plugins?: Plugin[],\n): Plugin[] | undefined {\n if (plugins) {\n const deduped = new Set>();\n dedupePlugins(deduped, plugins);\n return [...deduped];\n }\n return undefined;\n}\n", "import { SerovalUnknownTypedArrayError } from '../errors';\n\ntype TypedArrayConstructor =\n | Int8ArrayConstructor\n | Int16ArrayConstructor\n | Int32ArrayConstructor\n | Uint8ArrayConstructor\n | Uint16ArrayConstructor\n | Uint32ArrayConstructor\n | Uint8ClampedArrayConstructor\n | Float32ArrayConstructor\n | Float64ArrayConstructor\n | BigInt64ArrayConstructor\n | BigUint64ArrayConstructor;\n\nexport type TypedArrayValue =\n | Int8Array\n | Int16Array\n | Int32Array\n | Uint8Array\n | Uint16Array\n | Uint32Array\n | Uint8ClampedArray\n | Float32Array\n | Float64Array;\n\nexport type BigIntTypedArrayValue = BigInt64Array | BigUint64Array;\n\nexport function getTypedArrayConstructor(name: string): TypedArrayConstructor {\n switch (name) {\n case 'Int8Array':\n return Int8Array;\n case 'Int16Array':\n return Int16Array;\n case 'Int32Array':\n return Int32Array;\n case 'Uint8Array':\n return Uint8Array;\n case 'Uint16Array':\n return Uint16Array;\n case 'Uint32Array':\n return Uint32Array;\n case 'Uint8ClampedArray':\n return Uint8ClampedArray;\n case 'Float32Array':\n return Float32Array;\n case 'Float64Array':\n return Float64Array;\n case 'BigInt64Array':\n return BigInt64Array;\n case 'BigUint64Array':\n return BigUint64Array;\n default:\n throw new SerovalUnknownTypedArrayError(name);\n }\n}\n", "import { ALL_ENABLED, Feature } from '../compat';\nimport {\n CONSTANT_VAL,\n ERROR_CONSTRUCTOR,\n NIL,\n SerovalNodeType,\n SerovalObjectFlags,\n SYMBOL_REF,\n} from '../constants';\nimport {\n ARRAY_BUFFER_CONSTRUCTOR,\n PROMISE_CONSTRUCTOR,\n type PromiseConstructorResolver,\n} from '../constructors';\nimport {\n SerovalDepthLimitError,\n SerovalDeserializationError,\n SerovalMalformedNodeError,\n SerovalMissingInstanceError,\n SerovalMissingPluginError,\n SerovalUnsupportedNodeError,\n} from '../errors';\nimport type { PluginAccessOptions } from '../plugin';\nimport { SerovalMode } from '../plugin';\nimport { getReference } from '../reference';\nimport { createSequence, type Sequence, sequenceToIterator } from '../sequence';\nimport type { Stream } from '../stream';\nimport { createStream, isStream, streamToAsyncIterable } from '../stream';\nimport { deserializeString } from '../string';\nimport {\n SYM_ASYNC_ITERATOR,\n SYM_IS_CONCAT_SPREADABLE,\n SYM_ITERATOR,\n SYM_TO_STRING_TAG,\n} from '../symbols';\nimport type {\n SerovalAggregateErrorNode,\n SerovalArrayBufferNode,\n SerovalArrayNode,\n SerovalAsyncIteratorFactoryInstanceNode,\n SerovalAsyncIteratorFactoryNode,\n SerovalBigIntTypedArrayNode,\n SerovalBoxedNode,\n SerovalDataViewNode,\n SerovalDateNode,\n SerovalErrorNode,\n SerovalIteratorFactoryInstanceNode,\n SerovalIteratorFactoryNode,\n SerovalMapNode,\n SerovalNode,\n SerovalNullConstructorNode,\n SerovalObjectNode,\n SerovalObjectRecordNode,\n SerovalPluginNode,\n SerovalPromiseConstructorNode,\n SerovalPromiseNode,\n SerovalPromiseRejectNode,\n SerovalPromiseResolveNode,\n SerovalReferenceNode,\n SerovalRegExpNode,\n SerovalSequenceNode,\n SerovalSetNode,\n SerovalStreamConstructorNode,\n SerovalStreamNextNode,\n SerovalStreamReturnNode,\n SerovalStreamThrowNode,\n SerovalTypedArrayNode,\n} from '../types';\nimport type {\n BigIntTypedArrayValue,\n TypedArrayValue,\n} from '../utils/typed-array';\nimport { getTypedArrayConstructor } from '../utils/typed-array';\n\nconst MAX_BASE64_LENGTH = 1_000_000; // ~0.75MB decoded\nconst MAX_BIGINT_LENGTH = 10_000;\nconst MAX_REGEXP_SOURCE_LENGTH = 20_000;\n\nfunction applyObjectFlag(obj: unknown, flag: SerovalObjectFlags): unknown {\n switch (flag) {\n case SerovalObjectFlags.Frozen:\n return Object.freeze(obj);\n case SerovalObjectFlags.NonExtensible:\n return Object.preventExtensions(obj);\n case SerovalObjectFlags.Sealed:\n return Object.seal(obj);\n default:\n return obj;\n }\n}\n\ntype AssignableValue = AggregateError | Error | Iterable;\ntype AssignableNode = SerovalAggregateErrorNode | SerovalErrorNode;\n\nexport interface BaseDeserializerContextOptions extends PluginAccessOptions {\n refs?: Map;\n features?: number;\n disabledFeatures?: number;\n depthLimit?: number;\n}\n\nexport interface BaseDeserializerContext extends PluginAccessOptions {\n readonly mode: SerovalMode;\n /**\n * Mapping ids to values\n */\n refs: Map;\n features: number;\n depthLimit: number;\n}\n\nconst DEFAULT_DEPTH_LIMIT = 1000;\n\nexport function createBaseDeserializerContext(\n mode: SerovalMode,\n options: BaseDeserializerContextOptions,\n): BaseDeserializerContext {\n return {\n mode,\n plugins: options.plugins,\n refs: options.refs || new Map(),\n features: options.features ?? ALL_ENABLED ^ (options.disabledFeatures || 0),\n depthLimit: options.depthLimit || DEFAULT_DEPTH_LIMIT,\n };\n}\n\nexport interface VanillaDeserializerContextOptions\n extends Omit {\n markedRefs: number[] | Set;\n}\n\nexport interface VanillaDeserializerState {\n marked: Set;\n}\n\nexport interface VanillaDeserializerContext {\n mode: SerovalMode.Vanilla;\n base: BaseDeserializerContext;\n child: DeserializePluginContext | undefined;\n state: VanillaDeserializerState;\n}\n\nexport function createVanillaDeserializerContext(\n options: VanillaDeserializerContextOptions,\n): VanillaDeserializerContext {\n return {\n mode: SerovalMode.Vanilla,\n base: createBaseDeserializerContext(SerovalMode.Vanilla, options),\n child: NIL,\n state: {\n marked: new Set(options.markedRefs),\n },\n };\n}\n\nexport interface CrossDeserializerContext {\n mode: SerovalMode.Cross;\n base: BaseDeserializerContext;\n child: DeserializePluginContext | undefined;\n}\n\nexport type CrossDeserializerContextOptions = BaseDeserializerContextOptions;\n\nexport function createCrossDeserializerContext(\n options: CrossDeserializerContextOptions,\n): CrossDeserializerContext {\n return {\n mode: SerovalMode.Cross,\n base: createBaseDeserializerContext(SerovalMode.Cross, options),\n child: NIL,\n };\n}\n\ntype DeserializerContext =\n | VanillaDeserializerContext\n | CrossDeserializerContext;\n\nexport class DeserializePluginContext {\n constructor(\n private _p: DeserializerContext,\n private depth: number,\n ) {}\n\n deserialize(node: SerovalNode): T {\n return deserialize(this._p, this.depth, node) as T;\n }\n}\n\nfunction guardIndexedValue(ctx: BaseDeserializerContext, id: number): void {\n if (id < 0 || !Number.isFinite(id) || !Number.isInteger(id)) {\n throw new SerovalMalformedNodeError({\n t: SerovalNodeType.IndexedValue,\n i: id,\n } as SerovalNode);\n }\n if (ctx.refs.has(id)) {\n throw new Error('Conflicted ref id: ' + id);\n }\n}\n\nfunction assignIndexedValueVanilla(\n ctx: VanillaDeserializerContext,\n id: number,\n value: T,\n): T {\n guardIndexedValue(ctx.base, id);\n if (ctx.state.marked.has(id)) {\n ctx.base.refs.set(id, value);\n }\n return value;\n}\n\nfunction assignIndexedValueCross(\n ctx: CrossDeserializerContext,\n id: number,\n value: T,\n): T {\n guardIndexedValue(ctx.base, id);\n ctx.base.refs.set(id, value);\n return value;\n}\n\nfunction assignIndexedValue(\n ctx: DeserializerContext,\n id: number,\n value: T,\n): T {\n return ctx.mode === SerovalMode.Vanilla\n ? assignIndexedValueVanilla(ctx, id, value)\n : assignIndexedValueCross(ctx, id, value);\n}\n\nfunction deserializeKnownValue<\n T extends Record,\n K extends keyof T,\n>(node: SerovalNode, record: T, key: K): T[K] {\n if (Object.hasOwn(record, key)) {\n return record[key];\n }\n throw new SerovalMalformedNodeError(node);\n}\n\nfunction deserializeReference(\n ctx: DeserializerContext,\n node: SerovalReferenceNode,\n): unknown {\n return assignIndexedValue(\n ctx,\n node.i,\n getReference(deserializeString(node.s)),\n );\n}\n\nfunction deserializeArray(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalArrayNode,\n): unknown[] {\n const items = node.a;\n const len = items.length;\n const result: unknown[] = assignIndexedValue(\n ctx,\n node.i,\n new Array(len),\n );\n for (let i = 0, item: SerovalNode | 0; i < len; i++) {\n item = items[i];\n if (item) {\n result[i] = deserialize(ctx, depth, item);\n }\n }\n applyObjectFlag(result, node.o);\n return result;\n}\n\nfunction isValidKey(key: string): boolean {\n switch (key) {\n case 'constructor':\n case '__proto__':\n case 'prototype':\n case '__defineGetter__':\n case '__defineSetter__':\n case '__lookupGetter__':\n case '__lookupSetter__':\n // case 'then':\n return false;\n default:\n return true;\n }\n}\n\nfunction isValidSymbol(symbol: symbol): boolean {\n switch (symbol) {\n case SYM_ASYNC_ITERATOR:\n case SYM_IS_CONCAT_SPREADABLE:\n case SYM_TO_STRING_TAG:\n case SYM_ITERATOR:\n return true;\n default:\n return false;\n }\n}\n\nfunction assignStringProperty(\n object: Record,\n key: string,\n value: unknown,\n): void {\n if (isValidKey(key)) {\n object[key] = value;\n } else {\n Object.defineProperty(object, key, {\n value,\n configurable: true,\n enumerable: true,\n writable: true,\n });\n }\n}\n\nfunction assignProperty(\n ctx: DeserializerContext,\n depth: number,\n object: Record,\n key: string | SerovalNode,\n value: SerovalNode,\n): void {\n if (typeof key === 'string') {\n assignStringProperty(object, key, deserialize(ctx, depth, value));\n } else {\n const actual = deserialize(ctx, depth, key);\n switch (typeof actual) {\n case 'string':\n assignStringProperty(object, actual, deserialize(ctx, depth, value));\n break;\n case 'symbol':\n if (isValidSymbol(actual)) {\n object[actual] = deserialize(ctx, depth, value);\n }\n break;\n default:\n throw new SerovalMalformedNodeError(key);\n }\n }\n}\n\nfunction deserializeProperties(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalObjectRecordNode,\n result: Record,\n): Record {\n const keys = node.k;\n const len = keys.length;\n if (len > 0) {\n for (let i = 0, vals = node.v, len = keys.length; i < len; i++) {\n assignProperty(ctx, depth, result, keys[i], vals[i]);\n }\n }\n return result;\n}\n\nfunction deserializeObject(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalObjectNode | SerovalNullConstructorNode,\n): Record {\n const result = assignIndexedValue(\n ctx,\n node.i,\n (node.t === SerovalNodeType.Object ? {} : Object.create(null)) as Record<\n string,\n unknown\n >,\n );\n deserializeProperties(ctx, depth, node.p, result);\n applyObjectFlag(result, node.o);\n return result;\n}\n\nfunction deserializeDate(\n ctx: DeserializerContext,\n node: SerovalDateNode,\n): Date {\n return assignIndexedValue(ctx, node.i, new Date(node.s));\n}\n\nfunction deserializeRegExp(\n ctx: DeserializerContext,\n node: SerovalRegExpNode,\n): RegExp {\n if (ctx.base.features & Feature.RegExp) {\n const source = deserializeString(node.c);\n if (source.length > MAX_REGEXP_SOURCE_LENGTH) {\n throw new SerovalMalformedNodeError(node);\n }\n return assignIndexedValue(ctx, node.i, new RegExp(source, node.m));\n }\n throw new SerovalUnsupportedNodeError(node);\n}\n\nfunction deserializeSet(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalSetNode,\n): Set {\n const result = assignIndexedValue(ctx, node.i, new Set());\n for (let i = 0, items = node.a, len = items.length; i < len; i++) {\n result.add(deserialize(ctx, depth, items[i]));\n }\n return result;\n}\n\nfunction deserializeMap(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalMapNode,\n): Map {\n const result = assignIndexedValue(ctx, node.i, new Map());\n for (\n let i = 0, keys = node.e.k, vals = node.e.v, len = keys.length;\n i < len;\n i++\n ) {\n result.set(\n deserialize(ctx, depth, keys[i]),\n deserialize(ctx, depth, vals[i]),\n );\n }\n return result;\n}\n\nfunction deserializeArrayBuffer(\n ctx: DeserializerContext,\n node: SerovalArrayBufferNode,\n): ArrayBuffer {\n if (node.s.length > MAX_BASE64_LENGTH) {\n throw new SerovalMalformedNodeError(node);\n }\n const result = assignIndexedValue(\n ctx,\n node.i,\n ARRAY_BUFFER_CONSTRUCTOR(deserializeString(node.s)),\n );\n return result;\n}\n\nfunction deserializeTypedArray(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,\n): TypedArrayValue | BigIntTypedArrayValue {\n const construct = getTypedArrayConstructor(node.c) as Int8ArrayConstructor;\n const source = deserialize(ctx, depth, node.f) as ArrayBuffer;\n const offset = node.b ?? 0;\n if (offset < 0 || offset > source.byteLength) {\n throw new SerovalMalformedNodeError(node);\n }\n const result = assignIndexedValue(\n ctx,\n node.i,\n new construct(source, offset, node.l),\n );\n return result;\n}\n\nfunction deserializeDataView(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalDataViewNode,\n): DataView {\n const source = deserialize(ctx, depth, node.f) as ArrayBuffer;\n const offset = node.b ?? 0;\n if (offset < 0 || offset > source.byteLength) {\n throw new SerovalMalformedNodeError(node);\n }\n const result = assignIndexedValue(\n ctx,\n node.i,\n new DataView(source, offset, node.l),\n );\n return result;\n}\n\nfunction deserializeDictionary(\n ctx: DeserializerContext,\n depth: number,\n node: AssignableNode,\n result: T,\n): T {\n if (node.p) {\n const fields = deserializeProperties(ctx, depth, node.p, {});\n Object.defineProperties(result, Object.getOwnPropertyDescriptors(fields));\n }\n return result;\n}\n\nfunction deserializeAggregateError(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalAggregateErrorNode,\n): AggregateError {\n // Serialize the required arguments\n const result = assignIndexedValue(\n ctx,\n node.i,\n new AggregateError([], deserializeString(node.m)),\n );\n // `AggregateError` might've been extended\n // either through class or custom properties\n // Make sure to assign extra properties\n return deserializeDictionary(ctx, depth, node, result);\n}\n\nfunction deserializeError(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalErrorNode,\n): Error {\n const construct = deserializeKnownValue(node, ERROR_CONSTRUCTOR, node.s);\n const result = assignIndexedValue(\n ctx,\n node.i,\n new construct(deserializeString(node.m)),\n );\n return deserializeDictionary(ctx, depth, node, result);\n}\n\nfunction deserializePromise(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalPromiseNode,\n): Promise {\n const deferred = PROMISE_CONSTRUCTOR();\n const result = assignIndexedValue(ctx, node.i, deferred.p);\n const deserialized = deserialize(ctx, depth, node.f);\n if (node.s) {\n deferred.s(deserialized);\n } else {\n deferred.f(deserialized);\n }\n return result;\n}\n\nfunction deserializeBoxed(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalBoxedNode,\n): unknown {\n return assignIndexedValue(\n ctx,\n node.i,\n // biome-ignore lint/style/useConsistentBuiltinInstantiation: intended\n Object(deserialize(ctx, depth, node.f)),\n );\n}\n\nfunction deserializePlugin(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalPluginNode,\n): unknown {\n const currentPlugins = ctx.base.plugins;\n if (currentPlugins) {\n const tag = deserializeString(node.c);\n for (let i = 0, len = currentPlugins.length; i < len; i++) {\n const plugin = currentPlugins[i];\n if (plugin.tag === tag) {\n return assignIndexedValue(\n ctx,\n node.i,\n plugin.deserialize(node.s, new DeserializePluginContext(ctx, depth), {\n id: node.i,\n }),\n );\n }\n }\n }\n throw new SerovalMissingPluginError(node.c);\n}\n\nfunction deserializePromiseConstructor(\n ctx: DeserializerContext,\n node: SerovalPromiseConstructorNode,\n): unknown {\n return assignIndexedValue(\n ctx,\n node.i,\n assignIndexedValue(ctx, node.s, PROMISE_CONSTRUCTOR()).p,\n );\n}\n\nfunction deserializePromiseResolve(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalPromiseResolveNode,\n): unknown {\n const deferred = ctx.base.refs.get(node.i) as\n | PromiseConstructorResolver\n | undefined;\n if (deferred) {\n deferred.s(deserialize(ctx, depth, node.a[1]));\n return NIL;\n }\n throw new SerovalMissingInstanceError('Promise');\n}\n\nfunction deserializePromiseReject(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalPromiseRejectNode,\n): unknown {\n const deferred = ctx.base.refs.get(node.i) as\n | PromiseConstructorResolver\n | undefined;\n if (deferred) {\n deferred.f(deserialize(ctx, depth, node.a[1]));\n return NIL;\n }\n throw new SerovalMissingInstanceError('Promise');\n}\n\nfunction deserializeIteratorFactoryInstance(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalIteratorFactoryInstanceNode,\n): unknown {\n deserialize(ctx, depth, node.a[0]);\n const source = deserialize(ctx, depth, node.a[1]);\n return sequenceToIterator(source as Sequence);\n}\n\nfunction deserializeAsyncIteratorFactoryInstance(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalAsyncIteratorFactoryInstanceNode,\n): unknown {\n deserialize(ctx, depth, node.a[0]);\n const source = deserialize(ctx, depth, node.a[1]);\n return streamToAsyncIterable(source as Stream);\n}\n\nfunction deserializeStreamConstructor(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalStreamConstructorNode,\n): unknown {\n const result = assignIndexedValue(ctx, node.i, createStream());\n const items = node.a;\n const len = items.length;\n if (len) {\n for (let i = 0; i < len; i++) {\n deserialize(ctx, depth, items[i]);\n }\n }\n return result;\n}\n\nfunction deserializeStreamNext(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalStreamNextNode,\n): unknown {\n const deferred = ctx.base.refs.get(node.i) as Stream | undefined;\n if (deferred && isStream(deferred)) {\n deferred.next(deserialize(ctx, depth, node.f));\n return NIL;\n }\n throw new SerovalMissingInstanceError('Stream');\n}\n\nfunction deserializeStreamThrow(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalStreamThrowNode,\n): unknown {\n const deferred = ctx.base.refs.get(node.i) as Stream | undefined;\n if (deferred && isStream(deferred)) {\n deferred.throw(deserialize(ctx, depth, node.f));\n return NIL;\n }\n throw new SerovalMissingInstanceError('Stream');\n}\n\nfunction deserializeStreamReturn(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalStreamReturnNode,\n): unknown {\n const deferred = ctx.base.refs.get(node.i) as Stream | undefined;\n if (deferred && isStream(deferred)) {\n deferred.return(deserialize(ctx, depth, node.f));\n return NIL;\n }\n throw new SerovalMissingInstanceError('Stream');\n}\n\nfunction deserializeIteratorFactory(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalIteratorFactoryNode,\n): unknown {\n deserialize(ctx, depth, node.f);\n return NIL;\n}\n\nfunction deserializeAsyncIteratorFactory(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalAsyncIteratorFactoryNode,\n): unknown {\n deserialize(ctx, depth, node.a[1]);\n return NIL;\n}\n\nfunction deserializeSequence(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalSequenceNode,\n): Sequence {\n const result = assignIndexedValue(\n ctx,\n node.i,\n createSequence([], node.s, node.l),\n );\n for (let i = 0, len = node.a.length; i < len; i++) {\n result.v[i] = deserialize(ctx, depth, node.a[i]);\n }\n return result;\n}\n\nfunction deserialize(\n ctx: DeserializerContext,\n depth: number,\n node: SerovalNode,\n): unknown {\n if (depth > ctx.base.depthLimit) {\n throw new SerovalDepthLimitError(ctx.base.depthLimit);\n }\n depth += 1;\n switch (node.t) {\n case SerovalNodeType.Constant:\n return deserializeKnownValue(node, CONSTANT_VAL, node.s);\n case SerovalNodeType.Number:\n return Number(node.s);\n case SerovalNodeType.String:\n return deserializeString(String(node.s));\n case SerovalNodeType.BigInt:\n if (String(node.s).length > MAX_BIGINT_LENGTH) {\n throw new SerovalMalformedNodeError(node);\n }\n return BigInt(node.s);\n case SerovalNodeType.IndexedValue:\n return ctx.base.refs.get(node.i);\n case SerovalNodeType.Reference:\n return deserializeReference(ctx, node);\n case SerovalNodeType.Array:\n return deserializeArray(ctx, depth, node);\n case SerovalNodeType.Object:\n case SerovalNodeType.NullConstructor:\n return deserializeObject(ctx, depth, node);\n case SerovalNodeType.Date:\n return deserializeDate(ctx, node);\n case SerovalNodeType.RegExp:\n return deserializeRegExp(ctx, node);\n case SerovalNodeType.Set:\n return deserializeSet(ctx, depth, node);\n case SerovalNodeType.Map:\n return deserializeMap(ctx, depth, node);\n case SerovalNodeType.ArrayBuffer:\n return deserializeArrayBuffer(ctx, node);\n case SerovalNodeType.BigIntTypedArray:\n case SerovalNodeType.TypedArray:\n return deserializeTypedArray(ctx, depth, node);\n case SerovalNodeType.DataView:\n return deserializeDataView(ctx, depth, node);\n case SerovalNodeType.AggregateError:\n return deserializeAggregateError(ctx, depth, node);\n case SerovalNodeType.Error:\n return deserializeError(ctx, depth, node);\n case SerovalNodeType.Promise:\n return deserializePromise(ctx, depth, node);\n case SerovalNodeType.WKSymbol:\n return deserializeKnownValue(node, SYMBOL_REF, node.s);\n case SerovalNodeType.Boxed:\n return deserializeBoxed(ctx, depth, node);\n case SerovalNodeType.Plugin:\n return deserializePlugin(ctx, depth, node);\n case SerovalNodeType.PromiseConstructor:\n return deserializePromiseConstructor(ctx, node);\n case SerovalNodeType.PromiseSuccess:\n return deserializePromiseResolve(ctx, depth, node);\n case SerovalNodeType.PromiseFailure:\n return deserializePromiseReject(ctx, depth, node);\n case SerovalNodeType.IteratorFactoryInstance:\n return deserializeIteratorFactoryInstance(ctx, depth, node);\n case SerovalNodeType.AsyncIteratorFactoryInstance:\n return deserializeAsyncIteratorFactoryInstance(ctx, depth, node);\n case SerovalNodeType.StreamConstructor:\n return deserializeStreamConstructor(ctx, depth, node);\n case SerovalNodeType.StreamNext:\n return deserializeStreamNext(ctx, depth, node);\n case SerovalNodeType.StreamThrow:\n return deserializeStreamThrow(ctx, depth, node);\n case SerovalNodeType.StreamReturn:\n return deserializeStreamReturn(ctx, depth, node);\n case SerovalNodeType.IteratorFactory:\n return deserializeIteratorFactory(ctx, depth, node);\n case SerovalNodeType.AsyncIteratorFactory:\n return deserializeAsyncIteratorFactory(ctx, depth, node);\n // case SerovalNodeType.SpecialReference:\n case SerovalNodeType.Sequence:\n return deserializeSequence(ctx, depth, node);\n default:\n throw new SerovalUnsupportedNodeError(node);\n }\n}\n\nexport function deserializeTop(\n ctx: DeserializerContext,\n node: SerovalNode,\n): unknown {\n try {\n return deserialize(ctx, 0, node);\n } catch (error) {\n throw new SerovalDeserializationError(error);\n }\n}\n", "\ndeclare const T: unknown;\n\nconst RETURN = () => T;\nconst SERIALIZED_RETURN = /* @__PURE__ */ RETURN.toString();\n\nconst IS_MODERN = /* @__PURE__ */ /=>/.test(SERIALIZED_RETURN);\n\nexport function createFunction(parameters: string[], body: string): string {\n if (IS_MODERN) {\n const joined =\n parameters.length === 1\n ? parameters[0]\n : '(' + parameters.join(',') + ')';\n return joined + '=>' + (body.startsWith('{') ? '(' + body + ')' : body);\n }\n return 'function(' + parameters.join(',') + '){return ' + body + '}';\n}\n\nexport function createEffectfulFunction(\n parameters: string[],\n body: string,\n): string {\n if (IS_MODERN) {\n const joined =\n parameters.length === 1\n ? parameters[0]\n : '(' + parameters.join(',') + ')';\n return joined + '=>{' + body + '}';\n }\n return 'function(' + parameters.join(',') + '){' + body + '}';\n}", "// Written by https://github.com/DylanPiercey and is distributed under the MIT license.\nconst REF_START_CHARS = /* @__PURE__ */ 'hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_'; // Avoids chars that could evaluate to a reserved word.\nconst REF_START_CHARS_LEN = /* @__PURE__ */ REF_START_CHARS.length;\nconst REF_CHARS =\n /* @__PURE__ */ 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_';\nconst REF_CHARS_LEN = /* @__PURE__ */ REF_CHARS.length;\n\nexport default function getIdentifier(index: number): string {\n let mod = index % REF_START_CHARS_LEN;\n let ref = REF_START_CHARS[mod];\n index = (index - mod) / REF_START_CHARS_LEN;\n while (index > 0) {\n mod = index % REF_CHARS_LEN;\n ref += REF_CHARS[mod];\n index = (index - mod) / REF_CHARS_LEN;\n }\n return ref;\n}\n", "const IDENTIFIER_CHECK = /^[$A-Z_][0-9A-Z_$]*$/i;\n\nexport function isValidIdentifier(name: string): boolean {\n const char = name[0];\n return (\n (char === '$' ||\n char === '_' ||\n (char >= 'A' && char <= 'Z') ||\n (char >= 'a' && char <= 'z')) &&\n IDENTIFIER_CHECK.test(name)\n );\n}\n", "import { Feature } from '../compat';\nimport {\n CONSTANT_STRING,\n ERROR_CONSTRUCTOR_STRING,\n NIL,\n SerovalNodeType,\n SerovalObjectFlags,\n SYMBOL_STRING,\n} from '../constants';\nimport {\n SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR,\n SERIALIZED_ITERATOR_CONSTRUCTOR,\n} from '../constructors';\nimport {\n SerovalMissingPluginError,\n SerovalSerializationError,\n SerovalUnsupportedNodeError,\n} from '../errors';\nimport { createEffectfulFunction, createFunction } from '../function-string';\nimport { GLOBAL_CONTEXT_REFERENCES, REFERENCES_KEY } from '../keys';\nimport type { PluginAccessOptions } from '../plugin';\nimport { SerovalMode } from '../plugin';\nimport { SPECIAL_REF_STRING } from '../special-reference';\nimport { serializeString } from '../string';\nimport type {\n SerovalAggregateErrorNode,\n SerovalArrayBufferNode,\n SerovalArrayNode,\n SerovalAsyncIteratorFactoryInstanceNode,\n SerovalAsyncIteratorFactoryNode,\n SerovalBigIntTypedArrayNode,\n SerovalBoxedNode,\n SerovalDataViewNode,\n SerovalDateNode,\n SerovalErrorNode,\n SerovalIndexedValueNode,\n SerovalIteratorFactoryInstanceNode,\n SerovalIteratorFactoryNode,\n SerovalMapNode,\n SerovalNode,\n SerovalNodeWithID,\n SerovalNullConstructorNode,\n SerovalObjectNode,\n SerovalObjectRecordKey,\n SerovalObjectRecordNode,\n SerovalPluginNode,\n SerovalPromiseConstructorNode,\n SerovalPromiseNode,\n SerovalPromiseRejectNode,\n SerovalPromiseResolveNode,\n SerovalReferenceNode,\n SerovalRegExpNode,\n SerovalSequenceNode,\n SerovalSetNode,\n SerovalStreamConstructorNode,\n SerovalStreamNextNode,\n SerovalStreamReturnNode,\n SerovalStreamThrowNode,\n SerovalTypedArrayNode,\n} from '../types';\nimport getIdentifier from '../utils/get-identifier';\nimport { isValidIdentifier } from '../utils/is-valid-identifier';\n\nconst enum AssignmentType {\n Index = 0,\n Add = 1,\n Set = 2,\n Delete = 3,\n}\n\ninterface IndexAssignment {\n t: AssignmentType.Index;\n s: string;\n k: undefined;\n v: string;\n}\n\ninterface SetAssignment {\n t: AssignmentType.Set;\n s: string;\n k: string;\n v: string;\n}\n\ninterface AddAssignment {\n t: AssignmentType.Add;\n s: string;\n k: undefined;\n v: string;\n}\n\ninterface DeleteAssignment {\n t: AssignmentType.Delete;\n s: string;\n k: string;\n v: undefined;\n}\n\n// Array of assignments to be done (used for recursion)\ntype Assignment =\n | IndexAssignment\n | AddAssignment\n | SetAssignment\n | DeleteAssignment;\n\nexport interface FlaggedObject {\n type: SerovalObjectFlags;\n value: string;\n}\n\nfunction getAssignmentExpression(assignment: Assignment): string {\n switch (assignment.t) {\n case AssignmentType.Index:\n return assignment.s + '=' + assignment.v;\n case AssignmentType.Set:\n return assignment.s + '.set(' + assignment.k + ',' + assignment.v + ')';\n case AssignmentType.Add:\n return assignment.s + '.add(' + assignment.v + ')';\n case AssignmentType.Delete:\n return assignment.s + '.delete(' + assignment.k + ')';\n }\n}\n\nfunction mergeAssignments(assignments: Assignment[]): Assignment[] {\n const newAssignments: Assignment[] = [];\n let current = assignments[0];\n for (\n let i = 1, len = assignments.length, item: Assignment, prev = current;\n i < len;\n i++\n ) {\n item = assignments[i];\n if (item.t === AssignmentType.Index && item.v === prev.v) {\n // Merge if the right-hand value is the same\n // saves at least 2 chars\n current = {\n t: AssignmentType.Index,\n s: item.s,\n k: NIL,\n v: getAssignmentExpression(current),\n } as IndexAssignment;\n } else if (item.t === AssignmentType.Set && item.s === prev.s) {\n // Maps has chaining methods, merge if source is the same\n current = {\n t: AssignmentType.Set,\n s: getAssignmentExpression(current),\n k: item.k,\n v: item.v,\n } as SetAssignment;\n } else if (item.t === AssignmentType.Add && item.s === prev.s) {\n // Sets has chaining methods too\n current = {\n t: AssignmentType.Add,\n s: getAssignmentExpression(current),\n k: NIL,\n v: item.v,\n } as AddAssignment;\n } else if (item.t === AssignmentType.Delete && item.s === prev.s) {\n // Maps has chaining methods, merge if source is the same\n current = {\n t: AssignmentType.Delete,\n s: getAssignmentExpression(current),\n k: item.k,\n v: NIL,\n } as DeleteAssignment;\n } else {\n // Different assignment, push current\n newAssignments.push(current);\n current = item;\n }\n prev = item;\n }\n\n newAssignments.push(current);\n\n return newAssignments;\n}\n\nfunction resolveAssignments(assignments: Assignment[]): string | undefined {\n if (assignments.length) {\n let result = '';\n const merged = mergeAssignments(assignments);\n for (let i = 0, len = merged.length; i < len; i++) {\n result += getAssignmentExpression(merged[i]) + ',';\n }\n return result;\n }\n return NIL;\n}\n\nconst NULL_CONSTRUCTOR = 'Object.create(null)';\nconst SET_CONSTRUCTOR = 'new Set';\nconst MAP_CONSTRUCTOR = 'new Map';\n\nconst PROMISE_RESOLVE = 'Promise.resolve';\nconst PROMISE_REJECT = 'Promise.reject';\n\nconst OBJECT_FLAG_CONSTRUCTOR: Record =\n {\n [SerovalObjectFlags.Frozen]: 'Object.freeze',\n [SerovalObjectFlags.Sealed]: 'Object.seal',\n [SerovalObjectFlags.NonExtensible]: 'Object.preventExtensions',\n [SerovalObjectFlags.None]: NIL,\n };\n\ntype SerovalNodeWithProperties =\n | SerovalObjectNode\n | SerovalNullConstructorNode\n | SerovalAggregateErrorNode\n | SerovalErrorNode;\n\nexport interface BaseSerializerContextOptions extends PluginAccessOptions {\n features: number;\n markedRefs: number[] | Set;\n}\n\nexport interface BaseSerializerContext extends PluginAccessOptions {\n readonly mode: SerovalMode;\n\n features: number;\n /*\n * To check if an object is synchronously referencing itself\n */\n stack: number[];\n /**\n * Array of object mutations\n */\n flags: FlaggedObject[];\n /**\n * Array of assignments to be done (used for recursion)\n */\n assignments: Assignment[];\n /**\n * Refs that are...referenced\n */\n marked: Set;\n}\n\nexport interface CrossContextOptions {\n scopeId?: string;\n}\n\nexport function createBaseSerializerContext(\n mode: SerovalMode,\n options: BaseSerializerContextOptions,\n): BaseSerializerContext {\n return {\n mode,\n plugins: options.plugins,\n features: options.features,\n marked: new Set(options.markedRefs),\n stack: [],\n flags: [],\n assignments: [],\n };\n}\n\nexport interface VanillaSerializerState {\n valid: Map;\n vars: string[];\n}\n\nfunction createVanillaSerializerState(): VanillaSerializerState {\n return {\n valid: new Map(),\n vars: [],\n };\n}\n\nexport interface VanillaSerializerContext {\n mode: SerovalMode.Vanilla;\n base: BaseSerializerContext;\n state: VanillaSerializerState;\n child: SerializePluginContext | undefined;\n}\n\nexport type VanillaSerializerContextOptions = BaseSerializerContextOptions;\n\nexport function createVanillaSerializerContext(\n options: VanillaSerializerContextOptions,\n): VanillaSerializerContext {\n return {\n mode: SerovalMode.Vanilla,\n base: createBaseSerializerContext(SerovalMode.Vanilla, options),\n state: createVanillaSerializerState(),\n child: NIL,\n };\n}\n\nexport interface CrossSerializerContext {\n mode: SerovalMode.Cross;\n base: BaseSerializerContext;\n state: CrossContextOptions;\n child: SerializePluginContext | undefined;\n}\n\nexport interface CrossSerializerContextOptions\n extends BaseSerializerContextOptions,\n CrossContextOptions {\n // empty\n}\n\nexport function createCrossSerializerContext(\n options: CrossSerializerContextOptions,\n): CrossSerializerContext {\n return {\n mode: SerovalMode.Cross,\n base: createBaseSerializerContext(SerovalMode.Cross, options),\n state: options,\n child: NIL,\n };\n}\n\ntype SerializerContext = VanillaSerializerContext | CrossSerializerContext;\n\nexport class SerializePluginContext {\n constructor(private _p: SerializerContext) {}\n\n serialize(node: SerovalNode) {\n return serialize(this._p, node);\n }\n}\n\n/**\n * Creates the reference param (identifier) from the given reference ID\n * Calling this function means the value has been referenced somewhere\n */\nfunction getVanillaRefParam(\n state: VanillaSerializerState,\n index: number,\n): string {\n /**\n * Creates a new reference ID from a given reference ID\n * This new reference ID means that the reference itself\n * has been referenced at least once, and is used to generate\n * the variables\n */\n let actualIndex = state.valid.get(index);\n if (actualIndex == null) {\n actualIndex = state.valid.size;\n state.valid.set(index, actualIndex);\n }\n let identifier = state.vars[actualIndex];\n if (identifier == null) {\n identifier = getIdentifier(actualIndex);\n state.vars[actualIndex] = identifier;\n }\n return identifier;\n}\n\nfunction getCrossRefParam(id: number): string {\n return GLOBAL_CONTEXT_REFERENCES + '[' + id + ']';\n}\n\n/**\n * Converts the ID of a reference into a identifier string\n * that is used to refer to the object instance in the\n * generated script.\n */\nfunction getRefParam(ctx: SerializerContext, id: number): string {\n return ctx.mode === SerovalMode.Vanilla\n ? getVanillaRefParam(ctx.state, id)\n : getCrossRefParam(id);\n}\n\nfunction markSerializerRef(ctx: BaseSerializerContext, id: number): void {\n ctx.marked.add(id);\n}\n\nfunction isSerializerRefMarked(\n ctx: BaseSerializerContext,\n id: number,\n): boolean {\n return ctx.marked.has(id);\n}\n\nfunction pushObjectFlag(\n ctx: SerializerContext,\n flag: SerovalObjectFlags,\n id: number,\n): void {\n if (flag !== SerovalObjectFlags.None) {\n markSerializerRef(ctx.base, id);\n ctx.base.flags.push({\n type: flag,\n value: getRefParam(ctx, id),\n });\n }\n}\n\nfunction resolveFlags(ctx: BaseSerializerContext): string | undefined {\n let result = '';\n for (let i = 0, current = ctx.flags, len = current.length; i < len; i++) {\n const flag = current[i];\n result += OBJECT_FLAG_CONSTRUCTOR[flag.type] + '(' + flag.value + '),';\n }\n return result;\n}\n\nfunction resolvePatches(ctx: BaseSerializerContext): string | undefined {\n const assignments = resolveAssignments(ctx.assignments);\n const flags = resolveFlags(ctx);\n if (assignments) {\n if (flags) {\n return assignments + flags;\n }\n return assignments;\n }\n return flags;\n}\n\n/**\n * Generates the inlined assignment for the reference\n * This is different from the assignments array as this one\n * signifies creation rather than mutation\n */\nfunction createAssignment(\n ctx: BaseSerializerContext,\n source: string,\n value: string,\n): void {\n ctx.assignments.push({\n t: AssignmentType.Index,\n s: source,\n k: NIL,\n v: value,\n });\n}\n\nfunction createAddAssignment(\n ctx: SerializerContext,\n ref: number,\n value: string,\n): void {\n ctx.base.assignments.push({\n t: AssignmentType.Add,\n s: getRefParam(ctx, ref),\n k: NIL,\n v: value,\n });\n}\n\nfunction createSetAssignment(\n ctx: SerializerContext,\n ref: number,\n key: string,\n value: string,\n): void {\n ctx.base.assignments.push({\n t: AssignmentType.Set,\n s: getRefParam(ctx, ref),\n k: key,\n v: value,\n });\n}\n\nfunction createDeleteAssignment(\n ctx: SerializerContext,\n ref: number,\n key: string,\n): void {\n ctx.base.assignments.push({\n t: AssignmentType.Delete,\n s: getRefParam(ctx, ref),\n k: key,\n v: NIL,\n });\n}\n\nfunction createArrayAssign(\n ctx: SerializerContext,\n ref: number,\n index: number | string,\n value: string,\n): void {\n createAssignment(ctx.base, getRefParam(ctx, ref) + '[' + index + ']', value);\n}\n\nfunction createObjectAssign(\n ctx: SerializerContext,\n ref: number,\n key: string,\n value: string,\n): void {\n createAssignment(ctx.base, getRefParam(ctx, ref) + '.' + key, value);\n}\n\nfunction createSequenceAssign(\n ctx: SerializerContext,\n ref: number,\n index: number | string,\n value: string,\n): void {\n createAssignment(ctx.base, getRefParam(ctx, ref) + '.v[' + index + ']', value);\n}\n\n/**\n * Checks if the value is in the stack. Stack here is a reference\n * structure to know if a object is to be accessed in a TDZ.\n */\nfunction isIndexedValueInStack(\n ctx: BaseSerializerContext,\n node: SerovalNode,\n): boolean {\n return node.t === SerovalNodeType.IndexedValue && ctx.stack.includes(node.i);\n}\n\n/**\n * Produces an assignment expression. `id` generates a reference\n * parameter (through `getRefParam`) and has the option to\n * return the reference parameter directly or assign a value to\n * it.\n */\nfunction assignIndexedValue(\n ctx: SerializerContext,\n index: number,\n value: string,\n): string {\n if (\n ctx.mode === SerovalMode.Vanilla &&\n !isSerializerRefMarked(ctx.base, index)\n ) {\n return value;\n }\n /**\n * In cross-reference, we have to assume that\n * every reference are going to be referenced\n * in the future, and so we need to store\n * all of it into the reference array.\n *\n * otherwise in vanilla, we only do this if it\n * is actually referenced\n */\n return getRefParam(ctx, index) + '=' + value;\n}\n\nfunction serializeReference(node: SerovalReferenceNode): string {\n return REFERENCES_KEY + '.get(\"' + node.s + '\")';\n}\n\nfunction serializeArrayItem(\n ctx: SerializerContext,\n id: number,\n item: SerovalNode | 0,\n index: number,\n): string {\n // Check if index is a hole\n if (item) {\n // Check if item is a parent\n if (isIndexedValueInStack(ctx.base, item)) {\n markSerializerRef(ctx.base, id);\n createArrayAssign(\n ctx,\n id,\n index,\n getRefParam(ctx, (item as SerovalIndexedValueNode).i),\n );\n return '';\n }\n return serialize(ctx, item);\n }\n return '';\n}\n\nfunction serializeArray(\n ctx: SerializerContext,\n node: SerovalArrayNode,\n): string {\n const id = node.i;\n const list = node.a;\n const len = list.length;\n if (len > 0) {\n ctx.base.stack.push(id);\n let values = serializeArrayItem(ctx, id, list[0], 0);\n // This is different than Map and Set\n // because we also need to serialize\n // the holes of the Array\n let isHoley = values === '';\n for (let i = 1, item: string; i < len; i++) {\n item = serializeArrayItem(ctx, id, list[i], i);\n values += ',' + item;\n isHoley = item === '';\n }\n ctx.base.stack.pop();\n pushObjectFlag(ctx, node.o, node.i);\n return '[' + values + (isHoley ? ',]' : ']');\n }\n return '[]';\n}\n\nfunction serializeProperty(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n key: SerovalObjectRecordKey,\n val: SerovalNode,\n): string {\n if (typeof key === 'string') {\n const check = Number(key);\n const isIdentifier =\n // Test if key is a valid positive number or JS identifier\n // so that we don't have to serialize the key and wrap with brackets\n (check >= 0 &&\n // It's also important to consider that if the key is\n // indeed numeric, we need to make sure that when\n // converted back into a string, it's still the same\n // to the original key. This allows us to differentiate\n // keys that has numeric formats but in a different\n // format, which can cause unintentional key declaration\n // Example: { 0x1: 1 } vs { '0x1': 1 }\n check.toString() === key) ||\n isValidIdentifier(key);\n if (isIndexedValueInStack(ctx.base, val)) {\n const refParam = getRefParam(ctx, (val as SerovalIndexedValueNode).i);\n markSerializerRef(ctx.base, source.i);\n // Strict identifier check, make sure\n // that it isn't numeric (except NaN)\n if (isIdentifier && check !== check) {\n createObjectAssign(ctx, source.i, key, refParam);\n } else {\n createArrayAssign(\n ctx,\n source.i,\n isIdentifier ? key : '\"' + key + '\"',\n refParam,\n );\n }\n return '';\n }\n return (isIdentifier ? key : '\"' + key + '\"') + ':' + serialize(ctx, val);\n }\n return '[' + serialize(ctx, key) + ']:' + serialize(ctx, val);\n}\n\nfunction serializeProperties(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n record: SerovalObjectRecordNode,\n): string {\n const keys = record.k;\n const len = keys.length;\n if (len > 0) {\n const values = record.v;\n ctx.base.stack.push(source.i);\n let result = serializeProperty(ctx, source, keys[0], values[0]);\n for (let i = 1, item = result; i < len; i++) {\n item = serializeProperty(ctx, source, keys[i], values[i]);\n result += (item && result && ',') + item;\n }\n ctx.base.stack.pop();\n return '{' + result + '}';\n }\n return '{}';\n}\n\nfunction serializeObject(\n ctx: SerializerContext,\n node: SerovalObjectNode,\n): string {\n pushObjectFlag(ctx, node.o, node.i);\n return serializeProperties(ctx, node, node.p);\n}\n\nfunction serializeWithObjectAssign(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n value: SerovalObjectRecordNode,\n serialized: string,\n): string {\n const fields = serializeProperties(ctx, source, value);\n if (fields !== '{}') {\n return 'Object.assign(' + serialized + ',' + fields + ')';\n }\n return serialized;\n}\n\nfunction serializeStringKeyAssignment(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n mainAssignments: Assignment[],\n key: string,\n value: SerovalNode,\n): void {\n const base = ctx.base;\n const serialized = serialize(ctx, value);\n const check = Number(key);\n const isIdentifier =\n // Test if key is a valid positive number or JS identifier\n // so that we don't have to serialize the key and wrap with brackets\n (check >= 0 &&\n // It's also important to consider that if the key is\n // indeed numeric, we need to make sure that when\n // converted back into a string, it's still the same\n // to the original key. This allows us to differentiate\n // keys that has numeric formats but in a different\n // format, which can cause unintentional key declaration\n // Example: { 0x1: 1 } vs { '0x1': 1 }\n check.toString() === key) ||\n isValidIdentifier(key);\n if (isIndexedValueInStack(base, value)) {\n // Strict identifier check, make sure\n // that it isn't numeric (except NaN)\n if (isIdentifier && check !== check) {\n createObjectAssign(ctx, source.i, key, serialized);\n } else {\n createArrayAssign(\n ctx,\n source.i,\n isIdentifier ? key : '\"' + key + '\"',\n serialized,\n );\n }\n } else {\n const parentAssignment = base.assignments;\n base.assignments = mainAssignments;\n if (isIdentifier && check !== check) {\n createObjectAssign(ctx, source.i, key, serialized);\n } else {\n createArrayAssign(\n ctx,\n source.i,\n isIdentifier ? key : '\"' + key + '\"',\n serialized,\n );\n }\n base.assignments = parentAssignment;\n }\n}\n\nfunction serializeAssignment(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n mainAssignments: Assignment[],\n key: SerovalObjectRecordKey,\n value: SerovalNode,\n): void {\n if (typeof key === 'string') {\n serializeStringKeyAssignment(ctx, source, mainAssignments, key, value);\n } else {\n const base = ctx.base;\n const parent = base.stack;\n base.stack = [];\n const serialized = serialize(ctx, value);\n base.stack = parent;\n const parentAssignment = base.assignments;\n base.assignments = mainAssignments;\n createArrayAssign(ctx, source.i, serialize(ctx, key), serialized);\n base.assignments = parentAssignment;\n }\n}\n\nfunction serializeAssignments(\n ctx: SerializerContext,\n source: SerovalNodeWithProperties,\n node: SerovalObjectRecordNode,\n): string | undefined {\n const keys = node.k;\n const len = keys.length;\n if (len > 0) {\n const mainAssignments: Assignment[] = [];\n const values = node.v;\n ctx.base.stack.push(source.i);\n for (let i = 0; i < len; i++) {\n serializeAssignment(ctx, source, mainAssignments, keys[i], values[i]);\n }\n ctx.base.stack.pop();\n return resolveAssignments(mainAssignments);\n }\n return NIL;\n}\n\nfunction serializeDictionary(\n ctx: SerializerContext,\n node: SerovalNodeWithProperties,\n init: string,\n): string {\n if (node.p) {\n const base = ctx.base;\n if (base.features & Feature.ObjectAssign) {\n init = serializeWithObjectAssign(ctx, node, node.p, init);\n } else {\n markSerializerRef(base, node.i);\n const assignments = serializeAssignments(ctx, node, node.p);\n if (assignments) {\n return (\n '(' +\n assignIndexedValue(ctx, node.i, init) +\n ',' +\n assignments +\n getRefParam(ctx, node.i) +\n ')'\n );\n }\n }\n }\n return init;\n}\n\nfunction serializeNullConstructor(\n ctx: SerializerContext,\n node: SerovalNullConstructorNode,\n): string {\n pushObjectFlag(ctx, node.o, node.i);\n return serializeDictionary(ctx, node, NULL_CONSTRUCTOR);\n}\n\nfunction serializeDate(node: SerovalDateNode): string {\n return 'new Date(\"' + node.s + '\")';\n}\n\nfunction serializeRegExp(\n ctx: SerializerContext,\n node: SerovalRegExpNode,\n): string {\n if (ctx.base.features & Feature.RegExp) {\n return '/' + node.c + '/' + node.m;\n }\n throw new SerovalUnsupportedNodeError(node);\n}\n\nfunction serializeSetItem(\n ctx: SerializerContext,\n id: number,\n item: SerovalNode,\n): string {\n const base = ctx.base;\n if (isIndexedValueInStack(base, item)) {\n markSerializerRef(base, id);\n createAddAssignment(\n ctx,\n id,\n getRefParam(ctx, (item as SerovalIndexedValueNode).i),\n );\n return '';\n }\n return serialize(ctx, item);\n}\n\nfunction serializeSet(ctx: SerializerContext, node: SerovalSetNode): string {\n let serialized = SET_CONSTRUCTOR;\n const items = node.a;\n const size = items.length;\n const id = node.i;\n if (size > 0) {\n ctx.base.stack.push(id);\n let result = serializeSetItem(ctx, id, items[0]);\n for (let i = 1, item = result; i < size; i++) {\n item = serializeSetItem(ctx, id, items[i]);\n result += (item && result && ',') + item;\n }\n ctx.base.stack.pop();\n if (result) {\n serialized += '([' + result + '])';\n }\n }\n return serialized;\n}\n\nfunction serializeMapEntry(\n ctx: SerializerContext,\n id: number,\n key: SerovalNode,\n val: SerovalNode,\n sentinel: string,\n): string {\n const base = ctx.base;\n if (isIndexedValueInStack(base, key)) {\n // Create reference for the map instance\n const keyRef = getRefParam(ctx, (key as SerovalIndexedValueNode).i);\n markSerializerRef(base, id);\n // Check if value is a parent\n if (isIndexedValueInStack(base, val)) {\n const valueRef = getRefParam(ctx, (val as SerovalIndexedValueNode).i);\n // Register an assignment since\n // both key and value are a parent of this\n // Map instance\n createSetAssignment(ctx, id, keyRef, valueRef);\n return '';\n }\n // Reset the stack\n // This is required because the serialized\n // value is no longer part of the expression\n // tree and has been moved to the deferred\n // assignment\n if (\n val.t !== SerovalNodeType.IndexedValue &&\n val.i != null &&\n isSerializerRefMarked(base, val.i)\n ) {\n // We use a trick here using sequence (or comma) expressions\n // basically we serialize the intended object in place WITHOUT\n // actually returning it, this is by returning a placeholder\n // value that we will remove sometime after.\n const serialized =\n '(' + serialize(ctx, val) + ',[' + sentinel + ',' + sentinel + '])';\n createSetAssignment(ctx, id, keyRef, getRefParam(ctx, val.i));\n createDeleteAssignment(ctx, id, sentinel);\n return serialized;\n }\n const parent = base.stack;\n base.stack = [];\n createSetAssignment(ctx, id, keyRef, serialize(ctx, val));\n base.stack = parent;\n return '';\n }\n if (isIndexedValueInStack(base, val)) {\n // Create ref for the Map instance\n const valueRef = getRefParam(ctx, (val as SerovalIndexedValueNode).i);\n markSerializerRef(base, id);\n if (\n key.t !== SerovalNodeType.IndexedValue &&\n key.i != null &&\n isSerializerRefMarked(base, key.i)\n ) {\n const serialized =\n '(' + serialize(ctx, key) + ',[' + sentinel + ',' + sentinel + '])';\n createSetAssignment(ctx, id, getRefParam(ctx, key.i), valueRef);\n createDeleteAssignment(ctx, id, sentinel);\n return serialized;\n }\n // Reset stack for the key serialization\n const parent = base.stack;\n base.stack = [];\n createSetAssignment(ctx, id, serialize(ctx, key), valueRef);\n base.stack = parent;\n return '';\n }\n\n return '[' + serialize(ctx, key) + ',' + serialize(ctx, val) + ']';\n}\n\nfunction serializeMap(ctx: SerializerContext, node: SerovalMapNode): string {\n let serialized = MAP_CONSTRUCTOR;\n const keys = node.e.k;\n const size = keys.length;\n const id = node.i;\n const sentinel = node.f;\n const sentinelId = getRefParam(ctx, sentinel.i);\n const base = ctx.base;\n if (size > 0) {\n const vals = node.e.v;\n base.stack.push(id);\n let result = serializeMapEntry(ctx, id, keys[0], vals[0], sentinelId);\n for (let i = 1, item = result; i < size; i++) {\n item = serializeMapEntry(ctx, id, keys[i], vals[i], sentinelId);\n result += (item && result && ',') + item;\n }\n base.stack.pop();\n // Check if there are any values\n // so that the empty Map constructor\n // can be used instead\n if (result) {\n serialized += '([' + result + '])';\n }\n }\n if (sentinel.t === SerovalNodeType.SpecialReference) {\n markSerializerRef(base, sentinel.i);\n serialized = '(' + serialize(ctx, sentinel) + ',' + serialized + ')';\n }\n return serialized;\n}\n\nfunction serializeArrayBuffer(\n ctx: SerializerContext,\n node: SerovalArrayBufferNode,\n): string {\n return getConstructor(ctx, node.f) + '(\"' + node.s + '\")';\n}\n\nfunction serializeTypedArray(\n ctx: SerializerContext,\n node: SerovalTypedArrayNode | SerovalBigIntTypedArrayNode,\n): string {\n return 'new ' + node.c + '(' + serialize(ctx, node.f) + ',' + node.b + ',' + node.l + ')';\n}\n\nfunction serializeDataView(\n ctx: SerializerContext,\n node: SerovalDataViewNode,\n): string {\n return 'new DataView(' + serialize(ctx, node.f) + ',' + node.b + ',' + node.l + ')';\n}\n\nfunction serializeAggregateError(\n ctx: SerializerContext,\n node: SerovalAggregateErrorNode,\n): string {\n const id = node.i;\n // `AggregateError` might've been extended\n // either through class or custom properties\n // Make sure to assign extra properties\n ctx.base.stack.push(id);\n const serialized = serializeDictionary(\n ctx,\n node,\n 'new AggregateError([],\"' + node.m + '\")',\n );\n ctx.base.stack.pop();\n return serialized;\n}\n\nfunction serializeError(\n ctx: SerializerContext,\n node: SerovalErrorNode,\n): string {\n return serializeDictionary(\n ctx,\n node,\n 'new ' + ERROR_CONSTRUCTOR_STRING[node.s] + '(\"' + node.m + '\")',\n );\n}\n\nfunction serializePromise(\n ctx: SerializerContext,\n node: SerovalPromiseNode,\n): string {\n let serialized: string;\n // Check if resolved value is a parent expression\n const fulfilled = node.f;\n const id = node.i;\n const promiseConstructor = node.s ? PROMISE_RESOLVE : PROMISE_REJECT;\n const base = ctx.base;\n if (isIndexedValueInStack(base, fulfilled)) {\n // A Promise trick, reference the value\n // inside the `then` expression so that\n // the Promise evaluates after the parent\n // has initialized\n const ref = getRefParam(ctx, (fulfilled as SerovalIndexedValueNode).i);\n serialized =\n promiseConstructor +\n (node.s\n ? '().then(' + createFunction([], ref) + ')'\n : '().catch(' + createEffectfulFunction([], 'throw ' + ref) + ')');\n } else {\n base.stack.push(id);\n const result = serialize(ctx, fulfilled);\n base.stack.pop();\n // just inline the value/reference here\n serialized = promiseConstructor + '(' + result + ')';\n }\n return serialized;\n}\n\nfunction serializeBoxed(\n ctx: SerializerContext,\n node: SerovalBoxedNode,\n): string {\n return 'Object(' + serialize(ctx, node.f) + ')';\n}\n\nfunction getConstructor(\n ctx: SerializerContext,\n node: SerovalNodeWithID,\n): string {\n const current = serialize(ctx, node);\n return node.t === SerovalNodeType.IndexedValue\n ? current\n : '(' + current + ')';\n}\n\nfunction serializePromiseConstructor(\n ctx: SerializerContext,\n node: SerovalPromiseConstructorNode,\n): string {\n if (ctx.mode === SerovalMode.Vanilla) {\n throw new SerovalUnsupportedNodeError(node);\n }\n const resolver = assignIndexedValue(\n ctx,\n node.s,\n getConstructor(ctx, node.f) + '()',\n );\n return '(' + resolver + ').p';\n}\n\nfunction serializePromiseResolve(\n ctx: SerializerContext,\n node: SerovalPromiseResolveNode,\n): string {\n if (ctx.mode === SerovalMode.Vanilla) {\n throw new SerovalUnsupportedNodeError(node);\n }\n return (\n getConstructor(ctx, node.a[0]) +\n '(' +\n getRefParam(ctx, node.i) +\n ',' +\n serialize(ctx, node.a[1]) +\n ')'\n );\n}\n\nfunction serializePromiseReject(\n ctx: SerializerContext,\n node: SerovalPromiseRejectNode,\n): string {\n if (ctx.mode === SerovalMode.Vanilla) {\n throw new SerovalUnsupportedNodeError(node);\n }\n return (\n getConstructor(ctx, node.a[0]) +\n '(' +\n getRefParam(ctx, node.i) +\n ',' +\n serialize(ctx, node.a[1]) +\n ')'\n );\n}\n\nfunction serializePlugin(\n ctx: SerializerContext,\n node: SerovalPluginNode,\n): string {\n const currentPlugins = ctx.base.plugins;\n if (currentPlugins) {\n for (let i = 0, len = currentPlugins.length; i < len; i++) {\n const plugin = currentPlugins[i];\n if (plugin.tag === node.c) {\n if (ctx.child == null) {\n ctx.child = new SerializePluginContext(ctx);\n }\n return plugin.serialize(node.s, ctx.child, {\n id: node.i,\n });\n }\n }\n }\n throw new SerovalMissingPluginError(node.c);\n}\n\nfunction serializeIteratorFactory(\n ctx: SerializerContext,\n node: SerovalIteratorFactoryNode,\n): string {\n let result = '';\n let initialized = false;\n if (node.f.t !== SerovalNodeType.IndexedValue) {\n markSerializerRef(ctx.base, node.f.i);\n result = '(' + serialize(ctx, node.f) + ',';\n initialized = true;\n }\n result += assignIndexedValue(\n ctx,\n node.i,\n '(' +\n SERIALIZED_ITERATOR_CONSTRUCTOR +\n ')(' +\n getRefParam(ctx, node.f.i) +\n ')',\n );\n if (initialized) {\n result += ')';\n }\n return result;\n}\n\nfunction serializeIteratorFactoryInstance(\n ctx: SerializerContext,\n node: SerovalIteratorFactoryInstanceNode,\n): string {\n return getConstructor(ctx, node.a[0]) + '(' + serialize(ctx, node.a[1]) + ')';\n}\n\nfunction serializeAsyncIteratorFactory(\n ctx: SerializerContext,\n node: SerovalAsyncIteratorFactoryNode,\n): string {\n const promise = node.a[0];\n const symbol = node.a[1];\n const base = ctx.base;\n\n let result = '';\n\n if (promise.t !== SerovalNodeType.IndexedValue) {\n markSerializerRef(base, promise.i);\n result += '(' + serialize(ctx, promise);\n }\n if (symbol.t !== SerovalNodeType.IndexedValue) {\n markSerializerRef(base, symbol.i);\n result += (result ? ',' : '(') + serialize(ctx, symbol);\n }\n if (result) {\n result += ',';\n }\n\n const iterator = assignIndexedValue(\n ctx,\n node.i,\n '(' +\n SERIALIZED_ASYNC_ITERATOR_CONSTRUCTOR +\n ')(' +\n getRefParam(ctx, symbol.i) +\n ',' +\n getRefParam(ctx, promise.i) +\n ')',\n );\n\n if (result) {\n return result + iterator + ')';\n }\n\n return iterator;\n}\n\nfunction serializeAsyncIteratorFactoryInstance(\n ctx: SerializerContext,\n node: SerovalAsyncIteratorFactoryInstanceNode,\n): string {\n return getConstructor(ctx, node.a[0]) + '(' + serialize(ctx, node.a[1]) + ')';\n}\n\nfunction serializeStreamConstructor(\n ctx: SerializerContext,\n node: SerovalStreamConstructorNode,\n): string {\n const result = assignIndexedValue(\n ctx,\n node.i,\n getConstructor(ctx, node.f) + '()',\n );\n const len = node.a.length;\n if (len) {\n let values = serialize(ctx, node.a[0]);\n for (let i = 1; i < len; i++) {\n values += ',' + serialize(ctx, node.a[i]);\n }\n return '(' + result + ',' + values + ',' + getRefParam(ctx, node.i) + ')';\n }\n return result;\n}\n\nfunction serializeStreamNext(\n ctx: SerializerContext,\n node: SerovalStreamNextNode,\n): string {\n return getRefParam(ctx, node.i) + '.next(' + serialize(ctx, node.f) + ')';\n}\n\nfunction serializeStreamThrow(\n ctx: SerializerContext,\n node: SerovalStreamThrowNode,\n): string {\n return getRefParam(ctx, node.i) + '.throw(' + serialize(ctx, node.f) + ')';\n}\n\nfunction serializeStreamReturn(\n ctx: SerializerContext,\n node: SerovalStreamReturnNode,\n): string {\n return getRefParam(ctx, node.i) + '.return(' + serialize(ctx, node.f) + ')';\n}\n\nfunction serializeSequenceItem(\n ctx: SerializerContext,\n id: number,\n index: number,\n item: SerovalNode,\n): string {\n const base = ctx.base;\n if (isIndexedValueInStack(base, item)) {\n markSerializerRef(base, id);\n createSequenceAssign(\n ctx,\n id,\n index,\n getRefParam(ctx, (item as SerovalIndexedValueNode).i),\n );\n return '';\n }\n return serialize(ctx, item);\n}\n\nfunction serializeSequence(\n ctx: SerializerContext,\n node: SerovalSequenceNode,\n): string {\n const items = node.a;\n const size = items.length;\n const id = node.i;\n if (size > 0) {\n ctx.base.stack.push(id);\n let result = serializeSequenceItem(ctx, id, 0, items[0]);\n for (let i = 1, item = result; i < size; i++) {\n item = serializeSequenceItem(ctx, id, i, items[i]);\n result += (item && result && ',') + item;\n }\n ctx.base.stack.pop();\n if (result) {\n return '{__SEROVAL_SEQUENCE__:!0,v:[' + result + '],t:' + node.s + ',d:' + node.l + '}';\n }\n }\n return '{__SEROVAL_SEQUENCE__:!0,v:[],t:-1,d:0}';\n}\n\nfunction serializeAssignable(\n ctx: SerializerContext,\n node: SerovalNode,\n): string {\n switch (node.t) {\n case SerovalNodeType.WKSymbol:\n return SYMBOL_STRING[node.s];\n case SerovalNodeType.Reference:\n return serializeReference(node);\n case SerovalNodeType.Array:\n return serializeArray(ctx, node);\n case SerovalNodeType.Object:\n return serializeObject(ctx, node);\n case SerovalNodeType.NullConstructor:\n return serializeNullConstructor(ctx, node);\n case SerovalNodeType.Date:\n return serializeDate(node);\n case SerovalNodeType.RegExp:\n return serializeRegExp(ctx, node);\n case SerovalNodeType.Set:\n return serializeSet(ctx, node);\n case SerovalNodeType.Map:\n return serializeMap(ctx, node);\n case SerovalNodeType.ArrayBuffer:\n return serializeArrayBuffer(ctx, node);\n case SerovalNodeType.BigIntTypedArray:\n case SerovalNodeType.TypedArray:\n return serializeTypedArray(ctx, node);\n case SerovalNodeType.DataView:\n return serializeDataView(ctx, node);\n case SerovalNodeType.AggregateError:\n return serializeAggregateError(ctx, node);\n case SerovalNodeType.Error:\n return serializeError(ctx, node);\n case SerovalNodeType.Promise:\n return serializePromise(ctx, node);\n case SerovalNodeType.Boxed:\n return serializeBoxed(ctx, node);\n case SerovalNodeType.PromiseConstructor:\n return serializePromiseConstructor(ctx, node);\n case SerovalNodeType.Plugin:\n return serializePlugin(ctx, node);\n case SerovalNodeType.SpecialReference:\n return SPECIAL_REF_STRING[node.s];\n case SerovalNodeType.Sequence:\n return serializeSequence(ctx, node);\n default:\n throw new SerovalUnsupportedNodeError(node);\n }\n}\n\nfunction serialize(ctx: SerializerContext, node: SerovalNode): string {\n switch (node.t) {\n case SerovalNodeType.Constant:\n return CONSTANT_STRING[node.s];\n case SerovalNodeType.Number:\n return '' + node.s;\n case SerovalNodeType.String:\n return '\"' + node.s + '\"';\n case SerovalNodeType.BigInt:\n return node.s + 'n';\n case SerovalNodeType.IndexedValue:\n return getRefParam(ctx, node.i);\n case SerovalNodeType.PromiseSuccess:\n return serializePromiseResolve(ctx, node);\n case SerovalNodeType.PromiseFailure:\n return serializePromiseReject(ctx, node);\n case SerovalNodeType.IteratorFactory:\n return serializeIteratorFactory(ctx, node);\n case SerovalNodeType.IteratorFactoryInstance:\n return serializeIteratorFactoryInstance(ctx, node);\n case SerovalNodeType.AsyncIteratorFactory:\n return serializeAsyncIteratorFactory(ctx, node);\n case SerovalNodeType.AsyncIteratorFactoryInstance:\n return serializeAsyncIteratorFactoryInstance(ctx, node);\n case SerovalNodeType.StreamConstructor:\n return serializeStreamConstructor(ctx, node);\n case SerovalNodeType.StreamNext:\n return serializeStreamNext(ctx, node);\n case SerovalNodeType.StreamThrow:\n return serializeStreamThrow(ctx, node);\n case SerovalNodeType.StreamReturn:\n return serializeStreamReturn(ctx, node);\n default:\n return assignIndexedValue(ctx, node.i, serializeAssignable(ctx, node));\n }\n}\n\nexport function serializeRoot(\n ctx: SerializerContext,\n node: SerovalNode,\n): string {\n try {\n return serialize(ctx, node);\n } catch (error) {\n throw error instanceof SerovalSerializationError\n ? error\n : new SerovalSerializationError(error);\n }\n}\n\nexport function serializeTopVanilla(\n ctx: VanillaSerializerContext,\n tree: SerovalNode,\n): string {\n const result = serialize(ctx, tree);\n // Shared references detected\n if (tree.i != null && ctx.state.vars.length) {\n const patches = resolvePatches(ctx.base);\n let body = result;\n if (patches) {\n // Get (or create) a ref from the source\n const index = getRefParam(ctx, tree.i);\n body = result + ',' + patches + index;\n if (!result.startsWith(index + '=')) {\n body = index + '=' + body;\n }\n body = '(' + body + ')';\n }\n return '(' + createFunction(ctx.state.vars, body) + ')()';\n }\n if (tree.t === SerovalNodeType.Object) {\n return '(' + result + ')';\n }\n return result;\n}\n\nexport function serializeTopCross(\n ctx: CrossSerializerContext,\n tree: SerovalNode,\n): string {\n // Get the serialized result\n const result = serialize(ctx, tree);\n // If the node is a non-reference, return\n // the result immediately\n const id = tree.i;\n if (id == null) {\n return result;\n }\n // Get the patches\n const patches = resolvePatches(ctx.base);\n // Get the variable that represents the root\n const ref = getRefParam(ctx, id);\n const scopeId = ctx.state.scopeId;\n // Parameters needed for scoping\n const params = scopeId == null ? '' : GLOBAL_CONTEXT_REFERENCES;\n // If there are patches, append it after the result\n const body = patches ? '(' + result + ',' + patches + ref + ')' : result;\n // If there are no params, there's no need to generate a function\n if (params === '') {\n if (tree.t === SerovalNodeType.Object && !patches) {\n return '(' + body + ')';\n }\n return body;\n }\n // Get the arguments for the IIFE\n const args =\n scopeId == null\n ? '()'\n : '(' +\n GLOBAL_CONTEXT_REFERENCES +\n '[\"' +\n serializeString(scopeId) +\n '\"])';\n // Create the IIFE\n return '(' + createFunction([params], body) + ')' + args;\n}\n", "import {\n createAggregateErrorNode,\n createArrayNode,\n createAsyncIteratorFactoryInstanceNode,\n createBigIntNode,\n createBigIntTypedArrayNode,\n createBoxedNode,\n createDataViewNode,\n createDateNode,\n createErrorNode,\n createIteratorFactoryInstanceNode,\n createNumberNode,\n createPluginNode,\n createRegExpNode,\n createSequenceNode,\n createSetNode,\n createStreamConstructorNode,\n createStreamNextNode,\n createStreamReturnNode,\n createStreamThrowNode,\n createStringNode,\n createTypedArrayNode,\n} from '../base-primitives';\nimport { Feature } from '../compat';\nimport { NIL, SerovalNodeType } from '../constants';\nimport {\n SerovalDepthLimitError,\n SerovalParserError,\n SerovalUnsupportedTypeError,\n} from '../errors';\nimport { FALSE_NODE, NULL_NODE, TRUE_NODE, UNDEFINED_NODE } from '../literals';\nimport { createSerovalNode } from '../node';\nimport { OpaqueReference } from '../opaque-reference';\nimport { type Plugin, SerovalMode } from '../plugin';\nimport {\n createSequenceFromIterable,\n isSequence,\n type Sequence,\n} from '../sequence';\nimport { SpecialReference } from '../special-reference';\nimport type { Stream } from '../stream';\nimport {\n createStream,\n createStreamFromAsyncIterable,\n isStream,\n} from '../stream';\nimport { serializeString } from '../string';\nimport {\n SYM_ASYNC_ITERATOR,\n SYM_IS_CONCAT_SPREADABLE,\n SYM_ITERATOR,\n SYM_TO_STRING_TAG,\n} from '../symbols';\nimport type {\n SerovalAggregateErrorNode,\n SerovalArrayNode,\n SerovalBigIntTypedArrayNode,\n SerovalBoxedNode,\n SerovalDataViewNode,\n SerovalErrorNode,\n SerovalMapNode,\n SerovalNode,\n SerovalNodeWithID,\n SerovalNullConstructorNode,\n SerovalObjectNode,\n SerovalObjectRecordKey,\n SerovalObjectRecordNode,\n SerovalPluginNode,\n SerovalPromiseConstructorNode,\n SerovalSequenceNode,\n SerovalSetNode,\n SerovalTypedArrayNode,\n} from '../types';\nimport { getErrorOptions } from '../utils/error';\nimport type {\n BigIntTypedArrayValue,\n TypedArrayValue,\n} from '../utils/typed-array';\nimport type { BaseParserContext, BaseParserContextOptions } from './parser';\nimport {\n createArrayBufferNode,\n createBaseParserContext,\n createIndexForValue,\n createMapNode,\n createObjectNode,\n createPromiseConstructorNode,\n getReferenceNode,\n parseAsyncIteratorFactory,\n parseIteratorFactory,\n ParserNodeType,\n parseSpecialReference,\n parseWellKnownSymbol,\n} from './parser';\n\ntype ObjectLikeNode = SerovalObjectNode | SerovalNullConstructorNode;\n\nexport type SyncParserContextOptions = BaseParserContextOptions;\n\nconst enum ParserMode {\n Sync = 1,\n Stream = 2,\n}\n\nexport interface SyncParserContext {\n type: ParserMode.Sync;\n base: BaseParserContext;\n child: SyncParsePluginContext | undefined;\n}\n\nexport function createSyncParserContext(\n mode: SerovalMode,\n options: SyncParserContextOptions,\n): SyncParserContext {\n return {\n type: ParserMode.Sync,\n base: createBaseParserContext(mode, options),\n child: NIL,\n };\n}\n\nexport class SyncParsePluginContext {\n constructor(\n private _p: SyncParserContext,\n private depth: number,\n ) {}\n\n parse(current: T): SerovalNode {\n return parseSOS(this._p, this.depth, current);\n }\n}\n\nexport interface StreamParserContextOptions extends SyncParserContextOptions {\n onParse: (node: SerovalNode, initial: boolean) => void;\n onError?: (error: unknown) => void;\n onDone?: () => void;\n}\n\nexport interface StreamParserContext {\n type: ParserMode.Stream;\n base: BaseParserContext;\n state: StreamParserState;\n}\nexport class StreamParsePluginContext {\n constructor(\n private _p: StreamParserContext,\n private depth: number,\n ) {}\n\n parse(current: T): SerovalNode {\n return parseSOS(this._p, this.depth, current);\n }\n\n parseWithError(current: T): SerovalNode | undefined {\n return parseWithError(this._p, this.depth, current);\n }\n\n isAlive(): boolean {\n return this._p.state.alive;\n }\n\n pushPendingState(): void {\n pushPendingState(this._p);\n }\n\n popPendingState(): void {\n popPendingState(this._p);\n }\n\n onParse(node: SerovalNode): void {\n onParse(this._p, node);\n }\n\n onError(error: unknown): void {\n onError(this._p, error);\n }\n}\n\ninterface StreamParserState {\n // Life cycle\n alive: boolean;\n // Number of pending things\n pending: number;\n //\n initial: boolean;\n //\n buffer: SerovalNode[];\n // Callbacks\n onParse: (node: SerovalNode, initial: boolean) => void;\n onError?: (error: unknown) => void;\n onDone?: () => void;\n}\n\nfunction createStreamParserState(\n options: StreamParserContextOptions,\n): StreamParserState {\n return {\n alive: true,\n pending: 0,\n initial: true,\n buffer: [],\n onParse: options.onParse,\n onError: options.onError,\n onDone: options.onDone,\n };\n}\n\nexport function createStreamParserContext(\n options: StreamParserContextOptions,\n): StreamParserContext {\n return {\n type: ParserMode.Stream,\n base: createBaseParserContext(SerovalMode.Cross, options),\n state: createStreamParserState(options),\n };\n}\n\ntype SOSParserContext = SyncParserContext | StreamParserContext;\n\nfunction parseItems(\n ctx: SOSParserContext,\n depth: number,\n current: unknown[],\n): (SerovalNode | 0)[] {\n const nodes: (SerovalNode | 0)[] = [];\n for (let i = 0, len = current.length; i < len; i++) {\n if (i in current) {\n nodes[i] = parseSOS(ctx, depth, current[i]);\n } else {\n nodes[i] = 0;\n }\n }\n return nodes;\n}\n\nfunction parseArray(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: unknown[],\n): SerovalArrayNode {\n return createArrayNode(id, current, parseItems(ctx, depth, current));\n}\n\nfunction parseProperties(\n ctx: SOSParserContext,\n depth: number,\n properties: Record,\n): SerovalObjectRecordNode {\n const entries = Object.entries(properties);\n const keyNodes: SerovalObjectRecordKey[] = [];\n const valueNodes: SerovalNode[] = [];\n for (let i = 0, len = entries.length; i < len; i++) {\n keyNodes.push(serializeString(entries[i][0]));\n valueNodes.push(parseSOS(ctx, depth, entries[i][1]));\n }\n // Check special properties, symbols in this case\n if (SYM_ITERATOR in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ITERATOR));\n valueNodes.push(\n createIteratorFactoryInstanceNode(\n parseIteratorFactory(ctx.base),\n parseSOS(\n ctx,\n depth,\n createSequenceFromIterable(\n properties as unknown as Iterable,\n ),\n ) as SerovalNodeWithID,\n ),\n );\n }\n if (SYM_ASYNC_ITERATOR in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_ASYNC_ITERATOR));\n valueNodes.push(\n createAsyncIteratorFactoryInstanceNode(\n parseAsyncIteratorFactory(ctx.base),\n parseSOS(\n ctx,\n depth,\n ctx.type === ParserMode.Sync\n ? createStream()\n : createStreamFromAsyncIterable(\n properties as unknown as AsyncIterable,\n ),\n ) as SerovalNodeWithID,\n ),\n );\n }\n if (SYM_TO_STRING_TAG in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_TO_STRING_TAG));\n valueNodes.push(createStringNode(properties[SYM_TO_STRING_TAG] as string));\n }\n if (SYM_IS_CONCAT_SPREADABLE in properties) {\n keyNodes.push(parseWellKnownSymbol(ctx.base, SYM_IS_CONCAT_SPREADABLE));\n valueNodes.push(\n properties[SYM_IS_CONCAT_SPREADABLE] ? TRUE_NODE : FALSE_NODE,\n );\n }\n return {\n k: keyNodes,\n v: valueNodes,\n };\n}\n\nfunction parsePlainObject(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Record,\n empty: boolean,\n): ObjectLikeNode {\n return createObjectNode(\n id,\n current,\n empty,\n parseProperties(ctx, depth, current),\n );\n}\n\nfunction parseBoxed(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: object,\n): SerovalBoxedNode {\n return createBoxedNode(id, parseSOS(ctx, depth, current.valueOf()));\n}\n\nfunction parseTypedArray(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: TypedArrayValue,\n): SerovalTypedArrayNode {\n return createTypedArrayNode(\n id,\n current,\n parseSOS(ctx, depth, current.buffer),\n );\n}\n\nfunction parseBigIntTypedArray(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: BigIntTypedArrayValue,\n): SerovalBigIntTypedArrayNode {\n return createBigIntTypedArrayNode(\n id,\n current,\n parseSOS(ctx, depth, current.buffer),\n );\n}\n\nfunction parseDataView(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: DataView,\n): SerovalDataViewNode {\n return createDataViewNode(id, current, parseSOS(ctx, depth, current.buffer));\n}\n\nfunction parseError(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Error,\n): SerovalErrorNode {\n const options = getErrorOptions(current, ctx.base.features);\n return createErrorNode(\n id,\n current,\n options ? parseProperties(ctx, depth, options) : NIL,\n );\n}\n\nfunction parseAggregateError(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: AggregateError,\n): SerovalAggregateErrorNode {\n const options = getErrorOptions(current, ctx.base.features);\n return createAggregateErrorNode(\n id,\n current,\n options ? parseProperties(ctx, depth, options) : NIL,\n );\n}\n\nfunction parseMap(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Map,\n): SerovalMapNode {\n const keyNodes: SerovalNode[] = [];\n const valueNodes: SerovalNode[] = [];\n for (const [key, value] of current.entries()) {\n keyNodes.push(parseSOS(ctx, depth, key));\n valueNodes.push(parseSOS(ctx, depth, value));\n }\n return createMapNode(ctx.base, id, keyNodes, valueNodes);\n}\n\nfunction parseSet(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Set,\n): SerovalSetNode {\n const items: SerovalNode[] = [];\n for (const item of current.keys()) {\n items.push(parseSOS(ctx, depth, item));\n }\n return createSetNode(id, items);\n}\n\nfunction parseStream(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Stream,\n): SerovalNode {\n const result = createStreamConstructorNode(\n id,\n parseSpecialReference(ctx.base, SpecialReference.StreamConstructor),\n [],\n );\n if (ctx.type === ParserMode.Sync) {\n return result;\n }\n pushPendingState(ctx);\n current.on({\n next: value => {\n if (ctx.state.alive) {\n const parsed = parseWithError(ctx, depth, value);\n if (parsed) {\n onParse(ctx, createStreamNextNode(id, parsed));\n }\n }\n },\n throw: value => {\n if (ctx.state.alive) {\n const parsed = parseWithError(ctx, depth, value);\n if (parsed) {\n onParse(ctx, createStreamThrowNode(id, parsed));\n }\n }\n popPendingState(ctx);\n },\n return: value => {\n if (ctx.state.alive) {\n const parsed = parseWithError(ctx, depth, value);\n if (parsed) {\n onParse(ctx, createStreamReturnNode(id, parsed));\n }\n }\n popPendingState(ctx);\n },\n });\n return result;\n}\n\nfunction handlePromiseSuccess(\n this: StreamParserContext,\n id: number,\n depth: number,\n data: unknown,\n): void {\n if (this.state.alive) {\n const parsed = parseWithError(this, depth, data);\n if (parsed) {\n onParse(\n this,\n createSerovalNode(\n SerovalNodeType.PromiseSuccess,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n [\n parseSpecialReference(this.base, SpecialReference.PromiseSuccess),\n parsed,\n ],\n NIL,\n NIL,\n NIL,\n NIL,\n ),\n );\n }\n popPendingState(this);\n }\n}\n\nfunction handlePromiseFailure(\n this: StreamParserContext,\n id: number,\n depth: number,\n data: unknown,\n): void {\n if (this.state.alive) {\n const parsed = parseWithError(this, depth, data);\n if (parsed) {\n onParse(\n this,\n createSerovalNode(\n SerovalNodeType.PromiseFailure,\n id,\n NIL,\n NIL,\n NIL,\n NIL,\n NIL,\n [\n parseSpecialReference(this.base, SpecialReference.PromiseFailure),\n parsed,\n ],\n NIL,\n NIL,\n NIL,\n NIL,\n ),\n );\n }\n }\n popPendingState(this);\n}\n\nfunction parsePromise(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Promise,\n): SerovalPromiseConstructorNode {\n // Creates a unique reference for the promise resolver\n const resolver = createIndexForValue(ctx.base, {});\n if (ctx.type === ParserMode.Stream) {\n pushPendingState(ctx);\n current.then(\n handlePromiseSuccess.bind(ctx, resolver, depth),\n handlePromiseFailure.bind(ctx, resolver, depth),\n );\n }\n return createPromiseConstructorNode(ctx.base, id, resolver);\n}\n\nfunction parsePluginSync(\n ctx: SyncParserContext,\n depth: number,\n id: number,\n current: unknown,\n currentPlugins: Plugin[],\n): SerovalPluginNode | undefined {\n for (let i = 0, len = currentPlugins.length; i < len; i++) {\n const plugin = currentPlugins[i];\n if (plugin.parse.sync && plugin.test(current)) {\n return createPluginNode(\n id,\n plugin.tag,\n plugin.parse.sync(current, new SyncParsePluginContext(ctx, depth), {\n id,\n }),\n );\n }\n }\n return NIL;\n}\n\nfunction parsePluginStream(\n ctx: StreamParserContext,\n depth: number,\n id: number,\n current: unknown,\n currentPlugins: Plugin[],\n): SerovalPluginNode | undefined {\n for (let i = 0, len = currentPlugins.length; i < len; i++) {\n const plugin = currentPlugins[i];\n if (plugin.parse.stream && plugin.test(current)) {\n return createPluginNode(\n id,\n plugin.tag,\n plugin.parse.stream(current, new StreamParsePluginContext(ctx, depth), {\n id,\n }),\n );\n }\n }\n return NIL;\n}\n\nfunction parsePlugin(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: unknown,\n): SerovalPluginNode | undefined {\n const currentPlugins = ctx.base.plugins;\n if (currentPlugins) {\n return ctx.type === ParserMode.Sync\n ? parsePluginSync(ctx, depth, id, current, currentPlugins)\n : parsePluginStream(ctx, depth, id, current, currentPlugins);\n }\n return NIL;\n}\n\nfunction parseSequence(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: Sequence,\n): SerovalSequenceNode {\n const nodes: SerovalNode[] = [];\n for (let i = 0, len = current.v.length; i < len; i++) {\n nodes[i] = parseSOS(ctx, depth, current.v[i]);\n }\n return createSequenceNode(id, nodes, current.t, current.d);\n}\n\nfunction parseObjectPhase2(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: object,\n currentClass: unknown,\n): SerovalNode {\n switch (currentClass) {\n case Object:\n return parsePlainObject(\n ctx,\n depth,\n id,\n current as Record,\n false,\n );\n case NIL:\n return parsePlainObject(\n ctx,\n depth,\n id,\n current as Record,\n true,\n );\n case Date:\n return createDateNode(id, current as unknown as Date);\n case Error:\n case EvalError:\n case RangeError:\n case ReferenceError:\n case SyntaxError:\n case TypeError:\n case URIError:\n return parseError(ctx, depth, id, current as unknown as Error);\n case Number:\n case Boolean:\n case String:\n case BigInt:\n return parseBoxed(ctx, depth, id, current);\n case ArrayBuffer:\n return createArrayBufferNode(\n ctx.base,\n id,\n current as unknown as ArrayBuffer,\n );\n case Int8Array:\n case Int16Array:\n case Int32Array:\n case Uint8Array:\n case Uint16Array:\n case Uint32Array:\n case Uint8ClampedArray:\n case Float32Array:\n case Float64Array:\n return parseTypedArray(\n ctx,\n depth,\n id,\n current as unknown as TypedArrayValue,\n );\n case DataView:\n return parseDataView(ctx, depth, id, current as unknown as DataView);\n case Map:\n return parseMap(\n ctx,\n depth,\n id,\n current as unknown as Map,\n );\n case Set:\n return parseSet(ctx, depth, id, current as unknown as Set);\n default:\n break;\n }\n // Promises\n if (currentClass === Promise || current instanceof Promise) {\n return parsePromise(ctx, depth, id, current as unknown as Promise);\n }\n const currentFeatures = ctx.base.features;\n if (currentFeatures & Feature.RegExp && currentClass === RegExp) {\n return createRegExpNode(id, current as unknown as RegExp);\n }\n // BigInt Typed Arrays\n if (currentFeatures & Feature.BigIntTypedArray) {\n switch (currentClass) {\n case BigInt64Array:\n case BigUint64Array:\n return parseBigIntTypedArray(\n ctx,\n depth,\n id,\n current as unknown as BigIntTypedArrayValue,\n );\n default:\n break;\n }\n }\n if (\n currentFeatures & Feature.AggregateError &&\n typeof AggregateError !== 'undefined' &&\n (currentClass === AggregateError || current instanceof AggregateError)\n ) {\n return parseAggregateError(\n ctx,\n depth,\n id,\n current as unknown as AggregateError,\n );\n }\n // Slow path. We only need to handle Errors and Iterators\n // since they have very broad implementations.\n if (current instanceof Error) {\n return parseError(ctx, depth, id, current);\n }\n // Generator functions don't have a global constructor\n // despite existing\n if (SYM_ITERATOR in current || SYM_ASYNC_ITERATOR in current) {\n return parsePlainObject(ctx, depth, id, current, !!currentClass);\n }\n throw new SerovalUnsupportedTypeError(current);\n}\n\nfunction parseObject(\n ctx: SOSParserContext,\n depth: number,\n id: number,\n current: object,\n): SerovalNode {\n if (Array.isArray(current)) {\n return parseArray(ctx, depth, id, current);\n }\n if (isStream(current)) {\n return parseStream(ctx, depth, id, current);\n }\n if (isSequence(current)) {\n return parseSequence(ctx, depth, id, current);\n }\n const currentClass = current.constructor;\n if (currentClass === OpaqueReference) {\n return parseSOS(\n ctx,\n depth,\n (current as OpaqueReference).replacement,\n );\n }\n const parsed = parsePlugin(ctx, depth, id, current);\n if (parsed) {\n return parsed;\n }\n return parseObjectPhase2(ctx, depth, id, current, currentClass);\n}\n\nfunction parseFunction(\n ctx: SOSParserContext,\n depth: number,\n current: unknown,\n): SerovalNode {\n const ref = getReferenceNode(ctx.base, current);\n if (ref.type !== ParserNodeType.Fresh) {\n return ref.value;\n }\n const plugin = parsePlugin(ctx, depth, ref.value, current);\n if (plugin) {\n return plugin;\n }\n throw new SerovalUnsupportedTypeError(current);\n}\n\nexport function parseSOS(\n ctx: SOSParserContext,\n depth: number,\n current: T,\n): SerovalNode {\n if (depth >= ctx.base.depthLimit) {\n throw new SerovalDepthLimitError(ctx.base.depthLimit);\n }\n switch (typeof current) {\n case 'boolean':\n return current ? TRUE_NODE : FALSE_NODE;\n case 'undefined':\n return UNDEFINED_NODE;\n case 'string':\n return createStringNode(current as string);\n case 'number':\n return createNumberNode(current as number);\n case 'bigint':\n return createBigIntNode(current as bigint);\n case 'object': {\n if (current) {\n const ref = getReferenceNode(ctx.base, current);\n return ref.type === ParserNodeType.Fresh\n ? parseObject(ctx, depth + 1, ref.value, current as object)\n : ref.value;\n }\n return NULL_NODE;\n }\n case 'symbol':\n return parseWellKnownSymbol(ctx.base, current);\n case 'function': {\n return parseFunction(ctx, depth, current);\n }\n default:\n throw new SerovalUnsupportedTypeError(current);\n }\n}\n\nexport function parseTop(ctx: SyncParserContext, current: T): SerovalNode {\n try {\n return parseSOS(ctx, 0, current);\n } catch (error) {\n throw error instanceof SerovalParserError\n ? error\n : new SerovalParserError(error);\n }\n}\n\nfunction onParse(ctx: StreamParserContext, node: SerovalNode): void {\n // If the value emitted happens to be during parsing, we push to the\n // buffer and emit after the initial parsing is done.\n if (ctx.state.initial) {\n ctx.state.buffer.push(node);\n } else {\n onParseInternal(ctx, node, false);\n }\n}\n\nfunction onError(ctx: StreamParserContext, error: unknown): void {\n if (ctx.state.onError) {\n ctx.state.onError(error);\n } else {\n throw error instanceof SerovalParserError\n ? error\n : new SerovalParserError(error);\n }\n}\n\nfunction onDone(ctx: StreamParserContext): void {\n if (ctx.state.onDone) {\n ctx.state.onDone();\n }\n}\n\nfunction onParseInternal(\n ctx: StreamParserContext,\n node: SerovalNode,\n initial: boolean,\n): void {\n try {\n ctx.state.onParse(node, initial);\n } catch (error) {\n onError(ctx, error);\n }\n}\n\nfunction pushPendingState(ctx: StreamParserContext): void {\n ctx.state.pending++;\n}\n\nfunction popPendingState(ctx: StreamParserContext): void {\n if (--ctx.state.pending <= 0) {\n onDone(ctx);\n }\n}\n\nfunction parseWithError(\n ctx: StreamParserContext,\n depth: number,\n current: T,\n): SerovalNode | undefined {\n try {\n return parseSOS(ctx, depth, current);\n } catch (err) {\n onError(ctx, err);\n return NIL;\n }\n}\n\nexport function startStreamParse(\n ctx: StreamParserContext,\n current: T,\n): void {\n const parsed = parseWithError(ctx, 0, current);\n if (parsed) {\n onParseInternal(ctx, parsed, true);\n ctx.state.initial = false;\n flushStreamParse(ctx, ctx.state);\n\n // Check if there's any pending pushes\n if (ctx.state.pending <= 0) {\n destroyStreamParse(ctx);\n }\n }\n}\n\nfunction flushStreamParse(\n ctx: StreamParserContext,\n state: StreamParserState,\n): void {\n for (let i = 0, len = state.buffer.length; i < len; i++) {\n onParseInternal(ctx, state.buffer[i], false);\n }\n}\n\nexport function destroyStreamParse(ctx: StreamParserContext): void {\n if (ctx.state.alive) {\n onDone(ctx);\n ctx.state.alive = false;\n }\n}\n", "import type { AsyncParserContextOptions } from '../context/async-parser';\nimport {\n createAsyncParserContext,\n parseTopAsync,\n} from '../context/async-parser';\nimport type { CrossDeserializerContextOptions } from '../context/deserializer';\nimport {\n createCrossDeserializerContext,\n deserializeTop,\n} from '../context/deserializer';\nimport type { CrossContextOptions } from '../context/serializer';\nimport {\n createCrossSerializerContext,\n serializeTopCross,\n} from '../context/serializer';\nimport type {\n StreamParserContextOptions,\n SyncParserContextOptions,\n} from '../context/sync-parser';\nimport {\n createStreamParserContext,\n createSyncParserContext,\n destroyStreamParse,\n parseTop,\n startStreamParse,\n} from '../context/sync-parser';\nimport { resolvePlugins, SerovalMode } from '../plugin';\nimport type { SerovalNode } from '../types';\n\nexport interface CrossSerializeOptions\n extends SyncParserContextOptions,\n CrossContextOptions {}\n\nexport function crossSerialize(\n source: T,\n options: CrossSerializeOptions = {},\n): string {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createSyncParserContext(SerovalMode.Cross, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n refs: options.refs,\n });\n const tree = parseTop(ctx, source);\n const serial = createCrossSerializerContext({\n plugins,\n features: ctx.base.features,\n scopeId: options.scopeId,\n markedRefs: ctx.base.marked,\n });\n return serializeTopCross(serial, tree);\n}\n\nexport interface CrossSerializeAsyncOptions\n extends AsyncParserContextOptions,\n CrossContextOptions {}\n\nexport async function crossSerializeAsync(\n source: T,\n options: CrossSerializeAsyncOptions = {},\n): Promise {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createAsyncParserContext(SerovalMode.Cross, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n refs: options.refs,\n });\n const tree = await parseTopAsync(ctx, source);\n const serial = createCrossSerializerContext({\n plugins,\n features: ctx.base.features,\n scopeId: options.scopeId,\n markedRefs: ctx.base.marked,\n });\n return serializeTopCross(serial, tree);\n}\n\nexport type ToCrossJSONOptions = SyncParserContextOptions;\n\nexport function toCrossJSON(\n source: T,\n options: ToCrossJSONOptions = {},\n): SerovalNode {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createSyncParserContext(SerovalMode.Cross, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n refs: options.refs,\n });\n return parseTop(ctx, source);\n}\n\nexport type ToCrossJSONAsyncOptions = AsyncParserContextOptions;\n\nexport async function toCrossJSONAsync(\n source: T,\n options: ToCrossJSONAsyncOptions = {},\n): Promise {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createAsyncParserContext(SerovalMode.Cross, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n refs: options.refs,\n });\n return await parseTopAsync(ctx, source);\n}\n\nexport interface CrossSerializeStreamOptions\n extends Omit,\n CrossContextOptions {\n onSerialize: (data: string, initial: boolean) => void;\n}\n\nexport function crossSerializeStream(\n source: T,\n options: CrossSerializeStreamOptions,\n): () => void {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createStreamParserContext({\n plugins,\n refs: options.refs,\n disabledFeatures: options.disabledFeatures,\n onParse(node, initial): void {\n const serial = createCrossSerializerContext({\n plugins,\n features: ctx.base.features,\n scopeId: options.scopeId,\n markedRefs: ctx.base.marked,\n });\n\n let serialized: string;\n\n try {\n serialized = serializeTopCross(serial, node);\n } catch (err) {\n if (options.onError) {\n options.onError(err);\n }\n return;\n }\n\n options.onSerialize(serialized, initial);\n },\n onError: options.onError,\n onDone: options.onDone,\n });\n\n startStreamParse(ctx, source);\n\n return destroyStreamParse.bind(null, ctx);\n}\n\nexport type ToCrossJSONStreamOptions = StreamParserContextOptions;\n\nexport function toCrossJSONStream(\n source: T,\n options: ToCrossJSONStreamOptions,\n): () => void {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createStreamParserContext({\n plugins,\n refs: options.refs,\n disabledFeatures: options.disabledFeatures,\n depthLimit: options.depthLimit,\n onParse: options.onParse,\n onError: options.onError,\n onDone: options.onDone,\n });\n\n startStreamParse(ctx, source);\n\n return destroyStreamParse.bind(null, ctx);\n}\n\nexport type FromCrossJSONOptions = CrossDeserializerContextOptions;\n\nexport function fromCrossJSON(\n source: SerovalNode,\n options: FromCrossJSONOptions,\n): T {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createCrossDeserializerContext({\n plugins,\n refs: options.refs,\n features: options.features,\n disabledFeatures: options.disabledFeatures,\n depthLimit: options.depthLimit,\n });\n return deserializeTop(ctx, source) as T;\n}\n", "import { crossSerializeStream } from './cross';\nimport {\n resolvePlugins,\n type Plugin,\n type PluginAccessOptions,\n} from './plugin';\nimport { serializeString } from './string';\n\nexport interface SerializerOptions extends PluginAccessOptions {\n globalIdentifier: string;\n scopeId?: string;\n disabledFeatures?: number;\n onData: (result: string) => void;\n onError: (error: unknown) => void;\n onDone?: () => void;\n}\n\nexport default class Serializer {\n private alive = true;\n\n private flushed = false;\n\n private done = false;\n\n private pending = 0;\n\n private cleanups: (() => void)[] = [];\n\n private refs = new Map();\n\n private plugins?: Plugin[];\n\n constructor(private options: SerializerOptions) {\n this.plugins = resolvePlugins(options.plugins);\n }\n\n keys = new Set();\n\n write(key: string, value: unknown): void {\n if (this.alive && !this.flushed) {\n this.pending++;\n this.keys.add(key);\n this.cleanups.push(\n crossSerializeStream(value, {\n plugins: this.plugins,\n scopeId: this.options.scopeId,\n refs: this.refs,\n disabledFeatures: this.options.disabledFeatures,\n onError: this.options.onError,\n onSerialize: (data, initial) => {\n if (this.alive) {\n this.options.onData(\n initial\n ? this.options.globalIdentifier +\n '[\"' +\n serializeString(key) +\n '\"]=' +\n data\n : data,\n );\n }\n },\n onDone: () => {\n if (this.alive) {\n this.pending--;\n if (\n this.pending <= 0 &&\n this.flushed &&\n !this.done &&\n this.options.onDone\n ) {\n this.options.onDone();\n this.done = true;\n }\n }\n },\n }),\n );\n }\n }\n\n ids = 0;\n\n private getNextID(): string {\n while (this.keys.has('' + this.ids)) {\n this.ids++;\n }\n return '' + this.ids;\n }\n\n push(value: unknown): string {\n const newID = this.getNextID();\n this.write(newID, value);\n return newID;\n }\n\n flush(): void {\n if (this.alive) {\n this.flushed = true;\n if (this.pending <= 0 && !this.done && this.options.onDone) {\n this.options.onDone();\n this.done = true;\n }\n }\n }\n\n close(): void {\n if (this.alive) {\n for (let i = 0, len = this.cleanups.length; i < len; i++) {\n this.cleanups[i]();\n }\n if (!this.done && this.options.onDone) {\n this.options.onDone();\n this.done = true;\n }\n this.alive = false;\n }\n }\n}\n", "import {\n createAsyncParserContext,\n parseTopAsync,\n} from '../context/async-parser';\nimport {\n createVanillaDeserializerContext,\n deserializeTop,\n} from '../context/deserializer';\nimport type { BaseParserContextOptions } from '../context/parser';\nimport {\n createVanillaSerializerContext,\n serializeTopVanilla,\n} from '../context/serializer';\nimport { createSyncParserContext, parseTop } from '../context/sync-parser';\nimport {\n type PluginAccessOptions,\n resolvePlugins,\n SerovalMode,\n} from '../plugin';\nimport type { SerovalNode } from '../types';\nimport { ALL_ENABLED } from '../compat';\nexport type SyncParserContextOptions = Omit;\nexport type AsyncParserContextOptions = Omit;\n\nexport function serialize(\n source: T,\n options: SyncParserContextOptions = {},\n): string {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createSyncParserContext(SerovalMode.Vanilla, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n });\n const tree = parseTop(ctx, source);\n const serial = createVanillaSerializerContext({\n plugins,\n features: ctx.base.features,\n markedRefs: ctx.base.marked,\n });\n return serializeTopVanilla(serial, tree);\n}\n\nexport async function serializeAsync(\n source: T,\n options: AsyncParserContextOptions = {},\n): Promise {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createAsyncParserContext(SerovalMode.Vanilla, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n });\n const tree = await parseTopAsync(ctx, source);\n const serial = createVanillaSerializerContext({\n plugins,\n features: ctx.base.features,\n markedRefs: ctx.base.marked,\n });\n return serializeTopVanilla(serial, tree);\n}\n\nexport function deserialize(source: string): T {\n return (0, eval)(source) as T;\n}\n\nexport interface SerovalJSON {\n t: SerovalNode;\n f: number;\n m: number[];\n}\n\nexport interface FromJSONOptions extends PluginAccessOptions {\n disabledFeatures?: number;\n}\n\nexport function toJSON(\n source: T,\n options: SyncParserContextOptions = {},\n): SerovalJSON {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createSyncParserContext(SerovalMode.Vanilla, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n });\n return {\n t: parseTop(ctx, source),\n f: ctx.base.features,\n m: Array.from(ctx.base.marked),\n };\n}\n\nexport async function toJSONAsync(\n source: T,\n options: AsyncParserContextOptions = {},\n): Promise {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createAsyncParserContext(SerovalMode.Vanilla, {\n plugins,\n disabledFeatures: options.disabledFeatures,\n });\n return {\n t: await parseTopAsync(ctx, source),\n f: ctx.base.features,\n m: Array.from(ctx.base.marked),\n };\n}\n\nexport function compileJSON(\n source: SerovalJSON,\n options: PluginAccessOptions = {},\n): string {\n const plugins = resolvePlugins(options.plugins);\n const ctx = createVanillaSerializerContext({\n plugins,\n features: source.f,\n markedRefs: source.m,\n });\n return serializeTopVanilla(ctx, source.t);\n}\n\nexport function fromJSON(\n source: SerovalJSON,\n options: FromJSONOptions = {},\n): T {\n const plugins = resolvePlugins(options.plugins);\n const disabledFeatures = options.disabledFeatures || 0;\n const sourceFeatures = source.f ?? ALL_ENABLED;\n const ctx = createVanillaDeserializerContext({\n plugins,\n markedRefs: source.m,\n features: sourceFeatures & ~disabledFeatures,\n disabledFeatures,\n });\n return deserializeTop(ctx, source.t) as T;\n}\n", "import { createPlugin } from 'seroval'\nimport { GLOBAL_TSR } from '../constants'\nimport type { Plugin, SerovalNode } from 'seroval'\nimport type {\n RegisteredConfigType,\n RegisteredSsr,\n SSROption,\n} from '../../router'\nimport type { LooseReturnType } from '../../utils'\nimport type { AnyRoute, ResolveAllSSR } from '../../route'\nimport type { RawStream } from './RawStream'\n\ndeclare const TSR_SERIALIZABLE: unique symbol\nexport type TSR_SERIALIZABLE = typeof TSR_SERIALIZABLE\n\nexport type TsrSerializable = { [TSR_SERIALIZABLE]: true }\nexport interface DefaultSerializable {\n number: number\n string: string\n boolean: boolean\n null: null\n undefined: undefined\n bigint: bigint\n Date: Date\n Uint8Array: Uint8Array\n RawStream: RawStream\n TsrSerializable: TsrSerializable\n}\n\nexport interface SerializableExtensions extends DefaultSerializable {}\n\nexport type Serializable = SerializableExtensions[keyof SerializableExtensions]\n\nexport type UnionizeSerializationAdaptersInput<\n TAdapters extends ReadonlyArray,\n> = TAdapters[number]['~types']['input']\n\n/**\n * Create a strongly-typed serialization adapter for SSR hydration.\n * Use to register custom types with the router serializer.\n */\nexport function createSerializationAdapter<\n TInput = unknown,\n TOutput = unknown,\n const TExtendsAdapters extends\n | ReadonlyArray\n | never = never,\n>(\n opts: CreateSerializationAdapterOptions,\n): SerializationAdapter {\n return opts as unknown as SerializationAdapter<\n TInput,\n TOutput,\n TExtendsAdapters\n >\n}\n\nexport interface CreateSerializationAdapterOptions<\n TInput,\n TOutput,\n TExtendsAdapters extends ReadonlyArray | never,\n> {\n key: string\n extends?: TExtendsAdapters\n test: (value: unknown) => value is TInput\n toSerializable: (\n value: TInput,\n ) => ValidateSerializable<\n TOutput,\n Serializable | UnionizeSerializationAdaptersInput\n >\n fromSerializable: (value: TOutput) => TInput\n}\n\nexport type ValidateSerializable =\n T extends ReadonlyArray\n ? ResolveArrayShape\n : T extends TSerializable\n ? T\n : T extends (...args: Array) => any\n ? 'Function is not serializable'\n : T extends Promise\n ? ValidateSerializablePromise\n : T extends ReadableStream\n ? ValidateReadableStream\n : T extends Set\n ? ValidateSerializableSet\n : T extends Map\n ? ValidateSerializableMap\n : T extends AsyncGenerator\n ? ValidateSerializableAsyncGenerator\n : {\n [K in keyof T]: ValidateSerializable\n }\n\nexport type ValidateSerializableAsyncGenerator =\n T extends AsyncGenerator\n ? AsyncGenerator<\n ValidateSerializable,\n ValidateSerializable,\n TNext\n >\n : never\n\nexport type ValidateSerializablePromise =\n T extends Promise\n ? Promise>\n : never\n\nexport type ValidateReadableStream =\n T extends ReadableStream\n ? ReadableStream>\n : never\n\nexport type ValidateSerializableSet =\n T extends Set\n ? Set>\n : never\n\nexport type ValidateSerializableMap =\n T extends Map\n ? Map<\n ValidateSerializable,\n ValidateSerializable\n >\n : never\n\nexport type RegisteredReadableStream =\n unknown extends SerializerExtensions['ReadableStream']\n ? never\n : SerializerExtensions['ReadableStream']\n\nexport interface DefaultSerializerExtensions {\n ReadableStream: unknown\n}\n\nexport interface SerializerExtensions extends DefaultSerializerExtensions {}\n\nexport interface SerializationAdapter<\n TInput,\n TOutput,\n TExtendsAdapters extends ReadonlyArray,\n> {\n '~types': SerializationAdapterTypes\n key: string\n extends?: TExtendsAdapters\n test: (value: unknown) => value is TInput\n toSerializable: (value: TInput) => TOutput\n fromSerializable: (value: TOutput) => TInput\n}\n\nexport interface SerializationAdapterTypes<\n TInput,\n TOutput,\n TExtendsAdapters extends ReadonlyArray,\n> {\n input: TInput | UnionizeSerializationAdaptersInput\n output: TOutput\n extends: TExtendsAdapters\n}\n\nexport type AnySerializationAdapter = SerializationAdapter\n\n/** Create a Seroval plugin for server-side serialization only. */\nexport function makeSsrSerovalPlugin(\n serializationAdapter: AnySerializationAdapter,\n options: { didRun: boolean },\n): Plugin {\n return createPlugin({\n tag: '$TSR/t/' + serializationAdapter.key,\n test: serializationAdapter.test,\n parse: {\n stream(value, ctx) {\n return ctx.parse(serializationAdapter.toSerializable(value))\n },\n },\n serialize(node, ctx) {\n options.didRun = true\n return (\n GLOBAL_TSR +\n '.t.get(\"' +\n serializationAdapter.key +\n '\")(' +\n ctx.serialize(node) +\n ')'\n )\n },\n // we never deserialize on the server during SSR\n deserialize: undefined as never,\n })\n}\n\n/** Create a Seroval plugin for client/server symmetric (de)serialization. */\nexport function makeSerovalPlugin(\n serializationAdapter: AnySerializationAdapter,\n): Plugin {\n return createPlugin({\n tag: '$TSR/t/' + serializationAdapter.key,\n test: serializationAdapter.test,\n parse: {\n sync(value, ctx) {\n return ctx.parse(serializationAdapter.toSerializable(value))\n },\n async async(value, ctx) {\n return await ctx.parse(serializationAdapter.toSerializable(value))\n },\n stream(value, ctx) {\n return ctx.parse(serializationAdapter.toSerializable(value))\n },\n },\n // we don't generate JS code outside of SSR (for now)\n serialize: undefined as never,\n deserialize(node, ctx) {\n return serializationAdapter.fromSerializable(ctx.deserialize(node))\n },\n })\n}\n\nexport type ValidateSerializableInput = ValidateSerializable<\n T,\n RegisteredSerializableInput\n>\n\nexport type RegisteredSerializableInput =\n | (unknown extends RegisteredSerializationAdapters\n ? never\n : RegisteredSerializationAdapters extends ReadonlyArray\n ? RegisteredSerializationAdapters[number]['~types']['input']\n : never)\n | Serializable\n\nexport type RegisteredSerializationAdapters = RegisteredConfigType<\n TRegister,\n 'serializationAdapters'\n>\n\nexport type ValidateSerializableInputResult =\n ValidateSerializableResult>\n\nexport type ValidateSerializableResult =\n T extends ReadonlyArray\n ? ResolveArrayShape\n : T extends TSerializable\n ? T\n : unknown extends SerializerExtensions['ReadableStream']\n ? { [K in keyof T]: ValidateSerializableResult }\n : T extends SerializerExtensions['ReadableStream']\n ? ReadableStream\n : { [K in keyof T]: ValidateSerializableResult }\n\nexport type RegisteredSSROption =\n unknown extends RegisteredConfigType\n ? SSROption\n : RegisteredConfigType\n\nexport type ValidateSerializableLifecycleResult<\n TRegister,\n TParentRoute extends AnyRoute,\n TSSR,\n TFn,\n> =\n false extends RegisteredSsr\n ? any\n : ValidateSerializableLifecycleResultSSR<\n TRegister,\n TParentRoute,\n TSSR,\n TFn\n > extends infer TInput\n ? TInput\n : never\n\nexport type ValidateSerializableLifecycleResultSSR<\n TRegister,\n TParentRoute extends AnyRoute,\n TSSR,\n TFn,\n> =\n ResolveAllSSR extends false\n ? any\n : RegisteredSSROption extends false\n ? any\n : ValidateSerializableInput>\n\ntype ResolveArrayShape<\n T extends ReadonlyArray,\n TSerializable,\n TMode extends 'input' | 'result',\n> = number extends T['length']\n ? T extends Array\n ? Array>\n : ReadonlyArray>\n : ResolveTupleShape\n\ntype ResolveTupleShape<\n T extends ReadonlyArray,\n TSerializable,\n TMode extends 'input' | 'result',\n> = T extends readonly [infer THead, ...infer TTail]\n ? readonly [\n ArrayModeResult,\n ...ResolveTupleShape, TSerializable, TMode>,\n ]\n : T\n\ntype ArrayModeResult<\n TMode extends 'input' | 'result',\n TValue,\n TSerializable,\n> = TMode extends 'input'\n ? ValidateSerializable\n : ValidateSerializableResult\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nconst PROMISE_TO_ABORT_SIGNAL = (promise: Promise) => {\n const controller = new AbortController();\n const abort = controller.abort.bind(controller);\n promise.then(abort, abort);\n return controller;\n};\n\nfunction resolveAbortSignalResult(\n this: AbortSignal,\n resolve: (value: unknown) => void,\n): void {\n resolve(this.reason);\n}\n\nfunction resolveAbortSignal(\n this: AbortSignal,\n resolve: (value: unknown) => void,\n): void {\n this.addEventListener('abort', resolveAbortSignalResult.bind(this, resolve), {\n once: true,\n });\n}\n\nfunction abortSignalToPromise(signal: AbortSignal): Promise {\n return new Promise(resolveAbortSignal.bind(signal));\n}\n\nconst ABORT_CONTROLLER = {};\n\nconst AbortControllerFactoryPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/AbortControllerFactoryPlugin',\n test(value) {\n return value === ABORT_CONTROLLER;\n },\n parse: {\n sync() {\n return ABORT_CONTROLLER;\n },\n async async() {\n return await Promise.resolve(ABORT_CONTROLLER);\n },\n stream() {\n return ABORT_CONTROLLER;\n },\n },\n serialize() {\n return PROMISE_TO_ABORT_SIGNAL.toString();\n },\n deserialize() {\n return PROMISE_TO_ABORT_SIGNAL;\n },\n});\n\nconst AbortSignalPlugin = /* @__PURE__ */ createPlugin<\n AbortSignal,\n { reason?: SerovalNode; controller?: SerovalNode; factory?: SerovalNode }\n>({\n tag: 'seroval-plugins/web/AbortSignal',\n extends: [AbortControllerFactoryPlugin],\n test(value) {\n if (typeof AbortSignal === 'undefined') {\n return false;\n }\n return value instanceof AbortSignal;\n },\n parse: {\n sync(value, ctx) {\n if (value.aborted) {\n return {\n reason: ctx.parse(value.reason),\n };\n }\n return {};\n },\n async async(value, ctx) {\n if (value.aborted) {\n return {\n reason: await ctx.parse(value.reason),\n };\n }\n const result = await abortSignalToPromise(value);\n return {\n reason: await ctx.parse(result),\n };\n },\n stream(value, ctx) {\n if (value.aborted) {\n return {\n reason: ctx.parse(value.reason),\n };\n }\n\n const promise = abortSignalToPromise(value);\n\n return {\n factory: ctx.parse(ABORT_CONTROLLER),\n controller: ctx.parse(promise),\n };\n },\n },\n serialize(node, ctx) {\n if (node.reason) {\n return 'AbortSignal.abort(' + ctx.serialize(node.reason) + ')';\n }\n if (node.controller && node.factory) {\n return (\n '(' +\n ctx.serialize(node.factory) +\n ')(' +\n ctx.serialize(node.controller) +\n ').signal'\n );\n }\n return '(new AbortController).signal';\n },\n deserialize(node, ctx) {\n if (node.reason) {\n return AbortSignal.abort(ctx.deserialize(node.reason));\n }\n if (node.controller) {\n return PROMISE_TO_ABORT_SIGNAL(ctx.deserialize(node.controller)).signal;\n }\n const controller = new AbortController();\n return controller.signal;\n },\n});\n\nexport default AbortSignalPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\ntype BlobNode = {\n type: SerovalNode;\n buffer: SerovalNode;\n};\n\nconst BlobPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/Blob',\n test(value) {\n if (typeof Blob === 'undefined') {\n return false;\n }\n return value instanceof Blob;\n },\n parse: {\n async async(value, ctx) {\n return {\n type: await ctx.parse(value.type),\n buffer: await ctx.parse(await value.arrayBuffer()),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new Blob([' +\n ctx.serialize(node.buffer) +\n '],{type:' +\n ctx.serialize(node.type) +\n '})'\n );\n },\n deserialize(node, ctx) {\n return new Blob([ctx.deserialize(node.buffer) as ArrayBuffer], {\n type: ctx.deserialize(node.type) as string,\n });\n },\n});\n\nexport default BlobPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nfunction createCustomEventOptions(current: CustomEvent): CustomEventInit {\n return {\n detail: current.detail as unknown,\n bubbles: current.bubbles,\n cancelable: current.cancelable,\n composed: current.composed,\n };\n}\n\ntype CustomEventNode = {\n type: SerovalNode;\n options: SerovalNode;\n};\n\nconst CustomEventPlugin = /* @__PURE__ */ createPlugin<\n CustomEvent,\n CustomEventNode\n>({\n tag: 'seroval-plugins/web/CustomEvent',\n test(value) {\n if (typeof CustomEvent === 'undefined') {\n return false;\n }\n return value instanceof CustomEvent;\n },\n parse: {\n sync(value, ctx) {\n return {\n type: ctx.parse(value.type),\n options: ctx.parse(createCustomEventOptions(value)),\n };\n },\n async async(value, ctx) {\n return {\n type: await ctx.parse(value.type),\n options: await ctx.parse(createCustomEventOptions(value)),\n };\n },\n stream(value, ctx) {\n return {\n type: ctx.parse(value.type),\n options: ctx.parse(createCustomEventOptions(value)),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new CustomEvent(' +\n ctx.serialize(node.type) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new CustomEvent(\n ctx.deserialize(node.type) as string,\n ctx.deserialize(node.options) as CustomEventInit,\n );\n },\n});\n\nexport default CustomEventPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\ntype DOMExceptionNode = {\n name: SerovalNode;\n message: SerovalNode;\n};\n\nconst DOMExceptionPlugin = /* @__PURE__ */ createPlugin<\n DOMException,\n DOMExceptionNode\n>({\n tag: 'seroval-plugins/web/DOMException',\n test(value) {\n if (typeof DOMException === 'undefined') {\n return false;\n }\n return value instanceof DOMException;\n },\n parse: {\n sync(value, ctx) {\n return {\n name: ctx.parse(value.name),\n message: ctx.parse(value.message),\n };\n },\n async async(value, ctx) {\n return {\n name: await ctx.parse(value.name),\n message: await ctx.parse(value.message),\n };\n },\n stream(value, ctx) {\n return {\n name: ctx.parse(value.name),\n message: ctx.parse(value.message),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new DOMException(' +\n ctx.serialize(node.message) +\n ',' +\n ctx.serialize(node.name) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new DOMException(\n ctx.deserialize(node.message) as string,\n ctx.deserialize(node.name) as string,\n );\n },\n});\n\nexport default DOMExceptionPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nfunction createEventOptions(current: Event): EventInit {\n return {\n bubbles: current.bubbles,\n cancelable: current.cancelable,\n composed: current.composed,\n };\n}\n\ntype EventNode = {\n type: SerovalNode;\n options: SerovalNode;\n};\n\nconst EventPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/Event',\n test(value) {\n if (typeof Event === 'undefined') {\n return false;\n }\n return value instanceof Event;\n },\n parse: {\n sync(value, ctx) {\n return {\n type: ctx.parse(value.type),\n options: ctx.parse(createEventOptions(value)),\n };\n },\n async async(value, ctx) {\n return {\n type: await ctx.parse(value.type),\n options: await ctx.parse(createEventOptions(value)),\n };\n },\n stream(value, ctx) {\n return {\n type: ctx.parse(value.type),\n options: ctx.parse(createEventOptions(value)),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new Event(' +\n ctx.serialize(node.type) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new Event(\n ctx.deserialize(node.type) as string,\n ctx.deserialize(node.options) as EventInit,\n );\n },\n});\n\nexport default EventPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\ntype FileNode = {\n name: SerovalNode;\n options: SerovalNode;\n buffer: SerovalNode;\n};\n\nconst FilePlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/File',\n test(value) {\n if (typeof File === 'undefined') {\n return false;\n }\n return value instanceof File;\n },\n parse: {\n async async(value, ctx) {\n return {\n name: await ctx.parse(value.name),\n options: await ctx.parse({\n type: value.type,\n lastModified: value.lastModified,\n }),\n buffer: await ctx.parse(await value.arrayBuffer()),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new File([' +\n ctx.serialize(node.buffer) +\n '],' +\n ctx.serialize(node.name) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new File(\n [ctx.deserialize(node.buffer) as ArrayBuffer],\n ctx.deserialize(node.name) as string,\n ctx.deserialize(node.options) as FilePropertyBag,\n );\n },\n});\n\nexport default FilePlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\nimport FilePlugin from './file';\n\ntype FormDataInit = [key: string, value: FormDataEntryValue][];\n\nfunction convertFormData(instance: FormData): FormDataInit {\n const items: FormDataInit = [];\n instance.forEach((value, key) => {\n items.push([key, value]);\n });\n return items;\n}\n\nconst FORM_DATA_FACTORY = {};\n\nconst FORM_DATA_FACTORY_CONSTRUCTOR = (\n e: [key: string, value: FormDataEntryValue][],\n f = new FormData(),\n i = 0,\n s = e.length,\n t?: [key: string, value: FormDataEntryValue],\n) => {\n for (; i < s; i++) {\n t = e[i];\n f.append(t[0], t[1]);\n }\n return f;\n};\n\nconst FormDataFactoryPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/FormDataFactory',\n test(value) {\n return value === FORM_DATA_FACTORY;\n },\n parse: {\n sync() {\n return FORM_DATA_FACTORY;\n },\n async async() {\n return await Promise.resolve(FORM_DATA_FACTORY);\n },\n stream() {\n return FORM_DATA_FACTORY;\n },\n },\n serialize() {\n return FORM_DATA_FACTORY_CONSTRUCTOR.toString();\n },\n deserialize() {\n return FORM_DATA_FACTORY;\n },\n});\n\ntype FormDataNode = {\n factory: SerovalNode;\n entries: SerovalNode;\n};\n\nconst FormDataPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/FormData',\n extends: [FilePlugin, FormDataFactoryPlugin],\n test(value) {\n if (typeof FormData === 'undefined') {\n return false;\n }\n return value instanceof FormData;\n },\n parse: {\n sync(value, ctx) {\n return {\n factory: ctx.parse(FORM_DATA_FACTORY),\n entries: ctx.parse(convertFormData(value)),\n };\n },\n async async(value, ctx) {\n return {\n factory: await ctx.parse(FORM_DATA_FACTORY),\n entries: await ctx.parse(convertFormData(value)),\n };\n },\n stream(value, ctx) {\n return {\n factory: ctx.parse(FORM_DATA_FACTORY),\n entries: ctx.parse(convertFormData(value)),\n };\n },\n },\n serialize(node, ctx) {\n return (\n '(' +\n ctx.serialize(node.factory) +\n ')(' +\n ctx.serialize(node.entries) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return FORM_DATA_FACTORY_CONSTRUCTOR(\n ctx.deserialize(node.entries) as FormDataInit,\n );\n },\n});\n\nexport default FormDataPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nfunction convertHeaders(instance: Headers): HeadersInit {\n const items: HeadersInit = [];\n // biome-ignore lint/complexity/noForEach: \n instance.forEach((value, key) => {\n items.push([key, value]);\n });\n return items;\n}\n\nconst HeadersPlugin = /* @__PURE__ */ createPlugin<\n Headers,\n { value: SerovalNode }\n>({\n tag: 'seroval-plugins/web/Headers',\n test(value) {\n if (typeof Headers === 'undefined') {\n return false;\n }\n return value instanceof Headers;\n },\n parse: {\n sync(value, ctx) {\n return {\n value: ctx.parse(convertHeaders(value)),\n };\n },\n async async(value, ctx) {\n return {\n value: await ctx.parse(convertHeaders(value)),\n };\n },\n stream(value, ctx) {\n return {\n value: ctx.parse(convertHeaders(value)),\n };\n },\n },\n serialize(node, ctx) {\n return 'new Headers(' + ctx.serialize(node.value) + ')';\n },\n deserialize(node, ctx) {\n return new Headers(ctx.deserialize(node.value) as HeadersInit);\n },\n});\n\nexport default HeadersPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\ntype ImageDataNode = {\n data: SerovalNode;\n width: SerovalNode;\n height: SerovalNode;\n options: SerovalNode;\n};\n\nconst ImageDataPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/ImageData',\n test(value) {\n if (typeof ImageData === 'undefined') {\n return false;\n }\n return value instanceof ImageData;\n },\n parse: {\n sync(value, ctx) {\n return {\n data: ctx.parse(value.data),\n width: ctx.parse(value.width),\n height: ctx.parse(value.height),\n options: ctx.parse({\n colorSpace: value.colorSpace,\n }),\n };\n },\n async async(value, ctx) {\n return {\n data: await ctx.parse(value.data),\n width: await ctx.parse(value.width),\n height: await ctx.parse(value.height),\n options: await ctx.parse({\n colorSpace: value.colorSpace,\n }),\n };\n },\n stream(value, ctx) {\n return {\n data: ctx.parse(value.data),\n width: ctx.parse(value.width),\n height: ctx.parse(value.height),\n options: ctx.parse({\n colorSpace: value.colorSpace,\n }),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new ImageData(' +\n ctx.serialize(node.data) +\n ',' +\n ctx.serialize(node.width) +\n ',' +\n ctx.serialize(node.height) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new ImageData(\n ctx.deserialize(node.data) as Uint8ClampedArray,\n ctx.deserialize(node.width) as number,\n ctx.deserialize(node.height) as number,\n ctx.deserialize(node.options) as ImageDataSettings,\n );\n },\n});\n\nexport default ImageDataPlugin;\n", "import type { SerovalNode, Stream } from 'seroval';\nimport { createPlugin, createStream } from 'seroval';\n\nconst READABLE_STREAM_FACTORY = {};\n\nconst READABLE_STREAM_FACTORY_CONSTRUCTOR = (stream: Stream) =>\n new ReadableStream({\n start: controller => {\n stream.on({\n next: value => {\n try {\n controller.enqueue(value);\n } catch (_error) {\n // no-op\n }\n },\n throw: value => {\n controller.error(value);\n },\n return: () => {\n try {\n controller.close();\n } catch (_error) {\n // no-op\n }\n },\n });\n },\n });\n\nconst ReadableStreamFactoryPlugin = /* @__PURE__ */ createPlugin<\n object,\n {}\n>({\n tag: 'seroval-plugins/web/ReadableStreamFactory',\n test(value) {\n return value === READABLE_STREAM_FACTORY;\n },\n parse: {\n sync() {\n return READABLE_STREAM_FACTORY;\n },\n async async() {\n return await Promise.resolve(READABLE_STREAM_FACTORY);\n },\n stream() {\n return READABLE_STREAM_FACTORY;\n },\n },\n serialize() {\n return READABLE_STREAM_FACTORY_CONSTRUCTOR.toString();\n },\n deserialize() {\n return READABLE_STREAM_FACTORY;\n },\n});\n\nfunction toStream(value: ReadableStream): Stream {\n const stream = createStream();\n\n const reader = value.getReader();\n\n async function push(): Promise {\n try {\n const result = await reader.read();\n if (result.done) {\n stream.return(result.value);\n } else {\n stream.next(result.value);\n await push();\n }\n } catch (error) {\n stream.throw(error);\n }\n }\n\n push().catch(() => {\n //\n });\n\n return stream;\n}\n\ntype ReadableStreamNode = {\n factory: SerovalNode;\n stream: SerovalNode;\n};\n\nconst ReadableStreamPlugin = /* @__PURE__ */ createPlugin<\n ReadableStream,\n ReadableStreamNode\n>({\n tag: 'seroval/plugins/web/ReadableStream',\n extends: [ReadableStreamFactoryPlugin],\n test(value) {\n if (typeof ReadableStream === 'undefined') {\n return false;\n }\n return value instanceof ReadableStream;\n },\n parse: {\n sync(_value, ctx) {\n return {\n factory: ctx.parse(READABLE_STREAM_FACTORY),\n stream: ctx.parse(createStream()),\n };\n },\n async async(value, ctx) {\n return {\n factory: await ctx.parse(READABLE_STREAM_FACTORY),\n stream: await ctx.parse(toStream(value)),\n };\n },\n stream(value, ctx) {\n return {\n factory: ctx.parse(READABLE_STREAM_FACTORY),\n stream: ctx.parse(toStream(value)),\n };\n },\n },\n serialize(node, ctx) {\n return (\n '(' +\n ctx.serialize(node.factory) +\n ')(' +\n ctx.serialize(node.stream) +\n ')'\n );\n },\n deserialize(node, ctx) {\n const stream = ctx.deserialize(node.stream) as Stream;\n return READABLE_STREAM_FACTORY_CONSTRUCTOR(stream);\n },\n});\n\nexport default ReadableStreamPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\nimport HeadersPlugin from './headers';\nimport ReadableStreamPlugin from './readable-stream';\n\nfunction createRequestOptions(\n current: Request,\n body: ArrayBuffer | ReadableStream | null,\n): RequestInit {\n return {\n body,\n cache: current.cache,\n credentials: current.credentials,\n headers: current.headers,\n integrity: current.integrity,\n keepalive: current.keepalive,\n method: current.method,\n mode: current.mode,\n redirect: current.redirect,\n referrer: current.referrer,\n referrerPolicy: current.referrerPolicy,\n };\n}\n\ntype RequestNode = {\n url: SerovalNode;\n options: SerovalNode;\n};\n\nconst RequestPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/Request',\n extends: [ReadableStreamPlugin, HeadersPlugin],\n test(value) {\n if (typeof Request === 'undefined') {\n return false;\n }\n return value instanceof Request;\n },\n parse: {\n async async(value, ctx) {\n return {\n url: await ctx.parse(value.url),\n options: await ctx.parse(\n createRequestOptions(\n value,\n value.body && !value.bodyUsed\n ? await value.clone().arrayBuffer()\n : null,\n ),\n ),\n };\n },\n stream(value, ctx) {\n return {\n url: ctx.parse(value.url),\n options: ctx.parse(\n createRequestOptions(\n value,\n value.body && !value.bodyUsed ? value.clone().body : null,\n ),\n ),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new Request(' +\n ctx.serialize(node.url) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new Request(\n ctx.deserialize(node.url) as string,\n ctx.deserialize(node.options) as RequestInit,\n );\n },\n});\n\nexport default RequestPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\nimport HeadersPlugin from './headers';\nimport ReadableStreamPlugin from './readable-stream';\n\nfunction createResponseOptions(current: Response): ResponseInit {\n return {\n headers: current.headers,\n status: current.status,\n statusText: current.statusText,\n };\n}\n\ntype ResponseNode = {\n body: SerovalNode;\n options: SerovalNode;\n};\n\nconst ResponsePlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/Response',\n extends: [ReadableStreamPlugin, HeadersPlugin],\n test(value) {\n if (typeof Response === 'undefined') {\n return false;\n }\n return value instanceof Response;\n },\n parse: {\n async async(value, ctx) {\n return {\n body: await ctx.parse(\n value.body && !value.bodyUsed\n ? await value.clone().arrayBuffer()\n : null,\n ),\n options: await ctx.parse(createResponseOptions(value)),\n };\n },\n stream(value, ctx) {\n return {\n body: ctx.parse(\n value.body && !value.bodyUsed ? value.clone().body : null,\n ),\n options: ctx.parse(createResponseOptions(value)),\n };\n },\n },\n serialize(node, ctx) {\n return (\n 'new Response(' +\n ctx.serialize(node.body) +\n ',' +\n ctx.serialize(node.options) +\n ')'\n );\n },\n deserialize(node, ctx) {\n return new Response(\n ctx.deserialize(node.body) as BodyInit,\n ctx.deserialize(node.options) as ResponseInit,\n );\n },\n});\n\nexport default ResponsePlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nconst URLPlugin = /* @__PURE__ */ createPlugin({\n tag: 'seroval-plugins/web/URL',\n test(value) {\n if (typeof URL === 'undefined') {\n return false;\n }\n return value instanceof URL;\n },\n parse: {\n sync(value, ctx) {\n return {\n value: ctx.parse(value.href),\n };\n },\n async async(value, ctx) {\n return {\n value: await ctx.parse(value.href),\n };\n },\n stream(value, ctx) {\n return {\n value: ctx.parse(value.href),\n };\n },\n },\n serialize(node, ctx) {\n return 'new URL(' + ctx.serialize(node.value) + ')';\n },\n deserialize(node, ctx) {\n return new URL(ctx.deserialize(node.value) as string);\n },\n});\n\nexport default URLPlugin;\n", "import type { SerovalNode } from 'seroval';\nimport { createPlugin } from 'seroval';\n\nconst URLSearchParamsPlugin = /* @__PURE__ */ createPlugin<\n URLSearchParams,\n { value: SerovalNode }\n>({\n tag: 'seroval-plugins/web/URLSearchParams',\n test(value) {\n if (typeof URLSearchParams === 'undefined') {\n return false;\n }\n return value instanceof URLSearchParams;\n },\n parse: {\n sync(value, ctx) {\n return {\n value: ctx.parse(value.toString()),\n };\n },\n async async(value, ctx) {\n return {\n value: await ctx.parse(value.toString()),\n };\n },\n stream(value, ctx) {\n return {\n value: ctx.parse(value.toString()),\n };\n },\n },\n serialize(node, ctx) {\n return 'new URLSearchParams(' + ctx.serialize(node.value) + ')';\n },\n deserialize(node, ctx) {\n return new URLSearchParams(ctx.deserialize(node.value) as string);\n },\n});\n\nexport default URLSearchParamsPlugin;\n", "import { createPlugin } from 'seroval'\nimport type { SerovalNode } from 'seroval'\n\nexport interface ErrorNode {\n message: SerovalNode\n}\n\n/**\n * this plugin serializes only the `message` part of an Error\n * this helps with serializing e.g. a ZodError which has functions attached that cannot be serialized\n */\nexport const ShallowErrorPlugin = /* @__PURE__ */ createPlugin<\n Error,\n ErrorNode\n>({\n tag: '$TSR/Error',\n test(value) {\n return value instanceof Error\n },\n parse: {\n sync(value, ctx) {\n return {\n message: ctx.parse(value.message),\n }\n },\n async async(value, ctx) {\n return {\n message: await ctx.parse(value.message),\n }\n },\n stream(value, ctx) {\n return {\n message: ctx.parse(value.message),\n }\n },\n },\n serialize(node, ctx) {\n return 'new Error(' + ctx.serialize(node.message) + ')'\n },\n deserialize(node, ctx) {\n return new Error(ctx.deserialize(node.message))\n },\n})\n", "import { createPlugin, createStream } from 'seroval'\nimport type { Plugin } from 'seroval'\n\n/**\n * Hint for RawStream encoding strategy during SSR serialization.\n * - 'binary': Always use base64 encoding (best for binary data like files, images)\n * - 'text': Try UTF-8 first, fallback to base64 (best for text-heavy data like RSC payloads)\n */\nexport type RawStreamHint = 'binary' | 'text'\n\n/**\n * Options for RawStream configuration.\n */\nexport interface RawStreamOptions {\n /**\n * Encoding hint for SSR serialization.\n * - 'binary' (default): Always use base64 encoding\n * - 'text': Try UTF-8 first, fallback to base64 for invalid UTF-8 chunks\n */\n hint?: RawStreamHint\n}\n\n/**\n * Marker class for ReadableStream that should be serialized\n * with base64 encoding (SSR) or binary framing (server functions).\n *\n * Wrap your binary streams with this to get efficient serialization:\n * ```ts\n * // For binary data (files, images, etc.)\n * return { data: new RawStream(file.stream()) }\n *\n * // For text-heavy data (RSC payloads, etc.)\n * return { data: new RawStream(rscStream, { hint: 'text' }) }\n * ```\n */\nexport class RawStream {\n public readonly hint: RawStreamHint\n\n constructor(\n public readonly stream: ReadableStream,\n options?: RawStreamOptions,\n ) {\n this.hint = options?.hint ?? 'binary'\n }\n}\n\n/**\n * Callback type for RPC plugin to register raw streams with multiplexer\n */\nexport type OnRawStreamCallback = (\n streamId: number,\n stream: ReadableStream,\n) => void\n\n// Base64 helpers used in both Node and browser.\n// In Node-like runtimes, prefer Buffer for speed and compatibility.\nconst BufferCtor: any = (globalThis as any).Buffer\nconst hasNodeBuffer = !!BufferCtor && typeof BufferCtor.from === 'function'\n\nfunction uint8ArrayToBase64(bytes: Uint8Array): string {\n if (bytes.length === 0) return ''\n\n if (hasNodeBuffer) {\n return BufferCtor.from(bytes).toString('base64')\n }\n\n // Browser fallback: chunked String.fromCharCode + btoa\n const CHUNK_SIZE = 0x8000 // 32KB chunks to avoid stack overflow\n const chunks: Array = []\n for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {\n const chunk = bytes.subarray(i, i + CHUNK_SIZE)\n chunks.push(String.fromCharCode.apply(null, chunk as any))\n }\n return btoa(chunks.join(''))\n}\n\nfunction base64ToUint8Array(base64: string): Uint8Array {\n if (base64.length === 0) return new Uint8Array(0)\n\n if (hasNodeBuffer) {\n const buf = BufferCtor.from(base64, 'base64')\n return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength)\n }\n\n const binary = atob(base64)\n const bytes = new Uint8Array(binary.length)\n for (let i = 0; i < binary.length; i++) {\n bytes[i] = binary.charCodeAt(i)\n }\n return bytes\n}\n\n// Factory sentinels - use null-proto objects to avoid prototype surprises\nconst RAW_STREAM_FACTORY_BINARY: Record = Object.create(null)\nconst RAW_STREAM_FACTORY_TEXT: Record = Object.create(null)\n\n// Factory constructor for binary mode - converts seroval stream to ReadableStream\n// All chunks are base64 encoded strings\nconst RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY = (\n stream: ReturnType,\n) =>\n new ReadableStream({\n start(controller) {\n stream.on({\n next(base64: string) {\n try {\n controller.enqueue(base64ToUint8Array(base64))\n } catch {\n // Stream may be closed\n }\n },\n throw(error: unknown) {\n controller.error(error)\n },\n return() {\n try {\n controller.close()\n } catch {\n // Stream may already be closed\n }\n },\n })\n },\n })\n\n// Factory constructor for text mode - converts seroval stream to ReadableStream\n// Chunks are either strings (UTF-8) or { $b64: string } (base64 fallback)\n// Use module-level TextEncoder to avoid per-factory allocation\nconst textEncoderForFactory = new TextEncoder()\nconst RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT = (\n stream: ReturnType,\n) => {\n return new ReadableStream({\n start(controller) {\n stream.on({\n next(value: string | { $b64: string }) {\n try {\n if (typeof value === 'string') {\n controller.enqueue(textEncoderForFactory.encode(value))\n } else {\n controller.enqueue(base64ToUint8Array(value.$b64))\n }\n } catch {\n // Stream may be closed\n }\n },\n throw(error: unknown) {\n controller.error(error)\n },\n return() {\n try {\n controller.close()\n } catch {\n // Stream may already be closed\n }\n },\n })\n },\n })\n}\n\n// Minified factory function for binary mode - all chunks are base64 strings\n// This must be self-contained since it's injected into the HTML\nconst FACTORY_BINARY = `(s=>new ReadableStream({start(c){s.on({next(b){try{const d=atob(b),a=new Uint8Array(d.length);for(let i=0;i{const e=new TextEncoder();return new ReadableStream({start(c){s.on({next(v){try{if(typeof v==='string'){c.enqueue(e.encode(v))}else{const d=atob(v.$b64),a=new Uint8Array(d.length);for(let i=0;i to seroval stream with base64-encoded chunks (binary mode)\nfunction toBinaryStream(readable: ReadableStream) {\n const stream = createStream()\n const reader = readable.getReader()\n\n // Use iterative loop instead of recursive async to avoid stack accumulation\n ;(async () => {\n try {\n while (true) {\n const { done, value } = await reader.read()\n if (done) {\n stream.return(undefined)\n break\n }\n stream.next(uint8ArrayToBase64(value))\n }\n } catch (error) {\n stream.throw(error)\n } finally {\n reader.releaseLock()\n }\n })()\n\n return stream\n}\n\n// Convert ReadableStream to seroval stream with UTF-8 first, base64 fallback (text mode)\nfunction toTextStream(readable: ReadableStream) {\n const stream = createStream()\n const reader = readable.getReader()\n const decoder = new TextDecoder('utf-8', { fatal: true })\n\n // Use iterative loop instead of recursive async to avoid stack accumulation\n ;(async () => {\n try {\n while (true) {\n const { done, value } = await reader.read()\n if (done) {\n // Flush any remaining bytes in the decoder\n try {\n const remaining = decoder.decode()\n if (remaining.length > 0) {\n stream.next(remaining)\n }\n } catch {\n // Ignore decode errors on flush\n }\n stream.return(undefined)\n break\n }\n\n try {\n // Try UTF-8 decode first\n const text = decoder.decode(value, { stream: true })\n if (text.length > 0) {\n stream.next(text)\n }\n } catch {\n // UTF-8 decode failed, fallback to base64\n stream.next({ $b64: uint8ArrayToBase64(value) })\n }\n }\n } catch (error) {\n stream.throw(error)\n } finally {\n reader.releaseLock()\n }\n })()\n\n return stream\n}\n\n// Factory plugin for binary mode\nconst RawStreamFactoryBinaryPlugin = createPlugin<\n Record,\n undefined\n>({\n tag: 'tss/RawStreamFactory',\n test(value) {\n return value === RAW_STREAM_FACTORY_BINARY\n },\n parse: {\n sync() {\n return undefined\n },\n async() {\n return Promise.resolve(undefined)\n },\n stream() {\n return undefined\n },\n },\n serialize() {\n return FACTORY_BINARY\n },\n deserialize() {\n return RAW_STREAM_FACTORY_BINARY\n },\n})\n\n// Factory plugin for text mode\nconst RawStreamFactoryTextPlugin = createPlugin<\n Record,\n undefined\n>({\n tag: 'tss/RawStreamFactoryText',\n test(value) {\n return value === RAW_STREAM_FACTORY_TEXT\n },\n parse: {\n sync() {\n return undefined\n },\n async() {\n return Promise.resolve(undefined)\n },\n stream() {\n return undefined\n },\n },\n serialize() {\n return FACTORY_TEXT\n },\n deserialize() {\n return RAW_STREAM_FACTORY_TEXT\n },\n})\n\n/**\n * SSR Plugin - uses base64 or UTF-8+base64 encoding for chunks, delegates to seroval's stream mechanism.\n * Used during SSR when serializing to JavaScript code for HTML injection.\n *\n * Supports two modes based on RawStream hint:\n * - 'binary': Always base64 encode (default)\n * - 'text': Try UTF-8 first, fallback to base64 for invalid UTF-8\n */\nexport const RawStreamSSRPlugin: Plugin = createPlugin({\n tag: 'tss/RawStream',\n extends: [RawStreamFactoryBinaryPlugin, RawStreamFactoryTextPlugin],\n\n test(value: unknown) {\n return value instanceof RawStream\n },\n\n parse: {\n sync(value: RawStream, ctx) {\n // Sync parse not really supported for streams, return empty stream\n const factory =\n value.hint === 'text'\n ? RAW_STREAM_FACTORY_TEXT\n : RAW_STREAM_FACTORY_BINARY\n return {\n hint: value.hint,\n factory: ctx.parse(factory),\n stream: ctx.parse(createStream()),\n }\n },\n async async(value: RawStream, ctx) {\n const factory =\n value.hint === 'text'\n ? RAW_STREAM_FACTORY_TEXT\n : RAW_STREAM_FACTORY_BINARY\n const encodedStream =\n value.hint === 'text'\n ? toTextStream(value.stream)\n : toBinaryStream(value.stream)\n return {\n hint: value.hint,\n factory: await ctx.parse(factory),\n stream: await ctx.parse(encodedStream),\n }\n },\n stream(value: RawStream, ctx) {\n const factory =\n value.hint === 'text'\n ? RAW_STREAM_FACTORY_TEXT\n : RAW_STREAM_FACTORY_BINARY\n const encodedStream =\n value.hint === 'text'\n ? toTextStream(value.stream)\n : toBinaryStream(value.stream)\n return {\n hint: value.hint,\n factory: ctx.parse(factory),\n stream: ctx.parse(encodedStream),\n }\n },\n },\n\n serialize(node: { hint: RawStreamHint; factory: any; stream: any }, ctx) {\n return (\n '(' +\n ctx.serialize(node.factory) +\n ')(' +\n ctx.serialize(node.stream) +\n ')'\n )\n },\n\n deserialize(\n node: { hint: RawStreamHint; factory: any; stream: any },\n ctx,\n ): any {\n const stream: ReturnType = ctx.deserialize(node.stream)\n return node.hint === 'text'\n ? RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT(stream)\n : RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY(stream)\n },\n}) as Plugin\n\n/**\n * Node type for RPC plugin serialization\n */\ninterface RawStreamRPCNode {\n streamId: number\n}\n\n/**\n * Creates an RPC plugin instance that registers raw streams with a multiplexer.\n * Used for server function responses where we want binary framing.\n * Note: RPC always uses binary framing regardless of hint.\n *\n * @param onRawStream Callback invoked when a RawStream is encountered during serialization\n */\nexport function createRawStreamRPCPlugin(\n onRawStream: OnRawStreamCallback,\n): Plugin {\n // Own stream counter - sequential IDs starting at 1, independent of seroval internals\n let nextStreamId = 1\n\n return createPlugin({\n tag: 'tss/RawStream',\n\n test(value: unknown) {\n return value instanceof RawStream\n },\n\n parse: {\n async(value: RawStream) {\n const streamId = nextStreamId++\n onRawStream(streamId, value.stream)\n return Promise.resolve({ streamId })\n },\n stream(value: RawStream) {\n const streamId = nextStreamId++\n onRawStream(streamId, value.stream)\n return { streamId }\n },\n },\n\n serialize(): never {\n // RPC uses toCrossJSONStream which produces JSON nodes, not JS code.\n // This method is only called by crossSerialize* which we don't use.\n throw new Error(\n 'RawStreamRPCPlugin.serialize should not be called. RPC uses JSON serialization, not JS code generation.',\n )\n },\n\n deserialize(): never {\n // Client uses createRawStreamDeserializePlugin instead\n throw new Error(\n 'RawStreamRPCPlugin.deserialize should not be called. Use createRawStreamDeserializePlugin on client.',\n )\n },\n }) as Plugin\n}\n\n/**\n * Creates a deserialize-only plugin for client-side stream reconstruction.\n * Used in serverFnFetcher to wire up streams from frame decoder.\n *\n * @param getOrCreateStream Function to get/create a stream by ID from frame decoder\n */\nexport function createRawStreamDeserializePlugin(\n getOrCreateStream: (id: number) => ReadableStream,\n): Plugin {\n return createPlugin({\n tag: 'tss/RawStream',\n\n test: () => false, // Client never serializes RawStream\n\n parse: {}, // Client only deserializes, never parses\n\n serialize(): never {\n // Client never serializes RawStream back to server\n throw new Error(\n 'RawStreamDeserializePlugin.serialize should not be called. Client only deserializes.',\n )\n },\n\n deserialize(node: RawStreamRPCNode) {\n return getOrCreateStream(node.streamId)\n },\n }) as Plugin\n}\n", "import * as React from 'react'\n\n// Safe version of React.use() that will not cause compilation errors against\n// React 18 with Webpack, which statically analyzes imports and fails when it\n// sees React.use referenced (since 'use' is not exported from React 18).\n// This uses a dynamic string lookup to avoid the static analysis.\nconst REACT_USE = 'use'\n\n/**\n * React.use if available (React 19+), undefined otherwise.\n * Use dynamic lookup to avoid Webpack compilation errors with React 18.\n */\nexport const reactUse:\n | ((usable: Promise | React.Context) => T)\n | undefined = (React as any)[REACT_USE]\n\nexport function useStableCallback) => any>(\n fn: T,\n): T {\n const fnRef = React.useRef(fn)\n fnRef.current = fn\n\n const ref = React.useRef((...args: Array) => fnRef.current(...args))\n return ref.current as T\n}\n\nexport const useLayoutEffect =\n typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\n/**\n * Taken from https://www.developerway.com/posts/implementing-advanced-use-previous-hook#part3\n */\nexport function usePrevious(value: T): T | null {\n // initialise the ref with previous and current values\n const ref = React.useRef<{ value: T; prev: T | null }>({\n value: value,\n prev: null,\n })\n\n const current = ref.current.value\n\n // if the value passed into hook doesn't match what we store as \"current\"\n // move the \"current\" to the \"previous\"\n // and store the passed value as \"current\"\n if (value !== current) {\n ref.current = {\n value: value,\n prev: current,\n }\n }\n\n // return the previous value only\n return ref.current.prev\n}\n\n/**\n * React hook to wrap `IntersectionObserver`.\n *\n * This hook will create an `IntersectionObserver` and observe the ref passed to it.\n *\n * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.\n *\n * @param ref - The ref to observe\n * @param intersectionObserverOptions - The options to pass to the IntersectionObserver\n * @param options - The options to pass to the hook\n * @param callback - The callback to call when the intersection changes\n * @returns The IntersectionObserver instance\n * @example\n * ```tsx\n * const MyComponent = () => {\n * const ref = React.useRef(null)\n * useIntersectionObserver(\n * ref,\n * (entry) => { doSomething(entry) },\n * { rootMargin: '10px' },\n * { disabled: false }\n * )\n * return
\n * ```\n */\nexport function useIntersectionObserver(\n ref: React.RefObject,\n callback: (entry: IntersectionObserverEntry | undefined) => void,\n intersectionObserverOptions: IntersectionObserverInit = {},\n options: { disabled?: boolean } = {},\n) {\n React.useEffect(() => {\n if (\n !ref.current ||\n options.disabled ||\n typeof IntersectionObserver !== 'function'\n ) {\n return\n }\n\n const observer = new IntersectionObserver(([entry]) => {\n callback(entry)\n }, intersectionObserverOptions)\n\n observer.observe(ref.current)\n\n return () => {\n observer.disconnect()\n }\n }, [callback, intersectionObserverOptions, options.disabled, ref])\n}\n\n/**\n * React hook to take a `React.ForwardedRef` and returns a `ref` that can be used on a DOM element.\n *\n * @param ref - The forwarded ref\n * @returns The inner ref returned by `useRef`\n * @example\n * ```tsx\n * const MyComponent = React.forwardRef((props, ref) => {\n * const innerRef = useForwardedRef(ref)\n * return
\n * })\n * ```\n */\nexport function useForwardedRef(ref?: React.ForwardedRef) {\n const innerRef = React.useRef(null)\n React.useImperativeHandle(ref, () => innerRef.current!, [])\n return innerRef\n}\n", "import * as React from 'react'\n\nimport { TSR_DEFERRED_PROMISE, defer } from '@tanstack/router-core'\nimport { reactUse } from './utils'\n\nexport type AwaitOptions = {\n promise: Promise\n}\n\n/** Suspend until a deferred promise resolves or rejects and return its data. */\nexport function useAwaited({ promise: _promise }: AwaitOptions): T {\n if (reactUse) {\n const data = reactUse(_promise)\n return data\n }\n const promise = defer(_promise)\n\n if (promise[TSR_DEFERRED_PROMISE].status === 'pending') {\n throw promise\n }\n\n if (promise[TSR_DEFERRED_PROMISE].status === 'error') {\n throw promise[TSR_DEFERRED_PROMISE].error\n }\n\n return promise[TSR_DEFERRED_PROMISE].data\n}\n\n/**\n * Component that suspends on a deferred promise and renders its child with\n * the resolved value. Optionally provides a Suspense fallback.\n */\nexport function Await(\n props: AwaitOptions & {\n fallback?: React.ReactNode\n children: (result: T) => React.ReactNode\n },\n) {\n const inner = \n if (props.fallback) {\n return {inner}\n }\n return inner\n}\n\nfunction AwaitInner(\n props: AwaitOptions & {\n fallback?: React.ReactNode\n children: (result: T) => React.ReactNode\n },\n): React.JSX.Element {\n const data = useAwaited(props)\n\n return props.children(data) as React.JSX.Element\n}\n", "import * as React from 'react'\nimport type { ErrorRouteComponent } from './route'\nimport type { ErrorInfo } from 'react'\n\nexport function CatchBoundary(props: {\n getResetKey: () => number | string\n children: React.ReactNode\n errorComponent?: ErrorRouteComponent\n onCatch?: (error: Error, errorInfo: ErrorInfo) => void\n}) {\n const errorComponent = props.errorComponent ?? ErrorComponent\n\n return (\n {\n if (error) {\n return React.createElement(errorComponent, {\n error,\n reset,\n })\n }\n\n return props.children\n }}\n />\n )\n}\n\nclass CatchBoundaryImpl extends React.Component<{\n getResetKey: () => number | string\n children: (props: {\n error: Error | null\n reset: () => void\n }) => React.ReactNode\n onCatch?: (error: Error, errorInfo: ErrorInfo) => void\n}> {\n state = { error: null } as { error: Error | null; resetKey: string }\n static getDerivedStateFromProps(props: any) {\n return { resetKey: props.getResetKey() }\n }\n static getDerivedStateFromError(error: Error) {\n return { error }\n }\n reset() {\n this.setState({ error: null })\n }\n componentDidUpdate(\n prevProps: Readonly<{\n getResetKey: () => string\n children: (props: { error: any; reset: () => void }) => any\n onCatch?: ((error: any, info: any) => void) | undefined\n }>,\n prevState: any,\n ): void {\n if (prevState.error && prevState.resetKey !== this.state.resetKey) {\n this.reset()\n }\n }\n componentDidCatch(error: Error, errorInfo: ErrorInfo) {\n if (this.props.onCatch) {\n this.props.onCatch(error, errorInfo)\n }\n }\n render() {\n // If the resetKey has changed, don't render the error\n return this.props.children({\n error:\n this.state.resetKey !== this.props.getResetKey()\n ? null\n : this.state.error,\n reset: () => {\n this.reset()\n },\n })\n }\n}\n\nexport function ErrorComponent({ error }: { error: any }) {\n const [show, setShow] = React.useState(process.env.NODE_ENV !== 'production')\n\n return (\n
\n
\n Something went wrong!\n setShow((d) => !d)}\n >\n {show ? 'Hide Error' : 'Show Error'}\n \n
\n
\n {show ? (\n
\n \n {error.message ? {error.message} : null}\n \n
\n ) : null}\n
\n )\n}\n", "import React from 'react'\n\nexport interface ClientOnlyProps {\n /**\n * The children to render when the JS is loaded.\n */\n children: React.ReactNode\n /**\n * The fallback component to render if the JS is not yet loaded.\n */\n fallback?: React.ReactNode\n}\n\n/**\n * Render the children only after the JS has loaded client-side. Use an optional\n * fallback component if the JS is not yet loaded.\n *\n * @example\n * Render a Chart component if JS loads, renders a simple FakeChart\n * component server-side or if there is no JS. The FakeChart can have only the\n * UI without the behavior or be a loading spinner or skeleton.\n *\n * ```tsx\n * return (\n * }>\n * \n * \n * )\n * ```\n */\nexport function ClientOnly({ children, fallback = null }: ClientOnlyProps) {\n return useHydrated() ? (\n {children}\n ) : (\n {fallback}\n )\n}\n\n/**\n * Return a boolean indicating if the JS has been hydrated already.\n * When doing Server-Side Rendering, the result will always be false.\n * When doing Client-Side Rendering, the result will always be false on the\n * first render and true from then on. Even if a new component renders it will\n * always start with true.\n *\n * @example\n * ```tsx\n * // Disable a button that needs JS to work.\n * let hydrated = useHydrated()\n * return (\n * \n * )\n * ```\n * @returns True if the JS has been hydrated already, false otherwise.\n */\nexport function useHydrated(): boolean {\n return React.useSyncExternalStore(\n subscribe,\n () => true,\n () => false,\n )\n}\n\nfunction subscribe() {\n return () => {}\n}\n", "var isProduction = process.env.NODE_ENV === 'production';\nfunction warning(condition, message) {\n if (!isProduction) {\n if (condition) {\n return;\n }\n\n var text = \"Warning: \" + message;\n\n if (typeof console !== 'undefined') {\n console.warn(text);\n }\n\n try {\n throw Error(text);\n } catch (x) {}\n }\n}\n\nexport default warning;\n", "import { useCallback } from 'react'\nimport { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector'\nimport type { AnyAtom } from '@tanstack/store'\n\ntype SyncExternalStoreSubscribe = Parameters<\n typeof useSyncExternalStoreWithSelector\n>[0]\n\nfunction defaultCompare(a: T, b: T) {\n return a === b\n}\n\nexport function useStore(\n atom: TAtom,\n selector: (\n snapshot: TAtom extends { get: () => infer TSnapshot }\n ? TSnapshot\n : undefined,\n ) => T,\n compare: (a: T, b: T) => boolean = defaultCompare,\n): T {\n const subscribe: SyncExternalStoreSubscribe = useCallback(\n (handleStoreChange) => {\n if (!atom) {\n return () => {}\n }\n const { unsubscribe } = atom.subscribe(handleStoreChange)\n return unsubscribe\n },\n [atom],\n )\n\n const boundGetSnapshot = useCallback(() => atom?.get(), [atom])\n\n const selectedSnapshot = useSyncExternalStoreWithSelector(\n subscribe,\n boundGetSnapshot,\n boundGetSnapshot,\n selector,\n compare,\n )\n\n return selectedSnapshot\n}\n", "import * as React from 'react'\nimport type { AnyRouter } from '@tanstack/router-core'\n\nexport const routerContext = React.createContext(null!)\n", "import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { routerContext } from './routerContext'\nimport type { AnyRouter, RegisteredRouter } from '@tanstack/router-core'\n\n/**\n * Access the current TanStack Router instance from React context.\n * Must be used within a `RouterProvider`.\n *\n * Options:\n * - `warn`: Log a warning if no router context is found (default: true).\n *\n * @returns The registered router instance.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useRouterHook\n */\nexport function useRouter(opts?: {\n warn?: boolean\n}): TRouter {\n const value = React.useContext(routerContext)\n warning(\n !((opts?.warn ?? true) && !value),\n 'useRouter must be used inside a component!',\n )\n return value as any\n}\n", "import { useStore } from '@tanstack/react-store'\nimport { useRef } from 'react'\nimport { replaceEqualDeep } from '@tanstack/router-core'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { useRouter } from './useRouter'\nimport type {\n AnyRouter,\n RegisteredRouter,\n RouterState,\n} from '@tanstack/router-core'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\n\nexport type UseRouterStateOptions<\n TRouter extends AnyRouter,\n TSelected,\n TStructuralSharing,\n> = {\n router?: TRouter\n select?: (\n state: RouterState,\n ) => ValidateSelected\n} & StructuralSharingOption\n\nexport type UseRouterStateResult<\n TRouter extends AnyRouter,\n TSelected,\n> = unknown extends TSelected ? RouterState : TSelected\n\n/**\n * Subscribe to the router's state store with optional selection and\n * structural sharing for render optimization.\n *\n * Options:\n * - `select`: Project the full router state to a derived slice\n * - `structuralSharing`: Replace-equal semantics for stable references\n * - `router`: Read state from a specific router instance instead of context\n *\n * @returns The selected router state (or the full state by default).\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useRouterStateHook\n */\nexport function useRouterState<\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseRouterStateOptions,\n): UseRouterStateResult {\n const contextRouter = useRouter({\n warn: opts?.router === undefined,\n })\n const router = opts?.router || contextRouter\n\n // During SSR we render exactly once and do not need reactivity.\n // Avoid subscribing to the store (and any structural sharing work) on the server.\n const _isServer = isServer ?? router.isServer\n if (_isServer) {\n const state = router.state as RouterState\n return (opts?.select ? opts.select(state) : state) as UseRouterStateResult<\n TRouter,\n TSelected\n >\n }\n\n const previousResult =\n // eslint-disable-next-line react-hooks/rules-of-hooks\n useRef>(undefined)\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n return useStore(router.__store, (state) => {\n if (opts?.select) {\n if (opts.structuralSharing ?? router.options.defaultStructuralSharing) {\n const newSlice = replaceEqualDeep(\n previousResult.current,\n opts.select(state),\n )\n previousResult.current = newSlice\n return newSlice\n }\n return opts.select(state)\n }\n return state\n }) as UseRouterStateResult\n}\n", "import * as React from 'react'\n\nexport const matchContext = React.createContext(undefined)\n\n// N.B. this only exists so we can conditionally call useContext on it when we are not interested in the nearest match\nexport const dummyMatchContext = React.createContext(\n undefined,\n)\n", "import * as React from 'react'\nimport invariant from 'tiny-invariant'\nimport { useRouterState } from './useRouterState'\nimport { dummyMatchContext, matchContext } from './matchContext'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n MakeRouteMatch,\n MakeRouteMatchUnion,\n RegisteredRouter,\n StrictOrFrom,\n ThrowConstraint,\n ThrowOrOptional,\n} from '@tanstack/router-core'\n\nexport interface UseMatchBaseOptions<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing extends boolean,\n> {\n select?: (\n match: MakeRouteMatch,\n ) => ValidateSelected\n shouldThrow?: TThrow\n}\n\nexport type UseMatchRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseMatchBaseOptions<\n TRouter,\n TFrom,\n true,\n true,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption,\n) => UseMatchResult\n\nexport type UseMatchOptions<\n TRouter extends AnyRouter,\n TFrom extends string | undefined,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing extends boolean,\n> = StrictOrFrom &\n UseMatchBaseOptions<\n TRouter,\n TFrom,\n TStrict,\n TThrow,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption\n\nexport type UseMatchResult<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TSelected,\n> = unknown extends TSelected\n ? TStrict extends true\n ? MakeRouteMatch\n : MakeRouteMatchUnion\n : TSelected\n\n/**\n * Read and select the nearest or targeted route match.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useMatchHook\n */\nexport function useMatch<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TStrict extends boolean = true,\n TThrow extends boolean = true,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts: UseMatchOptions<\n TRouter,\n TFrom,\n TStrict,\n ThrowConstraint,\n TSelected,\n TStructuralSharing\n >,\n): ThrowOrOptional, TThrow> {\n const nearestMatchId = React.useContext(\n opts.from ? dummyMatchContext : matchContext,\n )\n\n const matchSelection = useRouterState({\n select: (state: any) => {\n const match = state.matches.find((d: any) =>\n opts.from ? opts.from === d.routeId : d.id === nearestMatchId,\n )\n invariant(\n !((opts.shouldThrow ?? true) && !match),\n `Could not find ${opts.from ? `an active match from \"${opts.from}\"` : 'a nearest match!'}`,\n )\n\n if (match === undefined) {\n return undefined\n }\n\n return opts.select ? opts.select(match) : match\n },\n structuralSharing: opts.structuralSharing,\n } as any)\n\n return matchSelection as any\n}\n", "import { useMatch } from './useMatch'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n RegisteredRouter,\n ResolveUseLoaderData,\n StrictOrFrom,\n UseLoaderDataResult,\n} from '@tanstack/router-core'\n\nexport interface UseLoaderDataBaseOptions<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TSelected,\n TStructuralSharing,\n> {\n select?: (\n match: ResolveUseLoaderData,\n ) => ValidateSelected\n}\n\nexport type UseLoaderDataOptions<\n TRouter extends AnyRouter,\n TFrom extends string | undefined,\n TStrict extends boolean,\n TSelected,\n TStructuralSharing,\n> = StrictOrFrom &\n UseLoaderDataBaseOptions<\n TRouter,\n TFrom,\n TStrict,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption\n\nexport type UseLoaderDataRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseLoaderDataBaseOptions<\n TRouter,\n TId,\n true,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption,\n) => UseLoaderDataResult\n\n/**\n * Read and select the current route's loader data with type‑safety.\n *\n * Options:\n * - `from`/`strict`: Choose which route's data to read and strictness\n * - `select`: Map the loader data to a derived value\n * - `structuralSharing`: Enable structural sharing for stable references\n *\n * @returns The loader data (or selected value) for the matched route.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useLoaderDataHook\n */\nexport function useLoaderData<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TStrict extends boolean = true,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts: UseLoaderDataOptions<\n TRouter,\n TFrom,\n TStrict,\n TSelected,\n TStructuralSharing\n >,\n): UseLoaderDataResult {\n return useMatch({\n from: opts.from!,\n strict: opts.strict,\n structuralSharing: opts.structuralSharing,\n select: (s: any) => {\n return opts.select ? opts.select(s.loaderData) : s.loaderData\n },\n } as any) as UseLoaderDataResult\n}\n", "import { useMatch } from './useMatch'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n RegisteredRouter,\n ResolveUseLoaderDeps,\n StrictOrFrom,\n UseLoaderDepsResult,\n} from '@tanstack/router-core'\n\nexport interface UseLoaderDepsBaseOptions<\n TRouter extends AnyRouter,\n TFrom,\n TSelected,\n TStructuralSharing,\n> {\n select?: (\n deps: ResolveUseLoaderDeps,\n ) => ValidateSelected\n}\n\nexport type UseLoaderDepsOptions<\n TRouter extends AnyRouter,\n TFrom extends string | undefined,\n TSelected,\n TStructuralSharing,\n> = StrictOrFrom &\n UseLoaderDepsBaseOptions &\n StructuralSharingOption\n\nexport type UseLoaderDepsRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseLoaderDepsBaseOptions &\n StructuralSharingOption,\n) => UseLoaderDepsResult\n\n/**\n * Read and select the current route's loader dependencies object.\n *\n * Options:\n * - `from`: Choose which route's loader deps to read\n * - `select`: Map the deps to a derived value\n * - `structuralSharing`: Enable structural sharing for stable references\n *\n * @returns The loader deps (or selected value) for the matched route.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useLoaderDepsHook\n */\nexport function useLoaderDeps<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts: UseLoaderDepsOptions,\n): UseLoaderDepsResult {\n const { select, ...rest } = opts\n return useMatch({\n ...rest,\n select: (s) => {\n return select ? select(s.loaderDeps) : s.loaderDeps\n },\n }) as UseLoaderDepsResult\n}\n", "import { useMatch } from './useMatch'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n RegisteredRouter,\n ResolveUseParams,\n StrictOrFrom,\n ThrowConstraint,\n ThrowOrOptional,\n UseParamsResult,\n} from '@tanstack/router-core'\n\nexport interface UseParamsBaseOptions<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing,\n> {\n select?: (\n params: ResolveUseParams,\n ) => ValidateSelected\n shouldThrow?: TThrow\n}\n\nexport type UseParamsOptions<\n TRouter extends AnyRouter,\n TFrom extends string | undefined,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing,\n> = StrictOrFrom &\n UseParamsBaseOptions<\n TRouter,\n TFrom,\n TStrict,\n TThrow,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption\n\nexport type UseParamsRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseParamsBaseOptions<\n TRouter,\n TFrom,\n /* TStrict */ true,\n /* TThrow */ true,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption,\n) => UseParamsResult\n\n/**\n * Access the current route's path parameters with type-safety.\n *\n * Options:\n * - `from`/`strict`: Specify the matched route and whether to enforce strict typing\n * - `select`: Project the params object to a derived value for memoized renders\n * - `structuralSharing`: Enable structural sharing for stable references\n * - `shouldThrow`: Throw if the route is not found in strict contexts\n *\n * @returns The params object (or selected value) for the matched route.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useParamsHook\n */\nexport function useParams<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TStrict extends boolean = true,\n TThrow extends boolean = true,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts: UseParamsOptions<\n TRouter,\n TFrom,\n TStrict,\n ThrowConstraint,\n TSelected,\n TStructuralSharing\n >,\n): ThrowOrOptional<\n UseParamsResult,\n TThrow\n> {\n return useMatch({\n from: opts.from!,\n shouldThrow: opts.shouldThrow,\n structuralSharing: opts.structuralSharing,\n strict: opts.strict,\n select: (match) => {\n const params = opts.strict === false ? match.params : match._strictParams\n\n return opts.select ? opts.select(params) : params\n },\n }) as any\n}\n", "import { useMatch } from './useMatch'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n RegisteredRouter,\n ResolveUseSearch,\n StrictOrFrom,\n ThrowConstraint,\n ThrowOrOptional,\n UseSearchResult,\n} from '@tanstack/router-core'\n\nexport interface UseSearchBaseOptions<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing,\n> {\n select?: (\n state: ResolveUseSearch,\n ) => ValidateSelected\n shouldThrow?: TThrow\n}\n\nexport type UseSearchOptions<\n TRouter extends AnyRouter,\n TFrom,\n TStrict extends boolean,\n TThrow extends boolean,\n TSelected,\n TStructuralSharing,\n> = StrictOrFrom &\n UseSearchBaseOptions<\n TRouter,\n TFrom,\n TStrict,\n TThrow,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption\n\nexport type UseSearchRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseSearchBaseOptions<\n TRouter,\n TFrom,\n /* TStrict */ true,\n /* TThrow */ true,\n TSelected,\n TStructuralSharing\n > &\n StructuralSharingOption,\n) => UseSearchResult\n\n/**\n * Read and select the current route's search parameters with type-safety.\n *\n * Options:\n * - `from`/`strict`: Control which route's search is read and how strictly it's typed\n * - `select`: Map the search object to a derived value for render optimization\n * - `structuralSharing`: Enable structural sharing for stable references\n * - `shouldThrow`: Throw when the route is not found (strict contexts)\n *\n * @returns The search object (or selected value) for the matched route.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useSearchHook\n */\nexport function useSearch<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TStrict extends boolean = true,\n TThrow extends boolean = true,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts: UseSearchOptions<\n TRouter,\n TFrom,\n TStrict,\n ThrowConstraint,\n TSelected,\n TStructuralSharing\n >,\n): ThrowOrOptional<\n UseSearchResult,\n TThrow\n> {\n return useMatch({\n from: opts.from!,\n strict: opts.strict,\n shouldThrow: opts.shouldThrow,\n structuralSharing: opts.structuralSharing,\n select: (match: any) => {\n return opts.select ? opts.select(match.search) : match.search\n },\n }) as any\n}\n", "import * as React from 'react'\nimport { useLayoutEffect } from './utils'\nimport { useRouter } from './useRouter'\nimport type {\n AnyRouter,\n FromPathOption,\n NavigateOptions,\n RegisteredRouter,\n UseNavigateResult,\n} from '@tanstack/router-core'\n\n/**\n * Imperative navigation hook.\n *\n * Returns a stable `navigate(options)` function to change the current location\n * programmatically. Prefer the `Link` component for user-initiated navigation,\n * and use this hook from effects, callbacks, or handlers where imperative\n * navigation is required.\n *\n * Options:\n * - `from`: Optional route base used to resolve relative `to` paths.\n *\n * @returns A function that accepts `NavigateOptions`.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useNavigateHook\n */\nexport function useNavigate<\n TRouter extends AnyRouter = RegisteredRouter,\n TDefaultFrom extends string = string,\n>(_defaultOpts?: {\n from?: FromPathOption\n}): UseNavigateResult {\n const router = useRouter()\n\n return React.useCallback(\n (options: NavigateOptions) => {\n return router.navigate({\n ...options,\n from: options.from ?? _defaultOpts?.from,\n })\n },\n [_defaultOpts?.from, router],\n ) as UseNavigateResult\n}\n\n/**\n * Component that triggers a navigation when rendered. Navigation executes\n * in an effect after mount/update.\n *\n * Props are the same as `NavigateOptions` used by `navigate()`.\n *\n * @returns null\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/navigateComponent\n */\nexport function Navigate<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string = string,\n const TTo extends string | undefined = undefined,\n const TMaskFrom extends string = TFrom,\n const TMaskTo extends string = '',\n>(props: NavigateOptions): null {\n const router = useRouter()\n const navigate = useNavigate()\n\n const previousPropsRef = React.useRef | null>(null)\n useLayoutEffect(() => {\n if (previousPropsRef.current !== props) {\n navigate(props)\n previousPropsRef.current = props\n }\n }, [router, props, navigate])\n return null\n}\n", "import { useMatch } from './useMatch'\nimport type {\n AnyRouter,\n RegisteredRouter,\n UseRouteContextBaseOptions,\n UseRouteContextOptions,\n UseRouteContextResult,\n} from '@tanstack/router-core'\n\nexport type UseRouteContextRoute = <\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n>(\n opts?: UseRouteContextBaseOptions,\n) => UseRouteContextResult\n\nexport function useRouteContext<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string | undefined = undefined,\n TStrict extends boolean = true,\n TSelected = unknown,\n>(\n opts: UseRouteContextOptions,\n): UseRouteContextResult {\n return useMatch({\n ...(opts as any),\n select: (match) =>\n opts.select ? opts.select(match.context) : match.context,\n }) as UseRouteContextResult\n}\n", "import * as React from 'react'\nimport { flushSync } from 'react-dom'\nimport {\n deepEqual,\n exactPathTest,\n functionalUpdate,\n isDangerousProtocol,\n preloadWarning,\n removeTrailingSlash,\n} from '@tanstack/router-core'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { useRouterState } from './useRouterState'\nimport { useRouter } from './useRouter'\n\nimport { useForwardedRef, useIntersectionObserver } from './utils'\n\nimport { useHydrated } from './ClientOnly'\nimport type {\n AnyRouter,\n Constrain,\n LinkOptions,\n RegisteredRouter,\n RoutePaths,\n} from '@tanstack/router-core'\nimport type { ReactNode } from 'react'\nimport type {\n ValidateLinkOptions,\n ValidateLinkOptionsArray,\n} from './typePrimitives'\n\n/**\n * Build anchor-like props for declarative navigation and preloading.\n *\n * Returns stable `href`, event handlers and accessibility props derived from\n * router options and active state. Used internally by `Link` and custom links.\n *\n * Options cover `to`, `params`, `search`, `hash`, `state`, `preload`,\n * `activeProps`, `inactiveProps`, and more.\n *\n * @returns React anchor props suitable for `` or custom components.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useLinkPropsHook\n */\nexport function useLinkProps<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string = string,\n const TTo extends string | undefined = undefined,\n const TMaskFrom extends string = TFrom,\n const TMaskTo extends string = '',\n>(\n options: UseLinkPropsOptions,\n forwardedRef?: React.ForwardedRef,\n): React.ComponentPropsWithRef<'a'> {\n const router = useRouter()\n const innerRef = useForwardedRef(forwardedRef)\n\n // Determine if we're on the server - used for tree-shaking client-only code\n const _isServer = isServer ?? router.isServer\n\n const {\n // custom props\n activeProps,\n inactiveProps,\n activeOptions,\n to,\n preload: userPreload,\n preloadDelay: userPreloadDelay,\n hashScrollIntoView,\n replace,\n startTransition,\n resetScroll,\n viewTransition,\n // element props\n children,\n target,\n disabled,\n style,\n className,\n onClick,\n onBlur,\n onFocus,\n onMouseEnter,\n onMouseLeave,\n onTouchStart,\n ignoreBlocker,\n // prevent these from being returned\n params: _params,\n search: _search,\n hash: _hash,\n state: _state,\n mask: _mask,\n reloadDocument: _reloadDocument,\n unsafeRelative: _unsafeRelative,\n from: _from,\n _fromLocation,\n ...propsSafeToSpread\n } = options\n\n // ==========================================================================\n // SERVER EARLY RETURN\n // On the server, we return static props without any event handlers,\n // effects, or client-side interactivity.\n //\n // For SSR parity (to avoid hydration errors), we still compute the link's\n // active status on the server, but we avoid creating any router-state\n // subscriptions by reading from `router.state` directly.\n //\n // Note: `location.hash` is not available on the server.\n // ==========================================================================\n if (_isServer) {\n const safeInternal = isSafeInternal(to)\n\n // If `to` is obviously an absolute URL, treat as external and avoid\n // computing the internal location via `buildLocation`.\n if (\n typeof to === 'string' &&\n !safeInternal &&\n // Quick checks to avoid `new URL` in common internal-like cases\n to.indexOf(':') > -1\n ) {\n try {\n new URL(to)\n if (isDangerousProtocol(to, router.protocolAllowlist)) {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(`Blocked Link with dangerous protocol: ${to}`)\n }\n return {\n ...propsSafeToSpread,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n href: undefined,\n ...(children && { children }),\n ...(target && { target }),\n ...(disabled && { disabled }),\n ...(style && { style }),\n ...(className && { className }),\n }\n }\n\n return {\n ...propsSafeToSpread,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n href: to,\n ...(children && { children }),\n ...(target && { target }),\n ...(disabled && { disabled }),\n ...(style && { style }),\n ...(className && { className }),\n }\n } catch {\n // Not an absolute URL\n }\n }\n\n const next = router.buildLocation({ ...options, from: options.from } as any)\n\n // Use publicHref - it contains the correct href for display\n // When a rewrite changes the origin, publicHref is the full URL\n // Otherwise it's the origin-stripped path\n // This avoids constructing URL objects in the hot path\n const hrefOptionPublicHref = next.maskedLocation\n ? next.maskedLocation.publicHref\n : next.publicHref\n const hrefOptionExternal = next.maskedLocation\n ? next.maskedLocation.external\n : next.external\n const hrefOption = getHrefOption(\n hrefOptionPublicHref,\n hrefOptionExternal,\n router.history,\n disabled,\n )\n\n const externalLink = (() => {\n if (hrefOption?.external) {\n if (isDangerousProtocol(hrefOption.href, router.protocolAllowlist)) {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(\n `Blocked Link with dangerous protocol: ${hrefOption.href}`,\n )\n }\n return undefined\n }\n return hrefOption.href\n }\n\n if (safeInternal) return undefined\n\n // Only attempt URL parsing when it looks like an absolute URL.\n if (typeof to === 'string' && to.indexOf(':') > -1) {\n try {\n new URL(to)\n if (isDangerousProtocol(to, router.protocolAllowlist)) {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(`Blocked Link with dangerous protocol: ${to}`)\n }\n return undefined\n }\n return to\n } catch {}\n }\n\n return undefined\n })()\n\n const isActive = (() => {\n if (externalLink) return false\n\n const currentLocation = router.state.location\n\n const exact = activeOptions?.exact ?? false\n\n if (exact) {\n const testExact = exactPathTest(\n currentLocation.pathname,\n next.pathname,\n router.basepath,\n )\n if (!testExact) {\n return false\n }\n } else {\n const currentPathSplit = removeTrailingSlash(\n currentLocation.pathname,\n router.basepath,\n )\n const nextPathSplit = removeTrailingSlash(\n next.pathname,\n router.basepath,\n )\n\n const pathIsFuzzyEqual =\n currentPathSplit.startsWith(nextPathSplit) &&\n (currentPathSplit.length === nextPathSplit.length ||\n currentPathSplit[nextPathSplit.length] === '/')\n\n if (!pathIsFuzzyEqual) {\n return false\n }\n }\n\n const includeSearch = activeOptions?.includeSearch ?? true\n if (includeSearch) {\n if (currentLocation.search !== next.search) {\n const currentSearchEmpty =\n !currentLocation.search ||\n (typeof currentLocation.search === 'object' &&\n Object.keys(currentLocation.search).length === 0)\n const nextSearchEmpty =\n !next.search ||\n (typeof next.search === 'object' &&\n Object.keys(next.search).length === 0)\n\n if (!(currentSearchEmpty && nextSearchEmpty)) {\n const searchTest = deepEqual(currentLocation.search, next.search, {\n partial: !exact,\n ignoreUndefined: !activeOptions?.explicitUndefined,\n })\n if (!searchTest) {\n return false\n }\n }\n }\n }\n\n // Hash is not available on the server\n if (activeOptions?.includeHash) {\n return false\n }\n\n return true\n })()\n\n if (externalLink) {\n return {\n ...propsSafeToSpread,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n href: externalLink,\n ...(children && { children }),\n ...(target && { target }),\n ...(disabled && { disabled }),\n ...(style && { style }),\n ...(className && { className }),\n }\n }\n\n const resolvedActiveProps: React.HTMLAttributes =\n isActive\n ? (functionalUpdate(activeProps as any, {}) ?? STATIC_ACTIVE_OBJECT)\n : STATIC_EMPTY_OBJECT\n\n const resolvedInactiveProps: React.HTMLAttributes =\n isActive\n ? STATIC_EMPTY_OBJECT\n : (functionalUpdate(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT)\n\n const resolvedStyle = (() => {\n const baseStyle = style\n const activeStyle = resolvedActiveProps.style\n const inactiveStyle = resolvedInactiveProps.style\n\n if (!baseStyle && !activeStyle && !inactiveStyle) {\n return undefined\n }\n\n if (baseStyle && !activeStyle && !inactiveStyle) {\n return baseStyle\n }\n\n if (!baseStyle && activeStyle && !inactiveStyle) {\n return activeStyle\n }\n\n if (!baseStyle && !activeStyle && inactiveStyle) {\n return inactiveStyle\n }\n\n return {\n ...baseStyle,\n ...activeStyle,\n ...inactiveStyle,\n }\n })()\n\n const resolvedClassName = (() => {\n const baseClassName = className\n const activeClassName = resolvedActiveProps.className\n const inactiveClassName = resolvedInactiveProps.className\n\n if (!baseClassName && !activeClassName && !inactiveClassName) {\n return ''\n }\n\n let out = ''\n\n if (baseClassName) {\n out = baseClassName\n }\n\n if (activeClassName) {\n out = out ? `${out} ${activeClassName}` : activeClassName\n }\n\n if (inactiveClassName) {\n out = out ? `${out} ${inactiveClassName}` : inactiveClassName\n }\n\n return out\n })()\n\n return {\n ...propsSafeToSpread,\n ...resolvedActiveProps,\n ...resolvedInactiveProps,\n href: hrefOption?.href,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n disabled: !!disabled,\n target,\n ...(resolvedStyle && { style: resolvedStyle }),\n ...(resolvedClassName && { className: resolvedClassName }),\n ...(disabled && STATIC_DISABLED_PROPS),\n ...(isActive && STATIC_ACTIVE_PROPS),\n }\n }\n\n // ==========================================================================\n // CLIENT-ONLY CODE\n // Everything below this point only runs on the client. The `isServer` check\n // above is a compile-time constant that bundlers use for dead code elimination,\n // so this entire section is removed from server bundles.\n //\n // We disable the rules-of-hooks lint rule because these hooks appear after\n // an early return. This is safe because:\n // 1. `isServer` is a compile-time constant from conditional exports\n // 2. In server bundles, this code is completely eliminated by the bundler\n // 3. In client bundles, `isServer` is `false`, so the early return never executes\n // ==========================================================================\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const isHydrated = useHydrated()\n\n // subscribe to path/search/hash/params to re-build location when they change\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const currentLocationState = useRouterState({\n select: (s) => {\n const leaf = s.matches[s.matches.length - 1]\n return {\n search: leaf?.search,\n hash: s.location.hash,\n path: leaf?.pathname, // path + params\n }\n },\n structuralSharing: true as any,\n })\n\n const from = options.from\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const _options = React.useMemo(\n () => {\n return { ...options, from }\n },\n // eslint-disable-next-line react-hooks/exhaustive-deps\n [\n router,\n currentLocationState,\n from,\n options._fromLocation,\n options.hash,\n options.to,\n options.search,\n options.params,\n options.state,\n options.mask,\n options.unsafeRelative,\n ],\n )\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const next = React.useMemo(\n () => router.buildLocation({ ..._options } as any),\n [router, _options],\n )\n\n // Use publicHref - it contains the correct href for display\n // When a rewrite changes the origin, publicHref is the full URL\n // Otherwise it's the origin-stripped path\n // This avoids constructing URL objects in the hot path\n const hrefOptionPublicHref = next.maskedLocation\n ? next.maskedLocation.publicHref\n : next.publicHref\n const hrefOptionExternal = next.maskedLocation\n ? next.maskedLocation.external\n : next.external\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const hrefOption = React.useMemo(\n () =>\n getHrefOption(\n hrefOptionPublicHref,\n hrefOptionExternal,\n router.history,\n disabled,\n ),\n [disabled, hrefOptionExternal, hrefOptionPublicHref, router.history],\n )\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const externalLink = React.useMemo(() => {\n if (hrefOption?.external) {\n // Block dangerous protocols for external links\n if (isDangerousProtocol(hrefOption.href, router.protocolAllowlist)) {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(\n `Blocked Link with dangerous protocol: ${hrefOption.href}`,\n )\n }\n return undefined\n }\n return hrefOption.href\n }\n const safeInternal = isSafeInternal(to)\n if (safeInternal) return undefined\n if (typeof to !== 'string' || to.indexOf(':') === -1) return undefined\n try {\n new URL(to as any)\n // Block dangerous protocols like javascript:, blob:, data:\n if (isDangerousProtocol(to, router.protocolAllowlist)) {\n if (process.env.NODE_ENV !== 'production') {\n console.warn(`Blocked Link with dangerous protocol: ${to}`)\n }\n return undefined\n }\n return to\n } catch {}\n return undefined\n }, [to, hrefOption, router.protocolAllowlist])\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const isActive = useRouterState({\n select: (s) => {\n if (externalLink) return false\n if (activeOptions?.exact) {\n const testExact = exactPathTest(\n s.location.pathname,\n next.pathname,\n router.basepath,\n )\n if (!testExact) {\n return false\n }\n } else {\n const currentPathSplit = removeTrailingSlash(\n s.location.pathname,\n router.basepath,\n )\n const nextPathSplit = removeTrailingSlash(\n next.pathname,\n router.basepath,\n )\n\n const pathIsFuzzyEqual =\n currentPathSplit.startsWith(nextPathSplit) &&\n (currentPathSplit.length === nextPathSplit.length ||\n currentPathSplit[nextPathSplit.length] === '/')\n\n if (!pathIsFuzzyEqual) {\n return false\n }\n }\n\n if (activeOptions?.includeSearch ?? true) {\n const searchTest = deepEqual(s.location.search, next.search, {\n partial: !activeOptions?.exact,\n ignoreUndefined: !activeOptions?.explicitUndefined,\n })\n if (!searchTest) {\n return false\n }\n }\n\n if (activeOptions?.includeHash) {\n return isHydrated && s.location.hash === next.hash\n }\n return true\n },\n })\n\n // Get the active props\n const resolvedActiveProps: React.HTMLAttributes = isActive\n ? (functionalUpdate(activeProps as any, {}) ?? STATIC_ACTIVE_OBJECT)\n : STATIC_EMPTY_OBJECT\n\n // Get the inactive props\n const resolvedInactiveProps: React.HTMLAttributes =\n isActive\n ? STATIC_EMPTY_OBJECT\n : (functionalUpdate(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT)\n\n const resolvedClassName = [\n className,\n resolvedActiveProps.className,\n resolvedInactiveProps.className,\n ]\n .filter(Boolean)\n .join(' ')\n\n const resolvedStyle = (style ||\n resolvedActiveProps.style ||\n resolvedInactiveProps.style) && {\n ...style,\n ...resolvedActiveProps.style,\n ...resolvedInactiveProps.style,\n }\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const [isTransitioning, setIsTransitioning] = React.useState(false)\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const hasRenderFetched = React.useRef(false)\n\n const preload =\n options.reloadDocument || externalLink\n ? false\n : (userPreload ?? router.options.defaultPreload)\n const preloadDelay =\n userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const doPreload = React.useCallback(() => {\n router\n .preloadRoute({ ..._options, _builtLocation: next } as any)\n .catch((err) => {\n console.warn(err)\n console.warn(preloadWarning)\n })\n }, [router, _options, next])\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n const preloadViewportIoCallback = React.useCallback(\n (entry: IntersectionObserverEntry | undefined) => {\n if (entry?.isIntersecting) {\n doPreload()\n }\n },\n [doPreload],\n )\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n useIntersectionObserver(\n innerRef,\n preloadViewportIoCallback,\n intersectionObserverOptions,\n { disabled: !!disabled || !(preload === 'viewport') },\n )\n\n // eslint-disable-next-line react-hooks/rules-of-hooks\n React.useEffect(() => {\n if (hasRenderFetched.current) {\n return\n }\n if (!disabled && preload === 'render') {\n doPreload()\n hasRenderFetched.current = true\n }\n }, [disabled, doPreload, preload])\n\n // The click handler\n const handleClick = (e: React.MouseEvent) => {\n // Check actual element's target attribute as fallback\n const elementTarget = (\n e.currentTarget as HTMLAnchorElement | SVGAElement\n ).getAttribute('target')\n const effectiveTarget = target !== undefined ? target : elementTarget\n\n if (\n !disabled &&\n !isCtrlEvent(e) &&\n !e.defaultPrevented &&\n (!effectiveTarget || effectiveTarget === '_self') &&\n e.button === 0\n ) {\n e.preventDefault()\n\n flushSync(() => {\n setIsTransitioning(true)\n })\n\n const unsub = router.subscribe('onResolved', () => {\n unsub()\n setIsTransitioning(false)\n })\n\n // All is well? Navigate!\n // N.B. we don't call `router.commitLocation(next) here because we want to run `validateSearch` before committing\n router.navigate({\n ..._options,\n replace,\n resetScroll,\n hashScrollIntoView,\n startTransition,\n viewTransition,\n ignoreBlocker,\n })\n }\n }\n\n if (externalLink) {\n return {\n ...propsSafeToSpread,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n href: externalLink,\n ...(children && { children }),\n ...(target && { target }),\n ...(disabled && { disabled }),\n ...(style && { style }),\n ...(className && { className }),\n ...(onClick && { onClick }),\n ...(onBlur && { onBlur }),\n ...(onFocus && { onFocus }),\n ...(onMouseEnter && { onMouseEnter }),\n ...(onMouseLeave && { onMouseLeave }),\n ...(onTouchStart && { onTouchStart }),\n }\n }\n\n const enqueueIntentPreload = (e: React.MouseEvent | React.FocusEvent) => {\n if (disabled || preload !== 'intent') return\n\n if (!preloadDelay) {\n doPreload()\n return\n }\n\n const eventTarget = e.currentTarget\n\n if (timeoutMap.has(eventTarget)) {\n return\n }\n\n const id = setTimeout(() => {\n timeoutMap.delete(eventTarget)\n doPreload()\n }, preloadDelay)\n timeoutMap.set(eventTarget, id)\n }\n\n const handleTouchStart = (_: React.TouchEvent) => {\n if (disabled || preload !== 'intent') return\n doPreload()\n }\n\n const handleLeave = (e: React.MouseEvent | React.FocusEvent) => {\n if (disabled || !preload || !preloadDelay) return\n const eventTarget = e.currentTarget\n const id = timeoutMap.get(eventTarget)\n if (id) {\n clearTimeout(id)\n timeoutMap.delete(eventTarget)\n }\n }\n\n return {\n ...propsSafeToSpread,\n ...resolvedActiveProps,\n ...resolvedInactiveProps,\n href: hrefOption?.href,\n ref: innerRef as React.ComponentPropsWithRef<'a'>['ref'],\n onClick: composeHandlers([onClick, handleClick]),\n onBlur: composeHandlers([onBlur, handleLeave]),\n onFocus: composeHandlers([onFocus, enqueueIntentPreload]),\n onMouseEnter: composeHandlers([onMouseEnter, enqueueIntentPreload]),\n onMouseLeave: composeHandlers([onMouseLeave, handleLeave]),\n onTouchStart: composeHandlers([onTouchStart, handleTouchStart]),\n disabled: !!disabled,\n target,\n ...(resolvedStyle && { style: resolvedStyle }),\n ...(resolvedClassName && { className: resolvedClassName }),\n ...(disabled && STATIC_DISABLED_PROPS),\n ...(isActive && STATIC_ACTIVE_PROPS),\n ...(isHydrated && isTransitioning && STATIC_TRANSITIONING_PROPS),\n }\n}\n\nconst STATIC_EMPTY_OBJECT = {}\nconst STATIC_ACTIVE_OBJECT = { className: 'active' }\nconst STATIC_DISABLED_PROPS = { role: 'link', 'aria-disabled': true }\nconst STATIC_ACTIVE_PROPS = { 'data-status': 'active', 'aria-current': 'page' }\nconst STATIC_TRANSITIONING_PROPS = { 'data-transitioning': 'transitioning' }\n\nconst timeoutMap = new WeakMap>()\n\nconst intersectionObserverOptions: IntersectionObserverInit = {\n rootMargin: '100px',\n}\n\nconst composeHandlers =\n (handlers: Array>) =>\n (e: React.SyntheticEvent) => {\n for (const handler of handlers) {\n if (!handler) continue\n if (e.defaultPrevented) return\n handler(e)\n }\n }\n\nfunction getHrefOption(\n publicHref: string,\n external: boolean,\n history: AnyRouter['history'],\n disabled: boolean | undefined,\n) {\n if (disabled) return undefined\n // Full URL means rewrite changed the origin - treat as external-like\n if (external) {\n return { href: publicHref, external: true }\n }\n return {\n href: history.createHref(publicHref) || '/',\n external: false,\n }\n}\n\nfunction isSafeInternal(to: unknown) {\n if (typeof to !== 'string') return false\n const zero = to.charCodeAt(0)\n if (zero === 47) return to.charCodeAt(1) !== 47 // '/' but not '//'\n return zero === 46 // '.', '..', './', '../'\n}\n\ntype UseLinkReactProps = TComp extends keyof React.JSX.IntrinsicElements\n ? React.JSX.IntrinsicElements[TComp]\n : TComp extends React.ComponentType\n ? React.ComponentPropsWithoutRef &\n React.RefAttributes>\n : never\n\nexport type UseLinkPropsOptions<\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends RoutePaths | string = string,\n TTo extends string | undefined = '.',\n TMaskFrom extends RoutePaths | string = TFrom,\n TMaskTo extends string = '.',\n> = ActiveLinkOptions<'a', TRouter, TFrom, TTo, TMaskFrom, TMaskTo> &\n UseLinkReactProps<'a'>\n\nexport type ActiveLinkOptions<\n TComp = 'a',\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends string = string,\n TTo extends string | undefined = '.',\n TMaskFrom extends string = TFrom,\n TMaskTo extends string = '.',\n> = LinkOptions &\n ActiveLinkOptionProps\n\ntype ActiveLinkProps = Partial<\n LinkComponentReactProps & {\n [key: `data-${string}`]: unknown\n }\n>\n\nexport interface ActiveLinkOptionProps {\n /**\n * A function that returns additional props for the `active` state of this link.\n * These props override other props passed to the link (`style`'s are merged, `className`'s are concatenated)\n */\n activeProps?: ActiveLinkProps | (() => ActiveLinkProps)\n /**\n * A function that returns additional props for the `inactive` state of this link.\n * These props override other props passed to the link (`style`'s are merged, `className`'s are concatenated)\n */\n inactiveProps?: ActiveLinkProps | (() => ActiveLinkProps)\n}\n\nexport type LinkProps<\n TComp = 'a',\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends string = string,\n TTo extends string | undefined = '.',\n TMaskFrom extends string = TFrom,\n TMaskTo extends string = '.',\n> = ActiveLinkOptions &\n LinkPropsChildren\n\nexport interface LinkPropsChildren {\n // If a function is passed as a child, it will be given the `isActive` boolean to aid in further styling on the element it returns\n children?:\n | React.ReactNode\n | ((state: {\n isActive: boolean\n isTransitioning: boolean\n }) => React.ReactNode)\n}\n\ntype LinkComponentReactProps = Omit<\n UseLinkReactProps,\n keyof CreateLinkProps\n>\n\nexport type LinkComponentProps<\n TComp = 'a',\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends string = string,\n TTo extends string | undefined = '.',\n TMaskFrom extends string = TFrom,\n TMaskTo extends string = '.',\n> = LinkComponentReactProps &\n LinkProps\n\nexport type CreateLinkProps = LinkProps<\n any,\n any,\n string,\n string,\n string,\n string\n>\n\nexport type LinkComponent<\n in out TComp,\n in out TDefaultFrom extends string = string,\n> = <\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string = TDefaultFrom,\n const TTo extends string | undefined = undefined,\n const TMaskFrom extends string = TFrom,\n const TMaskTo extends string = '',\n>(\n props: LinkComponentProps,\n) => React.ReactElement\n\nexport interface LinkComponentRoute<\n in out TDefaultFrom extends string = string,\n> {\n defaultFrom: TDefaultFrom;\n <\n TRouter extends AnyRouter = RegisteredRouter,\n const TTo extends string | undefined = undefined,\n const TMaskTo extends string = '',\n >(\n props: LinkComponentProps<\n 'a',\n TRouter,\n this['defaultFrom'],\n TTo,\n this['defaultFrom'],\n TMaskTo\n >,\n ): React.ReactElement\n}\n\n/**\n * Creates a typed Link-like component that preserves TanStack Router's\n * navigation semantics and type-safety while delegating rendering to the\n * provided host component.\n *\n * Useful for integrating design system anchors/buttons while keeping\n * router-aware props (eg. `to`, `params`, `search`, `preload`).\n *\n * @param Comp The host component to render (eg. a design-system Link/Button)\n * @returns A router-aware component with the same API as `Link`.\n * @link https://tanstack.com/router/latest/docs/framework/react/guide/custom-link\n */\nexport function createLink(\n Comp: Constrain ReactNode>,\n): LinkComponent {\n return React.forwardRef(function CreatedLink(props, ref) {\n return \n }) as any\n}\n\n/**\n * A strongly-typed anchor component for declarative navigation.\n * Handles path, search, hash and state updates with optional route preloading\n * and active-state styling.\n *\n * Props:\n * - `preload`: Controls route preloading (eg. 'intent', 'render', 'viewport', true/false)\n * - `preloadDelay`: Delay in ms before preloading on hover\n * - `activeProps`/`inactiveProps`: Additional props merged when link is active/inactive\n * - `resetScroll`/`hashScrollIntoView`: Control scroll behavior on navigation\n * - `viewTransition`/`startTransition`: Use View Transitions/React transitions for navigation\n * - `ignoreBlocker`: Bypass registered blockers\n *\n * @returns An anchor-like element that navigates without full page reloads.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/linkComponent\n */\nexport const Link: LinkComponent<'a'> = React.forwardRef(\n (props, ref) => {\n const { _asChild, ...rest } = props\n const { type: _type, ...linkProps } = useLinkProps(rest as any, ref)\n\n const children =\n typeof rest.children === 'function'\n ? rest.children({\n isActive: (linkProps as any)['data-status'] === 'active',\n })\n : rest.children\n\n if (!_asChild) {\n // the ReturnType of useLinkProps returns the correct type for a element, not a general component that has a disabled prop\n // @ts-expect-error\n const { disabled: _, ...rest } = linkProps\n return React.createElement('a', rest, children)\n }\n return React.createElement(_asChild, linkProps, children)\n },\n) as any\n\nfunction isCtrlEvent(e: React.MouseEvent) {\n return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey)\n}\n\nexport type LinkOptionsFnOptions<\n TOptions,\n TComp,\n TRouter extends AnyRouter = RegisteredRouter,\n> =\n TOptions extends ReadonlyArray\n ? ValidateLinkOptionsArray\n : ValidateLinkOptions\n\nexport type LinkOptionsFn = <\n const TOptions,\n TRouter extends AnyRouter = RegisteredRouter,\n>(\n options: LinkOptionsFnOptions,\n) => TOptions\n\n/**\n * Validate and reuse navigation options for `Link`, `navigate` or `redirect`.\n * Accepts a literal options object and returns it typed for later spreading.\n * @example\n * const opts = linkOptions({ to: '/dashboard', search: { tab: 'home' } })\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/linkOptions\n */\nexport const linkOptions: LinkOptionsFn<'a'> = (options) => {\n return options as any\n}\n\n/**\n * Type-check a literal object for use with `Link`, `navigate` or `redirect`.\n * Use to validate and reuse navigation options across your app.\n * @example\n * const opts = linkOptions({ to: '/dashboard', search: { tab: 'home' } })\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/linkOptions\n */\n", "import {\n BaseRootRoute,\n BaseRoute,\n BaseRouteApi,\n notFound,\n} from '@tanstack/router-core'\nimport React from 'react'\nimport { useLoaderData } from './useLoaderData'\nimport { useLoaderDeps } from './useLoaderDeps'\nimport { useParams } from './useParams'\nimport { useSearch } from './useSearch'\nimport { useNavigate } from './useNavigate'\nimport { useMatch } from './useMatch'\nimport { useRouteContext } from './useRouteContext'\nimport { useRouter } from './useRouter'\nimport { Link } from './link'\nimport type {\n AnyContext,\n AnyRoute,\n AnyRouter,\n ConstrainLiteral,\n ErrorComponentProps,\n NotFoundError,\n NotFoundRouteProps,\n Register,\n RegisteredRouter,\n ResolveFullPath,\n ResolveId,\n ResolveParams,\n RootRoute as RootRouteCore,\n RootRouteId,\n RootRouteOptions,\n RouteConstraints,\n Route as RouteCore,\n RouteIds,\n RouteMask,\n RouteOptions,\n RouteTypesById,\n RouterCore,\n ToMaskOptions,\n UseNavigateResult,\n} from '@tanstack/router-core'\nimport type { UseLoaderDataRoute } from './useLoaderData'\nimport type { UseMatchRoute } from './useMatch'\nimport type { UseLoaderDepsRoute } from './useLoaderDeps'\nimport type { UseParamsRoute } from './useParams'\nimport type { UseSearchRoute } from './useSearch'\nimport type { UseRouteContextRoute } from './useRouteContext'\nimport type { LinkComponentRoute } from './link'\n\ndeclare module '@tanstack/router-core' {\n export interface UpdatableRouteOptionsExtensions {\n component?: RouteComponent\n errorComponent?: false | null | undefined | ErrorRouteComponent\n notFoundComponent?: NotFoundRouteComponent\n pendingComponent?: RouteComponent\n }\n\n export interface RootRouteOptionsExtensions {\n shellComponent?: ({\n children,\n }: {\n children: React.ReactNode\n }) => React.ReactNode\n }\n\n export interface RouteExtensions<\n in out TId extends string,\n in out TFullPath extends string,\n > {\n useMatch: UseMatchRoute\n useRouteContext: UseRouteContextRoute\n useSearch: UseSearchRoute\n useParams: UseParamsRoute\n useLoaderDeps: UseLoaderDepsRoute\n useLoaderData: UseLoaderDataRoute\n useNavigate: () => UseNavigateResult\n Link: LinkComponentRoute\n }\n}\n\n/**\n * Returns a route-specific API that exposes type-safe hooks pre-bound\n * to a single route ID. Useful for consuming a route's APIs from files\n * where the route object isn't directly imported (e.g. code-split files).\n *\n * @param id Route ID string literal for the target route.\n * @returns A `RouteApi` instance bound to the given route ID.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/getRouteApiFunction\n */\nexport function getRouteApi<\n const TId,\n TRouter extends AnyRouter = RegisteredRouter,\n>(id: ConstrainLiteral>) {\n return new RouteApi({ id })\n}\n\nexport class RouteApi<\n TId,\n TRouter extends AnyRouter = RegisteredRouter,\n> extends BaseRouteApi {\n /**\n * @deprecated Use the `getRouteApi` function instead.\n */\n constructor({ id }: { id: TId }) {\n super({ id })\n }\n\n useMatch: UseMatchRoute = (opts) => {\n return useMatch({\n select: opts?.select,\n from: this.id,\n structuralSharing: opts?.structuralSharing,\n } as any) as any\n }\n\n useRouteContext: UseRouteContextRoute = (opts) => {\n return useRouteContext({ ...(opts as any), from: this.id as any })\n }\n\n useSearch: UseSearchRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useSearch({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useParams: UseParamsRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useParams({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useLoaderDeps: UseLoaderDepsRoute = (opts) => {\n return useLoaderDeps({ ...opts, from: this.id, strict: false } as any)\n }\n\n useLoaderData: UseLoaderDataRoute = (opts) => {\n return useLoaderData({ ...opts, from: this.id, strict: false } as any)\n }\n\n useNavigate = (): UseNavigateResult<\n RouteTypesById['fullPath']\n > => {\n const router = useRouter()\n return useNavigate({ from: router.routesById[this.id as string].fullPath })\n }\n\n notFound = (opts?: NotFoundError) => {\n return notFound({ routeId: this.id as string, ...opts })\n }\n\n Link: LinkComponentRoute['fullPath']> =\n React.forwardRef((props, ref: React.ForwardedRef) => {\n const router = useRouter()\n const fullPath = router.routesById[this.id as string].fullPath\n return \n }) as unknown as LinkComponentRoute<\n RouteTypesById['fullPath']\n >\n}\n\nexport class Route<\n in out TRegister = unknown,\n in out TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute,\n in out TPath extends RouteConstraints['TPath'] = '/',\n in out TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<\n TParentRoute,\n TPath\n >,\n in out TCustomId extends RouteConstraints['TCustomId'] = string,\n in out TId extends RouteConstraints['TId'] = ResolveId<\n TParentRoute,\n TCustomId,\n TPath\n >,\n in out TSearchValidator = undefined,\n in out TParams = ResolveParams,\n in out TRouterContext = AnyContext,\n in out TRouteContextFn = AnyContext,\n in out TBeforeLoadFn = AnyContext,\n in out TLoaderDeps extends Record = {},\n in out TLoaderFn = undefined,\n in out TChildren = unknown,\n in out TFileRouteTypes = unknown,\n in out TSSR = unknown,\n in out TServerMiddlewares = unknown,\n in out THandlers = undefined,\n>\n extends BaseRoute<\n TRegister,\n TParentRoute,\n TPath,\n TFullPath,\n TCustomId,\n TId,\n TSearchValidator,\n TParams,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TFileRouteTypes,\n TSSR,\n TServerMiddlewares,\n THandlers\n >\n implements\n RouteCore<\n TRegister,\n TParentRoute,\n TPath,\n TFullPath,\n TCustomId,\n TId,\n TSearchValidator,\n TParams,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TFileRouteTypes,\n TSSR,\n TServerMiddlewares,\n THandlers\n >\n{\n /**\n * @deprecated Use the `createRoute` function instead.\n */\n constructor(\n options?: RouteOptions<\n TRegister,\n TParentRoute,\n TId,\n TCustomId,\n TFullPath,\n TPath,\n TSearchValidator,\n TParams,\n TLoaderDeps,\n TLoaderFn,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TSSR,\n TServerMiddlewares,\n THandlers\n >,\n ) {\n super(options)\n ;(this as any).$$typeof = Symbol.for('react.memo')\n }\n\n useMatch: UseMatchRoute = (opts) => {\n return useMatch({\n select: opts?.select,\n from: this.id,\n structuralSharing: opts?.structuralSharing,\n } as any) as any\n }\n\n useRouteContext: UseRouteContextRoute = (opts?) => {\n return useRouteContext({ ...(opts as any), from: this.id })\n }\n\n useSearch: UseSearchRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useSearch({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useParams: UseParamsRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useParams({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useLoaderDeps: UseLoaderDepsRoute = (opts) => {\n return useLoaderDeps({ ...opts, from: this.id } as any)\n }\n\n useLoaderData: UseLoaderDataRoute = (opts) => {\n return useLoaderData({ ...opts, from: this.id } as any)\n }\n\n useNavigate = (): UseNavigateResult => {\n return useNavigate({ from: this.fullPath })\n }\n\n Link: LinkComponentRoute = React.forwardRef(\n (props, ref: React.ForwardedRef) => {\n return \n },\n ) as unknown as LinkComponentRoute\n}\n\n/**\n * Creates a non-root Route instance for code-based routing.\n *\n * Use this to define a route that will be composed into a route tree\n * (typically via a parent route's `addChildren`). If you're using file-based\n * routing, prefer `createFileRoute`.\n *\n * @param options Route options (path, component, loader, context, etc.).\n * @returns A Route instance to be attached to the route tree.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouteFunction\n */\nexport function createRoute<\n TRegister = unknown,\n TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute,\n TPath extends RouteConstraints['TPath'] = '/',\n TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<\n TParentRoute,\n TPath\n >,\n TCustomId extends RouteConstraints['TCustomId'] = string,\n TId extends RouteConstraints['TId'] = ResolveId<\n TParentRoute,\n TCustomId,\n TPath\n >,\n TSearchValidator = undefined,\n TParams = ResolveParams,\n TRouteContextFn = AnyContext,\n TBeforeLoadFn = AnyContext,\n TLoaderDeps extends Record = {},\n TLoaderFn = undefined,\n TChildren = unknown,\n TSSR = unknown,\n const TServerMiddlewares = unknown,\n>(\n options: RouteOptions<\n TRegister,\n TParentRoute,\n TId,\n TCustomId,\n TFullPath,\n TPath,\n TSearchValidator,\n TParams,\n TLoaderDeps,\n TLoaderFn,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TSSR,\n TServerMiddlewares\n >,\n): Route<\n TRegister,\n TParentRoute,\n TPath,\n TFullPath,\n TCustomId,\n TId,\n TSearchValidator,\n TParams,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TSSR,\n TServerMiddlewares\n> {\n return new Route<\n TRegister,\n TParentRoute,\n TPath,\n TFullPath,\n TCustomId,\n TId,\n TSearchValidator,\n TParams,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TSSR,\n TServerMiddlewares\n >(\n // TODO: Help us TypeChris, you're our only hope!\n options as any,\n )\n}\n\nexport type AnyRootRoute = RootRoute<\n any,\n any,\n any,\n any,\n any,\n any,\n any,\n any,\n any,\n any,\n any\n>\n\n/**\n * Creates a root route factory that requires a router context type.\n *\n * Use when your root route expects `context` to be provided to `createRouter`.\n * The returned function behaves like `createRootRoute` but enforces a context type.\n *\n * @returns A factory function to configure and return a root route.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRootRouteWithContextFunction\n */\nexport function createRootRouteWithContext() {\n return <\n TRegister = Register,\n TRouteContextFn = AnyContext,\n TBeforeLoadFn = AnyContext,\n TSearchValidator = undefined,\n TLoaderDeps extends Record = {},\n TLoaderFn = undefined,\n TSSR = unknown,\n TServerMiddlewares = unknown,\n >(\n options?: RootRouteOptions<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TSSR,\n TServerMiddlewares\n >,\n ) => {\n return createRootRoute<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TSSR,\n TServerMiddlewares\n >(options)\n }\n}\n\n/**\n * @deprecated Use the `createRootRouteWithContext` function instead.\n */\nexport const rootRouteWithContext = createRootRouteWithContext\n\nexport class RootRoute<\n in out TRegister = unknown,\n in out TSearchValidator = undefined,\n in out TRouterContext = {},\n in out TRouteContextFn = AnyContext,\n in out TBeforeLoadFn = AnyContext,\n in out TLoaderDeps extends Record = {},\n in out TLoaderFn = undefined,\n in out TChildren = unknown,\n in out TFileRouteTypes = unknown,\n in out TSSR = unknown,\n in out TServerMiddlewares = unknown,\n in out THandlers = undefined,\n>\n extends BaseRootRoute<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TFileRouteTypes,\n TSSR,\n TServerMiddlewares,\n THandlers\n >\n implements\n RootRouteCore<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TFileRouteTypes,\n TSSR,\n TServerMiddlewares,\n THandlers\n >\n{\n /**\n * @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.\n */\n constructor(\n options?: RootRouteOptions<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TSSR,\n TServerMiddlewares,\n THandlers\n >,\n ) {\n super(options)\n ;(this as any).$$typeof = Symbol.for('react.memo')\n }\n\n useMatch: UseMatchRoute = (opts) => {\n return useMatch({\n select: opts?.select,\n from: this.id,\n structuralSharing: opts?.structuralSharing,\n } as any) as any\n }\n\n useRouteContext: UseRouteContextRoute = (opts) => {\n return useRouteContext({ ...(opts as any), from: this.id })\n }\n\n useSearch: UseSearchRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useSearch({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useParams: UseParamsRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useParams({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.id,\n } as any) as any\n }\n\n useLoaderDeps: UseLoaderDepsRoute = (opts) => {\n return useLoaderDeps({ ...opts, from: this.id } as any)\n }\n\n useLoaderData: UseLoaderDataRoute = (opts) => {\n return useLoaderData({ ...opts, from: this.id } as any)\n }\n\n useNavigate = (): UseNavigateResult<'/'> => {\n return useNavigate({ from: this.fullPath })\n }\n\n Link: LinkComponentRoute<'/'> = React.forwardRef(\n (props, ref: React.ForwardedRef) => {\n return \n },\n ) as unknown as LinkComponentRoute<'/'>\n}\n\n/**\n * Creates a root Route instance used to build your route tree.\n *\n * Typically paired with `createRouter({ routeTree })`. If you need to require\n * a typed router context, use `createRootRouteWithContext` instead.\n *\n * @param options Root route options (component, error, pending, etc.).\n * @returns A root route instance.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRootRouteFunction\n */\nexport function createRootRoute<\n TRegister = Register,\n TSearchValidator = undefined,\n TRouterContext = {},\n TRouteContextFn = AnyContext,\n TBeforeLoadFn = AnyContext,\n TLoaderDeps extends Record = {},\n TLoaderFn = undefined,\n TSSR = unknown,\n const TServerMiddlewares = unknown,\n THandlers = undefined,\n>(\n options?: RootRouteOptions<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TSSR,\n TServerMiddlewares,\n THandlers\n >,\n): RootRoute<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n unknown,\n unknown,\n TSSR,\n TServerMiddlewares,\n THandlers\n> {\n return new RootRoute<\n TRegister,\n TSearchValidator,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n unknown,\n unknown,\n TSSR,\n TServerMiddlewares,\n THandlers\n >(options)\n}\n\nexport function createRouteMask<\n TRouteTree extends AnyRoute,\n TFrom extends string,\n TTo extends string,\n>(\n opts: {\n routeTree: TRouteTree\n } & ToMaskOptions, TFrom, TTo>,\n): RouteMask {\n return opts as any\n}\n\nexport interface DefaultRouteTypes {\n component:\n | ((props: TProps) => any)\n | React.LazyExoticComponent<(props: TProps) => any>\n}\nexport interface RouteTypes extends DefaultRouteTypes {}\n\nexport type AsyncRouteComponent = RouteTypes['component'] & {\n preload?: () => Promise\n}\n\nexport type RouteComponent = AsyncRouteComponent<{}>\n\nexport type ErrorRouteComponent = AsyncRouteComponent\n\nexport type NotFoundRouteComponent = RouteTypes['component']\n\nexport class NotFoundRoute<\n TRegister,\n TParentRoute extends AnyRootRoute,\n TRouterContext = AnyContext,\n TRouteContextFn = AnyContext,\n TBeforeLoadFn = AnyContext,\n TSearchValidator = undefined,\n TLoaderDeps extends Record = {},\n TLoaderFn = undefined,\n TChildren = unknown,\n TSSR = unknown,\n TServerMiddlewares = unknown,\n> extends Route<\n TRegister,\n TParentRoute,\n '/404',\n '/404',\n '404',\n '404',\n TSearchValidator,\n {},\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n TSSR,\n TServerMiddlewares\n> {\n constructor(\n options: Omit<\n RouteOptions<\n TRegister,\n TParentRoute,\n string,\n string,\n string,\n string,\n TSearchValidator,\n {},\n TLoaderDeps,\n TLoaderFn,\n TRouterContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TSSR,\n TServerMiddlewares\n >,\n | 'caseSensitive'\n | 'parseParams'\n | 'stringifyParams'\n | 'path'\n | 'id'\n | 'params'\n >,\n ) {\n super({\n ...(options as any),\n id: '404',\n })\n }\n}\n", "import warning from 'tiny-warning'\nimport { createRoute } from './route'\n\nimport { useMatch } from './useMatch'\nimport { useLoaderDeps } from './useLoaderDeps'\nimport { useLoaderData } from './useLoaderData'\nimport { useSearch } from './useSearch'\nimport { useParams } from './useParams'\nimport { useNavigate } from './useNavigate'\nimport { useRouter } from './useRouter'\nimport { useRouteContext } from './useRouteContext'\nimport type { UseParamsRoute } from './useParams'\nimport type { UseMatchRoute } from './useMatch'\nimport type { UseSearchRoute } from './useSearch'\nimport type {\n AnyContext,\n AnyRoute,\n AnyRouter,\n Constrain,\n ConstrainLiteral,\n FileBaseRouteOptions,\n FileRoutesByPath,\n LazyRouteOptions,\n Register,\n RegisteredRouter,\n ResolveParams,\n Route,\n RouteById,\n RouteConstraints,\n RouteIds,\n RouteLoaderFn,\n UpdatableRouteOptions,\n UseNavigateResult,\n} from '@tanstack/router-core'\nimport type { UseLoaderDepsRoute } from './useLoaderDeps'\nimport type { UseLoaderDataRoute } from './useLoaderData'\nimport type { UseRouteContextRoute } from './useRouteContext'\n\n/**\n * Creates a file-based Route factory for a given path.\n *\n * Used by TanStack Router's file-based routing to associate a file with a\n * route. The returned function accepts standard route options. In normal usage\n * the `path` string is inserted and maintained by the `tsr` generator.\n *\n * @param path File path literal for the route (usually auto-generated).\n * @returns A function that accepts Route options and returns a Route instance.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createFileRouteFunction\n */\nexport function createFileRoute<\n TFilePath extends keyof FileRoutesByPath,\n TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],\n TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'],\n TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'],\n TFullPath extends RouteConstraints['TFullPath'] =\n FileRoutesByPath[TFilePath]['fullPath'],\n>(\n path?: TFilePath,\n): FileRoute['createRoute'] {\n if (typeof path === 'object') {\n return new FileRoute(path, {\n silent: true,\n }).createRoute(path) as any\n }\n return new FileRoute(path, {\n silent: true,\n }).createRoute\n}\n\n/** \n @deprecated It's no longer recommended to use the `FileRoute` class directly.\n Instead, use `createFileRoute('/path/to/file')(options)` to create a file route.\n*/\nexport class FileRoute<\n TFilePath extends keyof FileRoutesByPath,\n TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],\n TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'],\n TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'],\n TFullPath extends RouteConstraints['TFullPath'] =\n FileRoutesByPath[TFilePath]['fullPath'],\n> {\n silent?: boolean\n\n constructor(\n public path?: TFilePath,\n _opts?: { silent: boolean },\n ) {\n this.silent = _opts?.silent\n }\n\n createRoute = <\n TRegister = Register,\n TSearchValidator = undefined,\n TParams = ResolveParams,\n TRouteContextFn = AnyContext,\n TBeforeLoadFn = AnyContext,\n TLoaderDeps extends Record = {},\n TLoaderFn = undefined,\n TChildren = unknown,\n TSSR = unknown,\n const TMiddlewares = unknown,\n THandlers = undefined,\n >(\n options?: FileBaseRouteOptions<\n TRegister,\n TParentRoute,\n TId,\n TPath,\n TSearchValidator,\n TParams,\n TLoaderDeps,\n TLoaderFn,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn,\n AnyContext,\n TSSR,\n TMiddlewares,\n THandlers\n > &\n UpdatableRouteOptions<\n TParentRoute,\n TId,\n TFullPath,\n TParams,\n TSearchValidator,\n TLoaderFn,\n TLoaderDeps,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn\n >,\n ): Route<\n TRegister,\n TParentRoute,\n TPath,\n TFullPath,\n TFilePath,\n TId,\n TSearchValidator,\n TParams,\n AnyContext,\n TRouteContextFn,\n TBeforeLoadFn,\n TLoaderDeps,\n TLoaderFn,\n TChildren,\n unknown,\n TSSR,\n TMiddlewares,\n THandlers\n > => {\n if (process.env.NODE_ENV !== 'production') {\n warning(\n this.silent,\n 'FileRoute is deprecated and will be removed in the next major version. Use the createFileRoute(path)(options) function instead.',\n )\n }\n const route = createRoute(options as any)\n ;(route as any).isRoot = false\n return route as any\n }\n}\n\n/**\n @deprecated It's recommended not to split loaders into separate files.\n Instead, place the loader function in the main route file via `createFileRoute`.\n*/\nexport function FileRouteLoader<\n TFilePath extends keyof FileRoutesByPath,\n TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute'],\n>(\n _path: TFilePath,\n): (\n loaderFn: Constrain<\n TLoaderFn,\n RouteLoaderFn<\n Register,\n TRoute['parentRoute'],\n TRoute['types']['id'],\n TRoute['types']['params'],\n TRoute['types']['loaderDeps'],\n TRoute['types']['routerContext'],\n TRoute['types']['routeContextFn'],\n TRoute['types']['beforeLoadFn']\n >\n >,\n) => TLoaderFn {\n if (process.env.NODE_ENV !== 'production') {\n warning(\n false,\n `FileRouteLoader is deprecated and will be removed in the next major version. Please place the loader function in the the main route file, inside the \\`createFileRoute('/path/to/file')(options)\\` options`,\n )\n }\n return (loaderFn) => loaderFn as any\n}\n\ndeclare module '@tanstack/router-core' {\n export interface LazyRoute {\n useMatch: UseMatchRoute\n useRouteContext: UseRouteContextRoute\n useSearch: UseSearchRoute\n useParams: UseParamsRoute\n useLoaderDeps: UseLoaderDepsRoute\n useLoaderData: UseLoaderDataRoute\n useNavigate: () => UseNavigateResult\n }\n}\n\nexport class LazyRoute {\n options: {\n id: string\n } & LazyRouteOptions\n\n constructor(\n opts: {\n id: string\n } & LazyRouteOptions,\n ) {\n this.options = opts\n ;(this as any).$$typeof = Symbol.for('react.memo')\n }\n\n useMatch: UseMatchRoute = (opts) => {\n return useMatch({\n select: opts?.select,\n from: this.options.id,\n structuralSharing: opts?.structuralSharing,\n } as any) as any\n }\n\n useRouteContext: UseRouteContextRoute = (opts) => {\n return useRouteContext({ ...(opts as any), from: this.options.id })\n }\n\n useSearch: UseSearchRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useSearch({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.options.id,\n } as any) as any\n }\n\n useParams: UseParamsRoute = (opts) => {\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n return useParams({\n select: opts?.select,\n structuralSharing: opts?.structuralSharing,\n from: this.options.id,\n } as any) as any\n }\n\n useLoaderDeps: UseLoaderDepsRoute = (opts) => {\n return useLoaderDeps({ ...opts, from: this.options.id } as any)\n }\n\n useLoaderData: UseLoaderDataRoute = (opts) => {\n return useLoaderData({ ...opts, from: this.options.id } as any)\n }\n\n useNavigate = (): UseNavigateResult => {\n const router = useRouter()\n return useNavigate({ from: router.routesById[this.options.id].fullPath })\n }\n}\n\n/**\n * Creates a lazily-configurable code-based route stub by ID.\n *\n * Use this for code-splitting with code-based routes. The returned function\n * accepts only non-critical route options like `component`, `pendingComponent`,\n * `errorComponent`, and `notFoundComponent` which are applied when the route\n * is matched.\n *\n * @param id Route ID string literal to associate with the lazy route.\n * @returns A function that accepts lazy route options and returns a `LazyRoute`.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createLazyRouteFunction\n */\nexport function createLazyRoute<\n TRouter extends AnyRouter = RegisteredRouter,\n TId extends string = string,\n TRoute extends AnyRoute = RouteById,\n>(id: ConstrainLiteral>) {\n return (opts: LazyRouteOptions) => {\n return new LazyRoute({\n id: id,\n ...opts,\n })\n }\n}\n\n/**\n * Creates a lazily-configurable file-based route stub by file path.\n *\n * Use this for code-splitting with file-based routes (eg. `.lazy.tsx` files).\n * The returned function accepts only non-critical route options like\n * `component`, `pendingComponent`, `errorComponent`, and `notFoundComponent`.\n *\n * @param id File path literal for the route file.\n * @returns A function that accepts lazy route options and returns a `LazyRoute`.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createLazyFileRouteFunction\n */\nexport function createLazyFileRoute<\n TFilePath extends keyof FileRoutesByPath,\n TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute'],\n>(id: TFilePath): (opts: LazyRouteOptions) => LazyRoute {\n if (typeof id === 'object') {\n return new LazyRoute(id) as any\n }\n\n return (opts: LazyRouteOptions) => new LazyRoute({ id, ...opts })\n}\n", "import * as React from 'react'\nimport { isModuleNotFoundError } from '@tanstack/router-core'\nimport { reactUse } from './utils'\nimport type { AsyncRouteComponent } from './route'\n\n/**\n * Wrap a dynamic import to create a route component that supports\n * `.preload()` and friendly reload-on-module-missing behavior.\n *\n * @param importer Function returning a module promise\n * @param exportName Named export to use (default: `default`)\n * @returns A lazy route component compatible with TanStack Router\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/lazyRouteComponentFunction\n */\nexport function lazyRouteComponent<\n T extends Record,\n TKey extends keyof T = 'default',\n>(\n importer: () => Promise,\n exportName?: TKey,\n): T[TKey] extends (props: infer TProps) => any\n ? AsyncRouteComponent\n : never {\n let loadPromise: Promise | undefined\n let comp: T[TKey] | T['default']\n let error: any\n let reload: boolean\n\n const load = () => {\n if (!loadPromise) {\n loadPromise = importer()\n .then((res) => {\n loadPromise = undefined\n comp = res[exportName ?? 'default']\n })\n .catch((err) => {\n // We don't want an error thrown from preload in this case, because\n // there's nothing we want to do about module not found during preload.\n // Record the error, the rest is handled during the render path.\n error = err\n // If the load fails due to module not found, it may mean a new version of\n // the build was deployed and the user's browser is still using an old version.\n // If this happens, the old version in the user's browser would have an outdated\n // URL to the lazy module.\n // In that case, we want to attempt one window refresh to get the latest.\n if (isModuleNotFoundError(error)) {\n if (\n error instanceof Error &&\n typeof window !== 'undefined' &&\n typeof sessionStorage !== 'undefined'\n ) {\n // Again, we want to reload one time on module not found error and not enter\n // a reload loop if there is some other issue besides an old deploy.\n // That's why we store our reload attempt in sessionStorage.\n // Use error.message as key because it contains the module path that failed.\n const storageKey = `tanstack_router_reload:${error.message}`\n if (!sessionStorage.getItem(storageKey)) {\n sessionStorage.setItem(storageKey, '1')\n reload = true\n }\n }\n }\n })\n }\n\n return loadPromise\n }\n\n const lazyComp = function Lazy(props: any) {\n // Now that we're out of preload and into actual render path,\n if (reload) {\n // If it was a module loading error,\n // throw eternal suspense while we wait for window to reload\n window.location.reload()\n throw new Promise(() => {})\n }\n if (error) {\n // Otherwise, just throw the error\n throw error\n }\n\n if (!comp) {\n if (reactUse) {\n reactUse(load())\n } else {\n throw load()\n }\n }\n\n return React.createElement(comp, props)\n }\n\n ;(lazyComp as any).preload = load\n\n return lazyComp as any\n}\n", "import * as React from 'react'\nimport {\n getLocationChangeInfo,\n handleHashScroll,\n trimPathRight,\n} from '@tanstack/router-core'\nimport { useLayoutEffect, usePrevious } from './utils'\nimport { useRouter } from './useRouter'\nimport { useRouterState } from './useRouterState'\n\nexport function Transitioner() {\n const router = useRouter()\n const mountLoadForRouter = React.useRef({ router, mounted: false })\n\n const [isTransitioning, setIsTransitioning] = React.useState(false)\n // Track pending state changes\n const { hasPendingMatches, isLoading } = useRouterState({\n select: (s) => ({\n isLoading: s.isLoading,\n hasPendingMatches: s.matches.some((d) => d.status === 'pending'),\n }),\n structuralSharing: true,\n })\n\n const previousIsLoading = usePrevious(isLoading)\n\n const isAnyPending = isLoading || isTransitioning || hasPendingMatches\n const previousIsAnyPending = usePrevious(isAnyPending)\n\n const isPagePending = isLoading || hasPendingMatches\n const previousIsPagePending = usePrevious(isPagePending)\n\n router.startTransition = (fn: () => void) => {\n setIsTransitioning(true)\n React.startTransition(() => {\n fn()\n setIsTransitioning(false)\n })\n }\n\n // Subscribe to location changes\n // and try to load the new location\n React.useEffect(() => {\n const unsub = router.history.subscribe(router.load)\n\n const nextLocation = router.buildLocation({\n to: router.latestLocation.pathname,\n search: true,\n params: true,\n hash: true,\n state: true,\n _includeValidateSearch: true,\n })\n\n // Check if the current URL matches the canonical form.\n // Compare publicHref (browser-facing URL) for consistency with\n // the server-side redirect check in router.beforeLoad.\n if (\n trimPathRight(router.latestLocation.publicHref) !==\n trimPathRight(nextLocation.publicHref)\n ) {\n router.commitLocation({ ...nextLocation, replace: true })\n }\n\n return () => {\n unsub()\n }\n }, [router, router.history])\n\n // Try to load the initial location\n useLayoutEffect(() => {\n if (\n // if we are hydrating from SSR, loading is triggered in ssr-client\n (typeof window !== 'undefined' && router.ssr) ||\n (mountLoadForRouter.current.router === router &&\n mountLoadForRouter.current.mounted)\n ) {\n return\n }\n mountLoadForRouter.current = { router, mounted: true }\n\n const tryLoad = async () => {\n try {\n await router.load()\n } catch (err) {\n console.error(err)\n }\n }\n\n tryLoad()\n }, [router])\n\n useLayoutEffect(() => {\n // The router was loading and now it's not\n if (previousIsLoading && !isLoading) {\n router.emit({\n type: 'onLoad', // When the new URL has committed, when the new matches have been loaded into state.matches\n ...getLocationChangeInfo(router.state),\n })\n }\n }, [previousIsLoading, router, isLoading])\n\n useLayoutEffect(() => {\n // emit onBeforeRouteMount\n if (previousIsPagePending && !isPagePending) {\n router.emit({\n type: 'onBeforeRouteMount',\n ...getLocationChangeInfo(router.state),\n })\n }\n }, [isPagePending, previousIsPagePending, router])\n\n useLayoutEffect(() => {\n if (previousIsAnyPending && !isAnyPending) {\n const changeInfo = getLocationChangeInfo(router.state)\n router.emit({\n type: 'onResolved',\n ...changeInfo,\n })\n\n router.__store.setState((s: typeof router.state) => ({\n ...s,\n status: 'idle',\n resolvedLocation: s.location,\n }))\n\n if (changeInfo.hrefChanged) {\n handleHashScroll(router)\n }\n }\n }, [isAnyPending, previousIsAnyPending, router])\n\n return null\n}\n", "import * as React from 'react'\nimport { isNotFound } from '@tanstack/router-core'\nimport { CatchBoundary } from './CatchBoundary'\nimport { useRouterState } from './useRouterState'\nimport type { ErrorInfo } from 'react'\nimport type { NotFoundError } from '@tanstack/router-core'\n\nexport function CatchNotFound(props: {\n fallback?: (error: NotFoundError) => React.ReactElement\n onCatch?: (error: Error, errorInfo: ErrorInfo) => void\n children: React.ReactNode\n}) {\n // TODO: Some way for the user to programmatically reset the not-found boundary?\n const resetKey = useRouterState({\n select: (s) => `not-found-${s.location.pathname}-${s.status}`,\n })\n\n return (\n resetKey}\n onCatch={(error, errorInfo) => {\n if (isNotFound(error)) {\n props.onCatch?.(error, errorInfo)\n } else {\n throw error\n }\n }}\n errorComponent={({ error }) => {\n if (isNotFound(error)) {\n return props.fallback?.(error)\n } else {\n throw error\n }\n }}\n >\n {props.children}\n \n )\n}\n\nexport function DefaultGlobalNotFound() {\n return

Not Found

\n}\n", "import * as React from 'react'\n\nexport function SafeFragment(props: any) {\n return <>{props.children}\n}\n", "import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { DefaultGlobalNotFound } from './not-found'\nimport type { AnyRoute, AnyRouter } from '@tanstack/router-core'\n\n/**\n * Renders a not found component for a route when no matching route is found.\n *\n * @param router - The router instance containing the route configuration\n * @param route - The route that triggered the not found state\n * @param data - Additional data to pass to the not found component\n * @returns The rendered not found component or a default fallback component\n */\nexport function renderRouteNotFound(\n router: AnyRouter,\n route: AnyRoute,\n data: any,\n) {\n if (!route.options.notFoundComponent) {\n if (router.options.defaultNotFoundComponent) {\n return \n }\n\n if (process.env.NODE_ENV === 'development') {\n warning(\n route.options.notFoundComponent,\n `A notFoundError was encountered on the route with ID \"${route.id}\", but a notFoundComponent option was not configured, nor was a router level defaultNotFoundComponent configured. Consider configuring at least one of these to avoid TanStack Router's overly generic defaultNotFoundComponent (

Not Found

)`,\n )\n }\n\n return \n }\n\n return \n}\n", "import { isServer } from '@tanstack/router-core/isServer'\nimport { useRouter } from './useRouter'\n\n/**\n * Server-only helper to emit a script tag exactly once during SSR.\n */\nexport function ScriptOnce({ children }: { children: string }) {\n const router = useRouter()\n if (!(isServer ?? router.isServer)) {\n return null\n }\n\n return (\n \n )\n}\n", "import {\n defaultGetScrollRestorationKey,\n escapeHtml,\n restoreScroll,\n storageKey,\n} from '@tanstack/router-core'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { useRouter } from './useRouter'\nimport { ScriptOnce } from './ScriptOnce'\n\nexport function ScrollRestoration() {\n const router = useRouter()\n if (!router.isScrollRestoring || !(isServer ?? router.isServer)) {\n return null\n }\n if (typeof router.options.scrollRestoration === 'function') {\n const shouldRestore = router.options.scrollRestoration({\n location: router.latestLocation,\n })\n if (!shouldRestore) {\n return null\n }\n }\n const getKey =\n router.options.getScrollRestorationKey || defaultGetScrollRestorationKey\n const userKey = getKey(router.latestLocation)\n const resolvedKey =\n userKey !== defaultGetScrollRestorationKey(router.latestLocation)\n ? userKey\n : undefined\n\n const restoreScrollOptions: Parameters[0] = {\n storageKey,\n shouldScrollRestoration: true,\n }\n if (resolvedKey) {\n restoreScrollOptions.key = resolvedKey\n }\n\n return (\n \n )\n}\n", "import * as React from 'react'\nimport invariant from 'tiny-invariant'\nimport warning from 'tiny-warning'\nimport {\n createControlledPromise,\n getLocationChangeInfo,\n isNotFound,\n isRedirect,\n rootRouteId,\n} from '@tanstack/router-core'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { CatchBoundary, ErrorComponent } from './CatchBoundary'\nimport { useRouterState } from './useRouterState'\nimport { useRouter } from './useRouter'\nimport { CatchNotFound } from './not-found'\nimport { matchContext } from './matchContext'\nimport { SafeFragment } from './SafeFragment'\nimport { renderRouteNotFound } from './renderRouteNotFound'\nimport { ScrollRestoration } from './scroll-restoration'\nimport { ClientOnly } from './ClientOnly'\nimport type {\n AnyRoute,\n ParsedLocation,\n RootRouteOptions,\n} from '@tanstack/router-core'\n\nexport const Match = React.memo(function MatchImpl({\n matchId,\n}: {\n matchId: string\n}) {\n const router = useRouter()\n const matchState = useRouterState({\n select: (s) => {\n const matchIndex = s.matches.findIndex((d) => d.id === matchId)\n const match = s.matches[matchIndex]\n invariant(\n match,\n `Could not find match for matchId \"${matchId}\". Please file an issue!`,\n )\n return {\n routeId: match.routeId,\n ssr: match.ssr,\n _displayPending: match._displayPending,\n resetKey: s.loadedAt,\n parentRouteId: s.matches[matchIndex - 1]?.routeId as string,\n }\n },\n structuralSharing: true as any,\n })\n\n const route: AnyRoute = router.routesById[matchState.routeId]\n\n const PendingComponent =\n route.options.pendingComponent ?? router.options.defaultPendingComponent\n\n const pendingElement = PendingComponent ? : null\n\n const routeErrorComponent =\n route.options.errorComponent ?? router.options.defaultErrorComponent\n\n const routeOnCatch = route.options.onCatch ?? router.options.defaultOnCatch\n\n const routeNotFoundComponent = route.isRoot\n ? // If it's the root route, use the globalNotFound option, with fallback to the notFoundRoute's component\n (route.options.notFoundComponent ??\n router.options.notFoundRoute?.options.component)\n : route.options.notFoundComponent\n\n const resolvedNoSsr =\n matchState.ssr === false || matchState.ssr === 'data-only'\n const ResolvedSuspenseBoundary =\n // If we're on the root route, allow forcefully wrapping in suspense\n (!route.isRoot || route.options.wrapInSuspense || resolvedNoSsr) &&\n (route.options.wrapInSuspense ??\n PendingComponent ??\n ((route.options.errorComponent as any)?.preload || resolvedNoSsr))\n ? React.Suspense\n : SafeFragment\n\n const ResolvedCatchBoundary = routeErrorComponent\n ? CatchBoundary\n : SafeFragment\n\n const ResolvedNotFoundBoundary = routeNotFoundComponent\n ? CatchNotFound\n : SafeFragment\n\n const ShellComponent = route.isRoot\n ? ((route.options as RootRouteOptions).shellComponent ?? SafeFragment)\n : SafeFragment\n return (\n \n \n \n matchState.resetKey}\n errorComponent={routeErrorComponent || ErrorComponent}\n onCatch={(error, errorInfo) => {\n // Forward not found errors (we don't want to show the error component for these)\n if (isNotFound(error)) throw error\n warning(false, `Error in route match: ${matchId}`)\n routeOnCatch?.(error, errorInfo)\n }}\n >\n {\n // If the current not found handler doesn't exist or it has a\n // route ID which doesn't match the current route, rethrow the error\n if (\n !routeNotFoundComponent ||\n (error.routeId && error.routeId !== matchState.routeId) ||\n (!error.routeId && !route.isRoot)\n )\n throw error\n\n return React.createElement(routeNotFoundComponent, error as any)\n }}\n >\n {resolvedNoSsr || matchState._displayPending ? (\n \n \n \n ) : (\n \n )}\n \n \n \n \n {matchState.parentRouteId === rootRouteId &&\n router.options.scrollRestoration ? (\n <>\n \n \n \n ) : null}\n \n )\n})\n\n// On Rendered can't happen above the root layout because it actually\n// renders a dummy dom element to track the rendered state of the app.\n// We render a script tag with a key that changes based on the current\n// location state.__TSR_key. Also, because it's below the root layout, it\n// allows us to fire onRendered events even after a hydration mismatch\n// error that occurred above the root layout (like bad head/link tags,\n// which is common).\nfunction OnRendered() {\n const router = useRouter()\n\n const prevLocationRef = React.useRef>(\n undefined,\n )\n\n return (\n {\n if (\n el &&\n (prevLocationRef.current === undefined ||\n prevLocationRef.current.href !== router.latestLocation.href)\n ) {\n router.emit({\n type: 'onRendered',\n ...getLocationChangeInfo(router.state),\n })\n prevLocationRef.current = router.latestLocation\n }\n }}\n />\n )\n}\n\nexport const MatchInner = React.memo(function MatchInnerImpl({\n matchId,\n}: {\n matchId: string\n}): any {\n const router = useRouter()\n\n const { match, key, routeId } = useRouterState({\n select: (s) => {\n const match = s.matches.find((d) => d.id === matchId)!\n const routeId = match.routeId as string\n\n const remountFn =\n (router.routesById[routeId] as AnyRoute).options.remountDeps ??\n router.options.defaultRemountDeps\n const remountDeps = remountFn?.({\n routeId,\n loaderDeps: match.loaderDeps,\n params: match._strictParams,\n search: match._strictSearch,\n })\n const key = remountDeps ? JSON.stringify(remountDeps) : undefined\n\n return {\n key,\n routeId,\n match: {\n id: match.id,\n status: match.status,\n error: match.error,\n invalid: match.invalid,\n _forcePending: match._forcePending,\n _displayPending: match._displayPending,\n },\n }\n },\n structuralSharing: true as any,\n })\n\n const route = router.routesById[routeId] as AnyRoute\n\n const out = React.useMemo(() => {\n const Comp = route.options.component ?? router.options.defaultComponent\n if (Comp) {\n return \n }\n return \n }, [key, route.options.component, router.options.defaultComponent])\n\n if (match._displayPending) {\n throw router.getMatch(match.id)?._nonReactive.displayPendingPromise\n }\n\n if (match._forcePending) {\n throw router.getMatch(match.id)?._nonReactive.minPendingPromise\n }\n\n // see also hydrate() in packages/router-core/src/ssr/ssr-client.ts\n if (match.status === 'pending') {\n // We're pending, and if we have a minPendingMs, we need to wait for it\n const pendingMinMs =\n route.options.pendingMinMs ?? router.options.defaultPendingMinMs\n if (pendingMinMs) {\n const routerMatch = router.getMatch(match.id)\n if (routerMatch && !routerMatch._nonReactive.minPendingPromise) {\n // Create a promise that will resolve after the minPendingMs\n if (!(isServer ?? router.isServer)) {\n const minPendingPromise = createControlledPromise()\n\n routerMatch._nonReactive.minPendingPromise = minPendingPromise\n\n setTimeout(() => {\n minPendingPromise.resolve()\n // We've handled the minPendingPromise, so we can delete it\n routerMatch._nonReactive.minPendingPromise = undefined\n }, pendingMinMs)\n }\n }\n }\n throw router.getMatch(match.id)?._nonReactive.loadPromise\n }\n\n if (match.status === 'notFound') {\n invariant(isNotFound(match.error), 'Expected a notFound error')\n return renderRouteNotFound(router, route, match.error)\n }\n\n if (match.status === 'redirected') {\n // Redirects should be handled by the router transition. If we happen to\n // encounter a redirect here, it's a bug. Let's warn, but render nothing.\n invariant(isRedirect(match.error), 'Expected a redirect error')\n\n // warning(\n // false,\n // 'Tried to render a redirected route match! This is a weird circumstance, please file an issue!',\n // )\n throw router.getMatch(match.id)?._nonReactive.loadPromise\n }\n\n if (match.status === 'error') {\n // If we're on the server, we need to use React's new and super\n // wonky api for throwing errors from a server side render inside\n // of a suspense boundary. This is the only way to get\n // renderToPipeableStream to not hang indefinitely.\n // We'll serialize the error and rethrow it on the client.\n if (isServer ?? router.isServer) {\n const RouteErrorComponent =\n (route.options.errorComponent ??\n router.options.defaultErrorComponent) ||\n ErrorComponent\n return (\n \n )\n }\n\n throw match.error\n }\n\n return out\n})\n\n/**\n * Render the next child match in the route tree. Typically used inside\n * a route component to render nested routes.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/outletComponent\n */\nexport const Outlet = React.memo(function OutletImpl() {\n const router = useRouter()\n const matchId = React.useContext(matchContext)\n const routeId = useRouterState({\n select: (s) => s.matches.find((d) => d.id === matchId)?.routeId as string,\n })\n\n const route = router.routesById[routeId]!\n\n const parentGlobalNotFound = useRouterState({\n select: (s) => {\n const matches = s.matches\n const parentMatch = matches.find((d) => d.id === matchId)\n invariant(\n parentMatch,\n `Could not find parent match for matchId \"${matchId}\"`,\n )\n return parentMatch.globalNotFound\n },\n })\n\n const childMatchId = useRouterState({\n select: (s) => {\n const matches = s.matches\n const index = matches.findIndex((d) => d.id === matchId)\n return matches[index + 1]?.id\n },\n })\n\n const pendingElement = router.options.defaultPendingComponent ? (\n \n ) : null\n\n if (parentGlobalNotFound) {\n return renderRouteNotFound(router, route, undefined)\n }\n\n if (!childMatchId) {\n return null\n }\n\n const nextMatch = \n\n if (routeId === rootRouteId) {\n return (\n {nextMatch}\n )\n }\n\n return nextMatch\n})\n", "import * as React from 'react'\nimport warning from 'tiny-warning'\nimport { rootRouteId } from '@tanstack/router-core'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { CatchBoundary, ErrorComponent } from './CatchBoundary'\nimport { useRouterState } from './useRouterState'\nimport { useRouter } from './useRouter'\nimport { Transitioner } from './Transitioner'\nimport { matchContext } from './matchContext'\nimport { Match } from './Match'\nimport { SafeFragment } from './SafeFragment'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRoute,\n AnyRouter,\n DeepPartial,\n Expand,\n MakeOptionalPathParams,\n MakeOptionalSearchParams,\n MakeRouteMatchUnion,\n MaskOptions,\n MatchRouteOptions,\n NoInfer,\n RegisteredRouter,\n ResolveRelativePath,\n ResolveRoute,\n RouteByPath,\n RouterState,\n ToSubOptionsProps,\n} from '@tanstack/router-core'\n\ndeclare module '@tanstack/router-core' {\n export interface RouteMatchExtensions {\n meta?: Array\n links?: Array\n scripts?: Array\n styles?: Array\n headScripts?: Array\n }\n}\n\n/**\n * Internal component that renders the router's active match tree with\n * suspense, error, and not-found boundaries. Rendered by `RouterProvider`.\n */\nexport function Matches() {\n const router = useRouter()\n const rootRoute: AnyRoute = router.routesById[rootRouteId]\n\n const PendingComponent =\n rootRoute.options.pendingComponent ?? router.options.defaultPendingComponent\n\n const pendingElement = PendingComponent ? : null\n\n // Do not render a root Suspense during SSR or hydrating from SSR\n const ResolvedSuspense =\n (isServer ?? router.isServer) ||\n (typeof document !== 'undefined' && router.ssr)\n ? SafeFragment\n : React.Suspense\n\n const inner = (\n \n {!(isServer ?? router.isServer) && }\n \n \n )\n\n return router.options.InnerWrap ? (\n {inner}\n ) : (\n inner\n )\n}\n\nfunction MatchesInner() {\n const router = useRouter()\n const matchId = useRouterState({\n select: (s) => {\n return s.matches[0]?.id\n },\n })\n\n const resetKey = useRouterState({\n select: (s) => s.loadedAt,\n })\n\n const matchComponent = matchId ? : null\n\n return (\n \n {router.options.disableGlobalCatchBoundary ? (\n matchComponent\n ) : (\n resetKey}\n errorComponent={ErrorComponent}\n onCatch={\n process.env.NODE_ENV !== 'production'\n ? (error) => {\n warning(\n false,\n `The following error wasn't caught by any route! At the very least, consider setting an 'errorComponent' in your RootRoute!`,\n )\n warning(false, error.message || error.toString())\n }\n : undefined\n }\n >\n {matchComponent}\n \n )}\n \n )\n}\n\nexport type UseMatchRouteOptions<\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends string = string,\n TTo extends string | undefined = undefined,\n TMaskFrom extends string = TFrom,\n TMaskTo extends string = '',\n> = ToSubOptionsProps &\n DeepPartial> &\n DeepPartial> &\n MaskOptions &\n MatchRouteOptions\n\n/**\n * Create a matcher function for testing locations against route definitions.\n *\n * The returned function accepts standard navigation options (`to`, `params`,\n * `search`, etc.) and returns either `false` (no match) or the matched params\n * object when the route matches the current or pending location.\n *\n * Useful for conditional rendering and active UI states.\n *\n * @returns A `matchRoute(options)` function that returns `false` or params.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useMatchRouteHook\n */\nexport function useMatchRoute() {\n const router = useRouter()\n\n useRouterState({\n select: (s) => [s.location.href, s.resolvedLocation?.href, s.status],\n structuralSharing: true as any,\n })\n\n return React.useCallback(\n <\n const TFrom extends string = string,\n const TTo extends string | undefined = undefined,\n const TMaskFrom extends string = TFrom,\n const TMaskTo extends string = '',\n >(\n opts: UseMatchRouteOptions,\n ):\n | false\n | Expand['types']['allParams']> => {\n const { pending, caseSensitive, fuzzy, includeSearch, ...rest } = opts\n\n return router.matchRoute(rest as any, {\n pending,\n caseSensitive,\n fuzzy,\n includeSearch,\n })\n },\n [router],\n )\n}\n\nexport type MakeMatchRouteOptions<\n TRouter extends AnyRouter = RegisteredRouter,\n TFrom extends string = string,\n TTo extends string | undefined = undefined,\n TMaskFrom extends string = TFrom,\n TMaskTo extends string = '',\n> = UseMatchRouteOptions & {\n // If a function is passed as a child, it will be given the `isActive` boolean to aid in further styling on the element it returns\n children?:\n | ((\n params?: RouteByPath<\n TRouter['routeTree'],\n ResolveRelativePath>\n >['types']['allParams'],\n ) => React.ReactNode)\n | React.ReactNode\n}\n\n/**\n * Component that conditionally renders its children based on whether a route\n * matches the provided `from`/`to` options. If `children` is a function, it\n * receives the matched params object.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/matchRouteComponent\n */\nexport function MatchRoute<\n TRouter extends AnyRouter = RegisteredRouter,\n const TFrom extends string = string,\n const TTo extends string | undefined = undefined,\n const TMaskFrom extends string = TFrom,\n const TMaskTo extends string = '',\n>(props: MakeMatchRouteOptions): any {\n const matchRoute = useMatchRoute()\n const params = matchRoute(props as any) as boolean\n\n if (typeof props.children === 'function') {\n return (props.children as any)(params)\n }\n\n return params ? props.children : null\n}\n\nexport interface UseMatchesBaseOptions<\n TRouter extends AnyRouter,\n TSelected,\n TStructuralSharing,\n> {\n select?: (\n matches: Array>,\n ) => ValidateSelected\n}\n\nexport type UseMatchesResult<\n TRouter extends AnyRouter,\n TSelected,\n> = unknown extends TSelected ? Array> : TSelected\n\nexport function useMatches<\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseMatchesBaseOptions &\n StructuralSharingOption,\n): UseMatchesResult {\n return useRouterState({\n select: (state: RouterState) => {\n const matches = state.matches\n return opts?.select\n ? opts.select(matches as Array>)\n : matches\n },\n structuralSharing: opts?.structuralSharing,\n } as any) as UseMatchesResult\n}\n\n/**\n * Read the full array of active route matches or select a derived subset.\n *\n * Useful for debugging, breadcrumbs, or aggregating metadata across matches.\n *\n * @returns The array of matches (or the selected value).\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useMatchesHook\n */\n\n/**\n * Read the full array of active route matches or select a derived subset.\n *\n * Useful for debugging, breadcrumbs, or aggregating metadata across matches.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useMatchesHook\n */\nexport function useParentMatches<\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseMatchesBaseOptions &\n StructuralSharingOption,\n): UseMatchesResult {\n const contextMatchId = React.useContext(matchContext)\n\n return useMatches({\n select: (matches: Array>) => {\n matches = matches.slice(\n 0,\n matches.findIndex((d) => d.id === contextMatchId),\n )\n return opts?.select ? opts.select(matches) : matches\n },\n structuralSharing: opts?.structuralSharing,\n } as any)\n}\n\n/**\n * Read the array of active route matches that are children of the current\n * match (or selected parent) in the match tree.\n */\nexport function useChildMatches<\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseMatchesBaseOptions &\n StructuralSharingOption,\n): UseMatchesResult {\n const contextMatchId = React.useContext(matchContext)\n\n return useMatches({\n select: (matches: Array>) => {\n matches = matches.slice(\n matches.findIndex((d) => d.id === contextMatchId) + 1,\n )\n return opts?.select ? opts.select(matches) : matches\n },\n structuralSharing: opts?.structuralSharing,\n } as any)\n}\n", "import { RouterCore } from '@tanstack/router-core'\nimport { createFileRoute, createLazyFileRoute } from './fileRoute'\nimport type { RouterHistory } from '@tanstack/history'\nimport type {\n AnyRoute,\n CreateRouterFn,\n RouterConstructorOptions,\n TrailingSlashOption,\n} from '@tanstack/router-core'\n\nimport type {\n ErrorRouteComponent,\n NotFoundRouteComponent,\n RouteComponent,\n} from './route'\n\ndeclare module '@tanstack/router-core' {\n export interface RouterOptionsExtensions {\n /**\n * The default `component` a route should use if no component is provided.\n *\n * @default Outlet\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultcomponent-property)\n */\n defaultComponent?: RouteComponent\n /**\n * The default `errorComponent` a route should use if no error component is provided.\n *\n * @default ErrorComponent\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaulterrorcomponent-property)\n * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#handling-errors-with-routeoptionserrorcomponent)\n */\n defaultErrorComponent?: ErrorRouteComponent\n /**\n * The default `pendingComponent` a route should use if no pending component is provided.\n *\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpendingcomponent-property)\n * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#showing-a-pending-component)\n */\n defaultPendingComponent?: RouteComponent\n /**\n * The default `notFoundComponent` a route should use if no notFound component is provided.\n *\n * @default NotFound\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultnotfoundcomponent-property)\n * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/not-found-errors#default-router-wide-not-found-handling)\n */\n defaultNotFoundComponent?: NotFoundRouteComponent\n /**\n * A component that will be used to wrap the entire router.\n *\n * This is useful for providing a context to the entire router.\n *\n * Only non-DOM-rendering components like providers should be used, anything else will cause a hydration error.\n *\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#wrap-property)\n */\n Wrap?: (props: { children: any }) => React.JSX.Element\n /**\n * A component that will be used to wrap the inner contents of the router.\n *\n * This is useful for providing a context to the inner contents of the router where you also need access to the router context and hooks.\n *\n * Only non-DOM-rendering components like providers should be used, anything else will cause a hydration error.\n *\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#innerwrap-property)\n */\n InnerWrap?: (props: { children: any }) => React.JSX.Element\n\n /**\n * The default `onCatch` handler for errors caught by the Router ErrorBoundary\n *\n * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultoncatch-property)\n * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#handling-errors-with-routeoptionsoncatch)\n */\n defaultOnCatch?: (error: Error, errorInfo: React.ErrorInfo) => void\n }\n}\n\n/**\n * Creates a new Router instance for React.\n *\n * Pass the returned router to `RouterProvider` to enable routing.\n * Notable options: `routeTree` (your route definitions) and `context`\n * (required if the root route was created with `createRootRouteWithContext`).\n *\n * @param options Router options used to configure the router.\n * @returns A Router instance to be provided to `RouterProvider`.\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouterFunction\n */\nexport const createRouter: CreateRouterFn = (options) => {\n return new Router(options)\n}\n\nexport class Router<\n in out TRouteTree extends AnyRoute,\n in out TTrailingSlashOption extends TrailingSlashOption = 'never',\n in out TDefaultStructuralSharingOption extends boolean = false,\n in out TRouterHistory extends RouterHistory = RouterHistory,\n in out TDehydrated extends Record = Record,\n> extends RouterCore<\n TRouteTree,\n TTrailingSlashOption,\n TDefaultStructuralSharingOption,\n TRouterHistory,\n TDehydrated\n> {\n constructor(\n options: RouterConstructorOptions<\n TRouteTree,\n TTrailingSlashOption,\n TDefaultStructuralSharingOption,\n TRouterHistory,\n TDehydrated\n >,\n ) {\n super(options)\n }\n}\n\nif (typeof globalThis !== 'undefined') {\n ;(globalThis as any).createFileRoute = createFileRoute\n ;(globalThis as any).createLazyFileRoute = createLazyFileRoute\n} else if (typeof window !== 'undefined') {\n ;(window as any).createFileRoute = createFileRoute\n ;(window as any).createLazyFileRoute = createLazyFileRoute\n}\n", "import * as React from 'react'\nimport { Matches } from './Matches'\nimport { routerContext } from './routerContext'\nimport type {\n AnyRouter,\n RegisteredRouter,\n RouterOptions,\n} from '@tanstack/router-core'\n\n/**\n * Low-level provider that places the router into React context and optionally\n * updates router options from props. Most apps should use `RouterProvider`.\n */\nexport function RouterContextProvider<\n TRouter extends AnyRouter = RegisteredRouter,\n TDehydrated extends Record = Record,\n>({\n router,\n children,\n ...rest\n}: RouterProps & {\n children: React.ReactNode\n}) {\n if (Object.keys(rest).length > 0) {\n // Allow the router to update options on the router instance\n router.update({\n ...router.options,\n ...rest,\n context: {\n ...router.options.context,\n ...rest.context,\n },\n })\n }\n\n const provider = (\n \n {children}\n \n )\n\n if (router.options.Wrap) {\n return {provider}\n }\n\n return provider\n}\n\n/**\n * Top-level component that renders the active route matches and provides the\n * router to the React tree via context.\n *\n * Accepts the same options as `createRouter` via props to update the router\n * instance after creation.\n *\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouterFunction\n */\nexport function RouterProvider<\n TRouter extends AnyRouter = RegisteredRouter,\n TDehydrated extends Record = Record,\n>({ router, ...rest }: RouterProps) {\n return (\n \n \n \n )\n}\n\nexport type RouterProps<\n TRouter extends AnyRouter = RegisteredRouter,\n TDehydrated extends Record = Record,\n> = Omit<\n RouterOptions<\n TRouter['routeTree'],\n NonNullable,\n NonNullable,\n TRouter['history'],\n TDehydrated\n >,\n 'context'\n> & {\n router: TRouter\n context?: Partial<\n RouterOptions<\n TRouter['routeTree'],\n NonNullable,\n NonNullable,\n TRouter['history'],\n TDehydrated\n >['context']\n >\n}\n", "import {\n defaultGetScrollRestorationKey,\n getCssSelector,\n scrollRestorationCache,\n setupScrollRestoration,\n} from '@tanstack/router-core'\nimport { useRouter } from './useRouter'\nimport type {\n ParsedLocation,\n ScrollRestorationEntry,\n ScrollRestorationOptions,\n} from '@tanstack/router-core'\n\nfunction useScrollRestoration() {\n const router = useRouter()\n setupScrollRestoration(router, true)\n}\n\n/**\n * @deprecated Use the `scrollRestoration` router option instead.\n */\nexport function ScrollRestoration(_props: ScrollRestorationOptions) {\n useScrollRestoration()\n\n if (process.env.NODE_ENV === 'development') {\n console.warn(\n \"The ScrollRestoration component is deprecated. Use createRouter's `scrollRestoration` option instead.\",\n )\n }\n\n return null\n}\n\nexport function useElementScrollRestoration(\n options: (\n | {\n id: string\n getElement?: () => Window | Element | undefined | null\n }\n | {\n id?: string\n getElement: () => Window | Element | undefined | null\n }\n ) & {\n getKey?: (location: ParsedLocation) => string\n },\n): ScrollRestorationEntry | undefined {\n useScrollRestoration()\n\n const router = useRouter()\n const getKey = options.getKey || defaultGetScrollRestorationKey\n\n let elementSelector = ''\n\n if (options.id) {\n elementSelector = `[data-scroll-restoration-id=\"${options.id}\"]`\n } else {\n const element = options.getElement?.()\n if (!element) {\n return\n }\n elementSelector =\n element instanceof Window ? 'window' : getCssSelector(element)\n }\n\n const restoreKey = getKey(router.latestLocation)\n const byKey = scrollRestorationCache?.state[restoreKey]\n return byKey?.[elementSelector]\n}\n", "import * as React from 'react'\nimport { useRouter } from './useRouter'\nimport type {\n BlockerFnArgs,\n HistoryAction,\n HistoryLocation,\n} from '@tanstack/history'\nimport type {\n AnyRoute,\n AnyRouter,\n ParseRoute,\n RegisteredRouter,\n} from '@tanstack/router-core'\n\ninterface ShouldBlockFnLocation<\n out TRouteId,\n out TFullPath,\n out TAllParams,\n out TFullSearchSchema,\n> {\n routeId: TRouteId\n fullPath: TFullPath\n pathname: string\n params: TAllParams\n search: TFullSearchSchema\n}\n\ntype AnyShouldBlockFnLocation = ShouldBlockFnLocation\ntype MakeShouldBlockFnLocationUnion<\n TRouter extends AnyRouter = RegisteredRouter,\n TRoute extends AnyRoute = ParseRoute,\n> = TRoute extends any\n ? ShouldBlockFnLocation<\n TRoute['id'],\n TRoute['fullPath'],\n TRoute['types']['allParams'],\n TRoute['types']['fullSearchSchema']\n >\n : never\n\ntype BlockerResolver =\n | {\n status: 'blocked'\n current: MakeShouldBlockFnLocationUnion\n next: MakeShouldBlockFnLocationUnion\n action: HistoryAction\n proceed: () => void\n reset: () => void\n }\n | {\n status: 'idle'\n current: undefined\n next: undefined\n action: undefined\n proceed: undefined\n reset: undefined\n }\n\ntype ShouldBlockFnArgs = {\n current: MakeShouldBlockFnLocationUnion\n next: MakeShouldBlockFnLocationUnion\n action: HistoryAction\n}\n\nexport type ShouldBlockFn = (\n args: ShouldBlockFnArgs,\n) => boolean | Promise\nexport type UseBlockerOpts<\n TRouter extends AnyRouter = RegisteredRouter,\n TWithResolver extends boolean = boolean,\n> = {\n shouldBlockFn: ShouldBlockFn\n enableBeforeUnload?: boolean | (() => boolean)\n disabled?: boolean\n withResolver?: TWithResolver\n}\n\ntype LegacyBlockerFn = () => Promise | any\ntype LegacyBlockerOpts = {\n blockerFn?: LegacyBlockerFn\n condition?: boolean | any\n}\n\nfunction _resolveBlockerOpts(\n opts?: UseBlockerOpts | LegacyBlockerOpts | LegacyBlockerFn,\n condition?: boolean | any,\n): UseBlockerOpts {\n if (opts === undefined) {\n return {\n shouldBlockFn: () => true,\n withResolver: false,\n }\n }\n\n if ('shouldBlockFn' in opts) {\n return opts\n }\n\n if (typeof opts === 'function') {\n const shouldBlock = Boolean(condition ?? true)\n\n const _customBlockerFn = async () => {\n if (shouldBlock) return await opts()\n return false\n }\n\n return {\n shouldBlockFn: _customBlockerFn,\n enableBeforeUnload: shouldBlock,\n withResolver: false,\n }\n }\n\n const shouldBlock = Boolean(opts.condition ?? true)\n const fn = opts.blockerFn\n\n const _customBlockerFn = async () => {\n if (shouldBlock && fn !== undefined) {\n return await fn()\n }\n return shouldBlock\n }\n\n return {\n shouldBlockFn: _customBlockerFn,\n enableBeforeUnload: shouldBlock,\n withResolver: fn === undefined,\n }\n}\n\nexport function useBlocker<\n TRouter extends AnyRouter = RegisteredRouter,\n TWithResolver extends boolean = false,\n>(\n opts: UseBlockerOpts,\n): TWithResolver extends true ? BlockerResolver : void\n\n/**\n * @deprecated Use the shouldBlockFn property instead\n */\nexport function useBlocker(blockerFnOrOpts?: LegacyBlockerOpts): BlockerResolver\n\n/**\n * @deprecated Use the UseBlockerOpts object syntax instead\n */\nexport function useBlocker(\n blockerFn?: LegacyBlockerFn,\n condition?: boolean | any,\n): BlockerResolver\n\nexport function useBlocker(\n opts?: UseBlockerOpts | LegacyBlockerOpts | LegacyBlockerFn,\n condition?: boolean | any,\n): BlockerResolver | void {\n const {\n shouldBlockFn,\n enableBeforeUnload = true,\n disabled = false,\n withResolver = false,\n } = _resolveBlockerOpts(opts, condition)\n\n const router = useRouter()\n const { history } = router\n\n const [resolver, setResolver] = React.useState({\n status: 'idle',\n current: undefined,\n next: undefined,\n action: undefined,\n proceed: undefined,\n reset: undefined,\n })\n\n React.useEffect(() => {\n const blockerFnComposed = async (blockerFnArgs: BlockerFnArgs) => {\n function getLocation(\n location: HistoryLocation,\n ): AnyShouldBlockFnLocation {\n const parsedLocation = router.parseLocation(location)\n const matchedRoutes = router.getMatchedRoutes(parsedLocation.pathname)\n if (matchedRoutes.foundRoute === undefined) {\n return {\n routeId: '__notFound__',\n fullPath: parsedLocation.pathname,\n pathname: parsedLocation.pathname,\n params: matchedRoutes.routeParams,\n search: router.options.parseSearch(location.search),\n }\n }\n\n return {\n routeId: matchedRoutes.foundRoute.id,\n fullPath: matchedRoutes.foundRoute.fullPath,\n pathname: parsedLocation.pathname,\n params: matchedRoutes.routeParams,\n search: router.options.parseSearch(location.search),\n }\n }\n\n const current = getLocation(blockerFnArgs.currentLocation)\n const next = getLocation(blockerFnArgs.nextLocation)\n\n if (\n current.routeId === '__notFound__' &&\n next.routeId !== '__notFound__'\n ) {\n return false\n }\n\n const shouldBlock = await shouldBlockFn({\n action: blockerFnArgs.action,\n current,\n next,\n })\n if (!withResolver) {\n return shouldBlock\n }\n\n if (!shouldBlock) {\n return false\n }\n\n const promise = new Promise((resolve) => {\n setResolver({\n status: 'blocked',\n current,\n next,\n action: blockerFnArgs.action,\n proceed: () => resolve(false),\n reset: () => resolve(true),\n })\n })\n\n const canNavigateAsync = await promise\n setResolver({\n status: 'idle',\n current: undefined,\n next: undefined,\n action: undefined,\n proceed: undefined,\n reset: undefined,\n })\n\n return canNavigateAsync\n }\n\n return disabled\n ? undefined\n : history.block({ blockerFn: blockerFnComposed, enableBeforeUnload })\n }, [\n shouldBlockFn,\n enableBeforeUnload,\n disabled,\n withResolver,\n history,\n router,\n ])\n\n return resolver\n}\n\nconst _resolvePromptBlockerArgs = (\n props: PromptProps | LegacyPromptProps,\n): UseBlockerOpts => {\n if ('shouldBlockFn' in props) {\n return { ...props }\n }\n\n const shouldBlock = Boolean(props.condition ?? true)\n const fn = props.blockerFn\n\n const _customBlockerFn = async () => {\n if (shouldBlock && fn !== undefined) {\n return await fn()\n }\n return shouldBlock\n }\n\n return {\n shouldBlockFn: _customBlockerFn,\n enableBeforeUnload: shouldBlock,\n withResolver: fn === undefined,\n }\n}\n\nexport function Block<\n TRouter extends AnyRouter = RegisteredRouter,\n TWithResolver extends boolean = boolean,\n>(opts: PromptProps): React.ReactNode\n\n/**\n * @deprecated Use the UseBlockerOpts property instead\n */\nexport function Block(opts: LegacyPromptProps): React.ReactNode\n\nexport function Block(opts: PromptProps | LegacyPromptProps): React.ReactNode {\n const { children, ...rest } = opts\n const args = _resolvePromptBlockerArgs(rest)\n\n const resolver = useBlocker(args)\n return children\n ? typeof children === 'function'\n ? children(resolver as any)\n : children\n : null\n}\n\ntype LegacyPromptProps = {\n blockerFn?: LegacyBlockerFn\n condition?: boolean | any\n children?: React.ReactNode | ((params: BlockerResolver) => React.ReactNode)\n}\n\ntype PromptProps<\n TRouter extends AnyRouter = RegisteredRouter,\n TWithResolver extends boolean = boolean,\n TParams = TWithResolver extends true ? BlockerResolver : void,\n> = UseBlockerOpts & {\n children?: React.ReactNode | ((params: TParams) => React.ReactNode)\n}\n", "import { useRouterState } from './useRouterState'\nimport type {\n StructuralSharingOption,\n ValidateSelected,\n} from './structuralSharing'\nimport type {\n AnyRouter,\n RegisteredRouter,\n RouterState,\n} from '@tanstack/router-core'\n\nexport interface UseLocationBaseOptions<\n TRouter extends AnyRouter,\n TSelected,\n TStructuralSharing extends boolean = boolean,\n> {\n select?: (\n state: RouterState['location'],\n ) => ValidateSelected\n}\n\nexport type UseLocationResult<\n TRouter extends AnyRouter,\n TSelected,\n> = unknown extends TSelected\n ? RouterState['location']\n : TSelected\n\n/**\n * Read the current location from the router state with optional selection.\n * Useful for subscribing to just the pieces of location you care about.\n *\n * Options:\n * - `select`: Project the `location` object to a derived value\n * - `structuralSharing`: Enable structural sharing for stable references\n *\n * @returns The current location (or selected value).\n * @link https://tanstack.com/router/latest/docs/framework/react/api/router/useLocationHook\n */\nexport function useLocation<\n TRouter extends AnyRouter = RegisteredRouter,\n TSelected = unknown,\n TStructuralSharing extends boolean = boolean,\n>(\n opts?: UseLocationBaseOptions &\n StructuralSharingOption,\n): UseLocationResult {\n return useRouterState({\n select: (state: any) =>\n opts?.select ? opts.select(state.location) : state.location,\n } as any) as UseLocationResult\n}\n", "import { useRouterState } from './useRouterState'\n\nexport function useCanGoBack() {\n return useRouterState({ select: (s) => s.location.state.__TSR_index !== 0 })\n}\n", "import * as React from 'react'\nimport { isServer } from '@tanstack/router-core/isServer'\nimport { useRouter } from './useRouter'\nimport { useHydrated } from './ClientOnly'\nimport type { RouterManagedTag } from '@tanstack/router-core'\n\ninterface ScriptAttrs {\n [key: string]: string | boolean | undefined\n src?: string\n suppressHydrationWarning?: boolean\n}\n\nexport function Asset({\n tag,\n attrs,\n children,\n nonce,\n}: RouterManagedTag & { nonce?: string }): React.ReactElement | null {\n switch (tag) {\n case 'title':\n return (\n \n {children}\n \n )\n case 'meta':\n return \n case 'link':\n return \n case 'style':\n return (\n \n )\n case 'script':\n return \n default:\n return null\n }\n}\n\nfunction Script({\n attrs,\n children,\n}: {\n attrs?: ScriptAttrs\n children?: string\n}) {\n const router = useRouter()\n const hydrated = useHydrated()\n const dataScript =\n typeof attrs?.type === 'string' &&\n attrs.type !== '' &&\n attrs.type !== 'text/javascript' &&\n attrs.type !== 'module'\n\n if (\n process.env.NODE_ENV !== 'production' &&\n attrs?.src &&\n typeof children === 'string' &&\n children.trim().length\n ) {\n console.warn(\n '[TanStack Router] - OpenHandoff + Sandbox Agent Factory
diff --git a/factory/packages/frontend/package.json b/factory/packages/frontend/package.json index 4d00b9f..09c1871 100644 --- a/factory/packages/frontend/package.json +++ b/factory/packages/frontend/package.json @@ -1,5 +1,5 @@ { - "name": "@openhandoff/frontend", + "name": "@sandbox-agent/factory-frontend", "version": "0.1.0", "private": true, "type": "module", @@ -10,9 +10,9 @@ "test": "vitest run" }, "dependencies": { - "@openhandoff/client": "workspace:*", - "@openhandoff/frontend-errors": "workspace:*", - "@openhandoff/shared": "workspace:*", + "@sandbox-agent/factory-client": "workspace:*", + "@sandbox-agent/factory-frontend-errors": "workspace:*", + "@sandbox-agent/factory-shared": "workspace:*", "@tanstack/react-query": "^5.85.5", "@tanstack/react-router": "^1.132.23", "baseui": "^16.1.1", diff --git a/factory/packages/frontend/src/app/router.tsx b/factory/packages/frontend/src/app/router.tsx index 2719736..422631b 100644 --- a/factory/packages/frontend/src/app/router.tsx +++ b/factory/packages/frontend/src/app/router.tsx @@ -1,16 +1,33 @@ -import { useEffect } from "react"; -import { setFrontendErrorContext } from "@openhandoff/frontend-errors/client"; +import { useEffect, useSyncExternalStore } from "react"; +import { setFrontendErrorContext } from "@sandbox-agent/factory-frontend-errors/client"; +import { type MockBillingPlanId } from "@sandbox-agent/factory-client"; import { Navigate, Outlet, createRootRoute, createRoute, createRouter, + useNavigate, useRouterState, } from "@tanstack/react-router"; import { MockLayout } from "../components/mock-layout"; +import { + MockHostedCheckoutPage, + MockOrganizationBillingPage, + MockOrganizationImportPage, + MockOrganizationSelectorPage, + MockOrganizationSettingsPage, + MockSignInPage, +} from "../components/mock-onboarding"; import { defaultWorkspaceId } from "../lib/env"; -import { handoffWorkbenchClient } from "../lib/workbench"; +import { + activeMockOrganization, + activeMockUser, + getMockOrganizationById, + eligibleOrganizations, + useMockAppSnapshot, +} from "../lib/mock-app"; +import { getHandoffWorkbenchClient, resolveRepoRouteHandoffId } from "../lib/workbench"; const rootRoute = createRootRoute({ component: RootLayout, @@ -19,13 +36,43 @@ const rootRoute = createRootRoute({ const indexRoute = createRoute({ getParentRoute: () => rootRoute, path: "/", - component: () => ( - - ), + component: IndexRoute, +}); + +const signInRoute = createRoute({ + getParentRoute: () => rootRoute, + path: "/signin", + component: SignInRoute, +}); + +const organizationsRoute = createRoute({ + getParentRoute: () => rootRoute, + path: "/organizations", + component: OrganizationsRoute, +}); + +const organizationImportRoute = createRoute({ + getParentRoute: () => rootRoute, + path: "/organizations/$organizationId/import", + component: OrganizationImportRoute, +}); + +const organizationSettingsRoute = createRoute({ + getParentRoute: () => rootRoute, + path: "/organizations/$organizationId/settings", + component: OrganizationSettingsRoute, +}); + +const organizationBillingRoute = createRoute({ + getParentRoute: () => rootRoute, + path: "/organizations/$organizationId/billing", + component: OrganizationBillingRoute, +}); + +const organizationCheckoutRoute = createRoute({ + getParentRoute: () => rootRoute, + path: "/organizations/$organizationId/checkout/$planId", + component: OrganizationCheckoutRoute, }); const workspaceRoute = createRoute({ @@ -57,6 +104,12 @@ const repoRoute = createRoute({ const routeTree = rootRoute.addChildren([ indexRoute, + signInRoute, + organizationsRoute, + organizationImportRoute, + organizationSettingsRoute, + organizationBillingRoute, + organizationCheckoutRoute, workspaceRoute.addChildren([workspaceIndexRoute, handoffRoute, repoRoute]), ]); @@ -72,32 +125,141 @@ function WorkspaceLayoutRoute() { return ; } +function IndexRoute() { + const snapshot = useMockAppSnapshot(); + return ; +} + +function SignInRoute() { + const snapshot = useMockAppSnapshot(); + + if (snapshot.auth.status === "signed_in") { + return ; + } + + return ; +} + +function OrganizationsRoute() { + const snapshot = useMockAppSnapshot(); + + if (snapshot.auth.status === "signed_out") { + return ; + } + + return ; +} + +function OrganizationImportRoute() { + const snapshot = useMockAppSnapshot(); + const organization = useGuardedMockOrganization(organizationImportRoute.useParams().organizationId); + + if (snapshot.auth.status === "signed_out") { + return ; + } + + if (!organization) { + return ; + } + + return ; +} + +function OrganizationSettingsRoute() { + const snapshot = useMockAppSnapshot(); + const organization = useGuardedMockOrganization(organizationSettingsRoute.useParams().organizationId); + + if (snapshot.auth.status === "signed_out") { + return ; + } + + if (!organization) { + return ; + } + + return ; +} + +function OrganizationBillingRoute() { + const snapshot = useMockAppSnapshot(); + const organization = useGuardedMockOrganization(organizationBillingRoute.useParams().organizationId); + + if (snapshot.auth.status === "signed_out") { + return ; + } + + if (!organization) { + return ; + } + + return ; +} + +function OrganizationCheckoutRoute() { + const { organizationId, planId } = organizationCheckoutRoute.useParams(); + const snapshot = useMockAppSnapshot(); + const organization = useGuardedMockOrganization(organizationId); + + if (snapshot.auth.status === "signed_out") { + return ; + } + + if (!organization) { + return ; + } + + if (!isMockBillingPlanId(planId)) { + return ( + + ); + } + + return ; +} + function WorkspaceRoute() { const { workspaceId } = workspaceRoute.useParams(); - useEffect(() => { - setFrontendErrorContext({ - workspaceId, - handoffId: undefined, - }); - }, [workspaceId]); - return ; + + return ( + + + + ); } function HandoffRoute() { const { workspaceId, handoffId } = handoffRoute.useParams(); const { sessionId } = handoffRoute.useSearch(); - useEffect(() => { - setFrontendErrorContext({ - workspaceId, - handoffId, - repoId: undefined, - }); - }, [handoffId, workspaceId]); - return ; + + return ( + + + + ); } function RepoRoute() { const { workspaceId, repoId } = repoRoute.useParams(); + + return ( + + + + ); +} + +function RepoRouteInner({ workspaceId, repoId }: { workspaceId: string; repoId: string }) { + const client = getHandoffWorkbenchClient(workspaceId); + const snapshot = useSyncExternalStore( + client.subscribe.bind(client), + client.getSnapshot.bind(client), + client.getSnapshot.bind(client), + ); + useEffect(() => { setFrontendErrorContext({ workspaceId, @@ -105,9 +267,8 @@ function RepoRoute() { repoId, }); }, [repoId, workspaceId]); - const activeHandoffId = handoffWorkbenchClient.getSnapshot().handoffs.find( - (handoff) => handoff.repoId === repoId, - )?.id; + + const activeHandoffId = resolveRepoRouteHandoffId(snapshot, repoId); if (!activeHandoffId) { return ( candidate.workspaceId === workspaceId) ?? null; + + useEffect(() => { + setFrontendErrorContext({ + workspaceId, + handoffId: selectedHandoffId ?? undefined, + repoId: undefined, + }); + }, [selectedHandoffId, workspaceId]); + + return ( + void navigate({ to: "/organizations" }), + }, + { + label: "Settings", + onClick: () => + void navigate({ + to: "/organizations/$organizationId/settings", + params: { organizationId: organization.id }, + }), + }, + { + label: "Billing", + onClick: () => + void navigate({ + to: "/organizations/$organizationId/billing", + params: { organizationId: organization.id }, + }), + }, + ] + : undefined + } + /> + ); +} + +function MockWorkspaceGate({ + workspaceId, + children, +}: { + workspaceId: string; + children: React.ReactNode; +}) { + const snapshot = useMockAppSnapshot(); + + if (snapshot.auth.status === "signed_out") { + return ; + } + + const activeOrganization = activeMockOrganization(snapshot); + const workspaceOrganization = eligibleOrganizations(snapshot).find((candidate) => candidate.workspaceId === workspaceId) ?? null; + + if (!workspaceOrganization) { + return ; + } + + if (!activeOrganization || activeOrganization.id !== workspaceOrganization.id) { + return ; + } + + if (workspaceOrganization.repoImportStatus !== "ready") { + return ( + + ); + } + + return <>{children}; +} + +function NavigateToMockHome({ + snapshot, + replace = false, +}: { + snapshot: ReturnType; + replace?: boolean; +}) { + const activeOrganization = activeMockOrganization(snapshot); + const organizations = eligibleOrganizations(snapshot); + const targetOrganization = + activeOrganization ?? (organizations.length === 1 ? organizations[0] ?? null : null); + + if (snapshot.auth.status === "signed_out" || !activeMockUser(snapshot)) { + return ; + } + + if (!targetOrganization) { + return snapshot.users.length === 0 ? ( + + ) : ( + + ); + } + + if (targetOrganization.repoImportStatus !== "ready") { + return ( + + ); + } + + return ( + + ); +} + +function useGuardedMockOrganization(organizationId: string) { + const snapshot = useMockAppSnapshot(); + const user = activeMockUser(snapshot); + + if (!user) { + return null; + } + + const organization = getMockOrganizationById(snapshot, organizationId); + if (!organization) { + return null; + } + + return user.eligibleOrganizationIds.includes(organization.id) ? organization : null; +} + +function isMockBillingPlanId(planId: string): planId is MockBillingPlanId { + return planId === "free" || planId === "team" || planId === "enterprise"; +} + function RootLayout() { return ( <> diff --git a/factory/packages/frontend/src/components/mock-layout.tsx b/factory/packages/frontend/src/components/mock-layout.tsx index 68dd14f..bdc64a6 100644 --- a/factory/packages/frontend/src/components/mock-layout.tsx +++ b/factory/packages/frontend/src/components/mock-layout.tsx @@ -1,4 +1,5 @@ import { memo, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from "react"; +import type { HandoffWorkbenchClient } from "@sandbox-agent/factory-client"; import { useNavigate } from "@tanstack/react-router"; import { DiffContent } from "./mock-layout/diff-content"; @@ -8,7 +9,8 @@ import { RightSidebar } from "./mock-layout/right-sidebar"; import { Sidebar } from "./mock-layout/sidebar"; import { TabStrip } from "./mock-layout/tab-strip"; import { TranscriptHeader } from "./mock-layout/transcript-header"; -import { PROMPT_TEXTAREA_MAX_HEIGHT, PROMPT_TEXTAREA_MIN_HEIGHT, SPanel, ScrollBody, Shell } from "./mock-layout/ui"; +import { RightSidebarSkeleton, SidebarSkeleton, TranscriptSkeleton } from "./mock-layout/skeleton"; +import { PROMPT_TEXTAREA_MAX_HEIGHT, PROMPT_TEXTAREA_MIN_HEIGHT, PanelHeaderBar, SPanel, ScrollBody, Shell } from "./mock-layout/ui"; import { buildDisplayMessages, buildHistoryEvents, @@ -22,7 +24,6 @@ import { type Message, type ModelId, } from "./mock-layout/view-model"; -import { handoffWorkbenchClient } from "../lib/workbench"; function firstAgentTabId(handoff: Handoff): string | null { return handoff.tabs[0]?.id ?? null; @@ -63,6 +64,7 @@ function sanitizeActiveTabId( } const TranscriptPanel = memo(function TranscriptPanel({ + client, handoff, activeTabId, lastAgentTabId, @@ -72,6 +74,7 @@ const TranscriptPanel = memo(function TranscriptPanel({ onSetLastAgentTabId, onSetOpenDiffs, }: { + client: HandoffWorkbenchClient; handoff: Handoff; activeTabId: string | null; lastAgentTabId: string | null; @@ -172,12 +175,12 @@ const TranscriptPanel = memo(function TranscriptPanel({ return; } - void handoffWorkbenchClient.setSessionUnread({ + void client.setSessionUnread({ handoffId: handoff.id, tabId: activeAgentTab.id, unread: false, }); - }, [activeAgentTab?.id, activeAgentTab?.unread, handoff.id]); + }, [activeAgentTab?.id, activeAgentTab?.unread, client, handoff.id]); const startEditingField = useCallback((field: "title" | "branch", value: string) => { setEditingField(field); @@ -197,13 +200,13 @@ const TranscriptPanel = memo(function TranscriptPanel({ } if (field === "title") { - void handoffWorkbenchClient.renameHandoff({ handoffId: handoff.id, value }); + void client.renameHandoff({ handoffId: handoff.id, value }); } else { - void handoffWorkbenchClient.renameBranch({ handoffId: handoff.id, value }); + void client.renameBranch({ handoffId: handoff.id, value }); } setEditingField(null); }, - [editValue, handoff.id], + [client, editValue, handoff.id], ); const updateDraft = useCallback( @@ -212,14 +215,14 @@ const TranscriptPanel = memo(function TranscriptPanel({ return; } - void handoffWorkbenchClient.updateDraft({ + void client.updateDraft({ handoffId: handoff.id, tabId: promptTab.id, text: nextText, attachments: nextAttachments, }); }, - [handoff.id, promptTab], + [client, handoff.id, promptTab], ); const sendMessage = useCallback(() => { @@ -230,24 +233,24 @@ const TranscriptPanel = memo(function TranscriptPanel({ onSetActiveTabId(promptTab.id); onSetLastAgentTabId(promptTab.id); - void handoffWorkbenchClient.sendMessage({ + void client.sendMessage({ handoffId: handoff.id, tabId: promptTab.id, text, attachments, }); - }, [attachments, draft, handoff.id, onSetActiveTabId, onSetLastAgentTabId, promptTab]); + }, [attachments, client, draft, handoff.id, onSetActiveTabId, onSetLastAgentTabId, promptTab]); const stopAgent = useCallback(() => { if (!promptTab) { return; } - void handoffWorkbenchClient.stopAgent({ + void client.stopAgent({ handoffId: handoff.id, tabId: promptTab.id, }); - }, [handoff.id, promptTab]); + }, [client, handoff.id, promptTab]); const switchTab = useCallback( (tabId: string) => { @@ -257,7 +260,7 @@ const TranscriptPanel = memo(function TranscriptPanel({ onSetLastAgentTabId(tabId); const tab = handoff.tabs.find((candidate) => candidate.id === tabId); if (tab?.unread) { - void handoffWorkbenchClient.setSessionUnread({ + void client.setSessionUnread({ handoffId: handoff.id, tabId, unread: false, @@ -266,14 +269,14 @@ const TranscriptPanel = memo(function TranscriptPanel({ onSyncRouteSession(handoff.id, tabId); } }, - [handoff.id, handoff.tabs, onSetActiveTabId, onSetLastAgentTabId, onSyncRouteSession], + [client, handoff.id, handoff.tabs, onSetActiveTabId, onSetLastAgentTabId, onSyncRouteSession], ); const setTabUnread = useCallback( (tabId: string, unread: boolean) => { - void handoffWorkbenchClient.setSessionUnread({ handoffId: handoff.id, tabId, unread }); + void client.setSessionUnread({ handoffId: handoff.id, tabId, unread }); }, - [handoff.id], + [client, handoff.id], ); const startRenamingTab = useCallback( @@ -305,13 +308,13 @@ const TranscriptPanel = memo(function TranscriptPanel({ return; } - void handoffWorkbenchClient.renameSession({ + void client.renameSession({ handoffId: handoff.id, tabId: editingSessionTabId, title: trimmedName, }); cancelTabRename(); - }, [cancelTabRename, editingSessionName, editingSessionTabId, handoff.id]); + }, [cancelTabRename, client, editingSessionName, editingSessionTabId, handoff.id]); const closeTab = useCallback( (tabId: string) => { @@ -326,9 +329,9 @@ const TranscriptPanel = memo(function TranscriptPanel({ } onSyncRouteSession(handoff.id, nextTabId); - void handoffWorkbenchClient.closeTab({ handoffId: handoff.id, tabId }); + void client.closeTab({ handoffId: handoff.id, tabId }); }, - [activeTabId, handoff.id, handoff.tabs, lastAgentTabId, onSetActiveTabId, onSetLastAgentTabId, onSyncRouteSession], + [activeTabId, client, handoff.id, handoff.tabs, lastAgentTabId, onSetActiveTabId, onSetLastAgentTabId, onSyncRouteSession], ); const closeDiffTab = useCallback( @@ -346,12 +349,12 @@ const TranscriptPanel = memo(function TranscriptPanel({ const addTab = useCallback(() => { void (async () => { - const { tabId } = await handoffWorkbenchClient.addTab({ handoffId: handoff.id }); + const { tabId } = await client.addTab({ handoffId: handoff.id }); onSetLastAgentTabId(tabId); onSetActiveTabId(tabId); onSyncRouteSession(handoff.id, tabId); })(); - }, [handoff.id, onSetActiveTabId, onSetLastAgentTabId, onSyncRouteSession]); + }, [client, handoff.id, onSetActiveTabId, onSetLastAgentTabId, onSyncRouteSession]); const changeModel = useCallback( (model: ModelId) => { @@ -359,13 +362,13 @@ const TranscriptPanel = memo(function TranscriptPanel({ throw new Error(`Unable to change model for handoff ${handoff.id} without an active prompt tab`); } - void handoffWorkbenchClient.changeModel({ + void client.changeModel({ handoffId: handoff.id, tabId: promptTab.id, model, }); }, - [handoff.id, promptTab], + [client, handoff.id, promptTab], ); const addAttachment = useCallback( @@ -551,17 +554,32 @@ const TranscriptPanel = memo(function TranscriptPanel({ }); interface MockLayoutProps { + client: HandoffWorkbenchClient; workspaceId: string; selectedHandoffId?: string | null; selectedSessionId?: string | null; + sidebarTitle?: string; + sidebarSubtitle?: string; + sidebarActions?: Array<{ + label: string; + onClick: () => void; + }>; } -export function MockLayout({ workspaceId, selectedHandoffId, selectedSessionId }: MockLayoutProps) { +export function MockLayout({ + client, + workspaceId, + selectedHandoffId, + selectedSessionId, + sidebarTitle, + sidebarSubtitle, + sidebarActions, +}: MockLayoutProps) { const navigate = useNavigate(); const viewModel = useSyncExternalStore( - handoffWorkbenchClient.subscribe.bind(handoffWorkbenchClient), - handoffWorkbenchClient.getSnapshot.bind(handoffWorkbenchClient), - handoffWorkbenchClient.getSnapshot.bind(handoffWorkbenchClient), + client.subscribe.bind(client), + client.getSnapshot.bind(client), + client.getSnapshot.bind(client), ); const handoffs = viewModel.handoffs ?? []; const projects = viewModel.projects ?? []; @@ -661,19 +679,10 @@ export function MockLayout({ workspaceId, selectedHandoffId, selectedSessionId } throw new Error("Cannot create a handoff without an available repo"); } - const task = window.prompt("Describe the handoff task", "Investigate and implement the requested change"); - if (!task) { - return; - } - - const title = window.prompt("Optional handoff title", "")?.trim() || undefined; - const branch = window.prompt("Optional branch name", "")?.trim() || undefined; - const { handoffId, tabId } = await handoffWorkbenchClient.createHandoff({ + const { handoffId, tabId } = await client.createHandoff({ repoId, - task, + task: "", model: "gpt-4o", - ...(title ? { title } : {}), - ...(branch ? { branch } : {}), }); await navigate({ to: "/workspaces/$workspaceId/handoffs/$handoffId", @@ -684,7 +693,7 @@ export function MockLayout({ workspaceId, selectedHandoffId, selectedSessionId } search: { sessionId: tabId ?? undefined }, }); })(); - }, [activeHandoff?.repoId, navigate, viewModel.repos, workspaceId]); + }, [activeHandoff?.repoId, client, navigate, viewModel.repos, workspaceId]); const openDiffTab = useCallback( (path: string) => { @@ -726,8 +735,8 @@ export function MockLayout({ workspaceId, selectedHandoffId, selectedSessionId } ); const markHandoffUnread = useCallback((id: string) => { - void handoffWorkbenchClient.markHandoffUnread({ handoffId: id }); - }, []); + void client.markHandoffUnread({ handoffId: id }); + }, [client]); const renameHandoff = useCallback( (id: string) => { @@ -746,9 +755,9 @@ export function MockLayout({ workspaceId, selectedHandoffId, selectedSessionId } return; } - void handoffWorkbenchClient.renameHandoff({ handoffId: id, value: trimmedTitle }); + void client.renameHandoff({ handoffId: id, value: trimmedTitle }); }, - [handoffs], + [client, handoffs], ); const renameBranch = useCallback( @@ -768,24 +777,31 @@ export function MockLayout({ workspaceId, selectedHandoffId, selectedSessionId } return; } - void handoffWorkbenchClient.renameBranch({ handoffId: id, value: trimmedBranch }); + void client.renameBranch({ handoffId: id, value: trimmedBranch }); }, - [handoffs], + [client, handoffs], ); const archiveHandoff = useCallback(() => { if (!activeHandoff) { throw new Error("Cannot archive without an active handoff"); } - void handoffWorkbenchClient.archiveHandoff({ handoffId: activeHandoff.id }); - }, [activeHandoff]); + void client.archiveHandoff({ handoffId: activeHandoff.id }); + }, [activeHandoff, client]); const publishPr = useCallback(() => { if (!activeHandoff) { throw new Error("Cannot publish PR without an active handoff"); } - void handoffWorkbenchClient.publishPr({ handoffId: activeHandoff.id }); - }, [activeHandoff]); + void client.publishPr({ handoffId: activeHandoff.id }); + }, [activeHandoff, client]); + + const pushHandoff = useCallback(() => { + if (!activeHandoff) { + throw new Error("Cannot push without an active handoff"); + } + void client.pushHandoff({ handoffId: activeHandoff.id }); + }, [activeHandoff, client]); const revertFile = useCallback( (path: string) => { @@ -804,20 +820,54 @@ export function MockLayout({ workspaceId, selectedHandoffId, selectedSessionId } : current[activeHandoff.id] ?? null, })); - void handoffWorkbenchClient.revertFile({ + void client.revertFile({ handoffId: activeHandoff.id, path, }); }, - [activeHandoff, lastAgentTabIdByHandoff], + [activeHandoff, client, lastAgentTabIdByHandoff], ); + // Show full-page skeleton while the client snapshot is still empty (initial load) + const isInitialLoad = handoffs.length === 0 && projects.length === 0 && viewModel.repos.length === 0; + if (isInitialLoad) { + return ( + + + +
+ + + + + + + +
+ + + + + +
+ + + + + ); + } + if (!activeHandoff) { return ( diff --git a/factory/packages/frontend/src/components/mock-layout/message-list.tsx b/factory/packages/frontend/src/components/mock-layout/message-list.tsx index baf758f..17949f8 100644 --- a/factory/packages/frontend/src/components/mock-layout/message-list.tsx +++ b/factory/packages/frontend/src/components/mock-layout/message-list.tsx @@ -4,6 +4,7 @@ import { LabelSmall, LabelXSmall } from "baseui/typography"; import { Copy } from "lucide-react"; import { HistoryMinimap } from "./history-minimap"; +import { SkeletonBlock, SkeletonLine } from "./skeleton"; import { SpinnerDot } from "./ui"; import { buildDisplayMessages, formatMessageDuration, formatMessageTimestamp, type AgentTab, type HistoryEvent, type Message } from "./view-model"; @@ -45,21 +46,40 @@ export const MessageList = memo(function MessageList({ })} > {tab && messages.length === 0 ? ( -
- - {!tab.created ? "Choose an agent and model, then send your first message" : "No messages yet in this session"} - -
+ tab.created && tab.status === "running" ? ( + /* New tab that's loading — show message skeleton */ +
+
+ +
+
+ +
+
+ ) : ( +
+ + {!tab.created ? "Choose an agent and model, then send your first message" : "No messages yet in this session"} + +
+ ) ) : null} {messages.map((message) => { const isUser = message.sender === "client"; diff --git a/factory/packages/frontend/src/components/mock-layout/right-sidebar.tsx b/factory/packages/frontend/src/components/mock-layout/right-sidebar.tsx index ae8a1c0..d8927f1 100644 --- a/factory/packages/frontend/src/components/mock-layout/right-sidebar.tsx +++ b/factory/packages/frontend/src/components/mock-layout/right-sidebar.tsx @@ -15,6 +15,49 @@ import { import { type ContextMenuItem, ContextMenuOverlay, PanelHeaderBar, SPanel, ScrollBody, useContextMenu } from "./ui"; import { type FileTreeNode, type Handoff, diffTabId } from "./view-model"; +const StatusCard = memo(function StatusCard({ + label, + value, + mono = false, +}: { + label: string; + value: string; + mono?: boolean; +}) { + const [css, theme] = useStyletron(); + + return ( +
+ + {label} + +
+ {value} +
+
+ ); +}); + const FileTree = memo(function FileTree({ nodes, depth, @@ -106,6 +149,7 @@ export const RightSidebar = memo(function RightSidebar({ activeTabId, onOpenDiff, onArchive, + onPush, onRevertFile, onPublishPr, }: { @@ -113,6 +157,7 @@ export const RightSidebar = memo(function RightSidebar({ activeTabId: string | null; onOpenDiff: (path: string) => void; onArchive: () => void; + onPush: () => void; onRevertFile: (path: string) => void; onPublishPr: () => void; }) { @@ -121,7 +166,12 @@ export const RightSidebar = memo(function RightSidebar({ const contextMenu = useContextMenu(); const changedPaths = useMemo(() => new Set(handoff.fileChanges.map((file) => file.path)), [handoff.fileChanges]); const isTerminal = handoff.status === "archived"; + const canPush = !isTerminal && Boolean(handoff.branch); const pullRequestUrl = handoff.pullRequest != null ? `https://github.com/${handoff.repoName}/pull/${handoff.pullRequest.number}` : null; + const pullRequestStatus = + handoff.pullRequest == null + ? "Not published" + : `#${handoff.pullRequest.number} ${handoff.pullRequest.status === "draft" ? "Draft" : "Ready"}`; const copyFilePath = useCallback(async (path: string) => { try { @@ -183,6 +233,7 @@ export const RightSidebar = memo(function RightSidebar({ {pullRequestUrl ? "Open PR" : "Publish PR"} + {actions && actions.length > 0 ? ( +
+ {actions.map((action) => ( + + ))} +
+ ) : null} + {projects.length === 0 ? ( + + ) : (
{projects.map((project) => { const visibleCount = expandedProjects[project.id] ? project.handoffs.length : Math.min(project.handoffs.length, 5); @@ -92,10 +149,22 @@ export const Sidebar = memo(function Sidebar({ {project.label} - {formatRelativeAge(project.updatedAtMs)} + {project.updatedAtMs > 0 ? formatRelativeAge(project.updatedAtMs) : "No handoffs"}
+ {project.handoffs.length === 0 ? ( +
+ No handoffs yet +
+ ) : null} + {project.handoffs.slice(0, visibleCount).map((handoff) => { const isActive = handoff.id === activeId; const isDim = handoff.status === "archived"; @@ -218,6 +287,7 @@ export const Sidebar = memo(function Sidebar({ ); })}
+ )} {contextMenu.menu ? : null} diff --git a/factory/packages/frontend/src/components/mock-layout/skeleton.tsx b/factory/packages/frontend/src/components/mock-layout/skeleton.tsx new file mode 100644 index 0000000..298fcf4 --- /dev/null +++ b/factory/packages/frontend/src/components/mock-layout/skeleton.tsx @@ -0,0 +1,178 @@ +import { memo } from "react"; + +export const SkeletonLine = memo(function SkeletonLine({ + width = "100%", + height = 12, + borderRadius = 4, + style, +}: { + width?: string | number; + height?: number; + borderRadius?: number; + style?: React.CSSProperties; +}) { + return ( +
+ ); +}); + +export const SkeletonCircle = memo(function SkeletonCircle({ + size = 14, + style, +}: { + size?: number; + style?: React.CSSProperties; +}) { + return ; +}); + +export const SkeletonBlock = memo(function SkeletonBlock({ + width = "100%", + height = 60, + borderRadius = 8, + style, +}: { + width?: string | number; + height?: number; + borderRadius?: number; + style?: React.CSSProperties; +}) { + return ; +}); + +/** Sidebar skeleton: header + list of handoff placeholders */ +export const SidebarSkeleton = memo(function SidebarSkeleton() { + return ( +
+ {/* Project header skeleton */} +
+ + +
+ {/* Handoff item skeletons */} + {[0, 1, 2, 3].map((i) => ( +
+
+ + +
+
+ + +
+
+ ))} +
+ ); +}); + +/** Transcript area skeleton: tab strip + message bubbles */ +export const TranscriptSkeleton = memo(function TranscriptSkeleton() { + return ( +
+ {/* Tab strip skeleton */} +
+
+ + +
+
+ {/* Message skeletons */} +
+ {/* User message */} +
+
+ + +
+
+ {/* Agent message */} +
+
+ + +
+
+ {/* Another user message */} +
+
+ +
+
+
+
+ ); +}); + +/** Right sidebar skeleton: status cards + file list */ +export const RightSidebarSkeleton = memo(function RightSidebarSkeleton() { + return ( +
+ {/* Tab bar skeleton */} +
+ + +
+ {/* Status cards */} +
+ + +
+ {/* File changes */} +
+ {[0, 1, 2].map((i) => ( +
+ + +
+ + +
+
+ ))} +
+
+ ); +}); diff --git a/factory/packages/frontend/src/components/mock-layout/view-model.test.ts b/factory/packages/frontend/src/components/mock-layout/view-model.test.ts index 53b04b2..d3556e5 100644 --- a/factory/packages/frontend/src/components/mock-layout/view-model.test.ts +++ b/factory/packages/frontend/src/components/mock-layout/view-model.test.ts @@ -1,5 +1,5 @@ import { describe, expect, it } from "vitest"; -import type { WorkbenchAgentTab } from "@openhandoff/shared"; +import type { WorkbenchAgentTab } from "@sandbox-agent/factory-shared"; import { buildDisplayMessages } from "./view-model"; function makeTab(transcript: WorkbenchAgentTab["transcript"]): WorkbenchAgentTab { diff --git a/factory/packages/frontend/src/components/mock-layout/view-model.ts b/factory/packages/frontend/src/components/mock-layout/view-model.ts index 1275553..cd4e12e 100644 --- a/factory/packages/frontend/src/components/mock-layout/view-model.ts +++ b/factory/packages/frontend/src/components/mock-layout/view-model.ts @@ -12,7 +12,7 @@ import type { WorkbenchParsedDiffLine as ParsedDiffLine, WorkbenchProjectSection as ProjectSection, WorkbenchTranscriptEvent as TranscriptEvent, -} from "@openhandoff/shared"; +} from "@sandbox-agent/factory-shared"; import { extractEventText } from "../../features/sessions/model"; export type { ProjectSection }; diff --git a/factory/packages/frontend/src/components/mock-onboarding.tsx b/factory/packages/frontend/src/components/mock-onboarding.tsx new file mode 100644 index 0000000..1e90b9c --- /dev/null +++ b/factory/packages/frontend/src/components/mock-onboarding.tsx @@ -0,0 +1,1034 @@ +import { useEffect, useMemo, useState } from "react"; +import { + type FactoryBillingPlanId, + type FactoryOrganization, + type FactoryOrganizationMember, + type FactoryUser, +} from "@sandbox-agent/factory-shared"; +import { useNavigate } from "@tanstack/react-router"; +import { ArrowLeft, BadgeCheck, Building2, CreditCard, Github, LoaderCircle, ShieldCheck, Users } from "lucide-react"; +import { + activeMockUser, + eligibleOrganizations, + useMockAppClient, + useMockAppSnapshot, +} from "../lib/mock-app"; + +const dateFormatter = new Intl.DateTimeFormat("en-US", { + month: "short", + day: "numeric", + year: "numeric", +}); + +const planCatalog: Record< + FactoryBillingPlanId, + { + label: string; + price: string; + seats: string; + summary: string; + } +> = { + free: { + label: "Free", + price: "$0", + seats: "1 seat included", + summary: "Best for a personal workspace and quick evaluations.", + }, + team: { + label: "Team", + price: "$240/mo", + seats: "5 seats included", + summary: "GitHub org onboarding, shared billing, and seat accrual on first prompt.", + }, + enterprise: { + label: "Enterprise", + price: "$1,200/mo", + seats: "25 seats included", + summary: "Enterprise controls, larger seat pools, and procurement-ready billing.", + }, +}; + +function appSurfaceStyle(): React.CSSProperties { + return { + minHeight: "100dvh", + display: "flex", + flexDirection: "column", + background: + "radial-gradient(circle at top left, rgba(255, 79, 0, 0.16), transparent 28%), radial-gradient(circle at top right, rgba(24, 140, 255, 0.18), transparent 32%), #050505", + color: "#ffffff", + }; +} + +function topBarStyle(): React.CSSProperties { + return { + display: "flex", + alignItems: "center", + justifyContent: "space-between", + padding: "18px 28px", + borderBottom: "1px solid rgba(255, 255, 255, 0.1)", + background: "rgba(0, 0, 0, 0.36)", + backdropFilter: "blur(16px)", + }; +} + +function contentWrapStyle(): React.CSSProperties { + return { + width: "min(1180px, calc(100vw - 40px))", + margin: "0 auto", + padding: "28px 0 40px", + display: "flex", + flexDirection: "column", + gap: "20px", + }; +} + +function primaryButtonStyle(): React.CSSProperties { + return { + border: 0, + borderRadius: "999px", + padding: "11px 16px", + background: "#ff4f00", + color: "#ffffff", + fontWeight: 700, + cursor: "pointer", + }; +} + +function secondaryButtonStyle(): React.CSSProperties { + return { + border: "1px solid rgba(255, 255, 255, 0.16)", + borderRadius: "999px", + padding: "10px 15px", + background: "rgba(255, 255, 255, 0.03)", + color: "#ffffff", + fontWeight: 600, + cursor: "pointer", + }; +} + +function subtleButtonStyle(): React.CSSProperties { + return { + border: 0, + borderRadius: "999px", + padding: "10px 14px", + background: "rgba(255, 255, 255, 0.05)", + color: "#ffffff", + fontWeight: 600, + cursor: "pointer", + }; +} + +function cardStyle(): React.CSSProperties { + return { + background: "linear-gradient(180deg, rgba(21, 21, 24, 0.96), rgba(10, 10, 11, 0.98))", + border: "1px solid rgba(255, 255, 255, 0.1)", + borderRadius: "24px", + boxShadow: "0 18px 40px rgba(0, 0, 0, 0.36)", + }; +} + +function badgeStyle(background: string, color = "#f4f4f5"): React.CSSProperties { + return { + display: "inline-flex", + alignItems: "center", + gap: "6px", + padding: "6px 10px", + borderRadius: "999px", + background, + color, + fontSize: "12px", + fontWeight: 700, + letterSpacing: "0.01em", + }; +} + +function formatDate(value: string | null): string { + if (!value) { + return "N/A"; + } + return dateFormatter.format(new Date(value)); +} + +function workspacePath(organization: FactoryOrganization): string { + return `/workspaces/${organization.workspaceId}`; +} + +function settingsPath(organization: FactoryOrganization): string { + return `/organizations/${organization.id}/settings`; +} + +function billingPath(organization: FactoryOrganization): string { + return `/organizations/${organization.id}/billing`; +} + +function importPath(organization: FactoryOrganization): string { + return `/organizations/${organization.id}/import`; +} + +function checkoutPath(organization: FactoryOrganization, planId: FactoryBillingPlanId): string { + return `/organizations/${organization.id}/checkout/${planId}`; +} + +function statusBadge(organization: FactoryOrganization) { + if (organization.kind === "personal") { + return Personal workspace; + } + return GitHub organization; +} + +function githubBadge(organization: FactoryOrganization) { + if (organization.github.installationStatus === "connected") { + return GitHub connected; + } + if (organization.github.installationStatus === "reconnect_required") { + return Reconnect required; + } + return Install GitHub App; +} + +function PageShell({ + user, + title, + eyebrow, + description, + children, + actions, + onSignOut, +}: { + user: FactoryUser | null; + title: string; + eyebrow: string; + description: string; + children: React.ReactNode; + actions?: React.ReactNode; + onSignOut?: () => void; +}) { + return ( +
+
+
+
+ SA +
+
+
{eyebrow}
+
{title}
+
+
+
+ {actions} + {user ? ( +
+
+
{user.name}
+
@{user.githubLogin}
+
+ {onSignOut ? ( + + ) : null} +
+ ) : null} +
+
+
+
{description}
+ {children} +
+
+ ); +} + +function StatCard({ label, value, caption }: { label: string; value: string; caption: string }) { + return ( +
+
{label}
+
{value}
+
{caption}
+
+ ); +} + +function MemberRow({ member }: { member: FactoryOrganizationMember }) { + return ( +
+
+
{member.name}
+
{member.email}
+
+
{member.role}
+
+ + {member.state} + +
+
+ ); +} + +export function MockSignInPage() { + const client = useMockAppClient(); + const navigate = useNavigate(); + const mockAccount = { + name: "Nathan", + email: "nathan@acme.dev", + githubLogin: "nathan", + label: "Mock account for review", + }; + + return ( +
+
+
+
+ Mock Better Auth + GitHub OAuth +
+ Sign in and land directly in the org onboarding funnel. +
+
+ This mock screen stands in for a basic GitHub OAuth sign-in page. After sign-in, the user moves into the + separate organization selector and then the rest of the onboarding funnel. +
+
+
+ + GitHub sign-in +
+
+ + Org selection +
+
+ + Hosted billing +
+
+
+
+
+
Continue to Sandbox Agent
+
+ This mock sign-in uses a single GitHub account so the org selection step remains the place where the + user chooses their workspace. +
+
+ +
+
+
+
{mockAccount.name}
+
+ @{mockAccount.githubLogin} · {mockAccount.email} +
+
+ {mockAccount.label} +
+
+ Sign-in always lands as this single mock user. Organization choice happens on the next screen. +
+
+
+
+
+
+ ); +} + +export function MockOrganizationSelectorPage() { + const client = useMockAppClient(); + const snapshot = useMockAppSnapshot(); + const user = activeMockUser(snapshot); + const organizations: FactoryOrganization[] = eligibleOrganizations(snapshot); + const navigate = useNavigate(); + + return ( + { + void (async () => { + await client.signOut(); + await navigate({ to: "/signin" }); + })(); + }} + > +
+ {organizations.map((organization) => ( +
+
+
+
{organization.settings.displayName}
+
+ {organization.settings.slug} · {organization.settings.primaryDomain} +
+
+ {statusBadge(organization)} +
+
+ {githubBadge(organization)} + + + {planCatalog[organization.billing.planId]!.label} + +
+
+ {organization.kind === "personal" + ? "Personal workspaces skip seat purchasing but still show the same onboarding and billing entry points." + : "Organization onboarding includes GitHub repo import, seat accrual on first prompt, and billing controls for the shared workspace."} +
+
+ member.state === "active").length} active`} + /> + + +
+
+ + + +
+
+ ))} +
+ + ); +} + +export function MockOrganizationImportPage({ organization }: { organization: FactoryOrganization }) { + const client = useMockAppClient(); + const snapshot = useMockAppSnapshot(); + const user = activeMockUser(snapshot); + const navigate = useNavigate(); + + useEffect(() => { + if (organization.repoImportStatus === "ready") { + void navigate({ to: workspacePath(organization), replace: true }); + } + }, [navigate, organization]); + + return ( + void navigate({ to: "/organizations" })} style={secondaryButtonStyle()}> + + Back + + } + onSignOut={() => { + void (async () => { + await client.signOut(); + await navigate({ to: "/signin" }); + })(); + }} + > +
+
+
+ +
+
+ {organization.repoImportStatus === "ready" ? "Import complete" : "Preparing repository catalog"} +
+
{organization.github.lastSyncLabel}
+
+
+
+ The mock client now simulates the expected onboarding pause: GitHub app access is validated, repository metadata + is imported, and the resulting workspace stays blocked until ready. +
+
+
+
+
+ {organization.github.installationStatus !== "connected" ? ( + + ) : null} + + +
+
+
+ + + +
+
+ + ); +} + +export function MockOrganizationSettingsPage({ organization }: { organization: FactoryOrganization }) { + const client = useMockAppClient(); + const snapshot = useMockAppSnapshot(); + const user = activeMockUser(snapshot); + const navigate = useNavigate(); + const [displayName, setDisplayName] = useState(organization.settings.displayName); + const [slug, setSlug] = useState(organization.settings.slug); + const [primaryDomain, setPrimaryDomain] = useState(organization.settings.primaryDomain); + const seatCaption = useMemo( + () => `${organization.seatAssignments.length} of ${organization.billing.seatsIncluded} seats already accrued`, + [organization.billing.seatsIncluded, organization.seatAssignments.length], + ); + + useEffect(() => { + setDisplayName(organization.settings.displayName); + setSlug(organization.settings.slug); + setPrimaryDomain(organization.settings.primaryDomain); + }, [organization]); + + return ( + + + + + + } + onSignOut={() => { + void (async () => { + await client.signOut(); + await navigate({ to: "/signin" }); + })(); + }} + > +
+
+
+
+
+
Organization profile
+
+ Mock Better Auth org state persisted in the client package. +
+
+ {statusBadge(organization)} +
+ +
+ + +
+
+ + +
+
+ +
+
+ +
GitHub access
+
+
+ {githubBadge(organization)} + {organization.github.connectedAccount} +
+
+ {organization.github.importedRepoCount} repos imported. Last sync: {organization.github.lastSyncLabel} +
+
+ + +
+
+ +
+
+ +
Members and roles
+
+
+ Mock org membership feeds seat accrual and billing previews. +
+ {organization.members.map((member) => ( + + ))} +
+
+ +
+ + + +
+
+ + ); +} + +export function MockOrganizationBillingPage({ organization }: { organization: FactoryOrganization }) { + const client = useMockAppClient(); + const snapshot = useMockAppSnapshot(); + const user = activeMockUser(snapshot); + const navigate = useNavigate(); + + return ( + + + + + } + onSignOut={() => { + void (async () => { + await client.signOut(); + await navigate({ to: "/signin" }); + })(); + }} + > +
+ + + +
+ +
+ {(Object.entries(planCatalog) as Array<[FactoryBillingPlanId, (typeof planCatalog)[FactoryBillingPlanId]]>).map(([planId, plan]) => { + const isCurrent = organization.billing.planId === planId; + return ( +
+
+
+
{plan.label}
+
{plan.seats}
+
+ {isCurrent ? Current : null} +
+
{plan.price}
+
{plan.summary}
+ +
+ ); + })} +
+ +
+
+
+ +
Subscription controls
+
+
+ Stripe customer {organization.billing.stripeCustomerId}. This mock screen intentionally mirrors a hosted + billing portal entry point and the in-product summary beside it. +
+
+ {organization.billing.status === "scheduled_cancel" ? ( + + ) : ( + + )} + +
+
+ +
+
+ +
Invoices
+
+
+ Recent hosted billing activity for review. +
+ {organization.billing.invoices.length === 0 ? ( +
No invoices yet.
+ ) : ( + organization.billing.invoices.map((invoice) => ( +
+
+
{invoice.label}
+
{invoice.issuedAt}
+
+
${invoice.amountUsd}
+
+ + {invoice.status} + +
+
+ )) + )} +
+
+ + ); +} + +export function MockHostedCheckoutPage({ + organization, + planId, +}: { + organization: FactoryOrganization; + planId: FactoryBillingPlanId; +}) { + const client = useMockAppClient(); + const snapshot = useMockAppSnapshot(); + const user = activeMockUser(snapshot); + const navigate = useNavigate(); + const plan = planCatalog[planId]!; + + return ( + void navigate({ to: billingPath(organization) })} style={secondaryButtonStyle()}> + + Back to billing + + } + onSignOut={() => { + void (async () => { + await client.signOut(); + await navigate({ to: "/signin" }); + })(); + }} + > +
+
+
Order summary
+
+ {organization.settings.displayName} is checking out on the {plan.label} plan. +
+
+ + + + +
+
+
+
Mock card details
+
+ + +
+ +
+
+ + ); +} + +function CheckoutLine({ label, value }: { label: string; value: string }) { + return ( +
+
{label}
+
{value}
+
+ ); +} + +function inputStyle(): React.CSSProperties { + return { + width: "100%", + borderRadius: "14px", + border: "1px solid rgba(255, 255, 255, 0.12)", + background: "rgba(255, 255, 255, 0.04)", + color: "#ffffff", + padding: "12px 14px", + outline: "none", + }; +} diff --git a/factory/packages/frontend/src/components/workspace-dashboard.tsx b/factory/packages/frontend/src/components/workspace-dashboard.tsx index 420e27d..1b9033c 100644 --- a/factory/packages/frontend/src/components/workspace-dashboard.tsx +++ b/factory/packages/frontend/src/components/workspace-dashboard.tsx @@ -1,6 +1,7 @@ import { useEffect, useMemo, useState, type ReactNode } from "react"; -import type { AgentType, HandoffRecord, HandoffSummary, RepoBranchRecord, RepoOverview, RepoStackAction } from "@openhandoff/shared"; -import { groupHandoffStatus, type SandboxSessionEventRecord } from "@openhandoff/client"; +import type { AgentType, HandoffRecord, HandoffSummary, RepoBranchRecord, RepoOverview, RepoStackAction } from "@sandbox-agent/factory-shared"; +import type { SandboxSessionEventRecord } from "@sandbox-agent/factory-client"; +import { groupHandoffStatus } from "@sandbox-agent/factory-client/view-model"; import { useMutation, useQuery } from "@tanstack/react-query"; import { Link, useNavigate } from "@tanstack/react-router"; import { Button } from "baseui/button"; diff --git a/factory/packages/frontend/src/factory-client-view-model.d.ts b/factory/packages/frontend/src/factory-client-view-model.d.ts new file mode 100644 index 0000000..1b8e3dc --- /dev/null +++ b/factory/packages/frontend/src/factory-client-view-model.d.ts @@ -0,0 +1,7 @@ +declare module "@sandbox-agent/factory-client/view-model" { + export { + HANDOFF_STATUS_GROUPS, + groupHandoffStatus, + } from "@sandbox-agent/factory-client"; + export type { HandoffStatusGroup } from "@sandbox-agent/factory-client"; +} diff --git a/factory/packages/frontend/src/features/handoffs/model.test.ts b/factory/packages/frontend/src/features/handoffs/model.test.ts index 153442e..3d82467 100644 --- a/factory/packages/frontend/src/features/handoffs/model.test.ts +++ b/factory/packages/frontend/src/features/handoffs/model.test.ts @@ -1,5 +1,5 @@ import { describe, expect, it } from "vitest"; -import type { HandoffRecord } from "@openhandoff/shared"; +import type { HandoffRecord } from "@sandbox-agent/factory-shared"; import { formatDiffStat, groupHandoffsByRepo } from "./model"; const base: HandoffRecord = { diff --git a/factory/packages/frontend/src/features/handoffs/model.ts b/factory/packages/frontend/src/features/handoffs/model.ts index 977d50d..4106078 100644 --- a/factory/packages/frontend/src/features/handoffs/model.ts +++ b/factory/packages/frontend/src/features/handoffs/model.ts @@ -1,4 +1,4 @@ -import type { HandoffRecord } from "@openhandoff/shared"; +import type { HandoffRecord } from "@sandbox-agent/factory-shared"; export interface RepoGroup { repoId: string; diff --git a/factory/packages/frontend/src/features/sessions/model.test.ts b/factory/packages/frontend/src/features/sessions/model.test.ts index 0ead4d6..c2cc8ee 100644 --- a/factory/packages/frontend/src/features/sessions/model.test.ts +++ b/factory/packages/frontend/src/features/sessions/model.test.ts @@ -1,5 +1,5 @@ import { describe, expect, it } from "vitest"; -import type { SandboxSessionRecord } from "@openhandoff/client"; +import type { SandboxSessionRecord } from "@sandbox-agent/factory-client"; import { buildTranscript, extractEventText, resolveSessionSelection } from "./model"; describe("extractEventText", () => { diff --git a/factory/packages/frontend/src/features/sessions/model.ts b/factory/packages/frontend/src/features/sessions/model.ts index ea4d59d..9085a13 100644 --- a/factory/packages/frontend/src/features/sessions/model.ts +++ b/factory/packages/frontend/src/features/sessions/model.ts @@ -1,5 +1,5 @@ -import type { SandboxSessionEventRecord } from "@openhandoff/client"; -import type { SandboxSessionRecord } from "@openhandoff/client"; +import type { SandboxSessionEventRecord } from "@sandbox-agent/factory-client"; +import type { SandboxSessionRecord } from "@sandbox-agent/factory-client"; function fromPromptArray(value: unknown): string | null { if (!Array.isArray(value)) { diff --git a/factory/packages/frontend/src/lib/backend.ts b/factory/packages/frontend/src/lib/backend.ts index 17c527d..c788e4f 100644 --- a/factory/packages/frontend/src/lib/backend.ts +++ b/factory/packages/frontend/src/lib/backend.ts @@ -1,4 +1,4 @@ -import { createBackendClient } from "@openhandoff/client"; +import { createBackendClient } from "@sandbox-agent/factory-client/backend"; import { backendEndpoint, defaultWorkspaceId } from "./env"; export const backendClient = createBackendClient({ diff --git a/factory/packages/frontend/src/lib/env.ts b/factory/packages/frontend/src/lib/env.ts index c0744ca..500ef9c 100644 --- a/factory/packages/frontend/src/lib/env.ts +++ b/factory/packages/frontend/src/lib/env.ts @@ -6,7 +6,7 @@ function resolveDefaultBackendEndpoint(): string { } type FrontendImportMetaEnv = ImportMetaEnv & { - OPENHANDOFF_FRONTEND_CLIENT_MODE?: string; + FACTORY_FRONTEND_CLIENT_MODE?: string; }; const frontendEnv = import.meta.env as FrontendImportMetaEnv; @@ -17,7 +17,7 @@ export const backendEndpoint = export const defaultWorkspaceId = import.meta.env.VITE_HF_WORKSPACE?.trim() || "default"; function resolveFrontendClientMode(): "mock" | "remote" { - const raw = frontendEnv.OPENHANDOFF_FRONTEND_CLIENT_MODE?.trim().toLowerCase(); + const raw = frontendEnv.FACTORY_FRONTEND_CLIENT_MODE?.trim().toLowerCase(); if (raw === "mock") { return "mock"; } @@ -25,7 +25,7 @@ function resolveFrontendClientMode(): "mock" | "remote" { return "remote"; } throw new Error( - `Unsupported OPENHANDOFF_FRONTEND_CLIENT_MODE value "${frontendEnv.OPENHANDOFF_FRONTEND_CLIENT_MODE}". Expected "mock" or "remote".`, + `Unsupported FACTORY_FRONTEND_CLIENT_MODE value "${frontendEnv.FACTORY_FRONTEND_CLIENT_MODE}". Expected "mock" or "remote".`, ); } diff --git a/factory/packages/frontend/src/lib/mock-app.ts b/factory/packages/frontend/src/lib/mock-app.ts new file mode 100644 index 0000000..a2e0f24 --- /dev/null +++ b/factory/packages/frontend/src/lib/mock-app.ts @@ -0,0 +1,40 @@ +import { useSyncExternalStore } from "react"; +import { + createFactoryAppClient, + currentFactoryOrganization, + currentFactoryUser, + eligibleFactoryOrganizations, + type FactoryAppClient, +} from "@sandbox-agent/factory-client"; +import type { FactoryAppSnapshot, FactoryOrganization } from "@sandbox-agent/factory-shared"; +import { backendClient } from "./backend"; +import { frontendClientMode } from "./env"; + +const appClient: FactoryAppClient = createFactoryAppClient({ + mode: frontendClientMode, + backend: frontendClientMode === "remote" ? backendClient : undefined, +}); + +export function useMockAppSnapshot(): FactoryAppSnapshot { + return useSyncExternalStore( + appClient.subscribe.bind(appClient), + appClient.getSnapshot.bind(appClient), + appClient.getSnapshot.bind(appClient), + ); +} + +export function useMockAppClient(): FactoryAppClient { + return appClient; +} + +export const activeMockUser = currentFactoryUser; +export const activeMockOrganization = currentFactoryOrganization; +export const eligibleOrganizations = eligibleFactoryOrganizations; + +export function getMockOrganizationById( + snapshot: FactoryAppSnapshot, + organizationId: string, +): FactoryOrganization | null { + return snapshot.organizations.find((organization) => organization.id === organizationId) ?? null; +} + diff --git a/factory/packages/frontend/src/lib/workbench-routing.ts b/factory/packages/frontend/src/lib/workbench-routing.ts new file mode 100644 index 0000000..16dda11 --- /dev/null +++ b/factory/packages/frontend/src/lib/workbench-routing.ts @@ -0,0 +1,8 @@ +import type { HandoffWorkbenchSnapshot } from "@sandbox-agent/factory-shared"; + +export function resolveRepoRouteHandoffId( + snapshot: HandoffWorkbenchSnapshot, + repoId: string, +): string | null { + return snapshot.handoffs.find((handoff) => handoff.repoId === repoId)?.id ?? null; +} diff --git a/factory/packages/frontend/src/lib/workbench-runtime.mock.ts b/factory/packages/frontend/src/lib/workbench-runtime.mock.ts new file mode 100644 index 0000000..c046478 --- /dev/null +++ b/factory/packages/frontend/src/lib/workbench-runtime.mock.ts @@ -0,0 +1,11 @@ +import { + createHandoffWorkbenchClient, + type HandoffWorkbenchClient, +} from "@sandbox-agent/factory-client/workbench"; + +export function createWorkbenchRuntimeClient(workspaceId: string): HandoffWorkbenchClient { + return createHandoffWorkbenchClient({ + mode: "mock", + workspaceId, + }); +} diff --git a/factory/packages/frontend/src/lib/workbench-runtime.remote.ts b/factory/packages/frontend/src/lib/workbench-runtime.remote.ts new file mode 100644 index 0000000..bcd345f --- /dev/null +++ b/factory/packages/frontend/src/lib/workbench-runtime.remote.ts @@ -0,0 +1,13 @@ +import { + createHandoffWorkbenchClient, + type HandoffWorkbenchClient, +} from "@sandbox-agent/factory-client/workbench"; +import { backendClient } from "./backend"; + +export function createWorkbenchRuntimeClient(workspaceId: string): HandoffWorkbenchClient { + return createHandoffWorkbenchClient({ + mode: "remote", + backend: backendClient, + workspaceId, + }); +} diff --git a/factory/packages/frontend/src/lib/workbench.test.ts b/factory/packages/frontend/src/lib/workbench.test.ts new file mode 100644 index 0000000..8960523 --- /dev/null +++ b/factory/packages/frontend/src/lib/workbench.test.ts @@ -0,0 +1,38 @@ +import { describe, expect, it } from "vitest"; +import type { HandoffWorkbenchSnapshot } from "@sandbox-agent/factory-shared"; +import { resolveRepoRouteHandoffId } from "./workbench-routing"; + +const snapshot: HandoffWorkbenchSnapshot = { + workspaceId: "default", + repos: [ + { id: "repo-a", label: "acme/repo-a" }, + { id: "repo-b", label: "acme/repo-b" }, + ], + projects: [], + handoffs: [ + { + id: "handoff-a", + repoId: "repo-a", + title: "Alpha", + status: "idle", + repoName: "acme/repo-a", + updatedAtMs: 20, + branch: "feature/alpha", + pullRequest: null, + tabs: [], + fileChanges: [], + diffs: {}, + fileTree: [], + }, + ], +}; + +describe("resolveRepoRouteHandoffId", () => { + it("finds the active handoff for a repo route", () => { + expect(resolveRepoRouteHandoffId(snapshot, "repo-a")).toBe("handoff-a"); + }); + + it("returns null when a repo has no handoff yet", () => { + expect(resolveRepoRouteHandoffId(snapshot, "repo-b")).toBeNull(); + }); +}); diff --git a/factory/packages/frontend/src/lib/workbench.ts b/factory/packages/frontend/src/lib/workbench.ts index 8ea0e23..f504e00 100644 --- a/factory/packages/frontend/src/lib/workbench.ts +++ b/factory/packages/frontend/src/lib/workbench.ts @@ -1,9 +1,18 @@ -import { createHandoffWorkbenchClient } from "@openhandoff/client"; -import { backendClient } from "./backend"; -import { defaultWorkspaceId, frontendClientMode } from "./env"; +import type { HandoffWorkbenchClient } from "@sandbox-agent/factory-client/workbench"; +import { createWorkbenchRuntimeClient } from "@workbench-runtime"; +import { frontendClientMode } from "./env"; +export { resolveRepoRouteHandoffId } from "./workbench-routing"; -export const handoffWorkbenchClient = createHandoffWorkbenchClient({ - mode: frontendClientMode, - backend: backendClient, - workspaceId: defaultWorkspaceId, -}); +const workbenchClientCache = new Map(); + +export function getHandoffWorkbenchClient(workspaceId: string): HandoffWorkbenchClient { + const cacheKey = `${frontendClientMode}:${workspaceId}`; + const existing = workbenchClientCache.get(cacheKey); + if (existing) { + return existing; + } + + const client = createWorkbenchRuntimeClient(workspaceId); + workbenchClientCache.set(cacheKey, client); + return client; +} diff --git a/factory/packages/frontend/src/styles.css b/factory/packages/frontend/src/styles.css index 0e7c22d..968acd8 100644 --- a/factory/packages/frontend/src/styles.css +++ b/factory/packages/frontend/src/styles.css @@ -42,6 +42,11 @@ a { to { transform: rotate(360deg); } } +@keyframes hf-shimmer { + 0% { background-position: 200% 0; } + 100% { background-position: -200% 0; } +} + button, input, textarea, diff --git a/factory/packages/frontend/tsconfig.json b/factory/packages/frontend/tsconfig.json index a925623..b0ff0d0 100644 --- a/factory/packages/frontend/tsconfig.json +++ b/factory/packages/frontend/tsconfig.json @@ -6,7 +6,11 @@ "moduleResolution": "Bundler", "jsx": "react-jsx", "declaration": false, - "types": ["vite/client", "vitest/globals"] + "types": ["vite/client", "vitest/globals"], + "baseUrl": ".", + "paths": { + "@workbench-runtime": ["./src/lib/workbench-runtime.remote.ts"] + } }, "include": ["src", "vite.config.ts", "vitest.config.ts"] } diff --git a/factory/packages/frontend/vite.config.ts b/factory/packages/frontend/vite.config.ts index f0cfc1d..e0b5fe0 100644 --- a/factory/packages/frontend/vite.config.ts +++ b/factory/packages/frontend/vite.config.ts @@ -1,19 +1,43 @@ -import { defineConfig } from "vite"; +import { realpathSync } from "node:fs"; +import { dirname } from "node:path"; +import { fileURLToPath, URL } from "node:url"; +import { defineConfig, searchForWorkspaceRoot } from "vite"; import react from "@vitejs/plugin-react"; -import { frontendErrorCollectorVitePlugin } from "@openhandoff/frontend-errors/vite"; +import { frontendErrorCollectorVitePlugin } from "@sandbox-agent/factory-frontend-errors/vite"; const backendProxyTarget = process.env.HF_BACKEND_HTTP?.trim() || "http://127.0.0.1:7741"; const cacheDir = process.env.HF_VITE_CACHE_DIR?.trim() || undefined; +const frontendClientMode = process.env.FACTORY_FRONTEND_CLIENT_MODE?.trim() || "remote"; +const rivetkitClientEntry = realpathSync( + fileURLToPath(new URL("../client/node_modules/rivetkit/dist/browser/client.js", import.meta.url)), +); +const rivetkitPackageRoot = dirname(dirname(dirname(rivetkitClientEntry))); export default defineConfig({ define: { - "import.meta.env.OPENHANDOFF_FRONTEND_CLIENT_MODE": JSON.stringify( - process.env.OPENHANDOFF_FRONTEND_CLIENT_MODE?.trim() || "remote", + "import.meta.env.FACTORY_FRONTEND_CLIENT_MODE": JSON.stringify( + frontendClientMode, ), }, plugins: [react(), frontendErrorCollectorVitePlugin()], cacheDir, + resolve: { + alias: { + "rivetkit/client": rivetkitClientEntry, + "@workbench-runtime": fileURLToPath( + new URL( + frontendClientMode === "mock" + ? "./src/lib/workbench-runtime.mock.ts" + : "./src/lib/workbench-runtime.remote.ts", + import.meta.url, + ), + ), + }, + }, server: { port: 4173, + fs: { + allow: [searchForWorkspaceRoot(process.cwd()), rivetkitPackageRoot], + }, proxy: { "/api/rivet": { target: backendProxyTarget, diff --git a/factory/packages/shared/package.json b/factory/packages/shared/package.json index b458a38..0bfce7d 100644 --- a/factory/packages/shared/package.json +++ b/factory/packages/shared/package.json @@ -1,5 +1,5 @@ { - "name": "@openhandoff/shared", + "name": "@sandbox-agent/factory-shared", "version": "0.1.0", "private": true, "type": "module", diff --git a/factory/packages/shared/src/app-shell.ts b/factory/packages/shared/src/app-shell.ts new file mode 100644 index 0000000..92439be --- /dev/null +++ b/factory/packages/shared/src/app-shell.ts @@ -0,0 +1,88 @@ +export type FactoryBillingPlanId = "free" | "team" | "enterprise"; +export type FactoryBillingStatus = "active" | "trialing" | "past_due" | "scheduled_cancel"; +export type FactoryRepoImportStatus = "ready" | "not_started" | "importing"; +export type FactoryGithubInstallationStatus = "connected" | "install_required" | "reconnect_required"; +export type FactoryOrganizationKind = "personal" | "organization"; + +export interface FactoryUser { + id: string; + name: string; + email: string; + githubLogin: string; + roleLabel: string; + eligibleOrganizationIds: string[]; +} + +export interface FactoryOrganizationMember { + id: string; + name: string; + email: string; + role: "owner" | "admin" | "member"; + state: "active" | "invited"; +} + +export interface FactoryInvoice { + id: string; + label: string; + issuedAt: string; + amountUsd: number; + status: "paid" | "open"; +} + +export interface FactoryBillingState { + planId: FactoryBillingPlanId; + status: FactoryBillingStatus; + seatsIncluded: number; + trialEndsAt: string | null; + renewalAt: string | null; + stripeCustomerId: string; + paymentMethodLabel: string; + invoices: FactoryInvoice[]; +} + +export interface FactoryGithubState { + connectedAccount: string; + installationStatus: FactoryGithubInstallationStatus; + importedRepoCount: number; + lastSyncLabel: string; +} + +export interface FactoryOrganizationSettings { + displayName: string; + slug: string; + primaryDomain: string; + seatAccrualMode: "first_prompt"; + defaultModel: "claude-sonnet-4" | "claude-opus-4" | "gpt-4o" | "o3"; + autoImportRepos: boolean; +} + +export interface FactoryOrganization { + id: string; + workspaceId: string; + kind: FactoryOrganizationKind; + settings: FactoryOrganizationSettings; + github: FactoryGithubState; + billing: FactoryBillingState; + members: FactoryOrganizationMember[]; + seatAssignments: string[]; + repoImportStatus: FactoryRepoImportStatus; + repoCatalog: string[]; +} + +export interface FactoryAppSnapshot { + auth: { + status: "signed_out" | "signed_in"; + currentUserId: string | null; + }; + activeOrganizationId: string | null; + users: FactoryUser[]; + organizations: FactoryOrganization[]; +} + +export interface UpdateFactoryOrganizationProfileInput { + organizationId: string; + displayName: string; + slug: string; + primaryDomain: string; +} + diff --git a/factory/packages/shared/src/config.ts b/factory/packages/shared/src/config.ts index c0bc256..0657f9b 100644 --- a/factory/packages/shared/src/config.ts +++ b/factory/packages/shared/src/config.ts @@ -24,7 +24,7 @@ export const ConfigSchema = z.object({ backend: z.object({ host: z.string().default("127.0.0.1"), port: z.number().int().min(1).max(65535).default(7741), - dbPath: z.string().default("~/.local/share/openhandoff/handoff.db"), + dbPath: z.string().default("~/.local/share/sandbox-agent-factory/handoff.db"), opencode_poll_interval: z.number().default(2), github_poll_interval: z.number().default(30), backup_interval_secs: z.number().default(3600), @@ -32,7 +32,7 @@ export const ConfigSchema = z.object({ }).default({ host: "127.0.0.1", port: 7741, - dbPath: "~/.local/share/openhandoff/handoff.db", + dbPath: "~/.local/share/sandbox-agent-factory/handoff.db", opencode_poll_interval: 2, github_poll_interval: 30, backup_interval_secs: 3600, diff --git a/factory/packages/shared/src/index.ts b/factory/packages/shared/src/index.ts index 4634e8b..a8002e0 100644 --- a/factory/packages/shared/src/index.ts +++ b/factory/packages/shared/src/index.ts @@ -1,3 +1,4 @@ +export * from "./app-shell.js"; export * from "./contracts.js"; export * from "./config.js"; export * from "./workbench.js"; diff --git a/factory/packages/shared/test/workspace.test.ts b/factory/packages/shared/test/workspace.test.ts index 9ecb136..c2247f6 100644 --- a/factory/packages/shared/test/workspace.test.ts +++ b/factory/packages/shared/test/workspace.test.ts @@ -8,7 +8,7 @@ const cfg: AppConfig = ConfigSchema.parse({ backend: { host: "127.0.0.1", port: 7741, - dbPath: "~/.local/share/openhandoff/handoff.db", + dbPath: "~/.local/share/sandbox-agent-factory/handoff.db", opencode_poll_interval: 2, github_poll_interval: 30, backup_interval_secs: 3600, diff --git a/factory/research/friction/general.mdx b/factory/research/friction/general.mdx index e2a3d13..9585c72 100644 --- a/factory/research/friction/general.mdx +++ b/factory/research/friction/general.mdx @@ -101,7 +101,7 @@ Fixing Daytona `hf create` failures where `handoff.attach` would exhaust retries ### Friction / Issue -OpenHandoff was using RivetKit's KV-backed durable SQLite VFS via `rivetkit/db/drizzle`, which opens the SQLite DB keyed by `ctx.actorId`. Since actor instances can be rescheduled (new `actorId`) between requests, DB writes from initialization were not visible to later actions (e.g. `attach`), causing “Handoff not found” and action timeouts. +Sandbox Agent Factory was using RivetKit's KV-backed durable SQLite VFS via `rivetkit/db/drizzle`, which opens the SQLite DB keyed by `ctx.actorId`. Since actor instances can be rescheduled (new `actorId`) between requests, DB writes from initialization were not visible to later actions (e.g. `attach`), causing “Handoff not found” and action timeouts. Separately, importing `bun:sqlite` directly broke: @@ -194,7 +194,7 @@ Backend integration tests depend on native `better-sqlite3` bindings, which were ### Attempted Fix / Workaround -1. Attempted `pnpm --filter @openhandoff/backend rebuild better-sqlite3`. +1. Attempted `pnpm --filter @sandbox-agent/factory-backend rebuild better-sqlite3`. 2. Added runtime capability detection in DB-backed backend tests. 3. Marked DB-backed tests with `it.skipIf(!hasBetterSqliteBinding)` so tests run when native bindings exist and skip cleanly otherwise. @@ -280,7 +280,7 @@ Running backend tests with the integration flag enabled triggered unrelated acto ### Attempted Fix / Workaround -1. Switched to package-targeted test runs for deterministic coverage (`@openhandoff/backend` + `@openhandoff/frontend`). +1. Switched to package-targeted test runs for deterministic coverage (`@sandbox-agent/factory-backend` + `@sandbox-agent/factory-frontend`). 2. Relied on required workspace validation (`pnpm -w typecheck`, `pnpm -w build`, `pnpm -w test`) plus targeted stack test files. 3. Stopped the runaway integration run and recorded this friction for follow-up. diff --git a/factory/research/friction/rivet.mdx b/factory/research/friction/rivet.mdx index ce06f0e..73763fa 100644 --- a/factory/research/friction/rivet.mdx +++ b/factory/research/friction/rivet.mdx @@ -140,7 +140,7 @@ Captured the guidance here so future actor work doesn’t mix the two models arb ### What I Was Working On -Standardizing SQLite + Drizzle setup for RivetKit actors (migration-per-actor) to match the `rivet/examples/sandbox` pattern while keeping the OpenHandoff repo TypeScript-only. +Standardizing SQLite + Drizzle setup for RivetKit actors (migration-per-actor) to match the `rivet/examples/sandbox` pattern while keeping the Sandbox Agent Factory repo TypeScript-only. ### Friction / Issue @@ -174,7 +174,7 @@ Adopt these concrete repo conventions: - Per-actor migration tracking tables: - Even if all actors share one SQLite file, each actor must use its own migration table, e.g. - - `__openhandoff_migrations_` + - `__factory_migrations_` - `migrationNamespace` should be stable and sanitized to `[a-z0-9_]`. - Provider wiring pattern inside an actor: @@ -195,7 +195,7 @@ Captured the exact folder layout + script workflow so future actor DB work can f ### What I Was Working On -Diagnosing `StepExhaustedError` surfacing as `unknown error` during step replay (affecting OpenHandoff Daytona `hf create`). +Diagnosing `StepExhaustedError` surfacing as `unknown error` during step replay (affecting Sandbox Agent Factory Daytona `hf create`). ### Friction / Issue @@ -203,7 +203,7 @@ The workflow engine treated “step completed” as `stepData.output !== undefin ### Attempted Fix / Workaround -- None in OpenHandoff; this is a workflow-engine correctness bug. +- None in Sandbox Agent Factory; this is a workflow-engine correctness bug. ### Outcome diff --git a/factory/research/specs/rivetkit-opentui-migration-plan.md b/factory/research/specs/rivetkit-opentui-migration-plan.md index 6805c4a..db24067 100644 --- a/factory/research/specs/rivetkit-opentui-migration-plan.md +++ b/factory/research/specs/rivetkit-opentui-migration-plan.md @@ -16,7 +16,7 @@ Date: 2026-02-08 9. Every actor key is prefixed by workspace. 10. `--workspace` is optional; commands resolve workspace via flag -> config default -> `default`. 11. RivetKit local dependency wiring is `link:`-based. -12. Keep the existing config file path (`~/.config/openhandoff/config.toml`) and evolve keys in place. +12. Keep the existing config file path (`~/.config/sandbox-agent-factory/config.toml`) and evolve keys in place. 13. `.agents` and skill files are in scope for migration updates. 14. Parent orchestration actors (`workspace`, `project`, `handoff`) use command-only loops with no timeout. 15. Periodic syncing/polling runs in dedicated child actors, each with a single timeout cadence. diff --git a/factory/tsconfig.base.json b/factory/tsconfig.base.json index dd43cfe..d0a8e93 100644 --- a/factory/tsconfig.base.json +++ b/factory/tsconfig.base.json @@ -13,11 +13,11 @@ "declaration": true, "sourceMap": true, "paths": { - "@openhandoff/client": ["packages/client/src/index.ts"], - "@openhandoff/shared": ["packages/shared/src/index.ts"], - "@openhandoff/backend": ["packages/backend/src/index.ts"], - "@openhandoff/frontend-errors": ["packages/frontend-errors/src/index.ts"], - "@openhandoff/frontend-errors/*": ["packages/frontend-errors/src/*"] + "@sandbox-agent/factory-client": ["packages/client/src/index.ts"], + "@sandbox-agent/factory-shared": ["packages/shared/src/index.ts"], + "@sandbox-agent/factory-backend": ["packages/backend/src/index.ts"], + "@sandbox-agent/factory-frontend-errors": ["packages/frontend-errors/src/index.ts"], + "@sandbox-agent/factory-frontend-errors/*": ["packages/frontend-errors/src/*"] }, "noUncheckedIndexedAccess": true, "noImplicitOverride": true diff --git a/frontend/packages/inspector/index.html b/frontend/packages/inspector/index.html index 8a2080b..aeec796 100644 --- a/frontend/packages/inspector/index.html +++ b/frontend/packages/inspector/index.html @@ -8,7 +8,7 @@ - +