text: /*
   * Foundation Responsive Library
   * http://foundation.zurb.com
   * Copyright 2013, ZURB
   * Free to use under the MIT license.
   * http://www.opensource.org/licenses/mit-license.php
  */
  
  /*jslint unparam: true, browser: true, indent: 2 */
  
  // Accommodate running jQuery or Zepto in noConflict() mode by
  // using an anonymous function to redefine the $ shorthand name.
  // See http://docs.jquery.com/Using_jQuery_with_Other_Libraries
  // and http://zeptojs.com/
  var libFuncName = null;
  
  if (typeof jQuery === "undefined" &&
      typeof Zepto === "undefined" &&
      typeof $ === "function") {
    libFuncName = $;
  } else if (typeof jQuery === "function") {
    libFuncName = jQuery;
  } else if (typeof Zepto === "function") {
    libFuncName = Zepto;
  } else {
    throw new TypeError();
  }
  
  (function ($, window, document, undefined) {
    'use strict';
  
    // add dusty browser stuff
    if (!Array.prototype.filter) {
      Array.prototype.filter = function(fun /*, thisp */) {
        "use strict";
     
        if (this == null) {
          throw new TypeError();
        }
  
        var t = Object(this),
            len = t.length >>> 0;
        if (typeof fun != "function") {
            return;
        }
  
        var res = [],
            thisp = arguments[1];
        for (var i = 0; i < len; i++) {
          if (i in t) {
            var val = t[i]; // in case fun mutates this
            if (fun && fun.call(thisp, val, i, t)) {
              res.push(val);
            }
          }
        }
  
        return res;
      }
    }
  
    if (!Function.prototype.bind) {
      Function.prototype.bind = function (oThis) {
        if (typeof this !== "function") {
          // closest thing possible to the ECMAScript 5 internal IsCallable function
          throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");
        }
     
        var aArgs = Array.prototype.slice.call(arguments, 1), 
            fToBind = this, 
            fNOP = function () {},
            fBound = function () {
              return fToBind.apply(this instanceof fNOP && oThis
                 ? this
                 : oThis,
               aArgs.concat(Array.prototype.slice.call(arguments)));
            };
     
        fNOP.prototype = this.prototype;
        fBound.prototype = new fNOP();
     
        return fBound;
      };
    }
  
    // fake stop() for zepto.
    $.fn.stop = $.fn.stop || function() {
      return this;
    };
  
    window.Foundation = {
      name : 'Foundation',
  
      version : '4.1.3',
  
      // global Foundation cache object
      cache : {},
  
      init : function (scope, libraries, method, options, response, /* internal */ nc) {
        var library_arr,
            args = [scope, method, options, response],
            responses = [],
            nc = nc || false;
  
        // disable library error catching,
        // used for development only
        if (nc) this.nc = nc;
  
        // check RTL
        this.rtl = /rtl/i.test($('html').attr('dir'));
  
        // set foundation global scope
        this.scope = scope || this.scope;
  
        if (libraries && typeof libraries === 'string') {
          if (/off/i.test(libraries)) return this.off();
  
          library_arr = libraries.split(' ');
  
          if (library_arr.length > 0) {
            for (var i = library_arr.length - 1; i >= 0; i--) {
              responses.push(this.init_lib(library_arr[i], args));
            }
          }
        } else {
          for (var lib in this.libs) {
            responses.push(this.init_lib(lib, args));
          }
        }
  
        // if first argument is callback, add to args
        if (typeof libraries === 'function') {
          args.unshift(libraries);
        }
  
        return this.response_obj(responses, args);
      },
  
      response_obj : function (response_arr, args) {
        for (var i = 0, len = args.length; i < len; i++) {
          if (typeof args[i] === 'function') {
            return args[i]({
              errors: response_arr.filter(function (s) {
                if (typeof s === 'string') return s;
              })
            });
          }
        }
  
        return response_arr;
      },
  
      init_lib : function (lib, args) {
        return this.trap(function () {
          if (this.libs.hasOwnProperty(lib)) {
            this.patch(this.libs[lib]);
            return this.libs[lib].init.apply(this.libs[lib], args);
          }
        }.bind(this), lib);
      },
  
      trap : function (fun, lib) {
        if (!this.nc) {
          try {
            return fun();
          } catch (e) {
            return this.error({name: lib, message: 'could not be initialized', more: e.name + ' ' + e.message});
          }
        }
  
        return fun();
      },
  
      patch : function (lib) {
        this.fix_outer(lib);
        lib.scope = this.scope;
        lib.rtl = this.rtl;
      },
  
      inherit : function (scope, methods) {
        var methods_arr = methods.split(' ');
  
        for (var i = methods_arr.length - 1; i >= 0; i--) {
          if (this.lib_methods.hasOwnProperty(methods_arr[i])) {
            this.libs[scope.name][methods_arr[i]] = this.lib_methods[methods_arr[i]];
          }
        }
      },
  
      random_str : function (length) {
        var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz'.split('');
  
        if (!length) {
            length = Math.floor(Math.random() * chars.length);
        }
  
        var str = '';
        for (var i = 0; i < length; i++) {
            str += chars[Math.floor(Math.random() * chars.length)];
        }
        return str;
      },
  
      libs : {},
  
      // methods that can be inherited in libraries
      lib_methods : {
        set_data : function (node, data) {
          // this.name references the name of the library calling this method
          var id = [this.name,+new Date(),Foundation.random_str(5)].join('-');
  
          Foundation.cache[id] = data;
          node.attr('data-' + this.name + '-id', id);
          return data;
        },
  
        get_data : function (node) {
          return Foundation.cache[node.attr('data-' + this.name + '-id')];
        },
  
        remove_data : function (node) {
          if (node) {
            delete Foundation.cache[node.attr('data-' + this.name + '-id')];
            node.attr('data-' + this.name + '-id', '');
          } else {
            $('[data-' + this.name + '-id]').each(function () {
              delete Foundation.cache[$(this).attr('data-' + this.name + '-id')];
              $(this).attr('data-' + this.name + '-id', '');
            });
          }
        },
  
        throttle : function(fun, delay) {
          var timer = null;
          return function () {
            var context = this, args = arguments;
            clearTimeout(timer);
            timer = setTimeout(function () {
              fun.apply(context, args);
            }, delay);
          };
        },
  
        // parses data-options attribute on nodes and turns
        // them into an object
        data_options : function (el) {
          var opts = {}, ii, p,
              opts_arr = (el.attr('data-options') || ':').split(';'),
              opts_len = opts_arr.length;
  
          function isNumber (o) {
            return ! isNaN (o-0) && o !== null && o !== "" && o !== false && o !== true;
          }
  
          function trim(str) {
            if (typeof str === 'string') return $.trim(str);
            return str;
          }
  
          // parse options
          for (ii = opts_len - 1; ii >= 0; ii--) {
            p = opts_arr[ii].split(':');
  
            if (/true/i.test(p[1])) p[1] = true;
            if (/false/i.test(p[1])) p[1] = false;
            if (isNumber(p[1])) p[1] = parseInt(p[1], 10);
  
            if (p.length === 2 && p[0].length > 0) {
              opts[trim(p[0])] = trim(p[1]);
            }
          }
  
          return opts;
        },
  
        delay : function (fun, delay) {
          return setTimeout(fun, delay);
        },
  
        // animated scrolling
        scrollTo : function (el, to, duration) {
          if (duration < 0) return;
          var difference = to - $(window).scrollTop();
          var perTick = difference / duration * 10;
  
          this.scrollToTimerCache = setTimeout(function() {
            if (!isNaN(parseInt(perTick, 10))) {
              window.scrollTo(0, $(window).scrollTop() + perTick);
              this.scrollTo(el, to, duration - 10);
            }
          }.bind(this), 10);
        },
  
        // not supported in core Zepto
        scrollLeft : function (el) {
          if (!el.length) return;
          return ('scrollLeft' in el[0]) ? el[0].scrollLeft : el[0].pageXOffset;
        },
  
        // test for empty object or array
        empty : function (obj) {
          if (obj.length && obj.length > 0)    return false;
          if (obj.length && obj.length === 0)  return true;
  
          for (var key in obj) {
            if (hasOwnProperty.call(obj, key))    return false;
          }
  
          return true;
        }
      },
  
      fix_outer : function (lib) {
        lib.outerHeight = function (el, bool) {
          if (typeof Zepto === 'function') {
            return el.height();
          }
  
          if (typeof bool !== 'undefined') {
            return el.outerHeight(bool);
          }
  
          return el.outerHeight();
        };
  
        lib.outerWidth = function (el) {
          if (typeof Zepto === 'function') {
            return el.width();
          }
  
          if (typeof bool !== 'undefined') {
            return el.outerWidth(bool);
          }
  
          return el.outerWidth();
        };
      },
  
      error : function (error) {
        return error.name + ' ' + error.message + '; ' + error.more;
      },
  
      // remove all foundation events.
      off: function () {
        $(this.scope).off('.fndtn');
        $(window).off('.fndtn');
        return true;
      },
  
      zj : function () {
        try {
          return Zepto;
        } catch (e) {
          return jQuery;
        }
      }()
    };
  
    $.fn.foundation = function () {
      var args = Array.prototype.slice.call(arguments, 0);
  
      return this.each(function () {
        Foundation.init.apply(Foundation, [this].concat(args));
        return this;
      });
    };
  
  }(libFuncName, this, this.document));