@reticlehq/vite-plugin 2.3.0 → 2.4.0

package/dist/index.d.ts

@@ -1,4 +1,10 @@
 export declare const RETICLE_VITE_PLUGIN_NAME = "reticle";
+/**
+ * Compile-time global carrying the daemon's pairing token, for connects the plugin does not write
+ * itself. The bridge requires the token even on localhost, and nothing in a browser can read the
+ * file it lives in.
+ */
+export declare const RETICLE_TOKEN_GLOBAL = "__RETICLE_TOKEN__";
 /**
  * The connect code is served as a real module (not an inline <script>) so that Vite's import
  * pipeline resolves the bare `@reticlehq/react` specifier. An inline injected script is NOT run through
@@ -79,11 +85,20 @@ export interface ReticleVitePlugin {
     config?: (config: {
         optimizeDeps?: {
             include?: string[];
+            esbuildOptions?: {
+                define?: Record<string, string>;
+            };
         };
+        define?: Record<string, string>;
+        root?: string;
     }) => {
         optimizeDeps: {
             include: string[];
+            esbuildOptions: {
+                define: Record<string, string>;
+            };
         };
+        define: Record<string, string>;
     };
     /** Absent in desktop mode, where the plugin must also run for `vite build`. */
     apply?: 'serve';
@@ -116,7 +131,18 @@ interface HtmlTag {
 }
 export declare function readPairingToken(): string | undefined;
 /** The body of the connect module — real imports, resolved by Vite when the module is served. */
-export declare function connectModuleSource(options: ReticleVitePluginOptions): string;
+/**
+ * The conventional app-side dev module: `registerStore` / `registerCapabilities` live here.
+ *
+ * It is imported by CONVENTION rather than by patching the app's entry file. The connect is injected
+ * into a virtual module, so there is nowhere for a user to add these calls without `init` editing
+ * `src/main.tsx` — an edit to the file people actually own, for something that is opt-in enrichment.
+ * Convention costs one `existsSync` and leaves their entry untouched.
+ */
+export declare const RETICLE_DEV_MODULE_CANDIDATES: readonly ["src/reticle-dev.ts", "src/reticle-dev.js", "src/reticle-dev.tsx", "src/reticle-dev.jsx"];
+/** The app's dev module, as an importable path — or null when the app has none. */
+export declare function findDevModule(root: string, exists: (p: string) => boolean): string | null;
+export declare function connectModuleSource(options: ReticleVitePluginOptions, devModule?: string | null): string;
 /**
  * Reticle Vite plugin. Add to your `plugins` array and the entire integration is done:
  *

package/dist/index.js

@@ -1,16 +1,61 @@
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { transformSync } from '@babel/core';
 import reticleSource from '@reticlehq/babel-plugin';
-import { RETICLE_DEFAULT_PORT, RETICLE_RENDER_PREHOOK, bridgeWsUrl, ReticleDir, ReticleEnv, } from '@reticlehq/core';
+import { RETICLE_DEFAULT_PORT, RETICLE_RENDER_PREHOOK, bridgeWsUrl, ReticleDir, ReticleEnv, RETICLE_ROOT_GLOBAL, } from '@reticlehq/core';
 import { resolveProjectId } from './project-id.js';
 import { discoverDaemonPort } from './discover-port.js';
+import { SVELTE_FILE, stampSvelte } from './svelte-source.js';
+import { createRequire } from 'node:module';
 export const RETICLE_VITE_PLUGIN_NAME = 'reticle';
 // The React kit the host app imports the SDK from. It re-exports the browser sensor, so a single
 // specifier yields both `reticle` (connect) and `install` (the React adapter). NOT `@reticlehq/core`
 // — that is the isomorphic foundation and exports neither.
 const RETICLE_PACKAGE = '@reticlehq/react';
+/**
+ * Compile-time global carrying the daemon's pairing token, for connects the plugin does not write
+ * itself. The bridge requires the token even on localhost, and nothing in a browser can read the
+ * file it lives in.
+ */
+export const RETICLE_TOKEN_GLOBAL = '__RETICLE_TOKEN__';
+/**
+ * Whether a package can be resolved from this process. Used to avoid declaring an optimizeDeps entry
+ * for something the app does not have, which Vite reports as a resolve failure on every boot.
+ */
+function isResolvable(specifier) {
+    try {
+        createRequire(import.meta.url).resolve(specifier);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A fingerprint of the installed SDK build, mixed into `optimizeDeps` so Vite re-bundles when the
+ * SDK changes.
+ *
+ * Vite's dep-optimizer cache is keyed on the `optimizeDeps` config and the lockfile — NOT on the
+ * contents of the packages it bundled. Upgrade the SDK in place (a patched dist, a linked checkout,
+ * an overlay) and the version in `package.json` can stay the same, so Vite keeps serving the OLD
+ * pre-bundled copy out of `node_modules/.vite` across dev-server restarts. The fix you just shipped
+ * is simply not in the browser, and it looks like the fix does not work. That cost a real
+ * false-negative during this bug hunt, and every user upgrading in place hits the same thing.
+ *
+ * Size+mtime is enough: it changes whenever the bundle does and costs one `stat`.
+ */
+function sdkBuildFingerprint() {
+    try {
+        const entry = createRequire(import.meta.url).resolve(RETICLE_PACKAGE);
+        const { size, mtimeMs } = statSync(entry);
+        return `${String(size)}-${String(Math.trunc(mtimeMs))}`;
+    }
+    catch {
+        // Unresolvable (not installed yet, exotic layout) — a constant is still correct, just inert.
+        return 'unknown';
+    }
+}
 /** Files we stamp with source info — JSX/TSX only. */
 const JSX_FILE = /\.[jt]sx$/;
 /** Rollup virtual-module ids start with a NUL byte; never transform those. */
@@ -77,14 +122,23 @@ function isHtmlEntry(id, specifier, root) {
     // buildEnd post-condition means a wrong match cannot pass unnoticed as "nothing happened".
     return candidate.endsWith(target.startsWith('/') ? target : `/${target}`);
 }
-function shouldStamp(id) {
+/** A module id we may stamp at all: not virtual, not a dependency. Extension decides which stamper. */
+function stampableId(id) {
     if (id.startsWith(VIRTUAL_PREFIX))
-        return false;
+        return null;
     if (id.includes(NODE_MODULES))
-        return false;
+        return null;
     // Strip any query suffix (?worker, ?raw,...) before matching the extension.
-    const clean = id.split('?')[0] ?? id;
-    return JSX_FILE.test(clean);
+    return id.split('?')[0] ?? id;
+}
+function shouldStamp(id) {
+    const clean = stampableId(id);
+    return clean !== null && JSX_FILE.test(clean);
+}
+/** A `.svelte` single-file component, which needs the Svelte stamper rather than Babel. */
+function shouldStampSvelte(id) {
+    const clean = stampableId(id);
+    return clean !== null && SVELTE_FILE.test(clean);
 }
 function stamp(code, id) {
     const out = transformSync(code, {
@@ -152,9 +206,34 @@ function connectArgs(options) {
     return Object.keys(args).length > 0 ? JSON.stringify(args) : '';
 }
 /** The body of the connect module — real imports, resolved by Vite when the module is served. */
-export function connectModuleSource(options) {
+/**
+ * The conventional app-side dev module: `registerStore` / `registerCapabilities` live here.
+ *
+ * It is imported by CONVENTION rather than by patching the app's entry file. The connect is injected
+ * into a virtual module, so there is nowhere for a user to add these calls without `init` editing
+ * `src/main.tsx` — an edit to the file people actually own, for something that is opt-in enrichment.
+ * Convention costs one `existsSync` and leaves their entry untouched.
+ */
+export const RETICLE_DEV_MODULE_CANDIDATES = [
+    'src/reticle-dev.ts',
+    'src/reticle-dev.js',
+    'src/reticle-dev.tsx',
+    'src/reticle-dev.jsx',
+];
+/** The app's dev module, as an importable path — or null when the app has none. */
+export function findDevModule(root, exists) {
+    for (const rel of RETICLE_DEV_MODULE_CANDIDATES) {
+        if (exists(`${root}/${rel}`))
+            return `/${rel}`;
+    }
+    return null;
+}
+export function connectModuleSource(options, devModule = null) {
     const args = connectArgs(options);
-    return `import { reticle, install } from '${RETICLE_PACKAGE}';\ninstall();\nreticle.connect(${args});\n`;
+    const base = `import { reticle, install } from '${RETICLE_PACKAGE}';\ninstall();\nreticle.connect(${args});\n`;
+    // AFTER connect: registerStore subscribes through the live SDK, and registering before there is a
+    // session to report into drops the first diffs.
+    return devModule === null ? base : `${base}import('${devModule}');\n`;
 }
 /**
  * Reticle Vite plugin. Add to your `plugins` array and the entire integration is done:
@@ -256,15 +335,48 @@ export function reticle(options = {}) {
          * developer has never heard of. Measured on the react-admin demo with the SDK aliased to a local
          * checkout: zero sessions, and it looked like the app was failing to render.
          *
-         * Declaring them is free when Vite would have found them anyway.
+         * Declaring them is free when Vite would have found them anyway — but only when they are
+         * actually installed. Naming a package that is not there makes Vite log `Failed to resolve
+         * dependency: …, present in optimizeDeps.include` on every boot, which is a scary line pointing
+         * at Reticle for a problem that does not exist. SvelteKit apps hit exactly that: nothing in that
+         * tree depends on @testing-library/dom.
          */
         config(config) {
             return {
+                // Expose the daemon's pairing token to hand-written connects in the same Vite app. The
+                // plugin's own injected connect gets the token directly, but a connect the USER writes —
+                // SvelteKit's client hook, a custom entry — had no way to reach a file only Node can read,
+                // so it called connect() with no credential and the bridge answered "authentication
+                // failed". Empty until the daemon has provisioned one; the page reloads once it has.
+                define: {
+                    ...(config.define ?? {}),
+                    [RETICLE_TOKEN_GLOBAL]: JSON.stringify(readPairingToken() ?? ''),
+                    // Lets the SDK report React's absolute `_debugSource.fileName` as a repo-relative path,
+                    // so source looks the same whichever React version an app is on.
+                    [RETICLE_ROOT_GLOBAL]: JSON.stringify(config.root ?? process.cwd()),
+                },
                 optimizeDeps: {
+                    // Part of the cache key, not of the build: changing it is what makes Vite notice that the
+                    // SDK on disk is not the SDK it pre-bundled. See sdkBuildFingerprint.
+                    esbuildOptions: {
+                        ...(config.optimizeDeps?.esbuildOptions ?? {}),
+                        define: {
+                            ...(config.optimizeDeps?.esbuildOptions?.define ?? {}),
+                            __RETICLE_SDK_BUILD__: JSON.stringify(sdkBuildFingerprint()),
+                        },
+                    },
                     include: [
                         ...(config.optimizeDeps?.include ?? []),
-                        SDK_CJS_DEPS.TESTING_LIBRARY,
-                        SDK_CJS_DEPS.ARIA_QUERY,
+                        // The SDK ITSELF. Without this, Vite does not learn about @reticlehq/react until the
+                        // injected connect module is requested — mid-flight, on the very first page load. It
+                        // then pre-bundles it and forces a full reload, and the connect is lost in that reload:
+                        // no WebSocket, no session, no console message. The FIRST load after `reticle init` —
+                        // the one the whole product is judged on — silently did nothing, and it worked on the
+                        // next refresh, which is the worst possible shape for a bug like this.
+                        RETICLE_PACKAGE,
+                        // Only if present — see above; naming an absent package produces a boot warning that
+                        // blames Reticle for nothing.
+                        ...[SDK_CJS_DEPS.TESTING_LIBRARY, SDK_CJS_DEPS.ARIA_QUERY].filter(isResolvable),
                     ],
                 },
             };
@@ -279,7 +391,16 @@ export function reticle(options = {}) {
                 const stamped = sourceMapping && shouldStamp(id) ? stamp(withConnect, id) : null;
                 return stamped ?? { code: withConnect, map: null };
             }
-            if (!sourceMapping || !shouldStamp(id))
+            if (!sourceMapping)
+                return null;
+            // `.svelte` runs on the RAW component source, which is only still markup because this plugin
+            // declares `enforce: 'pre'` and therefore transforms before @sveltejs/vite-plugin-svelte. No
+            // map: the insertions are within a line and never move one, and a wrong map is worse than none.
+            if (shouldStampSvelte(id)) {
+                const stamped = stampSvelte(code, id);
+                return stamped === null ? null : { code: stamped, map: null };
+            }
+            if (!shouldStamp(id))
                 return null;
             return stamp(code, id);
         },
@@ -301,7 +422,9 @@ export function reticle(options = {}) {
         load(id) {
             if (!inject || id !== RETICLE_CONNECT_MODULE)
                 return null;
-            return connectModuleSource(resolveLazy());
+            // Resolved at load, not at config: the file may be created after the dev server starts.
+            const devModule = root === undefined ? null : findDevModule(root, existsSync);
+            return connectModuleSource(resolveLazy(), devModule);
         },
         configResolved(config) {
             root = config.root;

package/dist/svelte-source.d.ts

@@ -0,0 +1,66 @@
+/**
+ * `data-reticle-source` for `.svelte` single-file components.
+ *
+ * A SvelteKit app onboards, connects, and gets DOM, network, console, routing and storage — and then
+ * every verdict comes back without the `file:line` the whole product leads with, because the JSX
+ * stamper is Babel and a `.svelte` file is not JavaScript. This is the Svelte half.
+ *
+ * ## Where in the pipeline
+ *
+ * A Vite `transform` on the RAW component source, in the Reticle plugin, which already declares
+ * `enforce: 'pre'` — so it runs before `@sveltejs/vite-plugin-svelte` and hands the compiler markup
+ * that already carries the attribute. Getting the order wrong is the failure mode worth naming: run
+ * it after, and there is no markup left to stamp, only generated JavaScript whose original line
+ * numbers are gone. A Svelte *preprocessor* would also work and would be equally correct, but it has
+ * to be wired into `svelte.config.js` by the user, and an integration nobody enables is an
+ * integration that does not exist.
+ *
+ * ## Why the compiler is loaded the way it is
+ *
+ * `svelte` must never become a dependency of this package: a React project installing the Vite
+ * plugin must not acquire a Svelte compiler, and its build must be unaffected. So the compiler is
+ * resolved lazily, from the APP's directory, only when a `.svelte` id actually arrives, and its
+ * absence returns null rather than throwing. Same shape as the optional `playwright` import in the
+ * server's pool launcher.
+ *
+ * Resolution is synchronous (`createRequire`) rather than `await import()` because Svelte ships a CJS
+ * build of its compiler and the plugin's `transform` is synchronous — making the whole hook async to
+ * fetch an optional dependency would change the contract of every other path through it.
+ *
+ * ## Scope
+ *
+ * The attribute only. Mapping a DOM node to the COMPONENT that rendered it — what `@reticlehq/react`
+ * does through the fiber tree — is a separate and much larger problem, and is not attempted here.
+ */
+/** Files this module stamps. `.svelte.ts` (a runes module) is code, not markup — excluded. */
+export declare const SVELTE_FILE: RegExp;
+/** The part of `svelte/compiler` this module uses. Structural, so `svelte` stays un-imported. */
+export interface SvelteCompilerLike {
+    parse: (source: string, options?: {
+        modern?: boolean;
+    }) => unknown;
+}
+/** How the compiler is obtained. Injected in tests; the default resolves it from the app. */
+export type LoadSvelteCompiler = () => SvelteCompilerLike | null;
+/**
+ * A character offset as Babel would report it: 1-based line, 0-based column.
+ *
+ * Matching Babel exactly is not cosmetic — `parseSourceAttr` in the browser SDK reads one format,
+ * and a Svelte pointer that was 0-based on line would land every verdict one line off while looking
+ * completely plausible.
+ */
+export declare function offsetToLineColumn(source: string, offset: number): {
+    line: number;
+    column: number;
+};
+/** Project-relative, forward-slashed. A pointer must be the same string on Windows as on Linux. */
+export declare function sourcePathFor(id: string, cwd?: string): string;
+/**
+ * Stamp `data-reticle-source="file:line:column"` on every host element of a `.svelte` component.
+ *
+ * Returns null — never throws — when the compiler is absent or the component does not parse. In dev
+ * the transform runs on every keystroke, so a half-typed component is the NORMAL case; failing the
+ * build over one would make Reticle the reason the dev server is red, for a feature that is pure
+ * enrichment on top of an app that otherwise works.
+ */
+export declare function stampSvelte(code: string, id: string, load?: LoadSvelteCompiler): string | null;

package/dist/svelte-source.js

@@ -0,0 +1,166 @@
+import { createRequire } from 'node:module';
+import { relative } from 'node:path';
+import { DATA_RETICLE_SOURCE_ATTR } from '@reticlehq/core';
+/**
+ * `data-reticle-source` for `.svelte` single-file components.
+ *
+ * A SvelteKit app onboards, connects, and gets DOM, network, console, routing and storage — and then
+ * every verdict comes back without the `file:line` the whole product leads with, because the JSX
+ * stamper is Babel and a `.svelte` file is not JavaScript. This is the Svelte half.
+ *
+ * ## Where in the pipeline
+ *
+ * A Vite `transform` on the RAW component source, in the Reticle plugin, which already declares
+ * `enforce: 'pre'` — so it runs before `@sveltejs/vite-plugin-svelte` and hands the compiler markup
+ * that already carries the attribute. Getting the order wrong is the failure mode worth naming: run
+ * it after, and there is no markup left to stamp, only generated JavaScript whose original line
+ * numbers are gone. A Svelte *preprocessor* would also work and would be equally correct, but it has
+ * to be wired into `svelte.config.js` by the user, and an integration nobody enables is an
+ * integration that does not exist.
+ *
+ * ## Why the compiler is loaded the way it is
+ *
+ * `svelte` must never become a dependency of this package: a React project installing the Vite
+ * plugin must not acquire a Svelte compiler, and its build must be unaffected. So the compiler is
+ * resolved lazily, from the APP's directory, only when a `.svelte` id actually arrives, and its
+ * absence returns null rather than throwing. Same shape as the optional `playwright` import in the
+ * server's pool launcher.
+ *
+ * Resolution is synchronous (`createRequire`) rather than `await import()` because Svelte ships a CJS
+ * build of its compiler and the plugin's `transform` is synchronous — making the whole hook async to
+ * fetch an optional dependency would change the contract of every other path through it.
+ *
+ * ## Scope
+ *
+ * The attribute only. Mapping a DOM node to the COMPONENT that rendered it — what `@reticlehq/react`
+ * does through the fiber tree — is a separate and much larger problem, and is not attempted here.
+ */
+/** Files this module stamps. `.svelte.ts` (a runes module) is code, not markup — excluded. */
+export const SVELTE_FILE = /\.svelte$/;
+/** Element node types that are a real place in the DOM, in Svelte 5's AST and Svelte 4's. */
+const HOST_ELEMENT_TYPES = new Set(['RegularElement', 'Element']);
+/** The `parent` back-reference some AST shapes carry; following it would walk forever. */
+const PARENT_KEY = 'parent';
+/** Resolved once per process: `null` means "looked, not installed" and must not be retried per file. */
+let cachedCompiler;
+function defaultLoadCompiler() {
+    if (cachedCompiler !== undefined)
+        return cachedCompiler;
+    cachedCompiler = null;
+    // From the APP's root first. The plugin may be linked, hoisted, or in a pnpm store far from the
+    // project, and the compiler that matters is the one the app's own Svelte plugin will use.
+    for (const from of [`${process.cwd()}/package.json`, import.meta.url]) {
+        try {
+            cachedCompiler = createRequire(from)('svelte/compiler');
+            break;
+        }
+        catch {
+            // Not resolvable from here — try the next origin, then give up silently.
+        }
+    }
+    return cachedCompiler;
+}
+/**
+ * A character offset as Babel would report it: 1-based line, 0-based column.
+ *
+ * Matching Babel exactly is not cosmetic — `parseSourceAttr` in the browser SDK reads one format,
+ * and a Svelte pointer that was 0-based on line would land every verdict one line off while looking
+ * completely plausible.
+ */
+export function offsetToLineColumn(source, offset) {
+    let line = 1;
+    let lineStart = 0;
+    for (let i = 0; i < offset && i < source.length; i++) {
+        if (source[i] === '\n') {
+            line += 1;
+            lineStart = i + 1;
+        }
+    }
+    return { line, column: offset - lineStart };
+}
+/** Project-relative, forward-slashed. A pointer must be the same string on Windows as on Linux. */
+export function sourcePathFor(id, cwd = process.cwd()) {
+    return relative(cwd, id).replace(/\\/g, '/');
+}
+function isElementNode(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const node = value;
+    return (typeof node.type === 'string' &&
+        HOST_ELEMENT_TYPES.has(node.type) &&
+        typeof node.name === 'string' &&
+        typeof node.start === 'number');
+}
+function isAlreadyStamped(node) {
+    return (node.attributes ?? []).some((attr) => attr !== null &&
+        typeof attr === 'object' &&
+        attr.name === DATA_RETICLE_SOURCE_ATTR);
+}
+/**
+ * Collect every host element in the AST.
+ *
+ * A GENERIC walk over the object graph rather than a switch over Svelte's block types. `{#if}`,
+ * `{#each}`, `{#await}`, `{#key}`, `{#snippet}` and whatever the next release adds each nest their
+ * children under a differently-named field, and a hand-written descent silently misses the ones it
+ * has not heard of — elements inside an `{#each}` would simply never be stamped, with nothing to
+ * indicate they were skipped.
+ */
+function collectElements(root) {
+    const found = [];
+    const seen = new Set();
+    const visit = (value) => {
+        if (value === null || typeof value !== 'object' || seen.has(value))
+            return;
+        seen.add(value);
+        if (Array.isArray(value)) {
+            for (const item of value)
+                visit(item);
+            return;
+        }
+        if (isElementNode(value) && !isAlreadyStamped(value))
+            found.push(value);
+        for (const [key, child] of Object.entries(value)) {
+            if (key !== PARENT_KEY)
+                visit(child);
+        }
+    };
+    visit(root);
+    return found;
+}
+/**
+ * Stamp `data-reticle-source="file:line:column"` on every host element of a `.svelte` component.
+ *
+ * Returns null — never throws — when the compiler is absent or the component does not parse. In dev
+ * the transform runs on every keystroke, so a half-typed component is the NORMAL case; failing the
+ * build over one would make Reticle the reason the dev server is red, for a feature that is pure
+ * enrichment on top of an app that otherwise works.
+ */
+export function stampSvelte(code, id, load = defaultLoadCompiler) {
+    const compiler = load();
+    if (compiler === null)
+        return null;
+    let ast;
+    try {
+        // `modern: true` selects Svelte 5's AST; Svelte 4 ignores the option and returns its own shape.
+        // `collectElements` accepts both, so one call covers either major without a version probe.
+        ast = compiler.parse(code, { modern: true });
+    }
+    catch {
+        return null;
+    }
+    const elements = collectElements(ast);
+    if (elements.length === 0)
+        return null;
+    const file = sourcePathFor(id);
+    // Insert from the LAST element backwards: every insertion shifts the offsets after it, and
+    // applying them in source order would put each stamp progressively further from its own tag.
+    const ordered = [...elements].sort((a, b) => b.start - a.start);
+    let out = code;
+    for (const node of ordered) {
+        const { line, column } = offsetToLineColumn(code, node.start);
+        const insertAt = node.start + 1 + node.name.length;
+        const attribute = ` ${DATA_RETICLE_SOURCE_ATTR}="${file}:${String(line)}:${String(column)}"`;
+        out = `${out.slice(0, insertAt)}${attribute}${out.slice(insertAt)}`;
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reticlehq/vite-plugin",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Vite plugin for Reticle: dev-only source-map stamping plus auto-injected reticle.connect(). apply:'serve' guarantees it never ships to production.",
   "type": "module",
   "license": "Apache-2.0",
@@ -34,11 +34,12 @@
   ],
   "dependencies": {
     "@babel/core": "^7.26.0",
-    "@reticlehq/babel-plugin": "2.3.0",
-    "@reticlehq/core": "2.3.0"
+    "@reticlehq/babel-plugin": "2.4.0",
+    "@reticlehq/core": "2.4.0"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",
+    "svelte": "^5.56.8",
     "vite": "^8"
   },
   "peerDependencies": {