3383 lines
102 KiB
Plaintext
3383 lines
102 KiB
Plaintext
import {
|
|
__assign,
|
|
__extends,
|
|
__rest,
|
|
__spreadArray,
|
|
global_default,
|
|
invariant,
|
|
maybe,
|
|
newInvariantError
|
|
} from "/_nuxt/node_modules/.cache/vite/client/deps/chunk-VGPSIDND.js?v=e4f18c29";
|
|
|
|
// node_modules/@apollo/client/utilities/graphql/directives.js
|
|
import { visit, BREAK, Kind } from "/_nuxt/node_modules/graphql/index.mjs?v=e4f18c29";
|
|
function shouldInclude(_a, variables) {
|
|
var directives = _a.directives;
|
|
if (!directives || !directives.length) {
|
|
return true;
|
|
}
|
|
return getInclusionDirectives(directives).every(function(_a2) {
|
|
var directive = _a2.directive, ifArgument = _a2.ifArgument;
|
|
var evaledValue = false;
|
|
if (ifArgument.value.kind === "Variable") {
|
|
evaledValue = variables && variables[ifArgument.value.name.value];
|
|
invariant(evaledValue !== void 0, 78, directive.name.value);
|
|
} else {
|
|
evaledValue = ifArgument.value.value;
|
|
}
|
|
return directive.name.value === "skip" ? !evaledValue : evaledValue;
|
|
});
|
|
}
|
|
function getDirectiveNames(root2) {
|
|
var names = [];
|
|
visit(root2, {
|
|
Directive: function(node) {
|
|
names.push(node.name.value);
|
|
}
|
|
});
|
|
return names;
|
|
}
|
|
var hasAnyDirectives = function(names, root2) {
|
|
return hasDirectives(names, root2, false);
|
|
};
|
|
var hasAllDirectives = function(names, root2) {
|
|
return hasDirectives(names, root2, true);
|
|
};
|
|
function hasDirectives(names, root2, all) {
|
|
var nameSet = new Set(names);
|
|
var uniqueCount = nameSet.size;
|
|
visit(root2, {
|
|
Directive: function(node) {
|
|
if (nameSet.delete(node.name.value) && (!all || !nameSet.size)) {
|
|
return BREAK;
|
|
}
|
|
}
|
|
});
|
|
return all ? !nameSet.size : nameSet.size < uniqueCount;
|
|
}
|
|
function hasClientExports(document) {
|
|
return document && hasDirectives(["client", "export"], document, true);
|
|
}
|
|
function isInclusionDirective(_a) {
|
|
var value = _a.name.value;
|
|
return value === "skip" || value === "include";
|
|
}
|
|
function getInclusionDirectives(directives) {
|
|
var result2 = [];
|
|
if (directives && directives.length) {
|
|
directives.forEach(function(directive) {
|
|
if (!isInclusionDirective(directive))
|
|
return;
|
|
var directiveArguments = directive.arguments;
|
|
var directiveName = directive.name.value;
|
|
invariant(directiveArguments && directiveArguments.length === 1, 79, directiveName);
|
|
var ifArgument = directiveArguments[0];
|
|
invariant(ifArgument.name && ifArgument.name.value === "if", 80, directiveName);
|
|
var ifValue = ifArgument.value;
|
|
invariant(ifValue && (ifValue.kind === "Variable" || ifValue.kind === "BooleanValue"), 81, directiveName);
|
|
result2.push({ directive, ifArgument });
|
|
});
|
|
}
|
|
return result2;
|
|
}
|
|
function getFragmentMaskMode(fragment) {
|
|
var _a, _b;
|
|
var directive = (_a = fragment.directives) === null || _a === void 0 ? void 0 : _a.find(function(_a2) {
|
|
var name = _a2.name;
|
|
return name.value === "unmask";
|
|
});
|
|
if (!directive) {
|
|
return "mask";
|
|
}
|
|
var modeArg = (_b = directive.arguments) === null || _b === void 0 ? void 0 : _b.find(function(_a2) {
|
|
var name = _a2.name;
|
|
return name.value === "mode";
|
|
});
|
|
if (globalThis.__DEV__ !== false) {
|
|
if (modeArg) {
|
|
if (modeArg.value.kind === Kind.VARIABLE) {
|
|
globalThis.__DEV__ !== false && invariant.warn(82);
|
|
} else if (modeArg.value.kind !== Kind.STRING) {
|
|
globalThis.__DEV__ !== false && invariant.warn(83);
|
|
} else if (modeArg.value.value !== "migrate") {
|
|
globalThis.__DEV__ !== false && invariant.warn(84, modeArg.value.value);
|
|
}
|
|
}
|
|
}
|
|
if (modeArg && "value" in modeArg.value && modeArg.value.value === "migrate") {
|
|
return "migrate";
|
|
}
|
|
return "unmask";
|
|
}
|
|
|
|
// node_modules/@wry/trie/lib/index.js
|
|
var defaultMakeData = () => /* @__PURE__ */ Object.create(null);
|
|
var { forEach, slice } = Array.prototype;
|
|
var { hasOwnProperty } = Object.prototype;
|
|
var Trie = class _Trie {
|
|
constructor(weakness = true, makeData = defaultMakeData) {
|
|
this.weakness = weakness;
|
|
this.makeData = makeData;
|
|
}
|
|
lookup() {
|
|
return this.lookupArray(arguments);
|
|
}
|
|
lookupArray(array) {
|
|
let node = this;
|
|
forEach.call(array, (key) => node = node.getChildTrie(key));
|
|
return hasOwnProperty.call(node, "data") ? node.data : node.data = this.makeData(slice.call(array));
|
|
}
|
|
peek() {
|
|
return this.peekArray(arguments);
|
|
}
|
|
peekArray(array) {
|
|
let node = this;
|
|
for (let i = 0, len = array.length; node && i < len; ++i) {
|
|
const map = node.mapFor(array[i], false);
|
|
node = map && map.get(array[i]);
|
|
}
|
|
return node && node.data;
|
|
}
|
|
remove() {
|
|
return this.removeArray(arguments);
|
|
}
|
|
removeArray(array) {
|
|
let data;
|
|
if (array.length) {
|
|
const head = array[0];
|
|
const map = this.mapFor(head, false);
|
|
const child = map && map.get(head);
|
|
if (child) {
|
|
data = child.removeArray(slice.call(array, 1));
|
|
if (!child.data && !child.weak && !(child.strong && child.strong.size)) {
|
|
map.delete(head);
|
|
}
|
|
}
|
|
} else {
|
|
data = this.data;
|
|
delete this.data;
|
|
}
|
|
return data;
|
|
}
|
|
getChildTrie(key) {
|
|
const map = this.mapFor(key, true);
|
|
let child = map.get(key);
|
|
if (!child)
|
|
map.set(key, child = new _Trie(this.weakness, this.makeData));
|
|
return child;
|
|
}
|
|
mapFor(key, create) {
|
|
return this.weakness && isObjRef(key) ? this.weak || (create ? this.weak = /* @__PURE__ */ new WeakMap() : void 0) : this.strong || (create ? this.strong = /* @__PURE__ */ new Map() : void 0);
|
|
}
|
|
};
|
|
function isObjRef(value) {
|
|
switch (typeof value) {
|
|
case "object":
|
|
if (value === null)
|
|
break;
|
|
// Fall through to return true...
|
|
case "function":
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/common/canUse.js
|
|
var isReactNative = maybe(function() {
|
|
return navigator.product;
|
|
}) == "ReactNative";
|
|
var canUseWeakMap = typeof WeakMap === "function" && !(isReactNative && !global.HermesInternal);
|
|
var canUseWeakSet = typeof WeakSet === "function";
|
|
var canUseSymbol = typeof Symbol === "function" && typeof Symbol.for === "function";
|
|
var canUseAsyncIteratorSymbol = canUseSymbol && Symbol.asyncIterator;
|
|
var canUseDOM = typeof maybe(function() {
|
|
return window.document.createElement;
|
|
}) === "function";
|
|
var usingJSDOM = (
|
|
// Following advice found in this comment from @domenic (maintainer of jsdom):
|
|
// https://github.com/jsdom/jsdom/issues/1537#issuecomment-229405327
|
|
//
|
|
// Since we control the version of Jest and jsdom used when running Apollo
|
|
// Client tests, and that version is recent enought to include " jsdom/x.y.z"
|
|
// at the end of the user agent string, I believe this case is all we need to
|
|
// check. Testing for "Node.js" was recommended for backwards compatibility
|
|
// with older version of jsdom, but we don't have that problem.
|
|
maybe(function() {
|
|
return navigator.userAgent.indexOf("jsdom") >= 0;
|
|
}) || false
|
|
);
|
|
var canUseLayoutEffect = (canUseDOM || isReactNative) && !usingJSDOM;
|
|
|
|
// node_modules/@apollo/client/utilities/common/objects.js
|
|
function isNonNullObject(obj) {
|
|
return obj !== null && typeof obj === "object";
|
|
}
|
|
function isPlainObject(obj) {
|
|
return obj !== null && typeof obj === "object" && (Object.getPrototypeOf(obj) === Object.prototype || Object.getPrototypeOf(obj) === null);
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/graphql/fragments.js
|
|
import { BREAK as BREAK2, visit as visit2 } from "/_nuxt/node_modules/graphql/index.mjs?v=e4f18c29";
|
|
function getFragmentQueryDocument(document, fragmentName) {
|
|
var actualFragmentName = fragmentName;
|
|
var fragments = [];
|
|
document.definitions.forEach(function(definition) {
|
|
if (definition.kind === "OperationDefinition") {
|
|
throw newInvariantError(
|
|
85,
|
|
definition.operation,
|
|
definition.name ? " named '".concat(definition.name.value, "'") : ""
|
|
);
|
|
}
|
|
if (definition.kind === "FragmentDefinition") {
|
|
fragments.push(definition);
|
|
}
|
|
});
|
|
if (typeof actualFragmentName === "undefined") {
|
|
invariant(fragments.length === 1, 86, fragments.length);
|
|
actualFragmentName = fragments[0].name.value;
|
|
}
|
|
var query = __assign(__assign({}, document), { definitions: __spreadArray([
|
|
{
|
|
kind: "OperationDefinition",
|
|
// OperationTypeNode is an enum
|
|
operation: "query",
|
|
selectionSet: {
|
|
kind: "SelectionSet",
|
|
selections: [
|
|
{
|
|
kind: "FragmentSpread",
|
|
name: {
|
|
kind: "Name",
|
|
value: actualFragmentName
|
|
}
|
|
}
|
|
]
|
|
}
|
|
}
|
|
], document.definitions, true) });
|
|
return query;
|
|
}
|
|
function createFragmentMap(fragments) {
|
|
if (fragments === void 0) {
|
|
fragments = [];
|
|
}
|
|
var symTable = {};
|
|
fragments.forEach(function(fragment) {
|
|
symTable[fragment.name.value] = fragment;
|
|
});
|
|
return symTable;
|
|
}
|
|
function getFragmentFromSelection(selection, fragmentMap) {
|
|
switch (selection.kind) {
|
|
case "InlineFragment":
|
|
return selection;
|
|
case "FragmentSpread": {
|
|
var fragmentName = selection.name.value;
|
|
if (typeof fragmentMap === "function") {
|
|
return fragmentMap(fragmentName);
|
|
}
|
|
var fragment = fragmentMap && fragmentMap[fragmentName];
|
|
invariant(fragment, 87, fragmentName);
|
|
return fragment || null;
|
|
}
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
function isFullyUnmaskedOperation(document) {
|
|
var isUnmasked = true;
|
|
visit2(document, {
|
|
FragmentSpread: function(node) {
|
|
isUnmasked = !!node.directives && node.directives.some(function(directive) {
|
|
return directive.name.value === "unmask";
|
|
});
|
|
if (!isUnmasked) {
|
|
return BREAK2;
|
|
}
|
|
}
|
|
});
|
|
return isUnmasked;
|
|
}
|
|
|
|
// node_modules/@wry/caches/lib/strong.js
|
|
function defaultDispose() {
|
|
}
|
|
var StrongCache = class {
|
|
constructor(max = Infinity, dispose = defaultDispose) {
|
|
this.max = max;
|
|
this.dispose = dispose;
|
|
this.map = /* @__PURE__ */ new Map();
|
|
this.newest = null;
|
|
this.oldest = null;
|
|
}
|
|
has(key) {
|
|
return this.map.has(key);
|
|
}
|
|
get(key) {
|
|
const node = this.getNode(key);
|
|
return node && node.value;
|
|
}
|
|
get size() {
|
|
return this.map.size;
|
|
}
|
|
getNode(key) {
|
|
const node = this.map.get(key);
|
|
if (node && node !== this.newest) {
|
|
const { older, newer } = node;
|
|
if (newer) {
|
|
newer.older = older;
|
|
}
|
|
if (older) {
|
|
older.newer = newer;
|
|
}
|
|
node.older = this.newest;
|
|
node.older.newer = node;
|
|
node.newer = null;
|
|
this.newest = node;
|
|
if (node === this.oldest) {
|
|
this.oldest = newer;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
set(key, value) {
|
|
let node = this.getNode(key);
|
|
if (node) {
|
|
return node.value = value;
|
|
}
|
|
node = {
|
|
key,
|
|
value,
|
|
newer: null,
|
|
older: this.newest
|
|
};
|
|
if (this.newest) {
|
|
this.newest.newer = node;
|
|
}
|
|
this.newest = node;
|
|
this.oldest = this.oldest || node;
|
|
this.map.set(key, node);
|
|
return node.value;
|
|
}
|
|
clean() {
|
|
while (this.oldest && this.map.size > this.max) {
|
|
this.delete(this.oldest.key);
|
|
}
|
|
}
|
|
delete(key) {
|
|
const node = this.map.get(key);
|
|
if (node) {
|
|
if (node === this.newest) {
|
|
this.newest = node.older;
|
|
}
|
|
if (node === this.oldest) {
|
|
this.oldest = node.newer;
|
|
}
|
|
if (node.newer) {
|
|
node.newer.older = node.older;
|
|
}
|
|
if (node.older) {
|
|
node.older.newer = node.newer;
|
|
}
|
|
this.map.delete(key);
|
|
this.dispose(node.value, key);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// node_modules/@wry/caches/lib/weak.js
|
|
function noop() {
|
|
}
|
|
var defaultDispose2 = noop;
|
|
var _WeakRef = typeof WeakRef !== "undefined" ? WeakRef : function(value) {
|
|
return { deref: () => value };
|
|
};
|
|
var _WeakMap = typeof WeakMap !== "undefined" ? WeakMap : Map;
|
|
var _FinalizationRegistry = typeof FinalizationRegistry !== "undefined" ? FinalizationRegistry : function() {
|
|
return {
|
|
register: noop,
|
|
unregister: noop
|
|
};
|
|
};
|
|
var finalizationBatchSize = 10024;
|
|
var WeakCache = class {
|
|
constructor(max = Infinity, dispose = defaultDispose2) {
|
|
this.max = max;
|
|
this.dispose = dispose;
|
|
this.map = new _WeakMap();
|
|
this.newest = null;
|
|
this.oldest = null;
|
|
this.unfinalizedNodes = /* @__PURE__ */ new Set();
|
|
this.finalizationScheduled = false;
|
|
this.size = 0;
|
|
this.finalize = () => {
|
|
const iterator = this.unfinalizedNodes.values();
|
|
for (let i = 0; i < finalizationBatchSize; i++) {
|
|
const node = iterator.next().value;
|
|
if (!node)
|
|
break;
|
|
this.unfinalizedNodes.delete(node);
|
|
const key = node.key;
|
|
delete node.key;
|
|
node.keyRef = new _WeakRef(key);
|
|
this.registry.register(key, node, node);
|
|
}
|
|
if (this.unfinalizedNodes.size > 0) {
|
|
queueMicrotask(this.finalize);
|
|
} else {
|
|
this.finalizationScheduled = false;
|
|
}
|
|
};
|
|
this.registry = new _FinalizationRegistry(this.deleteNode.bind(this));
|
|
}
|
|
has(key) {
|
|
return this.map.has(key);
|
|
}
|
|
get(key) {
|
|
const node = this.getNode(key);
|
|
return node && node.value;
|
|
}
|
|
getNode(key) {
|
|
const node = this.map.get(key);
|
|
if (node && node !== this.newest) {
|
|
const { older, newer } = node;
|
|
if (newer) {
|
|
newer.older = older;
|
|
}
|
|
if (older) {
|
|
older.newer = newer;
|
|
}
|
|
node.older = this.newest;
|
|
node.older.newer = node;
|
|
node.newer = null;
|
|
this.newest = node;
|
|
if (node === this.oldest) {
|
|
this.oldest = newer;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
set(key, value) {
|
|
let node = this.getNode(key);
|
|
if (node) {
|
|
return node.value = value;
|
|
}
|
|
node = {
|
|
key,
|
|
value,
|
|
newer: null,
|
|
older: this.newest
|
|
};
|
|
if (this.newest) {
|
|
this.newest.newer = node;
|
|
}
|
|
this.newest = node;
|
|
this.oldest = this.oldest || node;
|
|
this.scheduleFinalization(node);
|
|
this.map.set(key, node);
|
|
this.size++;
|
|
return node.value;
|
|
}
|
|
clean() {
|
|
while (this.oldest && this.size > this.max) {
|
|
this.deleteNode(this.oldest);
|
|
}
|
|
}
|
|
deleteNode(node) {
|
|
if (node === this.newest) {
|
|
this.newest = node.older;
|
|
}
|
|
if (node === this.oldest) {
|
|
this.oldest = node.newer;
|
|
}
|
|
if (node.newer) {
|
|
node.newer.older = node.older;
|
|
}
|
|
if (node.older) {
|
|
node.older.newer = node.newer;
|
|
}
|
|
this.size--;
|
|
const key = node.key || node.keyRef && node.keyRef.deref();
|
|
this.dispose(node.value, key);
|
|
if (!node.keyRef) {
|
|
this.unfinalizedNodes.delete(node);
|
|
} else {
|
|
this.registry.unregister(node);
|
|
}
|
|
if (key)
|
|
this.map.delete(key);
|
|
}
|
|
delete(key) {
|
|
const node = this.map.get(key);
|
|
if (node) {
|
|
this.deleteNode(node);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
scheduleFinalization(node) {
|
|
this.unfinalizedNodes.add(node);
|
|
if (!this.finalizationScheduled) {
|
|
this.finalizationScheduled = true;
|
|
queueMicrotask(this.finalize);
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/@apollo/client/utilities/caching/caches.js
|
|
var scheduledCleanup = /* @__PURE__ */ new WeakSet();
|
|
function schedule(cache) {
|
|
if (cache.size <= (cache.max || -1)) {
|
|
return;
|
|
}
|
|
if (!scheduledCleanup.has(cache)) {
|
|
scheduledCleanup.add(cache);
|
|
setTimeout(function() {
|
|
cache.clean();
|
|
scheduledCleanup.delete(cache);
|
|
}, 100);
|
|
}
|
|
}
|
|
var AutoCleanedWeakCache = function(max, dispose) {
|
|
var cache = new WeakCache(max, dispose);
|
|
cache.set = function(key, value) {
|
|
var ret = WeakCache.prototype.set.call(this, key, value);
|
|
schedule(this);
|
|
return ret;
|
|
};
|
|
return cache;
|
|
};
|
|
var AutoCleanedStrongCache = function(max, dispose) {
|
|
var cache = new StrongCache(max, dispose);
|
|
cache.set = function(key, value) {
|
|
var ret = StrongCache.prototype.set.call(this, key, value);
|
|
schedule(this);
|
|
return ret;
|
|
};
|
|
return cache;
|
|
};
|
|
|
|
// node_modules/@apollo/client/utilities/caching/sizes.js
|
|
var cacheSizeSymbol = Symbol.for("apollo.cacheSize");
|
|
var cacheSizes = __assign({}, global_default[cacheSizeSymbol]);
|
|
|
|
// node_modules/@apollo/client/utilities/caching/getMemoryInternals.js
|
|
var globalCaches = {};
|
|
function registerGlobalCache(name, getSize) {
|
|
globalCaches[name] = getSize;
|
|
}
|
|
var getApolloClientMemoryInternals = globalThis.__DEV__ !== false ? _getApolloClientMemoryInternals : void 0;
|
|
var getInMemoryCacheMemoryInternals = globalThis.__DEV__ !== false ? _getInMemoryCacheMemoryInternals : void 0;
|
|
var getApolloCacheMemoryInternals = globalThis.__DEV__ !== false ? _getApolloCacheMemoryInternals : void 0;
|
|
function getCurrentCacheSizes() {
|
|
var defaults = {
|
|
parser: 1e3,
|
|
canonicalStringify: 1e3,
|
|
print: 2e3,
|
|
"documentTransform.cache": 2e3,
|
|
"queryManager.getDocumentInfo": 2e3,
|
|
"PersistedQueryLink.persistedQueryHashes": 2e3,
|
|
"fragmentRegistry.transform": 2e3,
|
|
"fragmentRegistry.lookup": 1e3,
|
|
"fragmentRegistry.findFragmentSpreads": 4e3,
|
|
"cache.fragmentQueryDocuments": 1e3,
|
|
"removeTypenameFromVariables.getVariableDefinitions": 2e3,
|
|
"inMemoryCache.maybeBroadcastWatch": 5e3,
|
|
"inMemoryCache.executeSelectionSet": 5e4,
|
|
"inMemoryCache.executeSubSelectedArray": 1e4
|
|
};
|
|
return Object.fromEntries(Object.entries(defaults).map(function(_a) {
|
|
var k = _a[0], v = _a[1];
|
|
return [
|
|
k,
|
|
cacheSizes[k] || v
|
|
];
|
|
}));
|
|
}
|
|
function _getApolloClientMemoryInternals() {
|
|
var _a, _b, _c, _d, _e;
|
|
if (!(globalThis.__DEV__ !== false))
|
|
throw new Error("only supported in development mode");
|
|
return {
|
|
limits: getCurrentCacheSizes(),
|
|
sizes: __assign({ print: (_a = globalCaches.print) === null || _a === void 0 ? void 0 : _a.call(globalCaches), parser: (_b = globalCaches.parser) === null || _b === void 0 ? void 0 : _b.call(globalCaches), canonicalStringify: (_c = globalCaches.canonicalStringify) === null || _c === void 0 ? void 0 : _c.call(globalCaches), links: linkInfo(this.link), queryManager: {
|
|
getDocumentInfo: this["queryManager"]["transformCache"].size,
|
|
documentTransforms: transformInfo(this["queryManager"].documentTransform)
|
|
} }, (_e = (_d = this.cache).getMemoryInternals) === null || _e === void 0 ? void 0 : _e.call(_d))
|
|
};
|
|
}
|
|
function _getApolloCacheMemoryInternals() {
|
|
return {
|
|
cache: {
|
|
fragmentQueryDocuments: getWrapperInformation(this["getFragmentDoc"])
|
|
}
|
|
};
|
|
}
|
|
function _getInMemoryCacheMemoryInternals() {
|
|
var fragments = this.config.fragments;
|
|
return __assign(__assign({}, _getApolloCacheMemoryInternals.apply(this)), { addTypenameDocumentTransform: transformInfo(this["addTypenameTransform"]), inMemoryCache: {
|
|
executeSelectionSet: getWrapperInformation(this["storeReader"]["executeSelectionSet"]),
|
|
executeSubSelectedArray: getWrapperInformation(this["storeReader"]["executeSubSelectedArray"]),
|
|
maybeBroadcastWatch: getWrapperInformation(this["maybeBroadcastWatch"])
|
|
}, fragmentRegistry: {
|
|
findFragmentSpreads: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.findFragmentSpreads),
|
|
lookup: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.lookup),
|
|
transform: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.transform)
|
|
} });
|
|
}
|
|
function isWrapper(f) {
|
|
return !!f && "dirtyKey" in f;
|
|
}
|
|
function getWrapperInformation(f) {
|
|
return isWrapper(f) ? f.size : void 0;
|
|
}
|
|
function isDefined(value) {
|
|
return value != null;
|
|
}
|
|
function transformInfo(transform) {
|
|
return recurseTransformInfo(transform).map(function(cache) {
|
|
return { cache };
|
|
});
|
|
}
|
|
function recurseTransformInfo(transform) {
|
|
return transform ? __spreadArray(__spreadArray([
|
|
getWrapperInformation(transform === null || transform === void 0 ? void 0 : transform["performWork"])
|
|
], recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform["left"]), true), recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform["right"]), true).filter(isDefined) : [];
|
|
}
|
|
function linkInfo(link) {
|
|
var _a;
|
|
return link ? __spreadArray(__spreadArray([
|
|
(_a = link === null || link === void 0 ? void 0 : link.getMemoryInternals) === null || _a === void 0 ? void 0 : _a.call(link)
|
|
], linkInfo(link === null || link === void 0 ? void 0 : link.left), true), linkInfo(link === null || link === void 0 ? void 0 : link.right), true).filter(isDefined) : [];
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/common/canonicalStringify.js
|
|
var canonicalStringify = Object.assign(function canonicalStringify2(value) {
|
|
return JSON.stringify(value, stableObjectReplacer);
|
|
}, {
|
|
reset: function() {
|
|
sortingMap = new AutoCleanedStrongCache(
|
|
cacheSizes.canonicalStringify || 1e3
|
|
/* defaultCacheSizes.canonicalStringify */
|
|
);
|
|
}
|
|
});
|
|
if (globalThis.__DEV__ !== false) {
|
|
registerGlobalCache("canonicalStringify", function() {
|
|
return sortingMap.size;
|
|
});
|
|
}
|
|
var sortingMap;
|
|
canonicalStringify.reset();
|
|
function stableObjectReplacer(key, value) {
|
|
if (value && typeof value === "object") {
|
|
var proto = Object.getPrototypeOf(value);
|
|
if (proto === Object.prototype || proto === null) {
|
|
var keys = Object.keys(value);
|
|
if (keys.every(everyKeyInOrder))
|
|
return value;
|
|
var unsortedKey = JSON.stringify(keys);
|
|
var sortedKeys = sortingMap.get(unsortedKey);
|
|
if (!sortedKeys) {
|
|
keys.sort();
|
|
var sortedKey = JSON.stringify(keys);
|
|
sortedKeys = sortingMap.get(sortedKey) || keys;
|
|
sortingMap.set(unsortedKey, sortedKeys);
|
|
sortingMap.set(sortedKey, sortedKeys);
|
|
}
|
|
var sortedObject_1 = Object.create(proto);
|
|
sortedKeys.forEach(function(key2) {
|
|
sortedObject_1[key2] = value[key2];
|
|
});
|
|
return sortedObject_1;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function everyKeyInOrder(key, i, keys) {
|
|
return i === 0 || keys[i - 1] <= key;
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/graphql/storeUtils.js
|
|
function makeReference(id) {
|
|
return { __ref: String(id) };
|
|
}
|
|
function isReference(obj) {
|
|
return Boolean(obj && typeof obj === "object" && typeof obj.__ref === "string");
|
|
}
|
|
function isDocumentNode(value) {
|
|
return isNonNullObject(value) && value.kind === "Document" && Array.isArray(value.definitions);
|
|
}
|
|
function isStringValue(value) {
|
|
return value.kind === "StringValue";
|
|
}
|
|
function isBooleanValue(value) {
|
|
return value.kind === "BooleanValue";
|
|
}
|
|
function isIntValue(value) {
|
|
return value.kind === "IntValue";
|
|
}
|
|
function isFloatValue(value) {
|
|
return value.kind === "FloatValue";
|
|
}
|
|
function isVariable(value) {
|
|
return value.kind === "Variable";
|
|
}
|
|
function isObjectValue(value) {
|
|
return value.kind === "ObjectValue";
|
|
}
|
|
function isListValue(value) {
|
|
return value.kind === "ListValue";
|
|
}
|
|
function isEnumValue(value) {
|
|
return value.kind === "EnumValue";
|
|
}
|
|
function isNullValue(value) {
|
|
return value.kind === "NullValue";
|
|
}
|
|
function valueToObjectRepresentation(argObj, name, value, variables) {
|
|
if (isIntValue(value) || isFloatValue(value)) {
|
|
argObj[name.value] = Number(value.value);
|
|
} else if (isBooleanValue(value) || isStringValue(value)) {
|
|
argObj[name.value] = value.value;
|
|
} else if (isObjectValue(value)) {
|
|
var nestedArgObj_1 = {};
|
|
value.fields.map(function(obj) {
|
|
return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);
|
|
});
|
|
argObj[name.value] = nestedArgObj_1;
|
|
} else if (isVariable(value)) {
|
|
var variableValue = (variables || {})[value.name.value];
|
|
argObj[name.value] = variableValue;
|
|
} else if (isListValue(value)) {
|
|
argObj[name.value] = value.values.map(function(listValue) {
|
|
var nestedArgArrayObj = {};
|
|
valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);
|
|
return nestedArgArrayObj[name.value];
|
|
});
|
|
} else if (isEnumValue(value)) {
|
|
argObj[name.value] = value.value;
|
|
} else if (isNullValue(value)) {
|
|
argObj[name.value] = null;
|
|
} else {
|
|
throw newInvariantError(96, name.value, value.kind);
|
|
}
|
|
}
|
|
function storeKeyNameFromField(field, variables) {
|
|
var directivesObj = null;
|
|
if (field.directives) {
|
|
directivesObj = {};
|
|
field.directives.forEach(function(directive) {
|
|
directivesObj[directive.name.value] = {};
|
|
if (directive.arguments) {
|
|
directive.arguments.forEach(function(_a) {
|
|
var name = _a.name, value = _a.value;
|
|
return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);
|
|
});
|
|
}
|
|
});
|
|
}
|
|
var argObj = null;
|
|
if (field.arguments && field.arguments.length) {
|
|
argObj = {};
|
|
field.arguments.forEach(function(_a) {
|
|
var name = _a.name, value = _a.value;
|
|
return valueToObjectRepresentation(argObj, name, value, variables);
|
|
});
|
|
}
|
|
return getStoreKeyName(field.name.value, argObj, directivesObj);
|
|
}
|
|
var KNOWN_DIRECTIVES = [
|
|
"connection",
|
|
"include",
|
|
"skip",
|
|
"client",
|
|
"rest",
|
|
"export",
|
|
"nonreactive"
|
|
];
|
|
var storeKeyNameStringify = canonicalStringify;
|
|
var getStoreKeyName = Object.assign(function(fieldName, args, directives) {
|
|
if (args && directives && directives["connection"] && directives["connection"]["key"]) {
|
|
if (directives["connection"]["filter"] && directives["connection"]["filter"].length > 0) {
|
|
var filterKeys = directives["connection"]["filter"] ? directives["connection"]["filter"] : [];
|
|
filterKeys.sort();
|
|
var filteredArgs_1 = {};
|
|
filterKeys.forEach(function(key) {
|
|
filteredArgs_1[key] = args[key];
|
|
});
|
|
return "".concat(directives["connection"]["key"], "(").concat(storeKeyNameStringify(filteredArgs_1), ")");
|
|
} else {
|
|
return directives["connection"]["key"];
|
|
}
|
|
}
|
|
var completeFieldName = fieldName;
|
|
if (args) {
|
|
var stringifiedArgs = storeKeyNameStringify(args);
|
|
completeFieldName += "(".concat(stringifiedArgs, ")");
|
|
}
|
|
if (directives) {
|
|
Object.keys(directives).forEach(function(key) {
|
|
if (KNOWN_DIRECTIVES.indexOf(key) !== -1)
|
|
return;
|
|
if (directives[key] && Object.keys(directives[key]).length) {
|
|
completeFieldName += "@".concat(key, "(").concat(storeKeyNameStringify(directives[key]), ")");
|
|
} else {
|
|
completeFieldName += "@".concat(key);
|
|
}
|
|
});
|
|
}
|
|
return completeFieldName;
|
|
}, {
|
|
setStringify: function(s) {
|
|
var previous = storeKeyNameStringify;
|
|
storeKeyNameStringify = s;
|
|
return previous;
|
|
}
|
|
});
|
|
function argumentsObjectFromField(field, variables) {
|
|
if (field.arguments && field.arguments.length) {
|
|
var argObj_1 = {};
|
|
field.arguments.forEach(function(_a) {
|
|
var name = _a.name, value = _a.value;
|
|
return valueToObjectRepresentation(argObj_1, name, value, variables);
|
|
});
|
|
return argObj_1;
|
|
}
|
|
return null;
|
|
}
|
|
function resultKeyNameFromField(field) {
|
|
return field.alias ? field.alias.value : field.name.value;
|
|
}
|
|
function getTypenameFromResult(result2, selectionSet, fragmentMap) {
|
|
var fragments;
|
|
for (var _i = 0, _a = selectionSet.selections; _i < _a.length; _i++) {
|
|
var selection = _a[_i];
|
|
if (isField(selection)) {
|
|
if (selection.name.value === "__typename") {
|
|
return result2[resultKeyNameFromField(selection)];
|
|
}
|
|
} else if (fragments) {
|
|
fragments.push(selection);
|
|
} else {
|
|
fragments = [selection];
|
|
}
|
|
}
|
|
if (typeof result2.__typename === "string") {
|
|
return result2.__typename;
|
|
}
|
|
if (fragments) {
|
|
for (var _b = 0, fragments_1 = fragments; _b < fragments_1.length; _b++) {
|
|
var selection = fragments_1[_b];
|
|
var typename = getTypenameFromResult(result2, getFragmentFromSelection(selection, fragmentMap).selectionSet, fragmentMap);
|
|
if (typeof typename === "string") {
|
|
return typename;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isField(selection) {
|
|
return selection.kind === "Field";
|
|
}
|
|
function isInlineFragment(selection) {
|
|
return selection.kind === "InlineFragment";
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/graphql/getFromAST.js
|
|
function checkDocument(doc) {
|
|
invariant(doc && doc.kind === "Document", 88);
|
|
var operations = doc.definitions.filter(function(d) {
|
|
return d.kind !== "FragmentDefinition";
|
|
}).map(function(definition) {
|
|
if (definition.kind !== "OperationDefinition") {
|
|
throw newInvariantError(89, definition.kind);
|
|
}
|
|
return definition;
|
|
});
|
|
invariant(operations.length <= 1, 90, operations.length);
|
|
return doc;
|
|
}
|
|
function getOperationDefinition(doc) {
|
|
checkDocument(doc);
|
|
return doc.definitions.filter(function(definition) {
|
|
return definition.kind === "OperationDefinition";
|
|
})[0];
|
|
}
|
|
function getOperationName(doc) {
|
|
return doc.definitions.filter(function(definition) {
|
|
return definition.kind === "OperationDefinition" && !!definition.name;
|
|
}).map(function(x) {
|
|
return x.name.value;
|
|
})[0] || null;
|
|
}
|
|
function getFragmentDefinitions(doc) {
|
|
return doc.definitions.filter(function(definition) {
|
|
return definition.kind === "FragmentDefinition";
|
|
});
|
|
}
|
|
function getQueryDefinition(doc) {
|
|
var queryDef = getOperationDefinition(doc);
|
|
invariant(queryDef && queryDef.operation === "query", 91);
|
|
return queryDef;
|
|
}
|
|
function getFragmentDefinition(doc) {
|
|
invariant(doc.kind === "Document", 92);
|
|
invariant(doc.definitions.length <= 1, 93);
|
|
var fragmentDef = doc.definitions[0];
|
|
invariant(fragmentDef.kind === "FragmentDefinition", 94);
|
|
return fragmentDef;
|
|
}
|
|
function getMainDefinition(queryDoc) {
|
|
checkDocument(queryDoc);
|
|
var fragmentDefinition;
|
|
for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {
|
|
var definition = _a[_i];
|
|
if (definition.kind === "OperationDefinition") {
|
|
var operation = definition.operation;
|
|
if (operation === "query" || operation === "mutation" || operation === "subscription") {
|
|
return definition;
|
|
}
|
|
}
|
|
if (definition.kind === "FragmentDefinition" && !fragmentDefinition) {
|
|
fragmentDefinition = definition;
|
|
}
|
|
}
|
|
if (fragmentDefinition) {
|
|
return fragmentDefinition;
|
|
}
|
|
throw newInvariantError(95);
|
|
}
|
|
function getDefaultValues(definition) {
|
|
var defaultValues = /* @__PURE__ */ Object.create(null);
|
|
var defs = definition && definition.variableDefinitions;
|
|
if (defs && defs.length) {
|
|
defs.forEach(function(def) {
|
|
if (def.defaultValue) {
|
|
valueToObjectRepresentation(defaultValues, def.variable.name, def.defaultValue);
|
|
}
|
|
});
|
|
}
|
|
return defaultValues;
|
|
}
|
|
|
|
// node_modules/optimism/node_modules/@wry/trie/lib/index.js
|
|
var defaultMakeData2 = () => /* @__PURE__ */ Object.create(null);
|
|
var { forEach: forEach2, slice: slice2 } = Array.prototype;
|
|
var { hasOwnProperty: hasOwnProperty2 } = Object.prototype;
|
|
var Trie2 = class _Trie {
|
|
constructor(weakness = true, makeData = defaultMakeData2) {
|
|
this.weakness = weakness;
|
|
this.makeData = makeData;
|
|
}
|
|
lookup(...array) {
|
|
return this.lookupArray(array);
|
|
}
|
|
lookupArray(array) {
|
|
let node = this;
|
|
forEach2.call(array, (key) => node = node.getChildTrie(key));
|
|
return hasOwnProperty2.call(node, "data") ? node.data : node.data = this.makeData(slice2.call(array));
|
|
}
|
|
peek(...array) {
|
|
return this.peekArray(array);
|
|
}
|
|
peekArray(array) {
|
|
let node = this;
|
|
for (let i = 0, len = array.length; node && i < len; ++i) {
|
|
const map = this.weakness && isObjRef2(array[i]) ? node.weak : node.strong;
|
|
node = map && map.get(array[i]);
|
|
}
|
|
return node && node.data;
|
|
}
|
|
getChildTrie(key) {
|
|
const map = this.weakness && isObjRef2(key) ? this.weak || (this.weak = /* @__PURE__ */ new WeakMap()) : this.strong || (this.strong = /* @__PURE__ */ new Map());
|
|
let child = map.get(key);
|
|
if (!child)
|
|
map.set(key, child = new _Trie(this.weakness, this.makeData));
|
|
return child;
|
|
}
|
|
};
|
|
function isObjRef2(value) {
|
|
switch (typeof value) {
|
|
case "object":
|
|
if (value === null)
|
|
break;
|
|
// Fall through to return true...
|
|
case "function":
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// node_modules/@wry/context/lib/context.esm.js
|
|
var currentContext = null;
|
|
var MISSING_VALUE = {};
|
|
var idCounter = 1;
|
|
var makeSlotClass = function() {
|
|
return (
|
|
/** @class */
|
|
function() {
|
|
function Slot2() {
|
|
this.id = [
|
|
"slot",
|
|
idCounter++,
|
|
Date.now(),
|
|
Math.random().toString(36).slice(2)
|
|
].join(":");
|
|
}
|
|
Slot2.prototype.hasValue = function() {
|
|
for (var context_1 = currentContext; context_1; context_1 = context_1.parent) {
|
|
if (this.id in context_1.slots) {
|
|
var value = context_1.slots[this.id];
|
|
if (value === MISSING_VALUE)
|
|
break;
|
|
if (context_1 !== currentContext) {
|
|
currentContext.slots[this.id] = value;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
if (currentContext) {
|
|
currentContext.slots[this.id] = MISSING_VALUE;
|
|
}
|
|
return false;
|
|
};
|
|
Slot2.prototype.getValue = function() {
|
|
if (this.hasValue()) {
|
|
return currentContext.slots[this.id];
|
|
}
|
|
};
|
|
Slot2.prototype.withValue = function(value, callback, args, thisArg) {
|
|
var _a;
|
|
var slots = (_a = {
|
|
__proto__: null
|
|
}, _a[this.id] = value, _a);
|
|
var parent = currentContext;
|
|
currentContext = { parent, slots };
|
|
try {
|
|
return callback.apply(thisArg, args);
|
|
} finally {
|
|
currentContext = parent;
|
|
}
|
|
};
|
|
Slot2.bind = function(callback) {
|
|
var context = currentContext;
|
|
return function() {
|
|
var saved = currentContext;
|
|
try {
|
|
currentContext = context;
|
|
return callback.apply(this, arguments);
|
|
} finally {
|
|
currentContext = saved;
|
|
}
|
|
};
|
|
};
|
|
Slot2.noContext = function(callback, args, thisArg) {
|
|
if (currentContext) {
|
|
var saved = currentContext;
|
|
try {
|
|
currentContext = null;
|
|
return callback.apply(thisArg, args);
|
|
} finally {
|
|
currentContext = saved;
|
|
}
|
|
} else {
|
|
return callback.apply(thisArg, args);
|
|
}
|
|
};
|
|
return Slot2;
|
|
}()
|
|
);
|
|
};
|
|
function maybe2(fn) {
|
|
try {
|
|
return fn();
|
|
} catch (ignored) {
|
|
}
|
|
}
|
|
var globalKey = "@wry/context:Slot";
|
|
var host = (
|
|
// Prefer globalThis when available.
|
|
// https://github.com/benjamn/wryware/issues/347
|
|
maybe2(function() {
|
|
return globalThis;
|
|
}) || // Fall back to global, which works in Node.js and may be converted by some
|
|
// bundlers to the appropriate identifier (window, self, ...) depending on the
|
|
// bundling target. https://github.com/endojs/endo/issues/576#issuecomment-1178515224
|
|
maybe2(function() {
|
|
return global;
|
|
}) || // Otherwise, use a dummy host that's local to this module. We used to fall
|
|
// back to using the Array constructor as a namespace, but that was flagged in
|
|
// https://github.com/benjamn/wryware/issues/347, and can be avoided.
|
|
/* @__PURE__ */ Object.create(null)
|
|
);
|
|
var globalHost = host;
|
|
var Slot = globalHost[globalKey] || // Earlier versions of this package stored the globalKey property on the Array
|
|
// constructor, so we check there as well, to prevent Slot class duplication.
|
|
Array[globalKey] || function(Slot2) {
|
|
try {
|
|
Object.defineProperty(globalHost, globalKey, {
|
|
value: Slot2,
|
|
enumerable: false,
|
|
writable: false,
|
|
// When it was possible for globalHost to be the Array constructor (a
|
|
// legacy Slot dedup strategy), it was important for the property to be
|
|
// configurable:true so it could be deleted. That does not seem to be as
|
|
// important when globalHost is the global object, but I don't want to
|
|
// cause similar problems again, and configurable:true seems safest.
|
|
// https://github.com/endojs/endo/issues/576#issuecomment-1178274008
|
|
configurable: true
|
|
});
|
|
} finally {
|
|
return Slot2;
|
|
}
|
|
}(makeSlotClass());
|
|
var bind = Slot.bind;
|
|
var noContext = Slot.noContext;
|
|
|
|
// node_modules/optimism/lib/context.js
|
|
var parentEntrySlot = new Slot();
|
|
|
|
// node_modules/optimism/lib/helpers.js
|
|
var { hasOwnProperty: hasOwnProperty3 } = Object.prototype;
|
|
var arrayFromSet = Array.from || function(set) {
|
|
const array = [];
|
|
set.forEach((item) => array.push(item));
|
|
return array;
|
|
};
|
|
function maybeUnsubscribe(entryOrDep) {
|
|
const { unsubscribe } = entryOrDep;
|
|
if (typeof unsubscribe === "function") {
|
|
entryOrDep.unsubscribe = void 0;
|
|
unsubscribe();
|
|
}
|
|
}
|
|
|
|
// node_modules/optimism/lib/entry.js
|
|
var emptySetPool = [];
|
|
var POOL_TARGET_SIZE = 100;
|
|
function assert(condition, optionalMessage) {
|
|
if (!condition) {
|
|
throw new Error(optionalMessage || "assertion failure");
|
|
}
|
|
}
|
|
function valueIs(a, b) {
|
|
const len = a.length;
|
|
return (
|
|
// Unknown values are not equal to each other.
|
|
len > 0 && // Both values must be ordinary (or both exceptional) to be equal.
|
|
len === b.length && // The underlying value or exception must be the same.
|
|
a[len - 1] === b[len - 1]
|
|
);
|
|
}
|
|
function valueGet(value) {
|
|
switch (value.length) {
|
|
case 0:
|
|
throw new Error("unknown value");
|
|
case 1:
|
|
return value[0];
|
|
case 2:
|
|
throw value[1];
|
|
}
|
|
}
|
|
function valueCopy(value) {
|
|
return value.slice(0);
|
|
}
|
|
var Entry = class _Entry {
|
|
constructor(fn) {
|
|
this.fn = fn;
|
|
this.parents = /* @__PURE__ */ new Set();
|
|
this.childValues = /* @__PURE__ */ new Map();
|
|
this.dirtyChildren = null;
|
|
this.dirty = true;
|
|
this.recomputing = false;
|
|
this.value = [];
|
|
this.deps = null;
|
|
++_Entry.count;
|
|
}
|
|
peek() {
|
|
if (this.value.length === 1 && !mightBeDirty(this)) {
|
|
rememberParent(this);
|
|
return this.value[0];
|
|
}
|
|
}
|
|
// This is the most important method of the Entry API, because it
|
|
// determines whether the cached this.value can be returned immediately,
|
|
// or must be recomputed. The overall performance of the caching system
|
|
// depends on the truth of the following observations: (1) this.dirty is
|
|
// usually false, (2) this.dirtyChildren is usually null/empty, and thus
|
|
// (3) valueGet(this.value) is usually returned without recomputation.
|
|
recompute(args) {
|
|
assert(!this.recomputing, "already recomputing");
|
|
rememberParent(this);
|
|
return mightBeDirty(this) ? reallyRecompute(this, args) : valueGet(this.value);
|
|
}
|
|
setDirty() {
|
|
if (this.dirty)
|
|
return;
|
|
this.dirty = true;
|
|
reportDirty(this);
|
|
maybeUnsubscribe(this);
|
|
}
|
|
dispose() {
|
|
this.setDirty();
|
|
forgetChildren(this);
|
|
eachParent(this, (parent, child) => {
|
|
parent.setDirty();
|
|
forgetChild(parent, this);
|
|
});
|
|
}
|
|
forget() {
|
|
this.dispose();
|
|
}
|
|
dependOn(dep2) {
|
|
dep2.add(this);
|
|
if (!this.deps) {
|
|
this.deps = emptySetPool.pop() || /* @__PURE__ */ new Set();
|
|
}
|
|
this.deps.add(dep2);
|
|
}
|
|
forgetDeps() {
|
|
if (this.deps) {
|
|
arrayFromSet(this.deps).forEach((dep2) => dep2.delete(this));
|
|
this.deps.clear();
|
|
emptySetPool.push(this.deps);
|
|
this.deps = null;
|
|
}
|
|
}
|
|
};
|
|
Entry.count = 0;
|
|
function rememberParent(child) {
|
|
const parent = parentEntrySlot.getValue();
|
|
if (parent) {
|
|
child.parents.add(parent);
|
|
if (!parent.childValues.has(child)) {
|
|
parent.childValues.set(child, []);
|
|
}
|
|
if (mightBeDirty(child)) {
|
|
reportDirtyChild(parent, child);
|
|
} else {
|
|
reportCleanChild(parent, child);
|
|
}
|
|
return parent;
|
|
}
|
|
}
|
|
function reallyRecompute(entry, args) {
|
|
forgetChildren(entry);
|
|
parentEntrySlot.withValue(entry, recomputeNewValue, [entry, args]);
|
|
if (maybeSubscribe(entry, args)) {
|
|
setClean(entry);
|
|
}
|
|
return valueGet(entry.value);
|
|
}
|
|
function recomputeNewValue(entry, args) {
|
|
entry.recomputing = true;
|
|
const { normalizeResult } = entry;
|
|
let oldValueCopy;
|
|
if (normalizeResult && entry.value.length === 1) {
|
|
oldValueCopy = valueCopy(entry.value);
|
|
}
|
|
entry.value.length = 0;
|
|
try {
|
|
entry.value[0] = entry.fn.apply(null, args);
|
|
if (normalizeResult && oldValueCopy && !valueIs(oldValueCopy, entry.value)) {
|
|
try {
|
|
entry.value[0] = normalizeResult(entry.value[0], oldValueCopy[0]);
|
|
} catch (_a) {
|
|
}
|
|
}
|
|
} catch (e) {
|
|
entry.value[1] = e;
|
|
}
|
|
entry.recomputing = false;
|
|
}
|
|
function mightBeDirty(entry) {
|
|
return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);
|
|
}
|
|
function setClean(entry) {
|
|
entry.dirty = false;
|
|
if (mightBeDirty(entry)) {
|
|
return;
|
|
}
|
|
reportClean(entry);
|
|
}
|
|
function reportDirty(child) {
|
|
eachParent(child, reportDirtyChild);
|
|
}
|
|
function reportClean(child) {
|
|
eachParent(child, reportCleanChild);
|
|
}
|
|
function eachParent(child, callback) {
|
|
const parentCount = child.parents.size;
|
|
if (parentCount) {
|
|
const parents = arrayFromSet(child.parents);
|
|
for (let i = 0; i < parentCount; ++i) {
|
|
callback(parents[i], child);
|
|
}
|
|
}
|
|
}
|
|
function reportDirtyChild(parent, child) {
|
|
assert(parent.childValues.has(child));
|
|
assert(mightBeDirty(child));
|
|
const parentWasClean = !mightBeDirty(parent);
|
|
if (!parent.dirtyChildren) {
|
|
parent.dirtyChildren = emptySetPool.pop() || /* @__PURE__ */ new Set();
|
|
} else if (parent.dirtyChildren.has(child)) {
|
|
return;
|
|
}
|
|
parent.dirtyChildren.add(child);
|
|
if (parentWasClean) {
|
|
reportDirty(parent);
|
|
}
|
|
}
|
|
function reportCleanChild(parent, child) {
|
|
assert(parent.childValues.has(child));
|
|
assert(!mightBeDirty(child));
|
|
const childValue = parent.childValues.get(child);
|
|
if (childValue.length === 0) {
|
|
parent.childValues.set(child, valueCopy(child.value));
|
|
} else if (!valueIs(childValue, child.value)) {
|
|
parent.setDirty();
|
|
}
|
|
removeDirtyChild(parent, child);
|
|
if (mightBeDirty(parent)) {
|
|
return;
|
|
}
|
|
reportClean(parent);
|
|
}
|
|
function removeDirtyChild(parent, child) {
|
|
const dc = parent.dirtyChildren;
|
|
if (dc) {
|
|
dc.delete(child);
|
|
if (dc.size === 0) {
|
|
if (emptySetPool.length < POOL_TARGET_SIZE) {
|
|
emptySetPool.push(dc);
|
|
}
|
|
parent.dirtyChildren = null;
|
|
}
|
|
}
|
|
}
|
|
function forgetChildren(parent) {
|
|
if (parent.childValues.size > 0) {
|
|
parent.childValues.forEach((_value, child) => {
|
|
forgetChild(parent, child);
|
|
});
|
|
}
|
|
parent.forgetDeps();
|
|
assert(parent.dirtyChildren === null);
|
|
}
|
|
function forgetChild(parent, child) {
|
|
child.parents.delete(parent);
|
|
parent.childValues.delete(child);
|
|
removeDirtyChild(parent, child);
|
|
}
|
|
function maybeSubscribe(entry, args) {
|
|
if (typeof entry.subscribe === "function") {
|
|
try {
|
|
maybeUnsubscribe(entry);
|
|
entry.unsubscribe = entry.subscribe.apply(null, args);
|
|
} catch (e) {
|
|
entry.setDirty();
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// node_modules/optimism/lib/dep.js
|
|
var EntryMethods = {
|
|
setDirty: true,
|
|
dispose: true,
|
|
forget: true
|
|
// Fully remove parent Entry from LRU cache and computation graph
|
|
};
|
|
function dep(options) {
|
|
const depsByKey = /* @__PURE__ */ new Map();
|
|
const subscribe = options && options.subscribe;
|
|
function depend(key) {
|
|
const parent = parentEntrySlot.getValue();
|
|
if (parent) {
|
|
let dep2 = depsByKey.get(key);
|
|
if (!dep2) {
|
|
depsByKey.set(key, dep2 = /* @__PURE__ */ new Set());
|
|
}
|
|
parent.dependOn(dep2);
|
|
if (typeof subscribe === "function") {
|
|
maybeUnsubscribe(dep2);
|
|
dep2.unsubscribe = subscribe(key);
|
|
}
|
|
}
|
|
}
|
|
depend.dirty = function dirty(key, entryMethodName) {
|
|
const dep2 = depsByKey.get(key);
|
|
if (dep2) {
|
|
const m = entryMethodName && hasOwnProperty3.call(EntryMethods, entryMethodName) ? entryMethodName : "setDirty";
|
|
arrayFromSet(dep2).forEach((entry) => entry[m]());
|
|
depsByKey.delete(key);
|
|
maybeUnsubscribe(dep2);
|
|
}
|
|
};
|
|
return depend;
|
|
}
|
|
|
|
// node_modules/optimism/lib/index.js
|
|
var defaultKeyTrie;
|
|
function defaultMakeCacheKey(...args) {
|
|
const trie = defaultKeyTrie || (defaultKeyTrie = new Trie2(typeof WeakMap === "function"));
|
|
return trie.lookupArray(args);
|
|
}
|
|
var caches = /* @__PURE__ */ new Set();
|
|
function wrap(originalFunction, { max = Math.pow(2, 16), keyArgs, makeCacheKey = defaultMakeCacheKey, normalizeResult, subscribe, cache: cacheOption = StrongCache } = /* @__PURE__ */ Object.create(null)) {
|
|
const cache = typeof cacheOption === "function" ? new cacheOption(max, (entry) => entry.dispose()) : cacheOption;
|
|
const optimistic = function() {
|
|
const key = makeCacheKey.apply(null, keyArgs ? keyArgs.apply(null, arguments) : arguments);
|
|
if (key === void 0) {
|
|
return originalFunction.apply(null, arguments);
|
|
}
|
|
let entry = cache.get(key);
|
|
if (!entry) {
|
|
cache.set(key, entry = new Entry(originalFunction));
|
|
entry.normalizeResult = normalizeResult;
|
|
entry.subscribe = subscribe;
|
|
entry.forget = () => cache.delete(key);
|
|
}
|
|
const value = entry.recompute(Array.prototype.slice.call(arguments));
|
|
cache.set(key, entry);
|
|
caches.add(cache);
|
|
if (!parentEntrySlot.hasValue()) {
|
|
caches.forEach((cache2) => cache2.clean());
|
|
caches.clear();
|
|
}
|
|
return value;
|
|
};
|
|
Object.defineProperty(optimistic, "size", {
|
|
get: () => cache.size,
|
|
configurable: false,
|
|
enumerable: false
|
|
});
|
|
Object.freeze(optimistic.options = {
|
|
max,
|
|
keyArgs,
|
|
makeCacheKey,
|
|
normalizeResult,
|
|
subscribe,
|
|
cache
|
|
});
|
|
function dirtyKey(key) {
|
|
const entry = key && cache.get(key);
|
|
if (entry) {
|
|
entry.setDirty();
|
|
}
|
|
}
|
|
optimistic.dirtyKey = dirtyKey;
|
|
optimistic.dirty = function dirty() {
|
|
dirtyKey(makeCacheKey.apply(null, arguments));
|
|
};
|
|
function peekKey(key) {
|
|
const entry = key && cache.get(key);
|
|
if (entry) {
|
|
return entry.peek();
|
|
}
|
|
}
|
|
optimistic.peekKey = peekKey;
|
|
optimistic.peek = function peek() {
|
|
return peekKey(makeCacheKey.apply(null, arguments));
|
|
};
|
|
function forgetKey(key) {
|
|
return key ? cache.delete(key) : false;
|
|
}
|
|
optimistic.forgetKey = forgetKey;
|
|
optimistic.forget = function forget() {
|
|
return forgetKey(makeCacheKey.apply(null, arguments));
|
|
};
|
|
optimistic.makeCacheKey = makeCacheKey;
|
|
optimistic.getKey = keyArgs ? function getKey() {
|
|
return makeCacheKey.apply(null, keyArgs.apply(null, arguments));
|
|
} : makeCacheKey;
|
|
return Object.freeze(optimistic);
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/graphql/DocumentTransform.js
|
|
function identity(document) {
|
|
return document;
|
|
}
|
|
var DocumentTransform = (
|
|
/** @class */
|
|
function() {
|
|
function DocumentTransform2(transform, options) {
|
|
if (options === void 0) {
|
|
options = /* @__PURE__ */ Object.create(null);
|
|
}
|
|
this.resultCache = canUseWeakSet ? /* @__PURE__ */ new WeakSet() : /* @__PURE__ */ new Set();
|
|
this.transform = transform;
|
|
if (options.getCacheKey) {
|
|
this.getCacheKey = options.getCacheKey;
|
|
}
|
|
this.cached = options.cache !== false;
|
|
this.resetCache();
|
|
}
|
|
DocumentTransform2.prototype.getCacheKey = function(document) {
|
|
return [document];
|
|
};
|
|
DocumentTransform2.identity = function() {
|
|
return new DocumentTransform2(identity, { cache: false });
|
|
};
|
|
DocumentTransform2.split = function(predicate, left, right) {
|
|
if (right === void 0) {
|
|
right = DocumentTransform2.identity();
|
|
}
|
|
return Object.assign(new DocumentTransform2(
|
|
function(document) {
|
|
var documentTransform = predicate(document) ? left : right;
|
|
return documentTransform.transformDocument(document);
|
|
},
|
|
// Reasonably assume both `left` and `right` transforms handle their own caching
|
|
{ cache: false }
|
|
), { left, right });
|
|
};
|
|
DocumentTransform2.prototype.resetCache = function() {
|
|
var _this = this;
|
|
if (this.cached) {
|
|
var stableCacheKeys_1 = new Trie(canUseWeakMap);
|
|
this.performWork = wrap(DocumentTransform2.prototype.performWork.bind(this), {
|
|
makeCacheKey: function(document) {
|
|
var cacheKeys = _this.getCacheKey(document);
|
|
if (cacheKeys) {
|
|
invariant(Array.isArray(cacheKeys), 77);
|
|
return stableCacheKeys_1.lookupArray(cacheKeys);
|
|
}
|
|
},
|
|
max: cacheSizes["documentTransform.cache"],
|
|
cache: WeakCache
|
|
});
|
|
}
|
|
};
|
|
DocumentTransform2.prototype.performWork = function(document) {
|
|
checkDocument(document);
|
|
return this.transform(document);
|
|
};
|
|
DocumentTransform2.prototype.transformDocument = function(document) {
|
|
if (this.resultCache.has(document)) {
|
|
return document;
|
|
}
|
|
var transformedDocument = this.performWork(document);
|
|
this.resultCache.add(transformedDocument);
|
|
return transformedDocument;
|
|
};
|
|
DocumentTransform2.prototype.concat = function(otherTransform) {
|
|
var _this = this;
|
|
return Object.assign(new DocumentTransform2(
|
|
function(document) {
|
|
return otherTransform.transformDocument(_this.transformDocument(document));
|
|
},
|
|
// Reasonably assume both transforms handle their own caching
|
|
{ cache: false }
|
|
), {
|
|
left: this,
|
|
right: otherTransform
|
|
});
|
|
};
|
|
return DocumentTransform2;
|
|
}()
|
|
);
|
|
|
|
// node_modules/@apollo/client/utilities/graphql/print.js
|
|
import { print as origPrint } from "/_nuxt/node_modules/graphql/index.mjs?v=e4f18c29";
|
|
var printCache;
|
|
var print = Object.assign(function(ast) {
|
|
var result2 = printCache.get(ast);
|
|
if (!result2) {
|
|
result2 = origPrint(ast);
|
|
printCache.set(ast, result2);
|
|
}
|
|
return result2;
|
|
}, {
|
|
reset: function() {
|
|
printCache = new AutoCleanedWeakCache(
|
|
cacheSizes.print || 2e3
|
|
/* defaultCacheSizes.print */
|
|
);
|
|
}
|
|
});
|
|
print.reset();
|
|
if (globalThis.__DEV__ !== false) {
|
|
registerGlobalCache("print", function() {
|
|
return printCache ? printCache.size : 0;
|
|
});
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/graphql/transform.js
|
|
import { visit as visit3, Kind as Kind2 } from "/_nuxt/node_modules/graphql/index.mjs?v=e4f18c29";
|
|
|
|
// node_modules/@apollo/client/utilities/common/arrays.js
|
|
var isArray = Array.isArray;
|
|
function isNonEmptyArray(value) {
|
|
return Array.isArray(value) && value.length > 0;
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/graphql/transform.js
|
|
var TYPENAME_FIELD = {
|
|
kind: Kind2.FIELD,
|
|
name: {
|
|
kind: Kind2.NAME,
|
|
value: "__typename"
|
|
}
|
|
};
|
|
function isEmpty(op, fragmentMap) {
|
|
return !op || op.selectionSet.selections.every(function(selection) {
|
|
return selection.kind === Kind2.FRAGMENT_SPREAD && isEmpty(fragmentMap[selection.name.value], fragmentMap);
|
|
});
|
|
}
|
|
function nullIfDocIsEmpty(doc) {
|
|
return isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc))) ? null : doc;
|
|
}
|
|
function getDirectiveMatcher(configs) {
|
|
var names = /* @__PURE__ */ new Map();
|
|
var tests = /* @__PURE__ */ new Map();
|
|
configs.forEach(function(directive) {
|
|
if (directive) {
|
|
if (directive.name) {
|
|
names.set(directive.name, directive);
|
|
} else if (directive.test) {
|
|
tests.set(directive.test, directive);
|
|
}
|
|
}
|
|
});
|
|
return function(directive) {
|
|
var config = names.get(directive.name.value);
|
|
if (!config && tests.size) {
|
|
tests.forEach(function(testConfig, test) {
|
|
if (test(directive)) {
|
|
config = testConfig;
|
|
}
|
|
});
|
|
}
|
|
return config;
|
|
};
|
|
}
|
|
function makeInUseGetterFunction(defaultKey) {
|
|
var map = /* @__PURE__ */ new Map();
|
|
return function inUseGetterFunction(key) {
|
|
if (key === void 0) {
|
|
key = defaultKey;
|
|
}
|
|
var inUse = map.get(key);
|
|
if (!inUse) {
|
|
map.set(key, inUse = {
|
|
// Variable and fragment spread names used directly within this
|
|
// operation or fragment definition, as identified by key. These sets
|
|
// will be populated during the first traversal of the document in
|
|
// removeDirectivesFromDocument below.
|
|
variables: /* @__PURE__ */ new Set(),
|
|
fragmentSpreads: /* @__PURE__ */ new Set()
|
|
});
|
|
}
|
|
return inUse;
|
|
};
|
|
}
|
|
function removeDirectivesFromDocument(directives, doc) {
|
|
checkDocument(doc);
|
|
var getInUseByOperationName = makeInUseGetterFunction("");
|
|
var getInUseByFragmentName = makeInUseGetterFunction("");
|
|
var getInUse = function(ancestors) {
|
|
for (var p = 0, ancestor = void 0; p < ancestors.length && (ancestor = ancestors[p]); ++p) {
|
|
if (isArray(ancestor))
|
|
continue;
|
|
if (ancestor.kind === Kind2.OPERATION_DEFINITION) {
|
|
return getInUseByOperationName(ancestor.name && ancestor.name.value);
|
|
}
|
|
if (ancestor.kind === Kind2.FRAGMENT_DEFINITION) {
|
|
return getInUseByFragmentName(ancestor.name.value);
|
|
}
|
|
}
|
|
globalThis.__DEV__ !== false && invariant.error(97);
|
|
return null;
|
|
};
|
|
var operationCount = 0;
|
|
for (var i = doc.definitions.length - 1; i >= 0; --i) {
|
|
if (doc.definitions[i].kind === Kind2.OPERATION_DEFINITION) {
|
|
++operationCount;
|
|
}
|
|
}
|
|
var directiveMatcher = getDirectiveMatcher(directives);
|
|
var shouldRemoveField = function(nodeDirectives) {
|
|
return isNonEmptyArray(nodeDirectives) && nodeDirectives.map(directiveMatcher).some(function(config) {
|
|
return config && config.remove;
|
|
});
|
|
};
|
|
var originalFragmentDefsByPath = /* @__PURE__ */ new Map();
|
|
var firstVisitMadeChanges = false;
|
|
var fieldOrInlineFragmentVisitor = {
|
|
enter: function(node) {
|
|
if (shouldRemoveField(node.directives)) {
|
|
firstVisitMadeChanges = true;
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
var docWithoutDirectiveSubtrees = visit3(doc, {
|
|
// These two AST node types share the same implementation, defined above.
|
|
Field: fieldOrInlineFragmentVisitor,
|
|
InlineFragment: fieldOrInlineFragmentVisitor,
|
|
VariableDefinition: {
|
|
enter: function() {
|
|
return false;
|
|
}
|
|
},
|
|
Variable: {
|
|
enter: function(node, _key, _parent, _path, ancestors) {
|
|
var inUse = getInUse(ancestors);
|
|
if (inUse) {
|
|
inUse.variables.add(node.name.value);
|
|
}
|
|
}
|
|
},
|
|
FragmentSpread: {
|
|
enter: function(node, _key, _parent, _path, ancestors) {
|
|
if (shouldRemoveField(node.directives)) {
|
|
firstVisitMadeChanges = true;
|
|
return null;
|
|
}
|
|
var inUse = getInUse(ancestors);
|
|
if (inUse) {
|
|
inUse.fragmentSpreads.add(node.name.value);
|
|
}
|
|
}
|
|
},
|
|
FragmentDefinition: {
|
|
enter: function(node, _key, _parent, path) {
|
|
originalFragmentDefsByPath.set(JSON.stringify(path), node);
|
|
},
|
|
leave: function(node, _key, _parent, path) {
|
|
var originalNode = originalFragmentDefsByPath.get(JSON.stringify(path));
|
|
if (node === originalNode) {
|
|
return node;
|
|
}
|
|
if (
|
|
// This logic applies only if the document contains one or more
|
|
// operations, since removing all fragments from a document containing
|
|
// only fragments makes the document useless.
|
|
operationCount > 0 && node.selectionSet.selections.every(function(selection) {
|
|
return selection.kind === Kind2.FIELD && selection.name.value === "__typename";
|
|
})
|
|
) {
|
|
getInUseByFragmentName(node.name.value).removed = true;
|
|
firstVisitMadeChanges = true;
|
|
return null;
|
|
}
|
|
}
|
|
},
|
|
Directive: {
|
|
leave: function(node) {
|
|
if (directiveMatcher(node)) {
|
|
firstVisitMadeChanges = true;
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
if (!firstVisitMadeChanges) {
|
|
return doc;
|
|
}
|
|
var populateTransitiveVars = function(inUse) {
|
|
if (!inUse.transitiveVars) {
|
|
inUse.transitiveVars = new Set(inUse.variables);
|
|
if (!inUse.removed) {
|
|
inUse.fragmentSpreads.forEach(function(childFragmentName) {
|
|
populateTransitiveVars(getInUseByFragmentName(childFragmentName)).transitiveVars.forEach(function(varName) {
|
|
inUse.transitiveVars.add(varName);
|
|
});
|
|
});
|
|
}
|
|
}
|
|
return inUse;
|
|
};
|
|
var allFragmentNamesUsed = /* @__PURE__ */ new Set();
|
|
docWithoutDirectiveSubtrees.definitions.forEach(function(def) {
|
|
if (def.kind === Kind2.OPERATION_DEFINITION) {
|
|
populateTransitiveVars(getInUseByOperationName(def.name && def.name.value)).fragmentSpreads.forEach(function(childFragmentName) {
|
|
allFragmentNamesUsed.add(childFragmentName);
|
|
});
|
|
} else if (def.kind === Kind2.FRAGMENT_DEFINITION && // If there are no operations in the document, then all fragment
|
|
// definitions count as usages of their own fragment names. This heuristic
|
|
// prevents accidentally removing all fragment definitions from the
|
|
// document just because it contains no operations that use the fragments.
|
|
operationCount === 0 && !getInUseByFragmentName(def.name.value).removed) {
|
|
allFragmentNamesUsed.add(def.name.value);
|
|
}
|
|
});
|
|
allFragmentNamesUsed.forEach(function(fragmentName) {
|
|
populateTransitiveVars(getInUseByFragmentName(fragmentName)).fragmentSpreads.forEach(function(childFragmentName) {
|
|
allFragmentNamesUsed.add(childFragmentName);
|
|
});
|
|
});
|
|
var fragmentWillBeRemoved = function(fragmentName) {
|
|
return !!// A fragment definition will be removed if there are no spreads that refer
|
|
// to it, or the fragment was explicitly removed because it had no fields
|
|
// other than __typename.
|
|
(!allFragmentNamesUsed.has(fragmentName) || getInUseByFragmentName(fragmentName).removed);
|
|
};
|
|
var enterVisitor = {
|
|
enter: function(node) {
|
|
if (fragmentWillBeRemoved(node.name.value)) {
|
|
return null;
|
|
}
|
|
}
|
|
};
|
|
return nullIfDocIsEmpty(visit3(docWithoutDirectiveSubtrees, {
|
|
// If the fragment is going to be removed, then leaving any dangling
|
|
// FragmentSpread nodes with the same name would be a mistake.
|
|
FragmentSpread: enterVisitor,
|
|
// This is where the fragment definition is actually removed.
|
|
FragmentDefinition: enterVisitor,
|
|
OperationDefinition: {
|
|
leave: function(node) {
|
|
if (node.variableDefinitions) {
|
|
var usedVariableNames_1 = populateTransitiveVars(
|
|
// If an operation is anonymous, we use the empty string as its key.
|
|
getInUseByOperationName(node.name && node.name.value)
|
|
).transitiveVars;
|
|
if (usedVariableNames_1.size < node.variableDefinitions.length) {
|
|
return __assign(__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function(varDef) {
|
|
return usedVariableNames_1.has(varDef.variable.name.value);
|
|
}) });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
var addTypenameToDocument = Object.assign(function(doc) {
|
|
return visit3(doc, {
|
|
SelectionSet: {
|
|
enter: function(node, _key, parent) {
|
|
if (parent && parent.kind === Kind2.OPERATION_DEFINITION) {
|
|
return;
|
|
}
|
|
var selections = node.selections;
|
|
if (!selections) {
|
|
return;
|
|
}
|
|
var skip = selections.some(function(selection) {
|
|
return isField(selection) && (selection.name.value === "__typename" || selection.name.value.lastIndexOf("__", 0) === 0);
|
|
});
|
|
if (skip) {
|
|
return;
|
|
}
|
|
var field = parent;
|
|
if (isField(field) && field.directives && field.directives.some(function(d) {
|
|
return d.name.value === "export";
|
|
})) {
|
|
return;
|
|
}
|
|
return __assign(__assign({}, node), { selections: __spreadArray(__spreadArray([], selections, true), [TYPENAME_FIELD], false) });
|
|
}
|
|
}
|
|
});
|
|
}, {
|
|
added: function(field) {
|
|
return field === TYPENAME_FIELD;
|
|
}
|
|
});
|
|
var connectionRemoveConfig = {
|
|
test: function(directive) {
|
|
var willRemove = directive.name.value === "connection";
|
|
if (willRemove) {
|
|
if (!directive.arguments || !directive.arguments.some(function(arg) {
|
|
return arg.name.value === "key";
|
|
})) {
|
|
globalThis.__DEV__ !== false && invariant.warn(98);
|
|
}
|
|
}
|
|
return willRemove;
|
|
}
|
|
};
|
|
function removeConnectionDirectiveFromDocument(doc) {
|
|
return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));
|
|
}
|
|
function getArgumentMatcher(config) {
|
|
return function argumentMatcher(argument) {
|
|
return config.some(function(aConfig) {
|
|
return argument.value && argument.value.kind === Kind2.VARIABLE && argument.value.name && (aConfig.name === argument.value.name.value || aConfig.test && aConfig.test(argument));
|
|
});
|
|
};
|
|
}
|
|
function removeArgumentsFromDocument(config, doc) {
|
|
var argMatcher = getArgumentMatcher(config);
|
|
return nullIfDocIsEmpty(visit3(doc, {
|
|
OperationDefinition: {
|
|
enter: function(node) {
|
|
return __assign(__assign({}, node), {
|
|
// Remove matching top level variables definitions.
|
|
variableDefinitions: node.variableDefinitions ? node.variableDefinitions.filter(function(varDef) {
|
|
return !config.some(function(arg) {
|
|
return arg.name === varDef.variable.name.value;
|
|
});
|
|
}) : []
|
|
});
|
|
}
|
|
},
|
|
Field: {
|
|
enter: function(node) {
|
|
var shouldRemoveField = config.some(function(argConfig) {
|
|
return argConfig.remove;
|
|
});
|
|
if (shouldRemoveField) {
|
|
var argMatchCount_1 = 0;
|
|
if (node.arguments) {
|
|
node.arguments.forEach(function(arg) {
|
|
if (argMatcher(arg)) {
|
|
argMatchCount_1 += 1;
|
|
}
|
|
});
|
|
}
|
|
if (argMatchCount_1 === 1) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
Argument: {
|
|
enter: function(node) {
|
|
if (argMatcher(node)) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
function removeFragmentSpreadFromDocument(config, doc) {
|
|
function enter(node) {
|
|
if (config.some(function(def) {
|
|
return def.name === node.name.value;
|
|
})) {
|
|
return null;
|
|
}
|
|
}
|
|
return nullIfDocIsEmpty(visit3(doc, {
|
|
FragmentSpread: { enter },
|
|
FragmentDefinition: { enter }
|
|
}));
|
|
}
|
|
function buildQueryFromSelectionSet(document) {
|
|
var definition = getMainDefinition(document);
|
|
var definitionOperation = definition.operation;
|
|
if (definitionOperation === "query") {
|
|
return document;
|
|
}
|
|
var modifiedDoc = visit3(document, {
|
|
OperationDefinition: {
|
|
enter: function(node) {
|
|
return __assign(__assign({}, node), { operation: "query" });
|
|
}
|
|
}
|
|
});
|
|
return modifiedDoc;
|
|
}
|
|
function removeClientSetsFromDocument(document) {
|
|
checkDocument(document);
|
|
var modifiedDoc = removeDirectivesFromDocument([
|
|
{
|
|
test: function(directive) {
|
|
return directive.name.value === "client";
|
|
},
|
|
remove: true
|
|
}
|
|
], document);
|
|
return modifiedDoc;
|
|
}
|
|
function addNonReactiveToNamedFragments(document) {
|
|
checkDocument(document);
|
|
return visit3(document, {
|
|
FragmentSpread: function(node) {
|
|
var _a;
|
|
if ((_a = node.directives) === null || _a === void 0 ? void 0 : _a.some(function(directive) {
|
|
return directive.name.value === "unmask";
|
|
})) {
|
|
return;
|
|
}
|
|
return __assign(__assign({}, node), { directives: __spreadArray(__spreadArray([], node.directives || [], true), [
|
|
{
|
|
kind: Kind2.DIRECTIVE,
|
|
name: { kind: Kind2.NAME, value: "nonreactive" }
|
|
}
|
|
], false) });
|
|
}
|
|
});
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/graphql/operations.js
|
|
function isOperation(document, operation) {
|
|
var _a;
|
|
return ((_a = getOperationDefinition(document)) === null || _a === void 0 ? void 0 : _a.operation) === operation;
|
|
}
|
|
function isMutationOperation(document) {
|
|
return isOperation(document, "mutation");
|
|
}
|
|
function isQueryOperation(document) {
|
|
return isOperation(document, "query");
|
|
}
|
|
function isSubscriptionOperation(document) {
|
|
return isOperation(document, "subscription");
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/common/mergeDeep.js
|
|
var hasOwnProperty4 = Object.prototype.hasOwnProperty;
|
|
function mergeDeep() {
|
|
var sources = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
sources[_i] = arguments[_i];
|
|
}
|
|
return mergeDeepArray(sources);
|
|
}
|
|
function mergeDeepArray(sources) {
|
|
var target = sources[0] || {};
|
|
var count = sources.length;
|
|
if (count > 1) {
|
|
var merger = new DeepMerger();
|
|
for (var i = 1; i < count; ++i) {
|
|
target = merger.merge(target, sources[i]);
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
var defaultReconciler = function(target, source, property) {
|
|
return this.merge(target[property], source[property]);
|
|
};
|
|
var DeepMerger = (
|
|
/** @class */
|
|
function() {
|
|
function DeepMerger2(reconciler) {
|
|
if (reconciler === void 0) {
|
|
reconciler = defaultReconciler;
|
|
}
|
|
this.reconciler = reconciler;
|
|
this.isObject = isNonNullObject;
|
|
this.pastCopies = /* @__PURE__ */ new Set();
|
|
}
|
|
DeepMerger2.prototype.merge = function(target, source) {
|
|
var _this = this;
|
|
var context = [];
|
|
for (var _i = 2; _i < arguments.length; _i++) {
|
|
context[_i - 2] = arguments[_i];
|
|
}
|
|
if (isNonNullObject(source) && isNonNullObject(target)) {
|
|
Object.keys(source).forEach(function(sourceKey) {
|
|
if (hasOwnProperty4.call(target, sourceKey)) {
|
|
var targetValue = target[sourceKey];
|
|
if (source[sourceKey] !== targetValue) {
|
|
var result2 = _this.reconciler.apply(_this, __spreadArray([
|
|
target,
|
|
source,
|
|
sourceKey
|
|
], context, false));
|
|
if (result2 !== targetValue) {
|
|
target = _this.shallowCopyForMerge(target);
|
|
target[sourceKey] = result2;
|
|
}
|
|
}
|
|
} else {
|
|
target = _this.shallowCopyForMerge(target);
|
|
target[sourceKey] = source[sourceKey];
|
|
}
|
|
});
|
|
return target;
|
|
}
|
|
return source;
|
|
};
|
|
DeepMerger2.prototype.shallowCopyForMerge = function(value) {
|
|
if (isNonNullObject(value)) {
|
|
if (!this.pastCopies.has(value)) {
|
|
if (Array.isArray(value)) {
|
|
value = value.slice(0);
|
|
} else {
|
|
value = __assign({ __proto__: Object.getPrototypeOf(value) }, value);
|
|
}
|
|
this.pastCopies.add(value);
|
|
}
|
|
}
|
|
return value;
|
|
};
|
|
return DeepMerger2;
|
|
}()
|
|
);
|
|
|
|
// node_modules/@apollo/client/utilities/policies/pagination.js
|
|
function concatPagination(keyArgs) {
|
|
if (keyArgs === void 0) {
|
|
keyArgs = false;
|
|
}
|
|
return {
|
|
keyArgs,
|
|
merge: function(existing, incoming) {
|
|
return existing ? __spreadArray(__spreadArray([], existing, true), incoming, true) : incoming;
|
|
}
|
|
};
|
|
}
|
|
function offsetLimitPagination(keyArgs) {
|
|
if (keyArgs === void 0) {
|
|
keyArgs = false;
|
|
}
|
|
return {
|
|
keyArgs,
|
|
merge: function(existing, incoming, _a) {
|
|
var args = _a.args;
|
|
var merged = existing ? existing.slice(0) : [];
|
|
if (incoming) {
|
|
if (args) {
|
|
var _b = args.offset, offset = _b === void 0 ? 0 : _b;
|
|
for (var i = 0; i < incoming.length; ++i) {
|
|
merged[offset + i] = incoming[i];
|
|
}
|
|
} else {
|
|
merged.push.apply(merged, incoming);
|
|
}
|
|
}
|
|
return merged;
|
|
}
|
|
};
|
|
}
|
|
function relayStylePagination(keyArgs) {
|
|
if (keyArgs === void 0) {
|
|
keyArgs = false;
|
|
}
|
|
return {
|
|
keyArgs,
|
|
read: function(existing, _a) {
|
|
var canRead = _a.canRead, readField = _a.readField;
|
|
if (!existing)
|
|
return existing;
|
|
var edges = [];
|
|
var firstEdgeCursor = "";
|
|
var lastEdgeCursor = "";
|
|
existing.edges.forEach(function(edge) {
|
|
if (canRead(readField("node", edge))) {
|
|
edges.push(edge);
|
|
if (edge.cursor) {
|
|
firstEdgeCursor = firstEdgeCursor || edge.cursor || "";
|
|
lastEdgeCursor = edge.cursor || lastEdgeCursor;
|
|
}
|
|
}
|
|
});
|
|
if (edges.length > 1 && firstEdgeCursor === lastEdgeCursor) {
|
|
firstEdgeCursor = "";
|
|
}
|
|
var _b = existing.pageInfo || {}, startCursor = _b.startCursor, endCursor = _b.endCursor;
|
|
return __assign(__assign({}, getExtras(existing)), { edges, pageInfo: __assign(__assign({}, existing.pageInfo), {
|
|
// If existing.pageInfo.{start,end}Cursor are undefined or "", default
|
|
// to firstEdgeCursor and/or lastEdgeCursor.
|
|
startCursor: startCursor || firstEdgeCursor,
|
|
endCursor: endCursor || lastEdgeCursor
|
|
}) });
|
|
},
|
|
merge: function(existing, incoming, _a) {
|
|
var args = _a.args, isReference2 = _a.isReference, readField = _a.readField;
|
|
if (!existing) {
|
|
existing = makeEmptyData();
|
|
}
|
|
if (!incoming) {
|
|
return existing;
|
|
}
|
|
var incomingEdges = incoming.edges ? incoming.edges.map(function(edge) {
|
|
if (isReference2(edge = __assign({}, edge))) {
|
|
edge.cursor = readField("cursor", edge);
|
|
}
|
|
return edge;
|
|
}) : [];
|
|
if (incoming.pageInfo) {
|
|
var pageInfo_1 = incoming.pageInfo;
|
|
var startCursor = pageInfo_1.startCursor, endCursor = pageInfo_1.endCursor;
|
|
var firstEdge = incomingEdges[0];
|
|
var lastEdge = incomingEdges[incomingEdges.length - 1];
|
|
if (firstEdge && startCursor) {
|
|
firstEdge.cursor = startCursor;
|
|
}
|
|
if (lastEdge && endCursor) {
|
|
lastEdge.cursor = endCursor;
|
|
}
|
|
var firstCursor = firstEdge && firstEdge.cursor;
|
|
if (firstCursor && !startCursor) {
|
|
incoming = mergeDeep(incoming, {
|
|
pageInfo: {
|
|
startCursor: firstCursor
|
|
}
|
|
});
|
|
}
|
|
var lastCursor = lastEdge && lastEdge.cursor;
|
|
if (lastCursor && !endCursor) {
|
|
incoming = mergeDeep(incoming, {
|
|
pageInfo: {
|
|
endCursor: lastCursor
|
|
}
|
|
});
|
|
}
|
|
}
|
|
var prefix = existing.edges;
|
|
var suffix = [];
|
|
if (args && args.after) {
|
|
var index = prefix.findIndex(function(edge) {
|
|
return edge.cursor === args.after;
|
|
});
|
|
if (index >= 0) {
|
|
prefix = prefix.slice(0, index + 1);
|
|
}
|
|
} else if (args && args.before) {
|
|
var index = prefix.findIndex(function(edge) {
|
|
return edge.cursor === args.before;
|
|
});
|
|
suffix = index < 0 ? prefix : prefix.slice(index);
|
|
prefix = [];
|
|
} else if (incoming.edges) {
|
|
prefix = [];
|
|
}
|
|
var edges = __spreadArray(__spreadArray(__spreadArray([], prefix, true), incomingEdges, true), suffix, true);
|
|
var pageInfo = __assign(__assign({}, incoming.pageInfo), existing.pageInfo);
|
|
if (incoming.pageInfo) {
|
|
var _b = incoming.pageInfo, hasPreviousPage = _b.hasPreviousPage, hasNextPage = _b.hasNextPage, startCursor = _b.startCursor, endCursor = _b.endCursor, extras = __rest(_b, ["hasPreviousPage", "hasNextPage", "startCursor", "endCursor"]);
|
|
Object.assign(pageInfo, extras);
|
|
if (!prefix.length) {
|
|
if (void 0 !== hasPreviousPage)
|
|
pageInfo.hasPreviousPage = hasPreviousPage;
|
|
if (void 0 !== startCursor)
|
|
pageInfo.startCursor = startCursor;
|
|
}
|
|
if (!suffix.length) {
|
|
if (void 0 !== hasNextPage)
|
|
pageInfo.hasNextPage = hasNextPage;
|
|
if (void 0 !== endCursor)
|
|
pageInfo.endCursor = endCursor;
|
|
}
|
|
}
|
|
return __assign(__assign(__assign({}, getExtras(existing)), getExtras(incoming)), { edges, pageInfo });
|
|
}
|
|
};
|
|
}
|
|
var getExtras = function(obj) {
|
|
return __rest(obj, notExtras);
|
|
};
|
|
var notExtras = ["edges", "pageInfo"];
|
|
function makeEmptyData() {
|
|
return {
|
|
edges: [],
|
|
pageInfo: {
|
|
hasPreviousPage: false,
|
|
hasNextPage: true,
|
|
startCursor: "",
|
|
endCursor: ""
|
|
}
|
|
};
|
|
}
|
|
|
|
// node_modules/zen-observable-ts/module.js
|
|
function _createForOfIteratorHelperLoose(o, allowArrayLike) {
|
|
var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
|
|
if (it) return (it = it.call(o)).next.bind(it);
|
|
if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
|
|
if (it) o = it;
|
|
var i = 0;
|
|
return function() {
|
|
if (i >= o.length) return { done: true };
|
|
return { done: false, value: o[i++] };
|
|
};
|
|
}
|
|
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
}
|
|
function _unsupportedIterableToArray(o, minLen) {
|
|
if (!o) return;
|
|
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
|
|
var n = Object.prototype.toString.call(o).slice(8, -1);
|
|
if (n === "Object" && o.constructor) n = o.constructor.name;
|
|
if (n === "Map" || n === "Set") return Array.from(o);
|
|
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
|
|
}
|
|
function _arrayLikeToArray(arr, len) {
|
|
if (len == null || len > arr.length) len = arr.length;
|
|
for (var i = 0, arr2 = new Array(len); i < len; i++) {
|
|
arr2[i] = arr[i];
|
|
}
|
|
return arr2;
|
|
}
|
|
function _defineProperties(target, props) {
|
|
for (var i = 0; i < props.length; i++) {
|
|
var descriptor = props[i];
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
|
descriptor.configurable = true;
|
|
if ("value" in descriptor) descriptor.writable = true;
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
|
}
|
|
}
|
|
function _createClass(Constructor, protoProps, staticProps) {
|
|
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
|
|
if (staticProps) _defineProperties(Constructor, staticProps);
|
|
Object.defineProperty(Constructor, "prototype", { writable: false });
|
|
return Constructor;
|
|
}
|
|
var hasSymbols = function() {
|
|
return typeof Symbol === "function";
|
|
};
|
|
var hasSymbol = function(name) {
|
|
return hasSymbols() && Boolean(Symbol[name]);
|
|
};
|
|
var getSymbol = function(name) {
|
|
return hasSymbol(name) ? Symbol[name] : "@@" + name;
|
|
};
|
|
if (hasSymbols() && !hasSymbol("observable")) {
|
|
Symbol.observable = Symbol("observable");
|
|
}
|
|
var SymbolIterator = getSymbol("iterator");
|
|
var SymbolObservable = getSymbol("observable");
|
|
var SymbolSpecies = getSymbol("species");
|
|
function getMethod(obj, key) {
|
|
var value = obj[key];
|
|
if (value == null) return void 0;
|
|
if (typeof value !== "function") throw new TypeError(value + " is not a function");
|
|
return value;
|
|
}
|
|
function getSpecies(obj) {
|
|
var ctor = obj.constructor;
|
|
if (ctor !== void 0) {
|
|
ctor = ctor[SymbolSpecies];
|
|
if (ctor === null) {
|
|
ctor = void 0;
|
|
}
|
|
}
|
|
return ctor !== void 0 ? ctor : Observable;
|
|
}
|
|
function isObservable(x) {
|
|
return x instanceof Observable;
|
|
}
|
|
function hostReportError(e) {
|
|
if (hostReportError.log) {
|
|
hostReportError.log(e);
|
|
} else {
|
|
setTimeout(function() {
|
|
throw e;
|
|
});
|
|
}
|
|
}
|
|
function enqueue(fn) {
|
|
Promise.resolve().then(function() {
|
|
try {
|
|
fn();
|
|
} catch (e) {
|
|
hostReportError(e);
|
|
}
|
|
});
|
|
}
|
|
function cleanupSubscription(subscription) {
|
|
var cleanup = subscription._cleanup;
|
|
if (cleanup === void 0) return;
|
|
subscription._cleanup = void 0;
|
|
if (!cleanup) {
|
|
return;
|
|
}
|
|
try {
|
|
if (typeof cleanup === "function") {
|
|
cleanup();
|
|
} else {
|
|
var unsubscribe = getMethod(cleanup, "unsubscribe");
|
|
if (unsubscribe) {
|
|
unsubscribe.call(cleanup);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
hostReportError(e);
|
|
}
|
|
}
|
|
function closeSubscription(subscription) {
|
|
subscription._observer = void 0;
|
|
subscription._queue = void 0;
|
|
subscription._state = "closed";
|
|
}
|
|
function flushSubscription(subscription) {
|
|
var queue = subscription._queue;
|
|
if (!queue) {
|
|
return;
|
|
}
|
|
subscription._queue = void 0;
|
|
subscription._state = "ready";
|
|
for (var i = 0; i < queue.length; ++i) {
|
|
notifySubscription(subscription, queue[i].type, queue[i].value);
|
|
if (subscription._state === "closed") break;
|
|
}
|
|
}
|
|
function notifySubscription(subscription, type, value) {
|
|
subscription._state = "running";
|
|
var observer = subscription._observer;
|
|
try {
|
|
var m = getMethod(observer, type);
|
|
switch (type) {
|
|
case "next":
|
|
if (m) m.call(observer, value);
|
|
break;
|
|
case "error":
|
|
closeSubscription(subscription);
|
|
if (m) m.call(observer, value);
|
|
else throw value;
|
|
break;
|
|
case "complete":
|
|
closeSubscription(subscription);
|
|
if (m) m.call(observer);
|
|
break;
|
|
}
|
|
} catch (e) {
|
|
hostReportError(e);
|
|
}
|
|
if (subscription._state === "closed") cleanupSubscription(subscription);
|
|
else if (subscription._state === "running") subscription._state = "ready";
|
|
}
|
|
function onNotify(subscription, type, value) {
|
|
if (subscription._state === "closed") return;
|
|
if (subscription._state === "buffering") {
|
|
subscription._queue.push({
|
|
type,
|
|
value
|
|
});
|
|
return;
|
|
}
|
|
if (subscription._state !== "ready") {
|
|
subscription._state = "buffering";
|
|
subscription._queue = [{
|
|
type,
|
|
value
|
|
}];
|
|
enqueue(function() {
|
|
return flushSubscription(subscription);
|
|
});
|
|
return;
|
|
}
|
|
notifySubscription(subscription, type, value);
|
|
}
|
|
var Subscription = function() {
|
|
function Subscription2(observer, subscriber) {
|
|
this._cleanup = void 0;
|
|
this._observer = observer;
|
|
this._queue = void 0;
|
|
this._state = "initializing";
|
|
var subscriptionObserver = new SubscriptionObserver(this);
|
|
try {
|
|
this._cleanup = subscriber.call(void 0, subscriptionObserver);
|
|
} catch (e) {
|
|
subscriptionObserver.error(e);
|
|
}
|
|
if (this._state === "initializing") this._state = "ready";
|
|
}
|
|
var _proto = Subscription2.prototype;
|
|
_proto.unsubscribe = function unsubscribe() {
|
|
if (this._state !== "closed") {
|
|
closeSubscription(this);
|
|
cleanupSubscription(this);
|
|
}
|
|
};
|
|
_createClass(Subscription2, [{
|
|
key: "closed",
|
|
get: function() {
|
|
return this._state === "closed";
|
|
}
|
|
}]);
|
|
return Subscription2;
|
|
}();
|
|
var SubscriptionObserver = function() {
|
|
function SubscriptionObserver2(subscription) {
|
|
this._subscription = subscription;
|
|
}
|
|
var _proto2 = SubscriptionObserver2.prototype;
|
|
_proto2.next = function next(value) {
|
|
onNotify(this._subscription, "next", value);
|
|
};
|
|
_proto2.error = function error(value) {
|
|
onNotify(this._subscription, "error", value);
|
|
};
|
|
_proto2.complete = function complete() {
|
|
onNotify(this._subscription, "complete");
|
|
};
|
|
_createClass(SubscriptionObserver2, [{
|
|
key: "closed",
|
|
get: function() {
|
|
return this._subscription._state === "closed";
|
|
}
|
|
}]);
|
|
return SubscriptionObserver2;
|
|
}();
|
|
var Observable = function() {
|
|
function Observable2(subscriber) {
|
|
if (!(this instanceof Observable2)) throw new TypeError("Observable cannot be called as a function");
|
|
if (typeof subscriber !== "function") throw new TypeError("Observable initializer must be a function");
|
|
this._subscriber = subscriber;
|
|
}
|
|
var _proto3 = Observable2.prototype;
|
|
_proto3.subscribe = function subscribe(observer) {
|
|
if (typeof observer !== "object" || observer === null) {
|
|
observer = {
|
|
next: observer,
|
|
error: arguments[1],
|
|
complete: arguments[2]
|
|
};
|
|
}
|
|
return new Subscription(observer, this._subscriber);
|
|
};
|
|
_proto3.forEach = function forEach3(fn) {
|
|
var _this = this;
|
|
return new Promise(function(resolve, reject) {
|
|
if (typeof fn !== "function") {
|
|
reject(new TypeError(fn + " is not a function"));
|
|
return;
|
|
}
|
|
function done() {
|
|
subscription.unsubscribe();
|
|
resolve();
|
|
}
|
|
var subscription = _this.subscribe({
|
|
next: function(value) {
|
|
try {
|
|
fn(value, done);
|
|
} catch (e) {
|
|
reject(e);
|
|
subscription.unsubscribe();
|
|
}
|
|
},
|
|
error: reject,
|
|
complete: resolve
|
|
});
|
|
});
|
|
};
|
|
_proto3.map = function map(fn) {
|
|
var _this2 = this;
|
|
if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
|
|
var C = getSpecies(this);
|
|
return new C(function(observer) {
|
|
return _this2.subscribe({
|
|
next: function(value) {
|
|
try {
|
|
value = fn(value);
|
|
} catch (e) {
|
|
return observer.error(e);
|
|
}
|
|
observer.next(value);
|
|
},
|
|
error: function(e) {
|
|
observer.error(e);
|
|
},
|
|
complete: function() {
|
|
observer.complete();
|
|
}
|
|
});
|
|
});
|
|
};
|
|
_proto3.filter = function filter(fn) {
|
|
var _this3 = this;
|
|
if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
|
|
var C = getSpecies(this);
|
|
return new C(function(observer) {
|
|
return _this3.subscribe({
|
|
next: function(value) {
|
|
try {
|
|
if (!fn(value)) return;
|
|
} catch (e) {
|
|
return observer.error(e);
|
|
}
|
|
observer.next(value);
|
|
},
|
|
error: function(e) {
|
|
observer.error(e);
|
|
},
|
|
complete: function() {
|
|
observer.complete();
|
|
}
|
|
});
|
|
});
|
|
};
|
|
_proto3.reduce = function reduce(fn) {
|
|
var _this4 = this;
|
|
if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
|
|
var C = getSpecies(this);
|
|
var hasSeed = arguments.length > 1;
|
|
var hasValue = false;
|
|
var seed = arguments[1];
|
|
var acc = seed;
|
|
return new C(function(observer) {
|
|
return _this4.subscribe({
|
|
next: function(value) {
|
|
var first = !hasValue;
|
|
hasValue = true;
|
|
if (!first || hasSeed) {
|
|
try {
|
|
acc = fn(acc, value);
|
|
} catch (e) {
|
|
return observer.error(e);
|
|
}
|
|
} else {
|
|
acc = value;
|
|
}
|
|
},
|
|
error: function(e) {
|
|
observer.error(e);
|
|
},
|
|
complete: function() {
|
|
if (!hasValue && !hasSeed) return observer.error(new TypeError("Cannot reduce an empty sequence"));
|
|
observer.next(acc);
|
|
observer.complete();
|
|
}
|
|
});
|
|
});
|
|
};
|
|
_proto3.concat = function concat() {
|
|
var _this5 = this;
|
|
for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
sources[_key] = arguments[_key];
|
|
}
|
|
var C = getSpecies(this);
|
|
return new C(function(observer) {
|
|
var subscription;
|
|
var index = 0;
|
|
function startNext(next) {
|
|
subscription = next.subscribe({
|
|
next: function(v) {
|
|
observer.next(v);
|
|
},
|
|
error: function(e) {
|
|
observer.error(e);
|
|
},
|
|
complete: function() {
|
|
if (index === sources.length) {
|
|
subscription = void 0;
|
|
observer.complete();
|
|
} else {
|
|
startNext(C.from(sources[index++]));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
startNext(_this5);
|
|
return function() {
|
|
if (subscription) {
|
|
subscription.unsubscribe();
|
|
subscription = void 0;
|
|
}
|
|
};
|
|
});
|
|
};
|
|
_proto3.flatMap = function flatMap(fn) {
|
|
var _this6 = this;
|
|
if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
|
|
var C = getSpecies(this);
|
|
return new C(function(observer) {
|
|
var subscriptions = [];
|
|
var outer = _this6.subscribe({
|
|
next: function(value) {
|
|
if (fn) {
|
|
try {
|
|
value = fn(value);
|
|
} catch (e) {
|
|
return observer.error(e);
|
|
}
|
|
}
|
|
var inner = C.from(value).subscribe({
|
|
next: function(value2) {
|
|
observer.next(value2);
|
|
},
|
|
error: function(e) {
|
|
observer.error(e);
|
|
},
|
|
complete: function() {
|
|
var i = subscriptions.indexOf(inner);
|
|
if (i >= 0) subscriptions.splice(i, 1);
|
|
completeIfDone();
|
|
}
|
|
});
|
|
subscriptions.push(inner);
|
|
},
|
|
error: function(e) {
|
|
observer.error(e);
|
|
},
|
|
complete: function() {
|
|
completeIfDone();
|
|
}
|
|
});
|
|
function completeIfDone() {
|
|
if (outer.closed && subscriptions.length === 0) observer.complete();
|
|
}
|
|
return function() {
|
|
subscriptions.forEach(function(s) {
|
|
return s.unsubscribe();
|
|
});
|
|
outer.unsubscribe();
|
|
};
|
|
});
|
|
};
|
|
_proto3[SymbolObservable] = function() {
|
|
return this;
|
|
};
|
|
Observable2.from = function from(x) {
|
|
var C = typeof this === "function" ? this : Observable2;
|
|
if (x == null) throw new TypeError(x + " is not an object");
|
|
var method = getMethod(x, SymbolObservable);
|
|
if (method) {
|
|
var observable = method.call(x);
|
|
if (Object(observable) !== observable) throw new TypeError(observable + " is not an object");
|
|
if (isObservable(observable) && observable.constructor === C) return observable;
|
|
return new C(function(observer) {
|
|
return observable.subscribe(observer);
|
|
});
|
|
}
|
|
if (hasSymbol("iterator")) {
|
|
method = getMethod(x, SymbolIterator);
|
|
if (method) {
|
|
return new C(function(observer) {
|
|
enqueue(function() {
|
|
if (observer.closed) return;
|
|
for (var _iterator = _createForOfIteratorHelperLoose(method.call(x)), _step; !(_step = _iterator()).done; ) {
|
|
var item = _step.value;
|
|
observer.next(item);
|
|
if (observer.closed) return;
|
|
}
|
|
observer.complete();
|
|
});
|
|
});
|
|
}
|
|
}
|
|
if (Array.isArray(x)) {
|
|
return new C(function(observer) {
|
|
enqueue(function() {
|
|
if (observer.closed) return;
|
|
for (var i = 0; i < x.length; ++i) {
|
|
observer.next(x[i]);
|
|
if (observer.closed) return;
|
|
}
|
|
observer.complete();
|
|
});
|
|
});
|
|
}
|
|
throw new TypeError(x + " is not observable");
|
|
};
|
|
Observable2.of = function of() {
|
|
for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
items[_key2] = arguments[_key2];
|
|
}
|
|
var C = typeof this === "function" ? this : Observable2;
|
|
return new C(function(observer) {
|
|
enqueue(function() {
|
|
if (observer.closed) return;
|
|
for (var i = 0; i < items.length; ++i) {
|
|
observer.next(items[i]);
|
|
if (observer.closed) return;
|
|
}
|
|
observer.complete();
|
|
});
|
|
});
|
|
};
|
|
_createClass(Observable2, null, [{
|
|
key: SymbolSpecies,
|
|
get: function() {
|
|
return this;
|
|
}
|
|
}]);
|
|
return Observable2;
|
|
}();
|
|
if (hasSymbols()) {
|
|
Object.defineProperty(Observable, Symbol("extensions"), {
|
|
value: {
|
|
symbol: SymbolObservable,
|
|
hostReportError
|
|
},
|
|
configurable: true
|
|
});
|
|
}
|
|
|
|
// node_modules/symbol-observable/es/ponyfill.js
|
|
function symbolObservablePonyfill(root2) {
|
|
var result2;
|
|
var Symbol2 = root2.Symbol;
|
|
if (typeof Symbol2 === "function") {
|
|
if (Symbol2.observable) {
|
|
result2 = Symbol2.observable;
|
|
} else {
|
|
if (typeof Symbol2.for === "function") {
|
|
result2 = Symbol2.for("https://github.com/benlesh/symbol-observable");
|
|
} else {
|
|
result2 = Symbol2("https://github.com/benlesh/symbol-observable");
|
|
}
|
|
try {
|
|
Symbol2.observable = result2;
|
|
} catch (err) {
|
|
}
|
|
}
|
|
} else {
|
|
result2 = "@@observable";
|
|
}
|
|
return result2;
|
|
}
|
|
|
|
// node_modules/symbol-observable/es/index.js
|
|
var root;
|
|
if (typeof self !== "undefined") {
|
|
root = self;
|
|
} else if (typeof window !== "undefined") {
|
|
root = window;
|
|
} else if (typeof global !== "undefined") {
|
|
root = global;
|
|
} else if (typeof module !== "undefined") {
|
|
root = module;
|
|
} else {
|
|
root = Function("return this")();
|
|
}
|
|
var result = symbolObservablePonyfill(root);
|
|
|
|
// node_modules/@apollo/client/utilities/observables/Observable.js
|
|
var prototype = Observable.prototype;
|
|
var fakeObsSymbol = "@@observable";
|
|
if (!prototype[fakeObsSymbol]) {
|
|
prototype[fakeObsSymbol] = function() {
|
|
return this;
|
|
};
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/promises/decoration.js
|
|
function createFulfilledPromise(value) {
|
|
var promise = Promise.resolve(value);
|
|
promise.status = "fulfilled";
|
|
promise.value = value;
|
|
return promise;
|
|
}
|
|
function createRejectedPromise(reason) {
|
|
var promise = Promise.reject(reason);
|
|
promise.catch(function() {
|
|
});
|
|
promise.status = "rejected";
|
|
promise.reason = reason;
|
|
return promise;
|
|
}
|
|
function isStatefulPromise(promise) {
|
|
return "status" in promise;
|
|
}
|
|
function wrapPromiseWithState(promise) {
|
|
if (isStatefulPromise(promise)) {
|
|
return promise;
|
|
}
|
|
var pendingPromise = promise;
|
|
pendingPromise.status = "pending";
|
|
pendingPromise.then(function(value) {
|
|
if (pendingPromise.status === "pending") {
|
|
var fulfilledPromise = pendingPromise;
|
|
fulfilledPromise.status = "fulfilled";
|
|
fulfilledPromise.value = value;
|
|
}
|
|
}, function(reason) {
|
|
if (pendingPromise.status === "pending") {
|
|
var rejectedPromise = pendingPromise;
|
|
rejectedPromise.status = "rejected";
|
|
rejectedPromise.reason = reason;
|
|
}
|
|
});
|
|
return promise;
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/promises/preventUnhandledRejection.js
|
|
function preventUnhandledRejection(promise) {
|
|
promise.catch(function() {
|
|
});
|
|
return promise;
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/common/cloneDeep.js
|
|
var toString = Object.prototype.toString;
|
|
function cloneDeep(value) {
|
|
return cloneDeepHelper(value);
|
|
}
|
|
function cloneDeepHelper(val, seen) {
|
|
switch (toString.call(val)) {
|
|
case "[object Array]": {
|
|
seen = seen || /* @__PURE__ */ new Map();
|
|
if (seen.has(val))
|
|
return seen.get(val);
|
|
var copy_1 = val.slice(0);
|
|
seen.set(val, copy_1);
|
|
copy_1.forEach(function(child, i) {
|
|
copy_1[i] = cloneDeepHelper(child, seen);
|
|
});
|
|
return copy_1;
|
|
}
|
|
case "[object Object]": {
|
|
seen = seen || /* @__PURE__ */ new Map();
|
|
if (seen.has(val))
|
|
return seen.get(val);
|
|
var copy_2 = Object.create(Object.getPrototypeOf(val));
|
|
seen.set(val, copy_2);
|
|
Object.keys(val).forEach(function(key) {
|
|
copy_2[key] = cloneDeepHelper(val[key], seen);
|
|
});
|
|
return copy_2;
|
|
}
|
|
default:
|
|
return val;
|
|
}
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/common/maybeDeepFreeze.js
|
|
function deepFreeze(value) {
|
|
var workSet = /* @__PURE__ */ new Set([value]);
|
|
workSet.forEach(function(obj) {
|
|
if (isNonNullObject(obj) && shallowFreeze(obj) === obj) {
|
|
Object.getOwnPropertyNames(obj).forEach(function(name) {
|
|
if (isNonNullObject(obj[name]))
|
|
workSet.add(obj[name]);
|
|
});
|
|
}
|
|
});
|
|
return value;
|
|
}
|
|
function shallowFreeze(obj) {
|
|
if (globalThis.__DEV__ !== false && !Object.isFrozen(obj)) {
|
|
try {
|
|
Object.freeze(obj);
|
|
} catch (e) {
|
|
if (e instanceof TypeError)
|
|
return null;
|
|
throw e;
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
function maybeDeepFreeze(obj) {
|
|
if (globalThis.__DEV__ !== false) {
|
|
deepFreeze(obj);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/observables/iteration.js
|
|
function iterateObserversSafely(observers, method, argument) {
|
|
var observersWithMethod = [];
|
|
observers.forEach(function(obs) {
|
|
return obs[method] && observersWithMethod.push(obs);
|
|
});
|
|
observersWithMethod.forEach(function(obs) {
|
|
return obs[method](argument);
|
|
});
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/observables/asyncMap.js
|
|
function asyncMap(observable, mapFn, catchFn) {
|
|
return new Observable(function(observer) {
|
|
var promiseQueue = {
|
|
// Normally we would initialize promiseQueue to Promise.resolve(), but
|
|
// in this case, for backwards compatibility, we need to be careful to
|
|
// invoke the first callback synchronously.
|
|
then: function(callback) {
|
|
return new Promise(function(resolve) {
|
|
return resolve(callback());
|
|
});
|
|
}
|
|
};
|
|
function makeCallback(examiner, key) {
|
|
return function(arg) {
|
|
if (examiner) {
|
|
var both = function() {
|
|
return observer.closed ? (
|
|
/* will be swallowed */
|
|
0
|
|
) : examiner(arg);
|
|
};
|
|
promiseQueue = promiseQueue.then(both, both).then(function(result2) {
|
|
return observer.next(result2);
|
|
}, function(error) {
|
|
return observer.error(error);
|
|
});
|
|
} else {
|
|
observer[key](arg);
|
|
}
|
|
};
|
|
}
|
|
var handler = {
|
|
next: makeCallback(mapFn, "next"),
|
|
error: makeCallback(catchFn, "error"),
|
|
complete: function() {
|
|
promiseQueue.then(function() {
|
|
return observer.complete();
|
|
});
|
|
}
|
|
};
|
|
var sub = observable.subscribe(handler);
|
|
return function() {
|
|
return sub.unsubscribe();
|
|
};
|
|
});
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/observables/subclassing.js
|
|
function fixObservableSubclass(subclass) {
|
|
function set(key) {
|
|
Object.defineProperty(subclass, key, { value: Observable });
|
|
}
|
|
if (canUseSymbol && Symbol.species) {
|
|
set(Symbol.species);
|
|
}
|
|
set("@@species");
|
|
return subclass;
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/observables/Concast.js
|
|
function isPromiseLike(value) {
|
|
return value && typeof value.then === "function";
|
|
}
|
|
var Concast = (
|
|
/** @class */
|
|
function(_super) {
|
|
__extends(Concast2, _super);
|
|
function Concast2(sources) {
|
|
var _this = _super.call(this, function(observer) {
|
|
_this.addObserver(observer);
|
|
return function() {
|
|
return _this.removeObserver(observer);
|
|
};
|
|
}) || this;
|
|
_this.observers = /* @__PURE__ */ new Set();
|
|
_this.promise = new Promise(function(resolve, reject) {
|
|
_this.resolve = resolve;
|
|
_this.reject = reject;
|
|
});
|
|
_this.handlers = {
|
|
next: function(result2) {
|
|
if (_this.sub !== null) {
|
|
_this.latest = ["next", result2];
|
|
_this.notify("next", result2);
|
|
iterateObserversSafely(_this.observers, "next", result2);
|
|
}
|
|
},
|
|
error: function(error) {
|
|
var sub = _this.sub;
|
|
if (sub !== null) {
|
|
if (sub)
|
|
setTimeout(function() {
|
|
return sub.unsubscribe();
|
|
});
|
|
_this.sub = null;
|
|
_this.latest = ["error", error];
|
|
_this.reject(error);
|
|
_this.notify("error", error);
|
|
iterateObserversSafely(_this.observers, "error", error);
|
|
}
|
|
},
|
|
complete: function() {
|
|
var _a = _this, sub = _a.sub, _b = _a.sources, sources2 = _b === void 0 ? [] : _b;
|
|
if (sub !== null) {
|
|
var value = sources2.shift();
|
|
if (!value) {
|
|
if (sub)
|
|
setTimeout(function() {
|
|
return sub.unsubscribe();
|
|
});
|
|
_this.sub = null;
|
|
if (_this.latest && _this.latest[0] === "next") {
|
|
_this.resolve(_this.latest[1]);
|
|
} else {
|
|
_this.resolve();
|
|
}
|
|
_this.notify("complete");
|
|
iterateObserversSafely(_this.observers, "complete");
|
|
} else if (isPromiseLike(value)) {
|
|
value.then(function(obs) {
|
|
return _this.sub = obs.subscribe(_this.handlers);
|
|
}, _this.handlers.error);
|
|
} else {
|
|
_this.sub = value.subscribe(_this.handlers);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
_this.nextResultListeners = /* @__PURE__ */ new Set();
|
|
_this.cancel = function(reason) {
|
|
_this.reject(reason);
|
|
_this.sources = [];
|
|
_this.handlers.error(reason);
|
|
};
|
|
_this.promise.catch(function(_) {
|
|
});
|
|
if (typeof sources === "function") {
|
|
sources = [new Observable(sources)];
|
|
}
|
|
if (isPromiseLike(sources)) {
|
|
sources.then(function(iterable) {
|
|
return _this.start(iterable);
|
|
}, _this.handlers.error);
|
|
} else {
|
|
_this.start(sources);
|
|
}
|
|
return _this;
|
|
}
|
|
Concast2.prototype.start = function(sources) {
|
|
if (this.sub !== void 0)
|
|
return;
|
|
this.sources = Array.from(sources);
|
|
this.handlers.complete();
|
|
};
|
|
Concast2.prototype.deliverLastMessage = function(observer) {
|
|
if (this.latest) {
|
|
var nextOrError = this.latest[0];
|
|
var method = observer[nextOrError];
|
|
if (method) {
|
|
method.call(observer, this.latest[1]);
|
|
}
|
|
if (this.sub === null && nextOrError === "next" && observer.complete) {
|
|
observer.complete();
|
|
}
|
|
}
|
|
};
|
|
Concast2.prototype.addObserver = function(observer) {
|
|
if (!this.observers.has(observer)) {
|
|
this.deliverLastMessage(observer);
|
|
this.observers.add(observer);
|
|
}
|
|
};
|
|
Concast2.prototype.removeObserver = function(observer) {
|
|
if (this.observers.delete(observer) && this.observers.size < 1) {
|
|
this.handlers.complete();
|
|
}
|
|
};
|
|
Concast2.prototype.notify = function(method, arg) {
|
|
var nextResultListeners = this.nextResultListeners;
|
|
if (nextResultListeners.size) {
|
|
this.nextResultListeners = /* @__PURE__ */ new Set();
|
|
nextResultListeners.forEach(function(listener) {
|
|
return listener(method, arg);
|
|
});
|
|
}
|
|
};
|
|
Concast2.prototype.beforeNext = function(callback) {
|
|
var called = false;
|
|
this.nextResultListeners.add(function(method, arg) {
|
|
if (!called) {
|
|
called = true;
|
|
callback(method, arg);
|
|
}
|
|
});
|
|
};
|
|
return Concast2;
|
|
}(Observable)
|
|
);
|
|
fixObservableSubclass(Concast);
|
|
|
|
// node_modules/@apollo/client/utilities/common/incrementalResult.js
|
|
function isExecutionPatchIncrementalResult(value) {
|
|
return "incremental" in value;
|
|
}
|
|
function isExecutionPatchInitialResult(value) {
|
|
return "hasNext" in value && "data" in value;
|
|
}
|
|
function isExecutionPatchResult(value) {
|
|
return isExecutionPatchIncrementalResult(value) || isExecutionPatchInitialResult(value);
|
|
}
|
|
function isApolloPayloadResult(value) {
|
|
return isNonNullObject(value) && "payload" in value;
|
|
}
|
|
function mergeIncrementalData(prevResult, result2) {
|
|
var mergedData = prevResult;
|
|
var merger = new DeepMerger();
|
|
if (isExecutionPatchIncrementalResult(result2) && isNonEmptyArray(result2.incremental)) {
|
|
result2.incremental.forEach(function(_a) {
|
|
var data = _a.data, path = _a.path;
|
|
for (var i = path.length - 1; i >= 0; --i) {
|
|
var key = path[i];
|
|
var isNumericKey = !isNaN(+key);
|
|
var parent_1 = isNumericKey ? [] : {};
|
|
parent_1[key] = data;
|
|
data = parent_1;
|
|
}
|
|
mergedData = merger.merge(mergedData, data);
|
|
});
|
|
}
|
|
return mergedData;
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/common/errorHandling.js
|
|
function graphQLResultHasError(result2) {
|
|
var errors = getGraphQLErrorsFromResult(result2);
|
|
return isNonEmptyArray(errors);
|
|
}
|
|
function getGraphQLErrorsFromResult(result2) {
|
|
var graphQLErrors = isNonEmptyArray(result2.errors) ? result2.errors.slice(0) : [];
|
|
if (isExecutionPatchIncrementalResult(result2) && isNonEmptyArray(result2.incremental)) {
|
|
result2.incremental.forEach(function(incrementalResult) {
|
|
if (incrementalResult.errors) {
|
|
graphQLErrors.push.apply(graphQLErrors, incrementalResult.errors);
|
|
}
|
|
});
|
|
}
|
|
return graphQLErrors;
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/common/compact.js
|
|
function compact() {
|
|
var objects = [];
|
|
for (var _i = 0; _i < arguments.length; _i++) {
|
|
objects[_i] = arguments[_i];
|
|
}
|
|
var result2 = /* @__PURE__ */ Object.create(null);
|
|
objects.forEach(function(obj) {
|
|
if (!obj)
|
|
return;
|
|
Object.keys(obj).forEach(function(key) {
|
|
var value = obj[key];
|
|
if (value !== void 0) {
|
|
result2[key] = value;
|
|
}
|
|
});
|
|
});
|
|
return result2;
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/common/mergeOptions.js
|
|
function mergeOptions(defaults, options) {
|
|
return compact(defaults, options, options.variables && {
|
|
variables: compact(__assign(__assign({}, defaults && defaults.variables), options.variables))
|
|
});
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/common/omitDeep.js
|
|
function omitDeep(value, key) {
|
|
return __omitDeep(value, key);
|
|
}
|
|
function __omitDeep(value, key, known) {
|
|
if (known === void 0) {
|
|
known = /* @__PURE__ */ new Map();
|
|
}
|
|
if (known.has(value)) {
|
|
return known.get(value);
|
|
}
|
|
var modified = false;
|
|
if (Array.isArray(value)) {
|
|
var array_1 = [];
|
|
known.set(value, array_1);
|
|
value.forEach(function(value2, index) {
|
|
var result2 = __omitDeep(value2, key, known);
|
|
modified || (modified = result2 !== value2);
|
|
array_1[index] = result2;
|
|
});
|
|
if (modified) {
|
|
return array_1;
|
|
}
|
|
} else if (isPlainObject(value)) {
|
|
var obj_1 = Object.create(Object.getPrototypeOf(value));
|
|
known.set(value, obj_1);
|
|
Object.keys(value).forEach(function(k) {
|
|
if (k === key) {
|
|
modified = true;
|
|
return;
|
|
}
|
|
var result2 = __omitDeep(value[k], key, known);
|
|
modified || (modified = result2 !== value[k]);
|
|
obj_1[k] = result2;
|
|
});
|
|
if (modified) {
|
|
return obj_1;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
|
|
// node_modules/@apollo/client/utilities/common/stripTypename.js
|
|
function stripTypename(value) {
|
|
return omitDeep(value, "__typename");
|
|
}
|
|
|
|
export {
|
|
shouldInclude,
|
|
getDirectiveNames,
|
|
hasAnyDirectives,
|
|
hasAllDirectives,
|
|
hasDirectives,
|
|
hasClientExports,
|
|
getInclusionDirectives,
|
|
getFragmentMaskMode,
|
|
Trie,
|
|
canUseWeakMap,
|
|
canUseWeakSet,
|
|
canUseSymbol,
|
|
canUseAsyncIteratorSymbol,
|
|
canUseDOM,
|
|
canUseLayoutEffect,
|
|
isNonNullObject,
|
|
isPlainObject,
|
|
getFragmentQueryDocument,
|
|
createFragmentMap,
|
|
getFragmentFromSelection,
|
|
isFullyUnmaskedOperation,
|
|
WeakCache,
|
|
AutoCleanedWeakCache,
|
|
AutoCleanedStrongCache,
|
|
cacheSizes,
|
|
getApolloClientMemoryInternals,
|
|
getInMemoryCacheMemoryInternals,
|
|
getApolloCacheMemoryInternals,
|
|
canonicalStringify,
|
|
makeReference,
|
|
isReference,
|
|
isDocumentNode,
|
|
valueToObjectRepresentation,
|
|
storeKeyNameFromField,
|
|
getStoreKeyName,
|
|
argumentsObjectFromField,
|
|
resultKeyNameFromField,
|
|
getTypenameFromResult,
|
|
isField,
|
|
isInlineFragment,
|
|
checkDocument,
|
|
getOperationDefinition,
|
|
getOperationName,
|
|
getFragmentDefinitions,
|
|
getQueryDefinition,
|
|
getFragmentDefinition,
|
|
getMainDefinition,
|
|
getDefaultValues,
|
|
Slot,
|
|
dep,
|
|
wrap,
|
|
DocumentTransform,
|
|
print,
|
|
isArray,
|
|
isNonEmptyArray,
|
|
removeDirectivesFromDocument,
|
|
addTypenameToDocument,
|
|
removeConnectionDirectiveFromDocument,
|
|
removeArgumentsFromDocument,
|
|
removeFragmentSpreadFromDocument,
|
|
buildQueryFromSelectionSet,
|
|
removeClientSetsFromDocument,
|
|
addNonReactiveToNamedFragments,
|
|
isMutationOperation,
|
|
isQueryOperation,
|
|
isSubscriptionOperation,
|
|
mergeDeep,
|
|
mergeDeepArray,
|
|
DeepMerger,
|
|
concatPagination,
|
|
offsetLimitPagination,
|
|
relayStylePagination,
|
|
Observable,
|
|
createFulfilledPromise,
|
|
createRejectedPromise,
|
|
isStatefulPromise,
|
|
wrapPromiseWithState,
|
|
preventUnhandledRejection,
|
|
cloneDeep,
|
|
maybeDeepFreeze,
|
|
iterateObserversSafely,
|
|
asyncMap,
|
|
fixObservableSubclass,
|
|
Concast,
|
|
isExecutionPatchIncrementalResult,
|
|
isExecutionPatchInitialResult,
|
|
isExecutionPatchResult,
|
|
isApolloPayloadResult,
|
|
mergeIncrementalData,
|
|
graphQLResultHasError,
|
|
getGraphQLErrorsFromResult,
|
|
compact,
|
|
mergeOptions,
|
|
omitDeep,
|
|
stripTypename
|
|
};
|
|
//# sourceMappingURL=chunk-5GBHNPGF.js.map
|