corrade-nucleus-nucleons – Blame information for rev 2

Subversion Repositories:
Rev:
Rev Author Line No. Line
2 office 1 /*
2 CryptoJS v3.1.2
3 code.google.com/p/crypto-js
4 (c) 2009-2013 by Jeff Mott. All rights reserved.
5 code.google.com/p/crypto-js/wiki/License
6 */
7 /**
8 * CryptoJS core components.
9 */
10 var CryptoJS = CryptoJS || (function (Math, undefined) {
11 /**
12 * CryptoJS namespace.
13 */
14 var C = {};
15  
16 /**
17 * Library namespace.
18 */
19 var C_lib = C.lib = {};
20  
21 /**
22 * Base object for prototypal inheritance.
23 */
24 var Base = C_lib.Base = (function () {
25 function F() {}
26  
27 return {
28 /**
29 * Creates a new object that inherits from this object.
30 *
31 * @param {Object} overrides Properties to copy into the new object.
32 *
33 * @return {Object} The new object.
34 *
35 * @static
36 *
37 * @example
38 *
39 * var MyType = CryptoJS.lib.Base.extend({
40 * field: 'value',
41 *
42 * method: function () {
43 * }
44 * });
45 */
46 extend: function (overrides) {
47 // Spawn
48 F.prototype = this;
49 var subtype = new F();
50  
51 // Augment
52 if (overrides) {
53 subtype.mixIn(overrides);
54 }
55  
56 // Create default initializer
57 if (!subtype.hasOwnProperty('init')) {
58 subtype.init = function () {
59 subtype.$super.init.apply(this, arguments);
60 };
61 }
62  
63 // Initializer's prototype is the subtype object
64 subtype.init.prototype = subtype;
65  
66 // Reference supertype
67 subtype.$super = this;
68  
69 return subtype;
70 },
71  
72 /**
73 * Extends this object and runs the init method.
74 * Arguments to create() will be passed to init().
75 *
76 * @return {Object} The new object.
77 *
78 * @static
79 *
80 * @example
81 *
82 * var instance = MyType.create();
83 */
84 create: function () {
85 var instance = this.extend();
86 instance.init.apply(instance, arguments);
87  
88 return instance;
89 },
90  
91 /**
92 * Initializes a newly created object.
93 * Override this method to add some logic when your objects are created.
94 *
95 * @example
96 *
97 * var MyType = CryptoJS.lib.Base.extend({
98 * init: function () {
99 * // ...
100 * }
101 * });
102 */
103 init: function () {
104 },
105  
106 /**
107 * Copies properties into this object.
108 *
109 * @param {Object} properties The properties to mix in.
110 *
111 * @example
112 *
113 * MyType.mixIn({
114 * field: 'value'
115 * });
116 */
117 mixIn: function (properties) {
118 for (var propertyName in properties) {
119 if (properties.hasOwnProperty(propertyName)) {
120 this[propertyName] = properties[propertyName];
121 }
122 }
123  
124 // IE won't copy toString using the loop above
125 if (properties.hasOwnProperty('toString')) {
126 this.toString = properties.toString;
127 }
128 },
129  
130 /**
131 * Creates a copy of this object.
132 *
133 * @return {Object} The clone.
134 *
135 * @example
136 *
137 * var clone = instance.clone();
138 */
139 clone: function () {
140 return this.init.prototype.extend(this);
141 }
142 };
143 }());
144  
145 /**
146 * An array of 32-bit words.
147 *
148 * @property {Array} words The array of 32-bit words.
149 * @property {number} sigBytes The number of significant bytes in this word array.
150 */
151 var WordArray = C_lib.WordArray = Base.extend({
152 /**
153 * Initializes a newly created word array.
154 *
155 * @param {Array} words (Optional) An array of 32-bit words.
156 * @param {number} sigBytes (Optional) The number of significant bytes in the words.
157 *
158 * @example
159 *
160 * var wordArray = CryptoJS.lib.WordArray.create();
161 * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
162 * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
163 */
164 init: function (words, sigBytes) {
165 words = this.words = words || [];
166  
167 if (sigBytes != undefined) {
168 this.sigBytes = sigBytes;
169 } else {
170 this.sigBytes = words.length * 4;
171 }
172 },
173  
174 /**
175 * Converts this word array to a string.
176 *
177 * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
178 *
179 * @return {string} The stringified word array.
180 *
181 * @example
182 *
183 * var string = wordArray + '';
184 * var string = wordArray.toString();
185 * var string = wordArray.toString(CryptoJS.enc.Utf8);
186 */
187 toString: function (encoder) {
188 return (encoder || Hex).stringify(this);
189 },
190  
191 /**
192 * Concatenates a word array to this word array.
193 *
194 * @param {WordArray} wordArray The word array to append.
195 *
196 * @return {WordArray} This word array.
197 *
198 * @example
199 *
200 * wordArray1.concat(wordArray2);
201 */
202 concat: function (wordArray) {
203 // Shortcuts
204 var thisWords = this.words;
205 var thatWords = wordArray.words;
206 var thisSigBytes = this.sigBytes;
207 var thatSigBytes = wordArray.sigBytes;
208  
209 // Clamp excess bits
210 this.clamp();
211  
212 // Concat
213 if (thisSigBytes % 4) {
214 // Copy one byte at a time
215 for (var i = 0; i < thatSigBytes; i++) {
216 var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
217 thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
218 }
219 } else if (thatWords.length > 0xffff) {
220 // Copy one word at a time
221 for (var i = 0; i < thatSigBytes; i += 4) {
222 thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
223 }
224 } else {
225 // Copy all words at once
226 thisWords.push.apply(thisWords, thatWords);
227 }
228 this.sigBytes += thatSigBytes;
229  
230 // Chainable
231 return this;
232 },
233  
234 /**
235 * Removes insignificant bits.
236 *
237 * @example
238 *
239 * wordArray.clamp();
240 */
241 clamp: function () {
242 // Shortcuts
243 var words = this.words;
244 var sigBytes = this.sigBytes;
245  
246 // Clamp
247 words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
248 words.length = Math.ceil(sigBytes / 4);
249 },
250  
251 /**
252 * Creates a copy of this word array.
253 *
254 * @return {WordArray} The clone.
255 *
256 * @example
257 *
258 * var clone = wordArray.clone();
259 */
260 clone: function () {
261 var clone = Base.clone.call(this);
262 clone.words = this.words.slice(0);
263  
264 return clone;
265 },
266  
267 /**
268 * Creates a word array filled with random bytes.
269 *
270 * @param {number} nBytes The number of random bytes to generate.
271 *
272 * @return {WordArray} The random word array.
273 *
274 * @static
275 *
276 * @example
277 *
278 * var wordArray = CryptoJS.lib.WordArray.random(16);
279 */
280 random: function (nBytes) {
281 var words = [];
282 for (var i = 0; i < nBytes; i += 4) {
283 < nBytes; i += 4) { words.push((Math.random() * 0x100000000) | 0);
284 < nBytes; i += 4) { }
285  
286 < nBytes; i += 4) { return new WordArray.init(words, nBytes);
287 < nBytes; i += 4) { }
288 < nBytes; i += 4) { });
289  
290 < nBytes; i += 4) { /**
291 < nBytes; i += 4) { * Encoder namespace.
292 < nBytes; i += 4) { */
293 < nBytes; i += 4) { var C_enc = C.enc = {};
294  
295 < nBytes; i += 4) { /**
296 < nBytes; i += 4) { * Hex encoding strategy.
297 < nBytes; i += 4) { */
298 < nBytes; i += 4) { var Hex = C_enc.Hex = {
299 < nBytes; i += 4) { /**
300 < nBytes; i += 4) { * Converts a word array to a hex string.
301 < nBytes; i += 4) { *
302 < nBytes; i += 4) { * @param {WordArray} wordArray The word array.
303 < nBytes; i += 4) { *
304 < nBytes; i += 4) { * @return {string} The hex string.
305 < nBytes; i += 4) { *
306 < nBytes; i += 4) { * @static
307 < nBytes; i += 4) { *
308 < nBytes; i += 4) { * @example
309 < nBytes; i += 4) { *
310 < nBytes; i += 4) { * var hexString = CryptoJS.enc.Hex.stringify(wordArray);
311 < nBytes; i += 4) { */
312 < nBytes; i += 4) { stringify: function (wordArray) {
313 < nBytes; i += 4) { // Shortcuts
314 < nBytes; i += 4) { var words = wordArray.words;
315 < nBytes; i += 4) { var sigBytes = wordArray.sigBytes;
316  
317 < nBytes; i += 4) { // Convert
318 < nBytes; i += 4) { var hexChars = [];
319 < nBytes; i += 4) { for (var i = 0; i < sigBytes; i++) {
320 < nBytes; i += 4) {< sigBytes; i++) { var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
321 < nBytes; i += 4) {< sigBytes; i++) { hexChars.push((bite >>> 4).toString(16));
322 < nBytes; i += 4) {< sigBytes; i++) { hexChars.push((bite & 0x0f).toString(16));
323 < nBytes; i += 4) {< sigBytes; i++) { }
324  
325 < nBytes; i += 4) {< sigBytes; i++) { return hexChars.join('');
326 < nBytes; i += 4) {< sigBytes; i++) { },
327  
328 < nBytes; i += 4) {< sigBytes; i++) { /**
329 < nBytes; i += 4) {< sigBytes; i++) { * Converts a hex string to a word array.
330 < nBytes; i += 4) {< sigBytes; i++) { *
331 < nBytes; i += 4) {< sigBytes; i++) { * @param {string} hexStr The hex string.
332 < nBytes; i += 4) {< sigBytes; i++) { *
333 < nBytes; i += 4) {< sigBytes; i++) { * @return {WordArray} The word array.
334 < nBytes; i += 4) {< sigBytes; i++) { *
335 < nBytes; i += 4) {< sigBytes; i++) { * @static
336 < nBytes; i += 4) {< sigBytes; i++) { *
337 < nBytes; i += 4) {< sigBytes; i++) { * @example
338 < nBytes; i += 4) {< sigBytes; i++) { *
339 < nBytes; i += 4) {< sigBytes; i++) { * var wordArray = CryptoJS.enc.Hex.parse(hexString);
340 < nBytes; i += 4) {< sigBytes; i++) { */
341 < nBytes; i += 4) {< sigBytes; i++) { parse: function (hexStr) {
342 < nBytes; i += 4) {< sigBytes; i++) { // Shortcut
343 < nBytes; i += 4) {< sigBytes; i++) { var hexStrLength = hexStr.length;
344  
345 < nBytes; i += 4) {< sigBytes; i++) { // Convert
346 < nBytes; i += 4) {< sigBytes; i++) { var words = [];
347 < nBytes; i += 4) {< sigBytes; i++) { for (var i = 0; i < hexStrLength; i += 2) {
348 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) { words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
349 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }
350  
351 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); return new WordArray.init(words, hexStrLength / 2);
352 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }
353 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); };
354  
355 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**
356 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Latin1 encoding strategy.
357 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */
358 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var Latin1 = C_enc.Latin1 = {
359 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**
360 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Converts a word array to a Latin1 string.
361 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
362 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {WordArray} wordArray The word array.
363 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
364 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @return {string} The Latin1 string.
365 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
366 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @static
367 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
368 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example
369 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
370 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
371 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */
372 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); stringify: function (wordArray) {
373 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Shortcuts
374 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var words = wordArray.words;
375 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var sigBytes = wordArray.sigBytes;
376  
377 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Convert
378 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var latin1Chars = [];
379 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); for (var i = 0; i < sigBytes; i++) {
380 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
381 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); latin1Chars.push(String.fromCharCode(bite));
382 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }
383  
384 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); return latin1Chars.join('');
385 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); },
386  
387 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**
388 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Converts a Latin1 string to a word array.
389 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
390 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {string} latin1Str The Latin1 string.
391 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
392 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @return {WordArray} The word array.
393 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
394 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @static
395 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
396 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example
397 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
398 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
399 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */
400 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); parse: function (latin1Str) {
401 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Shortcut
402 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var latin1StrLength = latin1Str.length;
403  
404 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Convert
405 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var words = [];
406 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); for (var i = 0; i < latin1StrLength; i++) {
407 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
408 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }
409  
410 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); return new WordArray.init(words, latin1StrLength);
411 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }
412 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); };
413  
414 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**
415 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * UTF-8 encoding strategy.
416 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */
417 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var Utf8 = C_enc.Utf8 = {
418 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**
419 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Converts a word array to a UTF-8 string.
420 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
421 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {WordArray} wordArray The word array.
422 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
423 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @return {string} The UTF-8 string.
424 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
425 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @static
426 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
427 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example
428 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
429 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
430 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */
431 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); stringify: function (wordArray) {
432 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); try {
433 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); return decodeURIComponent(escape(Latin1.stringify(wordArray)));
434 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); } catch (e) {
435 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); throw new Error('Malformed UTF-8 data');
436 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }
437 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); },
438  
439 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**
440 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Converts a UTF-8 string to a word array.
441 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
442 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {string} utf8Str The UTF-8 string.
443 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
444 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @return {WordArray} The word array.
445 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
446 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @static
447 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
448 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example
449 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
450 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
451 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */
452 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); parse: function (utf8Str) {
453 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
454 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }
455 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); };
456  
457 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**
458 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Abstract buffered block algorithm template.
459 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
460 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * The property blockSize must be implemented in a concrete subtype.
461 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
462 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
463 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */
464 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
465 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**
466 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Resets this block algorithm's data buffer to its initial state.
467 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
468 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example
469 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
470 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * bufferedBlockAlgorithm.reset();
471 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */
472 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); reset: function () {
473 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Initial values
474 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); this._data = new WordArray.init();
475 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); this._nDataBytes = 0;
476 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); },
477  
478 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**
479 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Adds new data to this block algorithm's buffer.
480 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
481 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
482 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
483 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example
484 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
485 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * bufferedBlockAlgorithm._append('data');
486 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * bufferedBlockAlgorithm._append(wordArray);
487 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */
488 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); _append: function (data) {
489 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Convert string to WordArray, else assume WordArray already
490 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); if (typeof data == 'string') {
491 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); data = Utf8.parse(data);
492 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }
493  
494 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Append
495 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); this._data.concat(data);
496 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); this._nDataBytes += data.sigBytes;
497 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); },
498  
499 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**
500 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Processes available data blocks.
501 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
502 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
503 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
504 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
505 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
506 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @return {WordArray} The processed data.
507 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
508 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example
509 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *
510 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var processedData = bufferedBlockAlgorithm._process();
511 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var processedData = bufferedBlockAlgorithm._process(!!'flush');
512 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */
513 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); _process: function (doFlush) {
514 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Shortcuts
515 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var data = this._data;
516 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var dataWords = data.words;
517 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var dataSigBytes = data.sigBytes;
518 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var blockSize = this.blockSize;
519 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var blockSizeBytes = blockSize * 4;
520  
521 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Count blocks ready
522 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var nBlocksReady = dataSigBytes / blockSizeBytes;
523 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); if (doFlush) {
524 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Round up to include partial blocks
525 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); nBlocksReady = Math.ceil(nBlocksReady);
526 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); } else {
527 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Round down to include only full blocks,
528 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // less the number of blocks that must remain in the buffer
529 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
530 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }
531  
532 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Count words ready
533 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var nWordsReady = nBlocksReady * blockSize;
534  
535 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Count bytes ready
536 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
537  
538 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Process blocks
539 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); if (nWordsReady) {
540 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); for (var offset = 0; offset < nWordsReady; offset += blockSize) {
541 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Perform concrete-algorithm logic
542 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this._doProcessBlock(dataWords, offset);
543 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { }
544  
545 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Remove processed words
546 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { var processedWords = dataWords.splice(0, nWordsReady);
547 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { data.sigBytes -= nBytesReady;
548 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { }
549  
550 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Return processed words
551 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return new WordArray.init(processedWords, nBytesReady);
552 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },
553  
554 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**
555 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Creates a copy of this object.
556 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
557 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @return {Object} The clone.
558 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
559 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example
560 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
561 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var clone = bufferedBlockAlgorithm.clone();
562 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */
563 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { clone: function () {
564 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { var clone = Base.clone.call(this);
565 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { clone._data = this._data.clone();
566  
567 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return clone;
568 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },
569  
570 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { _minBufferSize: 0
571 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { });
572  
573 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**
574 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Abstract hasher template.
575 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
576 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
577 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */
578 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
579 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**
580 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Configuration options.
581 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */
582 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { cfg: Base.extend(),
583  
584 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**
585 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Initializes a newly created hasher.
586 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
587 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
588 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
589 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example
590 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
591 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var hasher = CryptoJS.algo.SHA256.create();
592 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */
593 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { init: function (cfg) {
594 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Apply config defaults
595 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this.cfg = this.cfg.extend(cfg);
596  
597 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Set initial values
598 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this.reset();
599 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },
600  
601 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**
602 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Resets this hasher to its initial state.
603 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
604 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example
605 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
606 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * hasher.reset();
607 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */
608 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { reset: function () {
609 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Reset data buffer
610 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { BufferedBlockAlgorithm.reset.call(this);
611  
612 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Perform concrete-hasher logic
613 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this._doReset();
614 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },
615  
616 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**
617 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Updates this hasher with a message.
618 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
619 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @param {WordArray|string} messageUpdate The message to append.
620 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
621 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @return {Hasher} This hasher.
622 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
623 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example
624 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
625 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * hasher.update('message');
626 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * hasher.update(wordArray);
627 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */
628 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { update: function (messageUpdate) {
629 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Append
630 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this._append(messageUpdate);
631  
632 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Update the hash
633 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this._process();
634  
635 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Chainable
636 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return this;
637 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },
638  
639 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**
640 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Finalizes the hash computation.
641 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Note that the finalize operation is effectively a destructive, read-once operation.
642 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
643 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @param {WordArray|string} messageUpdate (Optional) A final message update.
644 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
645 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @return {WordArray} The hash.
646 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
647 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example
648 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
649 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var hash = hasher.finalize();
650 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var hash = hasher.finalize('message');
651 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var hash = hasher.finalize(wordArray);
652 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */
653 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { finalize: function (messageUpdate) {
654 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Final message update
655 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { if (messageUpdate) {
656 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this._append(messageUpdate);
657 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { }
658  
659 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Perform concrete-hasher logic
660 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { var hash = this._doFinalize();
661  
662 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return hash;
663 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },
664  
665 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { blockSize: 512/32,
666  
667 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**
668 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Creates a shortcut function to a hasher's object interface.
669 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
670 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @param {Hasher} hasher The hasher to create a helper for.
671 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
672 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @return {Function} The shortcut function.
673 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
674 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @static
675 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
676 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example
677 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
678 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
679 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */
680 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { _createHelper: function (hasher) {
681 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return function (message, cfg) {
682 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return new hasher.init(cfg).finalize(message);
683 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { };
684 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },
685  
686 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**
687 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Creates a shortcut function to the HMAC's object interface.
688 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
689 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @param {Hasher} hasher The hasher to use in this HMAC helper.
690 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
691 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @return {Function} The shortcut function.
692 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
693 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @static
694 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
695 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example
696 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *
697 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
698 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */
699 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { _createHmacHelper: function (hasher) {
700 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return function (message, key) {
701 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return new C_algo.HMAC.init(hasher, key).finalize(message);
702 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { };
703 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { }
704 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { });
705  
706 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**
707 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Algorithm namespace.
708 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */
709 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { var C_algo = C.algo = {};
710  
711 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return C;
712 < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) {}(Math));