123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245
function getChildrenDeep(children) {  return children.reduce(    (res, curr) => res.concat(curr, getChildrenDeep(curr._children)),    []  );}
const EMPTY_ARR = [];let tracking;let queue;
/** * Returns true if there is an active observer. * @return {boolean} */function isListening() {  return !!tracking;}
/** * Creates a root and executes the passed function that can contain computations. * The executed function receives an `unsubscribe` argument which can be called to * unsubscribe all inner computations. * * @param  {Function} fn * @return {*} */function root(fn) {  const prevTracking = tracking;  const rootUpdate = () => {};  tracking = rootUpdate;  resetUpdate(rootUpdate);  const result = fn(() => {    _unsubscribe(rootUpdate);    tracking = undefined;  });  tracking = prevTracking;  return result;}
/** * Sample the current value of an observable but don't create a dependency on it. * * @example * S(() => { if (foo()) bar(sample(bar) + 1); }); * * @param  {Function} fn * @return {*} */function sample(fn) {  const prevTracking = tracking;  tracking = undefined;  const value = fn();  tracking = prevTracking;  return value;}
/** * Creates a transaction in which an observable can be set multiple times * but only trigger a computation once. * @param  {Function} fn * @return {*} */function transaction(fn) {  let prevQueue = queue;  queue = [];  const result = fn();  let q = queue;  queue = prevQueue;  q.forEach(data => {    if (data._pending !== EMPTY_ARR) {      const pending = data._pending;      data._pending = EMPTY_ARR;      data(pending);    }  });  return result;}
/** * Creates a new observable, returns a function which can be used to get * the observable's value by calling the function without any arguments * and set the value by passing one argument of any type. * * @param  {*} value - Initial value. * @return {Function} */function observable(value) {  function data(nextValue) {    if (arguments.length === 0) {      if (tracking && !data._observers.has(tracking)) {        data._observers.add(tracking);        tracking._observables.push(data);      }      return value;    }
    if (queue) {      if (data._pending === EMPTY_ARR) {        queue.push(data);      }      data._pending = nextValue;      return nextValue;    }
    value = nextValue;
    // Clear `tracking` otherwise a computed triggered by a set    // in another computed is seen as a child of that other computed.    const clearedUpdate = tracking;    tracking = undefined;
    // Update can alter data._observers, make a copy before running.    data._runObservers = new Set(data._observers);    data._runObservers.forEach(observer => (observer._fresh = false));    data._runObservers.forEach(observer => {      if (!observer._fresh) observer();    });
    tracking = clearedUpdate;    return value;  }
  // Tiny indicator that this is an observable function.  data._observers = new Set();  // The 'not set' value must be unique, so `nullish` can be set in a transaction.  data._pending = EMPTY_ARR;
  return [data, data];}
/** * @namespace * @borrows observable as o */
/** * Creates a new computation which runs when defined and automatically re-runs * when any of the used observable's values are set. * * @param {Function} observer * @param {*} value - Seed value. * @return {Function} Computation which can be used in other computations. */function computed(observer, value) {  observer._update = update;
  // if (tracking == null) {  //   console.warn("computations created without a root or parent will never be disposed");  // }
  resetUpdate(update);  update();
  function update() {    const prevTracking = tracking;    if (tracking) {      tracking._children.push(update);    }
    const prevChildren = update._children;
    _unsubscribe(update);    update._fresh = true;    tracking = update;    value = observer(value);
    // If any children computations were removed mark them as fresh.    // Check the diff of the children list between pre and post update.    prevChildren.forEach(u => {      if (update._children.indexOf(u) === -1) {        u._fresh = true;      }    });
    // If any children were marked as fresh remove them from the run lists.    const allChildren = getChildrenDeep(update._children);    allChildren.forEach(removeFreshChildren);
    tracking = prevTracking;    return value;  }
  function data() {    if (update._fresh) {      update._observables.forEach(o => o());    } else {      value = update();    }    return value;  }
  return data;}
function removeFreshChildren(u) {  if (u._fresh) {    u._observables.forEach(o => {      if (o._runObservers) {        o._runObservers.delete(u);      }    });  }}
/** * Run the given function just before the enclosing computation updates * or is disposed. * @param  {Function} fn * @return {Function} */function cleanup(fn) {  if (tracking) {    tracking._cleanups.push(fn);  }  return fn;}
function _unsubscribe(update) {  update._children.forEach(_unsubscribe);  update._observables.forEach(o => {    o._observers.delete(update);    if (o._runObservers) {      o._runObservers.delete(update);    }  });  update._cleanups.forEach(c => c());  resetUpdate(update);}
function resetUpdate(update) {  // Keep track of which observables trigger updates. Needed for unsubscribe.  update._observables = [];  update._children = [];  update._cleanups = [];}
module.exports = {  createSignal: observable,  createRoot: root,  createComputed: computed,  createMemo: computed,  batch: transaction};