es5 pretty printer improved

foo.js

function flapjaxInit(options) {
   var defaultOptions = {includeSynonyms: true
                        ,exportMisc: true
                        ,exportCore: true
                        ,exportDOM: true
                        ,exportDOMMisc: true
                        ,exportWS: true
                        ,hide: []
                        ,show: []
                        ,redefine: false};
   if (options === false) {
      options = {hide: [],show: []};
   } else if (options === true || ! options) {
      options = {};
   }
   for (var option in defaultOptions) {
      if (options[option] === undefined) {
         options[option] = defaultOptions[option];
      }
   }
   ;
   var hideArray = options.hide;
   options.hide = {};
   for (var i = 0; i < hideArray.length; i++) {
      options.hide[hideArray[i]] = true;
   }
   var showArray = options.show;
   options.show = {};
   for (var i = 0; i < showArray.length; i++) {
      options.show[showArray[i]] = true;
   }
   var warn = function (s) {
   };
   var flapjax = {version: 4,base: {},combinators: {},behaviours: {},dom: {}};
   var d = flapjax.dom;
   flapjax.pub = {util: flapjax};
   var annotate = function (fn,names,protoArg,protoObjs,protoNames) {
      for (var i = 0; i < names.length; i++) {
         flapjax.pub[names[i]] = fn;
      }
      if (protoArg != undefined) {
         var pf = function () {
            var args = slice(arguments,0);
            args.splice(protoArg,0,this);
            return fn.apply(this,args)
         };
         for (var i = 0; i < protoObjs.length; i++) {
            for (var j = 0; j < protoNames.length; j++) {
               protoObjs[i][protoNames[j]] = pf;
            }
         }
      }
   };
   var exports = {};
   var synonyms = {};
   var misc = {};
   var core = {};
   var dom = {};
   var domMisc = {};
   var ws = {};
   var fxExport = function (exportCategory,exportVal,exportName) {
      if (! (exportCategory instanceof Object)) {
         throw "fxExport: category is " + exportCategory;
      }
      ;
      if (typeof exportName != "string") {
         console.log(exportVal);
         throw "fxExport: name is " + exportName;
      }
      ;
      exportVal.__flapjaxCategory = exportCategory;
      exports[exportName] = exportVal;
      for (var i = 3; i < arguments.length; i++) {
         exports[arguments[i]] = exportVal;
         synonyms[arguments[i]] = true;
      }
   };
   var fxMethodSynonyms = function (obj,method) {
      if (options.includeSynonyms === true) {
         for (var i = 2; i < arguments.length; i++) {
            obj.prototype[arguments[i]] = obj.prototype[method];
         }
         ;
      }
      ;
   };
   var slice = function (arr,start,stop) {
      var i,len = arr.length,r = [];
      if (! stop) {
         stop = len;
      }
      if (stop < 0) {
         stop = len + stop;
      }
      if (start < 0) {
         start = len - start;
      }
      if (stop < start) {
         i = start;
         start = stop;
         stop = i;
      }
      for (i = 0; i < stop - start; i++) {
         r[i] = arr[start + i];
      }
      return r
   };
   var isEqual = function (a,b) {
      return a == b || (typeof a == "number" && isNaN(a) || a == "NaN") && (typeof b ==
                                                                            "number" &&
                                                                            isNaN(b) || b
                                                                            == "NaN")
   };
   var member = function (elt,lst) {
      for (var i = 0; i < lst.length; i++) {
         if (isEqual(lst[i],elt)) {
            return true
         }
      }
      return false
   };
   var zip = function (arrays) {
      if (arrays.length == 0) return []
      var ret = [];
      for (var i = 0; i < arrays[0].length; i++) {
         ret.push([]);
         for (var j = 0; j < arrays.length; j++) ret[i].push(arrays[j][i]);
      }
      return ret
   };
   var map = function (fn) {
      var arrays = slice(arguments,1);
      if (arrays.length === 0) {
         return []
      } else if (arrays.length === 1) {
         var ret = [];
         for (var i = 0; i < arrays[0].length; i++) {
            ret.push(fn(arrays[0][i]));
         }
         return ret
      } else {
         var ret = zip(arrays);
         var o = new Object();
         for (var i = 0; i < ret.length; i++) {
            ret[i] = fn.apply(o,ret[i]);
         }
         return ret
      }
   };
   var filter = function (predFn,arr) {
      var res = [];
      for (var i = 0; i < arr.length; i++) {
         if (predFn(arr[i])) {
            res.push(arr[i]);
         }
      }
      return res
   };
   var fold = function (fn,init) {
      var lists = slice(arguments,2);
      if (lists.length === 0) {
         return init
      } else if (lists.length === 1) {
         var acc = init;
         for (var i = 0; i < lists[0].length; i++) {
            acc = fn(lists[0][i],acc);
         }
         return acc
      } else {
         var acc = init;
         for (var i = 0; i < lists[0].length; i++) {
            var args = map(function (lst) {
                             return lst[i]
                          },lists);
            args.push(acc);
            acc = fn.apply({},args);
         }
         return acc
      }
   };
   var foldR = function (fn,init) {
      var lists = slice(arguments,2);
      if (lists.length === 0) {
         return init
      } else if (lists.length === 1) {
         var acc = init;
         for (var i = lists[0].length - 1; i > - 1; i--) acc = fn(lists[0][i],acc);
         return acc
      } else {
         var acc = init;
         for (var i = lists[0].length - 1; i > - 1; i--) {
            var args = map(function (lst) {
                             return lst[i]
                          },lists);
            args.push(acc);
            acc = fn.apply({},args);
         }
         return acc
      }
   };
   var pushAll = function (destArray,srcArray) {
      for (var i = 0; i < srcArray.length; i++) {
         destArray.push(srcArray[i]);
      }
      return destArray
   };
   fxExport(misc,slice,"slice");
   fxExport(misc,member,"member");
   fxExport(misc,map,"map");
   fxExport(misc,map,"forEach");
   fxExport(misc,filter,"filter");
   fxExport(misc,fold,"fold");
   fxExport(misc,foldR,"foldR");
   var Pulse = function (stamp,value) {
      this.stamp = stamp;
      this.value = value;
   };
   var PQ = function () {
      var ctx = this;
      ctx.val = [];
      this.insert = function (kv) {
             ctx.val.push(kv);
             var kvpos = ctx.val.length - 1;
             while (kvpos > 0 && kv.k < ctx.val[Math.floor((kvpos - 1) / 2)].k) {
                var oldpos = kvpos;
                kvpos = Math.floor((kvpos - 1) / 2);
                ctx.val[oldpos] = ctx.val[kvpos];
                ctx.val[kvpos] = kv;
             }
          };
      this.isEmpty = function () {
             return ctx.val.length === 0
          };
      this.pop = function () {
             if (ctx.val.length == 1) {
                return ctx.val.pop()
             }
             var ret = ctx.val.shift();
             ctx.val.unshift(ctx.val.pop());
             var kvpos = 0;
             var kv = ctx.val[0];
             while (1) {
                var leftChild = kvpos * 2 + 1 < ctx.val.length ? ctx.val[kvpos * 2 + 1].k
                                : kv.k + 1;
                var rightChild = kvpos * 2 + 2 < ctx.val.length ? ctx.val[kvpos * 2 + 2].k
                                 : kv.k + 1;
                if (leftChild > kv.k && rightChild > kv.k) break; else if (leftChild <
                                                                           rightChild) {
                   ctx.val[kvpos] = ctx.val[kvpos * 2 + 1];
                   ctx.val[kvpos * 2 + 1] = kv;
                   kvpos = kvpos * 2 + 1;
                } else {
                   ctx.val[kvpos] = ctx.val[kvpos * 2 + 2];
                   ctx.val[kvpos * 2 + 2] = kv;
                   kvpos = kvpos * 2 + 2;
                }
             }
             return ret
          };
   };
   var lastRank = 0;
   var stamp = 1;
   var nextStamp = function () {
      return ++stamp
   };
   var propagatePulse = function (pulse,node) {
      var queue = new PQ();
      queue.insert({k: node.rank,n: node,v: pulse});
      while (! queue.isEmpty()) {
         var qv = queue.pop();
         qv.n.updater(function (nextPulse) {
                        for (var i = 0; i < qv.n.sendsTo.length; i++)
                        queue.insert({k: qv.n.sendsTo[i].rank
                                     ,n: qv.n.sendsTo[i]
                                     ,v: nextPulse});
                     },new Pulse(qv.v.stamp,qv.v.value));
      }
   };
   var EventStream = function (nodes,updater) {
      this.updater = updater;
      this.sendsTo = [];
      for (var i = 0; i < nodes.length; i++) {
         nodes[i].sendsTo.push(this);
      }
      this.rank = ++lastRank;
   };
   EventStream.prototype = new Object();
   fxExport(core,EventStream,"EventStream");
   var createNode = function (nodes,updater) {
      return new EventStream(nodes,updater)
   };
   var attachListener = function (node,dependent) {
      if (! (node instanceof EventStream)) {
         throw "attachListenenerNode: expects event as first arg";
      }
      if (! (dependent instanceof EventStream)) {
         throw "attachListenenerNode: expects event as second arg";
      }
      node.sendsTo.push(dependent);
      if (node.rank > dependent.rank) {
         var lowest = lastRank + 1;
         var q = [dependent];
         while (q.length) {
            var cur = q.splice(0,1)[0];
            cur.rank = ++lastRank;
            q = q.concat(cur.sendsTo);
         }
      }
   };
   var removeListener = function (node,dependent) {
      if (! (node instanceof EventStream)) {
         throw "removeListenerNode: expects event as first arg";
      }
      if (! (dependent instanceof EventStream)) {
         throw "removeListenenerNode: expects event as second arg";
      }
      var foundSending = false;
      for (var i = 0; i < node.sendsTo.length && ! foundSending; i++) {
         if (node.sendsTo[i] == dependent) {
            node.sendsTo.splice(i,1);
            foundSending = true;
         }
      }
      return foundSending
   };
   var internal_e = function (dependsOn) {
      return createNode(dependsOn || [],function (send,pulse) {
                          send(pulse);
                       })
   };
   var zero_e = function () {
      return createNode([],function (send,pulse) {
                          throw "zero_e : received a value; zero_e should not receive a value; the value was "
                          + pulse.value;
                       })
   };
   fxExport(core,zero_e,"zero_e");
   var one_e = function (val) {
      var sent = false;
      var evt = createNode([],function (send,pulse) {
                             if (sent) {
                                throw "one_e : received an extra value";
                             }
                             sent = true;
                             send(pulse);
                          });
      window.setTimeout(function () {
                          sendEvent(evt,val);
                       },0);
      return evt
   };
   fxExport(core,one_e,"one_e");
   var merge_e = function () {
      if (arguments.length == 0) {
         return zero_e()
      } else {
         var deps = slice(arguments,0);
         return internal_e(deps)
      }
   };
   fxExport(core,merge_e,"merge_e");
   EventStream.prototype.merge_e = function () {
          var deps = slice(arguments,0);
          deps.push(this);
          return internal_e(deps)
       };
   fxMethodSynonyms(EventStream,"merge_e","merge");
   EventStream.prototype.constant_e = function (constantValue) {
          return createNode([this],function (send,pulse) {
                              pulse.value = constantValue;
                              send(pulse);
                           })
       };
   fxMethodSynonyms(EventStream,"constant_e","constant","replaceValue_e","replaceValue");
   var constant_e = function (e) {
      return e.constant_e()
   };
   fxExport(core,constant_e,"constant_e","replaceValue_e");
   var createTimeSyncNode = function (nodes) {
      var nqs = map(function (n) {
                      var qpulse = [];
                      return {q: qpulse,v: createNode([n],function (s,p) {
                                                        qpulse.push(p.value);
                                                        s(p);
                                                     },nodes)}
                   },nodes);
      return createNode(map(function (n) {
                              return n.v
                           },nqs),function (s,p) {
                          var allfull = fold(function (n,acc) {
                                               return n.q.length && acc
                                            },true,nqs);
                          if (allfull) {
                             p.value = map(function (n) {
                                             return n.q.shift()
                                          },nqs);
                             s(p);
                          }
                       })
   };
   var Behaviour = function (event,init,updater) {
      if (! (event instanceof EventStream)) {
         throw "Behaviour: expected event as second arg";
      }
      var behave = this;
      this.last = init;
      this.underlyingRaw = event;
      this.underlying = createNode([event],updater ? function (s,p) {
                                     behave.last = updater(p.value);
                                     p.value = behave.last;
                                     s(p);
                                  } : function (s,p) {
                                     behave.last = p.value;
                                     s(p);
                                  });
   };
   Behaviour.prototype = new Object();
   fxExport(core,Behaviour,"Behaviour");
   fxExport(core,Behaviour,"Behavior");
   var receiver_e = function () {
      var evt = internal_e();
      evt.sendEvent = function (value) {
             propagatePulse(new Pulse(nextStamp(),value),evt);
          };
      return evt
   };
   fxExport(core,receiver_e,"receiver_e");
   var sendEvent = function (node,value) {
      if (! (node instanceof EventStream)) {
         throw "sendEvent: expected Event as first arg";
      }
      propagatePulse(new Pulse(nextStamp(),value),node);
   };
   fxExport(core,sendEvent,"sendEvent");
   synonyms["sendEvent"] = true;
   EventStream.prototype.bind_e = function (k) {
          var m = this;
          var prev_e = false;
          var out_e = createNode([],function (send,pulse) {
                                   send(pulse);
                                });
          out_e.name = "bind out_e";
          var in_e = createNode([m],function (send,pulse) {
                                  if (prev_e) {
                                     removeListener(prev_e,out_e);
                                  }
                                  prev_e = k(pulse.value);
                                  if (prev_e instanceof EventStream) {
                                     attachListener(prev_e,out_e);
                                  } else {
                                     throw "bind_e : expected EventStream";
                                  }
                               });
          in_e.name = "bind in_e";
          return out_e
       };
   EventStream.prototype.lift_e = function (f) {
          if (! (f instanceof Function)) {
             throw "lift_e : expected a function as the first argument; received " + f;
          }
          ;
          return createNode([this],function (send,pulse) {
                              pulse.value = f(pulse.value);
                              send(pulse);
                           })
       };
   fxMethodSynonyms(EventStream
                   ,"lift_e"
                   ,"transform_e"
                   ,"map_e"
                   ,"apply_e"
                   ,"lift"
                   ,"transform"
                   ,"map"
                   ,"apply");
   EventStream.prototype.not_e = function () {
          return this.lift_e(function (v) {
                 return ! v
              })
       };
   fxMethodSynonyms(EventStream,"not_e","not");
   var not_e = function (e) {
      return e.not_e()
   };
   fxExport(core,not_e,"not_e","not");
   EventStream.prototype.filter_e = function (pred) {
          if (! (pred instanceof Function)) {
             throw "filter_e : expected predicate; received " + pred;
          }
          ;
          return createNode([this],function (send,pulse) {
                              if (pred(pulse.value)) {
                                 send(pulse);
                              }
                           })
       };
   fxMethodSynonyms(EventStream,"filter_e","filter");
   var filter_e = function (e,p) {
      return e.filter_e(p)
   };
   fxExport(core,filter_e,"filter_e");
   EventStream.prototype.once_e = function () {
          var done = false;
          return createNode([this],function (send,pulse) {
                              if (! done) {
                                 done = true;
                                 send(pulse);
                              }
                           })
       };
   fxMethodSynonyms(EventStream,"once_e","once");
   var once_e = function (e) {
      return e.once_e()
   };
   fxExport(core,once_e,"once_e");
   EventStream.prototype.skipFirst_e = function () {
          var skipped = false;
          return createNode([this],function (send,pulse) {
                              if (skipped) {
                                 send(pulse);
                              } else {
                                 skipped = true;
                              }
                           })
       };
   fxMethodSynonyms(EventStream,"skipFirst_e","skipFirst");
   var skipFirst_e = function (e) {
      return e.skipFirst_e()
   };
   fxExport(core,skipFirst_e,"skipFirst_e");
   EventStream.prototype.collect_e = function (init,fold) {
          var acc = init;
          return this.lift_e(function (n) {
                 var next = fold(n,acc);
                 acc = next;
                 return next
              })
       };
   fxMethodSynonyms(EventStream,"collect_e","collect","transformWithMemory");
   var collect_e = function (e,i,f) {
      return e.collect_e(i,f)
   };
   fxExport(core,collect_e,"collect_e");
   EventStream.prototype.switch_e = function () {
          return this.bind_e(function (v) {
                 return v
              })
       };
   fxMethodSynonyms(EventStream,"switch_e","forwardLatest");
   var switch_e = function (e) {
      return e.switch_e()
   };
   fxExport(core,switch_e,"switch_e");
   EventStream.prototype.if_e = function (thenE,elseE) {
          var testStamp = - 1;
          var testValue = false;
          createNode([this],function (_,pulse) {
                       testStamp = pulse.stamp;
                       testValue = pulse.value;
                    });
          return merge_e(createNode([thenE],function (send,pulse) {
                                      if (testValue && testStamp == pulse.stamp) {
                                         send(pulse);
                                      }
                                   }),createNode([elseE],function (send,pulse) {
                                                   if (! testValue && testStamp ==
                                                       pulse.stamp) {
                                                      send(pulse);
                                                   }
                                                }))
       };
   fxMethodSynonyms(EventStream,"if_e","choose_e","choose");
   var if_e = function (test,thenE,elseE) {
      if (test instanceof EventStream) {
         return test.if_e(thenE,elseE)
      } else {
         return test ? thenE : elseE
      }
   };
   fxExport(core,if_e,"if_e","choose_e");
   var cond_e = function () {
      var predValArrays = slice(arguments,0);
      var acc = zero_e();
      for (var i = predValArrays.length - 1; i > - 1; i--) {
         acc = if_e(predValArrays[i][0],predValArrays[i][1],acc);
      }
      return acc
   };
   fxExport(core,cond_e,"cond_e");
   var and_e = function () {
      var nodes = slice(arguments,0);
      var acc = nodes.length > 0 ? nodes[nodes.length - 1] : one_e(true);
      for (var i = nodes.length - 2; i > - 1; i--) {
         acc = if_e(nodes[i],acc,nodes[i].constant_e(false));
      }
      return acc
   };
   fxExport(core,and_e,"and_e");
   EventStream.prototype.and_e = function () {
          var deps = [this].concat(slice(arguments,0));
          return and_e.apply(this,deps)
       };
   fxMethodSynonyms(EventStream,"and_e","and");
   var or_e = function () {
      var nodes = slice(arguments,0);
      var acc = nodes.length > 2 ? nodes[nodes.length - 1] : one_e(false);
      for (var i = nodes.length - 2; i > - 1; i--) {
         acc = if_e(nodes[i],nodes[i],acc);
      }
      return acc
   };
   fxExport(core,or_e,"or_e");
   EventStream.prototype.or_e = function () {
          var deps = [this].concat(slice(arguments,0));
          return or_e.apply(this,deps)
       };
   fxMethodSynonyms(EventStream,"or_e","or");
   var delayStatic_e = function (event,time) {
      var resE = internal_e();
      createNode([event],function (s,p) {
                   setTimeout(function () {
                                sendEvent(resE,p.value);
                             },time);
                });
      return resE
   };
   EventStream.prototype.delay_e = function (time) {
          var event = this;
          if (time instanceof Behaviour) {
             var receiverEE = internal_e();
             var link = {from: event,towards: delayStatic_e(event,valueNow(time))};
             var switcherE = createNode([changes(time)],function (s,p) {
                                          removeListener(link.from,link.towards);
                                          link = {from: event,towards: delayStatic_e(event
                                                                                    ,p.value)};
                                          sendEvent(receiverEE,link.towards);
                                       });
             var resE = receiverEE.switch_e();
             sendEvent(switcherE,valueNow(time));
             return resE
          } else {
             return delayStatic_e(event,time)
          }
       };
   fxMethodSynonyms(EventStream,"delay_e","delay");
   var delay_e = function (sourceE,interval) {
      return sourceE.delay_e(interval)
   };
   fxExport(core,delay_e,"delay_e");
   var lift_e = function (fn) {
      var valsOrNodes = slice(arguments,0);
      var selectors = [];
      var selectI = 0;
      var nodes = [];
      for (var i = 0; i < valsOrNodes.length; i++) {
         if (valsOrNodes[i] instanceof EventStream) {
            nodes.push(valsOrNodes[i]);
            selectors.push(function (ii) {
                   return function (realArgs) {
                          return realArgs[ii]
                       }
                }(selectI));
            selectI++;
         } else {
            selectors.push(function (aa) {
                   return function () {
                          return aa
                       }
                }(valsOrNodes[i]));
         }
      }
      var context = this;
      var nofnodes = slice(selectors,1);
      if (nodes.length === 0) {
         return one_e(fn.apply(context,valsOrNodes))
      } else if (nodes.length === 1 && fn instanceof Function) {
         return nodes[0].lift_e(function () {
                var args = arguments;
                return fn.apply(context,map(function (s) {
                                              return s(args)
                                           },nofnodes))
             })
      } else if (nodes.length === 1) {
         return fn.lift_e(function (v) {
                var args = arguments;
                return v.apply(context,map(function (s) {
                                             return s(args)
                                          },nofnodes))
             })
      } else if (fn instanceof Function) {
         return createTimeSyncNode(nodes).lift_e(function (arr) {
                return fn.apply(this,map(function (s) {
                                           return s(arr)
                                        },nofnodes))
             })
      } else if (fn instanceof EventStream) {
         return createTimeSyncNode(nodes).lift_e(function (arr) {
                return arr[0].apply(this,map(function (s) {
                                               return s(arr)
                                            },nofnodes))
             })
      } else {
         throw "unknown lift_e case";
      }
   };
   fxExport(core,lift_e,"lift_e","transform_e","map_e","apply_e");
   EventStream.prototype.snapshot_e = function (valueB) {
          return createNode([this],function (s,p) {
                              p.value = valueNow(valueB);
                              s(p);
                           })
       };
   fxMethodSynonyms(EventStream,"snapshot_e","snapshot","takeSnapshot");
   var snapshot_e = function (triggerE,valueB) {
      return triggerE.snapshot_e(valueB)
   };
   fxExport(core,snapshot_e,"snapshot_e");
   EventStream.prototype.filterRepeats_e = function (optStart) {
          var hadFirst = optStart === undefined ? false : true;
          var prev = optStart;
          return this.filter_e(function (v) {
                 if (! hadFirst || ! isEqual(prev,v)) {
                    hadFirst = true;
                    prev = v;
                    return true
                 } else {
                    return false
                 }
              })
       };
   fxMethodSynonyms(EventStream,"filterRepeats_e","filterRepeats");
   var filterRepeats_e = function (sourceE,optStart) {
      return sourceE.filterRepeats_e(optStart)
   };
   fxExport(core,filterRepeats_e,"filterRepeats_e","filterRepeats");
   var calmStatic_e = function (triggerE,time) {
      var out = internal_e();
      createNode([triggerE],function () {
                   var towards = null;
                   return function (s,p) {
                          if (towards !== null) {
                             clearTimeout(towards);
                          }
                          towards = setTimeout(function () {
                                                 towards = null;
                                                 sendEvent(out,p.value);
                                              },time);
                       }
                }());
      return out
   };
   EventStream.prototype.calm_e = function (time) {
          if (time instanceof Behaviour) {
             var out = internal_e();
             createNode([this],function () {
                          var towards = null;
                          return function (s,p) {
                                 if (towards !== null) {
                                    clearTimeout(towards);
                                 }
                                 towards = setTimeout(function () {
                                                        towards = null;
                                                        sendEvent(out,p.value);
                                                     },valueNow(time));
                              }
                       }());
             return out
          } else {
             return calmStatic_e(this,time)
          }
       };
   fxMethodSynonyms(EventStream,"calm_e","calm");
   var calm_e = function (sourceE,interval) {
      return sourceE.calm_e(interval)
   };
   fxExport(core,calm_e,"calm_e");
   EventStream.prototype.blind_e = function (time) {
          return createNode([this],function () {
                              var intervalFn = time instanceof Behaviour ? function () {
                                                  return valueNow(time)
                                               } : function () {
                                                  return time
                                               };
                              var lastSent = new Date().getTime() - intervalFn() - 1;
                              return function (s,p) {
                                     var curTime = new Date().getTime();
                                     if (curTime - lastSent > intervalFn()) {
                                        lastSent = curTime;
                                        s(p);
                                     }
                                  }
                           }())
       };
   fxMethodSynonyms(EventStream,"blind_e","blind");
   var blind_e = function (sourceE,interval) {
      return sourceE.blind_e(interval)
   };
   fxExport(core,blind_e,"blind_e");
   EventStream.prototype.hold = function (init) {
          return new Behaviour(this,init)
       };
   fxMethodSynonyms(EventStream,"hold","startsWith","toBehavior");
   var hold = function (e,init) {
      if (! (e instanceof EventStream)) {
         throw "hold: expected EventStream; received " + e;
      }
      return e.hold(init)
   };
   fxExport(core,hold,"hold");
   Behaviour.prototype.valueNow = function () {
          return this.last
       };
   var valueNow = function (behavior) {
      return behavior.valueNow()
   };
   fxExport(core,valueNow,"valueNow");
   Behaviour.prototype.changes = function () {
          return this.underlying
       };
   fxMethodSynonyms(Behaviour,"changes","toEvent");
   var changes = function (behave) {
      return behave.changes()
   };
   fxExport(core,changes,"changes");
   Behaviour.prototype.switch_b = function () {
          var behaviourCreatorsB = this;
          var init = valueNow(behaviourCreatorsB);
          var prevSourceE = null;
          var receiverE = new internal_e();
          var makerE = createNode([changes(behaviourCreatorsB)],function (_,p) {
                                    if (! (p.value instanceof Behaviour)) {
                                       throw "switch_b: expected Behaviour as value of Behaviour of first argument";
                                    }
                                    if (prevSourceE != null) {
                                       removeListener(prevSourceE,receiverE);
                                    }
                                    prevSourceE = changes(p.value);
                                    attachListener(prevSourceE,receiverE);
                                    sendEvent(receiverE,valueNow(p.value));
                                 });
          if (init instanceof Behaviour) {
             sendEvent(makerE,init);
          }
          return hold(receiverE,init instanceof Behaviour ? valueNow(init) : init)
       };
   fxMethodSynonyms(Behaviour,"switch_b","forwardLatest");
   var switch_b = function (b) {
      return b.switch_b()
   };
   fxExport(core,switch_b,"switch_b");
   var timer_b = function (interval) {
      return hold(timer_e(interval),new Date().getTime())
   };
   fxExport(dom,timer_b,"timer_b","asTimer_b");
   var delayStatic_b = function (triggerB,time,init) {
      return hold(delayStatic_e(changes(triggerB),time),init)
   };
   Behaviour.prototype.delay_b = function (time,init) {
          var triggerB = this;
          if (time instanceof Behaviour) {
             return hold(delay_e(changes(triggerB),time),arguments.length > 3 ? init
                        : valueNow(triggerB))
          } else {
             return delayStatic_b(triggerB,time,arguments.length > 3 ? init
                                 : valueNow(triggerB))
          }
       };
   fxMethodSynonyms(Behaviour,"delay_b","delay");
   var delay_b = function (srcB,timeB,init) {
      return srcB.delay_b(timeB,init)
   };
   fxExport(core,delay_b,"delay_b");
   Behaviour.prototype.sendBehaviour = function (val) {
          sendEvent(this.underlyingRaw,val);
       };
   Behaviour.prototype.sendBehavior = Behaviour.prototype.sendBehaviour;
   var sendBehaviour = function (b,v) {
      b.sendBehaviour(v);
   };
   fxExport(core,sendBehaviour,"sendBehaviour");
   fxExport(core,sendBehaviour,"sendBehavior");
   Behaviour.prototype.if_b = function (trueB,falseB) {
          var testB = this;
          if (! (trueB instanceof Behaviour)) {
             trueB = constant_b(trueB);
          }
          if (! (falseB instanceof Behaviour)) {
             falseB = constant_b(falseB);
          }
          return lift_b(function (te,t,f) {
                          return te ? t : f
                       },testB,trueB,falseB)
       };
   fxMethodSynonyms(Behaviour,"if_b","choose_b","choose");
   var if_b = function (test,cons,altr) {
      if (! (test instanceof Behaviour)) {
         test = constant_b(test);
      }
      ;
      return test.if_b(cons,altr)
   };
   fxExport(core,if_b,"if_b","choose_b");
   var cond_b = function () {
      var pairs = slice(arguments,0);
      return lift_b.apply({},[function () {
                            for (var i = 0; i < pairs.length; i++) {
                               if (arguments[i]) return arguments[pairs.length + i]
                            }
                            return undefined
                         }].concat(map(function (pair) {
                                         return pair[0]
                                      },pairs).concat(map(function (pair) {
                                                            return pair[1]
                                                         },pairs))))
   };
   fxExport(core,cond_b,"cond_b");
   var constant_b = function (val) {
      return new Behaviour(internal_e(),val)
   };
   fxExport(core,constant_b,"constant_b","receiver_b");
   var lift_b = function (fn) {
      var args = slice(arguments,1);
      var constituentsE = map(changes,filter(function (v) {
                                               return v instanceof Behaviour
                                            },arguments));
      var getCur = function (v) {
         return v instanceof Behaviour ? v.last : v
      };
      var ctx = this;
      var getRes = function () {
         return getCur(fn).apply(ctx,map(getCur,args))
      };
      if (constituentsE.length == 1) {
         return new Behaviour(constituentsE[0],getRes(),getRes)
      }
      var prevStamp = - 1;
      var mid = createNode(constituentsE,function (s,p) {
                             if (p.stamp != prevStamp) {
                                prevStamp = p.stamp;
                                s(p);
                             }
                          });
      return new Behaviour(mid,getRes(),getRes)
   };
   fxExport(core,lift_b,"lift_b","transform_b","apply_b");
   Behaviour.prototype.lift_b = function () {
          var args = slice(arguments,0).concat([this]);
          return lift_b.apply(this,args)
       };
   fxMethodSynonyms(Behaviour,"lift_b","transform_b","apply_b","transform","lift");
   var and_b = function () {
      return lift_b.apply({},[function () {
                            for (var i = 0; i < arguments.length; i++) {
                               if (! arguments[i]) return false
                            }
                            return true
                         }].concat(slice(arguments,0)))
   };
   fxExport(core,and_b,"and_b");
   Behaviour.prototype.and_b = function () {
          return and_b([this].concat(arguments))
       };
   fxMethodSynonyms(Behaviour,"and_b","and");
   var or_b = function () {
      return lift_b.apply({},[function () {
                            for (var i = 0; i < arguments.length; i++) {
                               if (arguments[i]) return true
                            }
                            return false
                         }].concat(slice(arguments,0)))
   };
   fxExport(core,or_b,"or_b");
   Behaviour.prototype.or_b = function () {
          return or_b([this].concat(arguments))
       };
   fxMethodSynonyms(Behaviour,"or_b","or");
   Behaviour.prototype.not_b = function () {
          return this.lift_b(function (v) {
                 return ! v
              })
       };
   fxMethodSynonyms(Behaviour,"not_b","not");
   var not_b = function (b) {
      return b.not_b()
   };
   fxExport(core,not_b,"not_b");
   Behaviour.prototype.blind_b = function (intervalB) {
          return changes(this).blind_e(intervalB).hold(this.valueNow())
       };
   fxMethodSynonyms(Behaviour,"blind_b","blind");
   var blind_b = function (srcB,intervalB) {
      return srcB.blind_b(intervalB)
   };
   fxExport(core,blind_b,"blind_b");
   Behaviour.prototype.calm_b = function (intervalB) {
          return this.changes().calm_e(intervalB).hold(this.valueNow())
       };
   fxMethodSynonyms(Behaviour,"calm_b","calm");
   var calm_b = function (srcB,intervalB) {
      return srcB.calm_b(intervalB)
   };
   fxExport(core,calm_b,"calm_b");
   var addEvent = function (obj,evType,fn) {
      if (obj.addEventListener) {
         obj.addEventListener(evType,fn,false);
         return true
      } else if (obj.attachEvent) {
         return obj.attachEvent("on" + evType,fn)
      } else {
         return false
      }
   };
   fxExport(domMisc,addEvent,"addEvent");
   var getElementsByClass = function (searchClass,node,tag) {
      var classElements = [];
      if (node === null || node === undefined) {
         node = document;
      }
      if (tag === null || tag === undefined) {
         tag = "*";
      }
      var els = node.getElementsByTagName(tag);
      var elsLen = els.length;
      var pattern = new RegExp("(^|\\s)" + searchClass + "(\\s|$)");
      for (var i = 0,j = 0; i < elsLen; i++) {
         if (pattern.test(els[i].className)) {
            classElements.push(els[i]);
         }
      }
      return classElements
   };
   fxExport(domMisc,getElementsByClass,"getElementsByClass","$$");
   var swapDom = function (replaceMe,withMe) {
      if (replaceMe === null || replaceMe === undefined) {
         throw "swapDom: expected dom node or id, received: " + replaceMe;
      }
      var replaceMeD = getObj(replaceMe);
      if (! (replaceMeD.nodeType > 0)) {
         throw "swapDom expected a Dom node as first arg, received " + replaceMeD;
      }
      if (withMe) {
         var withMeD = getObj(withMe);
         if (! (withMeD.nodeType > 0)) {
            throw "swapDom: can only swap with a DOM object";
         }
         try {
            if (withMeD != replaceMeD) replaceMeD.parentNode.replaceChild(withMeD
                                                                         ,replaceMeD);
         } catch (e) {
            throw "swapDom error in replace call: withMeD: " + withMeD +
            ", replaceMe Parent: " + replaceMeD + ", " + e + ", parent: " +
            replaceMeD.parentNode;
         }
      } else {
         replaceMeD.parentNode.removeChild(replaceMeD);
      }
      return replaceMeD
   };
   fxExport(domMisc,swapDom,"swapDom");
   var getObj = function (name) {
      if (typeof name == "object") {
         return name
      } else if (typeof name == "null" || typeof name == "undefined") {
         throw "getObj: expects a Dom obj or Dom id as first arg";
      } else {
         var res = document.getElementById ? document.getElementById(name) : document.all
                   ? document.all[name] : document.layers ? document.layers[name]
                   : function () {
                      throw "getObj: flapjax: cannot access object";
                   }();
         if (res === null || res === undefined) {
            throw "getObj: no obj to get: " + name;
         }
         return res
      }
   };
   fxExport(domMisc,getObj,"getObj");
   fxExport(domMisc,getObj,"$");
   var getMostDom = function (domObj,indices) {
      var acc = getObj(domObj);
      if (indices === null || indices === undefined || indices.length < 1) {
         return acc
      } else {
         for (var i = 0; i < indices.length - 1; i++) {
            acc = acc[indices[i]];
         }
         return acc
      }
   };
   var getDomVal = function (domObj,indices) {
      var val = getMostDom(domObj,indices);
      if (indices && indices.length > 0) {
         val = val[indices[indices.length - 1]];
      }
      return val
   };
   var ___timerID = 0;
   var __getTimerId = function () {
      return ++___timerID
   };
   var timerDisablers = [];
   var disableTimerNode = function (node) {
      timerDisablers[node.__timerId]();
   };
   var disableTimer = function (v) {
      if (v instanceof Behaviour) {
         disableTimerNode(v.underlyingRaw);
      } else if (v instanceof EventStream) {
         disableTimerNode(v);
      }
   };
   fxExport(dom,disableTimer,"disableTimer");
   var createTimerNodeStatic = function (interval) {
      var node = internal_e();
      node.__timerId = __getTimerId();
      var fn = function () {
         sendEvent(node,new Date().getTime());
      };
      var timer = setInterval(fn,interval);
      timerDisablers[node.__timerId] = function () {
             clearInterval(timer);
          };
      return node
   };
   var timer_e = function (interval) {
      if (interval instanceof Behaviour) {
         var receiverE = internal_e();
         var res = receiverE.switch_e();
         var prevE = createTimerNodeStatic(valueNow(interval));
         sendEvent(receiverE,prevE);
         createNode([changes(interval)],function (_,p) {
                      disableTimerNode(prevE);
                      prevE = createTimerNodeStatic(p.value);
                      sendEvent(receiverE,prevE);
                   });
         res.__timerId = __getTimerId();
         timerDisablers[res.__timerId] = function () {
                disableTimerNode[prevE]();
                return
             };
         return res
      } else {
         return createTimerNodeStatic(interval)
      }
   };
   fxExport(dom,timer_e,"timer_e","asTimer_e");
   d.TagB = function (tagName,args) {
          this.resE = internal_e();
          this.currentTag = document.createElement(tagName);
          this.extractParameters(args);
          this.insertChildrenNodes();
          this.styleHooks = [];
          this.styleChangedE = internal_e();
          var ctx = this;
          this.styleChangedE.lift_e(function (_) {
                 var oldTag = ctx.currentTag;
                 ctx.currentTag = document.createElement(tagName);
                 while (oldTag.firstChild) {
                    ctx.currentTag.appendChild(oldTag.removeChild(oldTag.firstChild));
                 }
                 while (ctx.styleHooks.length) removeListener(ctx.styleHooks.pop()
                                                             ,ctx.styleChangedE);
                 ctx.enstyle(ctx.currentTag,ctx.attribs);
                 sendEvent(ctx.resE,ctx.currentTag);
              });
          this.enstyle(this.currentTag,this.attribs);
          this.resB = hold(this.resE,this.currentTag);
       };
   d.TagB.prototype = {extractParameters: function (args) {
                         this.arrs = [];
                         var attribs = [];
                         var curarr = [];
                         this.arrs.push(curarr);
                         for (var i = 0; i < args.length; i++) {
                            if (args[i] instanceof Behaviour) {
                               var vn = valueNow(args[i]);
                               if (vn instanceof Array) {
                                  this.arrs.push(args[i]);
                                  curarr = [];
                                  this.arrs.push(curarr);
                               } else {
                                  if (typeof vn == "object" && vn.nodeType == 1 ||
                                      typeof vn == "string" || vn == undefined) {
                                     curarr.push(args[i]);
                                  } else if (typeof vn == "object") {
                                     attribs.push(args[i]);
                                  } else {
                                     throw "createParameterizedTagB: unknown behaviour argument argument "
                                     + i;
                                  }
                               }
                            } else {
                               if (args[i] instanceof Array) {
                                  var arr = args[i];
                                  for (var j = 0; j < arr.length; j++) {
                                     curarr.push(arr[j]);
                                  }
                               } else {
                                  var vn = args[i];
                                  if (typeof vn == "object" && vn.nodeType == 1 ||
                                      typeof vn == "string" || vn == undefined) {
                                     curarr.push(args[i]);
                                  } else if (typeof vn == "object") {
                                     attribs.push(args[i]);
                                  }
                               }
                            }
                         }
                         ;
                         if (attribs.length > 1) throw "createParameterizedTagB " +
                            tagName + ": more than one attribute (" + attribs.length +
                            ")";
                         this.attribs = attribs.length > 0 ? attribs[0] : {};
                      },insertChildrenNodes: function () {
                         var ctx = this;
                         function quickNode(e) {
                            if (typeof e == "object" && e.nodeType) return e else if (e ==
                                                                                      undefined)
                            return document.createTextNode("")
                            else return document.createTextNode(e)
                         }
                         function unBehaviourize(arr) {
                            return map(function (n) {
                                         return n instanceof Behaviour ? valueNow(n) : n
                                      },arr)
                         }
                         var lnodes = map(function () {
                                            return []
                                         },this.arrs);
                         var arrLastVals = map(unBehaviourize,unBehaviourize(this.arrs));
                         var arrChangesE = internal_e();
                         var nodeChangesE = internal_e();
                         function attachNodes(i,arr) {
                            for (var j = 0; j < arr.length; j++) {
                               var cnode = arr[j];
                               if (cnode instanceof Behaviour) {
                                  var newnode = function (jj) {
                                                   return changes(cnode).lift_e(function (n) {
                                                          return {index: i
                                                                 ,jdex: jj
                                                                 ,val: n}
                                                       })
                                                }(j);
                                  lnodes[i].push(newnode);
                                  attachListener(newnode,nodeChangesE);
                                  cnode = valueNow(cnode);
                               }
                            }
                         }
                         var childChangesE = merge_e(arrChangesE.lift_e(function (ai) {
                                                       var i = ai.index;
                                                       var newarr = ai.val;
                                                       while (lnodes[i].length) {
                                                          var ln = lnodes[i].pop();
                                                          removeListener(ln,nodeChangesE);
                                                       }
                                                       var newvals = map(function (n) {
                                                                           return quickNode(n)
                                                                        },unBehaviourize(newarr));
                                                       for (var j = 0; j <
                                                            arrLastVals[i].length; j++)
                                                       try {
                                                          ctx.currentTag.removeChild(arrLastVals[i][j]);
                                                       } catch (e) {
                                                       }
                                                       if (newvals.length) {
                                                          var nextNode = null;
                                                          for (ii = i + 1; ii <
                                                               arrLastVals.length &&
                                                               ! arrLastVals[ii].length; ii++)
                                                          ;
                                                          if (ii < arrLastVals.length)
                                                          nextNode = arrLastVals[ii][0];
                                                          for (var j = 0; j <
                                                               newvals.length; j++)
                                                          ctx.currentTag.insertBefore(newvals[j]
                                                                                     ,nextNode);
                                                       }
                                                       arrLastVals[i] = newvals;
                                                       attachNodes(i,newarr);
                                                       return ctx.currentTag
                                                    }),nodeChangesE.lift_e(function (ni) {
                                                       var i = ni.index;
                                                       var j = ni.jdex;
                                                       var newnode = quickNode(ni.val);
                                                       swapDom(arrLastVals[i][j],newnode);
                                                       arrLastVals[i][j] = newnode;
                                                       return ctx.currentTag
                                                    }));
                         childChangesE.lift_e(function (cc) {
                                sendEvent(ctx.resE,cc);
                             });
                         for (var i = 0; i < this.arrs.length; i++) {
                            for (var j = 0; j < arrLastVals[i].length; j++) {
                               arrLastVals[i][j] = quickNode(arrLastVals[i][j]);
                               this.currentTag.appendChild(arrLastVals[i][j]);
                            }
                            if (this.arrs[i] instanceof Behaviour) {
                               attachNodes(i,valueNow(this.arrs[i]));
                               var newnode = function (ii) {
                                                return changes(ctx.arrs[ii]).lift_e(function (na) {
                                                       return {index: ii,val: na}
                                                    })
                                             }(i);
                               attachListener(newnode,arrChangesE);
                            } else {
                               attachNodes(i,this.arrs[i]);
                            }
                         }
                      },enstyle: function (obj,vals) {
                         if (vals instanceof Behaviour) {
                            if (! (typeof valueNow(vals) == "object")) {
                               throw "enstyle: expected object literal as behaviour value";
                            }
                            this.styleHooks.push(changes(vals));
                            attachListener(changes(vals),this.styleChangedE);
                         }
                         var valsV = vals instanceof Behaviour ? valueNow(vals) : vals;
                         if (typeof valsV == "object") {
                            for (var i in valsV) {
                               if (! Object.prototype || ! Object.prototype[i]) {
                                  this.enstyleProperty(obj,valsV,i);
                               }
                            }
                         } else {
                            throw "enstyle: expected object literals";
                         }
                      },enstyleProperty: function (obj,vals,i) {
                         if (vals[i] instanceof Behaviour) {
                            if (typeof valueNow(vals[i]) == "object") {
                               this.enstyle(obj[i],vals[i]);
                            } else {
                               obj[i] = valueNow(vals[i]);
                               changes(vals[i]).lift_e(function (v) {
                                      obj[i] = v;
                                   });
                            }
                         } else {
                            if (typeof vals[i] == "object") {
                               this.enstyle(obj[i],vals[i]);
                            } else {
                               obj[i] = vals[i];
                            }
                         }
                      }};
   d.createParameterizedTagB = function (tagName) {
          return new d.TagB(tagName,slice(arguments,1)).resB
       };
   d.enstyleStaticProperty = function (obj,props,index) {
          if (typeof props[index] == "object") {
             for (var i in props[index]) {
                if (! Object.prototype || ! Object.prototype[i]) {
                   d.enstyleStaticProperty(obj[index],props[index],i);
                }
             }
          } else {
             obj[index] = props[index];
             if (index == "checked") obj["defaultChecked"] = props[index];
             if (index == "selected") obj["defaultSelected"] = props[index];
          }
       };
   d.staticTagMaker = function (tagName) {
          return function () {
                 var tagD = document.createElement(tagName);
                 if (! (tagD.nodeType > 0)) {
                    throw tagName + ": invalid tag name";
                 }
                 var attribs = [];
                 for (var i = 0; i < arguments.length; i++) {
                    if (arguments[i] instanceof Array) {
                       for (var j = 0; j < arguments[i].length; j++) {
                          if (arguments[i][j]) {
                             tagD.appendChild(typeof arguments[i][j] == "object" &&
                                 arguments[i][j].nodeType > 0 ? arguments[i][j]
                                 : document.createTextNode(arguments[i][j]));
                          }
                       }
                    } else if (! arguments[i]) {
                    } else if (typeof arguments[i] == "object" && arguments[i].nodeType >
                               0) {
                       tagD.appendChild(arguments[i]);
                    } else if (typeof arguments[i] == "object") {
                       attribs.push(arguments[i]);
                    } else {
                       tagD.appendChild(document.createTextNode(arguments[i]));
                    }
                 }
                 if (attribs.length == 1) {
                    for (var k in attribs[0]) {
                       if (! Object.prototype || ! Object.prototype[k]) {
                          d.enstyleStaticProperty(tagD,attribs[0],k);
                       }
                    }
                 } else if (attribs.length > 0) {
                    throw "static enstyle: expected object literals";
                 }
                 return tagD
              }
       };
   var generatedTags = ["a",
                       "b",
                       "blockquote",
                       "br",
                       "button",
                       "canvas",
                       "div",
                       "fieldset",
                       "form",
                       "font",
                       "h1",
                       "h2",
                       "h3",
                       "h4",
                       "hr",
                       "img",
                       "iframe",
                       "input",
                       "label",
                       "legend",
                       "li",
                       "ol",
                       "optgroup",
                       "option",
                       "p",
                       "pre",
                       "select",
                       "span",
                       "strong",
                       "table",
                       "tbody",
                       "td",
                       "textarea",
                       "tfoot",
                       "th",
                       "thead",
                       "tr",
                       "tt",
                       "ul"];
   map(function (tagName) {
         var upper = tagName.toUpperCase();
         d[upper + "B"] = function () {
                return d.createParameterizedTagB.apply(this
                                                      ,[tagName].concat(slice(arguments
                                                                             ,0)))
             };
         annotate(d[upper + "B"],[upper + "B"]);
         d[upper] = d.staticTagMaker(tagName);
         annotate(d[upper],[upper]);
      },generatedTags);
   d.TEXTB = function (strB) {
          if (! (strB instanceof Behaviour)) {
             strB = constant_b(strB);
          }
          return hold(changes(strB).lift_e(function (txt) {
                        return document.createTextNode(txt)
                     }),document.createTextNode(valueNow(strB)))
       };
   annotate(d.TEXTB,["TEXTB"]);
   var TEXT = function (str) {
      return document.createTextNode(str)
   };
   fxExport(dom,TEXT,"TEXT");
   var tagRec = function (eventNames,maker) {
      if (! (eventNames instanceof Array)) {
         throw "tagRec: expected array of event names as first arg";
      }
      if (! (maker instanceof Function)) {
         throw "tagRec: expected function as second arg";
      }
      var numEvents = eventNames.length;
      var internals = [];
      var switches = [];
      for (var i = 0; i < numEvents; i++) {
         internals[i] = internal_e();
         switches[i] = internals[i].switch_e();
      }
      ;
      var domB = maker.apply(this,switches);
      var prevValue;
      var interceptE = createNode([domB.changes()],function (_,p) {
                                    if (isEqual(p.value,prevValue)) {
                                       return
                                    }
                                    prevValue = p.value;
                                    for (var i = 0; i < numEvents; i++) {
                                       sendEvent(internals[i],extractEvent_e(prevValue
                                                                            ,eventNames[i]));
                                    }
                                    ;
                                 });
      sendEvent(interceptE,domB.valueNow());
      return domB
   };
   fxExport(dom,tagRec,"tagRec","nodeWithOwnEvents");
   var extractEventStatic_e = function (domObj,eventName) {
      if (! eventName) {
         throw "extractEvent_e : no event name specified";
      }
      if (! domObj) {
         throw "extractEvent_e : no DOM element specified";
      }
      domObj = getObj(domObj);
      var primEventE = internal_e();
      addEvent(domObj,eventName,function (evt) {
                 sendEvent(primEventE,evt || window.event);
                 return true
              });
      return primEventE
   };
   var extractEvent_e = function (domB,eventName) {
      if (! (domB instanceof Behaviour)) {
         return extractEventStatic_e(domB,eventName)
      } else {
         var domE = domB.changes();
         var eventEE = domE.lift_e(function (dom) {
                          return extractEventStatic_e(dom,eventName)
                       });
         var resultE = eventEE.switch_e();
         sendEvent(domE,domB.valueNow());
         return resultE
      }
      ;
   };
   fxExport(dom,extractEvent_e,"extractEvent_e","$EVT");
   d.extractEvents_e = function (domObj) {
          var eventNames = slice(arguments,1);
          var events = map(function (eventName) {
                             return extractEvent_e(domObj,eventName)
                          },eventNames.length === 0 ? [] : eventNames);
          return merge_e.apply(this,events)
       };
   annotate(d.extractEvents_e
           ,["extractEvents_e"]
           ,0
           ,[Behaviour.prototype]
           ,["extractEvents_e"]);
   d.extractValueOnEvent_e = function (triggerE,domObj) {
          if (! (triggerE instanceof EventStream)) {
             throw "extractValueOnEvent_e: expected Event as first arg";
          }
          return changes(d.extractValueOnEvent_b.apply(this,arguments))
       };
   annotate(d.extractValueOnEvent_e,["extractValueOnEvent_e"]);
   d.extractDomFieldOnEvent_e = function (triggerE,domObj) {
          if (! (triggerE instanceof EventStream)) {
             throw "extractDomFieldOnEvent_e: expected Event as first arg";
          }
          var indices = slice(arguments,2);
          var res = triggerE.lift_e(function () {
                       return getDomVal(domObj,indices)
                    });
          return res
       };
   d.extractValue_e = function (domObj) {
          return changes(d.extractValue_b.apply(this,arguments))
       };
   annotate(d.extractValue_e,["extractValue_e","$E"]);
   d.extractValueOnEvent_b = function (triggerE,domObj) {
          return d.extractValueStatic_b(domObj,triggerE)
       };
   annotate(d.extractValueOnEvent_b,["extractValueOnEvent_b"]);
   d.extractValueStatic_b = function (domObj,triggerE) {
          var objD;
          try {
             objD = getObj(domObj);
             if (typeof domObj == "string" && objD.id != domObj) {
                throw "Make a radio group";
             }
          } catch (e) {
             objD = {type: "radio-group",name: domObj};
          }
          var getter;
          switch (objD.type)
          {
             case "checkbox":
                return hold(filterRepeats_e(d.extractDomFieldOnEvent_e(triggerE ? triggerE
                                                                      : d.extractEvents_e(objD
                                                                                         ,"click"
                                                                                         ,"keyup"
                                                                                         ,"change"),objD,"checked"),objD.checked),objD.checked)
             case "select-one":
                getter = function (_) {
                       return objD.selectedIndex > - 1
                           ? objD.options[objD.selectedIndex].value
                           ? objD.options[objD.selectedIndex].value
                           : objD.options[objD.selectedIndex].innerText : undefined
                    };
                return hold(filterRepeats_e((triggerE ? triggerE : d.extractEvents_e(objD
                                                                                    ,"click"
                                                                                    ,"keyup"
                                                                                    ,"change")).lift_e(getter)),getter(),getter())
             case "select-multiple":
                getter = function (_) {
                       var res = [];
                       for (var i = 0; i < objD.options.length; i++) {
                          if (objD.options[i].selected) {
                             res.push(objD.options[i].value ? objD.options[i].value
                                 : objD.options[i].innerText);
                          }
                       }
                       return res
                    };
                return hold((triggerE ? triggerE : d.extractEvents_e(objD
                                                                    ,"click"
                                                                    ,"keyup"
                                                                    ,"change")).lift_e(getter),getter())
             case "text":
             case "textarea":
             case "hidden":
             case "password":
                return hold(filterRepeats_e(d.extractDomFieldOnEvent_e(triggerE ? triggerE
                                                                      : d.extractEvents_e(objD
                                                                                         ,"click"
                                                                                         ,"keyup"
                                                                                         ,"change"),objD,"value"),objD.value),objD.value)
             case "button":
                return hold(d.extractDomFieldOnEvent_e(triggerE ? triggerE
                                                      : d.extractEvents_e(objD
                                                                         ,"click"
                                                                         ,"keyup"
                                                                         ,"change"),objD,"value"),objD.value)
             case "radio":
             case "radio-group":
                var radiosAD = filter(function (elt) {
                                        return elt.type == "radio" &&
                                            elt.getAttribute("name") == objD.name
                                     },document.getElementsByTagName("input"));
                getter = objD.type == "radio" ? function (_) {
                       return objD.checked
                    } : function (_) {
                       for (var i = 0; i < radiosAD.length; i++) {
                          if (radiosAD[i].checked) {
                             return radiosAD[i].value
                          }
                       }
                       return undefined
                    };
                var actualTriggerE = triggerE ? triggerE : merge_e.apply(this
                                                                        ,map(function (radio) {
                                                                               return d.extractEvents_e(radio
                                                                                                       ,"click"
                                                                                                       ,"keyup"
                                                                                                       ,"change")
                                                                            }
                                                                            ,radiosAD));
                return hold(filterRepeats_e(actualTriggerE.lift_e(getter)
                                           ,getter()),getter())
             default:
                throw "extractValueStatic_b: unknown value type \"" + objD.type + "\"";
          }
       };
   d.extractValue_b = function (domObj) {
          if (domObj instanceof Behaviour) {
             return lift_b(function (dom) {
                             return d.extractValueStatic_b(dom)
                          },domObj).switch_b()
          } else {
             return d.extractValueStatic_b(domObj)
          }
       };
   annotate(d.extractValue_b,["extractValue_b",
           "$B"],0,[Behaviour.prototype],["extractValue_b","$B"]);
   d.deepStaticUpdate = function (into,from,index) {
          var fV = from instanceof Behaviour ? valueNow(from) : from;
          if (typeof fV == "object") {
             for (var i in fV) {
                if (! Object.prototype || ! Object.prototype[i]) {
                   d.deepStaticUpdate(index ? into[index] : into,fV[i],i);
                }
             }
          } else {
             var old = into[index];
             into[index] = fV;
          }
       };
   d.deepDynamicUpdate = function (into,from,index) {
          var fV = from instanceof Behaviour ? valueNow(from) : from;
          if (typeof fV == "object") {
             if (from instanceof Behaviour) {
                throw "deepDynamicUpdate: dynamic collections not supported";
             }
             for (var i in fV) {
                if (! Object.prototype || ! Object.prototype[i]) {
                   d.deepDynamicUpdate(index ? into[index] : into,fV[i],i);
                }
             }
          } else {
             if (from instanceof Behaviour) {
                createNode([changes(from)],function (s,p) {
                             if (index) {
                                var old = into[index];
                                into[index] = p.value;
                             } else {
                                into = p.value;
                             }
                          });
             }
          }
       };
   d.insertValue = function (val,domObj) {
          var indices = slice(arguments,2);
          var parent = getMostDom(domObj,indices);
          d.deepStaticUpdate(parent,val,indices ? indices[indices.length - 1]
                            : undefined);
       };
   annotate(d.insertValue,["insertValue"]);
   d.insertValueE = function (triggerE,domObj) {
          if (! (triggerE instanceof EventStream)) {
             throw "insertValueE: expected Event as first arg";
          }
          var indices = slice(arguments,2);
          var parent = getMostDom(domObj,indices);
          triggerE.lift_e(function (v) {
                 d.deepStaticUpdate(parent,v,indices ? indices[indices.length - 1]
                                   : undefined);
              });
       };
   annotate(d.insertValueE,["insertValueE"],0,[EventStream.prototype],["insertValueE"]);
   d.insertValueB = function (triggerB,domObj) {
          var indices = slice(arguments,2);
          var parent = getMostDom(domObj,indices);
          d.deepStaticUpdate(parent,triggerB,indices ? indices[indices.length - 1]
                            : undefined);
          d.deepDynamicUpdate(parent,triggerB,indices ? indices[indices.length - 1]
                             : undefined);
       };
   annotate(d.insertValueB,["insertValueB"],0,[Behaviour.prototype],["insertValueB"]);
   d.insertDomE = function (triggerE,domObj) {
          if (! (triggerE instanceof EventStream)) {
             throw "insertDomE: expected Event as first arg";
          }
          var objD = getObj(domObj);
          var res = triggerE.lift_e(function (newObj) {
                       if (! (typeof newObj == "object" && newObj.nodeType == 1)) {
                          newObj = d.SPAN({},newObj);
                       }
                       swapDom(objD,newObj);
                       objD = newObj;
                       return newObj
                    });
          return res
       };
   annotate(d.insertDomE,["insertDomE"],0,[EventStream.prototype],["insertDomE"]);
   d.insertDom = function (hookD,replaceWithD,optPosition) {
          switch (optPosition)
          {
             case undefined:
             case null:
             case "over":
                swapDom(hookD,replaceWithD);
                break;
             case "before":
                hookD.parentNode.insertBefore(replaceWithD,hookD);
                break;
             case "after":
                if (hookD.nextSibling) {
                   hookD.parentNode.insertBefore(replaceWithD,hookD.nextSibling);
                } else {
                   hookD.parentNode.appendChild(replaceWithD);
                }
                break;
             case "leftMost":
                if (hookD.parentNode.firstChild) {
                   hookD.parentNode.insertBefore(replaceWithD
                                                ,hookD.parentNode.firstChild);
                } else {
                   hookD.parentNode.appendChild(replaceWithD);
                }
                break;
             case "rightMost":
                hookD.parentNode.appendChild(replaceWithD);
                break;
             case "beginning":
                if (hookD.firstChild) {
                   hookD.insertBefore(replaceWithD,hookD.firstChild);
                } else {
                   hookD.appendChild(replaceWithD);
                }
                break;
             case "end":
                hookD.appendChild(replaceWithD);
                break;
             default:
                throw "domInsert: unknown position: " + optPosition;
          }
       };
   d.insertDomClean = function (replaceWithD,hook,optPosition) {
          d.insertDom(getObj(hook),typeof replaceWithD == "object" &&
                     replaceWithD.nodeType > 0 ? replaceWithD
                     : document.createTextNode(replaceWithD),optPosition);
       };
   annotate(d.insertDomClean,["insertDom"]);
   d.insertDomB = function (initTriggerB,optID,optPosition) {
          if (! (initTriggerB instanceof Behaviour)) {
             initTriggerB = constant_b(initTriggerB);
          }
          var triggerB = lift_b(function (d) {
                                  if (typeof d == "object" && d.nodeType > 0) {
                                     return d
                                  } else {
                                     var res = document.createElement("span");
                                     res.appendChild(document.createTextNode(d));
                                     return res
                                  }
                               },initTriggerB);
          var initD = valueNow(triggerB);
          if (! (typeof initD == "object" && initD.nodeType == 1)) {
             throw "insertDomB: initial value conversion failed: " + initD;
          }
          d.insertDom(optID === null || optID === undefined
                     ? getObj(initD.getAttribute("id"))
                     : getObj(optID),initD,optPosition);
          var resB = hold(d.insertDomE(changes(triggerB),initD),initD);
          return resB
       };
   annotate(d.insertDomB,["insertDomB"],0,[Behaviour.prototype],["insertDomB"]);
   d.extractId_b = function (id,start) {
          return hold(createNode(start instanceof Behaviour ? [changes(start)]
                                : [],function (s,p) {
                                   p.value = getObj(id);
                                   s(p);
                                }),getObj(id))
       };
   annotate(d.insertDomB,["extractId_b"],1,[Behaviour.prototype],["extractId_b"]);
   var mouse_e = function (elem) {
      return extractEvent_e(elem,"mousemove").lift_e(function (evt) {
             if (evt.pageX | evt.pageY) {
                return {left: evt.pageX,top: evt.pageY}
             } else if (evt.clientX || evt.clientY) {
                return {left: evt.clientX + document.body.scrollLeft,top: evt.clientY +
                       document.body.scrollTop}
             } else {
                return {left: 0,top: 0}
             }
          })
   };
   var mouse_b = function (elem) {
      return mouse_e(elem).hold({left: 0,top: 0})
   };
   fxExport(dom,mouse_b,"mouse_b");
   var mouseLeft_b = function (elem) {
      return lift_b(function (v) {
                      return v.left
                   },mouse_b(elem))
   };
   fxExport(dom,mouseLeft_b,"mouseLeft_b");
   var mouseTop_b = function (elem) {
      return mouse_b(elem).lift_b(function (v) {
             return v.top
          })
   };
   fxExport(dom,mouseTop_b,"mouseTop_b");
   var clicks_e = function (elem) {
      return extractEvent_e(elem,"click")
   };
   fxExport(dom,clicks_e,"clicks_e");
   var getURLParam = function (param) {
      var lparam = param.toLowerCase();
      var aReturn = [];
      var strHref = window.location.href;
      var endstr = strHref.indexOf("#") > - 1 ? strHref.indexOf("#") : strHref.length;
      if (strHref.indexOf("?") > - 1) {
         var strQueryString = strHref.substring(strHref.indexOf("?") + 1,endstr);
         map(function (qp) {
               var eq = qp.indexOf("=");
               var qname = qp.substr(0,eq + 1).toLowerCase();
               if (qname == lparam + "=") aReturn.push(decodeURIComponent(qp.substr(eq +
                      1)));
            },strQueryString.split("&"));
      }
      if (aReturn.length == 0) return undefined else if (aReturn.length == 1)
      return aReturn[0] else return aReturn
   };
   fxExport(domMisc,getURLParam,"getURLParam","$URL");
   var readCookie = function (name) {
      var nameEQ = name + "=";
      var ca = document.cookie.split(";");
      for (var i = 0; i < ca.length; i++) {
         var co = ca[i];
         while (co.charAt(0) == " ") {
            co = co.substring(1,co.length);
         }
         if (co.indexOf(nameEQ) === 0) {
            return co.substring(nameEQ.length,co.length)
         }
      }
      return undefined
   };
   fxExport(domMisc,readCookie,"readCookie");
   var scriptCounter = 0;
   var deleteScript = function (scriptID) {
      var scriptD = getObj(scriptID);
      scriptD.parentNode.removeChild(scriptD);
   };
   var runScript = function (url,fn,param) {
      var script = document.createElement("script");
      script.src = url;
      var scriptID = "scriptFnRPC" + scriptCounter++;
      script.setAttribute("id",scriptID);
      document.getElementsByTagName("head").item(0).appendChild(script);
      var timer = {};
      var check = function () {
         eval("try { if (" + param + "!== undefined) {var stat = " + param +
             ";}} catch (e) {}");
         if (stat !== undefined) {
            eval(param + " = undefined;");
            clearInterval(timer.timer);
            clearInterval(timer.timeout);
            if (fn instanceof Function) {
               fn(stat);
            }
            deleteScript(scriptID);
         }
      };
      timer.timer = setInterval(check,3500);
      timer.timeout = setTimeout(function () {
                                   try {
                                      clearInterval(timer.timer);
                                   } catch (e) {
                                   }
                                },5000);
   };
   var evalForeignScriptVal_e = function (urlArg_e) {
      var result = receiver_e();
      urlArg_e.lift_e(function (urlArg) {
             runScript(urlArg.url,function (val) {
                         result.sendEvent(val);
                      },urlArg.globalArg);
          });
      return result
   };
   fxExport(ws,evalForeignScriptVal_e,"evalForeignScriptVal_e");
   var ajaxRequest = function (method,url,body,async,useFlash,callback) {
      var xhr;
      if (useFlash) {
         xhr = new FlashXMLHttpRequest();
         xhr.onload = function () {
                callback(xhr);
             };
      } else if (window.XMLHttpRequest && ! window.ActiveXObject) {
         xhr = new window.XMLHttpRequest();
         xhr.onload = function () {
                callback(xhr);
             };
      } else if (window.ActiveXObject) {
         try {
            xhr = new ActiveXObject("Msxml2.XMLHTTP");
         } catch (e) {
            xhr = new ActiveXObject("Microsoft.XMLHTTP");
         }
         xhr.onreadystatechange = function () {
                if (xhr.readyState == 4) {
                   callback(xhr);
                }
             };
      }
      ;
      xhr.open(method,url,async);
      if (method == "POST") {
         xhr.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
      }
      xhr.send(body);
      return xhr
   };
   var encodeREST = function (obj) {
      var str = "";
      for (var field in obj) {
         if (typeof obj[field] !== "function") {
            if (str != "") {
               str += "&";
            }
            str += field + "=" + encodeURIComponent(obj[field]);
         }
      }
      return str
   };
   var parseJSON = function (str) {
      try {
         return ! /[^,:{}\\[\\]0-9.\\-+Eaeflnr-u \\n\\r\\t]/.test(str.replace(/\"(\\\\.|[^\"\\\\])*\"/g
                                                                             ,"")) &&
             eval("(" + str + ")")
      } catch (e) {
         throw "cannot parse JSON string: " + e;
      }
   };
   var toJSONString = function () {
                         var m = {"\b": "\\b"
                                 ,"\t": "\\t"
                                 ,"\n": "\\n"
                                 ,"\f": "\\f"
                                 ,"\r": "\\r"
                                 ,"\"": "\\\""
                                 ,"\\": "\\\\"};
                         var s = {array: function (x) {
                                    var a = ["["],b,f,i,l = x.length,v;
                                    for (i = 0; i < l; i += 1) {
                                       v = x[i];
                                       f = s[typeof v];
                                       if (f) {
                                          v = f(v);
                                          if (typeof v == "string") {
                                             if (b) {
                                                a[a.length] = ",";
                                             }
                                             a[a.length] = v;
                                             b = true;
                                          }
                                       }
                                    }
                                    a[a.length] = "]";
                                    return a.join("")
                                 },"boolean": function (x) {
                                    return String(x)
                                 },"null": function (x) {
                                    return "null"
                                 },number: function (x) {
                                    return isFinite(x) ? String(x) : "null"
                                 },object: function (x) {
                                    if (x) {
                                       if (x instanceof Array) {
                                          return s.array(x)
                                       }
                                       var a = ["{"],b,f,i,v;
                                       for (i in x) {
                                          v = x[i];
                                          f = s[typeof v];
                                          if (f) {
                                             v = f(v);
                                             if (typeof v == "string") {
                                                if (b) {
                                                   a[a.length] = ",";
                                                }
                                                a.push(s.string(i),":",v);
                                                b = true;
                                             }
                                          }
                                       }
                                       a[a.length] = "}";
                                       return a.join("")
                                    }
                                    return "null"
                                 },string: function (x) {
                                    if (/[\"\\\\\\x00-\\x1f]/.test(x)) {
                                       x = x.replace(/([\\x00-\\x1f\\\\\"])/g,function (a
                                                                                       ,b) {
                                                       var c = m[b];
                                                       if (c) {
                                                          return c
                                                       }
                                                       c = b.charCodeAt();
                                                       return "\\u00" + Math.floor(c /
                                                           16).toString(16) + (c %
                                                                               16).toString(16)
                                                    });
                                    }
                                    return "\"" + x + "\""
                                 }};
                         return function (val) {
                                var f = s[typeof val];
                                if (f) {
                                   return f(val)
                                } else {
                                   throw "parseJSON: unknown object type: " + typeof val;
                                }
                             }
                      }();
   var serverRequest_e = function (useFlash,requestE) {
      var response_e = receiver_e();
      requestE.lift_e(function (obj) {
             var body = "";
             var method = "GET";
             var url = obj.url;
             var reqType = obj.request ? obj.request : obj.fields ? "post" : "get";
             if (obj.request == "get") {
                url += "?" + encodeREST(obj.fields);
                body = "";
                method = "GET";
             } else if (obj.request == "post") {
                body = toJSONString(obj.fields);
                method = "POST";
             } else if (obj.request == "rawPost") {
                body = obj.body;
                method = "POST";
             } else if (obj.request == "rest") {
                body = encodeREST(obj.fields);
                method = "POST";
             } else {
                raise("Invalid request type: " + obj.request);
             }
             var async = obj.async;
             var xhr;
             if (obj.response == "json") {
                xhr = ajaxRequest(method,url,body,async,useFlash,function (xhr) {
                                    response_e.sendEvent(parseJSON(xhr.responseText));
                                 });
             } else if (obj.response == "xml") {
                ajaxRequest(method,url,body,async,useFlash,function (xhr) {
                              response_e.sendEvent(xhr.responseXML);
                           });
             } else if (obj.response == "plain" || ! obj.response) {
                ajaxRequest(method,url,body,async,useFlash,function (xhr) {
                              response_e.sendEvent(xhr.responseText);
                           });
             } else {
                raise("Unknown response format: " + obj.response);
             }
          });
      return response_e
   };
   var getWebServiceObject_e = function (requestE) {
      return serverRequest_e(false,requestE)
   };
   fxExport(ws,getWebServiceObject_e,"getWebServiceObject_e");
   var getForeignWebServiceObject_e = function (requestE) {
      return serverRequest_e(true,requestE)
   };
   fxExport(ws,getForeignWebServiceObject_e,"getForeignWebServiceObject_e");
   var cumulativeOffset = function (element) {
      var valueT = 0,valueL = 0;
      do {
         valueT += element.offsetTop || 0;
         valueL += element.offsetLeft || 0;
         element = element.offsetParent;
      } while (element);
      return {left: valueL,top: valueT}
   };
   fxExport(domMisc,cumulativeOffset,"cumulativeOffset");
   if (! options.hideAll) {
      for (var zz in flapjax.pub) {
         if (! options[zz]) {
            window[zz] = flapjax.pub[zz];
         }
      }
   }
   for (var id in exports) {
      if (window[id]) {
         if (options.redefine === false) {
            warn("window." + id + " is already defined; Flapjax will not " +
                "redefine it.");
         } else {
            warn("Flapjax is redefining window." + id + ".");
         }
      }
      if (window[id] && options.redefine === false) {
      } else if (options.show && options.hide && options.show[id] === true &&
                 options.hide[id] === true) {
         throw "flapjaxInit: invalid options: " + id +
         " specified as \'show\' and \'hide\'";
      } else if (options.show && options.show[id]) {
         window[id] = exports[id];
      } else if (options.hide && options.hide[id]) {
      } else if (! synonyms[id] || options.includeSynonyms) {
         if (options.exportMisc && exports[id].__flapjaxCategory === misc) {
            window[id] = exports[id];
         } else if (options.exportDOMMisc && exports[id].__flapjaxCategory === domMisc) {
            window[id] = exports[id];
         } else if (options.exportDOM && exports[id].__flapjaxCategory === dom) {
            window[id] = exports[id];
         } else if (options.exportCore && exports[id].__flapjaxCategory === core) {
            window[id] = exports[id];
         } else if (options.exportWS && exports[id].__flapjaxCategory === ws) {
            window[id] = exports[id];
         }
      }
   }
   return exports
}f