@burdenoff/microfe-eventfullymanaged 2026.510.105

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @burdenoff/microfe-eventfullymanaged
+ *
+ * EventfullyManaged Microfrontend - Comprehensive Event Management Platform
+ */
+export { EventfullyManagedRoot } from './eventfullymanaged/EventfullyManagedRoot';
+export type { EventfullyManagedRootProps } from './eventfullymanaged/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAC;AAClF,YAAY,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+import { EventfullyManagedRoot as e } from "./eventfullymanaged/EventfullyManagedRoot.js";
+export { e as EventfullyManagedRoot };

package/dist/node_modules/@apollo/client/core/networkStatus.js

@@ -0,0 +1,9 @@
+//#region node_modules/@apollo/client/core/networkStatus.js
+var e;
+(function(e) {
+	e[e.loading = 1] = "loading", e[e.setVariables = 2] = "setVariables", e[e.fetchMore = 3] = "fetchMore", e[e.refetch = 4] = "refetch", e[e.poll = 6] = "poll", e[e.ready = 7] = "ready", e[e.error = 8] = "error", e[e.streaming = 9] = "streaming";
+})(e ||= {});
+//#endregion
+export { e as NetworkStatus };
+
+//# sourceMappingURL=networkStatus.js.map

package/dist/node_modules/@apollo/client/core/networkStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"networkStatus.js","names":[],"sources":["../../../../../node_modules/@apollo/client/core/networkStatus.js"],"sourcesContent":["/**\n * The current status of a query’s execution in our system.\n */\nexport var NetworkStatus;\n(function (NetworkStatus) {\n    /**\n     * The query has never been run before and the query is now currently running. A query will still\n     * have this network status even if a partial data result was returned from the cache, but a\n     * query was dispatched anyway.\n     */\n    NetworkStatus[NetworkStatus[\"loading\"] = 1] = \"loading\";\n    /**\n     * If `setVariables` was called and a query was fired because of that then the network status\n     * will be `setVariables` until the result of that query comes back.\n     */\n    NetworkStatus[NetworkStatus[\"setVariables\"] = 2] = \"setVariables\";\n    /**\n     * Indicates that `fetchMore` was called on this query and that the query created is currently in\n     * flight.\n     */\n    NetworkStatus[NetworkStatus[\"fetchMore\"] = 3] = \"fetchMore\";\n    /**\n     * Similar to the `setVariables` network status. It means that `refetch` was called on a query\n     * and the refetch request is currently in flight.\n     */\n    NetworkStatus[NetworkStatus[\"refetch\"] = 4] = \"refetch\";\n    /**\n     * Indicates that a polling query is currently in flight. So for example if you are polling a\n     * query every 10 seconds then the network status will switch to `poll` every 10 seconds whenever\n     * a poll request has been sent but not resolved.\n     */\n    NetworkStatus[NetworkStatus[\"poll\"] = 6] = \"poll\";\n    /**\n     * No request is in flight for this query, and no errors happened. Everything is OK.\n     */\n    NetworkStatus[NetworkStatus[\"ready\"] = 7] = \"ready\";\n    /**\n     * No request is in flight for this query, but one or more errors were detected.\n     */\n    NetworkStatus[NetworkStatus[\"error\"] = 8] = \"error\";\n    /**\n     * Indicates that a `@defer` query has received at least the first chunk of\n     * the result but the full result has not yet been fully streamed to the\n     * client.\n     */\n    NetworkStatus[NetworkStatus[\"streaming\"] = 9] = \"streaming\";\n})(NetworkStatus || (NetworkStatus = {}));\n//# sourceMappingURL=networkStatus.js.map"],"x_google_ignoreList":[0],"mappings":";AAGA,IAAW;CACV,SAAU,GAAe;AAyCtB,CAnCA,EAAc,EAAc,UAAa,KAAK,WAK9C,EAAc,EAAc,eAAkB,KAAK,gBAKnD,EAAc,EAAc,YAAe,KAAK,aAKhD,EAAc,EAAc,UAAa,KAAK,WAM9C,EAAc,EAAc,OAAU,KAAK,QAI3C,EAAc,EAAc,QAAW,KAAK,SAI5C,EAAc,EAAc,QAAW,KAAK,SAM5C,EAAc,EAAc,YAAe,KAAK;GACjD,AAAkB,MAAgB,EAAE,CAAE"}

package/dist/node_modules/@apollo/client/react/context/ApolloContext.js

@@ -0,0 +1,18 @@
+import { invariant as e } from "../../utilities/invariant/index.js";
+import * as t from "react";
+//#region node_modules/@apollo/client/react/context/ApolloContext.js
+var n = Symbol.for("__APOLLO_CONTEXT__");
+function r() {
+	e("createContext" in t, 37);
+	let r = t.createContext[n];
+	return r || (Object.defineProperty(t.createContext, n, {
+		value: r = t.createContext({}),
+		enumerable: !1,
+		writable: !1,
+		configurable: !0
+	}), r.displayName = "ApolloContext"), r;
+}
+//#endregion
+export { r as getApolloContext };
+
+//# sourceMappingURL=ApolloContext.js.map

package/dist/node_modules/@apollo/client/react/context/ApolloContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApolloContext.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/react/context/ApolloContext.js"],"sourcesContent":["import * as React from \"react\";\nimport { invariant } from \"@apollo/client/utilities/invariant\";\n// To make sure Apollo Client doesn't create more than one React context\n// (which can lead to problems like having an Apollo Client instance added\n// in one context, then attempting to retrieve it from another different\n// context), a single Apollo context is created and tracked in global state.\nconst contextKey = Symbol.for(\"__APOLLO_CONTEXT__\");\nexport function getApolloContext() {\n    invariant(\"createContext\" in React, 37);\n    let context = React.createContext[contextKey];\n    if (!context) {\n        Object.defineProperty(React.createContext, contextKey, {\n            value: (context = React.createContext({})),\n            enumerable: false,\n            writable: false,\n            configurable: true,\n        });\n        context.displayName = \"ApolloContext\";\n    }\n    return context;\n}\n//# sourceMappingURL=ApolloContext.js.map\n"],"x_google_ignoreList":[0],"mappings":";;;AAMA,IAAM,IAAa,OAAO,IAAI,qBAAqB;AACnD,SAAgB,IAAmB;AAC/B,GAAU,mBAAmB,GAAO,GAAG;CACvC,IAAI,IAAU,EAAM,cAAc;AAUlC,QATK,MACD,OAAO,eAAe,EAAM,eAAe,GAAY;EACnD,OAAQ,IAAU,EAAM,cAAc,EAAE,CAAC;EACzC,YAAY;EACZ,UAAU;EACV,cAAc;EACjB,CAAC,EACF,EAAQ,cAAc,kBAEnB"}

package/dist/node_modules/@apollo/client/react/hooks/constants.js

@@ -0,0 +1,6 @@
+//#region node_modules/@apollo/client/react/hooks/constants.js
+var e = Symbol.for("apollo.skipToken");
+//#endregion
+export { e as skipToken };
+
+//# sourceMappingURL=constants.js.map

package/dist/node_modules/@apollo/client/react/hooks/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/react/hooks/constants.js"],"sourcesContent":["export const skipToken = Symbol.for(\"apollo.skipToken\");\n//# sourceMappingURL=constants.js.map"],"x_google_ignoreList":[0],"mappings":";AAAA,IAAa,IAAY,OAAO,IAAI,mBAAmB"}

package/dist/node_modules/@apollo/client/react/hooks/internal/useDeepMemo.js

@@ -0,0 +1,14 @@
+import e from "../../../../../@wry/equality/lib/index.js";
+import * as t from "react";
+//#region node_modules/@apollo/client/react/hooks/internal/useDeepMemo.js
+function n(n, r) {
+	let i = t.useRef(void 0);
+	return (!i.current || !e(i.current.deps, r)) && (i.current = {
+		value: n(),
+		deps: r
+	}), i.current.value;
+}
+//#endregion
+export { n as useDeepMemo };
+
+//# sourceMappingURL=useDeepMemo.js.map

package/dist/node_modules/@apollo/client/react/hooks/internal/useDeepMemo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDeepMemo.js","names":[],"sources":["../../../../../../../node_modules/@apollo/client/react/hooks/internal/useDeepMemo.js"],"sourcesContent":["import { equal } from \"@wry/equality\";\nimport * as React from \"react\";\nexport function useDeepMemo(memoFn, deps) {\n    const ref = React.useRef(void 0);\n    // eslint-disable-next-line react-hooks/refs\n    if (!ref.current || !equal(ref.current.deps, deps)) {\n        ref.current = { value: memoFn(), deps };\n    }\n    // eslint-disable-next-line react-hooks/refs\n    return ref.current.value;\n}\n//# sourceMappingURL=useDeepMemo.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAEA,SAAgB,EAAY,GAAQ,GAAM;CACtC,IAAM,IAAM,EAAM,OAAO,KAAK,EAAE;AAMhC,SAJI,CAAC,EAAI,WAAW,CAAC,EAAM,EAAI,QAAQ,MAAM,EAAK,MAC9C,EAAI,UAAU;EAAE,OAAO,GAAQ;EAAE;EAAM,GAGpC,EAAI,QAAQ"}

package/dist/node_modules/@apollo/client/react/hooks/internal/useIsomorphicLayoutEffect.js

@@ -0,0 +1,8 @@
+import { canUseDOM as e } from "../../../utilities/internal/canUseDOM.js";
+import * as t from "react";
+//#region node_modules/@apollo/client/react/hooks/internal/useIsomorphicLayoutEffect.js
+var n = e ? t.useLayoutEffect : t.useEffect;
+//#endregion
+export { n as useIsomorphicLayoutEffect };
+
+//# sourceMappingURL=useIsomorphicLayoutEffect.js.map

package/dist/node_modules/@apollo/client/react/hooks/internal/useIsomorphicLayoutEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsomorphicLayoutEffect.js","names":[],"sources":["../../../../../../../node_modules/@apollo/client/react/hooks/internal/useIsomorphicLayoutEffect.js"],"sourcesContent":["import * as React from \"react\";\nimport { canUseDOM } from \"@apollo/client/utilities/internal\";\n// use canUseDOM here instead of canUseLayoutEffect because we want to be able\n// to use useLayoutEffect in our jest tests. useLayoutEffect seems to work fine\n// in useSuspenseQuery tests, but to honor the original comment about the\n// warnings for useSyncExternalStore implementation, canUseLayoutEffect is left\n// alone.\nexport const useIsomorphicLayoutEffect = canUseDOM ? React.useLayoutEffect : React.useEffect;\n//# sourceMappingURL=useIsomorphicLayoutEffect.js.map"],"x_google_ignoreList":[0],"mappings":";;;AAOA,IAAa,IAA4B,IAAY,EAAM,kBAAkB,EAAM"}

package/dist/node_modules/@apollo/client/react/hooks/internal/wrapHook.js

@@ -0,0 +1,16 @@
+import { getApolloContext as e } from "../../context/ApolloContext.js";
+import { wrapperSymbol as t } from "../../internal/index.js";
+import * as n from "react";
+//#region node_modules/@apollo/client/react/hooks/internal/wrapHook.js
+function r(r, i, a) {
+	let o = [a.queryManager, r.startsWith("use") ? n.useContext(e()) : void 0], s = i;
+	for (let e of o) {
+		let n = e?.[t]?.[r];
+		n && (s = n(s));
+	}
+	return s;
+}
+//#endregion
+export { r as wrapHook };
+
+//# sourceMappingURL=wrapHook.js.map

package/dist/node_modules/@apollo/client/react/hooks/internal/wrapHook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapHook.js","names":[],"sources":["../../../../../../../node_modules/@apollo/client/react/hooks/internal/wrapHook.js"],"sourcesContent":["import * as React from \"react\";\nimport { wrapperSymbol } from \"@apollo/client/react/internal\";\n// direct import to avoid circular dependency\nimport { getApolloContext } from \"../../context/ApolloContext.js\";\n/**\n* @internal\n*\n* Makes an Apollo Client hook \"wrappable\".\n* That means that the Apollo Client instance can expose a \"wrapper\" that will be\n* used to wrap the original hook implementation with additional logic.\n* @example\n*\n* ```tsx\n* // this is already done in `@apollo/client` for all wrappable hooks (see `WrappableHooks`)\n* // following this pattern\n* function useQuery() {\n*   return wrapHook('useQuery', _useQuery, options.client)(query, options);\n* }\n* function _useQuery(query, options) {\n*   // original implementation\n* }\n*\n* // this is what a library like `@apollo/client-react-streaming` would do\n* class ApolloClientWithStreaming extends ApolloClient {\n*   constructor(options) {\n*     super(options);\n*     this.queryManager[Symbol.for(\"apollo.hook.wrappers\")] = {\n*       useQuery: (original) => (query, options) => {\n*         console.log(\"useQuery was called with options\", options);\n*         return original(query, options);\n*       }\n*     }\n*   }\n* }\n*\n* // this will now log the options and then call the original `useQuery`\n* const client = new ApolloClientWithStreaming({ ... });\n* useQuery(query, { client });\n* ```\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport function wrapHook(hookName, useHook, clientOrObsQuery) {\n    // Priority-wise, the later entries in this array wrap\n    // previous entries and could prevent them (and in the end,\n    // even the original hook) from running\n    const wrapperSources = [\n        clientOrObsQuery[\"queryManager\"],\n        // if we are a hook (not `preloadQuery`), we are guaranteed to be inside of\n        // a React render and can use context\n        hookName.startsWith(\"use\") ?\n            // eslint-disable-next-line react-hooks/rules-of-hooks\n            React.useContext(getApolloContext())\n            : undefined,\n    ];\n    let wrapped = useHook;\n    for (const source of wrapperSources) {\n        const wrapper = source?.[wrapperSymbol]?.[hookName];\n        if (wrapper) {\n            wrapped = wrapper(wrapped);\n        }\n    }\n    return wrapped;\n}\n//# sourceMappingURL=wrapHook.js.map\n"],"x_google_ignoreList":[0],"mappings":";;;;AA0CA,SAAgB,EAAS,GAAU,GAAS,GAAkB;CAI1D,IAAM,IAAiB,CACnB,EAAiB,cAGjB,EAAS,WAAW,MAAM,GAEtB,EAAM,WAAW,GAAkB,CAAC,GAClC,KAAA,EACT,EACG,IAAU;AACd,MAAK,IAAM,KAAU,GAAgB;EACjC,IAAM,IAAU,IAAS,KAAiB;AAC1C,EAAI,MACA,IAAU,EAAQ,EAAQ;;AAGlC,QAAO"}

package/dist/node_modules/@apollo/client/react/hooks/useApolloClient.js

@@ -0,0 +1,12 @@
+import { invariant as e } from "../../utilities/invariant/index.js";
+import { getApolloContext as t } from "../context/ApolloContext.js";
+import * as n from "react";
+//#region node_modules/@apollo/client/react/hooks/useApolloClient.js
+function r(r) {
+	let i = n.useContext(t()), a = r || i.client;
+	return e(!!a, 28), a;
+}
+//#endregion
+export { r as useApolloClient };
+
+//# sourceMappingURL=useApolloClient.js.map

package/dist/node_modules/@apollo/client/react/hooks/useApolloClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useApolloClient.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/react/hooks/useApolloClient.js"],"sourcesContent":["import * as React from \"react\";\nimport { invariant } from \"@apollo/client/utilities/invariant\";\nimport { getApolloContext } from \"../context/ApolloContext.js\";\n/**\n * @example\n *\n * ```jsx\n * import { useApolloClient } from \"@apollo/client/react\";\n *\n * function SomeComponent() {\n *   const client = useApolloClient();\n *   // `client` is now set to the `ApolloClient` instance being used by the\n *   // application (that was configured using something like `ApolloProvider`)\n * }\n * ```\n *\n * @returns The `ApolloClient` instance being used by the application.\n */\nexport function useApolloClient(override) {\n    const context = React.useContext(getApolloContext());\n    const client = override || context.client;\n    invariant(!!client, 28);\n    return client;\n}\n//# sourceMappingURL=useApolloClient.js.map\n"],"x_google_ignoreList":[0],"mappings":";;;;AAkBA,SAAgB,EAAgB,GAAU;CACtC,IAAM,IAAU,EAAM,WAAW,GAAkB,CAAC,EAC9C,IAAS,KAAY,EAAQ;AAEnC,QADA,EAAU,CAAC,CAAC,GAAQ,GAAG,EAChB"}

package/dist/node_modules/@apollo/client/react/hooks/useMutation.js

@@ -0,0 +1,99 @@
+import { mergeOptions as e } from "../../utilities/internal/mergeOptions.js";
+import { preventUnhandledRejection as t } from "../../utilities/internal/preventUnhandledRejection.js";
+import n from "../../../../@wry/equality/lib/index.js";
+import { useApolloClient as r } from "./useApolloClient.js";
+import { useIsomorphicLayoutEffect as i } from "./internal/useIsomorphicLayoutEffect.js";
+import * as a from "react";
+//#region node_modules/@apollo/client/react/hooks/useMutation.js
+function o(o, c) {
+	let l = r(c?.client), [u, d] = a.useState(() => s(l)), f = a.useRef({
+		result: u,
+		mutationId: 0,
+		isMounted: !0,
+		client: l,
+		mutation: o,
+		options: c
+	});
+	i(() => {
+		Object.assign(f.current, {
+			client: l,
+			options: c,
+			mutation: o
+		});
+	});
+	let p = a.useCallback((r = {}) => {
+		let { options: i, mutation: a } = f.current, o = {
+			...i,
+			mutation: a
+		}, s = r.client || f.current.client, c = typeof r.context == "function" ? r.context(i?.context) : r.context;
+		!f.current.result.loading && f.current.isMounted && d(f.current.result = {
+			loading: !0,
+			error: void 0,
+			data: void 0,
+			called: !0,
+			client: s
+		});
+		let l = ++f.current.mutationId, u = e(o, {
+			...r,
+			context: c
+		});
+		return t(s.mutate(u).then((e) => {
+			let { data: t, error: i } = e, a = r.onError || f.current.options?.onError;
+			if (i && a && a(i, u), l === f.current.mutationId) {
+				let e = {
+					called: !0,
+					loading: !1,
+					data: t,
+					error: i,
+					client: s
+				};
+				f.current.isMounted && !n(f.current.result, e) && d(f.current.result = e);
+			}
+			let o = r.onCompleted || f.current.options?.onCompleted;
+			return i || o?.(e.data, u), e;
+		}, (e) => {
+			if (l === f.current.mutationId && f.current.isMounted) {
+				let t = {
+					loading: !1,
+					error: e,
+					data: void 0,
+					called: !0,
+					client: s
+				};
+				n(f.current.result, t) || d(f.current.result = t);
+			}
+			let t = r.onError || f.current.options?.onError;
+			throw t && t(e, u), e;
+		}));
+	}, []), m = a.useCallback(() => {
+		if (f.current.isMounted) {
+			let e = s(f.current.client);
+			Object.assign(f.current, {
+				mutationId: 0,
+				result: e
+			}), d(e);
+		}
+	}, []);
+	return a.useEffect(() => {
+		let e = f.current;
+		return e.isMounted = !0, () => {
+			e.isMounted = !1;
+		};
+	}, []), [p, {
+		reset: m,
+		...u
+	}];
+}
+function s(e) {
+	return {
+		data: void 0,
+		error: void 0,
+		called: !1,
+		loading: !1,
+		client: e
+	};
+}
+//#endregion
+export { o as useMutation };
+
+//# sourceMappingURL=useMutation.js.map

package/dist/node_modules/@apollo/client/react/hooks/useMutation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMutation.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/react/hooks/useMutation.js"],"sourcesContent":["import { equal } from \"@wry/equality\";\nimport * as React from \"react\";\nimport { mergeOptions, preventUnhandledRejection, } from \"@apollo/client/utilities/internal\";\nimport { useIsomorphicLayoutEffect } from \"./internal/useIsomorphicLayoutEffect.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\n/**\n * > Refer to the [Mutations](https://www.apollographql.com/docs/react/data/mutations/) section for a more in-depth overview of `useMutation`.\n *\n * @example\n *\n * ```jsx\n * import { gql, useMutation } from \"@apollo/client\";\n *\n * const ADD_TODO = gql`\n *   mutation AddTodo($type: String!) {\n *     addTodo(type: $type) {\n *       id\n *       type\n *     }\n *   }\n * `;\n *\n * function AddTodo() {\n *   let input;\n *   const [addTodo, { data }] = useMutation(ADD_TODO);\n *\n *   return (\n *     <div>\n *       <form\n *         onSubmit={(e) => {\n *           e.preventDefault();\n *           addTodo({ variables: { type: input.value } });\n *           input.value = \"\";\n *         }}\n *       >\n *         <input\n *           ref={(node) => {\n *             input = node;\n *           }}\n *         />\n *         <button type=\"submit\">Add Todo</button>\n *       </form>\n *     </div>\n *   );\n * }\n * ```\n *\n * @param mutation - A GraphQL mutation document parsed into an AST by `gql`.\n * @param options - Options to control how the mutation is executed.\n * @returns A tuple in the form of `[mutate, result]`\n */\nexport function useMutation(mutation, options) {\n    const client = useApolloClient(options?.client);\n    const [result, setResult] = React.useState(() => createInitialResult(client));\n    const ref = React.useRef({\n        result,\n        mutationId: 0,\n        isMounted: true,\n        client,\n        mutation,\n        options,\n    });\n    useIsomorphicLayoutEffect(() => {\n        Object.assign(ref.current, { client, options, mutation });\n    });\n    const execute = React.useCallback((executeOptions = {}) => {\n        const { options, mutation } = ref.current;\n        const baseOptions = { ...options, mutation };\n        const client = executeOptions.client || ref.current.client;\n        const context = typeof executeOptions.context === \"function\" ?\n            executeOptions.context(options?.context)\n            : executeOptions.context;\n        if (!ref.current.result.loading && ref.current.isMounted) {\n            setResult((ref.current.result = {\n                loading: true,\n                error: undefined,\n                data: undefined,\n                called: true,\n                client,\n            }));\n        }\n        const mutationId = ++ref.current.mutationId;\n        const clientOptions = mergeOptions(baseOptions, {\n            ...executeOptions,\n            context,\n        });\n        return preventUnhandledRejection(client\n            .mutate(clientOptions)\n            .then((response) => {\n            const { data, error } = response;\n            const onError = executeOptions.onError || ref.current.options?.onError;\n            if (error && onError) {\n                onError(error, clientOptions);\n            }\n            if (mutationId === ref.current.mutationId) {\n                const result = {\n                    called: true,\n                    loading: false,\n                    data,\n                    error,\n                    client,\n                };\n                if (ref.current.isMounted &&\n                    !equal(ref.current.result, result)) {\n                    setResult((ref.current.result = result));\n                }\n            }\n            const onCompleted = executeOptions.onCompleted || ref.current.options?.onCompleted;\n            if (!error) {\n                onCompleted?.(response.data, clientOptions);\n            }\n            return response;\n        }, (error) => {\n            if (mutationId === ref.current.mutationId &&\n                ref.current.isMounted) {\n                const result = {\n                    loading: false,\n                    error,\n                    data: void 0,\n                    called: true,\n                    client,\n                };\n                if (!equal(ref.current.result, result)) {\n                    setResult((ref.current.result = result));\n                }\n            }\n            const onError = executeOptions.onError || ref.current.options?.onError;\n            if (onError) {\n                onError(error, clientOptions);\n            }\n            throw error;\n        }));\n    }, []);\n    const reset = React.useCallback(() => {\n        if (ref.current.isMounted) {\n            const result = createInitialResult(ref.current.client);\n            Object.assign(ref.current, { mutationId: 0, result });\n            setResult(result);\n        }\n    }, []);\n    React.useEffect(() => {\n        const current = ref.current;\n        current.isMounted = true;\n        return () => {\n            current.isMounted = false;\n        };\n    }, []);\n    return [execute, { reset, ...result }];\n}\nfunction createInitialResult(client) {\n    return {\n        data: undefined,\n        error: undefined,\n        called: false,\n        loading: false,\n        client,\n    };\n}\n//# sourceMappingURL=useMutation.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;AAmDA,SAAgB,EAAY,GAAU,GAAS;CAC3C,IAAM,IAAS,EAAgB,GAAS,OAAO,EACzC,CAAC,GAAQ,KAAa,EAAM,eAAe,EAAoB,EAAO,CAAC,EACvE,IAAM,EAAM,OAAO;EACrB;EACA,YAAY;EACZ,WAAW;EACX;EACA;EACA;EACH,CAAC;AACF,SAAgC;AAC5B,SAAO,OAAO,EAAI,SAAS;GAAE;GAAQ;GAAS;GAAU,CAAC;GAC3D;CACF,IAAM,IAAU,EAAM,aAAa,IAAiB,EAAE,KAAK;EACvD,IAAM,EAAE,YAAS,gBAAa,EAAI,SAC5B,IAAc;GAAE,GAAG;GAAS;GAAU,EACtC,IAAS,EAAe,UAAU,EAAI,QAAQ,QAC9C,IAAU,OAAO,EAAe,WAAY,aAC9C,EAAe,QAAQ,GAAS,QAAQ,GACtC,EAAe;AACrB,EAAI,CAAC,EAAI,QAAQ,OAAO,WAAW,EAAI,QAAQ,aAC3C,EAAW,EAAI,QAAQ,SAAS;GAC5B,SAAS;GACT,OAAO,KAAA;GACP,MAAM,KAAA;GACN,QAAQ;GACR;GACH,CAAE;EAEP,IAAM,IAAa,EAAE,EAAI,QAAQ,YAC3B,IAAgB,EAAa,GAAa;GAC5C,GAAG;GACH;GACH,CAAC;AACF,SAAO,EAA0B,EAC5B,OAAO,EAAc,CACrB,MAAM,MAAa;GACpB,IAAM,EAAE,SAAM,aAAU,GAClB,IAAU,EAAe,WAAW,EAAI,QAAQ,SAAS;AAI/D,OAHI,KAAS,KACT,EAAQ,GAAO,EAAc,EAE7B,MAAe,EAAI,QAAQ,YAAY;IACvC,IAAM,IAAS;KACX,QAAQ;KACR,SAAS;KACT;KACA;KACA;KACH;AACD,IAAI,EAAI,QAAQ,aACZ,CAAC,EAAM,EAAI,QAAQ,QAAQ,EAAO,IAClC,EAAW,EAAI,QAAQ,SAAS,EAAQ;;GAGhD,IAAM,IAAc,EAAe,eAAe,EAAI,QAAQ,SAAS;AAIvE,UAHK,KACD,IAAc,EAAS,MAAM,EAAc,EAExC;MACP,MAAU;AACV,OAAI,MAAe,EAAI,QAAQ,cAC3B,EAAI,QAAQ,WAAW;IACvB,IAAM,IAAS;KACX,SAAS;KACT;KACA,MAAM,KAAK;KACX,QAAQ;KACR;KACH;AACD,IAAK,EAAM,EAAI,QAAQ,QAAQ,EAAO,IAClC,EAAW,EAAI,QAAQ,SAAS,EAAQ;;GAGhD,IAAM,IAAU,EAAe,WAAW,EAAI,QAAQ,SAAS;AAI/D,SAHI,KACA,EAAQ,GAAO,EAAc,EAE3B;IACR,CAAC;IACJ,EAAE,CAAC,EACA,IAAQ,EAAM,kBAAkB;AAClC,MAAI,EAAI,QAAQ,WAAW;GACvB,IAAM,IAAS,EAAoB,EAAI,QAAQ,OAAO;AAEtD,GADA,OAAO,OAAO,EAAI,SAAS;IAAE,YAAY;IAAG;IAAQ,CAAC,EACrD,EAAU,EAAO;;IAEtB,EAAE,CAAC;AAQN,QAPA,EAAM,gBAAgB;EAClB,IAAM,IAAU,EAAI;AAEpB,SADA,EAAQ,YAAY,UACP;AACT,KAAQ,YAAY;;IAEzB,EAAE,CAAC,EACC,CAAC,GAAS;EAAE;EAAO,GAAG;EAAQ,CAAC;;AAE1C,SAAS,EAAoB,GAAQ;AACjC,QAAO;EACH,MAAM,KAAA;EACN,OAAO,KAAA;EACP,QAAQ;EACR,SAAS;EACT;EACH"}

package/dist/node_modules/@apollo/client/react/hooks/useQuery.js

@@ -0,0 +1,129 @@
+import { asapScheduler as e } from "../../../../rxjs/dist/esm5/internal/scheduler/asap.js";
+import { observeOn as t } from "../../../../rxjs/dist/esm5/internal/operators/observeOn.js";
+import { maybeDeepFreeze as n } from "../../utilities/internal/maybeDeepFreeze.js";
+import { mergeOptions as r } from "../../utilities/internal/mergeOptions.js";
+import i from "../../../../@wry/equality/lib/index.js";
+import { variablesUnknownSymbol as a } from "../../utilities/internal/constants.js";
+import { NetworkStatus as o } from "../../core/networkStatus.js";
+import { useApolloClient as s } from "./useApolloClient.js";
+import { useDeepMemo as c } from "./internal/useDeepMemo.js";
+import { skipToken as l } from "./constants.js";
+import { wrapHook as u } from "./internal/wrapHook.js";
+import { useSyncExternalStore as d } from "./useSyncExternalStore.js";
+import * as f from "react";
+//#region node_modules/@apollo/client/react/hooks/useQuery.js
+var p = Symbol();
+function m(e, ...[t]) {
+	"use no memo";
+	return u("useQuery", h, s(typeof t == "object" ? t.client : void 0))(e, t);
+}
+function h(e, t = {}) {
+	let n = s(typeof t == "object" ? t.client : void 0), { ssr: r } = typeof t == "object" ? t : {}, i = _(e, t, n.defaultOptions.watchQuery);
+	function a(t) {
+		let r = n.watchQuery(i);
+		return {
+			client: n,
+			query: e,
+			observable: r,
+			resultData: {
+				current: r.getCurrentResult(),
+				previousData: t?.resultData.current.data,
+				variables: r.variables
+			}
+		};
+	}
+	let [o, c] = f.useState(a);
+	(n !== o.client || e !== o.query) && c(o = a(o));
+	let { observable: l, resultData: u } = o;
+	v(i, l), b(u, l, i);
+	let d = y(l, u, r), p = f.useMemo(() => ({
+		refetch: l.refetch.bind(l),
+		fetchMore: l.fetchMore.bind(l),
+		updateQuery: l.updateQuery.bind(l),
+		startPolling: l.startPolling.bind(l),
+		stopPolling: l.stopPolling.bind(l),
+		subscribeToMore: l.subscribeToMore.bind(l)
+	}), [l]), m = u.previousData;
+	return f.useMemo(() => {
+		let { partial: e, ...t } = d;
+		return {
+			...t,
+			client: n,
+			observable: l,
+			variables: l.variables,
+			previousData: m,
+			...p
+		};
+	}, [
+		d,
+		n,
+		l,
+		m,
+		p
+	]);
+}
+var g = Symbol();
+function _(e, t, n) {
+	return c(() => {
+		if (t === l) {
+			let t = {
+				...r(n, {
+					query: e,
+					fetchPolicy: "standby"
+				}),
+				[a]: !0
+			};
+			return t[g] = !0, t;
+		}
+		let i = r(n, {
+			...t,
+			query: e
+		});
+		return t.skip && (i.initialFetchPolicy = t.initialFetchPolicy || t.fetchPolicy, i.fetchPolicy = "standby"), i;
+	}, [
+		e,
+		t,
+		n
+	]);
+}
+function v(e, t) {
+	"use no memo";
+	e.fetchPolicy ||= t.options.initialFetchPolicy;
+}
+function y(n, r, a) {
+	"use no memo";
+	let o = n.options.fetchPolicy;
+	return d(f.useCallback((a) => {
+		let o = n.pipe(t(e)).subscribe((e) => {
+			let t = r.current;
+			i(t, e) && i(r.variables, n.variables) || (r.variables = n.variables, t.data && !i(t.data, e.data) && (r.previousData = t.data), r.current = e, a());
+		});
+		return () => {
+			setTimeout(() => o.unsubscribe());
+		};
+	}, [n, r]), () => r.current, () => o !== "standby" && a === !1 || o === "no-cache" ? m.ssrDisabledResult : r.current);
+}
+function b(e, t, n) {
+	"use no memo";
+	if (t[p] && !i(t[p], n)) {
+		t[p][g] && !n.initialFetchPolicy && (n.initialFetchPolicy = n.fetchPolicy), x(t[p], n) ? t.reobserve(n) : t.applyOptions(n);
+		let r = t.getCurrentResult();
+		i(r.data, e.current.data) || (e.previousData = e.current.data || e.previousData), e.current = r, e.variables = t.variables;
+	}
+	t[p] = n;
+}
+function x(e, t) {
+	return e.query !== t.query || !i(e.variables, t.variables) || e.fetchPolicy !== t.fetchPolicy && (t.fetchPolicy === "standby" || e.fetchPolicy === "standby");
+}
+m.ssrDisabledResult = n({
+	loading: !0,
+	data: void 0,
+	dataState: "empty",
+	error: void 0,
+	networkStatus: o.loading,
+	partial: !0
+});
+//#endregion
+export { m as useQuery };
+
+//# sourceMappingURL=useQuery.js.map

package/dist/node_modules/@apollo/client/react/hooks/useQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQuery.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/react/hooks/useQuery.js"],"sourcesContent":["/**\n * Function parameters in this file try to follow a common order for the sake of\n * readability and consistency. The order is as follows:\n *\n * resultData\n * observable\n * client\n * query\n * options\n * watchQueryOptions\n * makeWatchQueryOptions\n */\n/**  */\nimport { equal } from \"@wry/equality\";\nimport * as React from \"react\";\nimport { asapScheduler, observeOn } from \"rxjs\";\nimport { NetworkStatus } from \"@apollo/client\";\nimport { maybeDeepFreeze, mergeOptions, variablesUnknownSymbol, } from \"@apollo/client/utilities/internal\";\nimport { skipToken } from \"./constants.js\";\nimport { useDeepMemo, wrapHook } from \"./internal/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nimport { useSyncExternalStore } from \"./useSyncExternalStore.js\";\nconst lastWatchOptions = Symbol();\nexport function useQuery(query, ...[options]) {\n    \"use no memo\";\n    return wrapHook(\"useQuery\", useQuery_, useApolloClient(typeof options === \"object\" ? options.client : undefined))(query, options);\n}\nfunction useQuery_(query, options = {}) {\n    const client = useApolloClient(typeof options === \"object\" ? options.client : undefined);\n    const { ssr } = typeof options === \"object\" ? options : {};\n    const watchQueryOptions = useOptions(query, options, client.defaultOptions.watchQuery);\n    function createState(previous) {\n        const observable = client.watchQuery(watchQueryOptions);\n        return {\n            client,\n            query,\n            observable,\n            resultData: {\n                current: observable.getCurrentResult(),\n                // Reuse previousData from previous InternalState (if any) to provide\n                // continuity of previousData even if/when the query or client changes.\n                previousData: previous?.resultData.current.data,\n                variables: observable.variables,\n            },\n        };\n    }\n    let [state, setState] = React.useState(createState);\n    if (client !== state.client || query !== state.query) {\n        // If the client or query have changed, we need to create a new InternalState.\n        // This will trigger a re-render with the new state, but it will also continue\n        // to run the current render function to completion.\n        // Since we sometimes trigger some side-effects in the render function, we\n        // re-assign `state` to the new state to ensure that those side-effects are\n        // triggered with the new state.\n        setState((state = createState(state)));\n    }\n    const { observable, resultData } = state;\n    useInitialFetchPolicyIfNecessary(watchQueryOptions, observable);\n    useResubscribeIfNecessary(resultData, // might get mutated during render\n    observable, // might get mutated during render\n    watchQueryOptions);\n    const result = useResult(observable, resultData, ssr);\n    const obsQueryFields = React.useMemo(() => ({\n        refetch: observable.refetch.bind(observable),\n        fetchMore: observable.fetchMore.bind(observable),\n        updateQuery: observable.updateQuery.bind(observable),\n        startPolling: observable.startPolling.bind(observable),\n        stopPolling: observable.stopPolling.bind(observable),\n        subscribeToMore: observable.subscribeToMore.bind(observable),\n    }), [observable]);\n    const previousData = resultData.previousData;\n    return React.useMemo(() => {\n        const { partial, ...rest } = result;\n        return {\n            ...rest,\n            client,\n            observable,\n            variables: observable.variables,\n            previousData,\n            ...obsQueryFields,\n        };\n    }, [result, client, observable, previousData, obsQueryFields]);\n}\nconst fromSkipToken = Symbol();\nfunction useOptions(query, options, defaultOptions) {\n    return useDeepMemo(() => {\n        if (options === skipToken) {\n            const opts = {\n                ...mergeOptions(defaultOptions, {\n                    query,\n                    fetchPolicy: \"standby\",\n                }),\n                [variablesUnknownSymbol]: true,\n            };\n            opts[fromSkipToken] = true;\n            return opts;\n        }\n        const watchQueryOptions = mergeOptions(defaultOptions, { ...options, query });\n        if (options.skip) {\n            watchQueryOptions.initialFetchPolicy =\n                options.initialFetchPolicy || options.fetchPolicy;\n            watchQueryOptions.fetchPolicy = \"standby\";\n        }\n        return watchQueryOptions;\n    }, [query, options, defaultOptions]);\n}\nfunction useInitialFetchPolicyIfNecessary(watchQueryOptions, observable) {\n    \"use no memo\";\n    if (!watchQueryOptions.fetchPolicy) {\n        watchQueryOptions.fetchPolicy = observable.options.initialFetchPolicy;\n    }\n}\nfunction useResult(observable, resultData, ssr) {\n    \"use no memo\";\n    const fetchPolicy = observable.options.fetchPolicy;\n    return useSyncExternalStore(React.useCallback((handleStoreChange) => {\n        const subscription = observable\n            // We use the asapScheduler here to prevent issues with trying to\n            // update in the middle of a render. `reobserve` is kicked off in the\n            // middle of a render and because RxJS emits values synchronously,\n            // its possible for this `handleStoreChange` to be called in that same\n            // render. This allows the render to complete before trying to emit a\n            // new value.\n            .pipe(observeOn(asapScheduler))\n            .subscribe((result) => {\n            const previous = resultData.current;\n            if (\n            // Avoid rerendering if the result is the same\n            equal(previous, result) &&\n                // Force rerender if the value was emitted because variables\n                // changed, such as when calling `refetch(newVars)` which returns\n                // the same data when `notifyOnNetworkStatusChange` is `false`.\n                equal(resultData.variables, observable.variables)) {\n                return;\n            }\n            resultData.variables = observable.variables;\n            if (previous.data && !equal(previous.data, result.data)) {\n                resultData.previousData = previous.data;\n            }\n            resultData.current = result;\n            handleStoreChange();\n        });\n        // Do the \"unsubscribe\" with a short delay.\n        // This way, an existing subscription can be reused without an additional\n        // request if \"unsubscribe\"  and \"resubscribe\" to the same ObservableQuery\n        // happen in very fast succession.\n        return () => {\n            setTimeout(() => subscription.unsubscribe());\n        };\n    }, [observable, resultData]), () => resultData.current, () => ((fetchPolicy !== \"standby\" && ssr === false) ||\n        fetchPolicy === \"no-cache\") ?\n        useQuery.ssrDisabledResult\n        : resultData.current);\n}\n// this hook is not compatible with any rules of React, and there's no good way to rewrite it.\n// it should stay a separate hook that will not be optimized by the compiler\nfunction useResubscribeIfNecessary(\n/** this hook will mutate properties on `resultData` */\nresultData, \n/** this hook will mutate properties on `observable` */\nobservable, watchQueryOptions) {\n    \"use no memo\";\n    if (observable[lastWatchOptions] &&\n        !equal(observable[lastWatchOptions], watchQueryOptions)) {\n        // If skipToken was used to generate options, we won't know the correct\n        // initialFetchPolicy until the hook is rerendered with real options, so we\n        // set it the next time we get real options\n        if (observable[lastWatchOptions][fromSkipToken] &&\n            !watchQueryOptions.initialFetchPolicy) {\n            watchQueryOptions.initialFetchPolicy =\n                watchQueryOptions.fetchPolicy;\n        }\n        // Though it might be tempting to postpone this reobserve call to the\n        // useEffect block, we need getCurrentResult to return an appropriate\n        // loading:true result synchronously (later within the same call to\n        // useQuery). Since we already have this.observable here (not true for\n        // the very first call to useQuery), we are not initiating any new\n        // subscriptions, though it does feel less than ideal that reobserve\n        // (potentially) kicks off a network request (for example, when the\n        // variables have changed), which is technically a side-effect.\n        if (shouldReobserve(observable[lastWatchOptions], watchQueryOptions)) {\n            observable.reobserve(watchQueryOptions);\n        }\n        else {\n            observable.applyOptions(watchQueryOptions);\n        }\n        // Make sure getCurrentResult returns a fresh ApolloQueryResult<TData>,\n        // but save the current data as this.previousData, just like setResult\n        // usually does.\n        const result = observable.getCurrentResult();\n        if (!equal(result.data, resultData.current.data)) {\n            resultData.previousData = (resultData.current.data ||\n                resultData.previousData);\n        }\n        resultData.current = result;\n        resultData.variables = observable.variables;\n    }\n    observable[lastWatchOptions] = watchQueryOptions;\n}\nfunction shouldReobserve(previousOptions, options) {\n    return (previousOptions.query !== options.query ||\n        !equal(previousOptions.variables, options.variables) ||\n        (previousOptions.fetchPolicy !== options.fetchPolicy &&\n            (options.fetchPolicy === \"standby\" ||\n                previousOptions.fetchPolicy === \"standby\")));\n}\nuseQuery.ssrDisabledResult = maybeDeepFreeze({\n    loading: true,\n    data: void 0,\n    dataState: \"empty\",\n    error: void 0,\n    networkStatus: NetworkStatus.loading,\n    partial: true,\n});\n//# sourceMappingURL=useQuery.js.map"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;AAsBA,IAAM,IAAmB,QAAQ;AACjC,SAAgB,EAAS,GAAO,GAAG,CAAC,IAAU;AAC1C;AACA,QAAO,EAAS,YAAY,GAAW,EAAgB,OAAO,KAAY,WAAW,EAAQ,SAAS,KAAA,EAAU,CAAC,CAAC,GAAO,EAAQ;;AAErI,SAAS,EAAU,GAAO,IAAU,EAAE,EAAE;CACpC,IAAM,IAAS,EAAgB,OAAO,KAAY,WAAW,EAAQ,SAAS,KAAA,EAAU,EAClF,EAAE,WAAQ,OAAO,KAAY,WAAW,IAAU,EAAE,EACpD,IAAoB,EAAW,GAAO,GAAS,EAAO,eAAe,WAAW;CACtF,SAAS,EAAY,GAAU;EAC3B,IAAM,IAAa,EAAO,WAAW,EAAkB;AACvD,SAAO;GACH;GACA;GACA;GACA,YAAY;IACR,SAAS,EAAW,kBAAkB;IAGtC,cAAc,GAAU,WAAW,QAAQ;IAC3C,WAAW,EAAW;IACzB;GACJ;;CAEL,IAAI,CAAC,GAAO,KAAY,EAAM,SAAS,EAAY;AACnD,EAAI,MAAW,EAAM,UAAU,MAAU,EAAM,UAO3C,EAAU,IAAQ,EAAY,EAAM,CAAE;CAE1C,IAAM,EAAE,eAAY,kBAAe;AAEnC,CADA,EAAiC,GAAmB,EAAW,EAC/D,EAA0B,GAC1B,GACA,EAAkB;CAClB,IAAM,IAAS,EAAU,GAAY,GAAY,EAAI,EAC/C,IAAiB,EAAM,eAAe;EACxC,SAAS,EAAW,QAAQ,KAAK,EAAW;EAC5C,WAAW,EAAW,UAAU,KAAK,EAAW;EAChD,aAAa,EAAW,YAAY,KAAK,EAAW;EACpD,cAAc,EAAW,aAAa,KAAK,EAAW;EACtD,aAAa,EAAW,YAAY,KAAK,EAAW;EACpD,iBAAiB,EAAW,gBAAgB,KAAK,EAAW;EAC/D,GAAG,CAAC,EAAW,CAAC,EACX,IAAe,EAAW;AAChC,QAAO,EAAM,cAAc;EACvB,IAAM,EAAE,YAAS,GAAG,MAAS;AAC7B,SAAO;GACH,GAAG;GACH;GACA;GACA,WAAW,EAAW;GACtB;GACA,GAAG;GACN;IACF;EAAC;EAAQ;EAAQ;EAAY;EAAc;EAAe,CAAC;;AAElE,IAAM,IAAgB,QAAQ;AAC9B,SAAS,EAAW,GAAO,GAAS,GAAgB;AAChD,QAAO,QAAkB;AACrB,MAAI,MAAY,GAAW;GACvB,IAAM,IAAO;IACT,GAAG,EAAa,GAAgB;KAC5B;KACA,aAAa;KAChB,CAAC;KACD,IAAyB;IAC7B;AAED,UADA,EAAK,KAAiB,IACf;;EAEX,IAAM,IAAoB,EAAa,GAAgB;GAAE,GAAG;GAAS;GAAO,CAAC;AAM7E,SALI,EAAQ,SACR,EAAkB,qBACd,EAAQ,sBAAsB,EAAQ,aAC1C,EAAkB,cAAc,YAE7B;IACR;EAAC;EAAO;EAAS;EAAe,CAAC;;AAExC,SAAS,EAAiC,GAAmB,GAAY;AACrE;AACA,CACI,EAAkB,gBAAc,EAAW,QAAQ;;AAG3D,SAAS,EAAU,GAAY,GAAY,GAAK;AAC5C;CACA,IAAM,IAAc,EAAW,QAAQ;AACvC,QAAO,EAAqB,EAAM,aAAa,MAAsB;EACjE,IAAM,IAAe,EAOhB,KAAK,EAAU,EAAc,CAAC,CAC9B,WAAW,MAAW;GACvB,IAAM,IAAW,EAAW;AAG5B,KAAM,GAAU,EAAO,IAInB,EAAM,EAAW,WAAW,EAAW,UAAU,KAGrD,EAAW,YAAY,EAAW,WAC9B,EAAS,QAAQ,CAAC,EAAM,EAAS,MAAM,EAAO,KAAK,KACnD,EAAW,eAAe,EAAS,OAEvC,EAAW,UAAU,GACrB,GAAmB;IACrB;AAKF,eAAa;AACT,oBAAiB,EAAa,aAAa,CAAC;;IAEjD,CAAC,GAAY,EAAW,CAAC,QAAQ,EAAW,eAAiB,MAAgB,aAAa,MAAQ,MACjG,MAAgB,aAChB,EAAS,oBACP,EAAW,QAAQ;;AAI7B,SAAS,EAET,GAEA,GAAY,GAAmB;AAC3B;AACA,KAAI,EAAW,MACX,CAAC,EAAM,EAAW,IAAmB,EAAkB,EAAE;AAiBzD,EAbI,EAAW,GAAkB,MAC7B,CAAC,EAAkB,uBACnB,EAAkB,qBACd,EAAkB,cAUtB,EAAgB,EAAW,IAAmB,EAAkB,GAChE,EAAW,UAAU,EAAkB,GAGvC,EAAW,aAAa,EAAkB;EAK9C,IAAM,IAAS,EAAW,kBAAkB;AAM5C,EALK,EAAM,EAAO,MAAM,EAAW,QAAQ,KAAK,KAC5C,EAAW,eAAgB,EAAW,QAAQ,QAC1C,EAAW,eAEnB,EAAW,UAAU,GACrB,EAAW,YAAY,EAAW;;AAEtC,GAAW,KAAoB;;AAEnC,SAAS,EAAgB,GAAiB,GAAS;AAC/C,QAAQ,EAAgB,UAAU,EAAQ,SACtC,CAAC,EAAM,EAAgB,WAAW,EAAQ,UAAU,IACnD,EAAgB,gBAAgB,EAAQ,gBACpC,EAAQ,gBAAgB,aACrB,EAAgB,gBAAgB;;AAEhD,EAAS,oBAAoB,EAAgB;CACzC,SAAS;CACT,MAAM,KAAK;CACX,WAAW;CACX,OAAO,KAAK;CACZ,eAAe,EAAc;CAC7B,SAAS;CACZ,CAAC"}

package/dist/node_modules/@apollo/client/react/hooks/useSyncExternalStore.js

@@ -0,0 +1,37 @@
+import { maybe as e } from "../../utilities/internal/globals/maybe.js";
+import "../../utilities/invariant/index.js";
+import { canUseDOM as t } from "../../utilities/internal/canUseDOM.js";
+import * as n from "react";
+//#region node_modules/@apollo/client/react/hooks/useSyncExternalStore.js
+var r = n.useSyncExternalStore, i = e(() => navigator.product) == "ReactNative", a = e(() => navigator.userAgent.indexOf("jsdom") >= 0) || !1, o = (t || i) && !a, s = r || ((e, t, r) => {
+	let i = t(), [{ inst: a }, s] = n.useState({ inst: {
+		value: i,
+		getSnapshot: t
+	} });
+	return o ? n.useLayoutEffect(() => {
+		Object.assign(a, {
+			value: i,
+			getSnapshot: t
+		}), c(a) && s({ inst: a });
+	}, [
+		e,
+		i,
+		t
+	]) : Object.assign(a, {
+		value: i,
+		getSnapshot: t
+	}), n.useEffect(() => (c(a) && s({ inst: a }), e(function() {
+		c(a) && s({ inst: a });
+	})), [e]), i;
+});
+function c({ value: e, getSnapshot: t }) {
+	try {
+		return e !== t();
+	} catch {
+		return !0;
+	}
+}
+//#endregion
+export { s as useSyncExternalStore };
+
+//# sourceMappingURL=useSyncExternalStore.js.map

package/dist/node_modules/@apollo/client/react/hooks/useSyncExternalStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSyncExternalStore.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/react/hooks/useSyncExternalStore.js"],"sourcesContent":["import * as React from \"react\";\nimport { __DEV__ } from \"@apollo/client/utilities/environment\";\nimport { canUseDOM } from \"@apollo/client/utilities/internal\";\nimport { maybe } from \"@apollo/client/utilities/internal/globals\";\nimport { invariant } from \"@apollo/client/utilities/invariant\";\nlet didWarnUncachedGetSnapshot = false;\n// Prevent webpack from complaining about our feature detection of the\n// useSyncExternalStore property of the React namespace, which is expected not\n// to exist when using React 17 and earlier, and that's fine.\nconst uSESKey = \"useSyncExternalStore\";\nconst realHook = React[uSESKey];\nconst isReactNative = maybe(() => navigator.product) == \"ReactNative\";\nconst usingJSDOM = \n// Following advice found in this comment from @domenic (maintainer of jsdom):\n// https://github.com/jsdom/jsdom/issues/1537#issuecomment-229405327\n//\n// Since we control the version of Jest and jsdom used when running Apollo\n// Client tests, and that version is recent enough to include \" jsdom/x.y.z\"\n// at the end of the user agent string, I believe this case is all we need to\n// check. Testing for \"Node.js\" was recommended for backwards compatibility\n// with older version of jsdom, but we don't have that problem.\nmaybe(() => navigator.userAgent.indexOf(\"jsdom\") >= 0) || false;\n// Our tests should all continue to pass if we remove this !usingJSDOM\n// condition, thereby allowing useLayoutEffect when using jsdom. Unfortunately,\n// if we allow useLayoutEffect, then useSyncExternalStore generates many\n// warnings about useLayoutEffect doing nothing on the server. While these\n// warnings are harmless, this !usingJSDOM condition seems to be the best way to\n// prevent them (i.e. skipping useLayoutEffect when using jsdom).\nconst canUseLayoutEffect = (canUseDOM || isReactNative) && !usingJSDOM;\n// Adapted from https://www.npmjs.com/package/use-sync-external-store, with\n// Apollo Client deviations called out by \"// DEVIATION ...\" comments.\n// When/if React.useSyncExternalStore is defined, delegate fully to it.\nexport const useSyncExternalStore = realHook ||\n    ((subscribe, getSnapshot, getServerSnapshot) => {\n        // Read the current snapshot from the store on every render. Again, this\n        // breaks the rules of React, and only works here because of specific\n        // implementation details, most importantly that updates are\n        // always synchronous.\n        const value = getSnapshot();\n        if (\n        // DEVIATION: Using __DEV__\n        __DEV__ &&\n            !didWarnUncachedGetSnapshot &&\n            // DEVIATION: Not using Object.is because we know our snapshots will never\n            // be exotic primitive values like NaN, which is !== itself.\n            value !== getSnapshot()) {\n            didWarnUncachedGetSnapshot = true;\n            // DEVIATION: Using invariant.error instead of console.error directly.\n            invariant.error(34);\n        }\n        // Because updates are synchronous, we don't queue them. Instead we force a\n        // re-render whenever the subscribed state changes by updating an some\n        // arbitrary useState hook. Then, during render, we call getSnapshot to read\n        // the current value.\n        //\n        // Because we don't actually use the state returned by the useState hook, we\n        // can save a bit of memory by storing other stuff in that slot.\n        //\n        // To implement the early bailout, we need to track some things on a mutable\n        // object. Usually, we would put that in a useRef hook, but we can stash it in\n        // our useState hook instead.\n        //\n        // To force a re-render, we call forceUpdate({inst}). That works because the\n        // new object always fails an equality check.\n        const [{ inst }, forceUpdate] = React.useState({\n            inst: { value, getSnapshot },\n        });\n        // Track the latest getSnapshot function with a ref. This needs to be updated\n        // in the layout phase so we can access it during the tearing check that\n        // happens on subscribe.\n        if (canUseLayoutEffect) {\n            // DEVIATION: We avoid calling useLayoutEffect when !canUseLayoutEffect,\n            // which may seem like a conditional hook, but this code ends up behaving\n            // unconditionally (one way or the other) because canUseLayoutEffect is\n            // constant.\n            React.useLayoutEffect(() => {\n                Object.assign(inst, { value, getSnapshot });\n                // Whenever getSnapshot or subscribe changes, we need to check in the\n                // commit phase if there was an interleaved mutation. In concurrent mode\n                // this can happen all the time, but even in synchronous mode, an earlier\n                // effect may have mutated the store.\n                if (checkIfSnapshotChanged(inst)) {\n                    // Force a re-render.\n                    forceUpdate({ inst });\n                }\n                // React Hook React.useLayoutEffect has a missing dependency: 'inst'. Either include it or remove the dependency array.\n                // eslint-disable-next-line react-hooks/exhaustive-deps\n            }, [subscribe, value, getSnapshot]);\n        }\n        else {\n            Object.assign(inst, { value, getSnapshot });\n        }\n        React.useEffect(() => {\n            // Check for changes right before subscribing. Subsequent changes will be\n            // detected in the subscription handler.\n            if (checkIfSnapshotChanged(inst)) {\n                // Force a re-render.\n                forceUpdate({ inst });\n            }\n            // Subscribe to the store and return a clean-up function.\n            return subscribe(function handleStoreChange() {\n                // TODO: Because there is no cross-renderer API for batching updates, it's\n                // up to the consumer of this library to wrap their subscription event\n                // with unstable_batchedUpdates. Should we try to detect when this isn't\n                // the case and print a warning in development?\n                // The store changed. Check if the snapshot changed since the last time we\n                // read from the store.\n                if (checkIfSnapshotChanged(inst)) {\n                    // Force a re-render.\n                    forceUpdate({ inst });\n                }\n            });\n            // React Hook React.useEffect has a missing dependency: 'inst'. Either include it or remove the dependency array.\n            // eslint-disable-next-line react-hooks/exhaustive-deps\n        }, [subscribe]);\n        return value;\n    });\nfunction checkIfSnapshotChanged({ value, getSnapshot, }) {\n    try {\n        return value !== getSnapshot();\n    }\n    catch {\n        return true;\n    }\n}\n//# sourceMappingURL=useSyncExternalStore.js.map\n"],"x_google_ignoreList":[0],"mappings":";;;;;AAKA,IAKM,IAAW,EADD,sBAEV,IAAgB,QAAY,UAAU,QAAQ,IAAI,eAClD,IASN,QAAY,UAAU,UAAU,QAAQ,QAAQ,IAAI,EAAE,IAAI,IAOpD,KAAsB,KAAa,MAAkB,CAAC,GAI/C,IAAuB,OAC9B,GAAW,GAAa,MAAsB;CAK5C,IAAM,IAAQ,GAAa,EA0BrB,CAAC,EAAE,WAAQ,KAAe,EAAM,SAAS,EAC3C,MAAM;EAAE;EAAO;EAAa,EAC/B,CAAC;AAiDF,QA7CI,IAKA,EAAM,sBAAsB;AAMxB,EALA,OAAO,OAAO,GAAM;GAAE;GAAO;GAAa,CAAC,EAKvC,EAAuB,EAAK,IAE5B,EAAY,EAAE,SAAM,CAAC;IAI1B;EAAC;EAAW;EAAO;EAAY,CAAC,GAGnC,OAAO,OAAO,GAAM;EAAE;EAAO;EAAa,CAAC,EAE/C,EAAM,iBAGE,EAAuB,EAAK,IAE5B,EAAY,EAAE,SAAM,CAAC,EAGlB,EAAU,WAA6B;AAO1C,EAAI,EAAuB,EAAK,IAE5B,EAAY,EAAE,SAAM,CAAC;GAE3B,GAGH,CAAC,EAAU,CAAC,EACR;;AAEf,SAAS,EAAuB,EAAE,UAAO,kBAAgB;AACrD,KAAI;AACA,SAAO,MAAU,GAAa;SAE5B;AACF,SAAO"}

package/dist/node_modules/@apollo/client/react/internal/index.js

@@ -0,0 +1,6 @@
+//#region node_modules/@apollo/client/react/internal/index.js
+var e = Symbol.for("apollo.hook.wrappers");
+//#endregion
+export { e as wrapperSymbol };
+
+//# sourceMappingURL=index.js.map

package/dist/node_modules/@apollo/client/react/internal/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/react/internal/index.js"],"sourcesContent":["export { getSuspenseCache } from \"./cache/getSuspenseCache.js\";\nexport { assertWrappedQueryRef, getWrappedPromise, InternalQueryReference, unwrapQueryRef, updateWrappedQueryRef, wrapQueryRef, } from \"./cache/QueryReference.js\";\nexport const wrapperSymbol = Symbol.for(\"apollo.hook.wrappers\");\n//# sourceMappingURL=index.js.map"],"x_google_ignoreList":[0],"mappings":";AAEA,IAAa,IAAgB,OAAO,IAAI,uBAAuB"}

package/dist/node_modules/@apollo/client/utilities/internal/canUseDOM.js

@@ -0,0 +1,7 @@
+import { maybe as e } from "./globals/maybe.js";
+//#region node_modules/@apollo/client/utilities/internal/canUseDOM.js
+var t = typeof e(() => window.document.createElement) == "function";
+//#endregion
+export { t as canUseDOM };
+
+//# sourceMappingURL=canUseDOM.js.map

package/dist/node_modules/@apollo/client/utilities/internal/canUseDOM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canUseDOM.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/utilities/internal/canUseDOM.js"],"sourcesContent":["import { maybe } from \"@apollo/client/utilities/internal/globals\";\n/**\n* @internal\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport const canUseDOM = typeof maybe(() => window.document.createElement) === \"function\";\n//# sourceMappingURL=canUseDOM.js.map\n"],"x_google_ignoreList":[0],"mappings":";;AAMA,IAAa,IAAY,OAAO,QAAY,OAAO,SAAS,cAAc,IAAK"}

package/dist/node_modules/@apollo/client/utilities/internal/compact.js

@@ -0,0 +1,14 @@
+//#region node_modules/@apollo/client/utilities/internal/compact.js
+function e(...e) {
+	let t = {};
+	return e.forEach((e) => {
+		e && Reflect.ownKeys(e).forEach((n) => {
+			let r = e[n];
+			r !== void 0 && (t[n] = r);
+		});
+	}), t;
+}
+//#endregion
+export { e as compact };
+
+//# sourceMappingURL=compact.js.map

package/dist/node_modules/@apollo/client/utilities/internal/compact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/utilities/internal/compact.js"],"sourcesContent":["/**\n* Merges the provided objects shallowly and removes\n* all properties with an `undefined` value\n*\n* @internal\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport function compact(...objects) {\n    const result = {};\n    objects.forEach((obj) => {\n        if (!obj)\n            return;\n        Reflect.ownKeys(obj).forEach((key) => {\n            const value = obj[key];\n            if (value !== void 0) {\n                result[key] = value;\n            }\n        });\n    });\n    return result;\n}\n//# sourceMappingURL=compact.js.map\n"],"x_google_ignoreList":[0],"mappings":";AAQA,SAAgB,EAAQ,GAAG,GAAS;CAChC,IAAM,IAAS,EAAE;AAWjB,QAVA,EAAQ,SAAS,MAAQ;AAChB,OAEL,QAAQ,QAAQ,EAAI,CAAC,SAAS,MAAQ;GAClC,IAAM,IAAQ,EAAI;AAClB,GAAI,MAAU,KAAK,MACf,EAAO,KAAO;IAEpB;GACJ,EACK"}

package/dist/node_modules/@apollo/client/utilities/internal/constants.js

@@ -0,0 +1,6 @@
+//#region node_modules/@apollo/client/utilities/internal/constants.js
+var e = Symbol.for("apollo.observableQuery.variablesUnknown");
+//#endregion
+export { e as variablesUnknownSymbol };
+
+//# sourceMappingURL=constants.js.map

package/dist/node_modules/@apollo/client/utilities/internal/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/utilities/internal/constants.js"],"sourcesContent":["/**\n* @internal\n* Used to set `extensions` on the GraphQL result without exposing it\n* unnecessarily. Only use internally!\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport const extensionsSymbol = Symbol.for(\"apollo.result.extensions\");\n/**\n * For use in Cache implementations only.\n * This should not be used in userland code.\n */\nexport const streamInfoSymbol = Symbol.for(\"apollo.result.streamInfo\");\n/**\n* @internal\n* Used as key for `ApolloClient.WatchQueryOptions`.\n*\n* Meant for framework integrators only!\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport const variablesUnknownSymbol = Symbol.for(\"apollo.observableQuery.variablesUnknown\");\n//# sourceMappingURL=constants.js.map\n"],"x_google_ignoreList":[0],"mappings":";AAqBA,IAAa,IAAyB,OAAO,IAAI,0CAA0C"}

package/dist/node_modules/@apollo/client/utilities/internal/deepFreeze.js

@@ -0,0 +1,17 @@
+import { isNonNullObject as e } from "./isNonNullObject.js";
+//#region node_modules/@apollo/client/utilities/internal/deepFreeze.js
+function t(t) {
+	let r = new Set([t]);
+	return r.forEach((t) => {
+		e(t) && n(t) === t && Object.getOwnPropertyNames(t).forEach((n) => {
+			e(t[n]) && r.add(t[n]);
+		});
+	}), t;
+}
+function n(e) {
+	return e;
+}
+//#endregion
+export { t as deepFreeze };
+
+//# sourceMappingURL=deepFreeze.js.map

package/dist/node_modules/@apollo/client/utilities/internal/deepFreeze.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepFreeze.js","names":[],"sources":["../../../../../../node_modules/@apollo/client/utilities/internal/deepFreeze.js"],"sourcesContent":["import { __DEV__ } from \"@apollo/client/utilities/environment\";\nimport { isNonNullObject } from \"./isNonNullObject.js\";\n/**\n* @internal only to be imported in tests\n* \n* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.\n*/\nexport function deepFreeze(value) {\n    const workSet = new Set([value]);\n    workSet.forEach((obj) => {\n        if (isNonNullObject(obj) && shallowFreeze(obj) === obj) {\n            Object.getOwnPropertyNames(obj).forEach((name) => {\n                if (isNonNullObject(obj[name]))\n                    workSet.add(obj[name]);\n            });\n        }\n    });\n    return value;\n}\nfunction shallowFreeze(obj) {\n    if (__DEV__ && !Object.isFrozen(obj)) {\n        try {\n            Object.freeze(obj);\n        }\n        catch (e) {\n            // Some types like Uint8Array and Node.js's Buffer cannot be frozen, but\n            // they all throw a TypeError when you try, so we re-throw any exceptions\n            // that are not TypeErrors, since that would be unexpected.\n            if (e instanceof TypeError)\n                return null;\n            throw e;\n        }\n    }\n    return obj;\n}\n//# sourceMappingURL=deepFreeze.js.map\n"],"x_google_ignoreList":[0],"mappings":";;AAOA,SAAgB,EAAW,GAAO;CAC9B,IAAM,IAAU,IAAI,IAAI,CAAC,EAAM,CAAC;AAShC,QARA,EAAQ,SAAS,MAAQ;AACrB,EAAI,EAAgB,EAAI,IAAI,EAAc,EAAI,KAAK,KAC/C,OAAO,oBAAoB,EAAI,CAAC,SAAS,MAAS;AAC9C,GAAI,EAAgB,EAAI,GAAM,IAC1B,EAAQ,IAAI,EAAI,GAAM;IAC5B;GAER,EACK;;AAEX,SAAS,EAAc,GAAK;AAcxB,QAAO"}

package/dist/node_modules/@apollo/client/utilities/internal/globals/global.js

@@ -0,0 +1,9 @@
+import { maybe as e } from "./maybe.js";
+//#region node_modules/@apollo/client/utilities/internal/globals/global.js
+var t = e(() => globalThis) || e(() => window) || e(() => self) || e(() => global) || e(function() {
+	return e.constructor("return this")();
+});
+//#endregion
+export { t as default };
+
+//# sourceMappingURL=global.js.map

package/dist/node_modules/@apollo/client/utilities/internal/globals/global.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.js","names":[],"sources":["../../../../../../../node_modules/@apollo/client/utilities/internal/globals/global.js"],"sourcesContent":["import { maybe } from \"./maybe.js\";\nexport default (// We don't expect the Function constructor ever to be invoked at runtime, as\n// long as at least one of globalThis, window, self, or global is defined, so\n// we are under no obligation to make it easy for static analysis tools to\n// detect syntactic usage of the Function constructor. If you think you can\nmaybe(() => globalThis) ||\n    maybe(() => window) ||\n    maybe(() => self) ||\n    maybe(() => global) || // improve your static analysis to detect this obfuscation, think again. This\n// is an arms race you cannot win, at least not in JavaScript.\nmaybe(function () {\n    return maybe.constructor(\"return this\")();\n}));\n//# sourceMappingURL=global.js.map\n"],"x_google_ignoreList":[0],"mappings":";;AACA,IAAA,IAIA,QAAY,WAAW,IACnB,QAAY,OAAO,IACnB,QAAY,KAAK,IACjB,QAAY,OAAO,IAEvB,EAAM,WAAY;AACd,QAAO,EAAM,YAAY,cAAc,EAAE;EAC3C"}

package/dist/node_modules/@apollo/client/utilities/internal/globals/maybe.js

@@ -0,0 +1,10 @@
+//#region node_modules/@apollo/client/utilities/internal/globals/maybe.js
+function e(e) {
+	try {
+		return e();
+	} catch {}
+}
+//#endregion
+export { e as maybe };
+
+//# sourceMappingURL=maybe.js.map

package/dist/node_modules/@apollo/client/utilities/internal/globals/maybe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maybe.js","names":[],"sources":["../../../../../../../node_modules/@apollo/client/utilities/internal/globals/maybe.js"],"sourcesContent":["export function maybe(thunk) {\n    try {\n        return thunk();\n    }\n    catch { }\n}\n//# sourceMappingURL=maybe.js.map"],"x_google_ignoreList":[0],"mappings":";AAAA,SAAgB,EAAM,GAAO;AACzB,KAAI;AACA,SAAO,GAAO;SAEZ"}

package/dist/node_modules/@apollo/client/utilities/internal/isNonNullObject.js

@@ -0,0 +1,8 @@
+//#region node_modules/@apollo/client/utilities/internal/isNonNullObject.js
+function e(e) {
+	return typeof e == "object" && !!e;
+}
+//#endregion
+export { e as isNonNullObject };
+
+//# sourceMappingURL=isNonNullObject.js.map