requirebin sketch

index.js

const d = require("derivable")

const name = d.atom("World");     // the name of the user   
const countryCode = d.atom("en"); // for i18n 
 
// static constants don't need to be wrapped 
const greetings = {
  en: "Hello",
  de: "Hallo",
  es: "Hola",
  cn: "您好",
  fr: "Bonjour",
};
 
// derive a greeting message based on the user's name and country. 
const greeting = countryCode.derive(cc => greetings[cc]);
const message = d.derive`${greeting}, ${name}!`; // es6 tagged template strings! 
 
// set up a Reactor to print the message every time it changes 
message.react(msg => console.log(msg));
// $> Hello, World! 
 
countryCode.set("de");
// $> Hallo, World! 
name.set("Dagmar");
// $> Hallo, Dagmar! 
 
// we can avoid unwanted intermediate reactions by using transactions 
d.transact(() => {
  countryCode.set("fr");
  name.set("Étienne");
});

minified.js

setTimeout(function(){
;require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"derivable":[function(require,module,exports){
// UMD loader
(function (global, factory) {
  "use strict";
  if (global && typeof global.define === "function" && global.define.amd) {
    global.define(["exports"], factory);
  } else if (typeof exports !== "undefined") {
    factory(exports);
  } else {
    factory(global.Derivable = {});
  }
})(this, function (exports) {
"use strict";

var util_keys = Object.keys;

function util_extend(obj) {
  for (var i = 1; i < arguments.length; i++) {
    var other = arguments[i];
    var keys = util_keys(other);
    for (var j = keys.length; j--;) {
      var prop = keys[j];
      obj[prop] = other[prop];
    }
  }
  return obj;
}

function _is(a, b) {
  // SameValue algorithm
  if (a === b) { // Steps 1-5, 7-10
    // Steps 6.b-6.e: +0 != -0
    return a !== 0 || 1 / a === 1 / b;
  } else {
    // Step 6.a: NaN == NaN
    return a !== a && b !== b;
  }
}

function util_equals (a, b) {
  return _is(a, b) || (a && typeof a.equals === 'function' && a.equals(b));
}

function util_addToArray (a, b) {
  var i = a.indexOf(b);
  if (i < 0) {
    a.push(b);
  }
}

function util_removeFromArray (a, b) {
  var i = a.indexOf(b);
  if (i >= 0) {
    a.splice(i, 1);
  }
}

function util_arrayContains (a, b) {
  return a.indexOf(b) >= 0;
}

var nextId = 0;
function util_nextId () {
  return nextId++;
}

function util_slice (a, i) {
  return Array.prototype.slice.call(a, i);
}

var util_unique = Object.freeze({equals: function () { return false; }});

function util_some (x) {
  return (x !== null) && (x !== void 0);
}

var util_DEBUG_MODE = false;
function util_setDebugMode(val) {
  util_DEBUG_MODE = !!val;
}

function util_setEquals(derivable, equals) {
  derivable._equals = equals;
  return derivable;
}

// node modes
var gc_NEW = 0,
    gc_CHANGED = 1,
    gc_UNCHANGED = 2,
    gc_ORPHANED = 3,
    gc_UNSTABLE = 4,
    gc_STABLE = 5,
    gc_DISOWNED = 6;

function gc_mark(node, reactors) {
  // make everything unstable
  if (node._type === types_REACTION) {
    if (node.reacting) {
      throw new Error("Cycle detected! Don't do this!");
    }
    reactors.push(node);
  } else {
    for (var i = node._children.length; i--;) {
      var child = node._children[i];
      if (child._state !== gc_UNSTABLE) {
        child._state = gc_UNSTABLE;
        gc_mark(child, reactors);
      }
    }
  }
}

function gc_sweep(node) {
  var i;
  switch (node._state) {
  case gc_CHANGED:
  case gc_UNCHANGED:
    // changed or unchanged means the node was visited
    // during the react phase, which means we keep it in
    // the graph for the next go round
    for (i = node._children.length; i--;) {
      var child = node._children[i];
      gc_sweep(child);
      if (child._state !== gc_STABLE) {
        node._children.splice(i, 1);
      }
    }
    node._state = gc_STABLE;
    break;
  case gc_UNSTABLE:
    if (node._type === types_REACTION) {
      // only happens when reaction created in transaction. see issue #14
      node._state = gc_STABLE;
    } else {
      // unstable means the node was not visited during
      // the react phase, which means we kick it out of the
      // graph.

      // but first we check if all of its parents were unchanged
      // if so, we can avoid recalculating it in future by
      // caching its parents' current values.
      var stashedParentStates = [];
      for (i = node._parents.length; i--;) {
        var parent = node._parents[i];
        if (parent._state !== gc_UNCHANGED) {
          // nope, its parents either have changed or weren't visited,
          // so we have to orphan this node
          node._state = gc_ORPHANED;
          break;
        }
        stashedParentStates.push([parent, parent._value]);
      }
      if (node._state !== gc_ORPHANED) {
        node._state = gc_DISOWNED;
        node._parents = stashedParentStates;
      }
    }
    break;
  case gc_STABLE:
  case gc_ORPHANED:
  case gc_DISOWNED:
    break;
  default:
    throw new Error("can't sweep state " + node._state);
  }
}

function gc_abort_sweep(node) {
  // set everything to unstable, kill all derivation caches and disconnect
  // the graph
  var doChildren = false;
  switch (node._type) {
  case types_ATOM:
    node._state = gc_STABLE;
    doChildren = true;
    break;
  case types_DERIVATION:
  case types_LENS:
    node._state = gc_NEW;
    node._value = util_unique;
    doChildren = true;
    break;
  case types_REACTION:
    node._state = gc_STABLE;
    doChildren = false;
    break;
  }
  if (doChildren) {
    for (var i = node._children.length; i--;) {
      gc_abort_sweep(node._children[i]);
    }
    node._children = [];
  }
}

var parentsStack = [];

function parents_capturingParents(f) {
  var i = parentsStack.length;
  parentsStack.push([]);
  try {
    f();
    return parentsStack[i];
  } finally {
    parentsStack.pop();
  }
}

function parents_maybeCaptureParent(p) {
  if (parentsStack.length > 0) {
    util_addToArray(parentsStack[parentsStack.length - 1], p);
  }
}

var types_ATOM = "ATOM",
    types_DERIVATION = "DERIVATION",
    types_LENS = "LENS",
    types_REACTION = "REACTION";

var RUNNING = 0,
    COMPLETED = 1,
    ABORTED = 3;

var TransactionAbortion = {};

function abortTransaction() {
  throw TransactionAbortion;
}

function transactions_newContext () {
  return {currentTxn: null};
}

function transactions_inTransaction (ctx) {
  return ctx.currentTxn !== null;
}

function transactions_currentTransaction (ctx) {
  return ctx.currentTxn;
}

function begin (ctx, txn) {
  txn._parent = ctx.currentTxn;
  txn._state = RUNNING;
  ctx.currentTxn = txn;
}

function popTransaction (ctx, cb) {
  var txn = ctx.currentTxn;
  ctx.currentTxn = txn._parent;
  if (txn._state !== RUNNING) {
    throw new Error("unexpected state: " + txn._state);
  }
  cb(txn);
}

function commit (ctx) {
  popTransaction(ctx, function (txn) {
    txn._state = COMPLETED;
    txn.onCommit && txn.onCommit();
  });
}

function abort (ctx) {
  popTransaction(ctx, function (txn) {
    txn._state = ABORTED;
    txn.onAbort && txn.onAbort();
  });
}

function transactions_transact (ctx, txn, f) {
  begin(ctx, txn);
  try {
    f(abortTransaction);
  } catch (e) {
    abort(ctx);
    if (e !== TransactionAbortion) {
      throw e;
    } else {
      return;
    }
  }
  commit(ctx);
}

function transactions_ticker (ctx, txnConstructor) {
  begin(ctx, txnConstructor());
  var disposed = false;
  return {
    tick: function () {
      if (disposed) throw new Error("can't tick disposed ticker");
      commit(ctx);
      begin(ctx, txnConstructor());
    },
    stop: function () {
      if (disposed) throw new Error("ticker already disposed");
      commit(ctx);
    }
  }
}

function reactorBase (parent, control) {
  var base = {
    control: control,      // the actual object the user gets
    parent: parent,        // the parent derivable
    parentReactor: null,
    dependentReactors: [],
    _state: gc_STABLE,
    active: false,         // whether or not listening for changes in parent
    _type: types_REACTION,
    uid: util_nextId(),
    reacting: false,       // whether or not reaction function being invoked
    yielding: false,       // whether or not letting parentReactor react first
  };
  if (util_DEBUG_MODE) {
    base.stack = Error().stack;
  }
  return base;
}
var cycleMsg = "Cyclical Reactor Dependency! Not allowed!";

function stop (base) {
  if (base.active) {
    util_removeFromArray(base.parent._children, base);
    if (base.parentReactor) {
      orphan(base);
    }
    base.active = false;
    base.control.onStop && base.control.onStop();
  }
}

var parentReactorStack = [];

function start (base) {
  if (!base.active) {
    util_addToArray(base.parent._children, base);
    base.active = true;
    base.parent._get();
    // capture reactor dependency relationships
    var len = parentReactorStack.length;
    if (len > 0) {
      base.parentReactor = parentReactorStack[len - 1];
    }

    base.control.onStart && base.control.onStart();
  }
}

function orphan (base) {
  if (base.parentReactor) {
    base.parentReactor = null;
  }
}

function adopt (parentBase, childBase) {
  childBase.parentReactor = parentBase;
}

function reactors_maybeReact (base) {
  if (base.yielding) {
    throw Error(cycleMsg);
  }
  if (base.active && base._state === gc_UNSTABLE) {
    if (base.parentReactor !== null) {
      try {
        base.yielding = true;
        reactors_maybeReact(base.parentReactor);
      } finally {
        base.yielding = false;
      }
    }
    // parent might have deactivated this one
    if (base.active) {
      var parent = base.parent, parentState = parent._state;
      if (parentState === gc_UNSTABLE ||
          parentState === gc_ORPHANED ||
          parentState === gc_DISOWNED ||
          parentState === gc_NEW) {
        parent._get();
      }
      parentState = parent._state;

      if (parentState === gc_UNCHANGED) {
        base._state = gc_STABLE;
      } else if (parentState === gc_CHANGED) {
        force(base);
      } else {
          throw new Error("invalid parent state: " + parentState);
      }
    }
  }
}

function force (base) {
  // base.reacting check now in gc_mark; total solution there as opposed to here
  if (base.control.react) {
    base._state = gc_STABLE;
    try {
      base.reacting = true;
      parentReactorStack.push(base);
      if (!util_DEBUG_MODE) {
        base.control.react(base.parent._get());
      } else {
        try {
          base.control.react(base.parent._get());
        } catch (e) {
          console.error(base.stack);
          throw e;
        }
      }
    } finally {
      parentReactorStack.pop();
      base.reacting = false;
    }
  } else {
      throw new Error("No reactor function available.");
  }
}

function reactors_Reactor () {
  /*jshint validthis:true */
  this._type = types_REACTION;
}

function reactors_createBase (control, parent) {
  if (control._base) {
    throw new Error("This reactor has already been initialized");
  }
  control._base = reactorBase(parent, control);
  return control;
}

util_extend(reactors_Reactor.prototype, {
  start: function () {
    start(this._base);
    return this;
  },
  stop: function () {
    stop(this._base);
    return this;
  },
  force: function () {
    force(this._base);
    return this;
  },
  isActive: function () {
    return this._base.active;
  },
  orphan: function () {
    orphan(this._base);
    return this;
  },
  adopt: function (child) {
    if (child._type !== types_REACTION) {
      throw Error("reactors can only adopt reactors");
    }
    adopt(this._base, child._base);
    return this;
  }
});

function reactors_StandardReactor (f) {
  /*jshint validthis:true */
  this._type = types_REACTION;
  this.react = f;
}

util_extend(reactors_StandardReactor.prototype, reactors_Reactor.prototype);

function reactors_anonymousReactor (descriptor) {
  return util_extend(new reactors_Reactor(), descriptor);
}

function derivable_createPrototype (D, opts) {
  var x = {
    /**
     * Creates a derived value whose state will always be f applied to this
     * value
     */
    derive: function (f, a, b, c, d) {
      var that = this;
      switch (arguments.length) {
      case 0:
        return that;
      case 1:
        switch (typeof f) {
          case 'function':
            return D.derivation(function () {
              return f(that.get());
            });
          case 'string':
          case 'number':
            return D.derivation(function () {
              return that.get()[D.unpack(f)];
            });
          default:
            if (f instanceof Array) {
              return f.map(function (x) {
                return that.derive(x);
              });
            } else if (f instanceof RegExp) {
              return D.derivation(function () {
                return that.get().match(f);
              });
            } else if (D.isDerivable(f)) {
              return D.derivation(function () {
                var deriver = f.get();
                var thing = that.get();
                switch (typeof deriver) {
                  case 'function':
                    return deriver(thing);
                  case 'string':
                  case 'number':
                    return thing[deriver];
                  default:
                    if (deriver instanceof RegExp) {
                      return thing.match(deriver);
                    } else {
                      throw Error('type error');
                    }
                }
                return that.get()[D.unpack(f)];
              });
            } else {
              throw Error('type error');
            }
        }
        break;
      case 2:
        return D.derivation(function () {
          return f(that.get(), D.unpack(a));
        });
      case 3:
        return D.derivation(function () {
          return f(that.get(), D.unpack(a), D.unpack(b));
        });
      case 4:
        return D.derivation(function () {
          return f(that.get(),
                   D.unpack(a),
                   D.unpack(b),
                   D.unpack(c));
        });
      case 5:
        return D.derivation(function () {
          return f(that.get(),
                   D.unpack(a),
                   D.unpack(b),
                   D.unpack(c),
                   D.unpack(d));
        });
      default:
        var args = ([that]).concat(util_slice(arguments, 1));
        return D.derivation(function () {
          return f.apply(null, args.map(D.unpack));
        });
      }
    },



    reactor: function (f) {
      if (typeof f === 'function') {
        return reactors_createBase(new reactors_StandardReactor(f), this);
      } else if (f instanceof reactors_Reactor) {
        return reactors_createBase(f, this);
      } else if (f && f.react) {
        return reactors_createBase(reactors_anonymousReactor(f), this);
      } else {
        throw new Error("Unrecognized type for reactor " + f);
      }
    },

    react: function (f, opts) {
      if (typeof f !== 'function') {
        throw Error('the first argument to .react must be a function');
      }

      opts = Object.assign({
        once: false,
        from: true,
        until: false,
        when: true,
        skipFirst: false,
      }, opts);

      // coerce fn or bool to derivable<bool>
      function condDerivable(fOrD, name) {
        if (!D.isDerivable(fOrD)) {
          if (typeof fOrD === 'function') {
            fOrD = D.derivation(fOrD);
          } else if (typeof fOrD === 'boolean') {
            fOrD = D.atom(fOrD);
          } else {
            throw Error('react ' + name + ' condition must be derivable');
          }
        }
        return fOrD.derive(function (x) { return !!x; });
      }

      // wrap reactor so f doesn't get a .this context, and to allow
      // stopping after one reaction if desired.
      var reactor = this.reactor({
        react: function (val) {
          if (opts.skipFirst) {
            opts.skipFirst = false;
          } else {
            f(val);
            if (opts.once) {
              this.stop();
              controller.stop();
            }
          }
        },
        onStart: opts.onStart,
        onStop: opts.onStop
      });

      // listen to when and until conditions, starting and stopping the
      // reactor as appropriate, and stopping this controller when until
      // condition becomes true
      var controller = D.struct({
        until: condDerivable(opts.until, 'until'),
        when: condDerivable(opts.when, 'when')
      }).reactor(function (conds) {
        if (conds.until) {
          reactor.stop();
          this.stop();
        } else if (conds.when) {
          if (!reactor.isActive()) {
            reactor.start().force();
          }
        } else if (reactor.isActive()) {
          reactor.stop();
        }
      });

      // listen to from condition, starting the reactor controller
      // when appropriate
      condDerivable(opts.from, 'from').reactor(function (from) {
        if (from) {
          controller.start().force();
          this.stop();
        }
      }).start().force();
    },

    get: function () {
      parents_maybeCaptureParent(this);
      return this._get(); // abstract protected method, in Java parlance
    },

    is: function (other) {
      return D.lift(opts.equals)(this, other);
    },

    and: function (other) {
      return this.derive(function (x) {return x && D.unpack(other);});
    },

    or: function (other) {
      return this.derive(function (x) {return x || D.unpack(other);});
    },

    then: function (thenClause, elseClause) {
      return this.derive(function (x) {
        return D.unpack(x ? thenClause : elseClause);
      });
    },

    mThen: function (thenClause, elseClause) {
      return this.derive(function (x) {
        return D.unpack(util_some(x) ? thenClause : elseClause);
      });
    },

    mOr: function (other) {
      return this.mThen(this, other);
    },

    mDerive: function (arg) {
      if (arguments.length === 1 && arg instanceof Array) {
        var that = this;
        return arg.map(function (a) { return that.mDerive(a); });
      } else {
        return this.mThen(this.derive.apply(this, arguments));
      }
    },

    mAnd: function (other) {
      return this.mThen(other, this);
    },

    not: function () {
      return this.derive(function (x) { return !x; });
    },

    withEquality: function (equals) {
      if (equals) {
        if (typeof equals !== 'function') {
          throw new Error('equals must be function');
        }
      } else {
        equals = null;
      }

      return util_setEquals(this._clone(), equals);
    },
  };

  x.switch = function () {
    var args = arguments;
    return this.derive(function (x) {
      var i;
      for (i = 0; i < args.length-1; i+=2) {
        if (opts.equals(x, D.unpack(args[i]))) {
          return D.unpack(args[i+1]);
        }
      }
      if (i === args.length - 1) {
        return D.unpack(args[i]);
      }
    });
  };

  return x;
}

function derivation_createPrototype (D, opts) {
  return {
    _clone: function () {
      return util_setEquals(D.derivation(this._deriver), this._equals);
    },

    _forceGet: function () {
      var that = this,
          i;
      var newParents = parents_capturingParents(function () {
        var newState;
        if (!util_DEBUG_MODE) {
          newState = that._deriver();
        } else {
          try {
            newState = that._deriver();
          } catch (e) {
            console.error(that._stack);
            throw e;
          }
        }
        var equals = that._equals || opts.equals;
        that._state = equals(newState, that._value) ? gc_UNCHANGED : gc_CHANGED;
        that._value = newState;
      });

      // organise parents
      for (i = this._parents.length; i--;) {
        var possiblyFormerParent = this._parents[i];
        if (!util_arrayContains(newParents, possiblyFormerParent)) {
          util_removeFromArray(possiblyFormerParent._children, this);
        }
      }

      this._parents = newParents;

      // add this as child to new parents
      for (i = newParents.length; i--;) {
        util_addToArray(newParents[i]._children, this);
      }
    },

    _get: function () {
      var i, parent;
      outer: switch (this._state) {
      case gc_NEW:
      case gc_ORPHANED:
        this._forceGet();
        break;
      case gc_UNSTABLE:
        for (i = 0; i < this._parents.length; i++) {
          parent = this._parents[i];
          var parentState = parent._state;
          if (parentState === gc_UNSTABLE ||
              parentState === gc_ORPHANED ||
              parentState === gc_DISOWNED) {
            parent._get();
          }
          parentState = parent._state;
          if (parentState === gc_CHANGED) {
            this._forceGet();
            break outer;
          } else if (!(parentState === gc_STABLE ||
                       parentState === gc_UNCHANGED)) {
            throw new Error("invalid parent mode: " + parentState);
          }
        }
        this._state = gc_UNCHANGED;
        break;
      case gc_DISOWNED:
        var parents = [];
        for (i = 0; i < this._parents.length; i++) {
          var parentStateTuple = this._parents[i],
              state = parentStateTuple[1];
          parent = parentStateTuple[0];
          if (!opts.equals(parent._get(), state)) {
            this._parents = [];
            this._forceGet();
            break outer;
          } else {
            parents.push(parent);
          }
        }
        for (i = parents.length; i--;) {
          util_addToArray(parents[i]._children, this);
        }
        this._parents = parents;
        this._state = gc_UNCHANGED;
        break;
      default:
        // noop
      }

      return this._value;
    }
  }
}

function derivation_construct(obj, deriver) {
  obj._children = [];
  obj._parents = [];
  obj._deriver = deriver;
  obj._state = gc_NEW;
  obj._type = types_DERIVATION;
  obj._value = util_unique;
  obj._equals = null;

  if (util_DEBUG_MODE) {
    obj._stack = Error().stack;
  }

  return obj;
}

function mutable_createPrototype (D, _) {
  return {
    swap: function (f) {
      var args = util_slice(arguments, 0);
      args[0] = this.get();
      return this.set(f.apply(null, args));
    },
    lens: function (monoLensDescriptor) {
      var that = this;
      return D.lens({
        get: function () {
          return monoLensDescriptor.get(that.get());
        },
        set: function (val) {
          that.set(monoLensDescriptor.set(that.get(), val));
        }
      });
    }
  }
}

function lens_createPrototype(D, _) {
  return {
    _clone: function () {
      return util_setEquals(D.lens(this._lensDescriptor), this._equals);
    },

    set: function (value) {
      var that = this;
      D.atomically(function () {
        that._lensDescriptor.set(value);
      });
      return this;
    }
  }
}

function lens_construct(derivation, descriptor) {
  derivation._lensDescriptor = descriptor;
  derivation._type = types_LENS;

  return derivation;
}

function processReactorQueue (rq) {
  for (var i = rq.length; i--;) {
    reactors_maybeReact(rq[i]);
  }
}

var TXN_CTX = transactions_newContext();

function atom_inTxn () {
  return transactions_inTransaction(TXN_CTX)
}

var NOOP_ARRAY = {push: function () {}};

function TransactionState () {
  this.inTxnValues = {};
  this.reactorQueue = [];
}

function getState (txnState, atom) {
  var inTxnValue = txnState.inTxnValues[atom._uid];
  if (inTxnValue) {
    return inTxnValue[1];
  } else {
    return atom._value;
  }
}

function setState (txnState, atom, state) {
  txnState.inTxnValues[atom._uid] = [atom, state];
  gc_mark(atom, txnState.reactorQueue);
}

util_extend(TransactionState.prototype, {
  onCommit: function () {
    var i, atomValueTuple;
    var keys = util_keys(this.inTxnValues);
    if (atom_inTxn()) {
      // push in-txn vals up to current txn
      for (i = keys.length; i--;) {
        atomValueTuple = this.inTxnValues[keys[i]];
        atomValueTuple[0].set(atomValueTuple[1]);
      }
    } else {
      // change root state and run reactors.
      for (i = keys.length; i--;) {
        atomValueTuple = this.inTxnValues[keys[i]];
        atomValueTuple[0]._value = atomValueTuple[1];
        gc_mark(atomValueTuple[0], NOOP_ARRAY);
      }

      processReactorQueue(this.reactorQueue);

      // then sweep for a clean finish
      for (i = keys.length; i--;) {
        gc_sweep(this.inTxnValues[keys[i]][0]);
      }
    }
  },

  onAbort: function () {
    if (!atom_inTxn()) {
      var keys = util_keys(this.inTxnValues);
      for (var i = keys.length; i--;) {
        gc_abort_sweep(this.inTxnValues[keys[i]][0]);
      }
    }
  }
})


function atom_createPrototype (D, opts) {
  return {
    _clone: function () {
      return util_setEquals(D.atom(this._value), this._equals);
    },

    withValidator: function (f) {
      if (f === null) {
        return this._clone();
      } if (typeof f === 'function') {
        var result = this._clone();
        var existing = this._validator;
        if (existing) {
          result._validator = function (x) { return f(x) && existing(x); }
        } else {
          result._validator = f;
        }
        return result;
      } else {
        throw new Error(".withValidator expects function or null");
      }
    },

    validate: function () {
      this._validate(this.get());
    },

    _validate: function (value) {
      var validationResult = this._validator && this._validator(value);
      if (this._validator && validationResult !== true) {
        throw new Error("Failed validation with value: '" + value + "'." +
                        " Validator returned '" + validationResult + "' ");
      }
    },

    set: function (value) {

      this._validate(value);
      var equals = this._equals || opts.equals;
      if (!equals(value, this._value)) {
        this._state = gc_CHANGED;

        if (atom_inTxn()) {
          setState(transactions_currentTransaction(TXN_CTX), this, value);
        } else {
          this._value = value;

          var reactorQueue = [];
          gc_mark(this, reactorQueue);
          processReactorQueue(reactorQueue);
          gc_sweep(this);
        }
      }
      return this;
    },

    _get: function () {
      if (atom_inTxn()) {
        return getState(transactions_currentTransaction(TXN_CTX), this);
      }
      return this._value;
    }
  };
}

function atom_construct (atom, value) {
  atom._uid = util_nextId();
  atom._children = [];
  atom._state = gc_STABLE;
  atom._value = value;
  atom._type = types_ATOM;
  atom._equals = null;
  return atom;
}

function atom_transact (f) {
  transactions_transact(TXN_CTX, new TransactionState(), f);
}

function atom_transaction (f) {
  return function () {
    var args = util_slice(arguments, 0);
    var that = this;
    var result;
    atom_transact(function () {
      result = f.apply(that, args);
    });
    return result;
  }
}

var ticker = null;

function atom_ticker () {
  if (ticker) {
    ticker.refCount++;
  } else {
    ticker = transactions_ticker(TXN_CTX, function () {
      return new TransactionState();
    });
    ticker.refCount = 1;
  }
  var done = false;
  return {
    tick: function () {
      if (done) throw new Error('tyring to use ticker after release');
      ticker.tick();
    },
    release: function () {
      if (done) throw new Error('ticker already released');
      if (--ticker.refCount === 0) {
        ticker.stop();
        ticker = null;
      }
      done = true;
    }
  };
}

var defaultConfig = { equals: util_equals };

function constructModule (config) {
  config = util_extend({}, defaultConfig, config || {});

  var D = {
    transact: atom_transact,
    defaultEquals: util_equals,
    setDebugMode: util_setDebugMode,
    transaction: atom_transaction,
    ticker: atom_ticker,
    Reactor: reactors_Reactor,
    isAtom: function (x) {
      return x && (x._type === types_ATOM || x._type === types_LENS);
    },
    isDerivable: function (x) {
      return x && (x._type === types_ATOM ||
                   x._type === types_LENS ||
                   x._type === types_DERIVATION);
    },
    isDerivation: function (x) {
      return x && (x._type === types_DERIVATION || x._type === types_LENS)
    },
    isLensed: function (x) {
      return x && x._type === types_LENS;
    },
    isReactor: function (x) {
      return x && x._type === types_REACTION;
    },
  };

  var Derivable  = derivable_createPrototype(D, config);
  var Mutable    = mutable_createPrototype(D, config);

  var Atom       = util_extend({}, Mutable, Derivable,
                               atom_createPrototype(D, config));

  var Derivation = util_extend({}, Derivable,
                               derivation_createPrototype(D, config));

  var Lens       = util_extend({}, Mutable, Derivation,
                              lens_createPrototype(D, config));


  /**
   * Constructs a new atom whose state is the given value
   */
  D.atom = function (val) {
    return atom_construct(Object.create(Atom), val);
  };

  /**
   * Returns a copy of f which runs atomically
   */
  D.atomic = function (f) {
    return function () {
      var result;
      var that = this;
      var args = arguments;
      D.atomically(function () {
        result = f.apply(that, args);
      });
      return result;
    }
  };

  D.atomically = function (f) {
    if (atom_inTxn()) {
      f();
    } else {
      D.transact(f);
    }
  };

  D.derivation = function (f) {
    return derivation_construct(Object.create(Derivation), f);
  };

  /**
   * Template string tag for derivable strings
   */
  D.derive = function (parts) {
    var args = util_slice(arguments, 1);
    return D.derivation(function () {
      var s = "";
      for (var i=0; i<parts.length; i++) {
        s += parts[i];
        if (i < args.length) {
          s += D.unpack(args[i]);
        }
      }
      return s;
    });
  };

  /**
   * creates a new lens
   */
  D.lens = function (descriptor) {
    return lens_construct(
      derivation_construct(Object.create(Lens), descriptor.get),
      descriptor
    );
  };

  /**
   * dereferences a thing if it is dereferencable, otherwise just returns it.
   */
  D.unpack = function (thing) {
    if (D.isDerivable(thing)) {
      return thing.get();
    } else {
      return thing;
    }
  };

  /**
   * lifts a non-monadic function to work on derivables
   */
  D.lift = function (f) {
    return function () {
      var args = arguments;
      var that = this;
      return D.derivation(function () {
        return f.apply(that, Array.prototype.map.call(args, D.unpack));
      });
    }
  };

  function deepUnpack (thing) {
    if (D.isDerivable(thing)) {
      return thing.get();
    } else if (thing instanceof Array) {
      return thing.map(deepUnpack);
    } else if (thing.constructor === Object) {
      var result = {};
      var keys = util_keys(thing);
      for (var i = keys.length; i--;) {
        var prop = keys[i];
        result[prop] = deepUnpack(thing[prop]);
      }
      return result;
    } else {
      return thing;
    }
  }

  D.struct = function (arg) {
    if (arg.constructor === Object || arg instanceof Array) {
      return D.derivation(function () {
        return deepUnpack(arg);
      });
    } else {
      throw new Error("`struct` expects plain Object or Array");
    }
  };

  function andOrFn (breakOn) {
    return function () {
      var args = arguments;
      return D.derivation(function () {
        var val;
        for (var i = 0; i < args.length; i++) {
          val = D.unpack(args[i]);
          if (breakOn(val)) {
            break;
          }
        }
        return val;
      });
    }
  }
  function identity (x) { return x; }
  function complement (f) { return function (x) { return !f(x); }}
  D.or = andOrFn(identity);
  D.mOr = andOrFn(util_some);
  D.and = andOrFn(complement(identity));
  D.mAnd = andOrFn(complement(util_some));

  return D;
}

util_extend(exports, constructModule());
exports.withEquality = function (equals) {
  return constructModule({equals: equals});
};
exports['default'] = exports;

});

//# sourceMappingURL=derivable.js.map
},{}]},{},[])
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","dist/derivable.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","// UMD loader\n(function (global, factory) {\n  \"use strict\";\n  if (global && typeof global.define === \"function\" && global.define.amd) {\n    global.define([\"exports\"], factory);\n  } else if (typeof exports !== \"undefined\") {\n    factory(exports);\n  } else {\n    factory(global.Derivable = {});\n  }\n})(this, function (exports) {\n\"use strict\";\n\nvar util_keys = Object.keys;\n\nfunction util_extend(obj) {\n  for (var i = 1; i < arguments.length; i++) {\n    var other = arguments[i];\n    var keys = util_keys(other);\n    for (var j = keys.length; j--;) {\n      var prop = keys[j];\n      obj[prop] = other[prop];\n    }\n  }\n  return obj;\n}\n\nfunction _is(a, b) {\n  // SameValue algorithm\n  if (a === b) { // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n}\n\nfunction util_equals (a, b) {\n  return _is(a, b) || (a && typeof a.equals === 'function' && a.equals(b));\n}\n\nfunction util_addToArray (a, b) {\n  var i = a.indexOf(b);\n  if (i < 0) {\n    a.push(b);\n  }\n}\n\nfunction util_removeFromArray (a, b) {\n  var i = a.indexOf(b);\n  if (i >= 0) {\n    a.splice(i, 1);\n  }\n}\n\nfunction util_arrayContains (a, b) {\n  return a.indexOf(b) >= 0;\n}\n\nvar nextId = 0;\nfunction util_nextId () {\n  return nextId++;\n}\n\nfunction util_slice (a, i) {\n  return Array.prototype.slice.call(a, i);\n}\n\nvar util_unique = Object.freeze({equals: function () { return false; }});\n\nfunction util_some (x) {\n  return (x !== null) && (x !== void 0);\n}\n\nvar util_DEBUG_MODE = false;\nfunction util_setDebugMode(val) {\n  util_DEBUG_MODE = !!val;\n}\n\nfunction util_setEquals(derivable, equals) {\n  derivable._equals = equals;\n  return derivable;\n}\n\n// node modes\nvar gc_NEW = 0,\n    gc_CHANGED = 1,\n    gc_UNCHANGED = 2,\n    gc_ORPHANED = 3,\n    gc_UNSTABLE = 4,\n    gc_STABLE = 5,\n    gc_DISOWNED = 6;\n\nfunction gc_mark(node, reactors) {\n  // make everything unstable\n  if (node._type === types_REACTION) {\n    if (node.reacting) {\n      throw new Error(\"Cycle detected! Don't do this!\");\n    }\n    reactors.push(node);\n  } else {\n    for (var i = node._children.length; i--;) {\n      var child = node._children[i];\n      if (child._state !== gc_UNSTABLE) {\n        child._state = gc_UNSTABLE;\n        gc_mark(child, reactors);\n      }\n    }\n  }\n}\n\nfunction gc_sweep(node) {\n  var i;\n  switch (node._state) {\n  case gc_CHANGED:\n  case gc_UNCHANGED:\n    // changed or unchanged means the node was visited\n    // during the react phase, which means we keep it in\n    // the graph for the next go round\n    for (i = node._children.length; i--;) {\n      var child = node._children[i];\n      gc_sweep(child);\n      if (child._state !== gc_STABLE) {\n        node._children.splice(i, 1);\n      }\n    }\n    node._state = gc_STABLE;\n    break;\n  case gc_UNSTABLE:\n    if (node._type === types_REACTION) {\n      // only happens when reaction created in transaction. see issue #14\n      node._state = gc_STABLE;\n    } else {\n      // unstable means the node was not visited during\n      // the react phase, which means we kick it out of the\n      // graph.\n\n      // but first we check if all of its parents were unchanged\n      // if so, we can avoid recalculating it in future by\n      // caching its parents' current values.\n      var stashedParentStates = [];\n      for (i = node._parents.length; i--;) {\n        var parent = node._parents[i];\n        if (parent._state !== gc_UNCHANGED) {\n          // nope, its parents either have changed or weren't visited,\n          // so we have to orphan this node\n          node._state = gc_ORPHANED;\n          break;\n        }\n        stashedParentStates.push([parent, parent._value]);\n      }\n      if (node._state !== gc_ORPHANED) {\n        node._state = gc_DISOWNED;\n        node._parents = stashedParentStates;\n      }\n    }\n    break;\n  case gc_STABLE:\n  case gc_ORPHANED:\n  case gc_DISOWNED:\n    break;\n  default:\n    throw new Error(\"can't sweep state \" + node._state);\n  }\n}\n\nfunction gc_abort_sweep(node) {\n  // set everything to unstable, kill all derivation caches and disconnect\n  // the graph\n  var doChildren = false;\n  switch (node._type) {\n  case types_ATOM:\n    node._state = gc_STABLE;\n    doChildren = true;\n    break;\n  case types_DERIVATION:\n  case types_LENS:\n    node._state = gc_NEW;\n    node._value = util_unique;\n    doChildren = true;\n    break;\n  case types_REACTION:\n    node._state = gc_STABLE;\n    doChildren = false;\n    break;\n  }\n  if (doChildren) {\n    for (var i = node._children.length; i--;) {\n      gc_abort_sweep(node._children[i]);\n    }\n    node._children = [];\n  }\n}\n\nvar parentsStack = [];\n\nfunction parents_capturingParents(f) {\n  var i = parentsStack.length;\n  parentsStack.push([]);\n  try {\n    f();\n    return parentsStack[i];\n  } finally {\n    parentsStack.pop();\n  }\n}\n\nfunction parents_maybeCaptureParent(p) {\n  if (parentsStack.length > 0) {\n    util_addToArray(parentsStack[parentsStack.length - 1], p);\n  }\n}\n\nvar types_ATOM = \"ATOM\",\n    types_DERIVATION = \"DERIVATION\",\n    types_LENS = \"LENS\",\n    types_REACTION = \"REACTION\";\n\nvar RUNNING = 0,\n    COMPLETED = 1,\n    ABORTED = 3;\n\nvar TransactionAbortion = {};\n\nfunction abortTransaction() {\n  throw TransactionAbortion;\n}\n\nfunction transactions_newContext () {\n  return {currentTxn: null};\n}\n\nfunction transactions_inTransaction (ctx) {\n  return ctx.currentTxn !== null;\n}\n\nfunction transactions_currentTransaction (ctx) {\n  return ctx.currentTxn;\n}\n\nfunction begin (ctx, txn) {\n  txn._parent = ctx.currentTxn;\n  txn._state = RUNNING;\n  ctx.currentTxn = txn;\n}\n\nfunction popTransaction (ctx, cb) {\n  var txn = ctx.currentTxn;\n  ctx.currentTxn = txn._parent;\n  if (txn._state !== RUNNING) {\n    throw new Error(\"unexpected state: \" + txn._state);\n  }\n  cb(txn);\n}\n\nfunction commit (ctx) {\n  popTransaction(ctx, function (txn) {\n    txn._state = COMPLETED;\n    txn.onCommit && txn.onCommit();\n  });\n}\n\nfunction abort (ctx) {\n  popTransaction(ctx, function (txn) {\n    txn._state = ABORTED;\n    txn.onAbort && txn.onAbort();\n  });\n}\n\nfunction transactions_transact (ctx, txn, f) {\n  begin(ctx, txn);\n  try {\n    f(abortTransaction);\n  } catch (e) {\n    abort(ctx);\n    if (e !== TransactionAbortion) {\n      throw e;\n    } else {\n      return;\n    }\n  }\n  commit(ctx);\n}\n\nfunction transactions_ticker (ctx, txnConstructor) {\n  begin(ctx, txnConstructor());\n  var disposed = false;\n  return {\n    tick: function () {\n      if (disposed) throw new Error(\"can't tick disposed ticker\");\n      commit(ctx);\n      begin(ctx, txnConstructor());\n    },\n    stop: function () {\n      if (disposed) throw new Error(\"ticker already disposed\");\n      commit(ctx);\n    }\n  }\n}\n\nfunction reactorBase (parent, control) {\n  var base = {\n    control: control,      // the actual object the user gets\n    parent: parent,        // the parent derivable\n    parentReactor: null,\n    dependentReactors: [],\n    _state: gc_STABLE,\n    active: false,         // whether or not listening for changes in parent\n    _type: types_REACTION,\n    uid: util_nextId(),\n    reacting: false,       // whether or not reaction function being invoked\n    yielding: false,       // whether or not letting parentReactor react first\n  };\n  if (util_DEBUG_MODE) {\n    base.stack = Error().stack;\n  }\n  return base;\n}\nvar cycleMsg = \"Cyclical Reactor Dependency! Not allowed!\";\n\nfunction stop (base) {\n  if (base.active) {\n    util_removeFromArray(base.parent._children, base);\n    if (base.parentReactor) {\n      orphan(base);\n    }\n    base.active = false;\n    base.control.onStop && base.control.onStop();\n  }\n}\n\nvar parentReactorStack = [];\n\nfunction start (base) {\n  if (!base.active) {\n    util_addToArray(base.parent._children, base);\n    base.active = true;\n    base.parent._get();\n    // capture reactor dependency relationships\n    var len = parentReactorStack.length;\n    if (len > 0) {\n      base.parentReactor = parentReactorStack[len - 1];\n    }\n\n    base.control.onStart && base.control.onStart();\n  }\n}\n\nfunction orphan (base) {\n  if (base.parentReactor) {\n    base.parentReactor = null;\n  }\n}\n\nfunction adopt (parentBase, childBase) {\n  childBase.parentReactor = parentBase;\n}\n\nfunction reactors_maybeReact (base) {\n  if (base.yielding) {\n    throw Error(cycleMsg);\n  }\n  if (base.active && base._state === gc_UNSTABLE) {\n    if (base.parentReactor !== null) {\n      try {\n        base.yielding = true;\n        reactors_maybeReact(base.parentReactor);\n      } finally {\n        base.yielding = false;\n      }\n    }\n    // parent might have deactivated this one\n    if (base.active) {\n      var parent = base.parent, parentState = parent._state;\n      if (parentState === gc_UNSTABLE ||\n          parentState === gc_ORPHANED ||\n          parentState === gc_DISOWNED ||\n          parentState === gc_NEW) {\n        parent._get();\n      }\n      parentState = parent._state;\n\n      if (parentState === gc_UNCHANGED) {\n        base._state = gc_STABLE;\n      } else if (parentState === gc_CHANGED) {\n        force(base);\n      } else {\n          throw new Error(\"invalid parent state: \" + parentState);\n      }\n    }\n  }\n}\n\nfunction force (base) {\n  // base.reacting check now in gc_mark; total solution there as opposed to here\n  if (base.control.react) {\n    base._state = gc_STABLE;\n    try {\n      base.reacting = true;\n      parentReactorStack.push(base);\n      if (!util_DEBUG_MODE) {\n        base.control.react(base.parent._get());\n      } else {\n        try {\n          base.control.react(base.parent._get());\n        } catch (e) {\n          console.error(base.stack);\n          throw e;\n        }\n      }\n    } finally {\n      parentReactorStack.pop();\n      base.reacting = false;\n    }\n  } else {\n      throw new Error(\"No reactor function available.\");\n  }\n}\n\nfunction reactors_Reactor () {\n  /*jshint validthis:true */\n  this._type = types_REACTION;\n}\n\nfunction reactors_createBase (control, parent) {\n  if (control._base) {\n    throw new Error(\"This reactor has already been initialized\");\n  }\n  control._base = reactorBase(parent, control);\n  return control;\n}\n\nutil_extend(reactors_Reactor.prototype, {\n  start: function () {\n    start(this._base);\n    return this;\n  },\n  stop: function () {\n    stop(this._base);\n    return this;\n  },\n  force: function () {\n    force(this._base);\n    return this;\n  },\n  isActive: function () {\n    return this._base.active;\n  },\n  orphan: function () {\n    orphan(this._base);\n    return this;\n  },\n  adopt: function (child) {\n    if (child._type !== types_REACTION) {\n      throw Error(\"reactors can only adopt reactors\");\n    }\n    adopt(this._base, child._base);\n    return this;\n  }\n});\n\nfunction reactors_StandardReactor (f) {\n  /*jshint validthis:true */\n  this._type = types_REACTION;\n  this.react = f;\n}\n\nutil_extend(reactors_StandardReactor.prototype, reactors_Reactor.prototype);\n\nfunction reactors_anonymousReactor (descriptor) {\n  return util_extend(new reactors_Reactor(), descriptor);\n}\n\nfunction derivable_createPrototype (D, opts) {\n  var x = {\n    /**\n     * Creates a derived value whose state will always be f applied to this\n     * value\n     */\n    derive: function (f, a, b, c, d) {\n      var that = this;\n      switch (arguments.length) {\n      case 0:\n        return that;\n      case 1:\n        switch (typeof f) {\n          case 'function':\n            return D.derivation(function () {\n              return f(that.get());\n            });\n          case 'string':\n          case 'number':\n            return D.derivation(function () {\n              return that.get()[D.unpack(f)];\n            });\n          default:\n            if (f instanceof Array) {\n              return f.map(function (x) {\n                return that.derive(x);\n              });\n            } else if (f instanceof RegExp) {\n              return D.derivation(function () {\n                return that.get().match(f);\n              });\n            } else if (D.isDerivable(f)) {\n              return D.derivation(function () {\n                var deriver = f.get();\n                var thing = that.get();\n                switch (typeof deriver) {\n                  case 'function':\n                    return deriver(thing);\n                  case 'string':\n                  case 'number':\n                    return thing[deriver];\n                  default:\n                    if (deriver instanceof RegExp) {\n                      return thing.match(deriver);\n                    } else {\n                      throw Error('type error');\n                    }\n                }\n                return that.get()[D.unpack(f)];\n              });\n            } else {\n              throw Error('type error');\n            }\n        }\n        break;\n      case 2:\n        return D.derivation(function () {\n          return f(that.get(), D.unpack(a));\n        });\n      case 3:\n        return D.derivation(function () {\n          return f(that.get(), D.unpack(a), D.unpack(b));\n        });\n      case 4:\n        return D.derivation(function () {\n          return f(that.get(),\n                   D.unpack(a),\n                   D.unpack(b),\n                   D.unpack(c));\n        });\n      case 5:\n        return D.derivation(function () {\n          return f(that.get(),\n                   D.unpack(a),\n                   D.unpack(b),\n                   D.unpack(c),\n                   D.unpack(d));\n        });\n      default:\n        var args = ([that]).concat(util_slice(arguments, 1));\n        return D.derivation(function () {\n          return f.apply(null, args.map(D.unpack));\n        });\n      }\n    },\n\n\n\n    reactor: function (f) {\n      if (typeof f === 'function') {\n        return reactors_createBase(new reactors_StandardReactor(f), this);\n      } else if (f instanceof reactors_Reactor) {\n        return reactors_createBase(f, this);\n      } else if (f && f.react) {\n        return reactors_createBase(reactors_anonymousReactor(f), this);\n      } else {\n        throw new Error(\"Unrecognized type for reactor \" + f);\n      }\n    },\n\n    react: function (f, opts) {\n      if (typeof f !== 'function') {\n        throw Error('the first argument to .react must be a function');\n      }\n\n      opts = Object.assign({\n        once: false,\n        from: true,\n        until: false,\n        when: true,\n        skipFirst: false,\n      }, opts);\n\n      // coerce fn or bool to derivable<bool>\n      function condDerivable(fOrD, name) {\n        if (!D.isDerivable(fOrD)) {\n          if (typeof fOrD === 'function') {\n            fOrD = D.derivation(fOrD);\n          } else if (typeof fOrD === 'boolean') {\n            fOrD = D.atom(fOrD);\n          } else {\n            throw Error('react ' + name + ' condition must be derivable');\n          }\n        }\n        return fOrD.derive(function (x) { return !!x; });\n      }\n\n      // wrap reactor so f doesn't get a .this context, and to allow\n      // stopping after one reaction if desired.\n      var reactor = this.reactor({\n        react: function (val) {\n          if (opts.skipFirst) {\n            opts.skipFirst = false;\n          } else {\n            f(val);\n            if (opts.once) {\n              this.stop();\n              controller.stop();\n            }\n          }\n        },\n        onStart: opts.onStart,\n        onStop: opts.onStop\n      });\n\n      // listen to when and until conditions, starting and stopping the\n      // reactor as appropriate, and stopping this controller when until\n      // condition becomes true\n      var controller = D.struct({\n        until: condDerivable(opts.until, 'until'),\n        when: condDerivable(opts.when, 'when')\n      }).reactor(function (conds) {\n        if (conds.until) {\n          reactor.stop();\n          this.stop();\n        } else if (conds.when) {\n          if (!reactor.isActive()) {\n            reactor.start().force();\n          }\n        } else if (reactor.isActive()) {\n          reactor.stop();\n        }\n      });\n\n      // listen to from condition, starting the reactor controller\n      // when appropriate\n      condDerivable(opts.from, 'from').reactor(function (from) {\n        if (from) {\n          controller.start().force();\n          this.stop();\n        }\n      }).start().force();\n    },\n\n    get: function () {\n      parents_maybeCaptureParent(this);\n      return this._get(); // abstract protected method, in Java parlance\n    },\n\n    is: function (other) {\n      return D.lift(opts.equals)(this, other);\n    },\n\n    and: function (other) {\n      return this.derive(function (x) {return x && D.unpack(other);});\n    },\n\n    or: function (other) {\n      return this.derive(function (x) {return x || D.unpack(other);});\n    },\n\n    then: function (thenClause, elseClause) {\n      return this.derive(function (x) {\n        return D.unpack(x ? thenClause : elseClause);\n      });\n    },\n\n    mThen: function (thenClause, elseClause) {\n      return this.derive(function (x) {\n        return D.unpack(util_some(x) ? thenClause : elseClause);\n      });\n    },\n\n    mOr: function (other) {\n      return this.mThen(this, other);\n    },\n\n    mDerive: function (arg) {\n      if (arguments.length === 1 && arg instanceof Array) {\n        var that = this;\n        return arg.map(function (a) { return that.mDerive(a); });\n      } else {\n        return this.mThen(this.derive.apply(this, arguments));\n      }\n    },\n\n    mAnd: function (other) {\n      return this.mThen(other, this);\n    },\n\n    not: function () {\n      return this.derive(function (x) { return !x; });\n    },\n\n    withEquality: function (equals) {\n      if (equals) {\n        if (typeof equals !== 'function') {\n          throw new Error('equals must be function');\n        }\n      } else {\n        equals = null;\n      }\n\n      return util_setEquals(this._clone(), equals);\n    },\n  };\n\n  x.switch = function () {\n    var args = arguments;\n    return this.derive(function (x) {\n      var i;\n      for (i = 0; i < args.length-1; i+=2) {\n        if (opts.equals(x, D.unpack(args[i]))) {\n          return D.unpack(args[i+1]);\n        }\n      }\n      if (i === args.length - 1) {\n        return D.unpack(args[i]);\n      }\n    });\n  };\n\n  return x;\n}\n\nfunction derivation_createPrototype (D, opts) {\n  return {\n    _clone: function () {\n      return util_setEquals(D.derivation(this._deriver), this._equals);\n    },\n\n    _forceGet: function () {\n      var that = this,\n          i;\n      var newParents = parents_capturingParents(function () {\n        var newState;\n        if (!util_DEBUG_MODE) {\n          newState = that._deriver();\n        } else {\n          try {\n            newState = that._deriver();\n          } catch (e) {\n            console.error(that._stack);\n            throw e;\n          }\n        }\n        var equals = that._equals || opts.equals;\n        that._state = equals(newState, that._value) ? gc_UNCHANGED : gc_CHANGED;\n        that._value = newState;\n      });\n\n      // organise parents\n      for (i = this._parents.length; i--;) {\n        var possiblyFormerParent = this._parents[i];\n        if (!util_arrayContains(newParents, possiblyFormerParent)) {\n          util_removeFromArray(possiblyFormerParent._children, this);\n        }\n      }\n\n      this._parents = newParents;\n\n      // add this as child to new parents\n      for (i = newParents.length; i--;) {\n        util_addToArray(newParents[i]._children, this);\n      }\n    },\n\n    _get: function () {\n      var i, parent;\n      outer: switch (this._state) {\n      case gc_NEW:\n      case gc_ORPHANED:\n        this._forceGet();\n        break;\n      case gc_UNSTABLE:\n        for (i = 0; i < this._parents.length; i++) {\n          parent = this._parents[i];\n          var parentState = parent._state;\n          if (parentState === gc_UNSTABLE ||\n              parentState === gc_ORPHANED ||\n              parentState === gc_DISOWNED) {\n            parent._get();\n          }\n          parentState = parent._state;\n          if (parentState === gc_CHANGED) {\n            this._forceGet();\n            break outer;\n          } else if (!(parentState === gc_STABLE ||\n                       parentState === gc_UNCHANGED)) {\n            throw new Error(\"invalid parent mode: \" + parentState);\n          }\n        }\n        this._state = gc_UNCHANGED;\n        break;\n      case gc_DISOWNED:\n        var parents = [];\n        for (i = 0; i < this._parents.length; i++) {\n          var parentStateTuple = this._parents[i],\n              state = parentStateTuple[1];\n          parent = parentStateTuple[0];\n          if (!opts.equals(parent._get(), state)) {\n            this._parents = [];\n            this._forceGet();\n            break outer;\n          } else {\n            parents.push(parent);\n          }\n        }\n        for (i = parents.length; i--;) {\n          util_addToArray(parents[i]._children, this);\n        }\n        this._parents = parents;\n        this._state = gc_UNCHANGED;\n        break;\n      default:\n        // noop\n      }\n\n      return this._value;\n    }\n  }\n}\n\nfunction derivation_construct(obj, deriver) {\n  obj._children = [];\n  obj._parents = [];\n  obj._deriver = deriver;\n  obj._state = gc_NEW;\n  obj._type = types_DERIVATION;\n  obj._value = util_unique;\n  obj._equals = null;\n\n  if (util_DEBUG_MODE) {\n    obj._stack = Error().stack;\n  }\n\n  return obj;\n}\n\nfunction mutable_createPrototype (D, _) {\n  return {\n    swap: function (f) {\n      var args = util_slice(arguments, 0);\n      args[0] = this.get();\n      return this.set(f.apply(null, args));\n    },\n    lens: function (monoLensDescriptor) {\n      var that = this;\n      return D.lens({\n        get: function () {\n          return monoLensDescriptor.get(that.get());\n        },\n        set: function (val) {\n          that.set(monoLensDescriptor.set(that.get(), val));\n        }\n      });\n    }\n  }\n}\n\nfunction lens_createPrototype(D, _) {\n  return {\n    _clone: function () {\n      return util_setEquals(D.lens(this._lensDescriptor), this._equals);\n    },\n\n    set: function (value) {\n      var that = this;\n      D.atomically(function () {\n        that._lensDescriptor.set(value);\n      });\n      return this;\n    }\n  }\n}\n\nfunction lens_construct(derivation, descriptor) {\n  derivation._lensDescriptor = descriptor;\n  derivation._type = types_LENS;\n\n  return derivation;\n}\n\nfunction processReactorQueue (rq) {\n  for (var i = rq.length; i--;) {\n    reactors_maybeReact(rq[i]);\n  }\n}\n\nvar TXN_CTX = transactions_newContext();\n\nfunction atom_inTxn () {\n  return transactions_inTransaction(TXN_CTX)\n}\n\nvar NOOP_ARRAY = {push: function () {}};\n\nfunction TransactionState () {\n  this.inTxnValues = {};\n  this.reactorQueue = [];\n}\n\nfunction getState (txnState, atom) {\n  var inTxnValue = txnState.inTxnValues[atom._uid];\n  if (inTxnValue) {\n    return inTxnValue[1];\n  } else {\n    return atom._value;\n  }\n}\n\nfunction setState (txnState, atom, state) {\n  txnState.inTxnValues[atom._uid] = [atom, state];\n  gc_mark(atom, txnState.reactorQueue);\n}\n\nutil_extend(TransactionState.prototype, {\n  onCommit: function () {\n    var i, atomValueTuple;\n    var keys = util_keys(this.inTxnValues);\n    if (atom_inTxn()) {\n      // push in-txn vals up to current txn\n      for (i = keys.length; i--;) {\n        atomValueTuple = this.inTxnValues[keys[i]];\n        atomValueTuple[0].set(atomValueTuple[1]);\n      }\n    } else {\n      // change root state and run reactors.\n      for (i = keys.length; i--;) {\n        atomValueTuple = this.inTxnValues[keys[i]];\n        atomValueTuple[0]._value = atomValueTuple[1];\n        gc_mark(atomValueTuple[0], NOOP_ARRAY);\n      }\n\n      processReactorQueue(this.reactorQueue);\n\n      // then sweep for a clean finish\n      for (i = keys.length; i--;) {\n        gc_sweep(this.inTxnValues[keys[i]][0]);\n      }\n    }\n  },\n\n  onAbort: function () {\n    if (!atom_inTxn()) {\n      var keys = util_keys(this.inTxnValues);\n      for (var i = keys.length; i--;) {\n        gc_abort_sweep(this.inTxnValues[keys[i]][0]);\n      }\n    }\n  }\n})\n\n\nfunction atom_createPrototype (D, opts) {\n  return {\n    _clone: function () {\n      return util_setEquals(D.atom(this._value), this._equals);\n    },\n\n    withValidator: function (f) {\n      if (f === null) {\n        return this._clone();\n      } if (typeof f === 'function') {\n        var result = this._clone();\n        var existing = this._validator;\n        if (existing) {\n          result._validator = function (x) { return f(x) && existing(x); }\n        } else {\n          result._validator = f;\n        }\n        return result;\n      } else {\n        throw new Error(\".withValidator expects function or null\");\n      }\n    },\n\n    validate: function () {\n      this._validate(this.get());\n    },\n\n    _validate: function (value) {\n      var validationResult = this._validator && this._validator(value);\n      if (this._validator && validationResult !== true) {\n        throw new Error(\"Failed validation with value: '\" + value + \"'.\" +\n                        \" Validator returned '\" + validationResult + \"' \");\n      }\n    },\n\n    set: function (value) {\n\n      this._validate(value);\n      var equals = this._equals || opts.equals;\n      if (!equals(value, this._value)) {\n        this._state = gc_CHANGED;\n\n        if (atom_inTxn()) {\n          setState(transactions_currentTransaction(TXN_CTX), this, value);\n        } else {\n          this._value = value;\n\n          var reactorQueue = [];\n          gc_mark(this, reactorQueue);\n          processReactorQueue(reactorQueue);\n          gc_sweep(this);\n        }\n      }\n      return this;\n    },\n\n    _get: function () {\n      if (atom_inTxn()) {\n        return getState(transactions_currentTransaction(TXN_CTX), this);\n      }\n      return this._value;\n    }\n  };\n}\n\nfunction atom_construct (atom, value) {\n  atom._uid = util_nextId();\n  atom._children = [];\n  atom._state = gc_STABLE;\n  atom._value = value;\n  atom._type = types_ATOM;\n  atom._equals = null;\n  return atom;\n}\n\nfunction atom_transact (f) {\n  transactions_transact(TXN_CTX, new TransactionState(), f);\n}\n\nfunction atom_transaction (f) {\n  return function () {\n    var args = util_slice(arguments, 0);\n    var that = this;\n    var result;\n    atom_transact(function () {\n      result = f.apply(that, args);\n    });\n    return result;\n  }\n}\n\nvar ticker = null;\n\nfunction atom_ticker () {\n  if (ticker) {\n    ticker.refCount++;\n  } else {\n    ticker = transactions_ticker(TXN_CTX, function () {\n      return new TransactionState();\n    });\n    ticker.refCount = 1;\n  }\n  var done = false;\n  return {\n    tick: function () {\n      if (done) throw new Error('tyring to use ticker after release');\n      ticker.tick();\n    },\n    release: function () {\n      if (done) throw new Error('ticker already released');\n      if (--ticker.refCount === 0) {\n        ticker.stop();\n        ticker = null;\n      }\n      done = true;\n    }\n  };\n}\n\nvar defaultConfig = { equals: util_equals };\n\nfunction constructModule (config) {\n  config = util_extend({}, defaultConfig, config || {});\n\n  var D = {\n    transact: atom_transact,\n    defaultEquals: util_equals,\n    setDebugMode: util_setDebugMode,\n    transaction: atom_transaction,\n    ticker: atom_ticker,\n    Reactor: reactors_Reactor,\n    isAtom: function (x) {\n      return x && (x._type === types_ATOM || x._type === types_LENS);\n    },\n    isDerivable: function (x) {\n      return x && (x._type === types_ATOM ||\n                   x._type === types_LENS ||\n                   x._type === types_DERIVATION);\n    },\n    isDerivation: function (x) {\n      return x && (x._type === types_DERIVATION || x._type === types_LENS)\n    },\n    isLensed: function (x) {\n      return x && x._type === types_LENS;\n    },\n    isReactor: function (x) {\n      return x && x._type === types_REACTION;\n    },\n  };\n\n  var Derivable  = derivable_createPrototype(D, config);\n  var Mutable    = mutable_createPrototype(D, config);\n\n  var Atom       = util_extend({}, Mutable, Derivable,\n                               atom_createPrototype(D, config));\n\n  var Derivation = util_extend({}, Derivable,\n                               derivation_createPrototype(D, config));\n\n  var Lens       = util_extend({}, Mutable, Derivation,\n                              lens_createPrototype(D, config));\n\n\n  /**\n   * Constructs a new atom whose state is the given value\n   */\n  D.atom = function (val) {\n    return atom_construct(Object.create(Atom), val);\n  };\n\n  /**\n   * Returns a copy of f which runs atomically\n   */\n  D.atomic = function (f) {\n    return function () {\n      var result;\n      var that = this;\n      var args = arguments;\n      D.atomically(function () {\n        result = f.apply(that, args);\n      });\n      return result;\n    }\n  };\n\n  D.atomically = function (f) {\n    if (atom_inTxn()) {\n      f();\n    } else {\n      D.transact(f);\n    }\n  };\n\n  D.derivation = function (f) {\n    return derivation_construct(Object.create(Derivation), f);\n  };\n\n  /**\n   * Template string tag for derivable strings\n   */\n  D.derive = function (parts) {\n    var args = util_slice(arguments, 1);\n    return D.derivation(function () {\n      var s = \"\";\n      for (var i=0; i<parts.length; i++) {\n        s += parts[i];\n        if (i < args.length) {\n          s += D.unpack(args[i]);\n        }\n      }\n      return s;\n    });\n  };\n\n  /**\n   * creates a new lens\n   */\n  D.lens = function (descriptor) {\n    return lens_construct(\n      derivation_construct(Object.create(Lens), descriptor.get),\n      descriptor\n    );\n  };\n\n  /**\n   * dereferences a thing if it is dereferencable, otherwise just returns it.\n   */\n  D.unpack = function (thing) {\n    if (D.isDerivable(thing)) {\n      return thing.get();\n    } else {\n      return thing;\n    }\n  };\n\n  /**\n   * lifts a non-monadic function to work on derivables\n   */\n  D.lift = function (f) {\n    return function () {\n      var args = arguments;\n      var that = this;\n      return D.derivation(function () {\n        return f.apply(that, Array.prototype.map.call(args, D.unpack));\n      });\n    }\n  };\n\n  function deepUnpack (thing) {\n    if (D.isDerivable(thing)) {\n      return thing.get();\n    } else if (thing instanceof Array) {\n      return thing.map(deepUnpack);\n    } else if (thing.constructor === Object) {\n      var result = {};\n      var keys = util_keys(thing);\n      for (var i = keys.length; i--;) {\n        var prop = keys[i];\n        result[prop] = deepUnpack(thing[prop]);\n      }\n      return result;\n    } else {\n      return thing;\n    }\n  }\n\n  D.struct = function (arg) {\n    if (arg.constructor === Object || arg instanceof Array) {\n      return D.derivation(function () {\n        return deepUnpack(arg);\n      });\n    } else {\n      throw new Error(\"`struct` expects plain Object or Array\");\n    }\n  };\n\n  function andOrFn (breakOn) {\n    return function () {\n      var args = arguments;\n      return D.derivation(function () {\n        var val;\n        for (var i = 0; i < args.length; i++) {\n          val = D.unpack(args[i]);\n          if (breakOn(val)) {\n            break;\n          }\n        }\n        return val;\n      });\n    }\n  }\n  function identity (x) { return x; }\n  function complement (f) { return function (x) { return !f(x); }}\n  D.or = andOrFn(identity);\n  D.mOr = andOrFn(util_some);\n  D.and = andOrFn(complement(identity));\n  D.mAnd = andOrFn(complement(util_some));\n\n  return D;\n}\n\nutil_extend(exports, constructModule());\nexports.withEquality = function (equals) {\n  return constructModule({equals: equals});\n};\nexports['default'] = exports;\n\n});\n\n//# sourceMappingURL=derivable.js.map"]}
const d = require("derivable")

const name = d.atom("World");     // the name of the user   
const countryCode = d.atom("en"); // for i18n 
 
// static constants don't need to be wrapped 
const greetings = {
  en: "Hello",
  de: "Hallo",
  es: "Hola",
  cn: "您好",
  fr: "Bonjour",
};
 
// derive a greeting message based on the user's name and country. 
const greeting = countryCode.derive(cc => greetings[cc]);
const message = d.derive`${greeting}, ${name}!`; // es6 tagged template strings! 
 
// set up a Reactor to print the message every time it changes 
message.react(msg => console.log(msg));
// $> Hello, World! 
 
countryCode.set("de");
// $> Hallo, World! 
name.set("Dagmar");
// $> Hallo, Dagmar! 
 
// we can avoid unwanted intermediate reactions by using transactions 
d.transact(() => {
  countryCode.set("fr");
  name.set("Étienne");
});
;}, 0)

package.json

{
  "name": "requirebin-sketch",
  "version": "1.0.0",
  "dependencies": {
    "derivable": "0.12.1"
  }
}

page-body.html

<!-- contents of this file will be placed inside the <body> -->
<div></div>

page-head.html

<!-- contents of this file will be placed inside the <head> -->

requirebin.md

made with requirebin