effector 0.18.10 with prettier

effector.prettify.es.js

function e({
  node: e,
  child: t = [],
  from: n = [],
  scope: r = {},
  meta: o = {},
}) {
  return {from: n.map(Q), seq: e, next: t.map(Q), meta: o, scope: r}
}
function t(e) {
  return e.compositeName
    ? e.compositeName.fullName
    : e.domainName
    ? e.domainName.fullName
    : e.id
}
function n(e) {
  let n = 0
  const r = Object.values(e),
    o = De - 1,
    a = r.length - 1
  let i = 'combine('
  for (const e of r) {
    const r = n === o || a === n ? '' : ', '
    if (
      (Ee(e) || Ie(e) || qe(e) ? (i += t(e) + r) : (i += e.toString() + r),
      (n += 1),
      '' === r)
    )
      break
  }
  return i + ')'
}
function r(e, t, n) {
  ;(this.shortName = e), (this.fullName = t), (this.path = n)
}
function o(e, t) {
  let n, o
  const a = e
  return (
    void 0 === t
      ? ((n = 0 === e.length ? [] : [e]), (o = e))
      : 0 === e.length
      ? ((n = t.path), (o = t.fullName))
      : ((n = t.path.concat([e])),
        (o = 0 === t.fullName.length ? e : t.fullName + '/' + e)),
    new r(a, o, n)
  )
}
function a() {
  const e = this.indexOf()
  ;-1 !== e && (this.splice(e, 1), (this.indexOf = Fe), (this.splice = He))
}
function i({name: n, parent: r, config: a = {}}) {
  const s = Te(),
    c = n || s,
    l = o(c, r),
    u = l.fullName,
    f = e({node: [J.emit({fullName: u})]}),
    d = (e, ...t) => d.create(e, u, t)
  return (
    (d.getType = () => u),
    (d.create = e => (be(d, e), e)),
    (d.kind = A),
    (d[R] = () => d),
    (d.id = s),
    (d.watch = ((e, n) =>
      Me(e, {
        scope: {trigger: e, handler: n},
        node: [Se, J.run({fn: (e, {trigger: n, handler: r}) => r(e, t(n))})],
      })).bind(null, d)),
    (d.map = ((e, t) => {
      const n = i({name: e.shortName + ' → *', parent: e.domainName})
      return (
        Me(e, {
          child: [n],
          scope: {handler: t},
          node: [J.compute({fn: (e, {handler: t}) => t(e)})],
        }),
        n
      )
    }).bind(null, d)),
    (d.filter = ((e, t) => {
      const n = i({name: e.shortName + ' →? *', parent: e.domainName})
      return (
        Me(e, {
          scope: {handler: t},
          child: [n],
          node: [
            J.compute({fn: (e, {handler: t}) => t(e)}),
            J.filter({fn: (e, t) => ((t.val = e), void 0 !== e)}),
            J.compute({fn: (e, t) => t.val}),
          ],
        }),
        n
      )
    }).bind(null, d)),
    (d.prepend = ((e, t) => {
      const n = i({name: '* → ' + e.shortName, parent: e.domainName})
      return (
        Me(n, {
          child: [e],
          scope: {handler: t},
          node: [J.compute({fn: (e, {handler: t}) => t(e)})],
        }),
        n
      )
    }).bind(null, d)),
    (d.subscribe = ((e, t) => e.watch(e => t.next(e))).bind(null, d)),
    (d.graphite = f),
    (d.shortName = c),
    (d.domainName = r),
    (d.compositeName = l),
    (d.defaultConfig = a),
    d
  )
}
function s(e = {}) {
  const t =
    'createStore: Second argument should be plain object, but you passed %s.'
  ke('object' == typeof e && null !== e, t, e),
    void 0 !== (null == e ? void 0 : e.ɔ) &&
      ke('object' == typeof e.ɔ && null !== e.ɔ, t, e.ɔ)
  const n = Object.assign({}, e, 'object' == typeof e.ɔ ? e.ɔ : {})
  return delete n.ɔ, n
}
function c(e, t) {
  const n = 'object' == typeof e ? Object.assign({}, s(t), e) : s(t)
  return {config: n, name: 'object' == typeof e || void 0 === e ? n.name : e}
}
function l(e, t = {}) {
  const {config: n, name: r} = c(e, t)
  return i({name: r, config: n})
}
function u(e) {
  G(
    'function' == typeof e || ('object' == typeof e && null !== e),
    'expect observable to be object or function',
  )
  const t = R in e ? e[R]() : e
  G('subscribe' in t, 'expect observable to have .subscribe')
  const n = l(),
    r = L.bind(null, n, {})
  return t.subscribe({next: n, error: r, complete: r}), n
}
function f() {}
function d() {}
function p(e) {
  return Z(e.plainState)
}
function m(e, t) {
  const n = e.subscribers.get(t)
  void 0 !== n && (n(), e.subscribers.delete(t))
}
function h(e, n, r) {
  const o = n,
    a = e.subscribers.get(o)
  return (
    a && a(),
    e.subscribers.set(
      o,
      Me(o, {
        scope: {handler: r, state: e.plainState, trigger: o},
        child: [e],
        node: [
          J.compute({
            fn(e, {handler: n, state: r, trigger: o}) {
              const a = n(Z(r), e, t(o))
              if (void 0 !== a) return $(r, a)
            },
          }),
        ],
      }),
    ),
    this
  )
}
function b(e, n, r) {
  const o = 'watch requires function handler'
  switch (r && (null == n ? void 0 : n.kind)) {
    case 'store':
    case 'event':
    case 'effect':
      return G('function' == typeof r, o), n.watch(o => r(p(e), o, t(n)))
    default:
      return G('function' == typeof n, o), g(e, n)
  }
}
function g(e, t) {
  G('function' == typeof t, 'Expected the listener to be a function')
  let n = 'Got initial error',
    r = p(e)
  f(e, 'subscribe')
  try {
    t(r), (n = 'Initial')
  } catch (e) {
    console.error(e)
  }
  return (
    d(n),
    Me(e, {
      node: [
        Se,
        J.run({
          fn(n) {
            let o = null
            if ((f(e, 'subscribe'), n !== r)) {
              r = n
              try {
                t(n)
              } catch (e) {
                console.error(e), (o = 'Got error')
              }
              d(o)
            } else d(o)
          },
        }),
      ],
    })
  )
}
function v(t) {
  const {currentState: n, config: r, parent: a} = t,
    {name: i} = r,
    s = Y(n),
    c = i || s.id,
    u = n,
    y = o(c, a),
    N = l('update ' + c),
    S = {
      graphite: e({
        scope: {state: s, oldState: n},
        node: [
          J.filter({fn: e => void 0 !== e}),
          J.update({store: s}),
          J.filter({
            fn: (e, t) => (e === t.oldState ? 0 : ((t.oldState = e), 1)),
          }),
        ],
      }),
      kind: z,
      id: s.id,
      shortName: c,
      domainName: a,
      defaultConfig: r,
      defaultState: u,
      plainState: s,
      subscribers: new Map(),
      compositeName: y,
    },
    w = {
      compositeName: S.compositeName,
      graphite: S.graphite,
      kind: z,
      id: s.id,
      shortName: c,
      domainName: a,
      setState: (e, t) => {
        const n = p(S),
          r = 'function' == typeof t ? t(n, e) : e
        be(w, r)
      },
      off: m.bind(null, S),
      watch: b.bind(null, S),
      updates: N,
      subscribe: g.bind(null, S),
      getState: p.bind(null, S),
      stateRef: s,
    }
  return (
    (w.defaultConfig = r),
    (w.reset = function(e, ...t) {
      for (const n of t) h.call(this, e, n, () => e.defaultState)
      return this
    }.bind(w, S)),
    (w.on = h.bind(w, S)),
    (w.defaultState = u),
    (w.map = function(e, t, n) {
      let r
      f(e, 'map')
      let o = 'Got initial error'
      try {
        const a = e.getState()
        void 0 !== a && (r = t(a, n)), (o = 'Initial')
      } catch (e) {
        console.error(e)
      }
      d(o)
      const a = this({
        config: {name: e.shortName + ' → *'},
        currentState: r,
        parent: e.domainName,
      })
      return (
        Me(e, {
          child: [a],
          scope: {store: e, handler: t, state: a.stateRef},
          node: [
            J.compute({
              fn(e, {state: t, store: n, handler: r}) {
                f(n, 'map')
                let o,
                  a = 'Got error'
                try {
                  ;(o = r(e, Z(t))), (a = null)
                } catch (e) {
                  console.error(e)
                }
                return d(a), o
              },
            }),
            Ne,
          ],
        }),
        a
      )
    }.bind(v, w)),
    (w.thru = function(e) {
      return e(this)
    }.bind(w)),
    (w.dispatch = (e => e).bind(null)),
    (w[R] = function(e) {
      const t = {
        subscribe: t => (
          G(
            'object' == typeof t && null !== t,
            'Expected the observer to be an object.',
          ),
          g(e, e => {
            t.next && t.next(e)
          })
        ),
      }
      return (
        (t[R] = function() {
          return this
        }),
        t
      )
    }.bind(null, S)),
    Re({from: w, to: N}),
    w
  )
}
function y(e, t = {}) {
  return (
    G(
      void 0 !== e,
      "createStore: First argument can't be undefined, use null instead.",
    ),
    v({currentState: e, config: s(t)})
  )
}
function N(e, t) {
  const n = o(t, e.domainName)
  ;(e.shortName = t),
    e.compositeName
      ? ((e.compositeName.path = n.path),
        (e.compositeName.shortName = n.shortName),
        (e.compositeName.fullName = n.fullName))
      : (e.compositeName = n)
}
function S(e, t) {
  const n = Array.isArray(e)
    ? Ve(e, e => e.slice(), [])
    : Ve(e, e => Object.assign({}, e), {})
  return t ? n.map(t) : n
}
function w(e, t) {
  let n
  return S((n = t('defaultShape' in e ? e.defaultShape : e.defaultState)))
}
function k(e, t) {
  const n = {}
  for (const r in t) {
    const o = t[r],
      a = (n[r] = l(r))
    e.on(a, o)
  }
  return n
}
function x(e) {
  const t = {}
  for (const n in e) {
    const r = e[n]
    t[n] = Ee(r) ? r : v({currentState: r, config: {name: n}})
  }
  return t
}
function j(e, t) {
  const n = v({
    currentState: t,
    parent: e.domainName,
    config: {name: e.shortName},
  })
  return n.on(e.done, (e, {result: t}) => t), n
}
function E(e, t) {
  const n = v({
    currentState: t,
    parent: e.domainName,
    config: {name: e.shortName},
  })
  return n.on(e, (e, t) => t), n
}
function I(e, t) {
  return Ee(e) ? e : Ie(e) ? E(e, t) : qe(e) ? j(e, t) : x(e)
}
function q(e, t) {
  return n => t(e.getState(), n)
}
function C(...e) {
  let t, n, r
  G(e.length > 0, 'at least one argument required')
  {
    const r = e[e.length - 1]
    'function' == typeof r ? ((n = e.slice(0, -1)), (t = r)) : (n = e)
  }
  e: {
    if (1 === n.length) {
      const e = n[0]
      if (!Ee(e)) {
        r = e
        break e
      }
    }
    ;(r = n), t && (t = We(t))
  }
  return S(r, t)
}
function O(e, t, n, r = 0) {
  let o
  void 0 === t &&
    'source' in e &&
    ((t = e.clock || e.sampler),
    (n = e.fn),
    (r = e.greedy),
    (o = e.target),
    (e = e.source)),
    void 0 === t && (t = e)
  const a = Le(e),
    i = Le(t)
  return (
    'boolean' == typeof n && ((r = n), (n = void 0)),
    (Ee(a) ? (Ee(i) ? _e : Ue) : Je)(a, i, n, r, o)
  )
}
function D() {
  const e = new Promise((e, t) => {
    ;(this.rs = e), (this.rj = t)
  })
  ;(e.anyway = () => (
    ke(0, '.anyway is deprecated, use .finally'), e.then(() => {}, () => {})
  )),
    (this.req = e)
}
function F({name: e, parent: t, config: n}) {
  const {handler: r} = n,
    o = i({name: e, parent: t, config: n}),
    a = o.create,
    s = i({name: o.shortName + ' done', parent: t, config: n}),
    c = i({name: o.shortName + ' fail', parent: t, config: n})
  s.graphite.seq.push(Qe), c.graphite.seq.push(Qe)
  let l =
    r ||
    function() {
      return ke(0, 'no thunk used in %s', this.getType()), Promise.resolve()
    }.bind(o)
  ;(o.done = s), (o.fail = c), (o.use = e => ((l = e), o))
  const u = () => l
  return (
    (o.use.getCurrent = u),
    (o.kind = P),
    (o.graphite.scope = {done: s, fail: c, getHandler: u}),
    o.graphite.seq.push(
      J.compute({
        fn: e =>
          'object' == typeof e && null !== e && 'ɔ' in e
            ? e.ɔ
            : {params: e, req: {rs(e) {}, rj(e) {}}},
      }),
      J.run({
        fn: ({params: e, req: t}, {getHandler: n, done: r, fail: o}) => (
          ((e, t, n, r) => {
            let o,
              a,
              i = 0
            try {
              a = e(t)
            } catch (e) {
              ;(i = 1), (o = e)
            }
            i
              ? r(o)
              : 'object' != typeof a ||
                null === a ||
                'function' != typeof a.then
              ? n(a)
              : a.then(n, r)
          })(
            n(),
            e,
            function(e) {
              const {event: t, params: n, handler: r} = this
              ge(t, {handler: r, toHandler: e, result: {params: n, result: e}})
            }.bind({event: r, params: e, handler: t.rs}),
            function(e) {
              const {event: t, params: n, handler: r} = this
              ge(t, {handler: r, toHandler: e, result: {params: n, error: e}})
            }.bind({event: o, params: e, handler: t.rj}),
          ),
          e
        ),
      }),
    ),
    (o.create = (e, t, n) => {
      const r = new D()
      return a({ɔ: {params: e, req: r}}, o.getType(), n), r.req
    }),
    (o.pending = y(Boolean(0))
      .on(o, () => Boolean(1))
      .reset(s)
      .reset(c)),
    o
  )
}
function H(e, t) {
  const {config: n, name: r} = c(e, t)
  return F({name: r, domainName: '', config: n})
}
function M(e, t = {}) {
  const {config: n, name: r} = c(e, t)
  return (function e({name: t, config: n = {}, parent: r, parentHooks: a}) {
    const c = $e(),
      l = o(t || '', r),
      u = new Xe(),
      f = ((e, t, n) => {
        let r
        return (
          (r = n ? Ze(n) : Ye(t)).domain.watch(t => {
            e.domains.add(t)
          }),
          r.event.watch(t => {
            e.events.add(t)
          }),
          r.store.watch(t => {
            e.storages.add(t)
          }),
          r.effect.watch(t => {
            e.effects.add(t)
          }),
          r
        )
      })(u, l, a)
    return {
      compositeName: l,
      id: c,
      defaultConfig: n,
      getType: () => l.fullName,
      onCreateEvent: e => (u.events.forEach(e), f.event.watch(e)),
      onCreateEffect: e => (u.effects.forEach(e), f.effect.watch(e)),
      onCreateStore: e => (u.storages.forEach(e), f.store.watch(e)),
      onCreateDomain: e => (u.domains.forEach(e), f.domain.watch(e)),
      event(e, t = {}) {
        const n = s(t),
          r = i({name: e, parent: l, config: n})
        return f.event(r), r
      },
      effect(e, t = {}) {
        const n = s(t),
          r = F({name: e, domainName: l.fullName, parent: l, config: n})
        return f.effect(r), r
      },
      domain(t, n = {}) {
        const r = s(n),
          o = e({name: t, parent: l, parentHooks: f, config: r})
        return f.domain(o), o
      },
      store(e, t = {}) {
        const n = s(t),
          r = v({currentState: e, parent: l, config: n})
        return f.store(r), r
      },
      kind: V,
    }
  })({name: void 0 === r ? '' : r, config: n})
}
import R from 'symbol-observable'
const T = '0.18.10',
  B = 'production' !== process.env.NODE_ENV
var G = B
  ? function e(t, n, ...r) {
      if (!t) {
        const t = Error()
        Error.captureStackTrace && Error.captureStackTrace(t, e),
          (t.name = 'Invariant Violation')
        let o = 0
        throw ((t.message = n.replace(/%s/g, () => r[o++])), t)
      }
    }
  : e => {
      if (!e) throw Error('Minified exception occurred')
    }
const z = 'store',
  A = 'event',
  P = 'effect',
  V = 'domain'
var W = Object.freeze({store: z, event: A, effect: P, domain: V})
const K = () => {
    let e = 0
    return () => (++e).toString(36)
  },
  U = K(),
  _ = (e, t) => ({id: U(), type: e, group: 'cmd', data: t}),
  J = {
    barrier: ({barrierID: e, priority: t = 'barrier'}) =>
      _('barrier', {barrierID: e, priority: t}),
    compute: _.bind(null, 'compute'),
    emit: _.bind(null, 'emit'),
    filter: _.bind(null, 'filter'),
    run: _.bind(null, 'run'),
    tap: _.bind(null, 'tap'),
    update: _.bind(null, 'update'),
  },
  L = (e, {deep: t} = {}) => {
    const n = Q(e)
    t && n.next.forEach(e => L(e, {deep: t})),
      n.from.forEach(e => {
        const t = e.next.indexOf(n)
        ;-1 !== t && e.next.splice(t, 1)
      }),
      (n.from.length = 0),
      (n.next.length = 0),
      (n.seq.length = 0),
      (n.scope = null)
  },
  Q = e => e.graphite || e,
  X = K(),
  Y = e => ({id: X(), current: e}),
  Z = ({current: e}) => e,
  $ = (e, t) => (e.current = t),
  ee = K(),
  te = e => {
    switch (e) {
      case 'child':
        return 0
      case 'pure':
        return 1
      case 'barrier':
        return 2
      case 'sampler':
        return 3
      case 'effect':
        return 4
      default:
        return -1
    }
  }
class ne {
  constructor(e, t) {
    ;(this.value = {current: e}), (this.parent = t)
  }
}
class re {
  constructor(e, t, n, r) {
    ;(this.value = e), (this.rank = t), (this.left = n), (this.right = r)
  }
}
const oe = e => (e ? ae(e.left, e.right) : null),
  ae = (e, t) => {
    let n, r, o, a, i, s, c
    for (;;) {
      var l, u
      if (((n = t), !(r = e))) return n
      if (!n) return r
      if (((a = r.left), !se((o = r.value), n.value)))
        return (
          (i = ae(r.right, n)),
          (s = (null === (l = a) || void 0 === l ? void 0 : l.rank) || 0) >=
          (c = (null === (u = i) || void 0 === u ? void 0 : u.rank) || 0)
            ? new re(o, c + 1, a, i)
            : new re(o, s + 1, i, a)
        )
      ;(t = r), (e = n)
    }
  }
class ie {
  constructor(e) {
    ;(this.isChanged = 1), (this.isFailed = 0), (this.scope = e)
  }
}
const se = (e, t) => (e.type === t.type ? e.id > t.id : te(e.type) > te(t.type))
let ce = 0,
  le = null
const ue = new Set(),
  fe = e => {
    le = ((e, t) => ae(new re(e, 1, null, null), t))(e, le)
  },
  de = ({step: e, firstIndex: t, scope: n, resetStop: r}, o) => {
    const a = new ie(e.scope)
    for (let r = t; r < e.seq.length && !o.stop; r++) {
      const i = e.seq[r]
      if (r === t) 'barrier' === i.type && ue.delete(i.data.barrierID)
      else
        switch (i.type) {
          case 'run':
            return void fe({
              step: e,
              firstIndex: r,
              scope: n,
              resetStop: 0,
              type: 'effect',
              id: ++ce,
            })
          case 'barrier': {
            const t = i.data.barrierID
            return void (
              ue.has(t) ||
              (ue.add(t),
              fe({
                step: e,
                firstIndex: r,
                scope: n,
                resetStop: 0,
                type: i.data.priority,
                id: ++ce,
              }))
            )
          }
        }
      ;(0, ve[i.type])(a, i.data, n.value),
        (o.stop = a.isFailed || !a.isChanged)
    }
    if (!o.stop)
      for (let t = 0; t < e.next.length; t++) {
        const r = new ne(Z(n.value), n)
        fe({
          step: e.next[t],
          firstIndex: 0,
          scope: r,
          resetStop: 1,
          type: 'child',
          id: ++ce,
        })
      }
    r && (o.stop = 0)
  }
let pe = 0
const me = (e, t) => {
    fe({
      step: Q(e),
      firstIndex: 0,
      scope: new ne(t, null),
      resetStop: 0,
      type: 'pure',
      id: ++ce,
    })
  },
  he = () => {
    const e = pe
    pe = 1
    const t = {stop: 0}
    let n
    for (; le; ) (n = le.value), (le = oe(le)), de(n, t)
    pe = e
  },
  be = (e, t) => {
    me(e, t), he()
  },
  ge = (e, t) => {
    me(e, t), pe || he()
  },
  ve = {
    barrier(e, t, n) {
      ;(e.isFailed = 0), (e.isChanged = 1)
    },
    emit(e, t, n) {},
    filter(e, t, n) {
      const r = ye({arg: Z(n), val: e.scope, fn: t.fn})
      e.isChanged = !!r.result
    },
    run(e, t, n) {
      const r = ye({arg: Z(n), val: e.scope, fn: t.fn})
      ;(e.isFailed = r.err), $(n, r.result)
    },
    update(e, t, n) {
      $(t.store, Z(n))
    },
    compute(e, t, n) {
      const r = ye({arg: Z(n), val: e.scope, fn: t.fn})
      ;(e.isFailed = r.err), $(n, r.result)
    },
    tap(e, t, n) {
      const r = ye({arg: Z(n), val: e.scope, fn: t.fn})
      e.isFailed = r.err
    },
  },
  ye = ({fn: e, arg: t, val: n}) => {
    const r = {err: 0, result: null}
    try {
      r.result = e(t, n)
    } catch (e) {
      console.error(e), (r.err = 1)
    }
    return r
  },
  Ne = J.filter({fn: (e, {state: t}) => e !== Z(t) && void 0 !== e}),
  Se = J.compute({fn: e => e})
var we = Object.freeze({filterChanged: Ne, noop: Se}),
  ke = B
    ? (e, t, ...n) => {
        e || console.error('Warning: ' + t, ...n)
      }
    : () => {}
const xe = e =>
    ('function' == typeof e || ('object' == typeof e && null !== e)) &&
    'kind' in e,
  je = e => t => xe(t) && t.kind === e,
  Ee = je(z),
  Ie = je(A),
  qe = je(P),
  Ce = je(V)
var Oe = Object.freeze({unit: xe, store: Ee, event: Ie, effect: qe, domain: Ce})
const De = 25,
  Fe = () => -1,
  He = () => [],
  Me = (t, n) => Re({from: t, to: e(n)}),
  Re = e => {
    const t = Q(e.from),
      n = Q(e.to)
    return (
      t.next.push(n),
      (e => {
        const t = e.parent.next,
          n = {indexOf: t.indexOf.bind(t, e.child), splice: t.splice.bind(t)},
          r = a.bind(n)
        return (r.unsubscribe = a.bind(n)), r
      })({child: n, parent: t})
    )
  },
  Te = K()
let Be = null,
  Ge = null
if (B) {
  const e = '☄',
    n =
      'undefined' != typeof performance &&
      'function' == typeof performance.mark &&
      'function' == typeof performance.clearMarks &&
      'function' == typeof performance.measure &&
      'function' == typeof performance.clearMeasures
  function ze(t) {
    return e + ' ' + t
  }
  const r = (t, n) => e + ' ' + t + (n ? ' Warning: ' + n : '')
  function Ae(e, t) {
    return e + '.' + t
  }
  function Pe(e, t) {
    return e + ' (#' + t + ')'
  }
  const o = () => {
    null !== Be &&
      null !== Ge &&
      ((e, n) => {
        const r = t(e),
          o = e.id
        var a
        ;(a = Pe(Ae(r, n), o)), performance.clearMarks(ze(a))
      })(Ge, Be),
      (Ge = null),
      (Be = null)
  }
  ;(f = (e, r) => {
    n &&
      (o(),
      ((e, n) => {
        const r = t(e),
          o = e.id
        return (a = Pe(Ae(r, n), o)), performance.mark(ze(a)), 1
        var a
      })(e, r) && ((Ge = e), (Be = r)))
  }),
    (d = e => {
      n &&
        (null !== Be &&
          null !== Ge &&
          ((e, n, o) => {
            const a = t(e),
              i = e.id,
              s = Ae(a, n)
            ;((e, t, n) => {
              const o = ze(t),
                a = r(e, n)
              try {
                performance.measure(a, o)
              } catch (e) {}
              performance.clearMarks(o), performance.clearMeasures(a)
            })(s, Pe(s, i), o)
          })(Ge, Be, e),
        (Be = null),
        (Ge = null))
    })
}
const Ve = (e, t, r) => {
    const o = [
        J.filter({
          fn: (e, {target: t, key: n}) => e !== Z(t)[n] && void 0 !== e,
        }),
        J.tap({
          fn(e, {isFresh: t, target: n, clone: r}) {
            Z(t) || ($(n, r(Z(n))), $(t, 1))
          },
        }),
        J.tap({
          fn(e, {target: t, key: n}) {
            Z(t)[n] = e
          },
        }),
        J.barrier({barrierID: ee()}),
        J.compute({fn: (e, {isFresh: t, target: n}) => ($(t, 0), Z(n))}),
      ],
      a = t(r),
      i = v({currentState: a, config: {name: n(e)}}),
      s = Y(0)
    for (const n in e) {
      const c = e[n]
      Ee(c)
        ? ((r[n] = c.defaultState),
          (a[n] = c.getState()),
          Me(c, {
            scope: {key: n, clone: t, target: i.stateRef, isFresh: s},
            node: o,
            child: [i],
          }))
        : (a[n] = r[n] = c)
    }
    return (i.defaultShape = e), (i.defaultState = r), i
  },
  We = e => t => e(...t),
  Ke = (e, t, n, r, o) => (
    Me(t, {
      scope: {state: e.stateRef, fn: n},
      child: [o],
      node: [
        !r && Se,
        !r && J.barrier({barrierID: ee(), priority: 'sampler'}),
        J.compute({
          fn: n
            ? (e, {state: t, fn: n}) => n(Z(t), e)
            : (e, {state: t}) => Z(t),
        }),
      ].filter(Boolean),
    }),
    o
  ),
  Ue = (e, t, n, r, o) =>
    Ke(e, t, n, r, o || i({name: e.shortName, parent: e.domainName})),
  _e = (e, t, n, r, o) => {
    const a = Z(e.stateRef)
    return Ke(
      e,
      t,
      n,
      r,
      o ||
        v({
          currentState: n ? n(a, Z(t.stateRef)) : a,
          config: {name: e.shortName},
          parent: e.domainName,
        }),
    )
  },
  Je = (e, t, n, r, o) => {
    o = o || i({name: e.shortName, parent: e.domainName})
    const a = Y(0),
      s = Y(),
      c = Y()
    return (
      Me(e, {
        scope: {hasSource: a},
        node: [
          J.update({store: s}),
          J.tap({
            fn(e, {hasSource: t}) {
              $(t, 1)
            },
          }),
        ],
      }),
      Me(t, {
        scope: {sourceState: s, clockState: c, hasSource: a, fn: n},
        child: [o],
        node: [
          J.update({store: c}),
          J.filter({fn: (e, {hasSource: t}) => Z(t)}),
          !r && J.barrier({barrierID: ee(), priority: 'sampler'}),
          J.compute({
            fn: n
              ? (e, {sourceState: t, clockState: n, fn: r}) => r(Z(t), Z(n))
              : (e, {sourceState: t}) => Z(t),
          }),
        ].filter(Boolean),
      }),
      o
    )
  },
  Le = e => (xe(e) ? e : S(e)),
  Qe = J.run({fn: ({handler: e, toHandler: t, result: n}) => (e(t), n)})
class Xe {
  constructor() {
    ;(this.events = new Set()),
      (this.effects = new Set()),
      (this.storages = new Set()),
      (this.domains = new Set())
  }
}
const Ye = e => ({
    event: i({name: e.fullName + ' event hook', parent: e}),
    effect: i({name: e.fullName + ' effect hook', parent: e}),
    store: i({name: e.fullName + ' store hook', parent: e}),
    domain: i({parent: e}),
  }),
  Ze = e => ({
    event: e.event.prepend(e => e),
    effect: e.effect.prepend(e => e),
    store: e.store.prepend(e => e),
    domain: e.domain.prepend(e => e),
  }),
  $e = K()
export {
  W as Kind,
  we as blocks,
  L as clearNode,
  C as combine,
  k as createApi,
  M as createDomain,
  H as createEffect,
  l as createEvent,
  e as createNode,
  y as createStore,
  C as createStoreObject,
  w as extract,
  Re as forward,
  u as fromObservable,
  G as invariant,
  Oe as is,
  Ce as isDomain,
  qe as isEffect,
  Ie as isEvent,
  Ee as isStore,
  xe as isUnit,
  be as launch,
  I as restore,
  j as restoreEffect,
  E as restoreEvent,
  x as restoreObject,
  O as sample,
  N as setStoreName,
  J as step,
  T as version,
  ke as warning,
  q as withProps,
}
//# sourceMappingURL=effector.es.js.map