Synnefo

/*jslint adsafe: false, bitwise: true, browser: true, cap: false, css: false,

  debug: false, devel: true, eqeqeq: true, es5: false, evil: false,

  forin: false, fragment: false, immed: true, laxbreak: false, newcap: true,

  nomen: false, on: false, onevar: true, passfail: false, plusplus: true,

  regexp: false, rhino: true, safe: false, strict: false, sub: false,

  undef: true, white: false, widget: false, windows: false */

/*global jQuery: false, window: false */

"use strict";

/*

 * Original code (c) 2010 Nick Galbreath

 * http://code.google.com/p/stringencoders/source/browse/#svn/trunk/javascript

 *

 * jQuery port (c) 2010 Carlo Zottmann

 * http://github.com/carlo/jquery-base64

 *

 * Permission is hereby granted, free of charge, to any person

 * obtaining a copy of this software and associated documentation

 * files (the "Software"), to deal in the Software without

 * restriction, including without limitation the rights to use,

 * copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following

 * conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

*/

/* base64 encode/decode compatible with window.btoa/atob

 *

 * window.atob/btoa is a Firefox extension to convert binary data (the "b")

 * to base64 (ascii, the "a").

 *

 * It is also found in Safari and Chrome.  It is not available in IE.

 *

 * if (!window.btoa) window.btoa = $.base64.encode

 * if (!window.atob) window.atob = $.base64.decode

 *

 * The original spec's for atob/btoa are a bit lacking

 * https://developer.mozilla.org/en/DOM/window.atob

 * https://developer.mozilla.org/en/DOM/window.btoa

 *

 * window.btoa and $.base64.encode takes a string where charCodeAt is [0,255]

 * If any character is not [0,255], then an exception is thrown.

 *

 * window.atob and $.base64.decode take a base64-encoded string

 * If the input length is not a multiple of 4, or contains invalid characters

 *   then an exception is thrown.

 */

jQuery.base64 = ( function( $ ) {

  var _PADCHAR = "=",

    _ALPHA = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",

    _VERSION = "1.0";

  function _getbyte64( s, i ) {

    // This is oddly fast, except on Chrome/V8.

    // Minimal or no improvement in performance by using a

    // object with properties mapping chars to value (eg. 'A': 0)

    var idx = _ALPHA.indexOf( s.charAt( i ) );

    if ( idx === -1 ) {

      throw "Cannot decode base64";

    }

    return idx;

  }

  function _decode( s ) {

    var pads = 0,

      i,

      b10,

      imax = s.length,

      x = [];

    s = String( s );

    if ( imax === 0 ) {

      return s;

    }

    if ( imax % 4 !== 0 ) {

      throw "Cannot decode base64";

    }

    if ( s.charAt( imax - 1 ) === _PADCHAR ) {

      pads = 1;

      if ( s.charAt( imax - 2 ) === _PADCHAR ) {

        pads = 2;

      }

      // either way, we want to ignore this last block

      imax -= 4;

    }

    for ( i = 0; i < imax; i += 4 ) {

      b10 = ( _getbyte64( s, i ) << 18 ) | ( _getbyte64( s, i + 1 ) << 12 ) | ( _getbyte64( s, i + 2 ) << 6 ) | _getbyte64( s, i + 3 );

      x.push( String.fromCharCode( b10 >> 16, ( b10 >> 8 ) & 0xff, b10 & 0xff ) );

    }

    switch ( pads ) {

      case 1:

        b10 = ( _getbyte64( s, i ) << 18 ) | ( _getbyte64( s, i + 1 ) << 12 ) | ( _getbyte64( s, i + 2 ) << 6 );

        x.push( String.fromCharCode( b10 >> 16, ( b10 >> 8 ) & 0xff ) );

        break;

      case 2:

        b10 = ( _getbyte64( s, i ) << 18) | ( _getbyte64( s, i + 1 ) << 12 );

        x.push( String.fromCharCode( b10 >> 16 ) );

        break;

    }

    return x.join( "" );

  }

  function _getbyte( s, i ) {

    var x = s.charCodeAt( i );

    if ( x > 255 ) {

      throw "INVALID_CHARACTER_ERR: DOM Exception 5";

    }

    return x;

  }

  function _encode( s ) {

    if ( arguments.length !== 1 ) {

      throw "SyntaxError: exactly one argument required";

    }

    s = String( s );

    var i,

      b10,

      x = [],

      imax = s.length - s.length % 3;

    if ( s.length === 0 ) {

      return s;

    }

    for ( i = 0; i < imax; i += 3 ) {

      b10 = ( _getbyte( s, i ) << 16 ) | ( _getbyte( s, i + 1 ) << 8 ) | _getbyte( s, i + 2 );

      x.push( _ALPHA.charAt( b10 >> 18 ) );

      x.push( _ALPHA.charAt( ( b10 >> 12 ) & 0x3F ) );

      x.push( _ALPHA.charAt( ( b10 >> 6 ) & 0x3f ) );

      x.push( _ALPHA.charAt( b10 & 0x3f ) );

    }

    switch ( s.length - imax ) {

      case 1:

        b10 = _getbyte( s, i ) << 16;

        x.push( _ALPHA.charAt( b10 >> 18 ) + _ALPHA.charAt( ( b10 >> 12 ) & 0x3F ) + _PADCHAR + _PADCHAR );

        break;

      case 2:

        b10 = ( _getbyte( s, i ) << 16 ) | ( _getbyte( s, i + 1 ) << 8 );

        x.push( _ALPHA.charAt( b10 >> 18 ) + _ALPHA.charAt( ( b10 >> 12 ) & 0x3F ) + _ALPHA.charAt( ( b10 >> 6 ) & 0x3f ) + _PADCHAR );

        break;

    }

    return x.join( "" );

  }

  return {

    decode: _decode,

    encode: _encode,

    VERSION: _VERSION

  };

}( jQuery ) );

/*!

 *  Copyright ? 2008 Fair Oaks Labs, Inc.

 *  All rights reserved.

 */

// Utility object:  Encode/Decode C-style binary primitives to/from octet arrays

function JSPack()

{

	// Module-level (private) variables

	var el,  bBE = false, m = this;

	// Raw byte arrays

	m._DeArray = function (a, p, l)

	{

		return [a.slice(p,p+l)];

	};

	m._EnArray = function (a, p, l, v)

	{

		for (var i = 0; i < l; a[p+i] = v[i]?v[i]:0, i++);

	};

	// ASCII characters

	m._DeChar = function (a, p)

	{

		return String.fromCharCode(a[p]);

	};

	m._EnChar = function (a, p, v)

	{

		a[p] = v.charCodeAt(0);

	};

	// Little-endian (un)signed N-byte integers

	m._DeInt = function (a, p)

	{

		var lsb = bBE?(el.len-1):0, nsb = bBE?-1:1, stop = lsb+nsb*el.len, rv, i, f;

		for (rv = 0, i = lsb, f = 1; i != stop; rv+=(a[p+i]*f), i+=nsb, f*=256);

		if (el.bSigned && (rv & Math.pow(2, el.len*8-1))) { rv -= Math.pow(2, el.len*8); }

		return rv;

	};

	m._EnInt = function (a, p, v)

	{

		var lsb = bBE?(el.len-1):0, nsb = bBE?-1:1, stop = lsb+nsb*el.len, i;

		v = (v<el.min)?el.min:(v>el.max)?el.max:v;

		for (i = lsb; i != stop; a[p+i]=v&0xff, i+=nsb, v>>=8);

	};

	// ASCII character strings

	m._DeString = function (a, p, l)

	{

		for (var rv = new Array(l), i = 0; i < l; rv[i] = String.fromCharCode(a[p+i]), i++);

		return rv.join('');

	};

	m._EnString = function (a, p, l, v)

	{

		for (var t, i = 0; i < l; a[p+i] = (t=v.charCodeAt(i))?t:0, i++);

	};

	// Little-endian N-bit IEEE 754 floating point

	m._De754 = function (a, p)

	{

		var s, e, m, i, d, nBits, mLen, eLen, eBias, eMax;

		mLen = el.mLen, eLen = el.len*8-el.mLen-1, eMax = (1<<eLen)-1, eBias = eMax>>1;

		i = bBE?0:(el.len-1); d = bBE?1:-1; s = a[p+i]; i+=d; nBits = -7;

		for (e = s&((1<<(-nBits))-1), s>>=(-nBits), nBits += eLen; nBits > 0; e=e*256+a[p+i], i+=d, nBits-=8);

		for (m = e&((1<<(-nBits))-1), e>>=(-nBits), nBits += mLen; nBits > 0; m=m*256+a[p+i], i+=d, nBits-=8);

		switch (e)

		{

			case 0:

				// Zero, or denormalized number

				e = 1-eBias;

				break;

			case eMax:

				// NaN, or +/-Infinity

				return m?NaN:((s?-1:1)*Infinity);

			default:

				// Normalized number

				m = m + Math.pow(2, mLen);

				e = e - eBias;

				break;

		}

		return (s?-1:1) * m * Math.pow(2, e-mLen);

	};

	m._En754 = function (a, p, v)

	{

		var s, e, m, i, d, c, mLen, eLen, eBias, eMax;

		mLen = el.mLen, eLen = el.len*8-el.mLen-1, eMax = (1<<eLen)-1, eBias = eMax>>1;

		s = v<0?1:0;

		v = Math.abs(v);

		if (isNaN(v) || (v == Infinity))

		{

			m = isNaN(v)?1:0;

			e = eMax;

		}

		else

		{

			e = Math.floor(Math.log(v)/Math.LN2);			// Calculate log2 of the value

			if (v*(c = Math.pow(2, -e)) < 1) { e--; c*=2; }		// Math.log() isn't 100% reliable

			// Round by adding 1/2 the significand's LSD

			if (e+eBias >= 1) { v += el.rt/c; }			// Normalized:  mLen significand digits

			else { v += el.rt*Math.pow(2, 1-eBias); } 		// Denormalized:  <= mLen significand digits

			if (v*c >= 2) { e++; c/=2; }				// Rounding can increment the exponent

			if (e+eBias >= eMax)

			{

				// Overflow

				m = 0;

				e = eMax;

			}

			else if (e+eBias >= 1)

			{

				// Normalized - term order matters, as Math.pow(2, 52-e) and v*Math.pow(2, 52) can overflow

				m = (v*c-1)*Math.pow(2, mLen);

				e = e + eBias;

			}

			else

			{

				// Denormalized - also catches the '0' case, somewhat by chance

				m = v*Math.pow(2, eBias-1)*Math.pow(2, mLen);

				e = 0;

			}

		}

		for (i = bBE?(el.len-1):0, d=bBE?-1:1; mLen >= 8; a[p+i]=m&0xff, i+=d, m/=256, mLen-=8);

		for (e=(e<<mLen)|m, eLen+=mLen; eLen > 0; a[p+i]=e&0xff, i+=d, e/=256, eLen-=8);

		a[p+i-d] |= s*128;

	};

	// Class data

	m._sPattern	= '(\\d+)?([AxcbBhHsfdiIlL])';

	m._lenLut	= {'A':1, 'x':1, 'c':1, 'b':1, 'B':1, 'h':2, 'H':2, 's':1, 'f':4, 'd':8, 'i':4, 'I':4, 'l':4, 'L':4};

	m._elLut	= {	'A': {en:m._EnArray, de:m._DeArray},

				's': {en:m._EnString, de:m._DeString},

				'c': {en:m._EnChar, de:m._DeChar},

				'b': {en:m._EnInt, de:m._DeInt, len:1, bSigned:true, min:-Math.pow(2, 7), max:Math.pow(2, 7)-1},

				'B': {en:m._EnInt, de:m._DeInt, len:1, bSigned:false, min:0, max:Math.pow(2, 8)-1},

				'h': {en:m._EnInt, de:m._DeInt, len:2, bSigned:true, min:-Math.pow(2, 15), max:Math.pow(2, 15)-1},

				'H': {en:m._EnInt, de:m._DeInt, len:2, bSigned:false, min:0, max:Math.pow(2, 16)-1},

				'i': {en:m._EnInt, de:m._DeInt, len:4, bSigned:true, min:-Math.pow(2, 31), max:Math.pow(2, 31)-1},

				'I': {en:m._EnInt, de:m._DeInt, len:4, bSigned:false, min:0, max:Math.pow(2, 32)-1},

				'l': {en:m._EnInt, de:m._DeInt, len:4, bSigned:true, min:-Math.pow(2, 31), max:Math.pow(2, 31)-1},

				'L': {en:m._EnInt, de:m._DeInt, len:4, bSigned:false, min:0, max:Math.pow(2, 32)-1},

				'f': {en:m._En754, de:m._De754, len:4, mLen:23, rt:Math.pow(2, -24)-Math.pow(2, -77)},

				'd': {en:m._En754, de:m._De754, len:8, mLen:52, rt:0}};

	// Unpack a series of n elements of size s from array a at offset p with fxn

	m._UnpackSeries = function (n, s, a, p)

	{

		for (var fxn = el.de, rv = [], i = 0; i < n; rv.push(fxn(a, p+i*s)), i++);

		return rv;

	};

	// Pack a series of n elements of size s from array v at offset i to array a at offset p with fxn

	m._PackSeries = function (n, s, a, p, v, i)

	{

		for (var fxn = el.en, o = 0; o < n; fxn(a, p+o*s, v[i+o]), o++);

	};

	// Unpack the octet array a, beginning at offset p, according to the fmt string

	m.Unpack = function (fmt, a, p)

	{

		// Set the private bBE flag based on the format string - assume big-endianness

		bBE = (fmt.charAt(0) != '<');

		p = p?p:0;

		var re = new RegExp(this._sPattern, 'g'), m, n, s, rv = [];

		while (m = re.exec(fmt))

		{

			n = ((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1]);

			s = this._lenLut[m[2]];

			if ((p + n*s) > a.length)

			{

				return undefined;

			}

			switch (m[2])

			{

				case 'A': case 's':

					rv.push(this._elLut[m[2]].de(a, p, n));

					break;

				case 'c': case 'b': case 'B': case 'h': case 'H':

				case 'i': case 'I': case 'l': case 'L': case 'f': case 'd':

					el = this._elLut[m[2]];

					rv.push(this._UnpackSeries(n, s, a, p));

					break;

			}

			p += n*s;

		}

		return Array.prototype.concat.apply([], rv);

	};

	// Pack the supplied values into the octet array a, beginning at offset p, according to the fmt string

	m.PackTo = function (fmt, a, p, values)

	{

		// Set the private bBE flag based on the format string - assume big-endianness

		bBE = (fmt.charAt(0) != '<');

		var re = new RegExp(this._sPattern, 'g'), m, n, s, i = 0, j;

		while (m = re.exec(fmt))

		{

			n = ((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1]);

			s = this._lenLut[m[2]];

			if ((p + n*s) > a.length)

			{

				return false;

			}

			switch (m[2])

			{

				case 'A': case 's':

					if ((i + 1) > values.length) { return false; }

					this._elLut[m[2]].en(a, p, n, values[i]);

					i += 1;

					break;

				case 'c': case 'b': case 'B': case 'h': case 'H':

				case 'i': case 'I': case 'l': case 'L': case 'f': case 'd':

					el = this._elLut[m[2]];

					if ((i + n) > values.length) { return false; }

					this._PackSeries(n, s, a, p, values, i);

					i += n;

					break;

				case 'x':

					for (j = 0; j < n; j++) { a[p+j] = 0; }

					break;

			}

			p += n*s;

		}

		return a;

	};

	// Pack the supplied values into a new octet array, according to the fmt string

	m.Pack = function (fmt, values)

	{

		return this.PackTo(fmt, new Array(this.CalcLength(fmt)), 0, values);

	};

	// Determine the number of bytes represented by the format string

	m.CalcLength = function (fmt)

	{

		var re = new RegExp(this._sPattern, 'g'), m, sum = 0;

		while (m = re.exec(fmt))

		{

			sum += (((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1])) * this._lenLut[m[2]];

		}

		return sum;

	};

};