@politie/sherlock-rxjs 3.4.21 → 3.4.23

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@politie/sherlock-rxjs",
-    "version": "3.4.21",
+    "version": "3.4.23",
     "description": "An extension to Sherlock that provides interop with RxJS.",
     "main": "sherlock-rxjs.cjs.js",
     "module": "sherlock-rxjs.esm.js",
@@ -38,7 +38,7 @@
         "tslib": "^2.2.0"
     },
     "peerDependencies": {
-        "@politie/sherlock": "3.4.21",
+        "@politie/sherlock": "3.4.23",
         "rxjs": "^5.4.0 || ^6.0.0 || ^7.0.0 "
     }
 }

package/rxjs.test.d.ts

@@ -0,0 +1 @@
+import 'expect-more-jest';

package/sherlock-rxjs.cjs.min.js

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,"__esModule",{value:!0});var r=require("@politie/sherlock"),n=require("rxjs");exports.fromObservable=function(n){var e,t=r.atom.unresolved();return t.connected$.react((function(){t.connected&&!e&&(e=n.subscribe({next:function(r){return t.set(r)},error:function(n){return t.setFinal(new r.ErrorWrapper(n))},complete:function(){return t.setFinal(t.getState())}})),!t.connected&&e&&(e.unsubscribe(),e=void 0)})),t},exports.toObservable=function(e,t){return new n.Observable((function(n){return r._internal.Reactor.create(e,(function(r){return n.next(r)}),t,(function(){return n.closed||n.complete()}))}))};
+Object.defineProperty(exports,"__esModule",{value:!0});var r=require("@politie/sherlock"),n=require("rxjs");exports.fromObservable=function(n){var e,t=r.atom.unresolved();return t.connected$.react(function(){t.connected&&!e&&(e=n.subscribe({next:function(r){return t.set(r)},error:function(n){return t.setFinal(new r.ErrorWrapper(n))},complete:function(){return t.setFinal(t.getState())}})),!t.connected&&e&&(e.unsubscribe(),e=void 0)}),t},exports.toObservable=function(e,t){return new n.Observable(function(n){return r._internal.Reactor.create(e,function(r){return n.next(r)},t,function(){return n.closed||n.complete()})})};
 //# sourceMappingURL=sherlock-rxjs.cjs.min.js.map

package/sherlock-rxjs.cjs.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-rxjs.cjs.min.js","names":["observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","next","value","set","error","err","setFinal","ErrorWrapper","complete","getState","unsubscribe","undefined","derivable","options","Observable","subscriber","_internal","Reactor","create","closed"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"mIAmBM,SAA4BA,GAC9B,IAEIC,EAFEC,EAAQC,OAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,OAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,UAAU,CAChCC,KAAM,SAAAC,GAAS,OAAAR,EAAMS,IAAID,EAAM,EAC/BE,MAAO,SAAAC,GAAO,OAAAX,EAAMY,SAAS,IAAIC,eAAaF,GAAK,EACnDG,SAAU,WAAM,OAAAd,EAAMY,SAASZ,EAAMe,WAAW,MAKnDf,EAAMK,WAAaN,IACpBA,EAAaiB,cACbjB,OAAekB,EAEvB,IAEOjB,CACX,E,qBA/BgB,SAAgBkB,EAAyBC,GACrD,OAAO,IAAIC,cAAc,SAACC,GACtB,OAAOC,YAAUC,QAAQC,OAAON,GAC5B,SAAAV,GAAS,OAAAa,EAAWd,KAAKC,EAAhB,GACTW,GACA,WAAM,OAAAE,EAAWI,QAAUJ,EAAWP,UAAhC,GAEd,GACJ","ignoreList":[]}
+{"version":3,"file":"sherlock-rxjs.cjs.min.js","names":["observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","next","value","set","error","err","setFinal","ErrorWrapper","complete","getState","unsubscribe","undefined","derivable","options","Observable","subscriber","_internal","Reactor","create","closed"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"mIAmBM,SAA4BA,GAC9B,IAEIC,EAFEC,EAAQC,OAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,MAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,UAAU,CAChCC,KAAM,SAAAC,GAAS,OAAAR,EAAMS,IAAID,EAAM,EAC/BE,MAAO,SAAAC,GAAO,OAAAX,EAAMY,SAAS,IAAIC,eAAaF,GAAK,EACnDG,SAAU,WAAM,OAAAd,EAAMY,SAASZ,EAAMe,WAAW,MAKnDf,EAAMK,WAAaN,IACpBA,EAAaiB,cACbjB,OAAekB,EAEvB,GAEOjB,CACX,E,qBA/BgB,SAAgBkB,EAAyBC,GACrD,OAAO,IAAIC,aAAc,SAACC,GACtB,OAAOC,YAAUC,QAAQC,OAAON,EAC5B,SAAAV,GAAS,OAAAa,EAAWd,KAAKC,EAAhB,EACTW,EACA,WAAM,OAAAE,EAAWI,QAAUJ,EAAWP,UAAhC,EAEd,EACJ","ignoreList":[]}

package/sherlock-rxjs.esm.min.js

@@ -1,2 +1,2 @@
-import{_internal as n,atom as r,ErrorWrapper as t}from"@politie/sherlock";import{Observable as o}from"rxjs";function e(r,t){return new o((function(o){return n.Reactor.create(r,(function(n){return o.next(n)}),t,(function(){return o.closed||o.complete()}))}))}function u(n){var o,e=r.unresolved();return e.connected$.react((function(){e.connected&&!o&&(o=n.subscribe({next:function(n){return e.set(n)},error:function(n){return e.setFinal(new t(n))},complete:function(){return e.setFinal(e.getState())}})),!e.connected&&o&&(o.unsubscribe(),o=void 0)})),e}export{u as fromObservable,e as toObservable};
+import{_internal as n,atom as r,ErrorWrapper as t}from"@politie/sherlock";import{Observable as o}from"rxjs";function e(r,t){return new o(function(o){return n.Reactor.create(r,function(n){return o.next(n)},t,function(){return o.closed||o.complete()})})}function u(n){var o,e=r.unresolved();return e.connected$.react(function(){e.connected&&!o&&(o=n.subscribe({next:function(n){return e.set(n)},error:function(n){return e.setFinal(new t(n))},complete:function(){return e.setFinal(e.getState())}})),!e.connected&&o&&(o.unsubscribe(),o=void 0)}),e}export{u as fromObservable,e as toObservable};
 //# sourceMappingURL=sherlock-rxjs.esm.min.js.map

package/sherlock-rxjs.esm.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-rxjs.esm.min.js","names":["toObservable","derivable","options","Observable","subscriber","_internal","Reactor","create","value","next","closed","complete","fromObservable","observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","set","error","err","setFinal","ErrorWrapper","getState","unsubscribe","undefined"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"4GASgB,SAAAA,EAAgBC,EAAyBC,GACrD,OAAO,IAAIC,GAAc,SAACC,GACtB,OAAOC,EAAUC,QAAQC,OAAON,GAC5B,SAAAO,GAAS,OAAAJ,EAAWK,KAAKD,EAAhB,GACTN,GACA,WAAM,OAAAE,EAAWM,QAAUN,EAAWO,UAAhC,GAEd,GACJ,CAEM,SAAUC,EAAkBC,GAC9B,IAEIC,EAFEC,EAAQC,EAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,OAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,UAAU,CAChCZ,KAAM,SAAAD,GAAS,OAAAO,EAAMO,IAAId,EAAM,EAC/Be,MAAO,SAAAC,GAAO,OAAAT,EAAMU,SAAS,IAAIC,EAAaF,GAAK,EACnDb,SAAU,WAAM,OAAAI,EAAMU,SAASV,EAAMY,WAAW,MAKnDZ,EAAMK,WAAaN,IACpBA,EAAac,cACbd,OAAee,EAEvB,IAEOd,CACX,Q","ignoreList":[]}
+{"version":3,"file":"sherlock-rxjs.esm.min.js","names":["toObservable","derivable","options","Observable","subscriber","_internal","Reactor","create","value","next","closed","complete","fromObservable","observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","set","error","err","setFinal","ErrorWrapper","getState","unsubscribe","undefined"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"4GASgB,SAAAA,EAAgBC,EAAyBC,GACrD,OAAO,IAAIC,EAAc,SAACC,GACtB,OAAOC,EAAUC,QAAQC,OAAON,EAC5B,SAAAO,GAAS,OAAAJ,EAAWK,KAAKD,EAAhB,EACTN,EACA,WAAM,OAAAE,EAAWM,QAAUN,EAAWO,UAAhC,EAEd,EACJ,CAEM,SAAUC,EAAkBC,GAC9B,IAEIC,EAFEC,EAAQC,EAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,MAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,UAAU,CAChCZ,KAAM,SAAAD,GAAS,OAAAO,EAAMO,IAAId,EAAM,EAC/Be,MAAO,SAAAC,GAAO,OAAAT,EAAMU,SAAS,IAAIC,EAAaF,GAAK,EACnDb,SAAU,WAAM,OAAAI,EAAMU,SAASV,EAAMY,WAAW,MAKnDZ,EAAMK,WAAaN,IACpBA,EAAac,cACbd,OAAee,EAEvB,GAEOd,CACX,Q","ignoreList":[]}

package/sherlock-rxjs.umd.min.js

@@ -1,2 +1,2 @@
-!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports,require("@politie/sherlock"),require("rxjs")):"function"==typeof define&&define.amd?define(["exports","@politie/sherlock","rxjs"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).SherlockRxjs={},e.Sherlock,e.Rx)}(this,(function(e,n,t){"use strict";e.fromObservable=function(e){var t,r=n.atom.unresolved();return r.connected$.react((function(){r.connected&&!t&&(t=e.subscribe({next:function(e){return r.set(e)},error:function(e){return r.setFinal(new n.ErrorWrapper(e))},complete:function(){return r.setFinal(r.getState())}})),!r.connected&&t&&(t.unsubscribe(),t=void 0)})),r},e.toObservable=function(e,r){return new t.Observable((function(t){return n._internal.Reactor.create(e,(function(e){return t.next(e)}),r,(function(){return t.closed||t.complete()}))}))},Object.defineProperty(e,"__esModule",{value:!0})}));
+!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports,require("@politie/sherlock"),require("rxjs")):"function"==typeof define&&define.amd?define(["exports","@politie/sherlock","rxjs"],n):n((e="undefined"!=typeof globalThis?globalThis:e||self).SherlockRxjs={},e.Sherlock,e.Rx)}(this,function(e,n,t){"use strict";e.fromObservable=function(e){var t,r=n.atom.unresolved();return r.connected$.react(function(){r.connected&&!t&&(t=e.subscribe({next:function(e){return r.set(e)},error:function(e){return r.setFinal(new n.ErrorWrapper(e))},complete:function(){return r.setFinal(r.getState())}})),!r.connected&&t&&(t.unsubscribe(),t=void 0)}),r},e.toObservable=function(e,r){return new t.Observable(function(t){return n._internal.Reactor.create(e,function(e){return t.next(e)},r,function(){return t.closed||t.complete()})})},Object.defineProperty(e,"__esModule",{value:!0})});
 //# sourceMappingURL=sherlock-rxjs.umd.min.js.map

package/sherlock-rxjs.umd.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"sherlock-rxjs.umd.min.js","names":["observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","next","value","set","error","err","setFinal","ErrorWrapper","complete","getState","unsubscribe","undefined","derivable","options","Observable","subscriber","_internal","Reactor","create","closed"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"iWAmBM,SAA4BA,GAC9B,IAEIC,EAFEC,EAAQC,OAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,OAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,UAAU,CAChCC,KAAM,SAAAC,GAAS,OAAAR,EAAMS,IAAID,EAAM,EAC/BE,MAAO,SAAAC,GAAO,OAAAX,EAAMY,SAAS,IAAIC,eAAaF,GAAK,EACnDG,SAAU,WAAM,OAAAd,EAAMY,SAASZ,EAAMe,WAAW,MAKnDf,EAAMK,WAAaN,IACpBA,EAAaiB,cACbjB,OAAekB,EAEvB,IAEOjB,CACX,E,eA/BgB,SAAgBkB,EAAyBC,GACrD,OAAO,IAAIC,cAAc,SAACC,GACtB,OAAOC,YAAUC,QAAQC,OAAON,GAC5B,SAAAV,GAAS,OAAAa,EAAWd,KAAKC,EAAhB,GACTW,GACA,WAAM,OAAAE,EAAWI,QAAUJ,EAAWP,UAAhC,GAEd,GACJ,E","ignoreList":[]}
+{"version":3,"file":"sherlock-rxjs.umd.min.js","names":["observable","subscription","atom$","atom","unresolved","connected$","react","connected","subscribe","next","value","set","error","err","setFinal","ErrorWrapper","complete","getState","unsubscribe","undefined","derivable","options","Observable","subscriber","_internal","Reactor","create","closed"],"sources":["../../extensions/sherlock-rxjs/rxjs.ts"],"sourcesContent":["import { _internal, atom, Derivable, ErrorWrapper, ReactorOptions } from '@politie/sherlock';\nimport { Observable, Subscriber, Subscription } from 'rxjs';\n\n/**\n * Creates an RxJS Observable from a Derivable. Optionally accepts a `ReactorOptions` that governs RxJS emissions\n * and lifecycle equivalent to {@link Derivable#react} {@link ReactorOptions}.\n * @param derivable Derivable to create an RxJS Observable from.\n * @param options Partial `ReactorOptions`.\n */\nexport function toObservable<V>(derivable: Derivable<V>, options?: Partial<ReactorOptions<V>>): Observable<V> {\n    return new Observable<V>((subscriber: Subscriber<V>) => {\n        return _internal.Reactor.create(derivable as _internal.BaseDerivable<V>,\n            value => subscriber.next(value),\n            options,\n            () => subscriber.closed || subscriber.complete(),\n        );\n    });\n}\n\nexport function fromObservable<V>(observable: Observable<V>): Derivable<V> {\n    const atom$ = atom.unresolved<V>();\n\n    let subscription: Subscription | undefined;\n    atom$.connected$.react(() => {\n        if (atom$.connected && !subscription) {\n            subscription = observable.subscribe({\n                next: value => atom$.set(value),\n                error: err => atom$.setFinal(new ErrorWrapper(err)),\n                complete: () => atom$.setFinal(atom$.getState()),\n        });\n        }\n        // This is not chained with the previous as an `else` branch, because this can be true immediately after\n        // the subscription occurs. Observables can complete synchronously on subscription.\n        if (!atom$.connected && subscription) {\n            subscription.unsubscribe();\n            subscription = undefined;\n        }\n    });\n\n    return atom$;\n}\n"],"mappings":"gWAmBM,SAA4BA,GAC9B,IAEIC,EAFEC,EAAQC,OAAKC,aAmBnB,OAhBAF,EAAMG,WAAWC,MAAM,WACfJ,EAAMK,YAAcN,IACpBA,EAAeD,EAAWQ,UAAU,CAChCC,KAAM,SAAAC,GAAS,OAAAR,EAAMS,IAAID,EAAM,EAC/BE,MAAO,SAAAC,GAAO,OAAAX,EAAMY,SAAS,IAAIC,eAAaF,GAAK,EACnDG,SAAU,WAAM,OAAAd,EAAMY,SAASZ,EAAMe,WAAW,MAKnDf,EAAMK,WAAaN,IACpBA,EAAaiB,cACbjB,OAAekB,EAEvB,GAEOjB,CACX,E,eA/BgB,SAAgBkB,EAAyBC,GACrD,OAAO,IAAIC,aAAc,SAACC,GACtB,OAAOC,YAAUC,QAAQC,OAAON,EAC5B,SAAAV,GAAS,OAAAa,EAAWd,KAAKC,EAAhB,EACTW,EACA,WAAM,OAAAE,EAAWI,QAAUJ,EAAWP,UAAhC,EAEd,EACJ,E","ignoreList":[]}