1 (function (root, factory) {
   2 
   3     if (typeof define === "function" && define.amd) {
   4         define(factory);
   5     } else if (typeof exports === "object") {
   6         module.exports = factory();
   7     } else {
   8         root.way = factory();
   9     }
  10 
  11 }(this, function () {
  12 
  13     "use strict";
  14 
  15     var way, w, tagPrefix = "way";
  16 
  17     //////////////////////////////
  18     // EVENT EMITTER DEFINITION //
  19     //////////////////////////////
  20 
  21     var EventEmitter = function () {
  22 
  23         this._watchers = {};
  24         this._watchersAll = {};
  25 
  26     };
  27 
  28     EventEmitter.prototype.constructor = EventEmitter;
  29 
  30     EventEmitter.prototype.watchAll = function (handler) {
  31 
  32         this._watchersAll = this._watchersAll || [];
  33         if (!_w.contains(this._watchersAll, handler)) { this._watchersAll.push(handler); }
  34 
  35     }
  36 
  37     EventEmitter.prototype.watch = function (selector, handler) {
  38 
  39         if (!this._watchers) { this._watchers = {}; }
  40         this._watchers[selector] = this._watchers[selector] || [];
  41         this._watchers[selector].push(handler);
  42 
  43     }
  44 
  45     EventEmitter.prototype.findWatcherDeps = function (selector) {
  46 
  47         // Go up to look for parent watchers
  48         // ex: if "some.nested.value" is the selector, it should also trigger for "some"
  49 
  50         var result = [];
  51         var watchers = _w.keys(this._watchers);
  52         watchers.forEach(function (watcher) {
  53             if (startsWith(selector, watcher)) { result.push(watcher); }
  54         });
  55         return result;
  56 
  57     }
  58 
  59     EventEmitter.prototype.emitChange = function (selector /* , arguments */) {
  60 
  61         if (!this._watchers) { this._watchers = {}; }
  62 
  63         var self = this;
  64 
  65         // Send data down to the local watchers
  66         var deps = self.findWatcherDeps(selector);
  67         deps.forEach(function (item) {
  68             if (self._watchers[item]) {
  69                 self._watchers[item].forEach(function (handler) {
  70                     handler.apply(self, [self.get(item)]);
  71                 });
  72             }
  73         });
  74 
  75         // Send data down to the global watchers
  76         if (!self._watchersAll || !_w.isArray(self._watchersAll)) { return; }
  77         self._watchersAll.forEach(function (watcher) {
  78             if (_w.isFunction(watcher)) { watcher.apply(self, [selector, self.get(selector)]); }
  79         });
  80 
  81     }
  82 
  83     ////////////////////
  84     // WAY DEFINITION //
  85     ////////////////////
  86 
  87     var WAY = function () {
  88 
  89         this.data = {};
  90         this._bindings = {};
  91         this.options = {
  92             persistent: true,
  93             timeoutInput: 50,
  94             timeoutDOM: 500
  95         };
  96 
  97     };
  98 
  99     // Inherit from EventEmitter
 100     WAY.prototype = Object.create(EventEmitter.prototype);
 101     WAY.constructor = WAY;
 102 
 103     //////////////////////////
 104     // DOM METHODS CHAINING //
 105     //////////////////////////
 106 
 107     WAY.prototype.dom = function (element) {
 108 
 109         this._element = w.dom(element).get(0);
 110         return this;
 111 
 112     };
 113 
 114     //////////////////////////////
 115     // DOM METHODS: DOM -> JSON //
 116     //////////////////////////////
 117 
 118     WAY.prototype.toStorage = function (options, element) {
 119 
 120         var self = this,
 121             element = element || self._element,
 122             options = options || self.dom(element).getOptions(),
 123             data = self.dom(element).toJSON(options),
 124             scope = self.dom(element).scope(),
 125             selector = scope ? scope + "." + options.data : options.data;
 126 
 127         if (options.readonly) { return false; }
 128         self.set(selector, data, options);
 129 
 130     }
 131 
 132     WAY.prototype.toJSON = function (options, element) {
 133 
 134         var self = this,
 135             element = element || self._element,
 136             data = self.dom(element).getValue(),
 137             options = options || self.dom(element).getOptions();
 138 
 139         if (_w.isArray(options.pick)) { data = selectNested(data, options.pick, true); }
 140         if (_w.isArray(options.omit)) { data = selectNested(data, options.omit, false); }
 141 
 142         return data;
 143 
 144     }
 145 
 146     //////////////////////////////
 147     // DOM METHODS: JSON -> DOM //
 148     //////////////////////////////
 149 
 150     WAY.prototype.fromStorage = function (options, element) {
 151 
 152         var self = this,
 153             element = element || self._element,
 154             options = options || self.dom(element).getOptions();
 155 
 156         if (options.writeonly) { return false; }
 157 
 158         var scope = self.dom(element).scope(),
 159                 selector = scope ? scope + "." + options.data : options.data,
 160                 data = self.get(selector);
 161 
 162         self.dom(element).fromJSON(data, options);
 163 
 164     }
 165 
 166     WAY.prototype.fromJSON = function (data, options, element) {
 167 
 168         var self = this,
 169                 element = element || self._element,
 170                 options = options || self.dom(element).getOptions();
 171 
 172         if (options.writeonly) { return false; }
 173 
 174         if (_w.isObject(data)) {
 175             if (_w.isArray(options.pick)) { data = selectNested(data, options.pick, true); }
 176             if (_w.isArray(options.omit)) { data = selectNested(data, options.omit, false); }
 177             var currentData = _w.isObject(self.dom(element).toJSON()) ? self.dom(element).toJSON() : {};
 178             data = _w.extend(currentData, data);
 179         }
 180 
 181         if (options.json) { data = _json.isStringified(data) ? data : _json.prettyprint(data); }
 182 
 183         self.dom(element).setValue(data, options);
 184 
 185     }
 186 
 187     /////////////////////////////////
 188     // DOM METHODS: GET - SET HTML //
 189     /////////////////////////////////
 190 
 191     WAY.prototype.getValue = function (element) {
 192 
 193         var self = this,
 194             element = element || self._element;
 195 
 196         var getters = {
 197             "SELECT": function () {
 198                 return w.dom(element).val();
 199             },
 200             "INPUT": function () {
 201                 var type = w.dom(element).type();
 202                 if (_w.contains(["text", "password"], type)) {
 203                     return w.dom(element).val();
 204                 }
 205                 if (_w.contains(["checkbox", "radio"], type)) {
 206                     return w.dom(element).prop("checked") ? w.dom(element).val() : null;
 207                 }
 208 
 209             },
 210             "TEXTAREA": function () {
 211                 return w.dom(element).val();
 212             }
 213         }
 214         var defaultGetter = function (a) {
 215             return w.dom(element).html();
 216         }
 217 
 218         var elementType = w.dom(element).get(0).tagName;
 219         var getter = getters[elementType] || defaultGetter;
 220         return getter();
 221 
 222     }
 223 
 224     WAY.prototype._transforms = {
 225         uppercase: function (data) {
 226             return _w.isString(data) ? data.toUpperCase() : data;
 227         },
 228         lowercase: function (data) {
 229             return _w.isString(data) ? data.toLowerCase() : data;
 230         },
 231         reverse: function (data) {
 232             return data && data.split && _w.isFunction(data.split) ? data.split("").reverse().join("") : data;
 233         }
 234     };
 235 
 236     WAY.prototype.registerTransform = function (name, transform) {
 237         var self = this;
 238         if (_w.isFunction(transform)) { self._transforms[name] = transform; }
 239     }
 240 
 241     WAY.prototype.setValue = function (data, options, element) {
 242 
 243         var self = this,
 244             element = element || self._element,
 245             options = options || self.dom(element).getOptions();
 246 
 247         options.transform = options.transform || [];
 248         options.transform.forEach(function (transformName) {
 249             var transform = self._transforms[transformName] || function (data) { return data };
 250             data = transform(data);
 251         });
 252 
 253         var setters = {
 254 
 255             "SELECT": function (a) {
 256                 w.dom(element).val(a);
 257             },
 258             "INPUT": function (a) {
 259                 if (!_w.isString(a)) { a = JSON.stringify(a); }
 260                 var type = w.dom(element).get(0).type;
 261                 if (_w.contains(["text", "password"], type)) {
 262                     w.dom(element).val(a || "");
 263                 }
 264                 if (_w.contains(["checkbox", "radio"], type)) {
 265                     if (a === w.dom(element).val()) {
 266                         w.dom(element).prop("checked", true);
 267                     } else {
 268                         w.dom(element).prop("checked", false);
 269                     }
 270                 }
 271             },
 272             "TEXTAREA": function (a) {
 273                 if (!_w.isString(a)) { a = JSON.stringify(a); }
 274                 w.dom(element).val(a || "");
 275             },
 276             "PRE": function (a) {
 277                 if (options.html) {
 278                     w.dom(element).html(a);
 279                 } else {
 280                     w.dom(element).text(a);
 281                 }
 282             },
 283             "IMG": function (a) {
 284 
 285                 if (!a) {
 286                     a = options.default || "";
 287                     w.dom(element).attr("src", a);
 288                     return false;
 289                 }
 290 
 291                 var isValidImageUrl = function (url, cb) {
 292                     w.dom(element).addClass("way-loading");
 293                     w.dom("img", {
 294                         src: url,
 295                         onerror: function () { cb(false); },
 296                         onload: function () { cb(true); }
 297                     });
 298                 }
 299 
 300                 isValidImageUrl(a, function (response) {
 301                     w.dom(element).removeClass("way-loading");
 302                     if (response) {
 303                         w.dom(element).removeClass("way-error").addClass("way-success");
 304                     } else {
 305                         if (a) {
 306                             w.dom(element).addClass("way-error");
 307                         } else {
 308                             w.dom(element).removeClass("way-error").removeClass("way-success");
 309                         }
 310                         a = options.default || "";
 311                     }
 312                     w.dom(element).attr("src", a);
 313                 });
 314 
 315             }
 316 
 317         }
 318         var defaultSetter = function (a) {
 319 
 320             if (options.html) {
 321                 w.dom(element).html(a);
 322             } else {
 323                 w.dom(element).text(a);
 324             }
 325 
 326         }
 327 
 328         var elementType = w.dom(element).get(0).tagName;
 329         var setter = setters[elementType] || defaultSetter;
 330         setter(data);
 331 
 332     }
 333 
 334     WAY.prototype.setDefault = function (force, options, element) {
 335 
 336         var self = this,
 337             element = element || self._element,
 338             force = force || false,
 339             options = options ? _w.extend(self.dom(element).getOptions(), options) : self.dom(element).getOptions();
 340 
 341         // Should we just set the default value in the DOM, or also in the datastore?
 342         if (!options.default) { return false; }
 343         if (force) {
 344             self.set(options.data, options.default, options);
 345         } else {
 346             self.dom(element).setValue(options.default, options);
 347         }
 348 
 349     }
 350 
 351     WAY.prototype.setDefaults = function () {
 352 
 353         var self = this,
 354             dataSelector = "[" + tagPrefix + "-default]";
 355 
 356         var elements = w.dom(dataSelector).get();
 357         for (var i in elements) {
 358             var element = elements[i],
 359                     options = self.dom(element).getOptions(),
 360                     selector = options.data || null,
 361                     data = selector ? self.get(selector) : null;
 362             if (!data) { self.dom(element).setDefault(); }
 363         }
 364 
 365     }
 366 
 367     /////////////////////////////////////
 368     // DOM METHODS: GET - SET BINDINGS //
 369     /////////////////////////////////////
 370 
 371     // Scans the DOM to look for new bindings
 372     WAY.prototype.registerBindings = function () {
 373 
 374         // Dealing with bindings removed from the DOM by just resetting all the bindings all the time.
 375         // Isn't there a better way?
 376         // One idea would be to add a "way-bound" class to bound elements
 377         // self._bindings = {};
 378 
 379         var self = this;
 380         var selector = "[" + tagPrefix + "-data]";
 381         self._bindings = {};
 382 
 383         var elements = w.dom(selector).get();
 384         for (var i in elements) {
 385             var element = elements[i],
 386                     options = self.dom(element).getOptions(),
 387                     scope = self.dom(element).scope(),
 388                     selector = scope ? scope + "." + options.data : options.data;
 389 
 390             self._bindings[selector] = self._bindings[selector] || [];
 391             if (!_w.contains(self._bindings[selector], w.dom(element).get(0))) {
 392                 self._bindings[selector].push(w.dom(element).get(0));
 393             }
 394 
 395         }
 396 
 397     }
 398 
 399     WAY.prototype.updateBindings = function (selector) {
 400 
 401         var self = this;
 402         self._bindings = self._bindings || {};
 403 
 404         // Set bindings for the data selector
 405         var bindings = pickAndMergeParentArrays(self._bindings, selector);
 406         bindings.forEach(function (element) {
 407             var focused = (w.dom(element).get(0) === w.dom(":focus").get(0)) ? true : false;
 408             if (!focused) { self.dom(element).fromStorage(); }
 409         });
 410 
 411         // Set bindings for the global selector
 412         if (self._bindings["__all__"]) {
 413             self._bindings["__all__"].forEach(function (element) {
 414                 self.dom(element).fromJSON(self.data);
 415             });
 416         }
 417 
 418     }
 419 
 420     ////////////////////////////////////
 421     // DOM METHODS: GET - SET REPEATS //
 422     ////////////////////////////////////
 423 
 424     WAY.prototype.registerRepeats = function () {
 425 
 426         // Register repeats
 427         var self = this;
 428         var selector = "[" + tagPrefix + "-repeat]";
 429         self._repeats = self._repeats || {};
 430         self._repeatsCount = self._repeatsCount || 0;
 431 
 432         var elements = w.dom(selector).get();
 433         for (var i in elements) {
 434             var element = elements[i],
 435                     options = self.dom(element).getOptions();
 436 
 437             self._repeats[options.repeat] = self._repeats[options.repeat] || [];
 438 
 439             var wrapperAttr = tagPrefix + "-repeat-wrapper=\"" + self._repeatsCount + "\"",
 440                     parent = w.dom(element).parent("[" + wrapperAttr + "]");
 441             if (!parent.length) {
 442 
 443                 self._repeats[options.repeat].push({
 444                     id: self._repeatsCount,
 445                     element: w.dom(element).clone(true).removeAttr(tagPrefix + "-repeat").removeAttr(tagPrefix + "-filter").get(0),
 446                     selector: options.repeat,
 447                     filter: options.filter
 448                 });
 449 
 450                 var wrapper = document.createElement("div");
 451                 w.dom(wrapper).attr(tagPrefix + "-repeat-wrapper", self._repeatsCount);
 452                 w.dom(wrapper).attr(tagPrefix + "-scope", options.repeat);
 453                 if (options.filter) { w.dom(wrapper).attr(tagPrefix + "-filter", options.filter); }
 454 
 455                 w.dom(element).replaceWith(wrapper);
 456                 self.updateRepeats(options.repeat);
 457 
 458                 self._repeatsCount++;
 459 
 460             }
 461 
 462         }
 463 
 464     }
 465 
 466     /*
 467     WAY.prototype._filters = {
 468         noFalsy: function(item ) {
 469             if (!item) {
 470                 return false;
 471             } else {
 472                 return true;
 473             }
 474         }
 475     };
 476 
 477     WAY.prototype.registerFilter = function(name, filter) {
 478         var self = this;
 479         if (_w.isFunction(filter)) { self._filters[name] = filter; }
 480     }
 481     */
 482 
 483     WAY.prototype.updateRepeats = function (selector) {
 484 
 485         var self = this;
 486         self._repeats = self._repeats || {};
 487 
 488         var repeats = pickAndMergeParentArrays(self._repeats, selector);
 489 
 490         repeats.forEach(function (repeat) {
 491 
 492             var wrapper = "[" + tagPrefix + "-repeat-wrapper=\"" + repeat.id + "\"]",
 493                     data = self.get(repeat.selector),
 494                     items = [];
 495 
 496             repeat.filter = repeat.filter || [];
 497             w.dom(wrapper).empty();
 498 
 499             for (var key in data) {
 500 
 501                 /*
 502                 var item = data[key],
 503                         test = true;
 504                 for (var i in repeat.filter) {
 505                     var filterName = repeat.filter[i];
 506                     var filter = self._filters[filterName] || function(data) { return data };
 507                     test = filter(item);
 508                     if (!test) { break; }
 509                 }
 510                 if (!test) { continue; }
 511                 */
 512 
 513                 w.dom(repeat.element).attr(tagPrefix + "-scope", key);
 514                 var html = w.dom(repeat.element).get(0).outerHTML;
 515                 html = html.replace(/\$\$key/gi, key);
 516                 items.push(html);
 517 
 518             }
 519 
 520             w.dom(wrapper).html(items.join(""));
 521             self.registerBindings();
 522             self.updateBindings();
 523 
 524         });
 525 
 526     }
 527 
 528     ////////////////////////
 529     // DOM METHODS: FORMS //
 530     ////////////////////////
 531 
 532     WAY.prototype.updateForms = function () {
 533 
 534         // If we just parse the forms with form2js (see commits before 08/19/2014) and set the data with way.set(),
 535         // we reset the entire data for this pathkey in the datastore. It causes the bug
 536         // reported here: https://github.com/gwendall/way.js/issues/10
 537         // Solution:
 538         // 1. watch new forms with a [way-data] attribute
 539         // 2. remove this attribute
 540         // 3. attach the appropriate attributes to its child inputs
 541         // -> so that each input is set separately to way.js' datastore
 542 
 543         var self = this;
 544         var selector = "form[" + tagPrefix + "-data]";
 545 
 546         var elements = w.dom(selector).get();
 547         for (var i in elements) {
 548 
 549             var form = elements[i],
 550                     options = self.dom(form).getOptions(),
 551                     formDataSelector = options.data;
 552             w.dom(form).removeAttr(tagPrefix + "-data");
 553 
 554             // Reverse needed to set the right index for "[]" names
 555             var inputs = w.dom(form).find("[name]").reverse().get();
 556             for (var i in inputs) {
 557 
 558                 var input = inputs[i],
 559                         name = w.dom(input).attr("name");
 560 
 561                 if (endsWith(name, "[]")) {
 562                     var array = name.split("[]")[0],
 563                             arraySelector = "[name^='" + array + "']",
 564                             arrayIndex = w.dom(form).find(arraySelector).get().length;
 565                     name = array + "." + arrayIndex;
 566                 }
 567                 var selector = formDataSelector + "." + name;
 568                 options.data = selector;
 569                 self.dom(input).setOptions(options);
 570                 w.dom(input).removeAttr("name");
 571 
 572             }
 573 
 574         }
 575 
 576     }
 577 
 578     /////////////////////////////////////////////
 579     // DOM METHODS: GET - SET ALL DEPENDENCIES //
 580     /////////////////////////////////////////////
 581 
 582     WAY.prototype.registerDependencies = function () {
 583 
 584         this.registerBindings();
 585         this.registerRepeats();
 586 
 587     }
 588 
 589     WAY.prototype.updateDependencies = function (selector) {
 590 
 591         this.updateBindings(selector);
 592         this.updateRepeats(selector);
 593         this.updateForms(selector);
 594 
 595     }
 596 
 597     //////////////////////////////////
 598     // DOM METHODS: OPTIONS PARSING //
 599     //////////////////////////////////
 600 
 601     WAY.prototype.setOptions = function (options, element) {
 602 
 603         var self = this,
 604                 element = self._element || element;
 605 
 606         for (var k in options) {
 607             var attr = tagPrefix + "-" + k,
 608                     value = options[k];
 609             w.dom(element).attr(attr, value);
 610         }
 611 
 612     }
 613 
 614     WAY.prototype.getOptions = function (element) {
 615 
 616         var self = this,
 617             element = element || self._element,
 618             defaultOptions = {
 619                 data: null,
 620                 html: false,
 621                 readonly: false,
 622                 writeonly: false,
 623                 persistent: false
 624             };
 625         return _w.extend(defaultOptions, self.dom(element).getAttrs(tagPrefix));
 626 
 627     }
 628 
 629     WAY.prototype.getAttrs = function (prefix, element) {
 630 
 631         var self = this,
 632                 element = element || self._element;
 633 
 634         var parseAttrValue = function (key, value) {
 635 
 636             var attrTypes = {
 637                 pick: "array",
 638                 omit: "array",
 639                 readonly: "boolean",
 640                 writeonly: "boolean",
 641                 json: "boolean",
 642                 html: "boolean",
 643                 persistent: "boolean"
 644             };
 645 
 646             var parsers = {
 647                 array: function (value) {
 648                     return value.split(",");
 649                 },
 650                 boolean: function (value) {
 651                     if (value === "true") { return true; }
 652                     if (value === "false") { return false; }
 653                     return true;
 654                 }
 655             };
 656             var defaultParser = function () { return value; };
 657             var valueType = attrTypes[key] || null;
 658             var parser = parsers[valueType] || defaultParser;
 659 
 660             return parser(value);
 661 
 662         }
 663 
 664         var attributes = {};
 665         var attrs = [].slice.call(w.dom(element).get(0).attributes);
 666         attrs.forEach(function (attr) {
 667             var include = (prefix && startsWith(attr.name, prefix + "-")) ? true : false;
 668             if (include) {
 669                 var name = (prefix) ? attr.name.slice(prefix.length + 1, attr.name.length) : attr.name;
 670                 var value = parseAttrValue(name, attr.value);
 671                 if (_w.contains(["transform", "filter"], name)) { value = value.split("|"); }
 672                 attributes[name] = value;
 673             }
 674         });
 675 
 676         return attributes;
 677 
 678     }
 679 
 680     //////////////////////////
 681     // DOM METHODS: SCOPING //
 682     //////////////////////////
 683 
 684     WAY.prototype.scope = function (options, element) {
 685 
 686         var self = this,
 687                 element = element || self._element,
 688                 scopeAttr = tagPrefix + "-scope",
 689                 scopeBreakAttr = tagPrefix + "-scope-break",
 690                 scopes = [],
 691                 scope = "";
 692 
 693         var parentsSelector = "[" + scopeBreakAttr + "], [" + scopeAttr + "]";
 694         var elements = w.dom(element).parents(parentsSelector).get();
 695         for (var i in elements) {
 696             var el = elements[i];
 697             if (w.dom(el).attr(scopeBreakAttr)) { break; }
 698             var attr = w.dom(el).attr(scopeAttr);
 699             scopes.unshift(attr);
 700         }
 701         if (w.dom(element).attr(scopeAttr)) { scopes.push(w.dom(element).attr(scopeAttr)); }
 702         if (w.dom(element).attr(scopeBreakAttr)) { scopes = []; }
 703 
 704         scope = _w.compact(scopes).join(".");
 705 
 706         return scope;
 707 
 708     }
 709 
 710     //////////////////
 711     // DATA METHODS //
 712     //////////////////
 713 
 714     WAY.prototype.get = function (selector) {
 715 
 716         var self = this;
 717         if (selector !== undefined && !_w.isString(selector)) { return false; }
 718         if (!self.data) { return {}; }
 719         return selector ? _json.get(self.data, selector) : self.data;
 720 
 721     }
 722 
 723     WAY.prototype.set = function (selector, value, options) {
 724 
 725         if (!selector) { return false; }
 726         if (selector.split(".")[0] === "this") {
 727             console.log("Sorry, \"this\" is a reserved word in way.js");
 728             return false;
 729         }
 730 
 731         var self = this;
 732         options = options || {};
 733 
 734         if (selector) {
 735 
 736             if (!_w.isString(selector)) { return false; }
 737             self.data = self.data || {};
 738             self.data = selector ? _json.set(self.data, selector, value) : {};
 739 
 740             self.updateDependencies(selector);
 741             self.emitChange(selector, value);
 742             if (options.persistent) { self.backup(selector); }
 743         }
 744 
 745     }
 746 
 747     WAY.prototype.push = function (selector, value, options) {
 748 
 749         if (!selector) { return false; }
 750 
 751         var self = this;
 752         options = options || {};
 753 
 754         if (selector) {
 755             self.data = selector ? _json.push(self.data, selector, value, true) : {};
 756         }
 757 
 758         self.updateDependencies(selector);
 759         self.emitChange(selector, null);
 760         if (options.persistent) { self.backup(selector); }
 761 
 762     }
 763 
 764     WAY.prototype.remove = function (selector, options) {
 765 
 766         var self = this;
 767         options = options || {};
 768 
 769         if (selector) {
 770             self.data = _json.remove(self.data, selector);
 771         } else {
 772             self.data = {};
 773         }
 774 
 775         self.updateDependencies(selector);
 776         self.emitChange(selector, null);
 777         if (options.persistent) { self.backup(selector); }
 778 
 779     }
 780 
 781     WAY.prototype.clear = function () {
 782 
 783         this.remove(null, { persistent: true });
 784 
 785     }
 786 
 787     //////////////////////////
 788     // LOCALSTORAGE METHODS //
 789     //////////////////////////
 790 
 791     WAY.prototype.backup = function () {
 792 
 793         var self = this;
 794         if (!self.options.persistent) { return; }
 795         try {
 796             var data = self.data || {};
 797             localStorage.setItem(tagPrefix, JSON.stringify(data));
 798         } catch (e) {
 799             console.log("Your browser does not support localStorage.");
 800         }
 801 
 802     }
 803 
 804     WAY.prototype.restore = function () {
 805 
 806         var self = this;
 807         if (!self.options.persistent) { return; }
 808         try {
 809             var data = localStorage.getItem(tagPrefix);
 810             try {
 811                 data = JSON.parse(data);
 812                 for (var key in data) {
 813                     self.set(key, data[key]);
 814                 }
 815             } catch (e) { }
 816         } catch (e) {
 817             console.log("Your browser does not support localStorage.");
 818         }
 819 
 820     }
 821 
 822     //////////
 823     // MISC //
 824     //////////
 825 
 826     var matchesSelector = function (el, selector) {
 827         var matchers = ["matches", "matchesSelector", "webkitMatchesSelector", "mozMatchesSelector", "msMatchesSelector", "oMatchesSelector"],
 828                 fn = null;
 829         for (var i in matchers) {
 830             fn = matchers[i];
 831             if (_w.isFunction(el[fn])) {
 832                 return el[fn](selector);
 833             }
 834         }
 835         return false;
 836     }
 837 
 838     var startsWith = function (str, starts) {
 839 
 840         if (starts === "") { return true; }
 841         if (str === null || starts === null) { return false; }
 842         str = String(str); starts = String(starts);
 843         return str.length >= starts.length && str.slice(0, starts.length) === starts;
 844 
 845     }
 846 
 847     var endsWith = function (str, ends) {
 848 
 849         if (ends === "") { return true; }
 850         if (str === null || ends === null) { return false; }
 851         str = String(str); ends = String(ends);
 852         return str.length >= ends.length && str.slice(str.length - ends.length, str.length) === ends;
 853 
 854     }
 855 
 856     var cleanEmptyKeys = function (object) {
 857 
 858         return _w.pick(object, _w.compact(_w.keys(object)));
 859 
 860     }
 861 
 862     var filterStartingWith = function (object, string, type) { // true: pick - false: omit
 863 
 864         var keys = _w.keys(object);
 865         keys.forEach(function (key) {
 866             if (type) {
 867                 if (!startsWith(key, string)) { delete object[key]; }
 868             } else {
 869                 if (startsWith(key, string)) { delete object[key]; }
 870             }
 871         });
 872         return object;
 873 
 874     }
 875 
 876     var selectNested = function (data, keys, type) { // true: pick - false: omit
 877 
 878         // Flatten / unflatten to allow for nested picks / omits (doesn't work with regular pick)
 879         // ex:  data = {something:{nested:"value"}}
 880         //        keys = ['something.nested']
 881 
 882         var flat = _json.flatten(data);
 883         for (var i in keys) flat = filterStartingWith(flat, keys[i], type);
 884         var unflat = _json.unflatten(flat);
 885         // Unflatten returns an object with an empty property if it is given an empty object
 886         return cleanEmptyKeys(unflat);
 887 
 888     }
 889 
 890     var pickAndMergeParentArrays = function (object, selector) {
 891 
 892         // Example:
 893         // object = { a: [1,2,3], a.b: [4,5,6], c: [7,8,9] }
 894         // fn(object, "a.b")
 895         // > [1,2,3,4,5,6]
 896 
 897         var keys = [];
 898         if (selector) {
 899 
 900             // Set bindings for the specified selector
 901 
 902             // (bindings that are repeat items)
 903             var split = selector.split("."),
 904                     lastKey = split[split.length - 1],
 905                     isArrayItem = !isNaN(lastKey);
 906 
 907             if (isArrayItem) {
 908                 split.pop();
 909                 var key = split.join(".");
 910                 keys = object[key] ? _w.union(keys, object[key]) : keys;
 911             }
 912 
 913             // (bindings with keys starting with, to include nested bindings)
 914             for (var key in object) {
 915                 if (startsWith(key, selector)) { keys = _w.union(keys, object[key]); }
 916             }
 917 
 918         } else {
 919 
 920             // Set bindings for all selectors
 921             for (var key in object) {
 922                 keys = _w.union(keys, object[key]);
 923             }
 924 
 925         }
 926         return keys;
 927 
 928     }
 929 
 930     var isPrintableKey = function (e) {
 931 
 932         var keycode = e.keyCode;
 933         if (!keycode) { return true; }
 934 
 935         var valid =
 936             (keycode === 8) || // delete
 937             (keycode > 47 && keycode < 58) || // number keys
 938             keycode === 32 || keycode === 13 || // spacebar & return key(s) (if you want to allow carriage returns)
 939             (keycode > 64 && keycode < 91) || // letter keys
 940             (keycode > 95 && keycode < 112) || // numpad keys
 941             (keycode > 185 && keycode < 193) || // ;=,-./` (in order)
 942             (keycode > 218 && keycode < 223);   // [\]' (in order)
 943 
 944         return valid;
 945 
 946     }
 947 
 948     var escapeHTML = function (str) {
 949         return str && _w.isString(str) ? str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;") : str;
 950     }
 951 
 952     ///////////////////////////////////////////////////
 953     // _w (strip of the required underscore methods) //
 954     ///////////////////////////////////////////////////
 955 
 956     var _w = {};
 957 
 958     var ArrayProto = Array.prototype,
 959             ObjProto = Object.prototype,
 960             FuncProto = Function.prototype;
 961 
 962     var nativeIsArray = Array.isArray,
 963             nativeKeys = Object.keys,
 964             nativeBind = FuncProto.bind;
 965 
 966     var
 967         push = ArrayProto.push,
 968         slice = ArrayProto.slice,
 969         concat = ArrayProto.concat,
 970         toString = ObjProto.toString,
 971         hasOwnProperty = ObjProto.hasOwnProperty;
 972 
 973     var flatten = function (input, shallow, strict, output) {
 974         if (shallow && _w.every(input, _w.isArray)) {
 975             return concat.apply(output, input);
 976         }
 977         for (var i = 0, length = input.length; i < length; i++) {
 978             var value = input[i];
 979             if (!_w.isArray(value) && !_w.isArguments(value)) {
 980                 if (!strict) output.push(value);
 981             } else if (shallow) {
 982                 push.apply(output, value);
 983             } else {
 984                 flatten(value, shallow, strict, output);
 985             }
 986         }
 987         return output;
 988     };
 989 
 990     var createCallback = function (func, context, argCount) {
 991         if (context === void 0) return func;
 992         switch (argCount == null ? 3 : argCount) {
 993             case 1: return function (value) {
 994                 return func.call(context, value);
 995             };
 996             case 2: return function (value, other) {
 997                 return func.call(context, value, other);
 998             };
 999             case 3: return function (value, index, collection) {
1000                 return func.call(context, value, index, collection);
1001             };
1002             case 4: return function (accumulator, value, index, collection) {
1003                 return func.call(context, accumulator, value, index, collection);
1004             };
1005         }
1006         return function () {
1007             return func.apply(context, arguments);
1008         };
1009     };
1010 
1011     _w.compact = function (array) {
1012         return _w.filter(array, _w.identity);
1013     };
1014 
1015     _w.filter = function (obj, predicate, context) {
1016         var results = [];
1017         if (obj == null) return results;
1018         predicate = _w.iteratee(predicate, context);
1019         _w.each(obj, function (value, index, list) {
1020             if (predicate(value, index, list)) results.push(value);
1021         });
1022         return results;
1023     };
1024 
1025     _w.identity = function (value) {
1026         return value;
1027     };
1028 
1029     _w.every = function (obj, predicate, context) {
1030         if (obj == null) return true;
1031         predicate = _w.iteratee(predicate, context);
1032         var keys = obj.length !== +obj.length && _w.keys(obj),
1033                 length = (keys || obj).length,
1034                 index, currentKey;
1035         for (index = 0; index < length; index++) {
1036             currentKey = keys ? keys[index] : index;
1037             if (!predicate(obj[currentKey], currentKey, obj)) return false;
1038         }
1039         return true;
1040     };
1041 
1042     _w.union = function () {
1043         return _w.uniq(flatten(arguments, true, true, []));
1044     };
1045 
1046     _w.uniq = function (array, isSorted, iteratee, context) {
1047         if (array == null) return [];
1048         if (!_w.isBoolean(isSorted)) {
1049             context = iteratee;
1050             iteratee = isSorted;
1051             isSorted = false;
1052         }
1053         if (iteratee != null) iteratee = _w.iteratee(iteratee, context);
1054         var result = [];
1055         var seen = [];
1056         for (var i = 0, length = array.length; i < length; i++) {
1057             var value = array[i];
1058             if (isSorted) {
1059                 if (!i || seen !== value) result.push(value);
1060                 seen = value;
1061             } else if (iteratee) {
1062                 var computed = iteratee(value, i, array);
1063                 if (_w.indexOf(seen, computed) < 0) {
1064                     seen.push(computed);
1065                     result.push(value);
1066                 }
1067             } else if (_w.indexOf(result, value) < 0) {
1068                 result.push(value);
1069             }
1070         }
1071         return result;
1072     };
1073 
1074     _w.pick = function (obj, iteratee, context) {
1075         var result = {}, key;
1076         if (obj == null) return result;
1077         if (_w.isFunction(iteratee)) {
1078             iteratee = createCallback(iteratee, context);
1079             for (key in obj) {
1080                 var value = obj[key];
1081                 if (iteratee(value, key, obj)) result[key] = value;
1082             }
1083         } else {
1084             var keys = concat.apply([], slice.call(arguments, 1));
1085             obj = new Object(obj);
1086             for (var i = 0, length = keys.length; i < length; i++) {
1087                 key = keys[i];
1088                 if (key in obj) result[key] = obj[key];
1089             }
1090         }
1091         return result;
1092     };
1093 
1094     _w.has = function (obj, key) {
1095         return obj != null && hasOwnProperty.call(obj, key);
1096     };
1097 
1098     _w.keys = function (obj) {
1099         if (!_w.isObject(obj)) return [];
1100         if (nativeKeys) return nativeKeys(obj);
1101         var keys = [];
1102         for (var key in obj) if (_w.has(obj, key)) keys.push(key);
1103         return keys;
1104     };
1105 
1106     _w.contains = function (obj, target) {
1107         if (obj == null) return false;
1108         if (obj.length !== +obj.length) obj = _w.values(obj);
1109         return _w.indexOf(obj, target) >= 0;
1110     };
1111 
1112     _w.sortedIndex = function (array, obj, iteratee, context) {
1113         iteratee = _w.iteratee(iteratee, context, 1);
1114         var value = iteratee(obj);
1115         var low = 0, high = array.length;
1116         while (low < high) {
1117             var mid = low + high >>> 1;
1118             if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
1119         }
1120         return low;
1121     };
1122 
1123     _w.property = function (key) {
1124         return function (obj) {
1125             return obj[key];
1126         };
1127     };
1128 
1129     _w.iteratee = function (value, context, argCount) {
1130         if (value == null) return _w.identity;
1131         if (_w.isFunction(value)) return createCallback(value, context, argCount);
1132         if (_w.isObject(value)) return _w.matches(value);
1133         return _w.property(value);
1134     };
1135 
1136     _w.pairs = function (obj) {
1137         var keys = _w.keys(obj);
1138         var length = keys.length;
1139         var pairs = Array(length);
1140         for (var i = 0; i < length; i++) {
1141             pairs[i] = [keys[i], obj[keys[i]]];
1142         }
1143         return pairs;
1144     };
1145 
1146     _w.matches = function (attrs) {
1147         var pairs = _w.pairs(attrs), length = pairs.length;
1148         return function (obj) {
1149             if (obj == null) return !length;
1150             obj = new Object(obj);
1151             for (var i = 0; i < length; i++) {
1152                 var pair = pairs[i], key = pair[0];
1153                 if (pair[1] !== obj[key] || !(key in obj)) return false;
1154             }
1155             return true;
1156         };
1157     };
1158 
1159     _w.indexOf = function (array, item, isSorted) {
1160         if (array == null) return -1;
1161         var i = 0, length = array.length;
1162         if (isSorted) {
1163             if (typeof isSorted == 'number') {
1164                 i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted;
1165             } else {
1166                 i = _w.sortedIndex(array, item);
1167                 return array[i] === item ? i : -1;
1168             }
1169         }
1170         for (; i < length; i++) if (array[i] === item) return i;
1171         return -1;
1172     };
1173 
1174     _w.values = function (obj) {
1175         var keys = _w.keys(obj);
1176         var length = keys.length;
1177         var values = Array(length);
1178         for (var i = 0; i < length; i++) {
1179             values[i] = obj[keys[i]];
1180         }
1181         return values;
1182     };
1183 
1184     _w.extend = function (obj) {
1185         if (!_w.isObject(obj)) return obj;
1186         var source, prop;
1187         for (var i = 1, length = arguments.length; i < length; i++) {
1188             source = arguments[i];
1189             for (prop in source) {
1190                 if (hasOwnProperty.call(source, prop)) {
1191                     obj[prop] = source[prop];
1192                 }
1193             }
1194         }
1195         return obj;
1196     };
1197 
1198     _w.isArray = function (obj) {
1199         return toString.call(obj) === '[object Array]';
1200     };
1201 
1202     _w.isBoolean = function (obj) {
1203         return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
1204     };
1205 
1206     _w.isUndefined = function (obj) {
1207         return obj === void 0;
1208     };
1209 
1210     _w.isObject = function (obj) {
1211         var type = typeof obj;
1212         return type === 'function' || type === 'object' && !!obj;
1213     };
1214 
1215     _w.each = function (obj, iteratee, context) {
1216         if (obj == null) return obj;
1217         iteratee = createCallback(iteratee, context);
1218         var i, length = obj.length;
1219         if (length === +length) {
1220             for (i = 0; i < length; i++) {
1221                 iteratee(obj[i], i, obj);
1222             }
1223         } else {
1224             var keys = _w.keys(obj);
1225             for (i = 0, length = keys.length; i < length; i++) {
1226                 iteratee(obj[keys[i]], keys[i], obj);
1227             }
1228         }
1229         return obj;
1230     };
1231 
1232     _w.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function (name) {
1233         _w['is' + name] = function (obj) {
1234             return toString.call(obj) === '[object ' + name + ']';
1235         };
1236     });
1237 
1238     ///////////////////////////////////////////////////////////
1239     // _json (strip of the required underscore.json methods) //
1240     ///////////////////////////////////////////////////////////
1241 
1242     var deepJSON = function (obj, key, value, remove) {
1243 
1244         var keys = key.replace(/\[(["']?)([^\1]+?)\1?\]/g, '.$2').replace(/^\./, '').split('.'),
1245                 root,
1246                 i = 0,
1247                 n = keys.length;
1248 
1249         // Set deep value
1250         if (arguments.length > 2) {
1251 
1252             root = obj;
1253             n--;
1254 
1255             while (i < n) {
1256                 key = keys[i++];
1257                 obj = obj[key] = _w.isObject(obj[key]) ? obj[key] : {};
1258             }
1259 
1260             if (remove) {
1261                 if (_w.isArray(obj)) {
1262                     obj.splice(keys[i], 1);
1263                 } else {
1264                     delete obj[keys[i]];
1265                 }
1266             } else {
1267                 obj[keys[i]] = value || "";
1268             }
1269 
1270             value = root;
1271 
1272             // Get deep value
1273         } else {
1274             while ((obj = obj[keys[i++]]) != null && i < n) { };
1275             value = i < n ? void 0 : obj;
1276         }
1277         if (value == null) {
1278             value = "";
1279         }
1280         return value;
1281 
1282     }
1283 
1284     var _json = {}
1285 
1286     _json.VERSION = '0.1.0';
1287     _json.debug = true;
1288 
1289     _json.exit = function (source, reason, data, value) {
1290 
1291         if (!_json.debug) return;
1292 
1293         var messages = {};
1294         messages.noJSON = "Not a JSON";
1295         messages.noString = "Not a String";
1296         messages.noArray = "Not an Array";
1297         messages.missing = "Missing argument";
1298 
1299         var error = { source: source, data: data, value: value };
1300         error.message = messages[reason] ? messages[reason] : "No particular reason";
1301         console.log("Error", error);
1302         return;
1303 
1304     }
1305 
1306     _json.is = function (json) {
1307 
1308         return (toString.call(json) == "[object Object]");
1309 
1310     }
1311 
1312     _json.isStringified = function (string) {
1313 
1314         var test = false;
1315         try {
1316             test = /^[\],:{}\s]*$/.test(string.replace(/\\["\\\/bfnrtu]/g, '@').
1317             replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
1318             replace(/(?:^|:|,)(?:\s*\[)+/g, ''));
1319         } catch (e) { }
1320         return test;
1321 
1322     }
1323 
1324     _json.get = function (json, selector) {
1325 
1326         if (json == undefined) return _json.exit("get", "missing", "json", json);
1327         if (selector == undefined) return _json.exit("get", "missing", "selector", selector);
1328         if (!_w.isString(selector)) return _json.exit("get", "noString", "selector", selector);
1329         return deepJSON(json, selector);
1330 
1331     };
1332 
1333     _json.set = function (json, selector, value) {
1334 
1335         if (json == undefined) return _json.exit("set", "missing", "json", json);
1336         if (selector == undefined) return _json.exit("set", "missing", "selector", selector);
1337         if (!_w.isString(selector)) return _json.exit("set", "noString", "selector", selector);
1338         return value ? deepJSON(json, selector, value) : _json.remove(json, selector);
1339         // return deepJSON(json, selector, value); // Now removes the property if the value is empty. Maybe should keep it instead?
1340 
1341     };
1342 
1343     _json.remove = function (json, selector) {
1344 
1345         if (json == undefined) return _json.exit("remove", "missing", "json", json);
1346         if (selector == undefined) return _json.exit("remove", "missing", "selector", selector);
1347         if (!_w.isString(selector)) return _json.exit("remove", "noString", "selector", selector);
1348         return deepJSON(json, selector, null, true);
1349 
1350     }
1351 
1352     _json.push = function (json, selector, value, force) {
1353 
1354         if (json == undefined) return _json.exit("push", "missing", "json", json);
1355         if (selector == undefined) return _json.exit("push", "missing", "selector", selector);
1356         var array = _json.get(json, selector);
1357         if (!_w.isArray(array)) {
1358             if (force) {
1359                 array = [];
1360             } else {
1361                 return _json.exit("push", "noArray", "array", array);
1362             }
1363         }
1364         array.push(value);
1365         return _json.set(json, selector, array);
1366 
1367     }
1368 
1369     _json.unshift = function (json, selector, value) {
1370 
1371         if (json == undefined) return _json.exit("unshift", "missing", "json", json);
1372         if (selector == undefined) return _json.exit("unshift", "missing", "selector", selector);
1373         if (value == undefined) return _json.exit("unshift", "missing", "value", value);
1374         var array = _json.get(json, selector);
1375         if (!_w.isArray(array)) return _json.exit("unshift", "noArray", "array", array);
1376         array.unshift(value);
1377         return _json.set(json, selector, array);
1378 
1379     }
1380 
1381     _json.flatten = function (json) {
1382 
1383         if (json.constructor.name != "Object") return _json.exit("flatten", "noJSON", "json", json);
1384 
1385         var result = {};
1386         function recurse(cur, prop) {
1387             if (Object(cur) !== cur) {
1388                 result[prop] = cur;
1389             } else if (Array.isArray(cur)) {
1390                 for (var i = 0, l = cur.length; i < l; i++) {
1391                     recurse(cur[i], prop ? prop + "." + i : "" + i);
1392                     if (l == 0) result[prop] = [];
1393                 }
1394             } else {
1395                 var isEmpty = true;
1396                 for (var p in cur) {
1397                     isEmpty = false;
1398                     recurse(cur[p], prop ? prop + "." + p : p);
1399                 }
1400                 if (isEmpty) result[prop] = {};
1401             }
1402         }
1403         recurse(json, "");
1404         return result;
1405 
1406     }
1407 
1408     _json.unflatten = function (data) {
1409 
1410         if (Object(data) !== data || Array.isArray(data))
1411             return data;
1412         var result = {}, cur, prop, idx, last, temp;
1413         for (var p in data) {
1414             cur = result, prop = "", last = 0;
1415             do {
1416                 idx = p.indexOf(".", last);
1417                 temp = p.substring(last, idx !== -1 ? idx : undefined);
1418                 cur = cur[prop] || (cur[prop] = (!isNaN(parseInt(temp)) ? [] : {}));
1419                 prop = temp;
1420                 last = idx + 1;
1421             } while (idx >= 0);
1422             cur[prop] = data[p];
1423         }
1424         return result[""];
1425 
1426     }
1427 
1428     _json.prettyprint = function (json) {
1429 
1430         return JSON.stringify(json, undefined, 2);
1431 
1432     }
1433 
1434     //////////////////////////////////////////
1435     // wQuery (mini replacement for jQuery) //
1436     //////////////////////////////////////////
1437 
1438     var wQuery = function () { };
1439     wQuery.constructor = wQuery;
1440 
1441     wQuery.prototype.dom = function (selector, createOptions) {
1442 
1443         var self = this,
1444                 elements = [];
1445 
1446         if (createOptions) {
1447             var element = document.createElement(selector);
1448             for (var k in createOptions) {
1449                 element[k] = createOptions[k];
1450             }
1451         } else {
1452             if (_w.isString(selector)) {
1453                 elements = [].slice.call(document.querySelectorAll(selector));
1454             } else {
1455                 if (_w.isObject(selector) && selector.attributes) { elements = [selector]; }
1456             }
1457             self._elements = elements;
1458             self.length = elements.length;
1459             return self;
1460         }
1461 
1462     }
1463 
1464     wQuery.prototype.on = function (events, fn) {
1465 
1466         var self = this,
1467                 elements = self._elements;
1468         events = events.split(" ");
1469         for (var i = 0, lenEl = elements.length; i < lenEl; i++) {
1470             var element = elements[i];
1471             for (var j = 0, lenEv = events.length; j < lenEv; j++) {
1472                 if (element.addEventListener) { element.addEventListener(events[j], fn, false); }
1473             }
1474         }
1475 
1476     }
1477 
1478     wQuery.prototype.find = function (selector) {
1479 
1480         var self = this,
1481                 element = self.get(0),
1482                 elements = [];
1483 
1484         if (_w.isString(selector)) {
1485             elements = [].slice.call(element.querySelectorAll(selector));
1486         }
1487         self._elements = elements;
1488         return self;
1489 
1490     }
1491 
1492     wQuery.prototype.get = function (index, chain) {
1493 
1494         var self = this,
1495                 elements = self._elements || [],
1496                 element = elements[index] || {};
1497 
1498         if (chain) {
1499             self._element = element;
1500             return self;
1501         } else {
1502             return _w.isNumber(index) ? element : elements;
1503         }
1504 
1505     }
1506 
1507     wQuery.prototype.reverse = function () {
1508         this._elements = this._elements.reverse();
1509         return this;
1510     }
1511 
1512     wQuery.prototype.val = function (value) {
1513         return this.prop("value", value);
1514     }
1515 
1516     wQuery.prototype.type = function (value) {
1517         return this.prop("type", value);
1518     }
1519 
1520     wQuery.prototype.html = function (value) {
1521         return this.prop("innerHTML", value);
1522     }
1523 
1524     wQuery.prototype.text = function (value) {
1525         return this.prop("innerHTML", escapeHTML(value));
1526     }
1527 
1528     wQuery.prototype.prop = function (prop, value) {
1529 
1530         var self = this,
1531                 elements = self._elements;
1532 
1533         for (var i in elements) {
1534             if (_w.isUndefined(value)) {
1535                 return elements[i][prop];
1536             } else {
1537                 elements[i][prop] = value;
1538             }
1539         }
1540 
1541     }
1542 
1543     wQuery.prototype.attr = function (attr, value) {
1544 
1545         var self = this,
1546                 elements = self._elements;
1547         for (var i in elements) {
1548             if (value === undefined) {
1549                 return elements[i].getAttribute(attr);
1550             } else {
1551                 elements[i].setAttribute(attr, value);
1552             }
1553         }
1554         return self;
1555 
1556     }
1557 
1558     wQuery.prototype.removeAttr = function (attr) {
1559         var self = this;
1560         for (var i in self._elements) self._elements[i].removeAttribute(attr);
1561         return self;
1562     }
1563 
1564     wQuery.prototype.addClass = function (c) {
1565         var self = this;
1566         for (var i in self._elements) self._elements[i].classList.add(c);
1567         return self;
1568     }
1569 
1570     wQuery.prototype.removeClass = function (c) {
1571         var self = this;
1572         for (var i in self._elements) self._elements[i].classList.remove(c);
1573         return self;
1574     }
1575 
1576     wQuery.prototype.parents = function (selector) {
1577         var self = this,
1578                 element = self.get(0),
1579                 parent = element.parentNode,
1580                 parents = [];
1581 
1582         while (parent !== null) {
1583             var o = parent,
1584                     matches = matchesSelector(o, selector),
1585                     isNotDomRoot = (o.doctype === undefined) ? true : false;
1586             if (!selector) { matches = true; }
1587             if (matches && isNotDomRoot) { parents.push(o); }
1588             parent = o.parentNode;
1589         }
1590         self._elements = parents;
1591         return self;
1592     }
1593 
1594     wQuery.prototype.parent = function (selector) {
1595         var self = this,
1596                 element = self.get(0),
1597                 o = element.parentNode,
1598                 matches = matchesSelector(o, selector);
1599         if (!selector) { matches = true; }
1600         return matches ? o : {};
1601     }
1602 
1603     wQuery.prototype.clone = function (chain) {
1604         var self = this,
1605                 element = self.get(0),
1606                 clone = element.cloneNode(true);
1607         self._elements = [clone];
1608         return chain ? self : clone;
1609     }
1610 
1611     wQuery.prototype.empty = function (chain) {
1612         var self = this,
1613                 element = self.get(0);
1614         if (!element || !element.hasChildNodes) { return chain ? self : element; }
1615 
1616         while (element.hasChildNodes()) {
1617             element.removeChild(element.lastChild);
1618         }
1619         return chain ? self : element;
1620     }
1621 
1622     wQuery.prototype.replaceWith = function (newDOM) {
1623         var self = this,
1624                 oldDOM = self.get(0),
1625                 parent = oldDOM.parentNode;
1626         parent.replaceChild(newDOM, oldDOM);
1627     }
1628 
1629     wQuery.prototype.ready = function (callback) {
1630 
1631         if (document && _w.isFunction(document.addEventListener)) {
1632             document.addEventListener("DOMContentLoaded", callback, false);
1633         } else if (window && _w.isFunction(window.addEventListener)) {
1634             window.addEventListener("load", callback, false);
1635         } else {
1636             document.onreadystatechange = function () {
1637                 if (document.readyState === "complete") { callback(); }
1638             }
1639         }
1640 
1641     }
1642 
1643     //////////////////////
1644     // WATCH DOM EVENTS //
1645     //////////////////////
1646 
1647     way = new WAY();
1648 
1649     var timeoutInput = null;
1650     var eventInputChange = function (e) {
1651         if (timeoutInput) { clearTimeout(timeoutInput); }
1652         timeoutInput = setTimeout(function () {
1653             var element = w.dom(e.target).get(0);
1654             way.dom(element).toStorage();
1655         }, way.options.timeout);
1656     }
1657 
1658     var eventClear = function (e) {
1659         e.preventDefault();
1660         var options = way.dom(this).getOptions();
1661         way.remove(options.data, options);
1662     }
1663 
1664     var eventPush = function (e) {
1665         e.preventDefault();
1666         var options = way.dom(this).getOptions();
1667         if (!options || !options["action-push"]) { return false; }
1668         var split = options["action-push"].split(":"),
1669                 selector = split[0] || null,
1670                 value = split[1] || null;
1671         way.push(selector, value, options);
1672     }
1673 
1674     var eventRemove = function (e) {
1675         e.preventDefault();
1676         var options = way.dom(this).getOptions();
1677         if (!options || !options["action-remove"]) { return false; }
1678         way.remove(options["action-remove"], options);
1679     }
1680 
1681     var timeoutDOM = null;
1682     var eventDOMChange = function () {
1683 
1684         // We need to register dynamically added bindings so we do it by watching DOM changes
1685         // We use a timeout since "DOMSubtreeModified" gets triggered on every change in the DOM (even input value changes)
1686         // so we can limit the number of scans when a user is typing something
1687         if (timeoutDOM) { clearTimeout(timeoutDOM); }
1688         timeoutDOM = setTimeout(function () {
1689             way.registerDependencies();
1690             setEventListeners();
1691         }, way.options.timeoutDOM);
1692 
1693     }
1694 
1695     //////////////
1696     // INITIATE //
1697     //////////////
1698 
1699     w = new wQuery();
1700     way.w = w;
1701 
1702     var setEventListeners = function () {
1703 
1704         w.dom("body").on("DOMSubtreeModified", eventDOMChange);
1705         w.dom("[" + tagPrefix + "-data]").on("input change", eventInputChange);
1706         w.dom("[" + tagPrefix + "-clear]").on("click", eventClear);
1707         w.dom("[" + tagPrefix + "-action-remove]").on("click", eventRemove);
1708         w.dom("[" + tagPrefix + "-action-push]").on("click", eventPush);
1709 
1710     }
1711 
1712     var eventInit = function () {
1713 
1714         setEventListeners();
1715         way.restore();
1716         way.setDefaults();
1717         way.registerDependencies();
1718         way.updateDependencies();
1719 
1720     }
1721 
1722     w.ready(eventInit);
1723 
1724     return way;
1725 
1726 }));