← Back to branch summary

~bcsaller/juju-gui/exportXY

« back to all changes in this revision

Viewing changes to lib/cryptojs/components/enc-base64.js

  • Committer: kapil.foss at gmail
  • Date: 2012-07-11 16:32:03 UTC
  • Revision ID: kapil.foss@gmail.com-20120711163203-nsuoy9r0p48az7mu
commit wip

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/cryptojs/components/enc-base64.js
 
1
/*
 
2
CryptoJS v3.0.2
 
3
code.google.com/p/crypto-js
 
4
(c) 2009-2012 by Jeff Mott. All rights reserved.
 
5
code.google.com/p/crypto-js/wiki/License
 
6
*/
 
7
(function () {
 
8
    // Shortcuts
 
9
    var C = CryptoJS;
 
10
    var C_lib = C.lib;
 
11
    var WordArray = C_lib.WordArray;
 
12
    var C_enc = C.enc;
 
13
 
 
14
    /**
 
15
     * Base64 encoding strategy.
 
16
     */
 
17
    var Base64 = C_enc.Base64 = {
 
18
        /**
 
19
         * Converts a word array to a Base64 string.
 
20
         *
 
21
         * @param {WordArray} wordArray The word array.
 
22
         *
 
23
         * @return {string} The Base64 string.
 
24
         *
 
25
         * @static
 
26
         *
 
27
         * @example
 
28
         *
 
29
         *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
 
30
         */
 
31
        stringify: function (wordArray) {
 
32
            // Shortcuts
 
33
            var words = wordArray.words;
 
34
            var sigBytes = wordArray.sigBytes;
 
35
            var map = this._map;
 
36
 
 
37
            // Clamp excess bits
 
38
            wordArray.clamp();
 
39
 
 
40
            // Convert
 
41
            var base64Chars = [];
 
42
            for (var i = 0; i < sigBytes; i += 3) {
 
43
                var byte1 = (words[i >>> 2]       >>> (24 - (i % 4) * 8))       & 0xff;
 
44
                var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
 
45
                var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
 
46
 
 
47
                var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
 
48
 
 
49
                for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {
 
50
                    base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
 
51
                }
 
52
            }
 
53
 
 
54
            // Add padding
 
55
            var paddingChar = map.charAt(64);
 
56
            if (paddingChar) {
 
57
                while (base64Chars.length % 4) {
 
58
                    base64Chars.push(paddingChar);
 
59
                }
 
60
            }
 
61
 
 
62
            return base64Chars.join('');
 
63
        },
 
64
 
 
65
        /**
 
66
         * Converts a Base64 string to a word array.
 
67
         *
 
68
         * @param {string} base64Str The Base64 string.
 
69
         *
 
70
         * @return {WordArray} The word array.
 
71
         *
 
72
         * @static
 
73
         *
 
74
         * @example
 
75
         *
 
76
         *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
 
77
         */
 
78
        parse: function (base64Str) {
 
79
            // Ignore whitespaces
 
80
            base64Str = base64Str.replace(/\s/g, '');
 
81
 
 
82
            // Shortcuts
 
83
            var base64StrLength = base64Str.length;
 
84
            var map = this._map;
 
85
 
 
86
            // Ignore padding
 
87
            var paddingChar = map.charAt(64);
 
88
            if (paddingChar) {
 
89
                var paddingIndex = base64Str.indexOf(paddingChar);
 
90
                if (paddingIndex != -1) {
 
91
                    base64StrLength = paddingIndex;
 
92
                }
 
93
            }
 
94
 
 
95
            // Convert
 
96
            var words = [];
 
97
            var nBytes = 0;
 
98
            for (var i = 0; i < base64StrLength; i++) {
 
99
                if (i % 4) {
 
100
                    var bitsHigh = map.indexOf(base64Str.charAt(i - 1)) << ((i % 4) * 2);
 
101
                    var bitsLow  = map.indexOf(base64Str.charAt(i)) >>> (6 - (i % 4) * 2);
 
102
                    words[nBytes >>> 2] |= (bitsHigh | bitsLow) << (24 - (nBytes % 4) * 8);
 
103
                    nBytes++;
 
104
                }
 
105
            }
 
106
 
 
107
            return WordArray.create(words, nBytes);
 
108
        },
 
109
 
 
110
        _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
 
111
    };
 
112
}());