@j0hanz/filesystem-mcp 1.19.0 → 2.0.0

package/dist/resources.js

@@ -1,179 +1,408 @@
-import { ProtocolError, ProtocolErrorCode, ResourceTemplate, } from '@modelcontextprotocol/server';
-import { globalMetrics } from './lib/observability.js';
-import { buildToolCatalog } from './resources/tool-catalog.js';
-import { buildToolInfo, getToolContracts } from './resources/tool-info.js';
-import { buildWorkflowGuide } from './resources/workflows.js';
-import { withDefaultIcons } from './tools/shared.js';
-const RESULT_TEMPLATE = new ResourceTemplate('filesystem-mcp://result/{id}', {
-    list: undefined,
-});
-const TOOL_INFO_TEMPLATE = new ResourceTemplate('internal://tool-info/{name}', {
-    list: () => ({
-        resources: getToolContracts().map((contract) => ({
-            uri: `internal://tool-info/${contract.name}`,
-            name: contract.name,
-            title: contract.title,
-            description: contract.description,
-            mimeType: 'text/markdown',
-        })),
-    }),
-});
-const TOOL_INFO_RESOURCE_NAME = 'filesystem-mcp-tool-info';
-const TOOL_INFO_RESOURCE_DESCRIPTION = 'Per-tool contract details, nuances, and gotchas. Read internal://tool-info/{name} with a tool name such as "read", "ls", or "grep".';
-const INSTRUCTIONS_RESOURCE_NAME = 'filesystem-mcp-instructions';
-const INSTRUCTIONS_RESOURCE_URI = 'internal://instructions';
-const INSTRUCTIONS_RESOURCE_DESCRIPTION = 'Comprehensive rules and guidelines for filesystem-mcp usage.';
-const RESULT_RESOURCE_NAME = 'filesystem-mcp-result';
-const RESULT_RESOURCE_DESCRIPTION = 'Ephemeral cached tool output exposed as an MCP resource. Not guaranteed to be listed via resources/list.';
-const METRICS_RESOURCE_NAME = 'filesystem-mcp-metrics';
-const METRICS_RESOURCE_URI = 'filesystem-mcp://metrics';
-const METRICS_RESOURCE_DESCRIPTION = 'Live per-tool call/error/avgDurationMs metrics snapshot.';
-const CATALOG_RESOURCE_NAME = 'filesystem-mcp-catalog';
-const CATALOG_RESOURCE_URI = 'internal://tool-catalog';
-const CATALOG_RESOURCE_DESCRIPTION = 'Tool selection guide and data flow map.';
-const WORKFLOW_RESOURCE_NAME = 'filesystem-mcp-workflows';
-const WORKFLOW_RESOURCE_URI = 'internal://workflows';
-const WORKFLOW_RESOURCE_DESCRIPTION = 'Standard operating procedures for exploration, search, edit, and patch.';
-export function registerInstructionResource(server, instructions, iconInfo) {
-    server.registerResource(INSTRUCTIONS_RESOURCE_NAME, INSTRUCTIONS_RESOURCE_URI, withDefaultIcons({
+import { checkResourceAllowed, ProtocolError, ProtocolErrorCode, ResourceNotFoundError, ResourceTemplate, resourceUrlFromServerUrl, UriTemplate, } from '@modelcontextprotocol/server';
+import { ErrorCode, formatUnknownErrorMessage, fsErrorCode, hasErrorShape, isFsError, } from './core/errors.js';
+import { decodeFileUriPath, encodeFileUriPath, extractPath, FILESYSTEM_FILE_URI_TEMPLATE, } from './core/file-uri.js';
+import { GuardedFileSystem } from './core/fs.js';
+import { Logger } from './core/observability.js';
+import { PathCompleter } from './core/path-completer.js';
+import { createWatcherRegistry, MAX_WATCHERS, } from './core/watcher-registry.js';
+import { buildSectionsRecord, INSTRUCTIONS_SUMMARY, INSTRUCTIONS_URI, renderSections, } from './instructions.js';
+/**
+ * A filesystem failure that reads as not-found on the resource wire, for both
+ * `resources/read` and `resources/subscribe`. ACCESS_DENIED folds in
+ * deliberately: masking whether an out-of-root or denylisted path exists is the
+ * security-correct answer, and the `FsError` message still carries the real
+ * cause to the client.
+ */
+function isNotFoundish(error) {
+    return (isFsError(error) &&
+        (error.code === ErrorCode.NOT_FOUND || error.code === ErrorCode.ACCESS_DENIED));
+}
+// ═══════════════════════════════════════════════════════════════
+// instructions
+// ═══════════════════════════════════════════════════════════════
+function createInstructionsResource(options) {
+    const text = renderSections(buildSectionsRecord(options.readOnly));
+    return {
+        name: 'filesystem-mcp-instructions',
         title: 'Server Instructions',
-        description: INSTRUCTIONS_RESOURCE_DESCRIPTION,
+        description: INSTRUCTIONS_SUMMARY,
         mimeType: 'text/markdown',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.8,
+        uri: INSTRUCTIONS_URI,
+        annotations: { audience: ['assistant'], priority: 0.8 },
+        cacheHint: { cacheScope: options.cacheScope ?? 'public', ttlMs: 300_000 },
+        read(uri) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: 'text/markdown',
+                        text,
+                    },
+                ],
+            };
         },
-    }, iconInfo), (uri) => ({
-        contents: [
-            {
-                uri: uri.href,
-                mimeType: 'text/markdown',
-                text: instructions,
-            },
-        ],
-    }));
+    };
 }
-export function registerToolCatalogResource(server, iconInfo) {
-    server.registerResource(CATALOG_RESOURCE_NAME, CATALOG_RESOURCE_URI, withDefaultIcons({
-        title: 'Tool Catalog',
-        description: CATALOG_RESOURCE_DESCRIPTION,
-        mimeType: 'text/markdown',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.7,
+// ═══════════════════════════════════════════════════════════════
+// filesystem
+// ═══════════════════════════════════════════════════════════════
+function createFilesystemResource(options) {
+    const completer = options.pathGuard ? new PathCompleter(options.pathGuard) : undefined;
+    const registry = options.watcherRegistry ?? createWatcherRegistry();
+    // Only the per-server (legacy/stdio) registry is owned by this resource and
+    // destroyed on dispose; the shared modern-leg registry is owned by the host
+    // and torn down at server shutdown.
+    const ownsRegistry = options.watcherRegistry === undefined;
+    // The URIs this connection holds a `resources/subscribe` lease for. The wire
+    // verb is per-URI and idempotent — a second subscribe is the same
+    // subscription, and one unsubscribe ends it — but the registry ref-counts
+    // leases (the HTTP listen leg needs that). Without this set a double
+    // subscribe took two leases that one unsubscribe could not release, and an
+    // unsubscribe for a URI never subscribed released a lease this connection
+    // never took, dropping a watcher some other holder still wanted.
+    const leasedUris = new Set();
+    // Subscribes mid-acquire, keyed by URI. Two concurrent subscribes for the
+    // same URI must share one acquire: both passing the `leasedUris` check
+    // before either finished took two registry leases that the single set entry
+    // could release only once — on the shared modern registry that orphan lease
+    // pinned a watcher until process shutdown.
+    const inflight = new Map();
+    return {
+        name: 'filesystem-mcp-file',
+        title: 'Workspace File',
+        description: 'Read a file from the workspace. Subscribe to get updates when the file changes.',
+        uriTemplate: FILESYSTEM_FILE_URI_TEMPLATE,
+        annotations: { audience: ['assistant'], priority: 0.8 },
+        // Without this the SDK falls back to its conservative `{ ttlMs: 0,
+        // cacheScope: 'private' }`, making every file read uncacheable — and this
+        // is the one resource with a live invalidation channel, so TTL and the
+        // watcher compose exactly as the spec's caching section describes. The TTL
+        // stays short because a non-subscriber gets no invalidation signal at all.
+        cacheHint: { cacheScope: options.cacheScope ?? 'public', ttlMs: 5_000 },
+        // No `list`: the template registers with `list: undefined` — readable but
+        // not enumerable. Listing each allowed root as a concrete resource
+        // duplicated the template and grew resources/list linearly with roots;
+        // `list_roots` owns root discovery.
+        async read(uri, _variables, _ctx) {
+            if (!options.pathGuard) {
+                throw new ProtocolError(ProtocolErrorCode.InternalError, 'PathGuard not configured');
+            }
+            // Decode via extractPath — the same decoder resources/subscribe uses — so
+            // both consumers are symmetric with buildFileResourceUri's encoding. The
+            // {+path} template variable arrives still percent-encoded, so validating
+            // it directly would treat "c%3A/proj/a.ts" as a literal relative path;
+            // no fallback to it here, or the two branches would validate different
+            // strings. extractPath only fails past the template match on undecodable
+            // percent-encoding, which is the caller's malformed URI.
+            const rawPath = extractPath(uri.href);
+            if (rawPath === undefined) {
+                throw new ProtocolError(ProtocolErrorCode.InvalidParams, 'Malformed file URI: path is not valid percent-encoding');
+            }
+            await options.pathGuard.validateExistingPath(rawPath);
+            const fs = new GuardedFileSystem(options.pathGuard);
+            const readResult = await fs.readRaw(rawPath);
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: readResult.mimeType || 'application/octet-stream',
+                        ...(readResult.isBinary
+                            ? { blob: readResult.content.toString('base64') }
+                            : { text: readResult.content.toString('utf-8') }),
+                    },
+                ],
+            };
         },
-    }, iconInfo), (uri) => ({
-        contents: [
-            {
-                uri: uri.href,
-                mimeType: 'text/markdown',
-                text: buildToolCatalog(),
-            },
-        ],
-    }));
-}
-export function registerWorkflowGuideResource(server, iconInfo) {
-    server.registerResource(WORKFLOW_RESOURCE_NAME, WORKFLOW_RESOURCE_URI, withDefaultIcons({
-        title: 'Workflow Guide',
-        description: WORKFLOW_RESOURCE_DESCRIPTION,
-        mimeType: 'text/markdown',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.6,
+        async complete(variable, value) {
+            if (variable !== 'path' || !completer)
+                return [];
+            // Both ends speak the `{+path}` form (see encodeFileUriPath), not raw OS
+            // paths: the partial arriving here is whatever this returned last, so the
+            // decode mirrors the encode. An undecodable partial is matched as typed.
+            const suggestions = await completer.suggest(decodeFileUriPath(value) ?? value);
+            return suggestions.map(encodeFileUriPath);
         },
-    }, iconInfo), (uri) => ({
-        contents: [
-            {
-                uri: uri.href,
-                mimeType: 'text/markdown',
-                text: buildWorkflowGuide(),
-            },
-        ],
-    }));
+        subscribe(uri, notify) {
+            const pathGuard = options.pathGuard;
+            if (!pathGuard)
+                return undefined;
+            // Already subscribed on this connection: the watcher is live and the sink
+            // is registered, so this is a no-op success rather than a second lease.
+            if (leasedUris.has(uri))
+                return undefined;
+            // A subscribe for this URI is mid-acquire: share its outcome instead of
+            // taking a second lease the lease set cannot represent.
+            const pending = inflight.get(uri);
+            if (pending)
+                return pending;
+            const acquire = async () => {
+                const result = await registry.acquire(pathGuard, uri, notify, {
+                    markSubscribe: true,
+                });
+                if (result.ok) {
+                    leasedUris.add(uri);
+                    return undefined;
+                }
+                if (result.reason === 'bad-uri') {
+                    throw new ResourceNotFoundError(uri, `Cannot subscribe: not a filesystem URI`);
+                }
+                if (result.reason === 'invalid-path') {
+                    const err = result.error;
+                    if (isNotFoundish(err)) {
+                        throw new ResourceNotFoundError(uri, `Cannot subscribe to ${uri}: ${err.message}`);
+                    }
+                    Logger.warn(`Unexpected error validating path for watcher ${uri}: ${formatUnknownErrorMessage(err)}`);
+                    throw err;
+                }
+                // Unsubscribed (or the registry destroyed) mid-await: the caller already
+                // asked for this to stop, so there is nothing to reject.
+                if (result.reason === 'stale')
+                    return undefined;
+                // capped / attach-failed: `false` tells the handler to reject, since
+                // undefined would report success with no watcher attached.
+                return false;
+            };
+            const promise = acquire().finally(() => inflight.delete(uri));
+            inflight.set(uri, promise);
+            return promise;
+        },
+        unsubscribe(uri) {
+            // Only release a lease this connection actually took.
+            if (!leasedUris.delete(uri))
+                return;
+            registry.release(uri);
+        },
+        destroy() {
+            // Release what this connection still holds before the registry goes: on
+            // the shared (modern) registry nothing else would ever end these leases.
+            for (const uri of leasedUris)
+                registry.release(uri);
+            leasedUris.clear();
+            if (ownsRegistry)
+                registry.destroy();
+        },
+    };
 }
-export function registerResultResources(server, store, iconInfo) {
-    server.registerResource(RESULT_RESOURCE_NAME, RESULT_TEMPLATE, withDefaultIcons({
+// ═══════════════════════════════════════════════════════════════
+// result
+// ═══════════════════════════════════════════════════════════════
+function createResultResource(options) {
+    return {
+        name: 'filesystem-mcp-result',
         title: 'Cached Tool Result',
-        description: RESULT_RESOURCE_DESCRIPTION,
-        mimeType: 'text/plain',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.3,
+        description: 'Ephemeral cached tool output. Listed via resources/list; entries expire after the cache TTL.',
+        mimeType: 'application/json',
+        uriTemplate: 'filesystem-mcp://result/{id}',
+        annotations: { audience: ['assistant'], priority: 0.3 },
+        cacheHint: { cacheScope: 'private', ttlMs: 60_000 },
+        list() {
+            const store = options.resourceStore;
+            const uris = store.keys(); // prunes expired first
+            const resources = [];
+            for (const uri of uris) {
+                try {
+                    const entry = store.getEntry(uri);
+                    resources.push({
+                        uri: entry.uri,
+                        name: entry.name,
+                        mimeType: entry.mimeType,
+                        size: entry.size,
+                    });
+                }
+                catch (err) {
+                    // An entry may expire between keys() and getEntry; skip it.
+                    if (isFsError(err) && err.code === ErrorCode.NOT_FOUND)
+                        continue;
+                    throw err;
+                }
+            }
+            // Recent-first: keys() returns insertion order, so the newest is last.
+            resources.reverse();
+            return { resources };
         },
-    }, iconInfo), (uri, variables) => {
-        const { id } = variables;
-        if (typeof id !== 'string' || id.length === 0) {
-            throw new ProtocolError(ProtocolErrorCode.ResourceNotFound, 'Cached result expired. Re-run the tool to regenerate.');
-        }
-        const entry = store.getText(uri.toString());
-        return {
-            contents: [
-                {
-                    uri: entry.uri,
-                    mimeType: entry.mimeType,
-                    text: entry.text,
-                },
-            ],
-        };
-    });
-}
-export function registerToolInfoResource(server, iconInfo) {
-    server.registerResource(TOOL_INFO_RESOURCE_NAME, TOOL_INFO_TEMPLATE, withDefaultIcons({
-        title: 'Tool Info',
-        description: TOOL_INFO_RESOURCE_DESCRIPTION,
-        mimeType: 'text/markdown',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.65,
+        read(uri, variables) {
+            const { id } = variables;
+            if (typeof id !== 'string' || id.length === 0) {
+                throw new ProtocolError(ProtocolErrorCode.InvalidParams, 'Malformed result URI: missing {id}. Use the exact resourceUri returned by the tool.');
+            }
+            let entry;
+            try {
+                entry = options.resourceStore.getEntry(uri.toString());
+            }
+            catch (err) {
+                if (isFsError(err) && err.code === ErrorCode.NOT_FOUND) {
+                    throw new ResourceNotFoundError(uri.toString(), 'Cached result not found or expired. Re-run the tool to regenerate.');
+                }
+                throw err;
+            }
+            return {
+                contents: [{ uri: entry.uri, mimeType: entry.mimeType, text: entry.text }],
+            };
         },
-    }, iconInfo), (uri, variables) => {
-        const { name } = variables;
-        if (typeof name !== 'string' || name.length === 0) {
-            throw new ProtocolError(ProtocolErrorCode.InvalidParams, 'Tool name is required');
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// export contracts
+// ═══════════════════════════════════════════════════════════════
+export function getResourceContracts(options) {
+    return [
+        createInstructionsResource(options),
+        createResultResource(options),
+        createFilesystemResource(options),
+    ];
+}
+// ═══════════════════════════════════════════════════════════════
+// registrar
+// ═══════════════════════════════════════════════════════════════
+function wrapRead(contract) {
+    return async (uri, variables, ctx) => {
+        try {
+            return await contract.read(uri, variables, ctx);
         }
-        const content = buildToolInfo(name);
-        if (content === undefined) {
-            throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool not found: ${name}`);
+        catch (error) {
+            if (hasErrorShape(error, 'ProtocolError'))
+                throw error;
+            // A missing or out-of-root path is a not-found, not a malformed request.
+            // The SDK puts ResourceNotFoundError on the wire as -32602 with
+            // `data.uri`, which is what clients match on; -32002 is the older code
+            // they also accept, and this SDK never emits it.
+            if (isNotFoundish(error)) {
+                throw new ResourceNotFoundError(uri.toString(), error.message);
+            }
+            // A remaining FsError (NOT_FILE, TOO_LARGE, ...) traces to the
+            // caller-supplied URI; anything else is a server-side failure and must
+            // not be blamed on the request.
+            const msg = isFsError(error) ? error.message : formatUnknownErrorMessage(error);
+            throw new ProtocolError(fsErrorCode(error), msg);
         }
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: 'text/markdown',
-                    text: content,
-                },
-            ],
-        };
-    });
+    };
 }
-export function registerMetricsResource(server, iconInfo) {
-    server.registerResource(METRICS_RESOURCE_NAME, METRICS_RESOURCE_URI, withDefaultIcons({
-        title: 'Tool Metrics',
-        description: METRICS_RESOURCE_DESCRIPTION,
-        mimeType: 'application/json',
-        annotations: {
-            audience: ['assistant'],
-            priority: 0.5,
-        },
-    }, iconInfo), (uri) => {
-        const snapshot = {};
-        for (const [tool, m] of globalMetrics) {
-            snapshot[tool] = {
-                calls: m.calls,
-                errors: m.errors,
-                avgDurationMs: m.calls > 0
-                    ? parseFloat((m.totalDurationMs / m.calls).toFixed(2))
-                    : 0,
-            };
+export function registerResources(deps) {
+    const server = deps.server;
+    const resourceContracts = getResourceContracts({ ...deps, readOnly: deps.readOnly ?? false });
+    for (const contract of resourceContracts) {
+        const config = {
+            ...(contract.title !== undefined ? { title: contract.title } : {}),
+            ...(contract.description !== undefined ? { description: contract.description } : {}),
+            ...(contract.mimeType !== undefined ? { mimeType: contract.mimeType } : {}),
+            ...(contract.annotations !== undefined ? { annotations: contract.annotations } : {}),
+            ...(contract.cacheHint !== undefined ? { cacheHint: contract.cacheHint } : {}),
+        };
+        if (contract.uriTemplate) {
+            const template = new ResourceTemplate(contract.uriTemplate, {
+                list: contract.list,
+                ...(contract.complete
+                    ? {
+                        complete: Object.fromEntries(new UriTemplate(contract.uriTemplate).variableNames.map((varName) => [
+                            varName,
+                            (value, ctx) => {
+                                const completeFn = contract.complete;
+                                return completeFn ? completeFn(varName, value, ctx) : [];
+                            },
+                        ])),
+                    }
+                    : {}),
+            });
+            server.registerResource(contract.name, template, config, wrapRead(contract));
+        }
+        else if (contract.uri) {
+            server.registerResource(contract.name, contract.uri, config, (uri, ctx) => wrapRead(contract)(uri, {}, ctx));
         }
-        return {
-            contents: [
-                {
-                    uri: uri.href,
-                    mimeType: 'application/json',
-                    text: JSON.stringify({ ok: true, metrics: snapshot }, null, 2),
-                },
-            ],
+    }
+    // `resources/subscribe`/`unsubscribe` are 2025-era-only verbs; a modern
+    // server answers `-32601 Method not found` for them, so registering these
+    // handlers on a modern-era instance would dispatch to code no request can
+    // reach.
+    if (deps.era !== 'modern') {
+        server.server.assertCanSetRequestHandler('resources/subscribe');
+        server.server.assertCanSetRequestHandler('resources/unsubscribe');
+        // One stable callback for the whole registrar, NOT one per subscribe. The
+        // registry holds these in a Set keyed by identity, so a fresh closure per
+        // request made a second `resources/subscribe` for the same URI register a
+        // second sink: one file change then sent N notifications, and `unsubscribe`
+        // (which only ends a lease) removed none of them. Subscribe is per-URI on
+        // the wire, so the sink must be too — this makes it idempotent.
+        const notifyUpdated = (updatedUri) => {
+            if (deps.notifier) {
+                deps.notifier.resourceUpdated(updatedUri);
+                return;
+            }
+            const updatePayload = { uri: updatedUri };
+            // A failed notify means the connection went away; nothing to recover.
+            void server.server.sendResourceUpdated(updatePayload).catch((err) => {
+                Logger.debug('resource update not delivered', {
+                    uri: updatedUri,
+                    error: formatUnknownErrorMessage(err),
+                });
+            });
         };
-    });
+        server.server.setRequestHandler('resources/subscribe', async (req) => {
+            const requestedResource = resourceUrlFromServerUrl(req.params.uri);
+            let foundMatch = false;
+            // A resource that exists but has no watcher (the instructions text, a
+            // cached result) is NOT a not-found: reporting it as one told clients a
+            // URI they can list and read does not exist. Track the two cases apart.
+            let knownButNotSubscribable = false;
+            for (const contract of resourceContracts) {
+                const configured = contract.uri ?? contract.uriTemplate.split('{')[0];
+                if (!contract.subscribe) {
+                    if (configured &&
+                        checkResourceAllowed({ requestedResource, configuredResource: configured })) {
+                        knownButNotSubscribable = true;
+                    }
+                    continue;
+                }
+                if (!configured)
+                    continue;
+                if (checkResourceAllowed({
+                    requestedResource,
+                    configuredResource: configured,
+                })) {
+                    foundMatch = true;
+                    const subscribeResult = await contract.subscribe(requestedResource.toString(), notifyUpdated);
+                    if (subscribeResult === false) {
+                        // InternalError for want of anything better: ProtocolErrorCode
+                        // has no resource-limit member, and the message already names
+                        // the actionable cause.
+                        throw new ProtocolError(ProtocolErrorCode.InternalError, `Subscription rejected: no watcher attached (watcher limit ${MAX_WATCHERS} reached, or fs.watch failed to start).`);
+                    }
+                    break;
+                }
+            }
+            if (!foundMatch) {
+                if (knownButNotSubscribable) {
+                    throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Resource ${requestedResource.toString()} does not support subscriptions; only ${FILESYSTEM_FILE_URI_TEMPLATE} does. Read it again for the current contents.`);
+                }
+                throw new ResourceNotFoundError(requestedResource.toString(), `Resource not found: ${requestedResource.toString()}`);
+            }
+            return {};
+        });
+        server.server.setRequestHandler('resources/unsubscribe', (req) => {
+            // Route by URI prefix, mirroring the subscribe handler: a broadcast
+            // to every contract works while only one is subscribable, but hands a
+            // second subscribable contract someone else's URI the day it appears.
+            const requestedResource = resourceUrlFromServerUrl(req.params.uri);
+            for (const contract of resourceContracts) {
+                if (!contract.unsubscribe)
+                    continue;
+                const configured = contract.uri ?? contract.uriTemplate.split('{')[0];
+                if (!configured)
+                    continue;
+                if (checkResourceAllowed({ requestedResource, configuredResource: configured })) {
+                    contract.unsubscribe(requestedResource.toString());
+                }
+            }
+            return {};
+        });
+    }
+    return {
+        dispose() {
+            for (const contract of resourceContracts) {
+                if (contract.destroy) {
+                    contract.destroy();
+                }
+            }
+        },
+    };
 }
+//# sourceMappingURL=resources.js.map