scratch – Blame information for rev 58

Subversion Repositories:
Rev:
Rev Author Line No. Line
58 office 1 (function e(t, n, r) {
2 function s(o, u) {
3 if (!n[o]) {
4 if (!t[o]) {
5 var a = typeof require == 'function' && require;
6 if (!u && a) {
7 return a(o, !0);
8 }
9 if (i) {
10 return i(o, !0);
11 }
12 var f = new Error('Cannot find module \'' + o + '\'');
13 throw f.code = 'MODULE_NOT_FOUND', f
14 }
15 var l = n[o] = {
16 exports: {}
17 };
18 t[o][0].call(l.exports, function(e) {
19 var n = t[o][1][e];
20 return s(n ? n : e);
21 }, l, l.exports, e, t, n, r);
22 }
23 return n[o].exports;
24 }
25 var i = typeof require == 'function' && require;
26 for (var o = 0; o < r.length; o++) {
27 s(r[o]);
28 }
29 return s;
30 })({
31 1: [function(require, module, exports) {
32 'use strict';
33  
34 /*
35 * Copyright © Jamie Mason, @fold_left,
36 * https://github.com/JamieMason
37 *
38 * Permission is hereby granted, free of charge, to any person
39 * obtaining a copy of this software and associated documentation files
40 * (the "Software"), to deal in the Software without restriction,
41 * including without limitation the rights to use, copy, modify, merge,
42 * publish, distribute, sublicense, and/or sell copies of the Software,
43 * and to permit persons to whom the Software is furnished to do so,
44 * subject to the following conditions:
45 *
46 * The above copyright notice and this permission notice shall be
47 * included in all copies or substantial portions of the Software.
48 *
49 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
50 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
51 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
52 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
53 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
54 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
55 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
56 * SOFTWARE.
57 */
58  
59 var factory = require('./lib/factory');
60  
61 var matchers = {
62 toBeAfter: require('./toBeAfter'),
63 toBeArray: require('./toBeArray'),
64 toBeArrayOfBooleans: require('./toBeArrayOfBooleans'),
65 toBeArrayOfNumbers: require('./toBeArrayOfNumbers'),
66 toBeArrayOfObjects: require('./toBeArrayOfObjects'),
67 toBeArrayOfSize: require('./toBeArrayOfSize'),
68 toBeArrayOfStrings: require('./toBeArrayOfStrings'),
69 toBeBefore: require('./toBeBefore'),
70 toBeBoolean: require('./toBeBoolean'),
71 toBeCalculable: require('./toBeCalculable'),
72 toBeDate: require('./toBeDate'),
73 toBeEmptyArray: require('./toBeEmptyArray'),
74 toBeEmptyObject: require('./toBeEmptyObject'),
75 toBeEmptyString: require('./toBeEmptyString'),
76 toBeEvenNumber: require('./toBeEvenNumber'),
77 toBeFalse: require('./toBeFalse'),
78 toBeFunction: require('./toBeFunction'),
79 toBeHtmlString: require('./toBeHtmlString'),
80 toBeIso8601: require('./toBeIso8601'),
81 toBeJsonString: require('./toBeJsonString'),
82 toBeLongerThan: require('./toBeLongerThan'),
83 toBeNonEmptyArray: require('./toBeNonEmptyArray'),
84 toBeNonEmptyObject: require('./toBeNonEmptyObject'),
85 toBeNonEmptyString: require('./toBeNonEmptyString'),
86 toBeNumber: require('./toBeNumber'),
87 toBeObject: require('./toBeObject'),
88 toBeOddNumber: require('./toBeOddNumber'),
89 toBeSameLengthAs: require('./toBeSameLengthAs'),
90 toBeShorterThan: require('./toBeShorterThan'),
91 toBeString: require('./toBeString'),
92 toBeTrue: require('./toBeTrue'),
93 toBeWhitespace: require('./toBeWhitespace'),
94 toBeWholeNumber: require('./toBeWholeNumber'),
95 toBeWithinRange: require('./toBeWithinRange'),
96 toEndWith: require('./toEndWith'),
97 toImplement: require('./toImplement'),
98 toStartWith: require('./toStartWith'),
99 toThrowAnyError: require('./toThrowAnyError'),
100 toThrowErrorOfType: require('./toThrowErrorOfType'),
101 toHaveArray: require('./toHaveArray'),
102 toHaveArrayOfBooleans: require('./toHaveArrayOfBooleans'),
103 toHaveArrayOfNumbers: require('./toHaveArrayOfNumbers'),
104 toHaveArrayOfObjects: require('./toHaveArrayOfObjects'),
105 toHaveArrayOfSize: require('./toHaveArrayOfSize'),
106 toHaveArrayOfStrings: require('./toHaveArrayOfStrings'),
107 toHaveBoolean: require('./toHaveBoolean'),
108 toHaveCalculable: require('./toHaveCalculable'),
109 toHaveDate: require('./toHaveDate'),
110 toHaveDateAfter: require('./toHaveDateAfter'),
111 toHaveDateBefore: require('./toHaveDateBefore'),
112 toHaveEmptyArray: require('./toHaveEmptyArray'),
113 toHaveEmptyObject: require('./toHaveEmptyObject'),
114 toHaveEmptyString: require('./toHaveEmptyString'),
115 toHaveEvenNumber: require('./toHaveEvenNumber'),
116 toHaveFalse: require('./toHaveFalse'),
117 toHaveHtmlString: require('./toHaveHtmlString'),
118 toHaveIso8601: require('./toHaveIso8601'),
119 toHaveJsonString: require('./toHaveJsonString'),
120 toHaveMember: require('./toHaveMember'),
121 toHaveMethod: require('./toHaveMethod'),
122 toHaveNonEmptyArray: require('./toHaveNonEmptyArray'),
123 toHaveNonEmptyObject: require('./toHaveNonEmptyObject'),
124 toHaveNonEmptyString: require('./toHaveNonEmptyString'),
125 toHaveNumber: require('./toHaveNumber'),
126 toHaveNumberWithinRange: require('./toHaveNumberWithinRange'),
127 toHaveObject: require('./toHaveObject'),
128 toHaveOddNumber: require('./toHaveOddNumber'),
129 toHaveString: require('./toHaveString'),
130 toHaveStringLongerThan: require('./toHaveStringLongerThan'),
131 toHaveStringSameLengthAs: require('./toHaveStringSameLengthAs'),
132 toHaveStringShorterThan: require('./toHaveStringShorterThan'),
133 toHaveTrue: require('./toHaveTrue'),
134 toHaveWhitespaceString: require('./toHaveWhitespaceString'),
135 toHaveWholeNumber: require('./toHaveWholeNumber')
136 };
137  
138 for (var matcherName in matchers) {
139 factory(matcherName, matchers[matcherName]);
140 }
141  
142 module.exports = matchers;
143  
144 }, {
145 './lib/factory': 3,
146 './toBeAfter': 10,
147 './toBeArray': 11,
148 './toBeArrayOfBooleans': 12,
149 './toBeArrayOfNumbers': 13,
150 './toBeArrayOfObjects': 14,
151 './toBeArrayOfSize': 15,
152 './toBeArrayOfStrings': 16,
153 './toBeBefore': 17,
154 './toBeBoolean': 18,
155 './toBeCalculable': 19,
156 './toBeDate': 20,
157 './toBeEmptyArray': 21,
158 './toBeEmptyObject': 22,
159 './toBeEmptyString': 23,
160 './toBeEvenNumber': 24,
161 './toBeFalse': 25,
162 './toBeFunction': 26,
163 './toBeHtmlString': 27,
164 './toBeIso8601': 28,
165 './toBeJsonString': 29,
166 './toBeLongerThan': 30,
167 './toBeNonEmptyArray': 31,
168 './toBeNonEmptyObject': 32,
169 './toBeNonEmptyString': 33,
170 './toBeNumber': 34,
171 './toBeObject': 35,
172 './toBeOddNumber': 36,
173 './toBeSameLengthAs': 37,
174 './toBeShorterThan': 38,
175 './toBeString': 39,
176 './toBeTrue': 40,
177 './toBeWhitespace': 41,
178 './toBeWholeNumber': 42,
179 './toBeWithinRange': 43,
180 './toEndWith': 44,
181 './toHaveArray': 45,
182 './toHaveArrayOfBooleans': 46,
183 './toHaveArrayOfNumbers': 47,
184 './toHaveArrayOfObjects': 48,
185 './toHaveArrayOfSize': 49,
186 './toHaveArrayOfStrings': 50,
187 './toHaveBoolean': 51,
188 './toHaveCalculable': 52,
189 './toHaveDate': 53,
190 './toHaveDateAfter': 54,
191 './toHaveDateBefore': 55,
192 './toHaveEmptyArray': 56,
193 './toHaveEmptyObject': 57,
194 './toHaveEmptyString': 58,
195 './toHaveEvenNumber': 59,
196 './toHaveFalse': 60,
197 './toHaveHtmlString': 61,
198 './toHaveIso8601': 62,
199 './toHaveJsonString': 63,
200 './toHaveMember': 64,
201 './toHaveMethod': 65,
202 './toHaveNonEmptyArray': 66,
203 './toHaveNonEmptyObject': 67,
204 './toHaveNonEmptyString': 68,
205 './toHaveNumber': 69,
206 './toHaveNumberWithinRange': 70,
207 './toHaveObject': 71,
208 './toHaveOddNumber': 72,
209 './toHaveString': 73,
210 './toHaveStringLongerThan': 74,
211 './toHaveStringSameLengthAs': 75,
212 './toHaveStringShorterThan': 76,
213 './toHaveTrue': 77,
214 './toHaveWhitespaceString': 78,
215 './toHaveWholeNumber': 79,
216 './toImplement': 80,
217 './toStartWith': 81,
218 './toThrowAnyError': 82,
219 './toThrowErrorOfType': 83
220 }],
221 2: [function(require, module, exports) {
222 'use strict';
223  
224 module.exports = every;
225  
226 function every(array, truthTest) {
227 for (var i = 0, len = array.length; i < len; i++) {
228 if (!truthTest(array[i])) {
229 return false;
230 }
231 }
232 return true;
233 }
234  
235 }, {}],
236 3: [function(require, module, exports) {
237 'use strict';
238  
239 var adapters = typeof jasmine.addMatchers === 'function' ?
240 require('./jasmine-v2') :
241 require('./jasmine-v1');
242  
243 module.exports = function(name, matcher) {
244 var adapter = adapters[matcher.length];
245 return adapter(name, matcher);
246 };
247  
248 }, {
249 './jasmine-v1': 4,
250 './jasmine-v2': 5
251 }],
252 4: [function(require, module, exports) {
253 'use strict';
254  
255 module.exports = {
256 1: createFactory(forActual),
257 2: createFactory(forActualAndExpected),
258 3: createFactory(forActualAndTwoExpected),
259 4: createFactory(forKeyAndActualAndTwoExpected)
260 };
261  
262 function createFactory(adapter) {
263 return function jasmineV1MatcherFactory(name, matcher) {
264 var matcherByName = new JasmineV1Matcher(name, adapter, matcher);
265 beforeEach(function() {
266 this.addMatchers(matcherByName);
267 });
268 return matcherByName;
269 };
270 }
271  
272 function JasmineV1Matcher(name, adapter, matcher) {
273 this[name] = adapter(name, matcher);
274 }
275  
276 function forActual(name, matcher) {
277 return function(optionalMessage) {
278 return matcher(this.actual, optionalMessage);
279 };
280 }
281  
282 function forActualAndExpected(name, matcher) {
283 return function(expected, optionalMessage) {
284 return matcher(expected, this.actual, optionalMessage);
285 };
286 }
287  
288 function forActualAndTwoExpected(name, matcher) {
289 return function(expected1, expected2, optionalMessage) {
290 return matcher(expected1, expected2, this.actual, optionalMessage);
291 };
292 }
293  
294 function forKeyAndActualAndTwoExpected(name, matcher) {
295 return function(key, expected1, expected2, optionalMessage) {
296 return matcher(key, expected1, expected2, this.actual, optionalMessage);
297 };
298 }
299  
300 }, {}],
301 5: [function(require, module, exports) {
302 'use strict';
303  
304 var matcherFactory = require('./matcherFactory');
305 var memberMatcherFactory = require('./memberMatcherFactory');
306  
307 module.exports = {
308 1: createFactory(getAdapter(1)),
309 2: createFactory(getAdapter(2)),
310 3: createFactory(getAdapter(3)),
311 4: createFactory(getAdapter(4))
312 };
313  
314 function createFactory(adapter) {
315 return function jasmineV2MatcherFactory(name, matcher) {
316 var matcherByName = new JasmineV2Matcher(name, adapter, matcher);
317 beforeEach(function() {
318 jasmine.addMatchers(matcherByName);
319 });
320 return matcherByName;
321 };
322 }
323  
324 function JasmineV2Matcher(name, adapter, matcher) {
325 this[name] = adapter(name, matcher);
326 }
327  
328 function getAdapter(argsCount) {
329 return function adapter(name, matcher) {
330 var factory = isMemberMatcher(name) ? memberMatcherFactory : matcherFactory;
331 return factory[argsCount](name, matcher);
332 };
333 }
334  
335 function isMemberMatcher(name) {
336 return name.search(/^toHave/) !== -1;
337 }
338  
339 }, {
340 './matcherFactory': 6,
341 './memberMatcherFactory': 7
342 }],
343 6: [function(require, module, exports) {
344 'use strict';
345  
346 module.exports = {
347 1: forActual,
348 2: forActualAndExpected,
349 3: forActualAndTwoExpected
350 };
351  
352 function forActual(name, matcher) {
353 return function(util) {
354 return {
355 compare: function(actual, optionalMessage) {
356 var passes = matcher(actual);
357 return {
358 pass: passes,
359 message: (
360 optionalMessage ?
361 util.buildFailureMessage(name, passes, actual, optionalMessage) :
362 util.buildFailureMessage(name, passes, actual)
363 )
364 };
365 }
366 };
367 };
368 }
369  
370 function forActualAndExpected(name, matcher) {
371 return function(util) {
372 return {
373 compare: function(actual, expected, optionalMessage) {
374 var passes = matcher(expected, actual);
375 return {
376 pass: passes,
377 message: (
378 optionalMessage ?
379 util.buildFailureMessage(name, passes, actual, expected, optionalMessage) :
380 util.buildFailureMessage(name, passes, actual, expected)
381 )
382 };
383 }
384 };
385 };
386 }
387  
388 function forActualAndTwoExpected(name, matcher) {
389 return function(util) {
390 return {
391 compare: function(actual, expected1, expected2, optionalMessage) {
392 var passes = matcher(expected1, expected2, actual);
393 return {
394 pass: passes,
395 message: (
396 optionalMessage ?
397 util.buildFailureMessage(name, passes, actual, expected1, expected2, optionalMessage) :
398 util.buildFailureMessage(name, passes, actual, expected1, expected2)
399 )
400 };
401 }
402 };
403 };
404 }
405  
406 }, {}],
407 7: [function(require, module, exports) {
408 'use strict';
409  
410 module.exports = {
411 2: forKeyAndActual,
412 3: forKeyAndActualAndExpected,
413 4: forKeyAndActualAndTwoExpected
414 };
415  
416 function forKeyAndActual(name, matcher) {
417 return function(util) {
418 return {
419 compare: function(actual, key, optionalMessage) {
420 var passes = matcher(key, actual);
421 return {
422 pass: passes,
423 message: (
424 optionalMessage ?
425 util.buildFailureMessage(name, passes, actual, optionalMessage) :
426 util.buildFailureMessage(name, passes, actual)
427 )
428 };
429 }
430 };
431 };
432 }
433  
434 function forKeyAndActualAndExpected(name, matcher) {
435 return function(util) {
436 return {
437 compare: function(actual, key, expected, optionalMessage) {
438 var passes = matcher(key, expected, actual);
439 return {
440 pass: passes,
441 message: (
442 optionalMessage ?
443 util.buildFailureMessage(name, passes, actual, expected, optionalMessage) :
444 util.buildFailureMessage(name, passes, actual, expected)
445 )
446 };
447 }
448 };
449 };
450 }
451  
452 function forKeyAndActualAndTwoExpected(name, matcher) {
453 return function(util) {
454 return {
455 compare: function(actual, key, expected1, expected2, optionalMessage) {
456 var passes = matcher(key, expected1, expected2, actual);
457 return {
458 pass: passes,
459 message: (
460 optionalMessage ?
461 util.buildFailureMessage(name, passes, actual, expected1, expected2, optionalMessage) :
462 util.buildFailureMessage(name, passes, actual, expected1, expected2)
463 )
464 };
465 }
466 };
467 };
468 }
469  
470 }, {}],
471 8: [function(require, module, exports) {
472 'use strict';
473  
474 module.exports = is;
475  
476 function is(value, type) {
477 return Object.prototype.toString.call(value) === '[object ' + type + ']';
478 }
479  
480 }, {}],
481 9: [function(require, module, exports) {
482 'use strict';
483  
484 module.exports = keys;
485  
486 function keys(object) {
487 var list = [];
488 for (var key in object) {
489 if (object.hasOwnProperty(key)) {
490 list.push(key);
491 }
492 }
493 return list;
494 }
495  
496 }, {}],
497 10: [function(require, module, exports) {
498 'use strict';
499  
500 var toBeBefore = require('./toBeBefore');
501  
502 module.exports = toBeAfter;
503  
504 function toBeAfter(otherDate, actual) {
505 return toBeBefore(actual, otherDate);
506 }
507  
508 }, {
509 './toBeBefore': 17
510 }],
511 11: [function(require, module, exports) {
512 'use strict';
513  
514 var is = require('./lib/is');
515  
516 module.exports = toBeArray;
517  
518 function toBeArray(actual) {
519 return is(actual, 'Array');
520 }
521  
522 }, {
523 './lib/is': 8
524 }],
525 12: [function(require, module, exports) {
526 'use strict';
527  
528 var every = require('./lib/every');
529 var toBeArray = require('./toBeArray');
530 var toBeBoolean = require('./toBeBoolean');
531  
532 module.exports = toBeArrayOfBooleans;
533  
534 function toBeArrayOfBooleans(actual) {
535 return toBeArray(actual) &&
536 every(actual, toBeBoolean);
537 }
538  
539 }, {
540 './lib/every': 2,
541 './toBeArray': 11,
542 './toBeBoolean': 18
543 }],
544 13: [function(require, module, exports) {
545 'use strict';
546  
547 var every = require('./lib/every');
548 var toBeArray = require('./toBeArray');
549 var toBeNumber = require('./toBeNumber');
550  
551 module.exports = toBeArrayOfBooleans;
552  
553 function toBeArrayOfBooleans(actual) {
554 return toBeArray(actual) &&
555 every(actual, toBeNumber);
556 }
557  
558 }, {
559 './lib/every': 2,
560 './toBeArray': 11,
561 './toBeNumber': 34
562 }],
563 14: [function(require, module, exports) {
564 'use strict';
565  
566 var every = require('./lib/every');
567 var toBeArray = require('./toBeArray');
568 var toBeObject = require('./toBeObject');
569  
570 module.exports = toBeArrayOfBooleans;
571  
572 function toBeArrayOfBooleans(actual) {
573 return toBeArray(actual) &&
574 every(actual, toBeObject);
575 }
576  
577 }, {
578 './lib/every': 2,
579 './toBeArray': 11,
580 './toBeObject': 35
581 }],
582 15: [function(require, module, exports) {
583 'use strict';
584  
585 var toBeArray = require('./toBeArray');
586  
587 module.exports = toBeArrayOfSize;
588  
589 function toBeArrayOfSize(size, actual) {
590 return toBeArray(actual) &&
591 actual.length === size;
592 }
593  
594 }, {
595 './toBeArray': 11
596 }],
597 16: [function(require, module, exports) {
598 'use strict';
599  
600 var every = require('./lib/every');
601 var toBeArray = require('./toBeArray');
602 var toBeString = require('./toBeString');
603  
604 module.exports = toBeArrayOfStrings;
605  
606 function toBeArrayOfStrings(actual) {
607 return toBeArray(actual) &&
608 every(actual, toBeString);
609 }
610  
611 }, {
612 './lib/every': 2,
613 './toBeArray': 11,
614 './toBeString': 39
615 }],
616 17: [function(require, module, exports) {
617 'use strict';
618  
619 var toBeDate = require('./toBeDate');
620  
621 module.exports = toBeBefore;
622  
623 function toBeBefore(otherDate, actual) {
624 return toBeDate(actual) &&
625 toBeDate(otherDate) &&
626 actual.getTime() < otherDate.getTime();
627 }
628  
629 }, {
630 './toBeDate': 20
631 }],
632 18: [function(require, module, exports) {
633 'use strict';
634  
635 var is = require('./lib/is');
636  
637 module.exports = toBeBoolean;
638  
639 function toBeBoolean(actual) {
640 return is(actual, 'Boolean');
641 }
642  
643 }, {
644 './lib/is': 8
645 }],
646 19: [function(require, module, exports) {
647 'use strict';
648  
649 module.exports = toBeCalculable;
650  
651 // Assert subject can be used in Mathemetic
652 // calculations despite not being a Number,
653 // for example `"1" * "2" === 2` whereas
654 // `"wut?" * 2 === NaN`.
655 function toBeCalculable(actual) {
656 return !isNaN(actual * 2);
657 }
658  
659 }, {}],
660 20: [function(require, module, exports) {
661 'use strict';
662  
663 var is = require('./lib/is');
664  
665 module.exports = toBeDate;
666  
667 function toBeDate(actual) {
668 return is(actual, 'Date');
669 }
670  
671 }, {
672 './lib/is': 8
673 }],
674 21: [function(require, module, exports) {
675 'use strict';
676  
677 var toBeArrayOfSize = require('./toBeArrayOfSize');
678  
679 module.exports = toBeEmptyArray;
680  
681 function toBeEmptyArray(actual) {
682 return toBeArrayOfSize(0, actual);
683 }
684  
685 }, {
686 './toBeArrayOfSize': 15
687 }],
688 22: [function(require, module, exports) {
689 'use strict';
690  
691 var keys = require('./lib/keys');
692 var is = require('./lib/is');
693  
694 module.exports = toBeEmptyObject;
695  
696 function toBeEmptyObject(actual) {
697 return is(actual, 'Object') &&
698 keys(actual).length === 0;
699 }
700  
701 }, {
702 './lib/is': 8,
703 './lib/keys': 9
704 }],
705 23: [function(require, module, exports) {
706 'use strict';
707  
708 module.exports = toBeEmptyString;
709  
710 function toBeEmptyString(actual) {
711 return actual === '';
712 }
713  
714 }, {}],
715 24: [function(require, module, exports) {
716 'use strict';
717  
718 var toBeNumber = require('./toBeNumber');
719  
720 module.exports = toBeEvenNumber;
721  
722 function toBeEvenNumber(actual) {
723 return toBeNumber(actual) &&
724 actual % 2 === 0;
725 }
726  
727 }, {
728 './toBeNumber': 34
729 }],
730 25: [function(require, module, exports) {
731 'use strict';
732  
733 var is = require('./lib/is');
734  
735 module.exports = toBeFalse;
736  
737 function toBeFalse(actual) {
738 return actual === false ||
739 is(actual, 'Boolean') &&
740 !actual.valueOf();
741 }
742  
743 }, {
744 './lib/is': 8
745 }],
746 26: [function(require, module, exports) {
747 'use strict';
748  
749 module.exports = toBeFunction;
750  
751 function toBeFunction(actual) {
752 return typeof actual === 'function';
753 }
754  
755 }, {}],
756 27: [function(require, module, exports) {
757 'use strict';
758  
759 var toBeString = require('./toBeString');
760  
761 module.exports = toBeHtmlString;
762  
763 function toBeHtmlString(actual) {
764 // < start with opening tag "<"
765 // ( start group 1
766 // "[^"]*" allow string in "double quotes"
767 // | OR
768 // '[^']*' allow string in "single quotes"
769 // | OR
770 // [^'">] cant contains one single quotes, double quotes and ">"
771 // ) end group 1
772 // * 0 or more
773 // > end with closing tag ">"
774 return toBeString(actual) &&
775 actual.search(/<("[^"]*"|'[^']*'|[^'">])*>/) !== -1;
776 <("[^"]*"|'[^']*'|[^'"> }
777  
778 <("[^"]*"|'[^']*'|[^'"> }, {
779 <("[^"]*"|'[^']*'|[^'"> './toBeString': 39
780 <("[^"]*"|'[^']*'|[^'"> }],
781 <("[^"]*"|'[^']*'|[^'"> 28: [function(require, module, exports) {
782 <("[^"]*"|'[^']*'|[^'"> 'use strict';
783  
784 <("[^"]*"|'[^']*'|[^'"> var toBeString = require('./toBeString');
785  
786 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeIso8601;
787  
788 <("[^"]*"|'[^']*'|[^'"> function toBeIso8601(actual) {
789  
790 <("[^"]*"|'[^']*'|[^'"> if (!toBeString(actual)) {
791 <("[^"]*"|'[^']*'|[^'"> return false;
792 <("[^"]*"|'[^']*'|[^'"> }
793  
794 <("[^"]*"|'[^']*'|[^'"> if (
795 <("[^"]*"|'[^']*'|[^'"> isIso8601(actual, [
796 <("[^"]*"|'[^']*'|[^'"> // 2013-07-08
797 <("[^"]*"|'[^']*'|[^'"> 4, '-', 2, '-', 2
798 <("[^"]*"|'[^']*'|[^'"> ]) || isIso8601(actual, [
799 <("[^"]*"|'[^']*'|[^'"> // 2013-07-08T07:29
800 <("[^"]*"|'[^']*'|[^'"> 4, '-', 2, '-', 2, 'T', 2, ':', 2
801 <("[^"]*"|'[^']*'|[^'"> ]) || isIso8601(actual, [
802 <("[^"]*"|'[^']*'|[^'"> // 2013-07-08T07:29:15
803 <("[^"]*"|'[^']*'|[^'"> 4, '-', 2, '-', 2, 'T', 2, ':', 2, ':', 2
804 <("[^"]*"|'[^']*'|[^'"> ]) || isIso8601(actual, [
805 <("[^"]*"|'[^']*'|[^'"> // 2013-07-08T07:29:15.863
806 <("[^"]*"|'[^']*'|[^'"> 4, '-', 2, '-', 2, 'T', 2, ':', 2, ':', 2, '.', 3
807 <("[^"]*"|'[^']*'|[^'"> ]) || isIso8601(actual, [
808 <("[^"]*"|'[^']*'|[^'"> // 2013-07-08T07:29:15.863Z
809 <("[^"]*"|'[^']*'|[^'"> 4, '-', 2, '-', 2, 'T', 2, ':', 2, ':', 2, '.', 3, 'Z'
810 <("[^"]*"|'[^']*'|[^'"> ])
811 <("[^"]*"|'[^']*'|[^'"> ) {
812 <("[^"]*"|'[^']*'|[^'"> return new Date(actual).toString() !== 'Invalid Date';
813 <("[^"]*"|'[^']*'|[^'"> }
814  
815 <("[^"]*"|'[^']*'|[^'"> return false;
816  
817 <("[^"]*"|'[^']*'|[^'"> }
818  
819 <("[^"]*"|'[^']*'|[^'"> function isIso8601(string, pattern) {
820 <("[^"]*"|'[^']*'|[^'"> var returnValue = string.search(
821 <("[^"]*"|'[^']*'|[^'"> new RegExp('^' + pattern.map(function(term) {
822 <("[^"]*"|'[^']*'|[^'"> if (term === '-') {
823 <("[^"]*"|'[^']*'|[^'"> return '\\-';
824 <("[^"]*"|'[^']*'|[^'"> } else if (typeof term === 'string') {
825 <("[^"]*"|'[^']*'|[^'"> return term;
826 <("[^"]*"|'[^']*'|[^'"> } else {
827 <("[^"]*"|'[^']*'|[^'"> return '([0-9]{' + term + '})';
828 <("[^"]*"|'[^']*'|[^'"> }
829 <("[^"]*"|'[^']*'|[^'"> }).join('') + '$')
830 <("[^"]*"|'[^']*'|[^'"> ) !== -1;
831 <("[^"]*"|'[^']*'|[^'"> return returnValue;
832 <("[^"]*"|'[^']*'|[^'"> }
833  
834 <("[^"]*"|'[^']*'|[^'"> }, {
835 <("[^"]*"|'[^']*'|[^'"> './toBeString': 39
836 <("[^"]*"|'[^']*'|[^'"> }],
837 <("[^"]*"|'[^']*'|[^'"> 29: [function(require, module, exports) {
838 <("[^"]*"|'[^']*'|[^'"> 'use strict';
839  
840 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeJsonString;
841  
842 <("[^"]*"|'[^']*'|[^'"> function toBeJsonString(actual) {
843 <("[^"]*"|'[^']*'|[^'"> var isParseable;
844 <("[^"]*"|'[^']*'|[^'"> var json;
845 <("[^"]*"|'[^']*'|[^'"> try {
846 <("[^"]*"|'[^']*'|[^'"> json = JSON.parse(actual);
847 <("[^"]*"|'[^']*'|[^'"> } catch (e) {
848 <("[^"]*"|'[^']*'|[^'"> isParseable = false;
849 <("[^"]*"|'[^']*'|[^'"> }
850 <("[^"]*"|'[^']*'|[^'"> return isParseable !== false &&
851 <("[^"]*"|'[^']*'|[^'"> json !== null;
852 <("[^"]*"|'[^']*'|[^'"> }
853  
854 <("[^"]*"|'[^']*'|[^'"> }, {}],
855 <("[^"]*"|'[^']*'|[^'"> 30: [function(require, module, exports) {
856 <("[^"]*"|'[^']*'|[^'"> 'use strict';
857  
858 <("[^"]*"|'[^']*'|[^'"> var toBeString = require('./toBeString');
859  
860 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeLongerThan;
861  
862 <("[^"]*"|'[^']*'|[^'"> function toBeLongerThan(otherString, actual) {
863 <("[^"]*"|'[^']*'|[^'"> return toBeString(actual) &&
864 <("[^"]*"|'[^']*'|[^'"> toBeString(otherString) &&
865 <("[^"]*"|'[^']*'|[^'"> actual.length > otherString.length;
866 <("[^"]*"|'[^']*'|[^'"> }
867  
868 <("[^"]*"|'[^']*'|[^'"> }, {
869 <("[^"]*"|'[^']*'|[^'"> './toBeString': 39
870 <("[^"]*"|'[^']*'|[^'"> }],
871 <("[^"]*"|'[^']*'|[^'"> 31: [function(require, module, exports) {
872 <("[^"]*"|'[^']*'|[^'"> 'use strict';
873  
874 <("[^"]*"|'[^']*'|[^'"> var is = require('./lib/is');
875  
876 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeNonEmptyArray;
877  
878 <("[^"]*"|'[^']*'|[^'"> function toBeNonEmptyArray(actual) {
879 <("[^"]*"|'[^']*'|[^'"> return is(actual, 'Array') &&
880 <("[^"]*"|'[^']*'|[^'"> actual.length > 0;
881 <("[^"]*"|'[^']*'|[^'"> }
882  
883 <("[^"]*"|'[^']*'|[^'"> }, {
884 <("[^"]*"|'[^']*'|[^'"> './lib/is': 8
885 <("[^"]*"|'[^']*'|[^'"> }],
886 <("[^"]*"|'[^']*'|[^'"> 32: [function(require, module, exports) {
887 <("[^"]*"|'[^']*'|[^'"> 'use strict';
888  
889 <("[^"]*"|'[^']*'|[^'"> var keys = require('./lib/keys');
890 <("[^"]*"|'[^']*'|[^'"> var is = require('./lib/is');
891  
892 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeNonEmptyObject;
893  
894 <("[^"]*"|'[^']*'|[^'"> function toBeNonEmptyObject(actual) {
895 <("[^"]*"|'[^']*'|[^'"> return is(actual, 'Object') &&
896 <("[^"]*"|'[^']*'|[^'"> keys(actual).length > 0;
897 <("[^"]*"|'[^']*'|[^'"> }
898  
899 <("[^"]*"|'[^']*'|[^'"> }, {
900 <("[^"]*"|'[^']*'|[^'"> './lib/is': 8,
901 <("[^"]*"|'[^']*'|[^'"> './lib/keys': 9
902 <("[^"]*"|'[^']*'|[^'"> }],
903 <("[^"]*"|'[^']*'|[^'"> 33: [function(require, module, exports) {
904 <("[^"]*"|'[^']*'|[^'"> 'use strict';
905  
906 <("[^"]*"|'[^']*'|[^'"> var toBeString = require('./toBeString');
907  
908 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeNonEmptyString;
909  
910 <("[^"]*"|'[^']*'|[^'"> function toBeNonEmptyString(actual) {
911 <("[^"]*"|'[^']*'|[^'"> return toBeString(actual) &&
912 <("[^"]*"|'[^']*'|[^'"> actual.length > 0;
913 <("[^"]*"|'[^']*'|[^'"> }
914  
915 <("[^"]*"|'[^']*'|[^'"> }, {
916 <("[^"]*"|'[^']*'|[^'"> './toBeString': 39
917 <("[^"]*"|'[^']*'|[^'"> }],
918 <("[^"]*"|'[^']*'|[^'"> 34: [function(require, module, exports) {
919 <("[^"]*"|'[^']*'|[^'"> 'use strict';
920  
921 <("[^"]*"|'[^']*'|[^'"> var is = require('./lib/is');
922  
923 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeNumber;
924  
925 <("[^"]*"|'[^']*'|[^'"> function toBeNumber(actual) {
926 <("[^"]*"|'[^']*'|[^'"> return !isNaN(parseFloat(actual)) &&
927 <("[^"]*"|'[^']*'|[^'"> !is(actual, 'String');
928 <("[^"]*"|'[^']*'|[^'"> }
929  
930 <("[^"]*"|'[^']*'|[^'"> }, {
931 <("[^"]*"|'[^']*'|[^'"> './lib/is': 8
932 <("[^"]*"|'[^']*'|[^'"> }],
933 <("[^"]*"|'[^']*'|[^'"> 35: [function(require, module, exports) {
934 <("[^"]*"|'[^']*'|[^'"> 'use strict';
935  
936 <("[^"]*"|'[^']*'|[^'"> var is = require('./lib/is');
937  
938 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeObject;
939  
940 <("[^"]*"|'[^']*'|[^'"> function toBeObject(actual) {
941 <("[^"]*"|'[^']*'|[^'"> return is(actual, 'Object');
942 <("[^"]*"|'[^']*'|[^'"> }
943  
944 <("[^"]*"|'[^']*'|[^'"> }, {
945 <("[^"]*"|'[^']*'|[^'"> './lib/is': 8
946 <("[^"]*"|'[^']*'|[^'"> }],
947 <("[^"]*"|'[^']*'|[^'"> 36: [function(require, module, exports) {
948 <("[^"]*"|'[^']*'|[^'"> 'use strict';
949  
950 <("[^"]*"|'[^']*'|[^'"> var toBeNumber = require('./toBeNumber');
951  
952 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeOddNumber;
953  
954 <("[^"]*"|'[^']*'|[^'"> function toBeOddNumber(actual) {
955 <("[^"]*"|'[^']*'|[^'"> return toBeNumber(actual) &&
956 <("[^"]*"|'[^']*'|[^'"> actual % 2 !== 0;
957 <("[^"]*"|'[^']*'|[^'"> }
958  
959 <("[^"]*"|'[^']*'|[^'"> }, {
960 <("[^"]*"|'[^']*'|[^'"> './toBeNumber': 34
961 <("[^"]*"|'[^']*'|[^'"> }],
962 <("[^"]*"|'[^']*'|[^'"> 37: [function(require, module, exports) {
963 <("[^"]*"|'[^']*'|[^'"> 'use strict';
964  
965 <("[^"]*"|'[^']*'|[^'"> var toBeString = require('./toBeString');
966  
967 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeSameLengthAs;
968  
969 <("[^"]*"|'[^']*'|[^'"> function toBeSameLengthAs(otherString, actual) {
970 <("[^"]*"|'[^']*'|[^'"> return toBeString(actual) &&
971 <("[^"]*"|'[^']*'|[^'"> toBeString(otherString) &&
972 <("[^"]*"|'[^']*'|[^'"> actual.length === otherString.length;
973 <("[^"]*"|'[^']*'|[^'"> }
974  
975 <("[^"]*"|'[^']*'|[^'"> }, {
976 <("[^"]*"|'[^']*'|[^'"> './toBeString': 39
977 <("[^"]*"|'[^']*'|[^'"> }],
978 <("[^"]*"|'[^']*'|[^'"> 38: [function(require, module, exports) {
979 <("[^"]*"|'[^']*'|[^'"> 'use strict';
980  
981 <("[^"]*"|'[^']*'|[^'"> var toBeString = require('./toBeString');
982  
983 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeShorterThan;
984  
985 <("[^"]*"|'[^']*'|[^'"> function toBeShorterThan(otherString, actual) {
986 <("[^"]*"|'[^']*'|[^'"> return toBeString(actual) &&
987 <("[^"]*"|'[^']*'|[^'"> toBeString(otherString) &&
988 <("[^"]*"|'[^']*'|[^'"> actual.length < otherString.length;
989 <("[^"]*"|'[^']*'|[^'"> }
990  
991 <("[^"]*"|'[^']*'|[^'"> }, {
992 <("[^"]*"|'[^']*'|[^'"> './toBeString': 39
993 <("[^"]*"|'[^']*'|[^'"> }],
994 <("[^"]*"|'[^']*'|[^'"> 39: [function(require, module, exports) {
995 <("[^"]*"|'[^']*'|[^'"> 'use strict';
996  
997 <("[^"]*"|'[^']*'|[^'"> var is = require('./lib/is');
998  
999 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeString;
1000  
1001 <("[^"]*"|'[^']*'|[^'"> function toBeString(actual) {
1002 <("[^"]*"|'[^']*'|[^'"> return is(actual, 'String');
1003 <("[^"]*"|'[^']*'|[^'"> }
1004  
1005 <("[^"]*"|'[^']*'|[^'"> }, {
1006 <("[^"]*"|'[^']*'|[^'"> './lib/is': 8
1007 <("[^"]*"|'[^']*'|[^'"> }],
1008 <("[^"]*"|'[^']*'|[^'"> 40: [function(require, module, exports) {
1009 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1010  
1011 <("[^"]*"|'[^']*'|[^'"> var is = require('./lib/is');
1012  
1013 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeTrue;
1014  
1015 <("[^"]*"|'[^']*'|[^'"> function toBeTrue(actual) {
1016 <("[^"]*"|'[^']*'|[^'"> return actual === true ||
1017 <("[^"]*"|'[^']*'|[^'"> is(actual, 'Boolean') &&
1018 <("[^"]*"|'[^']*'|[^'"> actual.valueOf();
1019 <("[^"]*"|'[^']*'|[^'"> }
1020  
1021 <("[^"]*"|'[^']*'|[^'"> }, {
1022 <("[^"]*"|'[^']*'|[^'"> './lib/is': 8
1023 <("[^"]*"|'[^']*'|[^'"> }],
1024 <("[^"]*"|'[^']*'|[^'"> 41: [function(require, module, exports) {
1025 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1026  
1027 <("[^"]*"|'[^']*'|[^'"> var toBeString = require('./toBeString');
1028  
1029 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeWhitespace;
1030  
1031 <("[^"]*"|'[^']*'|[^'"> function toBeWhitespace(actual) {
1032 <("[^"]*"|'[^']*'|[^'"> return toBeString(actual) &&
1033 <("[^"]*"|'[^']*'|[^'"> actual.search(/\S/) === -1;
1034 <("[^"]*"|'[^']*'|[^'"> }
1035  
1036 <("[^"]*"|'[^']*'|[^'"> }, {
1037 <("[^"]*"|'[^']*'|[^'"> './toBeString': 39
1038 <("[^"]*"|'[^']*'|[^'"> }],
1039 <("[^"]*"|'[^']*'|[^'"> 42: [function(require, module, exports) {
1040 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1041  
1042 <("[^"]*"|'[^']*'|[^'"> var toBeNumber = require('./toBeNumber');
1043  
1044 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeWholeNumber;
1045  
1046 <("[^"]*"|'[^']*'|[^'"> function toBeWholeNumber(actual) {
1047 <("[^"]*"|'[^']*'|[^'"> return toBeNumber(actual) && (
1048 <("[^"]*"|'[^']*'|[^'"> actual === 0 || actual % 1 === 0
1049 <("[^"]*"|'[^']*'|[^'"> );
1050 <("[^"]*"|'[^']*'|[^'"> }
1051  
1052 <("[^"]*"|'[^']*'|[^'"> }, {
1053 <("[^"]*"|'[^']*'|[^'"> './toBeNumber': 34
1054 <("[^"]*"|'[^']*'|[^'"> }],
1055 <("[^"]*"|'[^']*'|[^'"> 43: [function(require, module, exports) {
1056 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1057  
1058 <("[^"]*"|'[^']*'|[^'"> var toBeNumber = require('./toBeNumber');
1059  
1060 <("[^"]*"|'[^']*'|[^'"> module.exports = toBeWithinRange;
1061  
1062 <("[^"]*"|'[^']*'|[^'"> function toBeWithinRange(floor, ceiling, actual) {
1063 <("[^"]*"|'[^']*'|[^'"> return toBeNumber(actual) &&
1064 <("[^"]*"|'[^']*'|[^'"> actual >= floor &&
1065 <("[^"]*"|'[^']*'|[^'"> actual <= ceiling;
1066 <("[^"]*"|'[^']*'|[^'"> }
1067  
1068 <("[^"]*"|'[^']*'|[^'"> }, {
1069 <("[^"]*"|'[^']*'|[^'"> './toBeNumber': 34
1070 <("[^"]*"|'[^']*'|[^'"> }],
1071 <("[^"]*"|'[^']*'|[^'"> 44: [function(require, module, exports) {
1072 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1073  
1074 <("[^"]*"|'[^']*'|[^'"> var toBeNonEmptyString = require('./toBeNonEmptyString');
1075  
1076 <("[^"]*"|'[^']*'|[^'"> module.exports = toEndWith;
1077  
1078 <("[^"]*"|'[^']*'|[^'"> function toEndWith(subString, actual) {
1079 <("[^"]*"|'[^']*'|[^'"> if (!toBeNonEmptyString(actual) || !toBeNonEmptyString(subString)) {
1080 <("[^"]*"|'[^']*'|[^'"> return false;
1081 <("[^"]*"|'[^']*'|[^'"> }
1082 <("[^"]*"|'[^']*'|[^'"> return actual.slice(actual.length - subString.length, actual.length) === subString;
1083 <("[^"]*"|'[^']*'|[^'"> }
1084  
1085 <("[^"]*"|'[^']*'|[^'"> }, {
1086 <("[^"]*"|'[^']*'|[^'"> './toBeNonEmptyString': 33
1087 <("[^"]*"|'[^']*'|[^'"> }],
1088 <("[^"]*"|'[^']*'|[^'"> 45: [function(require, module, exports) {
1089 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1090  
1091 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1092 <("[^"]*"|'[^']*'|[^'"> var toBeArray = require('./toBeArray');
1093  
1094 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveArray;
1095  
1096 <("[^"]*"|'[^']*'|[^'"> function toHaveArray(key, actual) {
1097 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1098 <("[^"]*"|'[^']*'|[^'"> toBeArray(actual[key]);
1099 <("[^"]*"|'[^']*'|[^'"> }
1100  
1101 <("[^"]*"|'[^']*'|[^'"> }, {
1102 <("[^"]*"|'[^']*'|[^'"> './toBeArray': 11,
1103 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1104 <("[^"]*"|'[^']*'|[^'"> }],
1105 <("[^"]*"|'[^']*'|[^'"> 46: [function(require, module, exports) {
1106 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1107  
1108 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1109 <("[^"]*"|'[^']*'|[^'"> var toBeArrayOfBooleans = require('./toBeArrayOfBooleans');
1110  
1111 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveArrayOfBooleans;
1112  
1113 <("[^"]*"|'[^']*'|[^'"> function toHaveArrayOfBooleans(key, actual) {
1114 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1115 <("[^"]*"|'[^']*'|[^'"> toBeArrayOfBooleans(actual[key]);
1116 <("[^"]*"|'[^']*'|[^'"> }
1117  
1118 <("[^"]*"|'[^']*'|[^'"> }, {
1119 <("[^"]*"|'[^']*'|[^'"> './toBeArrayOfBooleans': 12,
1120 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1121 <("[^"]*"|'[^']*'|[^'"> }],
1122 <("[^"]*"|'[^']*'|[^'"> 47: [function(require, module, exports) {
1123 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1124  
1125 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1126 <("[^"]*"|'[^']*'|[^'"> var toBeArrayOfNumbers = require('./toBeArrayOfNumbers');
1127  
1128 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveArrayOfNumbers;
1129  
1130 <("[^"]*"|'[^']*'|[^'"> function toHaveArrayOfNumbers(key, actual) {
1131 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1132 <("[^"]*"|'[^']*'|[^'"> toBeArrayOfNumbers(actual[key]);
1133 <("[^"]*"|'[^']*'|[^'"> }
1134  
1135 <("[^"]*"|'[^']*'|[^'"> }, {
1136 <("[^"]*"|'[^']*'|[^'"> './toBeArrayOfNumbers': 13,
1137 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1138 <("[^"]*"|'[^']*'|[^'"> }],
1139 <("[^"]*"|'[^']*'|[^'"> 48: [function(require, module, exports) {
1140 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1141  
1142 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1143 <("[^"]*"|'[^']*'|[^'"> var toBeArrayOfObjects = require('./toBeArrayOfObjects');
1144  
1145 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveArrayOfObjects;
1146  
1147 <("[^"]*"|'[^']*'|[^'"> function toHaveArrayOfObjects(key, actual) {
1148 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1149 <("[^"]*"|'[^']*'|[^'"> toBeArrayOfObjects(actual[key]);
1150 <("[^"]*"|'[^']*'|[^'"> }
1151  
1152 <("[^"]*"|'[^']*'|[^'"> }, {
1153 <("[^"]*"|'[^']*'|[^'"> './toBeArrayOfObjects': 14,
1154 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1155 <("[^"]*"|'[^']*'|[^'"> }],
1156 <("[^"]*"|'[^']*'|[^'"> 49: [function(require, module, exports) {
1157 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1158  
1159 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1160 <("[^"]*"|'[^']*'|[^'"> var toBeArrayOfSize = require('./toBeArrayOfSize');
1161  
1162 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveArrayOfSize;
1163  
1164 <("[^"]*"|'[^']*'|[^'"> function toHaveArrayOfSize(key, size, actual) {
1165 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1166 <("[^"]*"|'[^']*'|[^'"> toBeArrayOfSize(size, actual[key]);
1167 <("[^"]*"|'[^']*'|[^'"> }
1168  
1169 <("[^"]*"|'[^']*'|[^'"> }, {
1170 <("[^"]*"|'[^']*'|[^'"> './toBeArrayOfSize': 15,
1171 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1172 <("[^"]*"|'[^']*'|[^'"> }],
1173 <("[^"]*"|'[^']*'|[^'"> 50: [function(require, module, exports) {
1174 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1175  
1176 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1177 <("[^"]*"|'[^']*'|[^'"> var toBeArrayOfStrings = require('./toBeArrayOfStrings');
1178  
1179 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveArrayOfStrings;
1180  
1181 <("[^"]*"|'[^']*'|[^'"> function toHaveArrayOfStrings(key, actual) {
1182 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1183 <("[^"]*"|'[^']*'|[^'"> toBeArrayOfStrings(actual[key]);
1184 <("[^"]*"|'[^']*'|[^'"> }
1185  
1186 <("[^"]*"|'[^']*'|[^'"> }, {
1187 <("[^"]*"|'[^']*'|[^'"> './toBeArrayOfStrings': 16,
1188 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1189 <("[^"]*"|'[^']*'|[^'"> }],
1190 <("[^"]*"|'[^']*'|[^'"> 51: [function(require, module, exports) {
1191 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1192  
1193 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1194 <("[^"]*"|'[^']*'|[^'"> var toBeBoolean = require('./toBeBoolean');
1195  
1196 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveBoolean;
1197  
1198 <("[^"]*"|'[^']*'|[^'"> function toHaveBoolean(key, actual) {
1199 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1200 <("[^"]*"|'[^']*'|[^'"> toBeBoolean(actual[key]);
1201 <("[^"]*"|'[^']*'|[^'"> }
1202  
1203 <("[^"]*"|'[^']*'|[^'"> }, {
1204 <("[^"]*"|'[^']*'|[^'"> './toBeBoolean': 18,
1205 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1206 <("[^"]*"|'[^']*'|[^'"> }],
1207 <("[^"]*"|'[^']*'|[^'"> 52: [function(require, module, exports) {
1208 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1209  
1210 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1211 <("[^"]*"|'[^']*'|[^'"> var toBeCalculable = require('./toBeCalculable');
1212  
1213 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveCalculable;
1214  
1215 <("[^"]*"|'[^']*'|[^'"> function toHaveCalculable(key, actual) {
1216 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1217 <("[^"]*"|'[^']*'|[^'"> toBeCalculable(actual[key]);
1218 <("[^"]*"|'[^']*'|[^'"> }
1219  
1220 <("[^"]*"|'[^']*'|[^'"> }, {
1221 <("[^"]*"|'[^']*'|[^'"> './toBeCalculable': 19,
1222 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1223 <("[^"]*"|'[^']*'|[^'"> }],
1224 <("[^"]*"|'[^']*'|[^'"> 53: [function(require, module, exports) {
1225 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1226  
1227 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1228 <("[^"]*"|'[^']*'|[^'"> var toBeDate = require('./toBeDate');
1229  
1230 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveDate;
1231  
1232 <("[^"]*"|'[^']*'|[^'"> function toHaveDate(key, actual) {
1233 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1234 <("[^"]*"|'[^']*'|[^'"> toBeDate(actual[key]);
1235 <("[^"]*"|'[^']*'|[^'"> }
1236  
1237 <("[^"]*"|'[^']*'|[^'"> }, {
1238 <("[^"]*"|'[^']*'|[^'"> './toBeDate': 20,
1239 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1240 <("[^"]*"|'[^']*'|[^'"> }],
1241 <("[^"]*"|'[^']*'|[^'"> 54: [function(require, module, exports) {
1242 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1243  
1244 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1245 <("[^"]*"|'[^']*'|[^'"> var toBeAfter = require('./toBeAfter');
1246  
1247 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveDateAfter;
1248  
1249 <("[^"]*"|'[^']*'|[^'"> function toHaveDateAfter(key, date, actual) {
1250 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1251 <("[^"]*"|'[^']*'|[^'"> toBeAfter(date, actual[key]);
1252 <("[^"]*"|'[^']*'|[^'"> }
1253  
1254 <("[^"]*"|'[^']*'|[^'"> }, {
1255 <("[^"]*"|'[^']*'|[^'"> './toBeAfter': 10,
1256 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1257 <("[^"]*"|'[^']*'|[^'"> }],
1258 <("[^"]*"|'[^']*'|[^'"> 55: [function(require, module, exports) {
1259 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1260  
1261 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1262 <("[^"]*"|'[^']*'|[^'"> var toBeBefore = require('./toBeBefore');
1263  
1264 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveDateBefore;
1265  
1266 <("[^"]*"|'[^']*'|[^'"> function toHaveDateBefore(key, date, actual) {
1267 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1268 <("[^"]*"|'[^']*'|[^'"> toBeBefore(date, actual[key]);
1269 <("[^"]*"|'[^']*'|[^'"> }
1270  
1271 <("[^"]*"|'[^']*'|[^'"> }, {
1272 <("[^"]*"|'[^']*'|[^'"> './toBeBefore': 17,
1273 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1274 <("[^"]*"|'[^']*'|[^'"> }],
1275 <("[^"]*"|'[^']*'|[^'"> 56: [function(require, module, exports) {
1276 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1277  
1278 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1279 <("[^"]*"|'[^']*'|[^'"> var toBeEmptyArray = require('./toBeEmptyArray');
1280  
1281 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveEmptyArray;
1282  
1283 <("[^"]*"|'[^']*'|[^'"> function toHaveEmptyArray(key, actual) {
1284 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1285 <("[^"]*"|'[^']*'|[^'"> toBeEmptyArray(actual[key]);
1286 <("[^"]*"|'[^']*'|[^'"> }
1287  
1288 <("[^"]*"|'[^']*'|[^'"> }, {
1289 <("[^"]*"|'[^']*'|[^'"> './toBeEmptyArray': 21,
1290 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1291 <("[^"]*"|'[^']*'|[^'"> }],
1292 <("[^"]*"|'[^']*'|[^'"> 57: [function(require, module, exports) {
1293 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1294  
1295 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1296 <("[^"]*"|'[^']*'|[^'"> var toBeEmptyObject = require('./toBeEmptyObject');
1297  
1298 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveEmptyObject;
1299  
1300 <("[^"]*"|'[^']*'|[^'"> function toHaveEmptyObject(key, actual) {
1301 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1302 <("[^"]*"|'[^']*'|[^'"> toBeEmptyObject(actual[key]);
1303 <("[^"]*"|'[^']*'|[^'"> }
1304  
1305 <("[^"]*"|'[^']*'|[^'"> }, {
1306 <("[^"]*"|'[^']*'|[^'"> './toBeEmptyObject': 22,
1307 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1308 <("[^"]*"|'[^']*'|[^'"> }],
1309 <("[^"]*"|'[^']*'|[^'"> 58: [function(require, module, exports) {
1310 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1311  
1312 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1313 <("[^"]*"|'[^']*'|[^'"> var toBeEmptyString = require('./toBeEmptyString');
1314  
1315 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveEmptyString;
1316  
1317 <("[^"]*"|'[^']*'|[^'"> function toHaveEmptyString(key, actual) {
1318 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1319 <("[^"]*"|'[^']*'|[^'"> toBeEmptyString(actual[key]);
1320 <("[^"]*"|'[^']*'|[^'"> }
1321  
1322 <("[^"]*"|'[^']*'|[^'"> }, {
1323 <("[^"]*"|'[^']*'|[^'"> './toBeEmptyString': 23,
1324 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1325 <("[^"]*"|'[^']*'|[^'"> }],
1326 <("[^"]*"|'[^']*'|[^'"> 59: [function(require, module, exports) {
1327 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1328  
1329 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1330 <("[^"]*"|'[^']*'|[^'"> var toBeEvenNumber = require('./toBeEvenNumber');
1331  
1332 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveEvenNumber;
1333  
1334 <("[^"]*"|'[^']*'|[^'"> function toHaveEvenNumber(key, actual) {
1335 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1336 <("[^"]*"|'[^']*'|[^'"> toBeEvenNumber(actual[key]);
1337 <("[^"]*"|'[^']*'|[^'"> }
1338  
1339 <("[^"]*"|'[^']*'|[^'"> }, {
1340 <("[^"]*"|'[^']*'|[^'"> './toBeEvenNumber': 24,
1341 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1342 <("[^"]*"|'[^']*'|[^'"> }],
1343 <("[^"]*"|'[^']*'|[^'"> 60: [function(require, module, exports) {
1344 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1345  
1346 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1347 <("[^"]*"|'[^']*'|[^'"> var toBeFalse = require('./toBeFalse');
1348  
1349 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveFalse;
1350  
1351 <("[^"]*"|'[^']*'|[^'"> function toHaveFalse(key, actual) {
1352 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1353 <("[^"]*"|'[^']*'|[^'"> toBeFalse(actual[key]);
1354 <("[^"]*"|'[^']*'|[^'"> }
1355  
1356 <("[^"]*"|'[^']*'|[^'"> }, {
1357 <("[^"]*"|'[^']*'|[^'"> './toBeFalse': 25,
1358 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1359 <("[^"]*"|'[^']*'|[^'"> }],
1360 <("[^"]*"|'[^']*'|[^'"> 61: [function(require, module, exports) {
1361 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1362  
1363 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1364 <("[^"]*"|'[^']*'|[^'"> var toBeHtmlString = require('./toBeHtmlString');
1365  
1366 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveHtmlString;
1367  
1368 <("[^"]*"|'[^']*'|[^'"> function toHaveHtmlString(key, actual) {
1369 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1370 <("[^"]*"|'[^']*'|[^'"> toBeHtmlString(actual[key]);
1371 <("[^"]*"|'[^']*'|[^'"> }
1372  
1373 <("[^"]*"|'[^']*'|[^'"> }, {
1374 <("[^"]*"|'[^']*'|[^'"> './toBeHtmlString': 27,
1375 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1376 <("[^"]*"|'[^']*'|[^'"> }],
1377 <("[^"]*"|'[^']*'|[^'"> 62: [function(require, module, exports) {
1378 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1379  
1380 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1381 <("[^"]*"|'[^']*'|[^'"> var toBeIso8601 = require('./toBeIso8601');
1382  
1383 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveIso8601;
1384  
1385 <("[^"]*"|'[^']*'|[^'"> function toHaveIso8601(key, actual) {
1386 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1387 <("[^"]*"|'[^']*'|[^'"> toBeIso8601(actual[key]);
1388 <("[^"]*"|'[^']*'|[^'"> }
1389  
1390 <("[^"]*"|'[^']*'|[^'"> }, {
1391 <("[^"]*"|'[^']*'|[^'"> './toBeIso8601': 28,
1392 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1393 <("[^"]*"|'[^']*'|[^'"> }],
1394 <("[^"]*"|'[^']*'|[^'"> 63: [function(require, module, exports) {
1395 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1396  
1397 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1398 <("[^"]*"|'[^']*'|[^'"> var toBeJsonString = require('./toBeJsonString');
1399  
1400 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveJsonString;
1401  
1402 <("[^"]*"|'[^']*'|[^'"> function toHaveJsonString(key, actual) {
1403 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1404 <("[^"]*"|'[^']*'|[^'"> toBeJsonString(actual[key]);
1405 <("[^"]*"|'[^']*'|[^'"> }
1406  
1407 <("[^"]*"|'[^']*'|[^'"> }, {
1408 <("[^"]*"|'[^']*'|[^'"> './toBeJsonString': 29,
1409 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1410 <("[^"]*"|'[^']*'|[^'"> }],
1411 <("[^"]*"|'[^']*'|[^'"> 64: [function(require, module, exports) {
1412 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1413  
1414 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1415 <("[^"]*"|'[^']*'|[^'"> var toBeString = require('./toBeString');
1416  
1417 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveMember;
1418  
1419 <("[^"]*"|'[^']*'|[^'"> function toHaveMember(key, actual) {
1420 <("[^"]*"|'[^']*'|[^'"> return toBeString(key) &&
1421 <("[^"]*"|'[^']*'|[^'"> toBeObject(actual) &&
1422 <("[^"]*"|'[^']*'|[^'"> key in actual;
1423 <("[^"]*"|'[^']*'|[^'"> }
1424  
1425 <("[^"]*"|'[^']*'|[^'"> }, {
1426 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35,
1427 <("[^"]*"|'[^']*'|[^'"> './toBeString': 39
1428 <("[^"]*"|'[^']*'|[^'"> }],
1429 <("[^"]*"|'[^']*'|[^'"> 65: [function(require, module, exports) {
1430 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1431  
1432 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1433 <("[^"]*"|'[^']*'|[^'"> var toBeFunction = require('./toBeFunction');
1434  
1435 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveMethod;
1436  
1437 <("[^"]*"|'[^']*'|[^'"> function toHaveMethod(key, actual) {
1438 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1439 <("[^"]*"|'[^']*'|[^'"> toBeFunction(actual[key]);
1440 <("[^"]*"|'[^']*'|[^'"> }
1441  
1442 <("[^"]*"|'[^']*'|[^'"> }, {
1443 <("[^"]*"|'[^']*'|[^'"> './toBeFunction': 26,
1444 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1445 <("[^"]*"|'[^']*'|[^'"> }],
1446 <("[^"]*"|'[^']*'|[^'"> 66: [function(require, module, exports) {
1447 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1448  
1449 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1450 <("[^"]*"|'[^']*'|[^'"> var toBeNonEmptyArray = require('./toBeNonEmptyArray');
1451  
1452 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveNonEmptyArray;
1453  
1454 <("[^"]*"|'[^']*'|[^'"> function toHaveNonEmptyArray(key, actual) {
1455 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1456 <("[^"]*"|'[^']*'|[^'"> toBeNonEmptyArray(actual[key]);
1457 <("[^"]*"|'[^']*'|[^'"> }
1458  
1459 <("[^"]*"|'[^']*'|[^'"> }, {
1460 <("[^"]*"|'[^']*'|[^'"> './toBeNonEmptyArray': 31,
1461 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1462 <("[^"]*"|'[^']*'|[^'"> }],
1463 <("[^"]*"|'[^']*'|[^'"> 67: [function(require, module, exports) {
1464 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1465  
1466 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1467 <("[^"]*"|'[^']*'|[^'"> var toBeNonEmptyObject = require('./toBeNonEmptyObject');
1468  
1469 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveNonEmptyObject;
1470  
1471 <("[^"]*"|'[^']*'|[^'"> function toHaveNonEmptyObject(key, actual) {
1472 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1473 <("[^"]*"|'[^']*'|[^'"> toBeNonEmptyObject(actual[key]);
1474 <("[^"]*"|'[^']*'|[^'"> }
1475  
1476 <("[^"]*"|'[^']*'|[^'"> }, {
1477 <("[^"]*"|'[^']*'|[^'"> './toBeNonEmptyObject': 32,
1478 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1479 <("[^"]*"|'[^']*'|[^'"> }],
1480 <("[^"]*"|'[^']*'|[^'"> 68: [function(require, module, exports) {
1481 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1482  
1483 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1484 <("[^"]*"|'[^']*'|[^'"> var toBeNonEmptyString = require('./toBeNonEmptyString');
1485  
1486 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveNonEmptyString;
1487  
1488 <("[^"]*"|'[^']*'|[^'"> function toHaveNonEmptyString(key, actual) {
1489 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1490 <("[^"]*"|'[^']*'|[^'"> toBeNonEmptyString(actual[key]);
1491 <("[^"]*"|'[^']*'|[^'"> }
1492  
1493 <("[^"]*"|'[^']*'|[^'"> }, {
1494 <("[^"]*"|'[^']*'|[^'"> './toBeNonEmptyString': 33,
1495 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1496 <("[^"]*"|'[^']*'|[^'"> }],
1497 <("[^"]*"|'[^']*'|[^'"> 69: [function(require, module, exports) {
1498 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1499  
1500 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1501 <("[^"]*"|'[^']*'|[^'"> var toBeNumber = require('./toBeNumber');
1502  
1503 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveNumber;
1504  
1505 <("[^"]*"|'[^']*'|[^'"> function toHaveNumber(key, actual) {
1506 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1507 <("[^"]*"|'[^']*'|[^'"> toBeNumber(actual[key]);
1508 <("[^"]*"|'[^']*'|[^'"> }
1509  
1510 <("[^"]*"|'[^']*'|[^'"> }, {
1511 <("[^"]*"|'[^']*'|[^'"> './toBeNumber': 34,
1512 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1513 <("[^"]*"|'[^']*'|[^'"> }],
1514 <("[^"]*"|'[^']*'|[^'"> 70: [function(require, module, exports) {
1515 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1516  
1517 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1518 <("[^"]*"|'[^']*'|[^'"> var toBeWithinRange = require('./toBeWithinRange');
1519  
1520 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveNumberWithinRange;
1521  
1522 <("[^"]*"|'[^']*'|[^'"> function toHaveNumberWithinRange(key, floor, ceiling, actual) {
1523 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1524 <("[^"]*"|'[^']*'|[^'"> toBeWithinRange(floor, ceiling, actual[key]);
1525 <("[^"]*"|'[^']*'|[^'"> }
1526  
1527 <("[^"]*"|'[^']*'|[^'"> }, {
1528 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35,
1529 <("[^"]*"|'[^']*'|[^'"> './toBeWithinRange': 43
1530 <("[^"]*"|'[^']*'|[^'"> }],
1531 <("[^"]*"|'[^']*'|[^'"> 71: [function(require, module, exports) {
1532 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1533  
1534 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1535  
1536 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveObject;
1537  
1538 <("[^"]*"|'[^']*'|[^'"> function toHaveObject(key, actual) {
1539 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1540 <("[^"]*"|'[^']*'|[^'"> toBeObject(actual[key]);
1541 <("[^"]*"|'[^']*'|[^'"> }
1542  
1543 <("[^"]*"|'[^']*'|[^'"> }, {
1544 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1545 <("[^"]*"|'[^']*'|[^'"> }],
1546 <("[^"]*"|'[^']*'|[^'"> 72: [function(require, module, exports) {
1547 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1548  
1549 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1550 <("[^"]*"|'[^']*'|[^'"> var toBeOddNumber = require('./toBeOddNumber');
1551  
1552 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveOddNumber;
1553  
1554 <("[^"]*"|'[^']*'|[^'"> function toHaveOddNumber(key, actual) {
1555 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1556 <("[^"]*"|'[^']*'|[^'"> toBeOddNumber(actual[key]);
1557 <("[^"]*"|'[^']*'|[^'"> }
1558  
1559 <("[^"]*"|'[^']*'|[^'"> }, {
1560 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35,
1561 <("[^"]*"|'[^']*'|[^'"> './toBeOddNumber': 36
1562 <("[^"]*"|'[^']*'|[^'"> }],
1563 <("[^"]*"|'[^']*'|[^'"> 73: [function(require, module, exports) {
1564 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1565  
1566 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1567 <("[^"]*"|'[^']*'|[^'"> var toBeString = require('./toBeString');
1568  
1569 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveString;
1570  
1571 <("[^"]*"|'[^']*'|[^'"> function toHaveString(key, actual) {
1572 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1573 <("[^"]*"|'[^']*'|[^'"> toBeString(actual[key]);
1574 <("[^"]*"|'[^']*'|[^'"> }
1575  
1576 <("[^"]*"|'[^']*'|[^'"> }, {
1577 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35,
1578 <("[^"]*"|'[^']*'|[^'"> './toBeString': 39
1579 <("[^"]*"|'[^']*'|[^'"> }],
1580 <("[^"]*"|'[^']*'|[^'"> 74: [function(require, module, exports) {
1581 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1582  
1583 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1584 <("[^"]*"|'[^']*'|[^'"> var toBeLongerThan = require('./toBeLongerThan');
1585  
1586 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveStringLongerThan;
1587  
1588 <("[^"]*"|'[^']*'|[^'"> function toHaveStringLongerThan(key, other, actual) {
1589 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1590 <("[^"]*"|'[^']*'|[^'"> toBeLongerThan(other, actual[key]);
1591 <("[^"]*"|'[^']*'|[^'"> }
1592  
1593 <("[^"]*"|'[^']*'|[^'"> }, {
1594 <("[^"]*"|'[^']*'|[^'"> './toBeLongerThan': 30,
1595 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1596 <("[^"]*"|'[^']*'|[^'"> }],
1597 <("[^"]*"|'[^']*'|[^'"> 75: [function(require, module, exports) {
1598 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1599  
1600 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1601 <("[^"]*"|'[^']*'|[^'"> var toBeSameLengthAs = require('./toBeSameLengthAs');
1602  
1603 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveStringSameLengthAs;
1604  
1605 <("[^"]*"|'[^']*'|[^'"> function toHaveStringSameLengthAs(key, other, actual) {
1606 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1607 <("[^"]*"|'[^']*'|[^'"> toBeSameLengthAs(other, actual[key]);
1608 <("[^"]*"|'[^']*'|[^'"> }
1609  
1610 <("[^"]*"|'[^']*'|[^'"> }, {
1611 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35,
1612 <("[^"]*"|'[^']*'|[^'"> './toBeSameLengthAs': 37
1613 <("[^"]*"|'[^']*'|[^'"> }],
1614 <("[^"]*"|'[^']*'|[^'"> 76: [function(require, module, exports) {
1615 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1616  
1617 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1618 <("[^"]*"|'[^']*'|[^'"> var toBeShorterThan = require('./toBeShorterThan');
1619  
1620 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveStringShorterThan;
1621  
1622 <("[^"]*"|'[^']*'|[^'"> function toHaveStringShorterThan(key, other, actual) {
1623 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1624 <("[^"]*"|'[^']*'|[^'"> toBeShorterThan(other, actual[key]);
1625 <("[^"]*"|'[^']*'|[^'"> }
1626  
1627 <("[^"]*"|'[^']*'|[^'"> }, {
1628 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35,
1629 <("[^"]*"|'[^']*'|[^'"> './toBeShorterThan': 38
1630 <("[^"]*"|'[^']*'|[^'"> }],
1631 <("[^"]*"|'[^']*'|[^'"> 77: [function(require, module, exports) {
1632 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1633  
1634 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1635 <("[^"]*"|'[^']*'|[^'"> var toBeTrue = require('./toBeTrue');
1636  
1637 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveTrue;
1638  
1639 <("[^"]*"|'[^']*'|[^'"> function toHaveTrue(key, actual) {
1640 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1641 <("[^"]*"|'[^']*'|[^'"> toBeTrue(actual[key]);
1642 <("[^"]*"|'[^']*'|[^'"> }
1643  
1644 <("[^"]*"|'[^']*'|[^'"> }, {
1645 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35,
1646 <("[^"]*"|'[^']*'|[^'"> './toBeTrue': 40
1647 <("[^"]*"|'[^']*'|[^'"> }],
1648 <("[^"]*"|'[^']*'|[^'"> 78: [function(require, module, exports) {
1649 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1650  
1651 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1652 <("[^"]*"|'[^']*'|[^'"> var toBeWhitespace = require('./toBeWhitespace');
1653  
1654 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveWhitespaceString;
1655  
1656 <("[^"]*"|'[^']*'|[^'"> function toHaveWhitespaceString(key, actual) {
1657 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1658 <("[^"]*"|'[^']*'|[^'"> toBeWhitespace(actual[key]);
1659 <("[^"]*"|'[^']*'|[^'"> }
1660  
1661 <("[^"]*"|'[^']*'|[^'"> }, {
1662 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35,
1663 <("[^"]*"|'[^']*'|[^'"> './toBeWhitespace': 41
1664 <("[^"]*"|'[^']*'|[^'"> }],
1665 <("[^"]*"|'[^']*'|[^'"> 79: [function(require, module, exports) {
1666 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1667  
1668 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1669 <("[^"]*"|'[^']*'|[^'"> var toBeWholeNumber = require('./toBeWholeNumber');
1670  
1671 <("[^"]*"|'[^']*'|[^'"> module.exports = toHaveWholeNumber;
1672  
1673 <("[^"]*"|'[^']*'|[^'"> function toHaveWholeNumber(key, actual) {
1674 <("[^"]*"|'[^']*'|[^'"> return toBeObject(actual) &&
1675 <("[^"]*"|'[^']*'|[^'"> toBeWholeNumber(actual[key]);
1676 <("[^"]*"|'[^']*'|[^'"> }
1677  
1678 <("[^"]*"|'[^']*'|[^'"> }, {
1679 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35,
1680 <("[^"]*"|'[^']*'|[^'"> './toBeWholeNumber': 42
1681 <("[^"]*"|'[^']*'|[^'"> }],
1682 <("[^"]*"|'[^']*'|[^'"> 80: [function(require, module, exports) {
1683 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1684  
1685 <("[^"]*"|'[^']*'|[^'"> var toBeObject = require('./toBeObject');
1686  
1687 <("[^"]*"|'[^']*'|[^'"> module.exports = toImplement;
1688  
1689 <("[^"]*"|'[^']*'|[^'"> function toImplement(api, actual) {
1690 <("[^"]*"|'[^']*'|[^'"> return toBeObject(api) &&
1691 <("[^"]*"|'[^']*'|[^'"> toBeObject(actual) &&
1692 <("[^"]*"|'[^']*'|[^'"> featuresAll(api, actual);
1693 <("[^"]*"|'[^']*'|[^'"> }
1694  
1695 <("[^"]*"|'[^']*'|[^'"> function featuresAll(api, actual) {
1696 <("[^"]*"|'[^']*'|[^'"> for (var key in api) {
1697 <("[^"]*"|'[^']*'|[^'"> if (api.hasOwnProperty(key) &&
1698 <("[^"]*"|'[^']*'|[^'"> key in actual === false) {
1699 <("[^"]*"|'[^']*'|[^'"> return false;
1700 <("[^"]*"|'[^']*'|[^'"> }
1701 <("[^"]*"|'[^']*'|[^'"> }
1702 <("[^"]*"|'[^']*'|[^'"> return true;
1703 <("[^"]*"|'[^']*'|[^'"> }
1704  
1705 <("[^"]*"|'[^']*'|[^'"> }, {
1706 <("[^"]*"|'[^']*'|[^'"> './toBeObject': 35
1707 <("[^"]*"|'[^']*'|[^'"> }],
1708 <("[^"]*"|'[^']*'|[^'"> 81: [function(require, module, exports) {
1709 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1710  
1711 <("[^"]*"|'[^']*'|[^'"> var toBeNonEmptyString = require('./toBeNonEmptyString');
1712  
1713 <("[^"]*"|'[^']*'|[^'"> module.exports = toStartWith;
1714  
1715 <("[^"]*"|'[^']*'|[^'"> function toStartWith(subString, actual) {
1716 <("[^"]*"|'[^']*'|[^'"> if (!toBeNonEmptyString(actual) || !toBeNonEmptyString(subString)) {
1717 <("[^"]*"|'[^']*'|[^'"> return false;
1718 <("[^"]*"|'[^']*'|[^'"> }
1719 <("[^"]*"|'[^']*'|[^'"> return actual.slice(0, subString.length) === subString;
1720 <("[^"]*"|'[^']*'|[^'"> }
1721  
1722 <("[^"]*"|'[^']*'|[^'"> }, {
1723 <("[^"]*"|'[^']*'|[^'"> './toBeNonEmptyString': 33
1724 <("[^"]*"|'[^']*'|[^'"> }],
1725 <("[^"]*"|'[^']*'|[^'"> 82: [function(require, module, exports) {
1726 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1727  
1728 <("[^"]*"|'[^']*'|[^'"> module.exports = toThrowAnyError;
1729  
1730 <("[^"]*"|'[^']*'|[^'"> function toThrowAnyError(actual) {
1731 <("[^"]*"|'[^']*'|[^'"> var threwError = false;
1732 <("[^"]*"|'[^']*'|[^'"> try {
1733 <("[^"]*"|'[^']*'|[^'"> actual();
1734 <("[^"]*"|'[^']*'|[^'"> } catch (e) {
1735 <("[^"]*"|'[^']*'|[^'"> threwError = true;
1736 <("[^"]*"|'[^']*'|[^'"> }
1737 <("[^"]*"|'[^']*'|[^'"> return threwError;
1738 <("[^"]*"|'[^']*'|[^'"> }
1739  
1740 <("[^"]*"|'[^']*'|[^'"> }, {}],
1741 <("[^"]*"|'[^']*'|[^'"> 83: [function(require, module, exports) {
1742 <("[^"]*"|'[^']*'|[^'"> 'use strict';
1743  
1744 <("[^"]*"|'[^']*'|[^'"> module.exports = toThrowErrorOfType;
1745  
1746 <("[^"]*"|'[^']*'|[^'"> function toThrowErrorOfType(type, actual) {
1747 <("[^"]*"|'[^']*'|[^'"> var threwErrorOfType = false;
1748 <("[^"]*"|'[^']*'|[^'"> try {
1749 <("[^"]*"|'[^']*'|[^'"> actual();
1750 <("[^"]*"|'[^']*'|[^'"> } catch (e) {
1751 <("[^"]*"|'[^']*'|[^'"> threwErrorOfType = (e.name === type);
1752 <("[^"]*"|'[^']*'|[^'"> }
1753 <("[^"]*"|'[^']*'|[^'"> return threwErrorOfType;
1754 <("[^"]*"|'[^']*'|[^'"> }
1755  
1756 <("[^"]*"|'[^']*'|[^'"> }, {}]
1757 <("[^"]*"|'[^']*'|[^'">}, {}, [1]);