phcthemes_web_theme_pack 0.1.0

data/app/assets/javascripts/themes/zoner/jquery-vanillabox/jquery.vanillabox.min.js

@@ -0,0 +1,24 @@
+(function($){/*
+ Vanillabox
+ (C) 2013 cocopon.
+
+ Licensed under the MIT license:
+ http://www.opensource.org/licenses/mit-license.php
+*/
+var d;function h(){}function k(a,b){return void 0!==a?a:b}function l(a){function b(){}b.prototype=m.prototype;a.prototype=new b}function n(a,b){var c=a.length,e;for(e=0;e<c;e++)b.call(this,a[e],e)}function q(a,b){var c=[],e=a.length,f;for(f=0;f<e;f++)c.push(b.call(this,a[f],f));return c}function r(){var a=new $.Deferred;setTimeout(function(){a.resolve()},0);return a.promise()}function s(){return!!navigator.userAgent.match(/(ipod|iphone|ipad)/ig)};function t(){};var u={ra:function(a){return a.a.show()},ba:function(a){return a.a.hide()},qa:function(a){u.Q(a);return a.a.show()},aa:function(a){return a.a.hide()},Q:function(a){var b=a.f,c=b.p(),e=v(a,c);b.a.css({width:c.width,height:c.height});a.a.css({left:e.left,top:e.top});return r()},pa:function(a){return a.a.show()},$:function(a){return a.a.hide()}},w={ra:function(a){return a.a.fadeIn(200)},ba:function(a){return a.a.fadeOut(300)},ta:function(a,b,c,e){var f=a.f.a;f.stop();b=f.animate({width:b.width,height:b.height},
+e);a=a.a;a.stop();c=a.animate({left:c.left,top:c.top},e);return $.when(b,c)},qa:function(a){var b=a.f,c=b.p(),e=v(a,c);b.a.css({width:c.width,height:c.height});a.a.css({left:e.left,top:e.top});return r()},aa:function(){return r()},Q:function(a){var b=a.f.p(),c=v(a,b);return w.ta(a,b,c,300)},pa:function(a){return a.a.fadeIn(200)},$:function(a){return a.a.fadeOut(300)}};var x={none:u,"default":w};function z(){this.c()}d=z.prototype;d.c=function(){var a=$("<div>");a.addClass("vnbx-mask");this.a=a;this.e()};d.b=function(){this.g();this.a=null};d.e=function(){$(window).on("resize",$.proxy(this.H,this));this.a.on("click",$.proxy(this.o,this))};d.g=function(){$(window).off("resize",this.H);this.a.off("click",this.o)};d.B=function(){var a=this.a;a.width("");a.height("");var b=$(window),c=$(document),e=Math.max(c.width(),b.width()),b=Math.max(c.height(),b.height());a.width(e);a.height(b)};d.H=function(){this.B()};
+d.o=function(){$(this).trigger("vnbx_click")};function A(a){a=a||{};this.l=k(a.u,w);this.k=k(a.s,"both");this.c()}d=A.prototype;d.c=function(){var a=$("<div>");a.addClass("vnbx-container");this.a=a;this.e()};d.b=function(){this.g();this.a=null};d.e=function(){};d.g=function(){this.w()};d.S=function(){$(this.d).on("vnbx_complete",$.proxy(this.D,this))};d.w=function(){$(this.d).off("vnbx_complete",this.D)};d.p=function(){var a=this.d,b={width:0,height:0};a&&(b=a.p());return{width:Math.max(b.width,200),height:Math.max(b.height,150)}};
+function B(a){a.ea={width:!0===a.k||"both"===a.k||"horizontal"===a.k?(window.innerWidth||document.documentElement.clientWidth)-100:Number.MAX_VALUE,height:!0===a.k||"both"===a.k||"vertical"===a.k?(window.innerHeight||document.documentElement.clientHeight)-100:Number.MAX_VALUE};a.d&&C(a)}function C(a){var b=a.ea;a.d.W(Math.max(b.width,200),Math.max(b.height,150))}d.B=function(){var a=this.d,b=a.p();a.a.css({marginLeft:-Math.round(b.width/2),marginTop:-Math.round(b.height/2)})};d.D=function(){this.B()};function D(a){a=a||{};this.f=new A({u:a.u,s:a.s});this.c();this.e()}d=D.prototype;d.c=function(){var a=$("<div>");a.addClass("vnbx-frame");this.a=a;this.a.append(this.f.a)};d.b=function(){this.f.b();this.f=null;this.g();this.a=null};d.e=function(){this.a.on("click",$.proxy(this.o,this))};d.g=function(){this.a.off("click",this.o)};
+function v(a,b){var c=a.f.a,e=c.width(),f=c.height();c.width(b.width);c.height(b.height);var g=$(window),p=a.a,y=window.innerWidth||document.documentElement.clientWidth,S=window.innerHeight||document.documentElement.clientHeight,y=Math.round(g.scrollLeft()+(y-p.outerWidth())/2),g=Math.max(Math.round(g.scrollTop()+(S-p.outerHeight())/2),0);c.width(e);c.height(f);return{left:y,top:g}}d.o=function(a){a.stopPropagation()};function m(a){a=a||{};this.sa=this.da=!1;this.oa=a.path;this.Ca=k(a.title,"");this.c()}d=m.prototype;d.c=function(){var a=$("<div>");a.addClass("vnbx-content");this.a=a;this.X();this.e()};d.X=h;d.e=h;d.g=h;d.b=function(){this.g();this.a=null};d.p=function(){var a=this.a;return{width:a.width(),height:a.height()}};d.W=function(a,b){this.a.css({maxWidth:a,maxHeight:b})};d.load=function(){this.a.addClass("vnbx-loading");this.da?E(this,this.sa):this.U()};d.U=h;
+function E(a,b){var c=a.a;a.da=!0;a.sa=b;c.removeClass("vnbx-loading");b||c.addClass("vnbx-error");$(a).trigger("vnbx_complete",b)}function F(a){m.call(this,a)}l(F);F.prototype.c=function(){m.prototype.c.call(this);this.a.addClass("vnbx-empty")};F.prototype.load=function(){var a=this;setTimeout(function(){$(a).trigger("vnbx_complete",!0)},0)};function G(a){m.call(this,a)}l(G);d=G.prototype;d.X=function(){var a=$("<img>");this.a.append(a);this.A=a};d.b=function(){m.prototype.b.call(this);this.A=null};
+d.e=function(){var a=this.A;a.on("load",$.proxy(this.G,this));a.on("error",$.proxy(this.F,this))};d.g=function(){var a=this.A;a.off("load",this.G);a.off("error",this.F)};d.W=function(a,b){this.A.css({maxWidth:a,maxHeight:b})};d.U=function(){this.A.attr("src",this.oa)};d.G=function(){E(this,!0)};d.F=function(){E(this,!1)};function H(a){a=a||{};this.ya=a.J;this.xa=a.I;m.call(this,a)}l(H);d=H.prototype;d.X=function(){var a=$("<iframe>");a.attr("frameborder",0);this.a.append(a);this.m=a};
+d.b=function(){m.prototype.b.call(this);this.m=null};d.e=function(){var a=this.m;a.on("load",$.proxy(this.G,this));a.on("error",$.proxy(this.F,this))};d.g=function(){var a=this.m;a.off("load",this.G);a.off("error",this.F)};d.p=function(){var a=s()?this.a:this.m;return{width:a.width(),height:a.height()}};d.W=function(a,b){(s()?this.a:this.m).css({maxWidth:a,maxHeight:b})};d.U=function(){this.m.attr("src",this.oa)};
+d.G=function(){if(this.m.attr("src")){var a=s()?this.a:this.m;a.width(this.ya);a.height(this.xa);E(this,!0)}};d.F=function(){E(this,!1)};var I={image:function(a){return new G({path:a.attr("href"),title:a.attr("title")})},iframe:function(a,b){return new H({path:a.attr("href"),J:b.J,I:b.I,title:a.attr("title")})}};function J(a){a=a||{};this.q=k(a.Da,1);this.t=k(a.loop,!1);K(this,k(a.page,0))}function K(a,b){var c=a.h,e=a.q,e=Math.min(Math.max(b,0),e-1);a.h=e;c!==e&&$(a).trigger("vnbx_change")}J.prototype.next=function(){var a=this.q,b=this.h,c=b+1;c>a-1&&(c=this.t?0:a-1);this.h=c;b!==c&&$(this).trigger("vnbx_change")};J.prototype.L=function(){var a=this.q,b=this.h,c=b-1;0>c&&(c=this.t?a-1:0);this.h=c;b!==c&&$(this).trigger("vnbx_change")};function L(a){this.v=a.r;this.T=k(a.disabled,!1);this.c()}d=L.prototype;d.c=function(){var a=$("<div>");a.addClass("vnbx-button");this.v&&a.addClass(this.v);a.attr("ontouchstart","void(0)");this.a=a;this.e()};d.b=function(){this.a=null};d.e=function(){this.a.on("click",$.proxy(this.o,this))};d.g=function(){this.a.off("click",this.o)};function M(a,b){var c=a.a;a.T=b;a.T?c.addClass("vnbx-disabled"):c.removeClass("vnbx-disabled")}d.o=function(a){a.stopPropagation();this.T||$(this).trigger("vnbx_click")};function N(a){this.v=a.r;this.c()}N.prototype.c=function(){var a=$("<div>");a.addClass("vnbx-label");this.v&&a.addClass(this.v);this.a=a};N.prototype.b=function(){this.a=null};function O(a){if(!a.Y||0===a.Y.length)throw new t;this.R=!1;this.M=a.Y;this.l=k(a.u,w);this.Aa=a.za;this.Ba=a.wa;this.N=a.ua;this.k=a.s;this.va={J:a.J,I:a.I,type:a.type};this.j=new J({loop:a.loop,Da:this.M.length});this.c()}d=O.prototype;
+d.c=function(){var a=this,b=new z,c=b.a;c.addClass("vnbx");c.hide();$("body").append(c);a.n=b;P(a);var e=new D({u:a.l,s:a.k}),b=e.a;a.i=e;c.append(b);c=new N({r:"vnbx-title"});a.Z=c;b.append(c.a);c=new N({r:"vnbx-pager"});a.V=c;b.append(c.a);c=new L({r:"vnbx-prev"});a.K=c;b.append(c.a);c=new L({r:"vnbx-next"});a.C=c;b.append(c.a);c=new L({r:"vnbx-close"});a.N||c.a.hide();a.O=c;b.append(c.a);a.e();b=q(a.M,function(b){b=$(b);var c=a.va,e=I[c.type];if(!e)throw new t;return e(b,c)});a.P=b;b=new F;Q(a,
+b)};function P(a){var b=a.n.a;s()&&b.addClass("vnbx-ios");a.N&&b.addClass("vnbx-close-button-enabled");1<a.j.q&&b.addClass("vnbx-group")}d.b=function(){R(this);this.g();n(this.P,function(a){a.b()});this.P=null;this.Z.b();this.Z=null;this.V.b();this.V=null;this.O.b();this.O=null;this.K.b();this.K=null;this.C.b();this.C=null;this.i.b();this.i=null;this.n.a.remove();this.n.b();this.n=null};
+d.e=function(){this.M.on("click",$.proxy(this.ma,this));$(this.n).on("vnbx_click",$.proxy(this.ia,this));$(this.j).on("vnbx_change",$.proxy(this.ka,this));$(this.O).on("vnbx_click",$.proxy(this.fa,this));$(this.K).on("vnbx_click",$.proxy(this.la,this));$(this.C).on("vnbx_click",$.proxy(this.ja,this))};
+d.g=function(){this.M.off("click",this.ma);$(this.n).off("vnbx_click",this.ia);$(this.j).off("vnbx_change",this.ka);$(this.O).off("vnbx_click",this.fa);$(this.K).off("vnbx_click",this.la);$(this.C).off("vnbx_click",this.ja);this.w();this.d=null};function T(a){var b=$(window),c=$(document);b.on("resize",$.proxy(a.H,a));b.on("scroll",$.proxy(a.na,a));c.on("keyup",$.proxy(a.ha,a))}function R(a){var b=$(window),c=$(document);b.off("resize",a.H,a);b.off("scroll",a.na,a);c.off("keyup",a.ha,a)}
+d.S=function(){var a=this.i.f.d,b=a.a;$(a).on("vnbx_complete",$.proxy(this.D,this));b.on("click",$.proxy(this.ga,this))};d.w=function(){var a=this.i.f.d,b=a.a;$(a).off("complete",this.D);b.off("click",this.ga)};d.show=function(a){var b=this,c=b.l;if(b.R)return r();b.R=!0;T(b);B(b.i.f);var e=b.n;e.B();var e=c.ra(e),c=c.qa(b.i),f=b.j;a=k(a,0);var g=a!==f.h;K(f,a);g||U(b);return $.when(e,c).then(function(){$(b).trigger("vnbx_show")})};
+d.hide=function(){var a=this;return a.R?$.when(a.l.aa(a.i),a.l.ba(a.n)).then(function(){R(a);a.R=!1;$(a).trigger("vnbx_hide")}):r()};d.L=function(){this.j.L()};d.next=function(){this.j.next()};function Q(a,b){var c=a.i.f,e=a.i.f.d;if(e!==b){e&&a.w();e=c.l;c.d&&(c.w(),e.$(c.d));c.d=b;c.S();c.ea&&C(c);var f=c.a,g=c.d.a,p=f.find("> *");0===p.length?f.append(g):g.insertBefore(p.first());e.pa(c.d);a.S();a.Z.a.text(b.Ca);b.load()}c.B()}
+function U(a){var b=a.j;a.V.a.text(String(b.h+1)+" of "+String(b.q));M(a.K,!(b.t||0<b.h));M(a.C,!(b.t||b.h<b.q-1));Q(a,a.P[a.j.h])}function V(a){a.ca&&clearTimeout(a.ca);a.ca=setTimeout(function(){a.Aa&&a.l.Q(a.i)},300)}d.H=function(){V(this)};d.na=function(){V(this)};d.ha=function(a){if(this.Ba)switch(a.keyCode){case 27:this.hide();break;case 37:this.L();break;case 39:this.next()}};d.ma=function(a){var b=this.M.index(a.delegateTarget);0>b||(a.preventDefault(),this.show(b))};d.ka=function(){U(this)};
+d.ia=function(){this.N||this.hide()};d.fa=function(){this.N&&this.hide()};d.la=function(){this.L()};d.ja=function(){this.next()};d.D=function(a,b){this.l.Q(this.i);var c=a.target,e;a:{e=this.P;var f=e.length,g;for(g=0;g<f;g++)if(e[g]===c){e=g;break a}e=-1}0<=e&&$(this).trigger("vnbx_load",[b,c,e])};d.ga=function(a){var b=this.j;a.stopPropagation();b.t||b.h<b.q-1?this.next():this.hide()};var W={animation:"default",closeButton:!1,adjustToWindow:"both",keyboard:!0,loop:!1,preferredHeight:600,preferredWidth:800,repositionOnScroll:!1,type:"image"};$.fn.Ea=function(a){var b={};$.extend(b,W);$.extend(b,a);a=$(this);return new O({u:x[b.animation]||w,ua:b.closeButton,s:b.adjustToWindow,wa:b.keyboard,loop:b.loop,I:b.preferredHeight,J:b.preferredWidth,za:b.repositionOnScroll,Y:a,type:b.type})};$.fn.vanillabox=$.fn.Ea;O.prototype.dispose=O.prototype.b;O.prototype.hide=O.prototype.hide;O.prototype.next=O.prototype.next;O.prototype.previous=O.prototype.L;O.prototype.show=O.prototype.show;})(jQuery);

data/app/assets/javascripts/themes/zoner/jshashtable/hashtable.js

@@ -0,0 +1,402 @@
+/**
+ * @license jahashtable, a JavaScript implementation of a hash table. It creates a single constructor function called
+ * Hashtable in the global scope.
+ *
+ * http://www.timdown.co.uk/jshashtable/
+ * Copyright 2013 Tim Down.
+ * Version: 3.0
+ * Build date: 17 July 2013
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var Hashtable = (function(UNDEFINED) {
+    var FUNCTION = "function", STRING = "string", UNDEF = "undefined";
+
+    // Require Array.prototype.splice, Object.prototype.hasOwnProperty and encodeURIComponent. In environments not
+    // having these (e.g. IE <= 5), we bail out now and leave Hashtable null.
+    if (typeof encodeURIComponent == UNDEF ||
+            Array.prototype.splice === UNDEFINED ||
+            Object.prototype.hasOwnProperty === UNDEFINED) {
+        return null;
+    }
+
+    function toStr(obj) {
+        return (typeof obj == STRING) ? obj : "" + obj;
+    }
+
+    function hashObject(obj) {
+        var hashCode;
+        if (typeof obj == STRING) {
+            return obj;
+        } else if (typeof obj.hashCode == FUNCTION) {
+            // Check the hashCode method really has returned a string
+            hashCode = obj.hashCode();
+            return (typeof hashCode == STRING) ? hashCode : hashObject(hashCode);
+        } else {
+            return toStr(obj);
+        }
+    }
+    
+    function merge(o1, o2) {
+        for (var i in o2) {
+            if (o2.hasOwnProperty(i)) {
+                o1[i] = o2[i];
+            }
+        }
+    }
+
+    function equals_fixedValueHasEquals(fixedValue, variableValue) {
+        return fixedValue.equals(variableValue);
+    }
+
+    function equals_fixedValueNoEquals(fixedValue, variableValue) {
+        return (typeof variableValue.equals == FUNCTION) ?
+            variableValue.equals(fixedValue) : (fixedValue === variableValue);
+    }
+
+    function createKeyValCheck(kvStr) {
+        return function(kv) {
+            if (kv === null) {
+                throw new Error("null is not a valid " + kvStr);
+            } else if (kv === UNDEFINED) {
+                throw new Error(kvStr + " must not be undefined");
+            }
+        };
+    }
+
+    var checkKey = createKeyValCheck("key"), checkValue = createKeyValCheck("value");
+
+    /*----------------------------------------------------------------------------------------------------------------*/
+
+    function Bucket(hash, firstKey, firstValue, equalityFunction) {
+        this[0] = hash;
+        this.entries = [];
+        this.addEntry(firstKey, firstValue);
+
+        if (equalityFunction !== null) {
+            this.getEqualityFunction = function() {
+                return equalityFunction;
+            };
+        }
+    }
+
+    var EXISTENCE = 0, ENTRY = 1, ENTRY_INDEX_AND_VALUE = 2;
+
+    function createBucketSearcher(mode) {
+        return function(key) {
+            var i = this.entries.length, entry, equals = this.getEqualityFunction(key);
+            while (i--) {
+                entry = this.entries[i];
+                if ( equals(key, entry[0]) ) {
+                    switch (mode) {
+                        case EXISTENCE:
+                            return true;
+                        case ENTRY:
+                            return entry;
+                        case ENTRY_INDEX_AND_VALUE:
+                            return [ i, entry[1] ];
+                    }
+                }
+            }
+            return false;
+        };
+    }
+
+    function createBucketLister(entryProperty) {
+        return function(aggregatedArr) {
+            var startIndex = aggregatedArr.length;
+            for (var i = 0, entries = this.entries, len = entries.length; i < len; ++i) {
+                aggregatedArr[startIndex + i] = entries[i][entryProperty];
+            }
+        };
+    }
+
+    Bucket.prototype = {
+        getEqualityFunction: function(searchValue) {
+            return (typeof searchValue.equals == FUNCTION) ? equals_fixedValueHasEquals : equals_fixedValueNoEquals;
+        },
+
+        getEntryForKey: createBucketSearcher(ENTRY),
+
+        getEntryAndIndexForKey: createBucketSearcher(ENTRY_INDEX_AND_VALUE),
+
+        removeEntryForKey: function(key) {
+            var result = this.getEntryAndIndexForKey(key);
+            if (result) {
+                this.entries.splice(result[0], 1);
+                return result[1];
+            }
+            return null;
+        },
+
+        addEntry: function(key, value) {
+            this.entries.push( [key, value] );
+        },
+
+        keys: createBucketLister(0),
+
+        values: createBucketLister(1),
+
+        getEntries: function(destEntries) {
+            var startIndex = destEntries.length;
+            for (var i = 0, entries = this.entries, len = entries.length; i < len; ++i) {
+                // Clone the entry stored in the bucket before adding to array
+                destEntries[startIndex + i] = entries[i].slice(0);
+            }
+        },
+
+        containsKey: createBucketSearcher(EXISTENCE),
+
+        containsValue: function(value) {
+            var entries = this.entries, i = entries.length;
+            while (i--) {
+                if ( value === entries[i][1] ) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    };
+
+    /*----------------------------------------------------------------------------------------------------------------*/
+
+    // Supporting functions for searching hashtable buckets
+
+    function searchBuckets(buckets, hash) {
+        var i = buckets.length, bucket;
+        while (i--) {
+            bucket = buckets[i];
+            if (hash === bucket[0]) {
+                return i;
+            }
+        }
+        return null;
+    }
+
+    function getBucketForHash(bucketsByHash, hash) {
+        var bucket = bucketsByHash[hash];
+
+        // Check that this is a genuine bucket and not something inherited from the bucketsByHash's prototype
+        return ( bucket && (bucket instanceof Bucket) ) ? bucket : null;
+    }
+
+    /*----------------------------------------------------------------------------------------------------------------*/
+
+    function Hashtable() {
+        var buckets = [];
+        var bucketsByHash = {};
+        var properties = {
+            replaceDuplicateKey: true,
+            hashCode: hashObject,
+            equals: null
+        };
+
+        var arg0 = arguments[0], arg1 = arguments[1];
+        if (arg1 !== UNDEFINED) {
+            properties.hashCode = arg0;
+            properties.equals = arg1;
+        } else if (arg0 !== UNDEFINED) {
+            merge(properties, arg0);
+        }
+
+        var hashCode = properties.hashCode, equals = properties.equals;
+
+        this.properties = properties;
+
+        this.put = function(key, value) {
+            checkKey(key);
+            checkValue(value);
+            var hash = hashCode(key), bucket, bucketEntry, oldValue = null;
+
+            // Check if a bucket exists for the bucket key
+            bucket = getBucketForHash(bucketsByHash, hash);
+            if (bucket) {
+                // Check this bucket to see if it already contains this key
+                bucketEntry = bucket.getEntryForKey(key);
+                if (bucketEntry) {
+                    // This bucket entry is the current mapping of key to value, so replace the old value.
+                    // Also, we optionally replace the key so that the latest key is stored.
+                    if (properties.replaceDuplicateKey) {
+                        bucketEntry[0] = key;
+                    }
+                    oldValue = bucketEntry[1];
+                    bucketEntry[1] = value;
+                } else {
+                    // The bucket does not contain an entry for this key, so add one
+                    bucket.addEntry(key, value);
+                }
+            } else {
+                // No bucket exists for the key, so create one and put our key/value mapping in
+                bucket = new Bucket(hash, key, value, equals);
+                buckets.push(bucket);
+                bucketsByHash[hash] = bucket;
+            }
+            return oldValue;
+        };
+
+        this.get = function(key) {
+            checkKey(key);
+
+            var hash = hashCode(key);
+
+            // Check if a bucket exists for the bucket key
+            var bucket = getBucketForHash(bucketsByHash, hash);
+            if (bucket) {
+                // Check this bucket to see if it contains this key
+                var bucketEntry = bucket.getEntryForKey(key);
+                if (bucketEntry) {
+                    // This bucket entry is the current mapping of key to value, so return the value.
+                    return bucketEntry[1];
+                }
+            }
+            return null;
+        };
+
+        this.containsKey = function(key) {
+            checkKey(key);
+            var bucketKey = hashCode(key);
+
+            // Check if a bucket exists for the bucket key
+            var bucket = getBucketForHash(bucketsByHash, bucketKey);
+
+            return bucket ? bucket.containsKey(key) : false;
+        };
+
+        this.containsValue = function(value) {
+            checkValue(value);
+            var i = buckets.length;
+            while (i--) {
+                if (buckets[i].containsValue(value)) {
+                    return true;
+                }
+            }
+            return false;
+        };
+
+        this.clear = function() {
+            buckets.length = 0;
+            bucketsByHash = {};
+        };
+
+        this.isEmpty = function() {
+            return !buckets.length;
+        };
+
+        var createBucketAggregator = function(bucketFuncName) {
+            return function() {
+                var aggregated = [], i = buckets.length;
+                while (i--) {
+                    buckets[i][bucketFuncName](aggregated);
+                }
+                return aggregated;
+            };
+        };
+
+        this.keys = createBucketAggregator("keys");
+        this.values = createBucketAggregator("values");
+        this.entries = createBucketAggregator("getEntries");
+
+        this.remove = function(key) {
+            checkKey(key);
+
+            var hash = hashCode(key), bucketIndex, oldValue = null;
+
+            // Check if a bucket exists for the bucket key
+            var bucket = getBucketForHash(bucketsByHash, hash);
+
+            if (bucket) {
+                // Remove entry from this bucket for this key
+                oldValue = bucket.removeEntryForKey(key);
+                if (oldValue !== null) {
+                    // Entry was removed, so check if bucket is empty
+                    if (bucket.entries.length == 0) {
+                        // Bucket is empty, so remove it from the bucket collections
+                        bucketIndex = searchBuckets(buckets, hash);
+                        buckets.splice(bucketIndex, 1);
+                        delete bucketsByHash[hash];
+                    }
+                }
+            }
+            return oldValue;
+        };
+
+        this.size = function() {
+            var total = 0, i = buckets.length;
+            while (i--) {
+                total += buckets[i].entries.length;
+            }
+            return total;
+        };
+    }
+
+    Hashtable.prototype = {
+        each: function(callback) {
+            var entries = this.entries(), i = entries.length, entry;
+            while (i--) {
+                entry = entries[i];
+                callback(entry[0], entry[1]);
+            }
+        },
+
+        equals: function(hashtable) {
+            var keys, key, val, count = this.size();
+            if (count == hashtable.size()) {
+                keys = this.keys();
+                while (count--) {
+                    key = keys[count];
+                    val = hashtable.get(key);
+                    if (val === null || val !== this.get(key)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return false;
+        },
+
+        putAll: function(hashtable, conflictCallback) {
+            var entries = hashtable.entries();
+            var entry, key, value, thisValue, i = entries.length;
+            var hasConflictCallback = (typeof conflictCallback == FUNCTION);
+            while (i--) {
+                entry = entries[i];
+                key = entry[0];
+                value = entry[1];
+
+                // Check for a conflict. The default behaviour is to overwrite the value for an existing key
+                if ( hasConflictCallback && (thisValue = this.get(key)) ) {
+                    value = conflictCallback(key, thisValue, value);
+                }
+                this.put(key, value);
+            }
+        },
+
+        clone: function() {
+            var clone = new Hashtable(this.properties);
+            clone.putAll(this);
+            return clone;
+        }
+    };
+
+    Hashtable.prototype.toQueryString = function() {
+        var entries = this.entries(), i = entries.length, entry;
+        var parts = [];
+        while (i--) {
+            entry = entries[i];
+            parts[i] = encodeURIComponent( toStr(entry[0]) ) + "=" + encodeURIComponent( toStr(entry[1]) );
+        }
+        return parts.join("&");
+    };
+
+    return Hashtable;
+})();

data/app/assets/javascripts/themes/zoner/numberformatter/numberformatter.js

@@ -0,0 +1,566 @@
+/**
+ * jquery.numberformatter - Formatting/Parsing Numbers in jQuery
+ * 
+ * Written by
+ * Michael Abernethy (mike@abernethysoft.com),
+ * Andrew Parry (aparry0@gmail.com)
+ *
+ * Dual licensed under the MIT (MIT-LICENSE.txt)
+ * and GPL (GPL-LICENSE.txt) licenses.
+ *
+ * @author Michael Abernethy, Andrew Parry
+ * @version 1.2.4-RELEASE ($Id$)
+ * 
+ * Dependencies
+ * 
+ * jQuery (http://jquery.com)
+ * jshashtable (http://www.timdown.co.uk/jshashtable)
+ * 
+ * Notes & Thanks
+ * 
+ * many thanks to advweb.nanasi.jp for his bug fixes
+ * jsHashtable is now used also, so thanks to the author for that excellent little class.
+ *
+ * This plugin can be used to format numbers as text and parse text as Numbers
+ * Because we live in an international world, we cannot assume that everyone
+ * uses "," to divide thousands, and "." as a decimal point.
+ *
+ * As of 1.2 the way this plugin works has changed slightly, parsing text to a number
+ * has 1 set of functions, formatting a number to text has it's own. Before things
+ * were a little confusing, so I wanted to separate the 2 out more.
+ *
+ *
+ * jQuery extension functions:
+ *
+ * formatNumber(options, writeBack, giveReturnValue) - Reads the value from the subject, parses to
+ * a Javascript Number object, then formats back to text using the passed options and write back to
+ * the subject.
+ * 
+ * parseNumber(options) - Parses the value in the subject to a Number object using the passed options
+ * to decipher the actual number from the text, then writes the value as text back to the subject.
+ * 
+ * 
+ * Generic functions:
+ * 
+ * formatNumber(numberString, options) - Takes a plain number as a string (e.g. '1002.0123') and returns
+ * a string of the given format options.
+ * 
+ * parseNumber(numberString, options) - Takes a number as text that is formatted the same as the given
+ * options then and returns it as a plain Number object.
+ * 
+ * To achieve the old way of combining parsing and formatting to keep say a input field always formatted
+ * to a given format after it has lost focus you'd simply use a combination of the functions.
+ * 
+ * e.g.
+ * $("#salary").blur(function(){
+ *      $(this).parseNumber({format:"#,###.00", locale:"us"});
+ *      $(this).formatNumber({format:"#,###.00", locale:"us"});
+ * });
+ *
+ * The syntax for the formatting is:
+ * 0 = Digit
+ * # = Digit, zero shows as absent
+ * . = Decimal separator
+ * - = Negative sign
+ * , = Grouping Separator
+ * % = Percent (multiplies the number by 100)
+ * 
+ * For example, a format of "#,###.00" and text of 4500.20 will
+ * display as "4.500,20" with a locale of "de", and "4,500.20" with a locale of "us"
+ *
+ *
+ * As of now, the only acceptable locales are 
+ * Arab Emirates -> "ae"
+ * Australia -> "au"
+ * Austria -> "at"
+ * Brazil -> "br"
+ * Canada -> "ca"
+ * China -> "cn"
+ * Czech -> "cz"
+ * Denmark -> "dk"
+ * Egypt -> "eg"
+ * Finland -> "fi"
+ * France  -> "fr"
+ * Germany -> "de"
+ * Greece -> "gr"
+ * Great Britain -> "gb"
+ * Hong Kong -> "hk"
+ * India -> "in"
+ * Israel -> "il"
+ * Japan -> "jp"
+ * Russia -> "ru"
+ * South Korea -> "kr"
+ * Spain -> "es"
+ * Sweden -> "se"
+ * Switzerland -> "ch"
+ * Taiwan -> "tw"
+ * Thailand -> "th"
+ * United States -> "us"
+ * Vietnam -> "vn"
+ **/
+
+(function(jQuery) {
+
+    var nfLocales = new Hashtable();
+    
+    var nfLocalesLikeUS = [ 'ae','au','ca','cn','eg','gb','hk','il','in','jp','sk','th','tw','us' ];
+    var nfLocalesLikeDE = [ 'at','br','de','dk','es','gr','it','nl','pt','tr','vn' ];
+    var nfLocalesLikeFR = [ 'bg','cz','fi','fr','no','pl','ru','se' ];
+    var nfLocalesLikeCH = [ 'ch' ];
+    
+    var nfLocaleFormatting = [ [".", ","], [",", "."], [",", " "], [".", "'"] ]; 
+    var nfAllLocales = [ nfLocalesLikeUS, nfLocalesLikeDE, nfLocalesLikeFR, nfLocalesLikeCH ]
+
+    function FormatData(dec, group, neg) {
+        this.dec = dec;
+        this.group = group;
+        this.neg = neg;
+    };
+
+    function init() {
+        // write the arrays into the hashtable
+        for (var localeGroupIdx = 0; localeGroupIdx < nfAllLocales.length; localeGroupIdx++) {
+            var localeGroup = nfAllLocales[localeGroupIdx];
+            for (var i = 0; i < localeGroup.length; i++) {
+                nfLocales.put(localeGroup[i], localeGroupIdx);
+            }
+        }
+    };
+
+    function formatCodes(locale, isFullLocale) {
+        if (nfLocales.size() == 0)
+            init();
+
+         // default values
+         var dec = ".";
+         var group = ",";
+         var neg = "-";
+         
+         if (isFullLocale == false) {
+             // Extract and convert to lower-case any language code from a real 'locale' formatted string, if not use as-is
+             // (To prevent locale format like : "fr_FR", "en_US", "de_DE", "fr_FR", "en-US", "de-DE")
+             if (locale.indexOf('_') != -1)
+                locale = locale.split('_')[1].toLowerCase();
+             else if (locale.indexOf('-') != -1)
+                locale = locale.split('-')[1].toLowerCase();
+        }
+
+         // hashtable lookup to match locale with codes
+         var codesIndex = nfLocales.get(locale);
+         if (codesIndex) {
+            var codes = nfLocaleFormatting[codesIndex];
+            if (codes) {
+                dec = codes[0];
+                group = codes[1];
+            }
+         }
+         return new FormatData(dec, group, neg);
+    };
+    
+    
+    /*  Formatting Methods  */
+    
+    
+    /**
+     * Formats anything containing a number in standard js number notation.
+     * 
+     * @param {Object}  options         The formatting options to use
+     * @param {Boolean} writeBack       (true) If the output value should be written back to the subject
+     * @param {Boolean} giveReturnValue (true) If the function should return the output string
+     */
+    jQuery.fn.formatNumber = function(options, writeBack, giveReturnValue) {
+    
+        return this.each(function() {
+            // enforce defaults
+            if (writeBack == null)
+                writeBack = true;
+            if (giveReturnValue == null)
+                giveReturnValue = true;
+            
+            // get text
+            var text;
+            if (jQuery(this).is(":input"))
+                text = new String(jQuery(this).val());
+            else
+                text = new String(jQuery(this).text());
+
+            // format
+            var returnString = jQuery.formatNumber(text, options);
+        
+            // set formatted string back, only if a success
+//          if (returnString) {
+                if (writeBack) {
+                    if (jQuery(this).is(":input"))
+                        jQuery(this).val(returnString);
+                    else
+                        jQuery(this).text(returnString);
+                }
+                if (giveReturnValue)
+                    return returnString;
+//          }
+//          return '';
+        });
+    };
+    
+    /**
+     * First parses a string and reformats it with the given options.
+     * 
+     * @param {Object} numberString
+     * @param {Object} options
+     */
+    jQuery.formatNumber = function(numberString, options){
+        var options = jQuery.extend({}, jQuery.fn.formatNumber.defaults, options);
+        var formatData = formatCodes(options.locale.toLowerCase(), options.isFullLocale);
+        
+        var dec = formatData.dec;
+        var group = formatData.group;
+        var neg = formatData.neg;
+        
+        var validFormat = "0#-,.";
+        
+        // strip all the invalid characters at the beginning and the end
+        // of the format, and we'll stick them back on at the end
+        // make a special case for the negative sign "-" though, so 
+        // we can have formats like -$23.32
+        var prefix = "";
+        var negativeInFront = false;
+        for (var i = 0; i < options.format.length; i++) {
+            if (validFormat.indexOf(options.format.charAt(i)) == -1) 
+                prefix = prefix + options.format.charAt(i);
+            else 
+                if (i == 0 && options.format.charAt(i) == '-') {
+                    negativeInFront = true;
+                    continue;
+                }
+                else 
+                    break;
+        }
+        var suffix = "";
+        for (var i = options.format.length - 1; i >= 0; i--) {
+            if (validFormat.indexOf(options.format.charAt(i)) == -1) 
+                suffix = options.format.charAt(i) + suffix;
+            else 
+                break;
+        }
+        
+        options.format = options.format.substring(prefix.length);
+        options.format = options.format.substring(0, options.format.length - suffix.length);
+        
+        // now we need to convert it into a number
+        //while (numberString.indexOf(group) > -1) 
+        //  numberString = numberString.replace(group, '');
+        //var number = new Number(numberString.replace(dec, ".").replace(neg, "-"));
+        var number = new Number(numberString);
+        
+        return jQuery._formatNumber(number, options, suffix, prefix, negativeInFront);
+    };
+    
+    /**
+     * Formats a Number object into a string, using the given formatting options
+     * 
+     * @param {Object} numberString
+     * @param {Object} options
+     */
+    jQuery._formatNumber = function(number, options, suffix, prefix, negativeInFront) {
+        var options = jQuery.extend({}, jQuery.fn.formatNumber.defaults, options);
+        var formatData = formatCodes(options.locale.toLowerCase(), options.isFullLocale);
+        
+        var dec = formatData.dec;
+        var group = formatData.group;
+        var neg = formatData.neg;
+
+        // check overrides
+        if (options.overrideGroupSep != null) {
+            group = options.overrideGroupSep;
+        }
+        if (options.overrideDecSep != null) {
+            dec = options.overrideDecSep;
+        }
+        if (options.overrideNegSign != null) {
+            neg = options.overrideNegSign;
+        }
+        
+        // Check NAN handling
+        var forcedToZero = false;
+        if (isNaN(number)) {
+            if (options.nanForceZero == true) {
+                number = 0;
+                forcedToZero = true;
+            } else {
+                return '';
+            }
+        }
+
+        // special case for percentages
+        if (options.isPercentage == true || (options.autoDetectPercentage && suffix.charAt(suffix.length - 1) == '%')) {
+            number = number * 100;
+        }
+
+        var returnString = "";
+        if (options.format.indexOf(".") > -1) {
+            var decimalPortion = dec;
+            var decimalFormat = options.format.substring(options.format.lastIndexOf(".") + 1);
+            
+            // round or truncate number as needed
+            if (options.round == true)
+                number = new Number(number.toFixed(decimalFormat.length));
+            else {
+                var numStr = number.toString();
+                if (numStr.lastIndexOf('.') > 0) {
+                    numStr = numStr.substring(0, numStr.lastIndexOf('.') + decimalFormat.length + 1);
+                }
+                number = new Number(numStr);
+            }
+            
+            var decimalValue = new Number(number.toString().substring(number.toString().indexOf('.')));
+            decimalString = new String(decimalValue.toFixed(decimalFormat.length));
+            decimalString = decimalString.substring(decimalString.lastIndexOf('.') + 1);
+            for (var i = 0; i < decimalFormat.length; i++) {
+                if (decimalFormat.charAt(i) == '#' && decimalString.charAt(i) != '0') {
+                    decimalPortion += decimalString.charAt(i);
+                    continue;
+                } else if (decimalFormat.charAt(i) == '#' && decimalString.charAt(i) == '0') {
+                    var notParsed = decimalString.substring(i);
+                    if (notParsed.match('[1-9]')) {
+                        decimalPortion += decimalString.charAt(i);
+                        continue;
+                    } else
+                        break;
+                } else if (decimalFormat.charAt(i) == "0")
+                    decimalPortion += decimalString.charAt(i);
+            }
+            returnString += decimalPortion
+         } else
+            number = Math.round(number);
+
+        var ones = Math.floor(number);
+        if (number < 0)
+            ones = Math.ceil(number);
+
+        var onesFormat = "";
+        if (options.format.indexOf(".") == -1)
+            onesFormat = options.format;
+        else
+            onesFormat = options.format.substring(0, options.format.indexOf("."));
+
+        var onePortion = "";
+        if (!(ones == 0 && onesFormat.substr(onesFormat.length - 1) == '#') || forcedToZero) {
+            // find how many digits are in the group
+            var oneText = new String(Math.abs(ones));
+            var groupLength = 9999;
+            if (onesFormat.lastIndexOf(",") != -1)
+                groupLength = onesFormat.length - onesFormat.lastIndexOf(",") - 1;
+            var groupCount = 0;
+            for (var i = oneText.length - 1; i > -1; i--) {
+                onePortion = oneText.charAt(i) + onePortion;
+                groupCount++;
+                if (groupCount == groupLength && i != 0) {
+                    onePortion = group + onePortion;
+                    groupCount = 0;
+                }
+            }
+            
+            // account for any pre-data padding
+            if (onesFormat.length > onePortion.length) {
+                var padStart = onesFormat.indexOf('0');
+                if (padStart != -1) {
+                    var padLen = onesFormat.length - padStart;
+                    
+                    // pad to left with 0's or group char
+                    var pos = onesFormat.length - onePortion.length - 1;
+                    while (onePortion.length < padLen) {
+                        var padChar = onesFormat.charAt(pos);
+                        // replace with real group char if needed
+                        if (padChar == ',')
+                            padChar = group;
+                        onePortion = padChar + onePortion;
+                        pos--;
+                    }
+                }
+            }
+        }
+        
+        if (!onePortion && onesFormat.indexOf('0', onesFormat.length - 1) !== -1)
+            onePortion = '0';
+
+        returnString = onePortion + returnString;
+
+        // handle special case where negative is in front of the invalid characters
+        if (number < 0 && negativeInFront && prefix.length > 0)
+            prefix = neg + prefix;
+        else if (number < 0)
+            returnString = neg + returnString;
+        
+        if (!options.decimalSeparatorAlwaysShown) {
+            if (returnString.lastIndexOf(dec) == returnString.length - 1) {
+                returnString = returnString.substring(0, returnString.length - 1);
+            }
+        }
+        returnString = prefix + returnString + suffix;
+        return returnString;
+    };
+
+
+    /*  Parsing Methods */
+
+
+    /**
+     * Parses a number of given format from the element and returns a Number object.
+     * @param {Object} options
+     */
+    jQuery.fn.parseNumber = function(options, writeBack, giveReturnValue) {
+        // enforce defaults
+        if (writeBack == null)
+            writeBack = true;
+        if (giveReturnValue == null)
+            giveReturnValue = true;
+        
+        // get text
+        var text;
+        if (jQuery(this).is(":input"))
+            text = new String(jQuery(this).val());
+        else
+            text = new String(jQuery(this).text());
+    
+        // parse text
+        var number = jQuery.parseNumber(text, options);
+        
+        if (number) {
+            if (writeBack) {
+                if (jQuery(this).is(":input"))
+                    jQuery(this).val(number.toString());
+                else
+                    jQuery(this).text(number.toString());
+            }
+            if (giveReturnValue)
+                return number;
+        }
+    };
+    
+    /**
+     * Parses a string of given format into a Number object.
+     * 
+     * @param {Object} string
+     * @param {Object} options
+     */
+    jQuery.parseNumber = function(numberString, options) {
+        var options = jQuery.extend({}, jQuery.fn.parseNumber.defaults, options);
+        var formatData = formatCodes(options.locale.toLowerCase(), options.isFullLocale);
+
+        var dec = formatData.dec;
+        var group = formatData.group;
+        var neg = formatData.neg;
+
+        // check overrides
+        if (options.overrideGroupSep != null) {
+            group = options.overrideGroupSep;
+        }
+        if (options.overrideDecSep != null) {
+            dec = options.overrideDecSep;
+        }
+        if (options.overrideNegSign != null) {
+            neg = options.overrideNegSign;
+        }
+
+        var valid = "1234567890";
+        var validOnce = '.-';
+        var strictMode = options.strict;
+        
+        // now we need to convert it into a number
+        while (numberString.indexOf(group)>-1) {
+            numberString = numberString.replace(group, '');
+        }
+        numberString = numberString.replace(dec, '.').replace(neg, '-');
+        var validText = '';
+        var hasPercent = false;
+
+        if (options.isPercentage == true || (options.autoDetectPercentage && numberString.charAt(numberString.length - 1) == '%')) {
+            hasPercent = true;
+        }
+
+        for (var i = 0; i < numberString.length; i++) {
+            if (valid.indexOf(numberString.charAt(i)) > -1) {
+                validText = validText + numberString.charAt(i);
+            } else if (validOnce.indexOf(numberString.charAt(i)) > -1) {
+                validText = validText + numberString.charAt(i);
+                validOnce = validOnce.replace(numberString.charAt(i), '');
+            } else {
+                if (options.allowPostfix) {
+                    // treat anything after this point (inclusive) as a postfix
+                    break;
+                } else if (strictMode) {
+                    // abort and force the text to NaN as it's not strictly valid
+                    validText = 'NaN';
+                    break;
+                }
+            }
+        }
+        var number = new Number(validText);
+        if (hasPercent) {
+            number = number / 100;
+            var decimalPos = validText.indexOf('.');
+            if (decimalPos != -1) {
+                var decimalPoints = validText.length - decimalPos - 1;
+                number = number.toFixed(decimalPoints + 2);
+            } else {
+                number = number.toFixed(2);
+            }
+        }
+
+        return number;
+    };
+
+    jQuery.fn.parseNumber.defaults = {
+        locale: "us",
+        decimalSeparatorAlwaysShown: false,
+        isPercentage: false,            // treats the input as a percentage (i.e. input divided by 100)
+        autoDetectPercentage: true,     // will search if the input string ends with '%', if it does then the above option is implicitly set
+        isFullLocale: false,
+        strict: false,                  // will abort the parse if it hits any unknown char
+        overrideGroupSep: null,         // override for group separator
+        overrideDecSep: null,           // override for decimal point separator
+        overrideNegSign: null,          // override for negative sign
+        allowPostfix: false             // will truncate the input string as soon as it hits an unknown char
+    };
+
+    jQuery.fn.formatNumber.defaults = {
+        format: "#,###.00",
+        locale: "us",
+        decimalSeparatorAlwaysShown: false,
+        nanForceZero: true,
+        round: true,
+        isFullLocale: false,
+        overrideGroupSep: null,
+        overrideDecSep: null,
+        overrideNegSign: null,
+        isPercentage: false,            // treats the input as a percentage (i.e. input multiplied by 100)
+        autoDetectPercentage: true      // will search if the format string ends with '%', if it does then the above option is implicitly set
+    };
+    
+    Number.prototype.toFixed = function(precision) {
+        return jQuery._roundNumber(this, precision);
+    };
+    
+    jQuery._roundNumber = function(number, decimalPlaces) {
+        var power = Math.pow(10, decimalPlaces || 0);
+        var value = String(Math.round(number * power) / power);
+        
+        // ensure the decimal places are there
+        if (decimalPlaces > 0) {
+            var dp = value.indexOf(".");
+            if (dp == -1) {
+                value += '.';
+                dp = 0;
+            } else {
+                dp = value.length - (dp + 1);
+            }
+            
+            while (dp < decimalPlaces) {
+                value += '0';
+                dp++;
+            }
+        }
+        return value;
+    };
+
+ })(jQuery);