@warp-drive/legacy 5.9.0-alpha.21 → 5.9.0-alpha.23

package/dist/unpkg/dev/index.js

@@ -1,355 +1,277 @@
-import { Store, RequestManager, Fetch, CacheHandler, recordIdentifierFor } from '@warp-drive/core';
-import { SchemaService, registerDerivations, instantiateRecord as instantiateRecord$1, teardownRecord as teardownRecord$1 } from '@warp-drive/core/reactive';
-import { DefaultCachePolicy } from '@warp-drive/core/store';
-import { LegacyNetworkHandler, adapterFor, serializerFor, pushPayload, normalize, serializeRecord, cleanup } from './compat.js';
-import { EmberArrayLikeExtension, EmberObjectArrayExtension, EmberObjectExtension } from './compat/extensions.js';
-import '@ember/object';
-import '@warp-drive/core/types/symbols';
-import '@warp-drive/utilities/string';
-import '@warp-drive/core/store/-private';
-import "./errors-DngRU-If.js";
-import "./schema-provider-0D7f-QOn.js";
-import { i as instantiateRecord, t as teardownRecord, m as modelFor } from "./hooks-UuiLxWxS.js";
-import '@ember/application';
-import { registerDerivations as registerDerivations$1, DelegatingSchemaService } from './model/migration-support.js';
-import { F as FragmentExtension, a as FragmentArrayExtension, f as fragmentsModelFor } from "./model-for-CXkJw59V.js";
-import { restoreDeprecatedStoreBehaviors } from './store.js';
+import { a as serializeRecord, i as pushPayload, n as cleanup, o as serializerFor, r as normalize, s as LegacyNetworkHandler, t as adapterFor } from "./compat-B2O7jZLN.js";
+import { EmberArrayLikeExtension, EmberObjectArrayExtension, EmberObjectExtension } from "./compat/extensions.js";
+import { n as modelFor, r as teardownRecord$1, t as instantiateRecord$1 } from "./model-BrJ3pFM-.js";
+import { DelegatingSchemaService, registerDerivations as registerDerivations$1 } from "./model/migration-support.js";
+import { a as FragmentArrayExtension, s as FragmentExtension, t as fragmentsModelFor } from "./model-fragments-tlMYPSd_.js";
+import { t as restoreDeprecatedStoreBehaviors } from "./store-D_V8-HQl.js";
+import { CacheHandler, Fetch, RequestManager, Store, recordIdentifierFor } from "@warp-drive/core";
+import { SchemaService, instantiateRecord, registerDerivations, teardownRecord } from "@warp-drive/core/reactive";
+import { DefaultCachePolicy } from "@warp-drive/core/store";
 
+//#region src/index.ts
 /**
- * @module
- * @mergeModuleWith <project>
- */
-
+* @module
+* @mergeModuleWith <project>
+*/
 /**
- * Setup options for a legacy store configured to use `Model` with `linksMode`
- * enabled, meaning no legacy adapter/serializer request infrastructure is required.
- *
- * @public
- */
-
+* Setup options for a legacy store configured to use `Model` with `linksMode`
+* enabled, meaning no legacy adapter/serializer request infrastructure is required.
+*
+* @public
+*/
 /**
- * Setup options for a legacy store configured to use `Model` along with the
- * legacy adapter/serializer network layer, but without the deprecated
- * `store.findRecord`/`findAll`/`query`/etc. request methods.
- *
- * @public
- */
-
+* Setup options for a legacy store configured to use `Model` along with the
+* legacy adapter/serializer network layer, but without the deprecated
+* `store.findRecord`/`findAll`/`query`/etc. request methods.
+*
+* @public
+*/
 /**
- * Setup options for a legacy store configured to use `Model` along with the
- * legacy adapter/serializer network layer and the deprecated
- * `store.findRecord`/`findAll`/`query`/etc. request methods.
- *
- * @public
- */
-
-//export type ConfiguredStore<T = unknown> = typeof Store;
-
+* Setup options for a legacy store configured to use `Model` along with the
+* legacy adapter/serializer network layer and the deprecated
+* `store.findRecord`/`findAll`/`query`/etc. request methods.
+*
+* @public
+*/
 /**
- * The available options when setting up the legacy store,
- * one of:
- *
- * - {@link LegacyModelStoreSetupOptions}
- * - {@link LegacyModelAndNetworkStoreSetupOptions}
- * - {@link LegacyModelAndNetworkAndRequestStoreSetupOptions}
- */
-
+* The available options when setting up the legacy store,
+* one of:
+*
+* - {@link LegacyModelStoreSetupOptions}
+* - {@link LegacyModelAndNetworkStoreSetupOptions}
+* - {@link LegacyModelAndNetworkAndRequestStoreSetupOptions}
+*/
 /**
- * Use the legacy store with the given options.
- *
- * See {@link LegacyStoreSetupOptions} for details on the available options.
- *
- * ```ts
- * import { useLegacyStore } from '@warp-drive/legacy';
- * import { JSONAPICache } from '@warp-drive/json-api';
- *
- * export default useLegacyStore({
- *   linksMode: false,
- *   legacyRequests: true,
- *   cache: JSONAPICache,
- *   schemas: [],
- * });
- * ```
- *
- * ### Adding Stateful Handlers
- *
- * A request {@link Handler} is sometimes more than a plain object or class
- * with a `request` method — it may need access to a stateful dependency such
- * as an Ember service (an auth token, a feature-flags service, an i18n
- * helper, etc.).
- *
- * A plain class handler that only relies on Ember's `@service` decorator will
- * not work here on its own: the handler is never instantiated *through*
- * Ember's container (it's just `new`'d up), so it has no owner and its
- * `@service` injections would fail to resolve.
- *
- * Instead, give `handlers` a function. It receives the {@link Store} instance
- * being configured, which by the time the function runs already has an owner
- * assigned. Use `getOwner`/`setOwner` from `@ember/owner` to transfer that
- * owner onto your handler instance before returning it, exactly as you would
- * when constructing any other DI-aware object outside of the container:
- *
- * ```ts
- * import { getOwner, setOwner } from '@ember/owner';
- * import { service } from '@ember/service';
- * import { useLegacyStore } from '@warp-drive/legacy';
- * import type { NextFn } from '@warp-drive/core/request';
- * import type { RequestContext } from '@warp-drive/core/types/request';
- * import { JSONAPICache } from '@warp-drive/json-api';
- *
- * class AuthHandler {
- *   @service session;
- *
- *   request<T>(context: RequestContext, next: NextFn<T>) {
- *     const headers = new Headers(context.request.headers);
- *     headers.append('Authorization', `Bearer ${this.session.accessToken}`);
- *     return next(Object.assign({}, context.request, { headers }));
- *   }
- * }
- *
- * export default useLegacyStore({
- *   linksMode: false,
- *   legacyRequests: true,
- *   cache: JSONAPICache,
- *   handlers: (store) => {
- *     const authHandler = new AuthHandler();
- *     setOwner(authHandler, getOwner(store)!);
- *     return [authHandler];
- *   },
- * });
- * ```
- *
- * The `handlers` function is invoked lazily and only once per store instance,
- * the first time `store.requestManager` is accessed, so it is safe to do
- * owner-dependent setup like this inside of it.
- *
- * ### Accessing the Store from a Handler's Context
- *
- * If a handler only needs to read something *off of the store itself*
- * (its cache, or a property/service you've attached to a custom store
- * subclass) rather than an unrelated Ember service, there is a second,
- * simpler option that requires no DI/`setOwner` wiring at all.
- *
- * Every request issued via {@link Store.request | store.request(...)}
- * automatically carries the originating store along as
- * {@link RequestInfo.store | context.request.store}. Any handler — a plain
- * object, a function-built handler, or a class — can read it directly,
- * without needing the `handlers` callback form shown above:
- *
- * ```ts
- * import { useLegacyStore } from '@warp-drive/legacy';
- * import type { NextFn } from '@warp-drive/core/request';
- * import type { RequestContext } from '@warp-drive/core/types/request';
- * import { JSONAPICache } from '@warp-drive/json-api';
- *
- * const LoggingHandler = {
- *   request<T>(context: RequestContext, next: NextFn<T>) {
- *     // only present when the request was made via `store.request(...)`
- *     const store = context.request.store;
- *     if (store) {
- *       console.log(`[${store.constructor.name}] ${context.request.url ?? ''}`);
- *     }
- *     return next(context.request);
- *   },
- * };
- *
- * export default useLegacyStore({
- *   linksMode: false,
- *   legacyRequests: true,
- *   cache: JSONAPICache,
- *   handlers: [LoggingHandler],
- * });
- * ```
- *
- * The trade-off versus the `getOwner`/`setOwner` pattern above is that
- * `context.request.store` is only populated for requests issued via
- * `store.request(...)`; a request made directly against a
- * {@link RequestManager} won't have it set unless the caller supplies it
- * explicitly, so a handler relying on it should treat it as optional (as
- * `LoggingHandler` does above).
- */
-
+* Use the legacy store with the given options.
+*
+* See {@link LegacyStoreSetupOptions} for details on the available options.
+*
+* ```ts
+* import { useLegacyStore } from '@warp-drive/legacy';
+* import { JSONAPICache } from '@warp-drive/json-api';
+*
+* export default useLegacyStore({
+*   linksMode: false,
+*   legacyRequests: true,
+*   cache: JSONAPICache,
+*   schemas: [],
+* });
+* ```
+*
+* ### Adding Stateful Handlers
+*
+* A request {@link Handler} is sometimes more than a plain object or class
+* with a `request` method — it may need access to a stateful dependency such
+* as an Ember service (an auth token, a feature-flags service, an i18n
+* helper, etc.).
+*
+* A plain class handler that only relies on Ember's `@service` decorator will
+* not work here on its own: the handler is never instantiated *through*
+* Ember's container (it's just `new`'d up), so it has no owner and its
+* `@service` injections would fail to resolve.
+*
+* Instead, give `handlers` a function. It receives the {@link Store} instance
+* being configured, which by the time the function runs already has an owner
+* assigned. Use `getOwner`/`setOwner` from `@ember/owner` to transfer that
+* owner onto your handler instance before returning it, exactly as you would
+* when constructing any other DI-aware object outside of the container:
+*
+* ```ts
+* import { getOwner, setOwner } from '@ember/owner';
+* import { service } from '@ember/service';
+* import { useLegacyStore } from '@warp-drive/legacy';
+* import type { NextFn } from '@warp-drive/core/request';
+* import type { RequestContext } from '@warp-drive/core/types/request';
+* import { JSONAPICache } from '@warp-drive/json-api';
+*
+* class AuthHandler {
+*   @service session;
+*
+*   request<T>(context: RequestContext, next: NextFn<T>) {
+*     const headers = new Headers(context.request.headers);
+*     headers.append('Authorization', `Bearer ${this.session.accessToken}`);
+*     return next(Object.assign({}, context.request, { headers }));
+*   }
+* }
+*
+* export default useLegacyStore({
+*   linksMode: false,
+*   legacyRequests: true,
+*   cache: JSONAPICache,
+*   handlers: (store) => {
+*     const authHandler = new AuthHandler();
+*     setOwner(authHandler, getOwner(store)!);
+*     return [authHandler];
+*   },
+* });
+* ```
+*
+* The `handlers` function is invoked lazily and only once per store instance,
+* the first time `store.requestManager` is accessed, so it is safe to do
+* owner-dependent setup like this inside of it.
+*
+* ### Accessing the Store from a Handler's Context
+*
+* If a handler only needs to read something *off of the store itself*
+* (its cache, or a property/service you've attached to a custom store
+* subclass) rather than an unrelated Ember service, there is a second,
+* simpler option that requires no DI/`setOwner` wiring at all.
+*
+* Every request issued via {@link Store.request | store.request(...)}
+* automatically carries the originating store along as
+* {@link RequestInfo.store | context.request.store}. Any handler — a plain
+* object, a function-built handler, or a class — can read it directly,
+* without needing the `handlers` callback form shown above:
+*
+* ```ts
+* import { useLegacyStore } from '@warp-drive/legacy';
+* import type { NextFn } from '@warp-drive/core/request';
+* import type { RequestContext } from '@warp-drive/core/types/request';
+* import { JSONAPICache } from '@warp-drive/json-api';
+*
+* const LoggingHandler = {
+*   request<T>(context: RequestContext, next: NextFn<T>) {
+*     // only present when the request was made via `store.request(...)`
+*     const store = context.request.store;
+*     if (store) {
+*       console.log(`[${store.constructor.name}] ${context.request.url ?? ''}`);
+*     }
+*     return next(context.request);
+*   },
+* };
+*
+* export default useLegacyStore({
+*   linksMode: false,
+*   legacyRequests: true,
+*   cache: JSONAPICache,
+*   handlers: [LoggingHandler],
+* });
+* ```
+*
+* The trade-off versus the `getOwner`/`setOwner` pattern above is that
+* `context.request.store` is only populated for requests issued via
+* `store.request(...)`; a request made directly against a
+* {@link RequestManager} won't have it set unless the caller supplies it
+* explicitly, so a handler relying on it should treat it as optional (as
+* `LoggingHandler` does above).
+*/
 function useLegacyStore(options, StoreKlass = Store) {
-  (test => {
-    if (!test) {
-      throw new Error(`If legacyRequests is true, linksMode must be false`);
-    }
-  })(!(options.linksMode && options.legacyRequests));
-  // we extend the store to ensure we don't leak our prototype overrides to other stores below.
-  class BaseKlass extends StoreKlass {}
-  class LegacyConfiguredStore extends BaseKlass {
-    constructor(createArgs) {
-      super(createArgs);
-      // installed via defineProperty (rather than a class field/accessor) so that
-      // this lazy override of the inherited `requestManager` field does not
-      // conflict with the documented pattern of assigning it directly on
-      // consumer-authored Store subclasses. The setter preserves the ability
-      // to replace `requestManager` outright after construction.
-      let requestManager;
-      Object.defineProperty(this, 'requestManager', {
-        configurable: true,
-        enumerable: true,
-        get: () => {
-          if (!requestManager) {
-            const handlersOption = options.handlers;
-            const handlers = typeof handlersOption === 'function' ? handlersOption(this) : handlersOption ?? [];
-            requestManager = new RequestManager().use([options.linksMode ? null : LegacyNetworkHandler, ...handlers, Fetch].filter(Boolean)).useCache(CacheHandler);
-          }
-          return requestManager;
-        },
-        set: value => {
-          requestManager = value;
-        }
-      });
-    }
-    lifetimes = options.policy ?? new DefaultCachePolicy({
-      apiCacheHardExpires: 15 * 60 * 1000,
-      // 15 minutes
-      apiCacheSoftExpires: 1 * 30 * 1000,
-      // 30 seconds
-      constraints: {
-        headers: {
-          'X-WarpDrive-Expires': true,
-          'Cache-Control': true,
-          Expires: true
-        }
-      }
-    });
-    createSchemaService() {
-      // prepare for PolarisMode
-      const schema = new SchemaService();
-      registerDerivations(schema);
-      if (options.schemas) schema.registerResources(options.schemas);
-      if (options.traits) {
-        for (const trait of options.traits) {
-          schema.registerTrait(trait);
-        }
-      }
-      if (options.derivations) {
-        for (const derivation of options.derivations) {
-          schema.registerDerivation(derivation);
-        }
-      }
-      if (options.transformations) {
-        for (const transformation of options.transformations) {
-          schema.registerTransformation(transformation);
-        }
-      }
-      if (options.hashFns) {
-        for (const hashFn of options.hashFns) {
-          schema.registerHashFn(hashFn);
-        }
-      }
-      if (options.CAUTION_MEGA_DANGER_ZONE_extensions) {
-        for (const extension of options.CAUTION_MEGA_DANGER_ZONE_extensions) {
-          schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(extension);
-        }
-      }
-
-      // Add support for LegacyMode ReactiveResource with Maximal coverage
-      // for upgrading from 4.x
-      registerDerivations$1(schema);
-      schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberArrayLikeExtension);
-      schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectArrayExtension);
-      schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectExtension);
-
-      // add support for fragments
-      if (options.modelFragments) {
-        schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);
-        schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);
-      }
-
-      // Add fallback for Models
-      return new DelegatingSchemaService(this, schema);
-    }
-    createCache(capabilities) {
-      // eslint-disable-next-line new-cap
-      return new options.cache(capabilities);
-    }
-    instantiateRecord(key, createArgs) {
-      if (this.schema.isDelegated(key)) {
-        return instantiateRecord.call(this, key, createArgs);
-      }
-      return instantiateRecord$1(this, key, createArgs);
-    }
-    teardownRecord(record) {
-      const key = recordIdentifierFor(record);
-      if (this.schema.isDelegated(key)) {
-        return teardownRecord.call(this, record);
-      }
-      return teardownRecord$1(record);
-    }
-    modelFor(type) {
-      assertType(this.schema, type);
-      const klass =
-      // prefer real models if present
-      modelFor.call(this, type) || (
-      // fallback to ShimModelClass specific to fragments if fragments support in use
-      options.modelFragments ? fragmentsModelFor.call(this, type) : false) ||
-      // fallback to ShimModelClass
-      super.modelFor(type);
-      return klass;
-    }
-    adapterFor(modelName, _allowMissing) {
-      (test => {
-        if (!test) {
-          throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
-        }
-      })(!options.linksMode);
-      // @ts-expect-error
-      return adapterFor.call(this, modelName, _allowMissing);
-    }
-    serializerFor(...args) {
-      (test => {
-        if (!test) {
-          throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
-        }
-      })(!options.linksMode);
-      return serializerFor.call(this, ...args);
-    }
-    pushPayload(...args) {
-      (test => {
-        if (!test) {
-          throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
-        }
-      })(!options.linksMode);
-      return pushPayload.call(this, ...args);
-    }
-    normalize(...args) {
-      (test => {
-        if (!test) {
-          throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
-        }
-      })(!options.linksMode);
-      return normalize.call(this, ...args);
-    }
-    serializeRecord(...args) {
-      (test => {
-        if (!test) {
-          throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
-        }
-      })(!options.linksMode);
-      return serializeRecord.call(this, ...args);
-    }
-    destroy() {
-      if (!options.linksMode) {
-        cleanup.call(this);
-      }
-      super.destroy();
-    }
-  }
-  if (options.legacyRequests) {
-    restoreDeprecatedStoreBehaviors(BaseKlass);
-  }
-  return LegacyConfiguredStore;
+	((test) => {
+		if (!test) throw new Error(`If legacyRequests is true, linksMode must be false`);
+	})(!(options.linksMode && options.legacyRequests));
+	class BaseKlass extends StoreKlass {}
+	class LegacyConfiguredStore extends BaseKlass {
+		constructor(createArgs) {
+			super(createArgs);
+			let requestManager;
+			Object.defineProperty(this, "requestManager", {
+				configurable: true,
+				enumerable: true,
+				get: () => {
+					if (!requestManager) {
+						const handlersOption = options.handlers;
+						const handlers = typeof handlersOption === "function" ? handlersOption(this) : handlersOption ?? [];
+						requestManager = new RequestManager().use([
+							options.linksMode ? null : LegacyNetworkHandler,
+							...handlers,
+							Fetch
+						].filter(Boolean)).useCache(CacheHandler);
+					}
+					return requestManager;
+				},
+				set: (value) => {
+					requestManager = value;
+				}
+			});
+		}
+		lifetimes = options.policy ?? new DefaultCachePolicy({
+			apiCacheHardExpires: 9e5,
+			apiCacheSoftExpires: 3e4,
+			constraints: { headers: {
+				"X-WarpDrive-Expires": true,
+				"Cache-Control": true,
+				Expires: true
+			} }
+		});
+		createSchemaService() {
+			const schema = new SchemaService();
+			registerDerivations(schema);
+			if (options.schemas) schema.registerResources(options.schemas);
+			if (options.traits) for (const trait of options.traits) schema.registerTrait(trait);
+			if (options.derivations) for (const derivation of options.derivations) schema.registerDerivation(derivation);
+			if (options.transformations) for (const transformation of options.transformations) schema.registerTransformation(transformation);
+			if (options.hashFns) for (const hashFn of options.hashFns) schema.registerHashFn(hashFn);
+			if (options.CAUTION_MEGA_DANGER_ZONE_extensions) for (const extension of options.CAUTION_MEGA_DANGER_ZONE_extensions) schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(extension);
+			registerDerivations$1(schema);
+			schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberArrayLikeExtension);
+			schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectArrayExtension);
+			schema.CAUTION_MEGA_DANGER_ZONE_registerExtension(EmberObjectExtension);
+			if (options.modelFragments) {
+				schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentExtension);
+				schema.CAUTION_MEGA_DANGER_ZONE_registerExtension?.(FragmentArrayExtension);
+			}
+			return new DelegatingSchemaService(this, schema);
+		}
+		createCache(capabilities) {
+			return new options.cache(capabilities);
+		}
+		instantiateRecord(key, createArgs) {
+			if (this.schema.isDelegated(key)) return instantiateRecord$1.call(this, key, createArgs);
+			return instantiateRecord(this, key, createArgs);
+		}
+		teardownRecord(record) {
+			const key = recordIdentifierFor(record);
+			if (this.schema.isDelegated(key)) return teardownRecord$1.call(this, record);
+			return teardownRecord(record);
+		}
+		modelFor(type) {
+			assertType(this.schema, type);
+			return modelFor.call(this, type) || (options.modelFragments ? fragmentsModelFor.call(this, type) : false) || super.modelFor(type);
+		}
+		adapterFor(modelName, _allowMissing) {
+			((test) => {
+				if (!test) throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
+			})(!options.linksMode);
+			return adapterFor.call(this, modelName, _allowMissing);
+		}
+		serializerFor(...args) {
+			((test) => {
+				if (!test) throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
+			})(!options.linksMode);
+			return serializerFor.call(this, ...args);
+		}
+		pushPayload(...args) {
+			((test) => {
+				if (!test) throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
+			})(!options.linksMode);
+			return pushPayload.call(this, ...args);
+		}
+		normalize(...args) {
+			((test) => {
+				if (!test) throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
+			})(!options.linksMode);
+			return normalize.call(this, ...args);
+		}
+		serializeRecord(...args) {
+			((test) => {
+				if (!test) throw new Error(`useLegacyStore was setup in linksMode. linksMode assumes that all requests have been migrated away from adapters and serializers.`);
+			})(!options.linksMode);
+			return serializeRecord.call(this, ...args);
+		}
+		destroy() {
+			if (!options.linksMode) cleanup.call(this);
+			super.destroy();
+		}
+	}
+	if (options.legacyRequests) restoreDeprecatedStoreBehaviors(BaseKlass);
+	return LegacyConfiguredStore;
 }
 function assertType(schema, type) {
-  (test => {
-    if (!test) {
-      throw new Error(`Expected type ${type} to be a valid ResourceType`);
-    }
-  })(schema.hasResource({
-    type
-  }));
+	((test) => {
+		if (!test) throw new Error(`Expected type ${type} to be a valid ResourceType`);
+	})(schema.hasResource({ type }));
 }
-export { useLegacyStore };
+
+//#endregion
+export { useLegacyStore };
+//# sourceMappingURL=index.js.map