effect 4.0.0-beta.65 → 4.0.0-beta.67

package/dist/unstable/reactivity/Atom.js

@@ -1,4 +1,27 @@
 /**
+ * The `Atom` module defines reactive values and the helpers for constructing,
+ * composing, running, and persisting them with an `AtomRegistry`. Atoms are
+ * small read functions whose regular `get` reads form a dependency graph, so
+ * derived values are cached by the registry and invalidated when their
+ * dependencies, writable state, refresh hooks, or subscriptions change.
+ *
+ * Use atoms for application and UI state, derived data, `Effect` or `Stream`
+ * queries exposed as `AsyncResult`, writable function atoms for commands,
+ * subscription refs, pull-based streams, optimistic updates, URL search
+ * parameters, `KeyValueStore` entries, and serializable or server-specific
+ * hydration.
+ *
+ * The cache belongs to the registry, not the atom object: the same atom can have
+ * different values in different registries, and serializable atoms are keyed by
+ * their serialization key. Stable atom identity matters for dependency tracking
+ * and cache reuse, so use `family` for parameterized atoms. Unobserved atoms are
+ * disposed unless kept alive or retained by an idle TTL, which can cause derived
+ * state, effects, streams, and finalizers to be rebuilt later. Runtime-backed
+ * atoms run effects and streams with the registry scheduler, scope, and
+ * `AtomRuntime` layer context; `runtime.withReactivity` only refreshes after
+ * explicit `Reactivity` invalidations, while one-shot reads such as `once` do
+ * not create dependency edges.
+ *
  * @since 4.0.0
  */
 import * as Arr from "../../Array.js";
@@ -27,23 +50,31 @@ import { AtomRegistry } from "./AtomRegistry.js";
 import * as Registry from "./AtomRegistry.js";
 import * as Reactivity from "./Reactivity.js";
 /**
- * @since 4.0.0
+ * Runtime identifier attached to `Atom` values and used by `isAtom`.
+ *
  * @category type ids
+ * @since 4.0.0
  */
 export const TypeId = "~effect/reactivity/Atom";
 /**
- * @since 4.0.0
+ * Returns `true` when a value is an `Atom`.
+ *
  * @category Guards
+ * @since 4.0.0
  */
 export const isAtom = u => hasProperty(u, TypeId);
 /**
- * @since 4.0.0
+ * Runtime identifier attached to writable atoms and used by `isWritable`.
+ *
  * @category type ids
+ * @since 4.0.0
  */
 export const WritableTypeId = "~effect/reactivity/Atom/Writable";
 /**
- * @since 4.0.0
+ * Returns a copy of an atom with an idle time-to-live: finite durations dispose it after inactivity, while an infinite duration keeps it alive.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export const setIdleTTL = /*#__PURE__*/dual(2, (self, durationInput) => {
   const duration = Duration.fromInputUnsafe(durationInput);
@@ -133,13 +164,17 @@ const WritableProto = {
   [WritableTypeId]: WritableTypeId
 };
 /**
- * @since 4.0.0
+ * Returns `true` when an atom is writable.
+ *
  * @category refinements
+ * @since 4.0.0
  */
 export const isWritable = atom => WritableTypeId in atom;
 /**
- * @since 4.0.0
+ * Creates a read-only atom from a read function and an optional custom refresh registration callback.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const readable = (read, refresh) => {
   const self = Object.create(AtomProto);
@@ -150,8 +185,10 @@ export const readable = (read, refresh) => {
   return self;
 };
 /**
- * @since 4.0.0
+ * Creates a writable atom from read and write functions, with an optional custom refresh registration callback.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const writable = (read, write, refresh) => {
   const self = Object.create(WritableProto);
@@ -169,8 +206,10 @@ function constSetSelf(ctx, value) {
 // constructors
 // -----------------------------------------------------------------------------
 /**
- * @since 4.0.0
+ * Creates an atom from a synchronous value or read function, or from an `Effect` or `Stream` whose state is exposed as an `AsyncResult`; plain values create writable state atoms.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const make = (arg, options) => {
   const readOrAtom = makeRead(arg, options);
@@ -274,8 +313,10 @@ function runCallbackSync(services, effect, onExit, uninterruptible = false) {
   return cancel;
 }
 /**
- * @since 4.0.0
+ * Creates a `RuntimeFactory` backed by the supplied `Layer.MemoMap`.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const context = options => {
   let globalLayer = Reactivity.layer;
@@ -314,13 +355,17 @@ export const context = options => {
   return factory;
 };
 /**
- * @since 4.0.0
+ * Default `Layer.MemoMap` used by the module-level `runtime` factory.
+ *
  * @category context
+ * @since 4.0.0
  */
 export const defaultMemoMap = /*#__PURE__*/Layer.makeMemoMapUnsafe();
 /**
- * @since 4.0.0
+ * Default `RuntimeFactory` created with `defaultMemoMap`.
+ *
  * @category context
+ * @since 4.0.0
  */
 export const runtime = /*#__PURE__*/context({
   memoMap: defaultMemoMap
@@ -329,8 +374,8 @@ export const runtime = /*#__PURE__*/context({
  * An alias to `Rx.runtime.withReactivity`, for refreshing an atom whenever the
  * keys change in the `Reactivity` service.
  *
- * @since 4.0.0
  * @category Reactivity
+ * @since 4.0.0
  */
 export const withReactivity = runtime.withReactivity;
 // -----------------------------------------------------------------------------
@@ -382,8 +427,10 @@ function makeStream(ctx, stream, initialValue, services = Context.empty()) {
 // constructors - subscription ref
 // -----------------------------------------------------------------------------
 /**
- * @since 4.0.0
+ * Creates a writable atom backed by a `SubscriptionRef`, or by an effect that produces one, updating from ref changes and writing atom updates back to the ref.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const subscriptionRef = ref => makeSubRef(readable(get => {
   const value = typeof ref === "function" ? ref(get) : ref;
@@ -423,8 +470,10 @@ const makeSubRef = (refAtom, read) => {
   }, write);
 };
 /**
- * @since 4.0.0
+ * Creates a writable atom for a synchronous function; writing an argument re-runs the function, returning `Option.none` before the first call unless an initial value is supplied.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const fnSync = function (...args) {
   if (args.length === 0) {
@@ -451,18 +500,24 @@ const makeFnSync = (f, options) => {
   });
 };
 /**
- * @since 4.0.0
+ * Control symbol that can be written to an `AtomResultFn` to reset it to its initial state.
+ *
  * @category symbols
+ * @since 4.0.0
  */
 export const Reset = /*#__PURE__*/Symbol.for("effect/reactivity/atom/Atom/Reset");
 /**
- * @since 4.0.0
+ * Control symbol that can be written to an `AtomResultFn` to interrupt the current asynchronous computation.
+ *
  * @category symbols
+ * @since 4.0.0
  */
 export const Interrupt = /*#__PURE__*/Symbol.for("effect/reactivity/atom/Atom/Interrupt");
 /**
- * @since 4.0.0
+ * Creates a writable atom for an `Effect` or `Stream` function; writing an argument starts the computation and exposes its state as an `AsyncResult`.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const fn = function (...args) {
   if (args.length === 0) {
@@ -524,8 +579,10 @@ function makeResultFn(f, options) {
   return [read, write, argAtom];
 }
 /**
- * @since 4.0.0
+ * Creates a writable atom that pulls an initial chunk from a stream and then pulls the next chunk whenever it is written to, accumulating items unless `disableAccumulation` is enabled.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const pull = (create, options) => {
   const pullSignal = removeTtl(state(0));
@@ -588,8 +645,10 @@ const makeStreamPull = (pullSignal, pullAtom) => writable(pullAtom.read, functio
   ctx.set(pullSignal, ctx.get(pullSignal) + 1);
 });
 /**
- * @since 4.0.0
+ * Creates a memoized atom factory that returns the same object for the same argument, using weak references for cached values when the platform supports them.
+ *
  * @category constructors
+ * @since 4.0.0
  */
 export const family = typeof WeakRef === "undefined" || typeof FinalizationRegistry === "undefined" ? f => {
   const atoms = MutableHashMap.empty();
@@ -619,8 +678,10 @@ export const family = typeof WeakRef === "undefined" || typeof FinalizationRegis
   };
 };
 /**
- * @since 4.0.0
+ * Uses a fallback `AsyncResult` atom while the primary atom is `Initial`, marking the fallback result as waiting until the primary atom produces a non-initial result.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export const withFallback = /*#__PURE__*/dual(2, (self, fallback) => {
   function withFallback(get) {
@@ -637,8 +698,10 @@ export const withFallback = /*#__PURE__*/dual(2, (self, fallback) => {
   });
 });
 /**
- * @since 4.0.0
+ * Returns a copy of an atom that remains cached and mounted even when no subscribers are using it.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export const keepAlive = self => Object.assign(Object.create(Object.getPrototypeOf(self)), {
   ...self,
@@ -650,37 +713,59 @@ export const keepAlive = self => Object.assign(Object.create(Object.getPrototype
  *
  * Note that Atom's have this behavior by default.
  *
- * @since 4.0.0
  * @category combinators
+ * @since 4.0.0
  */
 export const autoDispose = self => Object.assign(Object.create(Object.getPrototypeOf(self)), {
   ...self,
   keepAlive: false
 });
 /**
- * @since 4.0.0
+ * Sets whether an atom should be lazy.
+ *
+ * Lazy atoms defer recomputation while they have no active listeners or active
+ * non-lazy dependents, rebuilding the next time their value is observed.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export const setLazy = /*#__PURE__*/dual(2, (self, lazy) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
   ...self,
   lazy
 }));
 /**
- * @since 4.0.0
+ * Attaches a diagnostic label to an atom.
+ *
+ * The label is used for inspection and debugging metadata and does not change the
+ * atom's read or write behavior.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export const withLabel = /*#__PURE__*/dual(2, (self, name) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
   ...self,
   label: [name, new Error().stack?.split("\n")[5] ?? ""]
 }));
 /**
- * @since 4.0.0
+ * Pairs an atom with an initial value for registry initialization.
+ *
+ * The returned tuple can be supplied to `AtomRegistry` initial values so the atom
+ * starts with the provided value before it is first rebuilt.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export const initialValue = /*#__PURE__*/dual(2, (self, initialValue) => [self, initialValue]);
 /**
- * @since 4.0.0
+ * Creates a derived atom by reading another atom with a custom `AtomContext`
+ * function.
+ *
+ * If the source is writable, the derived atom keeps the source write input and
+ * forwards writes to the source. `initialValueTarget` controls which atom receives
+ * preloaded initial values for the derived atom.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export const transform = /*#__PURE__*/dual(args => isAtom(args[0]), (self, f, options) => {
   const atom = removeTtl(isWritable(self) ? writable(get => f(get, self), function (ctx, value) {
@@ -704,18 +789,34 @@ const getInitialValueTarget = atom => {
   return target;
 };
 /**
- * @since 4.0.0
+ * Maps the current value of an atom with a pure function.
+ *
+ * When the source atom is writable, the returned atom remains writable and keeps
+ * the source atom's write input type.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export const map = /*#__PURE__*/dual(2, (self, f) => transform(self, get => f(get(self))));
 /**
- * @since 4.0.0
+ * Maps the successful value inside an `AsyncResult` atom.
+ *
+ * Initial and failure states are preserved, and writable source atoms keep their
+ * original write input type.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export const mapResult = /*#__PURE__*/dual(2, (self, f) => map(self, AsyncResult.map(f)));
 /**
- * @since 4.0.0
+ * Creates an atom that publishes source changes only after the source has stopped
+ * changing for the specified duration.
+ *
+ * The current source value is used immediately, and any pending debounce timer is
+ * cleared when the derived atom is disposed.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export const debounce = /*#__PURE__*/dual(2, (self, duration) => {
   const millis = Duration.toMillis(Duration.fromInputUnsafe(duration));
@@ -740,11 +841,13 @@ export const debounce = /*#__PURE__*/dual(2, (self, duration) => {
   });
 });
 /**
- * Ensures that the value of the atom is refreshed at most once per specified
- * duration.
+ * Creates a derived atom that reads the source and schedules a refresh after the
+ * specified duration.
+ *
+ * The scheduled refresh is canceled when the derived atom's lifetime is disposed.
  *
- * @since 4.0.0
  * @category combinators
+ * @since 4.0.0
  */
 export const withRefresh = /*#__PURE__*/dual(2, (self, duration) => {
   const millis = Duration.toMillis(Duration.fromInputUnsafe(duration));
@@ -767,8 +870,8 @@ export const withRefresh = /*#__PURE__*/dual(2, (self, duration) => {
  * background refresh on first mount. Use `revalidateOnFocus` to control
  * focus behavior. `true` respects `staleTime` and `"always"` forces refetch.
  *
- * @since 4.0.0
  * @category combinators
+ * @since 4.0.0
  */
 export const swr = /*#__PURE__*/dual(2, (self, options) => {
   const staleTime = Duration.toMillis(Duration.fromInputUnsafe(options.staleTime));
@@ -819,8 +922,15 @@ const shouldRevalidateSWR = (result, staleTime) => {
   return !isFreshWithin(timestamp, staleTime, Date.now());
 };
 /**
- * @since 4.0.0
+ * Wraps an atom in a writable optimistic atom.
+ *
+ * Writes accept transition atoms containing `AsyncResult` values. Waiting
+ * successes are shown optimistically while transitions run; when successful
+ * transitions finish, the source atom is refreshed, and failures roll the value
+ * back to the latest source value.
+ *
  * @category Optimistic
+ * @since 4.0.0
  */
 export const optimistic = self => {
   let counter = 0;
@@ -908,8 +1018,15 @@ export const optimistic = self => {
   }, (ctx, atom) => ctx.set(writeAtom, [++counter, atom]), refresh => refresh(self));
 };
 /**
- * @since 4.0.0
+ * Creates an `AtomResultFn` that applies an optimistic update before running the
+ * underlying mutation.
+ *
+ * The reducer computes the provisional value from the current value and mutation
+ * input. The wrapped function result then completes the transition or updates the
+ * optimistic value through the provided setter callback.
+ *
  * @category Optimistic
+ * @since 4.0.0
  */
 export const optimisticFn = /*#__PURE__*/dual(2, (self, options) => {
   const transition = removeTtl(state(AsyncResult.initial()));
@@ -940,16 +1057,26 @@ export const optimisticFn = /*#__PURE__*/dual(2, (self, options) => {
   });
 });
 /**
- * @since 4.0.0
+ * Runs synchronous atom updates as a batch.
+ *
+ * Stale nodes are rebuilt and listeners are notified after the callback completes,
+ * so dependent updates observe the final batched state.
+ *
  * @category batching
+ * @since 4.0.0
  */
 export const batch = Registry.batch;
 // -----------------------------------------------------------------------------
 // Focus
 // -----------------------------------------------------------------------------
 /**
- * @since 4.0.0
+ * A browser-only signal atom that increments when the document becomes visible.
+ *
+ * It listens for `visibilitychange` events on `window` and removes the listener
+ * when the atom is disposed.
+ *
  * @category Focus
+ * @since 4.0.0
  */
 export const windowFocusSignal = /*#__PURE__*/readable(get => {
   let count = 0;
@@ -965,8 +1092,14 @@ export const windowFocusSignal = /*#__PURE__*/readable(get => {
   return count;
 });
 /**
- * @since 4.0.0
+ * Creates a combinator that refreshes an atom whenever the supplied signal atom
+ * changes.
+ *
+ * The derived atom also subscribes to the source atom so normal source updates are
+ * forwarded to its own value.
+ *
  * @category Focus
+ * @since 4.0.0
  */
 export const makeRefreshOnSignal = signal => self => transform(self, get => {
   get.once(signal);
@@ -977,16 +1110,27 @@ export const makeRefreshOnSignal = signal => self => transform(self, get => {
   initialValueTarget: self
 });
 /**
- * @since 4.0.0
+ * Refreshes an atom whenever `windowFocusSignal` changes.
+ *
+ * This helper is browser-only because `windowFocusSignal` depends on `window` and
+ * `document.visibilityState`.
+ *
  * @category Focus
+ * @since 4.0.0
  */
 export const refreshOnWindowFocus = /*#__PURE__*/makeRefreshOnSignal(windowFocusSignal);
 // -----------------------------------------------------------------------------
 // KeyValueStore
 // -----------------------------------------------------------------------------
 /**
- * @since 4.0.0
+ * Creates a writable atom backed by a `KeyValueStore` entry.
+ *
+ * Values are encoded and decoded with the supplied schema. In sync mode the atom
+ * exposes the decoded value and writes the default value when the key is missing;
+ * in async mode it exposes an `AsyncResult` of the decoded value.
+ *
  * @category KeyValueStore
+ * @since 4.0.0
  */
 export const kvs = options => {
   const setAtom = options.runtime.fn(value => KeyValueStore.KeyValueStore.use(store => KeyValueStore.toSchemaStore(store, options.schema).set(options.key, value)));
@@ -1028,8 +1172,8 @@ export const kvs = options => {
  *
  * Note: If you pass a schema, it has to be synchronous and have no context.
  *
- * @since 4.0.0
  * @category URL search params
+ * @since 4.0.0
  */
 export const searchParam = (name, options) => {
   const decode = options?.schema && Schema.decodeExit(options.schema);
@@ -1100,66 +1244,108 @@ function updateSearchParams() {
 // conversions
 // -----------------------------------------------------------------------------
 /**
- * @since 4.0.0
+ * Converts an atom into a stream using the `AtomRegistry` service.
+ *
+ * The stream emits the atom's current value immediately and then emits subsequent
+ * changes until the stream scope is closed.
+ *
  * @category Conversions
+ * @since 4.0.0
  */
 export const toStream = self => Stream.unwrap(AtomRegistry.use(r => Effect.succeed(Registry.toStream(r, self))));
 /**
- * @since 4.0.0
+ * Converts an `AsyncResult` atom into a stream using the `AtomRegistry` service.
+ *
+ * Initial results are skipped, successes are emitted as stream values, and
+ * failures fail the stream with the result cause.
+ *
  * @category Conversions
+ * @since 4.0.0
  */
 export const toStreamResult = self => Stream.unwrap(AtomRegistry.use(r => Effect.succeed(Registry.toStreamResult(r, self))));
 /**
- * @since 4.0.0
+ * Reads an atom's current value from the `AtomRegistry` service.
+ *
  * @category Conversions
+ * @since 4.0.0
  */
 export const get = self => AtomRegistry.use(r => Effect.succeed(r.get(self)));
 /**
- * @since 4.0.0
+ * Reads a writable atom, computes a return value and next write value, writes the
+ * next value, and returns the computed result.
+ *
  * @category Conversions
+ * @since 4.0.0
  */
-export const modify = /*#__PURE__*/dual(2, (self, f) => Effect.map(AtomRegistry.asEffect(), _ => _.modify(self, f)));
+export const modify = /*#__PURE__*/dual(2, (self, f) => Effect.map(AtomRegistry, _ => _.modify(self, f)));
 /**
- * @since 4.0.0
+ * Writes a value to a writable atom through the `AtomRegistry` service.
+ *
  * @category Conversions
+ * @since 4.0.0
  */
-export const set = /*#__PURE__*/dual(2, (self, value) => Effect.map(AtomRegistry.asEffect(), _ => _.set(self, value)));
+export const set = /*#__PURE__*/dual(2, (self, value) => Effect.map(AtomRegistry, _ => _.set(self, value)));
 /**
- * @since 4.0.0
+ * Updates a writable atom by reading its current value from the registry and
+ * writing the value returned by the update function.
+ *
  * @category Conversions
+ * @since 4.0.0
  */
-export const update = /*#__PURE__*/dual(2, (self, f) => Effect.map(AtomRegistry.asEffect(), _ => _.update(self, f)));
+export const update = /*#__PURE__*/dual(2, (self, f) => Effect.map(AtomRegistry, _ => _.update(self, f)));
 /**
- * @since 4.0.0
+ * Reads an `AsyncResult` atom as an effect through the `AtomRegistry` service.
+ *
+ * The effect waits while the result is `Initial`, and also while it is waiting
+ * when `suspendOnWaiting` is enabled. Successes succeed with the value and
+ * failures fail with the result cause.
+ *
  * @category Conversions
+ * @since 4.0.0
  */
 export const getResult = (self, options) => AtomRegistry.use(Registry.getResult(self, options));
 /**
- * @since 4.0.0
+ * Requests a refresh of an atom through the `AtomRegistry` service.
+ *
  * @category Conversions
+ * @since 4.0.0
  */
-export const refresh = self => Effect.map(AtomRegistry.asEffect(), _ => _.refresh(self));
+export const refresh = self => Effect.map(AtomRegistry, _ => _.refresh(self));
 /**
- * @since 4.0.0
+ * Mounts an atom in the `AtomRegistry` for the lifetime of the current scope.
+ *
+ * Mounting keeps the atom subscribed with a no-op listener until the scope
+ * finalizer releases it.
+ *
  * @category Conversions
+ * @since 4.0.0
  */
 export const mount = self => AtomRegistry.use(r => Registry.mount(r, self));
 // -----------------------------------------------------------------------------
 // Serializable
 // -----------------------------------------------------------------------------
 /**
- * @since 4.0.0
+ * The type id used to mark atoms that carry serialization metadata.
+ *
  * @category Serializable
+ * @since 4.0.0
  */
 export const SerializableTypeId = "~effect-atom/atom/Atom/Serializable";
 /**
- * @since 4.0.0
+ * Returns `true` when an atom carries `Serializable` metadata.
+ *
  * @category Serializable
+ * @since 4.0.0
  */
 export const isSerializable = self => SerializableTypeId in self;
 /**
- * @since 4.0.0
+ * Attaches serialization metadata to an atom using a schema and stable key.
+ *
+ * The schema is converted to a JSON codec for synchronous encode/decode, and the
+ * key is also used as the atom label when the atom does not already have one.
+ *
  * @category combinators
+ * @since 4.0.0
  */
 export const serializable = /*#__PURE__*/dual(2, (self, options) => {
   const codecJson = Schema.toCodecJson(options.schema);
@@ -1174,30 +1360,38 @@ export const serializable = /*#__PURE__*/dual(2, (self, options) => {
   });
 });
 /**
- * @since 4.0.0
+ * The type id used to mark atoms with a server-side read override.
+ *
  * @category ServerValue
+ * @since 4.0.0
  */
 export const ServerValueTypeId = "~effect-atom/atom/Atom/ServerValue";
 /**
  * Overrides the value of an Atom when read on the server.
  *
- * @since 4.0.0
  * @category ServerValue
+ * @since 4.0.0
  */
 export const withServerValue = /*#__PURE__*/dual(2, (self, read) => Object.assign(Object.create(Object.getPrototypeOf(self)), {
   ...self,
   [ServerValueTypeId]: read
 }));
 /**
- * Sets the Atom's server value to `Result.initial(true)`.
+ * Sets an `AsyncResult` atom's server-side value to
+ * `AsyncResult.initial(true)`.
  *
- * @since 4.0.0
  * @category ServerValue
+ * @since 4.0.0
  */
 export const withServerValueInitial = self => withServerValue(self, constant(AsyncResult.initial(true)));
 /**
- * @since 4.0.0
+ * Reads an atom from a registry, using its server-side read override when one is
+ * present.
+ *
+ * Nested reads performed by the override are resolved against the same registry.
+ *
  * @category ServerValue
+ * @since 4.0.0
  */
 export const getServerValue = /*#__PURE__*/dual(2, (self, registry) => ServerValueTypeId in self ? self[ServerValueTypeId](atom => registry.get(atom)) : registry.get(self));
 //# sourceMappingURL=Atom.js.map