@warp-drive/core 5.10.0-alpha.7 → 5.10.0-alpha.8

package/dist/store/-private.js

@@ -1,3 +1,3 @@
-import { C as setRecordIdentifier, D as isResourceKey, E as isRequestKey, F as ensureStringId, I as log, L as logGroup, N as normalizeModelName, P as coerceId, S as recordIdentifierFor, T as assertPrivateCapabilities, _ as isPrivateStore, b as StoreMap, f as createLegacyManyArray, g as assertPrivateStore, h as Store, m as CacheHandler, p as constructResource, v as RecordArrayManager, w as storeFor, x as _clearCaches, y as fastPush } from "../src-CjNe_Kwe.js";
+import { C as setRecordIdentifier, D as isResourceKey, E as isRequestKey, F as ensureStringId, I as log, L as logGroup, N as normalizeModelName, P as coerceId, S as recordIdentifierFor, T as assertPrivateCapabilities, _ as isPrivateStore, b as StoreMap, f as createLegacyManyArray, g as assertPrivateStore, h as Store, m as CacheHandler, p as constructResource, v as RecordArrayManager, w as storeFor, x as _clearCaches, y as fastPush } from "../src-BVANmW9j.js";
 
 export { CacheHandler, RecordArrayManager, Store, StoreMap, _clearCaches, normalizeModelName as _deprecatingNormalize, assertPrivateCapabilities, assertPrivateStore, coerceId, constructResource, createLegacyManyArray, ensureStringId, fastPush, isPrivateStore, isRequestKey, isResourceKey, log, logGroup, recordIdentifierFor, setRecordIdentifier, storeFor };

package/dist/types/-private.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"-private.d.ts","names":[],"sources":["../../src/types/-private.ts"],"mappings":";KAMK;KAIA,8BACc;KAWd;KAWA,2BACc;KA8Gd,aAAa,0CAA0C;KACvD,eAAe,GAAG,oBAAoB,mBAAmB,aAAa,KAAK;;;;;;;;;;;;;;;;;;wBAmBhE,eAAe,GAAG,UAAU,WAAW,KAAK,GAAG,OAAO,IAAI,eAAe,GAAG;;;;;;;;;;;;wBAwB5E,cAAc,GAAG,KAAK,eAAe;;;;;;;;;wBAarC,aAAa,GAAG,KAAK,cAAc,OAAO,IAAI;;;;;;;;;;;wBAe9C,kBAAkB,GAAG,UAAU,cAAc,KAAK,GAAG,OAAO,IAAI,eAAe,GAAG;;;;;;;;wBAoBlF,uBAAuB,GAAG,KAAK,wBAAwB;;;;;;;;wBAYvD,sBAAsB,GAAG,KAAK,uBAAuB,OAAO,IAAI"}
+{"version":3,"file":"-private.d.ts","names":[],"sources":["../../src/types/-private.ts"],"mappings":";KAcK;KAIA,8BACc;KAWd;KAWA,2BACc;KA8Gd,aAAa,0CAA0C;KACvD,eAAe,GAAG,oBAAoB,mBAAmB,aAAa,KAAK;;;;;;;;;;;;;;;;;;wBAmBhE,eAAe,GAAG,UAAU,WAAW,KAAK,GAAG,OAAO,IAAI,eAAe,GAAG;;;;;;;;;;;;wBAwB5E,cAAc,GAAG,KAAK,eAAe;;;;;;;;;wBAarC,aAAa,GAAG,KAAK,cAAc,OAAO,IAAI;;;;;;;;;;;wBAe9C,kBAAkB,GAAG,UAAU,cAAc,KAAK,GAAG,OAAO,IAAI,eAAe,GAAG;;;;;;;;wBAoBlF,uBAAuB,GAAG,KAAK,wBAAwB;;;;;;;;wBAYvD,sBAAsB,GAAG,KAAK,uBAAuB,OAAO,IAAI"}

package/dist/types/-private.js

@@ -1,3 +1,117 @@
-import { a as setTransient, i as peekUniversalTransient, n as getOrSetUniversal, o as setUniversalTransient, r as peekTransient, t as getOrSetGlobal } from "../-private-vJakAjAP.js";
+import { getGlobalConfig, macroCondition } from "@embroider/macros";
 
-export { getOrSetGlobal, getOrSetUniversal, peekTransient, peekUniversalTransient, setTransient, setUniversalTransient };
+//#region src/types/-private.ts
+const name = "@warp-drive/core";
+const version = "5.10.0-alpha.8";
+const GlobalRef = globalThis;
+const UniversalCache = GlobalRef.__warpDrive_universalCache = GlobalRef.__warpDrive_universalCache ?? {};
+GlobalRef[name] = GlobalRef[name] ?? { __version: version };
+const GlobalSink = GlobalRef[name];
+if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
+	if (GlobalSink.__version !== version) throw new Error("Multiple versions of WarpDrive detected, the application will malfunction.");
+}
+const ModuleScopedCaches = GlobalSink.__warpDrive_ModuleScopedCaches ?? {};
+if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
+	if (!GlobalSink.__warpDrive_ModuleScopedCaches) GlobalSink.__warpDrive_ModuleScopedCaches = ModuleScopedCaches;
+	else console.warn(`
+Multiple copies of WarpDrive have been detected. This may be due to a bug in ember-auto-import
+  in which test assets get their own copy of some v2-addons. This can cause the application to
+  malfunction as each copy will maintain its own separate state.`);
+} else {
+	if (GlobalSink.__warpDrive_hasOtherCopy) throw new Error("Multiple copies of WarpDrive detected, the application will malfunction.");
+	GlobalSink.__warpDrive_hasOtherCopy = true;
+}
+/**
+* Coordinates creation of a singleton `value` (e.g. a symbol, WeakMap, or
+* error class) for `key` so that duplicate copies of this package loaded
+* into the same process observe the same instance instead of each creating
+* their own.
+*
+* In `TESTING` builds this stores/reads `value` from a cache namespaced to
+* this package's name on `globalThis` (see the file-level comments above for
+* why this is necessary). Outside of `TESTING`, only one copy of the package
+* is expected to exist, so this is a no-op that always returns `value`
+* unchanged.
+*
+* The return type lies about symbols being unique to work around the d.ts
+* rollup issue described in `reactive/-private/symbols.ts`.
+*
+* @private
+*/
+function getOrSetGlobal(key, value) {
+	if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
+		const existing = ModuleScopedCaches[key];
+		if (existing === void 0) return ModuleScopedCaches[key] = value;
+		else return existing;
+	} else return value;
+}
+/**
+* Reads back the current value stored for `key` by {@link setTransient}, or
+* `null` if nothing has been stored yet.
+*
+* Unlike {@link getOrSetGlobal}, this always reads through the same
+* package-namespaced cache regardless of the `TESTING` flag, since this is
+* used for genuinely mutable state (not just singleton values) that must
+* stay in sync across any duplicate copies of this package.
+*
+* @private
+*/
+function peekTransient(key) {
+	const globalKey = `(transient) ${key}`;
+	return ModuleScopedCaches[globalKey] ?? null;
+}
+/**
+* Stores `value` for `key`, overwriting whatever was previously stored, so
+* that it can later be read back via {@link peekTransient}.
+*
+* See {@link peekTransient} for details on when/why this cache is shared.
+*
+* @private
+*/
+function setTransient(key, value) {
+	const globalKey = `(transient) ${key}`;
+	return ModuleScopedCaches[globalKey] = value;
+}
+/**
+* Like {@link getOrSetGlobal}, but reads/writes a cache that is shared across
+* *all* copies of WarpDrive on `globalThis`, regardless of package name.
+*
+* This is used for keys (e.g. request/promise caches) that must be
+* coordinated even across "mirror" packages published under different
+* names, rather than only across duplicate copies of the same package name.
+*
+* @private
+*/
+function getOrSetUniversal(key, value) {
+	if (macroCondition(getGlobalConfig().WarpDrive.env.TESTING)) {
+		const existing = UniversalCache[key];
+		if (existing === void 0) return UniversalCache[key] = value;
+		else return existing;
+	} else return value;
+}
+/**
+* Like {@link peekTransient}, but reads from the package-name-independent
+* cache used by {@link getOrSetUniversal}. Always reads through this shared
+* cache regardless of the `TESTING` flag.
+*
+* @private
+*/
+function peekUniversalTransient(key) {
+	const globalKey = `(transient) ${key}`;
+	return UniversalCache[globalKey] ?? null;
+}
+/**
+* Like {@link setTransient}, but writes to the package-name-independent
+* cache used by {@link getOrSetUniversal}, so it can later be read via
+* {@link peekUniversalTransient}.
+*
+* @private
+*/
+function setUniversalTransient(key, value) {
+	const globalKey = `(transient) ${key}`;
+	return UniversalCache[globalKey] = value;
+}
+
+//#endregion
+export { getOrSetGlobal, getOrSetUniversal, peekTransient, peekUniversalTransient, setTransient, setUniversalTransient };
+//# sourceMappingURL=-private.js.map

package/dist/types/-private.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"-private.js","names":["getGlobalConfig","macroCondition","name","__WARP_DRIVE_PACKAGE_NAME__","version","__WARP_DRIVE_PACKAGE_VERSION__","GlobalRef","globalThis","UniversalCache","__warpDrive_universalCache","__version","GlobalSink","WarpDrive","env","DEBUG","Error","ModuleScopedCaches","__warpDrive_ModuleScopedCaches","TESTING","console","warn","__warpDrive_hasOtherCopy","getOrSetGlobal","key","value","existing","undefined","peekTransient","globalKey","setTransient","getOrSetUniversal","peekUniversalTransient","setUniversalTransient"],"sources":["../../src/types/-private.ts"],"sourcesContent":["// in testing mode, we utilize globals to ensure only one copy exists of\n// these maps, due to bugs in ember-auto-import\nimport { DEBUG, TESTING } from '@warp-drive/core/build-config/env';\n\n// Substituted at build time (see `tools/internal-config/tsdown/config.js`)\n// with this package's own `name`/`version` from its `package.json`. Reading\n// it via a static import instead would get inlined by tsdown as a synthetic\n// sourcemap source with empty `sourcesContent`, which points outside the\n// published package once the built chunk is re-bundled by a consumer.\ndeclare const __WARP_DRIVE_PACKAGE_NAME__: string;\ndeclare const __WARP_DRIVE_PACKAGE_VERSION__: string;\nconst name = __WARP_DRIVE_PACKAGE_NAME__;\nconst version = __WARP_DRIVE_PACKAGE_VERSION__;\n\ntype UniversalTransientKey =\n  // @warp-drive/core/request\n  'REQ_ID';\n\ntype UniversalKey =\n  | `(transient) ${UniversalTransientKey}`\n  // @warp-drive/core/request\n  | 'RequestMap'\n  | 'PromiseCache'\n  | 'RequestCache'\n  // @warp-drive/core-types/request\n  | 'SkipCache'\n  | 'EnableHydration'\n  // @warp-drive/core-types/runtime\n  | 'WarpDriveRuntimeConfig';\n\ntype TransientKey =\n  // @warp-drive/core/graph\n  | 'transactionRef'\n  // @warp-drive/core/store\n  | 'configuredGenerationMethod'\n  | 'configuredUpdateMethod'\n  | 'configuredForgetMethod'\n  | 'configuredResetMethod'\n  | 'configuredKeyInfoMethod'\n  | 'signalHooks';\n\ntype GlobalKey =\n  | `(transient) ${TransientKey}`\n  // @warp-drive/legacy/adapter\n  | 'AdapterError'\n  | 'InvalidError'\n  | 'TimeoutError'\n  | 'AbortError'\n  | 'UnauthorizedError'\n  | 'ForbiddenError'\n  | 'NotFoundError'\n  | 'ConflictError'\n  | 'ServerError'\n  // @warp-drive/core/store/reactivity\n  | '#{}'\n  | '#[]'\n  | 'Signals'\n  // @warp-drive/legacy LegacySupport\n  | 'AvailableShims'\n  // @warp-drive/core RecordArrayManager\n  | 'FAKE_ARR'\n  // @warp-drive/core ReactiveArray\n  | '#source'\n  | '#update'\n  | '#notify'\n  | 'IS_COLLECTION'\n  // @warp-drive/core RequestCache\n  | 'Touching'\n  | 'RequestPromise'\n  // @warp-drive/legacy/compat FetchManager\n  | 'SaveOp'\n  // @warp-drive/legacy Model\n  | 'LEGACY_SUPPORT'\n  | 'LegacySupport'\n  // @warp-drive/core/graph\n  | 'Graphs'\n  // @warp-drive/core/request\n  | 'IS_FROZEN'\n  | 'IS_CACHE_HANDLER'\n  // @warp-drive/utilities\n  | 'CONFIG'\n  // @warp-drive/core CacheKeyManager\n  | 'DEBUG_MAP'\n  | 'IDENTIFIERS'\n  | 'DOCUMENTS'\n  // @warp-drive/core InstanceCache\n  | 'RecordCache'\n  | 'StoreMap'\n  // @warp-drive/core/types/symbols\n  | 'Store'\n  | '$type'\n  | 'TransformName'\n  | 'RequestSignature'\n  // @warp-drive/core/types/request\n  | 'IS_FUTURE'\n  | 'DOC'\n  // @warp-drive/core NotificationManager\n  | 'UnscopedChannel'\n  // @warp-drive/core/reactive\n  | 'ManagedArrayMap'\n  | 'ManagedObjectMap'\n  | 'Support'\n  | 'SOURCE'\n  | 'Destroy'\n  | 'Checkout'\n  | 'Commit'\n  | 'Context';\n\ntype ModuleScopedCaches = Record<GlobalKey, unknown>;\n\nconst GlobalRef = globalThis as unknown as Record<\n  string,\n  {\n    __warpDrive_ModuleScopedCaches?: ModuleScopedCaches;\n    __warpDrive_hasOtherCopy?: boolean;\n    __version: string;\n  }\n> & {\n  __warpDrive_universalCache: Record<UniversalKey, unknown>;\n};\nconst UniversalCache = (GlobalRef.__warpDrive_universalCache =\n  GlobalRef.__warpDrive_universalCache ?? ({} as Record<UniversalKey, unknown>));\n\n// in order to support mirror packages, we ensure that each\n// unique package name has its own global cache\nGlobalRef[name] = GlobalRef[name] ?? { __version: version };\nconst GlobalSink = GlobalRef[name];\n\nif (DEBUG) {\n  if (GlobalSink.__version !== version) {\n    throw new Error('Multiple versions of WarpDrive detected, the application will malfunction.');\n  }\n}\n\nconst ModuleScopedCaches = GlobalSink.__warpDrive_ModuleScopedCaches ?? ({} as ModuleScopedCaches);\nif (TESTING) {\n  if (!GlobalSink.__warpDrive_ModuleScopedCaches) {\n    GlobalSink.__warpDrive_ModuleScopedCaches = ModuleScopedCaches;\n  } else {\n    // oxlint-disable-next-line no-console\n    console.warn(`\nMultiple copies of WarpDrive have been detected. This may be due to a bug in ember-auto-import\n  in which test assets get their own copy of some v2-addons. This can cause the application to\n  malfunction as each copy will maintain its own separate state.`);\n  }\n} else {\n  if (GlobalSink.__warpDrive_hasOtherCopy) {\n    throw new Error('Multiple copies of WarpDrive detected, the application will malfunction.');\n  }\n  GlobalSink.__warpDrive_hasOtherCopy = true;\n}\n\ntype UniqueSymbol<T extends string> = `___(unique) Symbol(${T})`;\ntype UniqueSymbolOr<T, K extends string> = T extends symbol ? UniqueSymbol<K> : T;\n\n/**\n * Coordinates creation of a singleton `value` (e.g. a symbol, WeakMap, or\n * error class) for `key` so that duplicate copies of this package loaded\n * into the same process observe the same instance instead of each creating\n * their own.\n *\n * In `TESTING` builds this stores/reads `value` from a cache namespaced to\n * this package's name on `globalThis` (see the file-level comments above for\n * why this is necessary). Outside of `TESTING`, only one copy of the package\n * is expected to exist, so this is a no-op that always returns `value`\n * unchanged.\n *\n * The return type lies about symbols being unique to work around the d.ts\n * rollup issue described in `reactive/-private/symbols.ts`.\n *\n * @private\n */\nexport function getOrSetGlobal<T, K extends GlobalKey>(key: K, value: T): UniqueSymbolOr<T, K> {\n  if (TESTING) {\n    const existing = ModuleScopedCaches[key];\n    if (existing === undefined) {\n      return (ModuleScopedCaches[key] = value) as UniqueSymbolOr<T, K>;\n    } else {\n      return existing as UniqueSymbolOr<T, K>;\n    }\n  } else {\n    return value as UniqueSymbolOr<T, K>;\n  }\n}\n\n/**\n * Reads back the current value stored for `key` by {@link setTransient}, or\n * `null` if nothing has been stored yet.\n *\n * Unlike {@link getOrSetGlobal}, this always reads through the same\n * package-namespaced cache regardless of the `TESTING` flag, since this is\n * used for genuinely mutable state (not just singleton values) that must\n * stay in sync across any duplicate copies of this package.\n *\n * @private\n */\nexport function peekTransient<T>(key: TransientKey): T | null {\n  const globalKey: `(transient) ${TransientKey}` = `(transient) ${key}`;\n  return (ModuleScopedCaches[globalKey] as T) ?? null;\n}\n\n/**\n * Stores `value` for `key`, overwriting whatever was previously stored, so\n * that it can later be read back via {@link peekTransient}.\n *\n * See {@link peekTransient} for details on when/why this cache is shared.\n *\n * @private\n */\nexport function setTransient<T>(key: TransientKey, value: T): T {\n  const globalKey: `(transient) ${TransientKey}` = `(transient) ${key}`;\n  return (ModuleScopedCaches[globalKey] = value);\n}\n\n/**\n * Like {@link getOrSetGlobal}, but reads/writes a cache that is shared across\n * *all* copies of WarpDrive on `globalThis`, regardless of package name.\n *\n * This is used for keys (e.g. request/promise caches) that must be\n * coordinated even across \"mirror\" packages published under different\n * names, rather than only across duplicate copies of the same package name.\n *\n * @private\n */\nexport function getOrSetUniversal<T, K extends UniversalKey>(key: K, value: T): UniqueSymbolOr<T, K> {\n  if (TESTING) {\n    const existing = UniversalCache[key];\n    if (existing === undefined) {\n      return (UniversalCache[key] = value) as UniqueSymbolOr<T, K>;\n    } else {\n      return existing as UniqueSymbolOr<T, K>;\n    }\n  } else {\n    return value as UniqueSymbolOr<T, K>;\n  }\n}\n\n/**\n * Like {@link peekTransient}, but reads from the package-name-independent\n * cache used by {@link getOrSetUniversal}. Always reads through this shared\n * cache regardless of the `TESTING` flag.\n *\n * @private\n */\nexport function peekUniversalTransient<T>(key: UniversalTransientKey): T | null {\n  const globalKey: `(transient) ${UniversalTransientKey}` = `(transient) ${key}`;\n  return (UniversalCache[globalKey] as T) ?? null;\n}\n\n/**\n * Like {@link setTransient}, but writes to the package-name-independent\n * cache used by {@link getOrSetUniversal}, so it can later be read via\n * {@link peekUniversalTransient}.\n *\n * @private\n */\nexport function setUniversalTransient<T>(key: UniversalTransientKey, value: T): T {\n  const globalKey: `(transient) ${UniversalTransientKey}` = `(transient) ${key}`;\n  return (UniversalCache[globalKey] = value);\n}\n"],"mappings":";;;AAWA,MAAME;AACN,MAAME;AAkGN,MAAME,YAAYC;AAUlB,MAAMC,iBAAkBF,UAAUG,6BAChCH,UAAUG,8BAA+B,CAAC;AAI5CH,UAAUJ,QAAQI,UAAUJ,SAAS,EAAEQ,WAAWN,QAAQ;AAC1D,MAAMO,aAAaL,UAAUJ;AAE7B,IAAAD,eAAAD,gBAAA,CAAA,CAAAY,UAAAC,IAAAC,KAAA,GACE;KAAIH,WAAWD,cAAcN,SAC3B,MAAM,IAAIW,MAAM,4EAA4E;AAC9F;AAGF,MAAMC,qBAAqBL,WAAWM,kCAAmC,CAAC;AAC1E,IAAAhB,eAAAD,gBAAA,CAAA,CAAAY,UAAAC,IAAAK,OAAA,GAAa;CACX,IAAI,CAACP,WAAWM,gCACdN,WAAWM,iCAAiCD;MAG5CG,QAAQC,KAAK;;;iEAGgD;AAEjE,OAAO;CACL,IAAIT,WAAWU,0BACb,MAAM,IAAIN,MAAM,0EAA0E;CAE5FJ,WAAWU,2BAA2B;AACxC;;;;;;;;;;;;;;;;;;AAsBA,SAAgBC,eAAuCC,KAAQC,OAAgC;CAC7F,IAAAvB,eAAAD,gBAAA,CAAA,CAAAY,UAAAC,IAAAK,OAAA,GAAa;EACX,MAAMO,WAAWT,mBAAmBO;EACpC,IAAIE,aAAaC,QACf,OAAQV,mBAAmBO,OAAOC;OAElC,OAAOC;CAEX,OACE,OAAOD;AAEX;;;;;;;;;;;;AAaA,SAAgBG,cAAiBJ,KAA6B;CAC5D,MAAMK,YAA2C,eAAeL;CAChE,OAAQP,mBAAmBY,cAAoB;AACjD;;;;;;;;;AAUA,SAAgBC,aAAgBN,KAAmBC,OAAa;CAC9D,MAAMI,YAA2C,eAAeL;CAChE,OAAQP,mBAAmBY,aAAaJ;AAC1C;;;;;;;;;;;AAYA,SAAgBM,kBAA6CP,KAAQC,OAAgC;CACnG,IAAAvB,eAAAD,gBAAA,CAAA,CAAAY,UAAAC,IAAAK,OAAA,GAAa;EACX,MAAMO,WAAWjB,eAAee;EAChC,IAAIE,aAAaC,QACf,OAAQlB,eAAee,OAAOC;OAE9B,OAAOC;CAEX,OACE,OAAOD;AAEX;;;;;;;;AASA,SAAgBO,uBAA0BR,KAAsC;CAC9E,MAAMK,YAAoD,eAAeL;CACzE,OAAQf,eAAeoB,cAAoB;AAC7C;;;;;;;;AASA,SAAgBI,sBAAyBT,KAA4BC,OAAa;CAChF,MAAMI,YAAoD,eAAeL;CACzE,OAAQf,eAAeoB,aAAaJ;AACtC"}

package/dist/types/request.js

@@ -1,4 +1,4 @@
-import { n as getOrSetUniversal, t as getOrSetGlobal } from "../-private-vJakAjAP.js";
+import { getOrSetGlobal, getOrSetUniversal } from "./-private.js";
 
 //#region src/types/request.ts
 /**

package/dist/types/runtime.js

@@ -1,4 +1,4 @@
-import { n as getOrSetUniversal } from "../-private-vJakAjAP.js";
+import { getOrSetUniversal } from "./-private.js";
 
 //#region src/types/runtime.ts
 /**

package/dist/types/symbols.js

@@ -1,4 +1,4 @@
-import { t as getOrSetGlobal } from "../-private-vJakAjAP.js";
+import { getOrSetGlobal } from "./-private.js";
 
 //#region src/types/symbols.ts
 /**

package/dist/unpkg/dev/{-private-BVekQ7LS.js → -private-DrQgwtNS.js}

@@ -1,5 +1,5 @@
-import { a as setTransient, r as peekTransient, t as getOrSetGlobal } from "./-private-qh-3RIJv.js";
-import { f as setPromiseResult, o as DOMError, u as getPromiseResult } from "./request-C21stEc9.js";
+import { getOrSetGlobal, peekTransient, setTransient } from "./types/-private.js";
+import { f as setPromiseResult, o as DOMError, u as getPromiseResult } from "./request-nAaeDlS9.js";
 
 //#region src/signals/reactivity/configure.ts
 const ARRAY_SIGNAL = getOrSetGlobal("#[]", Symbol("#[]"));
@@ -3516,4 +3516,4 @@ function getPromiseState(promise) {
 
 //#endregion
 export { ARRAY_SIGNAL as A, createInternalMemo as C, notifyInternalSignal as D, makeInitializer as E, setupSignals as M, waitFor as N, peekInternalSignal as O, willSyncFlushWatchers as P, consumeInternalSignal as S, getOrCreateInternalSignal as T, entangleSignal as _, getPaginationState as a, signal as b, getPaginationCache as c, getRequestState as d, createSignalDescriptor as f, entangleInitiallyStaleSignal as g, defineSignal as h, getPaginationLinks as i, OBJECT_SIGNAL as j, withSignalStore as k, DISPOSE as l, defineNonEnumerableSignal as m, createPaginationLinksSubscription as n, clearPaginationCache as o, defineGate as p, createPaginationSubscription as r, defaultPageHints as s, getPromiseState as t, createRequestSubscription as u, gate as v, createInternalSignal as w, Signals as x, memoized as y };
-//# sourceMappingURL=-private-BVekQ7LS.js.map
+//# sourceMappingURL=-private-DrQgwtNS.js.map