├── .gitignore
├── test
    ├── fontloader-test.js
    ├── assets
    │   ├── subset.ttf
    │   ├── subset.woff
    │   ├── sourcesanspro-regular.ttf
    │   └── sourcesanspro-regular.woff
    ├── helper.js
    ├── index.html
    ├── deps.js
    ├── fontface-test.js
    └── fontfaceset-test.js
├── src
    ├── binarydata.js
    ├── fontfacesource.js
    ├── fontfacesetloadstatus.js
    ├── fontfaceloadstatus.js
    ├── fontfacedescriptors.js
    ├── fontformat.js
    ├── fontfaceset.js
    └── fontface.js
├── polyfill.js
├── .travis.yml
├── package.json
├── vendor
    ├── bramstein
    │   └── promise.min.js
    ├── google
    │   └── base.js
    └── sunesimonsen
    │   └── unexpected.js
├── Gruntfile.js
├── browsers.json
├── README.md
└── fontloader.js


/.gitignore:
--------------------------------------------------------------------------------
1 | build
2 | node_modules
3 | 


--------------------------------------------------------------------------------
/test/fontloader-test.js:
--------------------------------------------------------------------------------
1 | describe('fontloader', function () {
2 | 
3 | });
4 | 


--------------------------------------------------------------------------------
/test/assets/subset.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bramstein/fontloader/HEAD/test/assets/subset.ttf


--------------------------------------------------------------------------------
/test/assets/subset.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bramstein/fontloader/HEAD/test/assets/subset.woff


--------------------------------------------------------------------------------
/test/assets/sourcesanspro-regular.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bramstein/fontloader/HEAD/test/assets/sourcesanspro-regular.ttf


--------------------------------------------------------------------------------
/test/assets/sourcesanspro-regular.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bramstein/fontloader/HEAD/test/assets/sourcesanspro-regular.woff


--------------------------------------------------------------------------------
/src/binarydata.js:
--------------------------------------------------------------------------------
1 | goog.provide('fl.BinaryData');
2 | 
3 | /**
4 |  * @typedef {ArrayBuffer|ArrayBufferView}
5 |  */
6 | fl.BinaryData;
7 | 


--------------------------------------------------------------------------------
/src/fontfacesource.js:
--------------------------------------------------------------------------------
 1 | goog.provide('fl.FontFaceSource');
 2 | 
 3 | /**
 4 |  * @typedef {{
 5 |  *  url: string,
 6 |  *  format: string
 7 |  * }}
 8 |  */
 9 | fl.FontFaceSource;
10 | 


--------------------------------------------------------------------------------
/src/fontfacesetloadstatus.js:
--------------------------------------------------------------------------------
 1 | goog.provide('fl.FontFaceSetLoadStatus');
 2 | 
 3 | /**
 4 |  * @enum {string}
 5 |  */
 6 | fl.FontFaceSetLoadStatus = {
 7 |   LOADED: 'loaded',
 8 |   LOADING: 'loading'
 9 | };
10 | 


--------------------------------------------------------------------------------
/src/fontfaceloadstatus.js:
--------------------------------------------------------------------------------
 1 | goog.provide('fl.FontFaceLoadStatus');
 2 | 
 3 | /**
 4 |  * @enum {string}
 5 |  */
 6 | fl.FontFaceLoadStatus = {
 7 |   UNLOADED: "unloaded",
 8 |   LOADING: "loading",
 9 |   LOADED: "loaded",
10 |   ERROR: "error"
11 | };
12 | 


--------------------------------------------------------------------------------
/test/helper.js:
--------------------------------------------------------------------------------
 1 | window.loadStylesheet = function (href) {
 2 |   var link = document.createElement('link');
 3 | 
 4 |   link.rel = 'stylesheet';
 5 |   link.href = href;
 6 | 
 7 |   document.getElementsByTagName('head')[0].appendChild(link);
 8 | 
 9 |   return link;
10 | };
11 | 


--------------------------------------------------------------------------------
/polyfill.js:
--------------------------------------------------------------------------------
 1 | goog.provide('fontloader');
 2 | 
 3 | goog.require('fl.FontFace');
 4 | goog.require('fl.FontFaceSet');
 5 | 
 6 | if (!window['FontFace']) {
 7 |   window['FontFace'] = fl.FontFace;
 8 |   window['FontFace']['prototype']['load'] = fl.FontFace.prototype.load;
 9 | 
10 |   document['fonts'] = new fl.FontFaceSet();
11 | }
12 | 


--------------------------------------------------------------------------------
/src/fontfacedescriptors.js:
--------------------------------------------------------------------------------
 1 | goog.provide('fl.FontFaceDescriptors');
 2 | 
 3 | /**
 4 |  * @typedef {{
 5 |  *   style: string,
 6 |  *   weight: string,
 7 |  *   stretch: string,
 8 |  *   display: string,
 9 |  *   unicodeRange: string,
10 |  *   variant: string,
11 |  *   featureSettings: string
12 |  * }}
13 |  */
14 | fl.FontFaceDescriptors;
15 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | before_install:
2 |   - npm install -g grunt-cli
3 |   - wget https://s3.amazonaws.com/travis-phantomjs/phantomjs-2.0.0-ubuntu-12.04.tar.bz2
4 |   - tar -xjf phantomjs-2.0.0-ubuntu-12.04.tar.bz2
5 |   - sudo mv /usr/local/phantomjs/bin/phantomjs /usr/local/phantomjs/bin/phantomjs1
6 |   - sudo mv phantomjs /usr/local/phantomjs/bin/phantomjs
7 | language: node_js
8 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "fontloader",
 3 |   "version": "1.2.7",
 4 |   "description": "A polyfill for the FontLoader interface",
 5 |   "directories": {
 6 |     "test": "test"
 7 |   },
 8 |   "repository": "https://github.com/bramstein/fontloader.git",
 9 |   "keywords": [
10 |     "fontloader",
11 |     "fonts",
12 |     "font",
13 |     "font-face"
14 |   ],
15 |   "author": "Bram Stein <b.l.stein@gmail.com> (http://www.bramstein.com/)",
16 |   "license": "Apache 2.0",
17 |   "devDependencies": {
18 |     "mocha": "=2.2.5",
19 |     "sinon": "=1.14.1",
20 |     "grunt": "=0.4.5",
21 |     "grunt-contrib-clean": "=0.6.0",
22 |     "grunt-contrib-jshint": "=0.11.2",
23 |     "google-closure-compiler": "^20160911.0.0",
24 |     "grunt-exec": "~0.4.6",
25 |     "extend": "^2.0.1",
26 |     "unexpected": "^7.5.0",
27 |     "mocha-phantomjs-core": "^0.2.0",
28 |     "grunt-contrib-concat": "^0.5.1"
29 |   },
30 |   "scripts": {
31 |     "test": "grunt test"
32 |   },
33 |   "dependencies": {
34 |     "promis": "=1.1.4",
35 |     "closure-fetch": "=0.4.2",
36 |     "fontfaceobserver": "=2.0.5",
37 |     "closure-dom": "=0.2.6",
38 |     "cssvalue": "=0.0.3"
39 |   }
40 | }
41 | 


--------------------------------------------------------------------------------
/test/index.html:
--------------------------------------------------------------------------------
 1 | <!doctype html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <title>FontLoader</title>
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 7 |     <link href="../node_modules/mocha/mocha.css" rel="stylesheet">
 8 |   </head>
 9 |   <body>
10 |     <div id="mocha"></div>
11 |     <script>CLOSURE_NO_DEPS = true;</script>
12 |     <script src="../vendor/google/base.js"></script>
13 |     <script src="../node_modules/unexpected/unexpected.js"></script>
14 |     <script src="../node_modules/mocha/mocha.js"></script>
15 |     <script src="../node_modules/sinon/pkg/sinon.js"></script>
16 |     <script src="../node_modules/promis/promise.js"></script>
17 |     <script src="helper.js"></script>
18 |     <script src="deps.js"></script>
19 |     <script>
20 |       goog.require('fontloader');
21 |       mocha.ui('bdd');
22 | 
23 |       expect = weknowhow.expect;
24 |     </script>
25 |     <script src="./fontloader-test.js"></script>
26 |     <script src="./fontface-test.js"></script>
27 |     <script src="./fontfaceset-test.js"></script>
28 |     <script>
29 |       window.onload = function () {
30 |         mocha.run();
31 |       };
32 |     </script>
33 |   </body>
34 | </html>
35 | 


--------------------------------------------------------------------------------
/vendor/bramstein/promise.min.js:
--------------------------------------------------------------------------------
1 | (function(){'use strict';function f(a){this.a=k;this.b=void 0;this.d=[];var b=this;try{a(function(a){l(b,a)},function(a){m(b,a)})}catch(d){m(b,d)}}var k=2;function n(a){return new f(function(b,d){d(a)})}function p(a){return new f(function(b){b(a)})}
2 | function l(a,b){if(a.a===k){if(b===a)throw new TypeError("Promise resolved with itself.");try{var d=b&&b.then,c=!1;if(null!==b&&"object"===typeof b&&"function"===typeof d){d.call(b,function(b){c||l(a,b);c=!0},function(b){c||m(a,b);c=!0});return}}catch(e){c||m(a,e);return}a.a=0;a.b=b;q(a)}}function m(a,b){if(a.a===k){if(b===a)throw new TypeError("Promise rejected with itself.");a.a=1;a.b=b;q(a)}}
3 | function q(a){setTimeout(function(){if(a.a!==k)for(;a.d.length;){var b=a.d.shift(),d=b[0],c=b[1],e=b[2],b=b[3];try{0===a.a?"function"===typeof d?e(d.call(void 0,a.b)):e(a.b):1===a.a&&("function"===typeof c?e(c.call(void 0,a.b)):b(a.b))}catch(g){b(g)}}},0)}f.prototype.e=function(a){return this.c(void 0,a)};f.prototype.c=function(a,b){var d=this;return new f(function(c,e){d.d.push([a,b,c,e]);q(d)})};
4 | function r(a){return new f(function(b,d){function c(c){return function(d){g[c]=d;e+=1;e===a.length&&b(g)}}var e=0,g=[];0===a.length&&b(g);for(var h=0;h<a.length;h+=1)a[h].c(c(h),d)})}function s(a){return new f(function(b,d){for(var c=0;c<a.length;c+=1)a[c].c(b,d)})};window.Promise||(window.Promise=f,window.Promise.resolve=p,window.Promise.reject=n,window.Promise.race=s,window.Promise.all=r,window.Promise.prototype.then=f.prototype.c,window.Promise.prototype["catch"]=f.prototype.e);}());
5 | 


--------------------------------------------------------------------------------
/Gruntfile.js:
--------------------------------------------------------------------------------
 1 | module.exports = function (grunt) {
 2 |   require('google-closure-compiler').grunt(grunt);
 3 |   var extend = require('extend');
 4 | 
 5 |   var compilerOptions = {
 6 |     compilation_level: 'ADVANCED_OPTIMIZATIONS',
 7 |     warning_level: 'VERBOSE',
 8 |     summary_detail_level: 3,
 9 |     language_in: 'ECMASCRIPT5_STRICT',
10 |     output_wrapper: '(function(){%output%}());',
11 |     use_types_for_optimization: true
12 |   };
13 | 
14 |   var src = [
15 |     'polyfill.js',
16 |     'src/**/*.js',
17 |     'node_modules/cssvalue/src/**/*.js',
18 |     'node_modules/closure-fetch/src/**/*.js',
19 |     'node_modules/closure-dom/src/**/*.js',
20 |     'node_modules/fontfaceobserver/src/**/*.js'
21 |   ];
22 | 
23 |   grunt.initConfig({
24 |     pkg: grunt.file.readJSON('package.json'),
25 |     clean: ['build'],
26 |     exec: {
27 |       test: 'phantomjs node_modules/mocha-phantomjs-core/mocha-phantomjs-core.js test/index.html',
28 |       deps: 'calcdeps -p ' + src.map(function (p) { return p.replace('**/*.js', ''); }).join(' -p ' ) + ' -p ./vendor/google/base.js -o deps > test/deps.js'
29 |     },
30 |     jshint: {
31 |       all: ['src/**/*.js'],
32 |       options: {
33 |         // ... better written as dot notation
34 |         "-W069": true,
35 | 
36 |         // type definitions
37 |         "-W030": true,
38 | 
39 |         // Don't make functions within loops
40 |         "-W083": true,
41 | 
42 |         // Wrap the /regexp/ literal in parens to disambiguate the slash operator
43 |         "-W092": true
44 |       }
45 |     },
46 |     'closure-compiler': {
47 |       compile: {
48 |         files: {
49 |           "build/fontloader.js": src
50 |         },
51 |         options: extend({}, compilerOptions)
52 |       },
53 |       debug: {
54 |         files: {
55 |           "build/fontloader.debug.js": src
56 |         },
57 |         options: extend({}, compilerOptions, {
58 |           debug: true,
59 |           formatting: ['PRETTY_PRINT', 'PRINT_INPUT_DELIMITER']
60 |         })
61 |       }
62 |     },
63 |     concat: {
64 |       dist: {
65 |         src: ['node_modules/promis/promise.js', 'build/fontloader.js'],
66 |         dest: 'fontloader.js'
67 |       }
68 |     }
69 |   });
70 | 
71 |   grunt.loadNpmTasks('grunt-contrib-clean');
72 |   grunt.loadNpmTasks('grunt-contrib-jshint');
73 |   grunt.loadNpmTasks('grunt-exec');
74 |   grunt.loadNpmTasks('grunt-contrib-concat');
75 | 
76 |   grunt.registerTask('compile', ['closure-compiler:compile']);
77 |   grunt.registerTask('debug', ['closure-compiler:debug']);
78 |   grunt.registerTask('default', ['compile']);
79 |   grunt.registerTask('test', ['exec:test']);
80 |   grunt.registerTask('deps', ['exec:deps']);
81 |   grunt.registerTask('dist', ['closure-compiler:compile', 'concat:dist']);
82 | };
83 | 


--------------------------------------------------------------------------------
/test/deps.js:
--------------------------------------------------------------------------------
 1 | // This file was autogenerated by calcdeps.js
 2 | goog.addDependency("../../polyfill.js", ["fontloader"], ["fl.FontFace","fl.FontFaceSet"]);
 3 | goog.addDependency("../../src/binarydata.js", ["fl.BinaryData"], []);
 4 | goog.addDependency("../../src/fontface.js", ["fl.FontFace"], ["fl.FontFaceLoadStatus","fl.FontFormat","cssvalue.Src","lang.Promise","net.fetch","dom"]);
 5 | goog.addDependency("../../src/fontfacedescriptors.js", ["fl.FontFaceDescriptors"], []);
 6 | goog.addDependency("../../src/fontfaceloadstatus.js", ["fl.FontFaceLoadStatus"], []);
 7 | goog.addDependency("../../src/fontfaceset.js", ["fl.FontFaceSet"], ["fl.FontFaceSetLoadStatus","cssvalue.Font","lang.Promise"]);
 8 | goog.addDependency("../../src/fontfacesetloadstatus.js", ["fl.FontFaceSetLoadStatus"], []);
 9 | goog.addDependency("../../src/fontfacesource.js", ["fl.FontFaceSource"], []);
10 | goog.addDependency("../../src/fontformat.js", ["fl.FontFormat"], ["fontface.Observer"]);
11 | goog.addDependency("../../node_modules/cssvalue/src/featuresettings.js", ["cssvalue.FeatureSettings"], []);
12 | goog.addDependency("../../node_modules/cssvalue/src/font.js", ["cssvalue.Font"], []);
13 | goog.addDependency("../../node_modules/cssvalue/src/src.js", ["cssvalue.Src"], []);
14 | goog.addDependency("../../node_modules/cssvalue/src/unicoderange.js", ["cssvalue.UnicodeRange"], []);
15 | goog.addDependency("../../node_modules/promis/src/async.js", ["lang.async"], []);
16 | goog.addDependency("../../node_modules/promis/src/promise.js", ["lang.Promise"], ["lang.async"]);
17 | goog.addDependency("../../node_modules/closure-fetch/src/body.js", ["net.Body"], []);
18 | goog.addDependency("../../node_modules/closure-fetch/src/bodyinit.js", ["net.BodyInit"], []);
19 | goog.addDependency("../../node_modules/closure-fetch/src/fetch.js", ["net.fetch"], ["net.Body","net.Response","lang.Promise"]);
20 | goog.addDependency("../../node_modules/closure-fetch/src/headersinit.js", ["net.HeadersInit"], []);
21 | goog.addDependency("../../node_modules/closure-fetch/src/requestinit.js", ["net.RequestInit"], []);
22 | goog.addDependency("../../node_modules/closure-fetch/src/response.js", ["net.Response"], ["lang.Promise"]);
23 | goog.addDependency("../../node_modules/closure-fetch/src/responseinit.js", ["net.ResponseInit"], []);
24 | goog.addDependency("../../node_modules/closure-dom/src/dom.js", ["dom"], []);
25 | goog.addDependency("../../node_modules/fontfaceobserver/src/css.js", ["fontface.Css"], []);
26 | goog.addDependency("../../node_modules/fontfaceobserver/src/descriptors.js", ["fontface.Descriptors"], []);
27 | goog.addDependency("../../node_modules/fontfaceobserver/src/observer.js", ["fontface.Observer"], ["fontface.Ruler","dom","lang.Promise"]);
28 | goog.addDependency("../../node_modules/fontfaceobserver/src/ruler.js", ["fontface.Ruler"], ["dom"]);
29 | 


--------------------------------------------------------------------------------
/browsers.json:
--------------------------------------------------------------------------------
  1 | [
  2 |   {
  3 |     "os_version": "XP",
  4 |     "os": "Windows",
  5 |     "browser_version": "11.1",
  6 |     "browser": "opera"
  7 |   },
  8 |   {
  9 |     "os_version": "XP",
 10 |     "os": "Windows",
 11 |     "browser_version": "3.6",
 12 |     "browser": "firefox"
 13 |   },
 14 |   {
 15 |     "os_version": "XP",
 16 |     "os": "Windows",
 17 |     "browser_version": "20.0",
 18 |     "browser": "firefox"
 19 |   },
 20 |   {
 21 |     "os_version": "XP",
 22 |     "os": "Windows",
 23 |     "browser_version": "6.0",
 24 |     "browser": "ie"
 25 |   },
 26 |   {
 27 |     "os_version": "XP",
 28 |     "os": "Windows",
 29 |     "browser_version": "7.0",
 30 |     "browser": "ie"
 31 |   },
 32 |   {
 33 |     "os_version": "XP",
 34 |     "os": "Windows",
 35 |     "browser_version": "8.0",
 36 |     "browser": "ie"
 37 |   },
 38 |   {
 39 |     "os_version": "8",
 40 |     "os": "Windows",
 41 |     "browser_version": "10.0 Desktop",
 42 |     "browser": "ie"
 43 |   },
 44 |   {
 45 |     "os_version": "7",
 46 |     "os": "Windows",
 47 |     "browser_version": "9.0",
 48 |     "browser": "ie"
 49 |   },
 50 |   {
 51 |     "os_version": "Mountain Lion",
 52 |     "os": "OS X",
 53 |     "browser_version": "6.0",
 54 |     "browser": "safari"
 55 |   },
 56 |   {
 57 |     "os_version": "Mountain Lion",
 58 |     "os": "OS X",
 59 |     "browser_version": "25.0",
 60 |     "browser": "chrome"
 61 |   },
 62 |   {
 63 |     "os_version": "Snow Leopard",
 64 |     "os": "OS X",
 65 |     "browser_version": "5.0",
 66 |     "browser": "safari"
 67 |   },
 68 |   {
 69 |     "os_version": "5.0",
 70 |     "device": "iPad 2 (5.0)",
 71 |     "os": "ios",
 72 |     "browser": "Mobile Safari"
 73 |   },
 74 |   {
 75 |     "os_version": "5.1",
 76 |     "device": "iPad 3rd",
 77 |     "os": "ios",
 78 |     "browser": "Mobile Safari"
 79 |   },
 80 |   {
 81 |     "os_version": "6.0",
 82 |     "device": "iPhone 5",
 83 |     "os": "ios",
 84 |     "browser": "Mobile Safari"
 85 |   },
 86 |   {
 87 |     "os_version": "4.3.2",
 88 |     "device": "iPad 2",
 89 |     "os": "ios",
 90 |     "browser": "Mobile Safari"
 91 |   },
 92 |   {
 93 |     "os_version": "2.3",
 94 |     "device": "Samsung Galaxy S II",
 95 |     "os": "android",
 96 |     "browser": "Android Browser"
 97 |   },
 98 |   {
 99 |     "os_version": "2.2",
100 |     "device": "Samsung Galaxy S",
101 |     "os": "android",
102 |     "browser": "Android Browser"
103 |   },
104 |   {
105 |     "os_version": "4.2",
106 |     "device": "LG Nexus 4",
107 |     "os": "android",
108 |     "browser": "Android Browser"
109 |   },
110 |   {
111 |     "os_version": "4.0",
112 |     "device": "Samsung Galaxy Nexus",
113 |     "os": "android",
114 |     "browser": "Android Browser"
115 |   },
116 |   {
117 |     "os_version": "4.1",
118 |     "device": "Samsung Galaxy S III",
119 |     "os": "android",
120 |     "browser": "Android Browser"
121 |   }
122 | ]
123 | 


--------------------------------------------------------------------------------
/src/fontformat.js:
--------------------------------------------------------------------------------
 1 | goog.provide('fl.FontFormat');
 2 | 
 3 | goog.require('fontface.Observer');
 4 | 
 5 | goog.scope(function () {
 6 |   fl.FontFormat = {};
 7 | 
 8 |   var FontFormat = fl.FontFormat;
 9 | 
10 |   /**
11 |    * Width is 3072 (3em).
12 |    *
13 |    * @const
14 |    * @type {string}
15 |    */
16 |   FontFormat.WOFF2 = 'd09GMgABAAAAAADcAAoAAAAAAggAAACWAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAABk4ALAoUNAE2AiQDCAsGAAQgBSAHIBtvAciuMTaGVo8IaqBbcKPeB3CyAAIO4unr9nb72QE3p00iGQQIZcAAcAMEJOztBx7zdWVWn//BAPW1l0BN429cPrCPE75MA637gPs0DjavNxzHtWeXXErKIV3AF9TbHqCTOATL2BgjeIH30lQwSAonU1LabV8Iz12wDvgd/obV5QVxXDKvUhW1QfWNrS6HzEQJaP4tBA==';
17 | 
18 |   /**
19 |    * Width is 2048 (2em).
20 |    *
21 |    * @const
22 |    * @type {string}
23 |    */
24 |   FontFormat.WOFF = 'd09GRgABAAAAAAHgAAoAAAAAAggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPUy8yAAABUAAAABcAAABOBIQEIWNtYXAAAAFwAAAAJgAAACwADABzZ2x5ZgAAAaAAAAAUAAAAFAwBPQJoZWFkAAAA9AAAAC0AAAA2CHEB92hoZWEAAAEkAAAAFgAAACQMAQgDaG10eAAAAWgAAAAIAAAACAgAAABsb2NhAAABmAAAAAYAAAAGAAoAAG1heHAAAAE8AAAAEwAAACAABAACbmFtZQAAAbQAAAAeAAAAIAAjCF5wb3N0AAAB1AAAAAwAAAAgAAMAAHgBY2BkYABhb81vuvH8Nl8ZmFgYQOBCWvVrMP3VURxEczBAxBmYQAQAAFIIBgAAAHgBY2BkYGBhAAEOKAkUQQVMAAJKABkAAHgBY2BkYGBgAkIgjQ0AAAC+AAcAeAFjAIEUBkYGcoECgwILmAEiASBRAK4AAAAAAAgAAAB4AWNgYGBkYAZiBgYeBhYGBSDNAoQgvsP//xDy/0EwnwEATX4GfAAAAAAAAAAKAAAAAQAAAAAIAAQAAAEAADEBCAAEAHgBY2BgYGKQY2BmYGThZGAEshmgbCYw2wEABjMAigAAeAFjYGbACwAAfQAE';
25 | 
26 |   /**
27 |    * @type {string}
28 |    */
29 |   FontFormat.TEST_FONT_FAMILY = '_fff_';
30 | 
31 |   /**
32 |    * @type {Promise.<!Array.<string>>}
33 |    */
34 |   FontFormat.SUPPORTED_FORMATS = null;
35 | 
36 |   /**
37 |    * @return {Promise.<!Array.<string>>}
38 |    */
39 |   FontFormat.detect = function () {
40 |     if (!FontFormat.SUPPORTED_FORMATS) {
41 |       if (/MSIE|Trident/.test(navigator.userAgent)) {
42 |         return Promise.resolve(['woff', 'opentype', 'truetype']);
43 |       }
44 | 
45 |       var style = document.createElement('style'),
46 |           head = document.getElementsByTagName('head')[0];
47 | 
48 |       style.appendChild(document.createTextNode(
49 |         '@font-face{' +
50 |           'font-family:"' + FontFormat.TEST_FONT_FAMILY + '";' +
51 |           'src:' +
52 |             'url(data:font/woff2;base64,' + FontFormat.WOFF2  +') format("woff2"),' +
53 |             'url(data:application/font-woff;base64,' + FontFormat.WOFF + ') format("woff")' +
54 |         '}'
55 |       ));
56 | 
57 |       head.appendChild(style);
58 | 
59 |       // TODO: Since we have the font data hardcoded in the JS we can
60 |       // use the forced-relayout trick here, which removes the need
61 |       // to insert test spans into the document.
62 |       FontFormat.SUPPORTED_FORMATS = new fontface.Observer(FontFormat.TEST_FONT_FAMILY, {}).load('@', 5000).then(function () {
63 |         var ruler = new fontface.Ruler('@'),
64 |             formats = ['opentype', 'truetype'];
65 | 
66 |         ruler.setFont(FontFormat.TEST_FONT_FAMILY);
67 | 
68 |         document.body.appendChild(ruler.getElement());
69 | 
70 |         var width = ruler.getWidth();
71 | 
72 |         if (width >= 200) {
73 |           formats.unshift('woff');
74 |         }
75 | 
76 |         if (width == 300) {
77 |           formats.unshift('woff2');
78 |         }
79 | 
80 |         head.removeChild(style);
81 |         document.body.removeChild(ruler.getElement());
82 | 
83 |         return formats;
84 |       }, function () {
85 |         return ['opentype', 'truetype'];
86 |       });
87 |     }
88 |     return FontFormat.SUPPORTED_FORMATS;
89 |   };
90 | });
91 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Deprecated
 2 | 
 3 | This library is deprecated and no longer maintained. The CSS font loading API is near impossible to implement without access to the browser's internal font loading behaviour. The most useful aspects of the API (font events) has been implemented in [Font Face Observer](https://github.com/bramstein/fontfaceobserver), so please use that instead.
 4 | 
 5 | ## FontLoader Polyfill [![Build Status](https://travis-ci.org/bramstein/fontloader.png?branch=master)](https://travis-ci.org/bramstein/fontloader)
 6 | 
 7 | This polyfill implements the [W3C Font Load Events Module Level 3 specification](http://www.w3.org/TR/css-font-loading/). It detects when fonts have loaded and provides callbacks for each font load event. You can use the fontloader polyfill to prevent the Flash Of Unstyled Text (FOUT) or execute JavaScript code when fonts have loaded (for example to perform layout or show a user interface element.)
 8 | 
 9 | ## API
10 | 
11 | 
12 | ## Installation
13 | 
14 | If you using npm:
15 | 
16 |     $ npm install fontloader
17 | 
18 | Otherwise copy the [fontloader.js](fontloader.js) file to your project and include it.
19 | 
20 | ## Limitations
21 | 
22 | The following are limitations due to the fact that this is a JavaScript library without access to a browser's internal state.
23 | 
24 | #### Metric compatible fonts
25 | 
26 | Metric compatible fonts are fonts that are designed to have identical metrics to another font so they can be used as a substitute without affecting page layout. When a web font is metric compatible with one of the system fonts (the fonts that are used for `serif`, `sans-serif` and `monospace`) the fontloader can not detect when the web font has loaded.
27 | 
28 | #### Slow loading fonts
29 | 
30 | The library has a default timeout of 3 seconds after which it considers a font "load" failed. Unlike the native API this library is not capable of cancelling in-progress font loads so it may happen that the font still loads after the timeout. This is a rare case and usually indicative of a problem with either the font or the host it is loaded from.
31 | 
32 | ## Browser Support
33 | 
34 | The following browsers are supported:
35 | 
36 | * IE9+
37 | * Chrome
38 | * Firefox
39 | * Safari
40 | * Android
41 | * iOS
42 | * Opera
43 | 
44 | Other browser may work, but are not extensively tested. Please [open an issue](https://github.com/bramstein/fontloader/issues) if you think a browser should be supported but isn't. Tests are run automatically on all supported browsers using [BrowserStack](http://www.browserstack.com) and [browserstack-test](https://github.com/bramstein/browserstack-test).
45 | 
46 | ## Copyright and License
47 | 
48 | Portions of this project are derived from the [Web Font Loader](https://github.com/typekit/webfontloader):
49 | 
50 |     Web Font Loader Copyright (c) 2010 Adobe Systems Incorporated, Google Incorporated.
51 | 
52 | The FontLoader polyfill is therefore also licenced under the Apache 2.0 License:
53 | 
54 |     FontLoader Polyfill Copyright (c) 2013-2014 Bram Stein
55 | 
56 | Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
57 | 
58 |     http://www.apache.org/licenses/LICENSE-2.0
59 | 
60 | Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
61 | 


--------------------------------------------------------------------------------
/src/fontfaceset.js:
--------------------------------------------------------------------------------
  1 | goog.provide('fl.FontFaceSet');
  2 | 
  3 | goog.require('fl.FontFaceSetLoadStatus');
  4 | 
  5 | goog.require('cssvalue.Font');
  6 | 
  7 | goog.scope(function () {
  8 |   var FontFaceSetLoadStatus = fl.FontFaceSetLoadStatus,
  9 |       Font = cssvalue.Font;
 10 | 
 11 |   /**
 12 |    * @constructor
 13 |    */
 14 |   fl.FontFaceSet = function () {
 15 | 
 16 |     /**
 17 |      * @type {Array.<fl.FontFace>}
 18 |      */
 19 |     this.fonts = [];
 20 | 
 21 |     /**
 22 |      * @type {!fl.FontFaceSetLoadStatus}
 23 |      */
 24 |     this.loadStatus = FontFaceSetLoadStatus.LOADED;
 25 | 
 26 |     Object.defineProperties(this, {
 27 |       'status': {
 28 |         get: function () {
 29 |           return this.loadStatus;
 30 |         }
 31 |       },
 32 |       'size': {
 33 |         get: function () {
 34 |           return this.fonts.length;
 35 |         }
 36 |       }
 37 |     });
 38 |   };
 39 | 
 40 |   var FontFaceSet = fl.FontFaceSet;
 41 | 
 42 |   /**
 43 |    * @param {!fl.FontFace} font
 44 |    *
 45 |    * return {fl.FontFaceSet}
 46 |    */
 47 |   FontFaceSet.prototype['add'] = function (font) {
 48 |     if (!this['has'](font)) {
 49 |       font.insert();
 50 |       this.fonts.push(font);
 51 |     }
 52 |   };
 53 | 
 54 |   /**
 55 |    * @param {!fl.FontFace} font
 56 |    *
 57 |    * @return {boolean}
 58 |    */
 59 |   FontFaceSet.prototype['delete'] = function (font) {
 60 |     var index = this.fonts.indexOf(font);
 61 | 
 62 |     if (index !== -1) {
 63 |       font.remove();
 64 |       this.fonts.splice(index, 1);
 65 |       return true;
 66 |     } else {
 67 |       return false;
 68 |     }
 69 |   };
 70 | 
 71 |   FontFaceSet.prototype['clear'] = function () {
 72 |     this.fonts = [];
 73 |   };
 74 | 
 75 |   /**
 76 |    * @param {!fl.FontFace} font
 77 |    *
 78 |    * @return {boolean}
 79 |    */
 80 |   FontFaceSet.prototype['has'] = function (font) {
 81 |     return this.fonts.indexOf(font) !== -1;
 82 |   };
 83 | 
 84 |   /**
 85 |    * @param {function(fl.FontFace, number, fl.FontFaceSet)} fn
 86 |    */
 87 |   FontFaceSet.prototype['forEach'] = function (fn) {
 88 |     var set = this;
 89 | 
 90 |     this.fonts.forEach(function (font, index) {
 91 |       fn(font, index, set);
 92 |     });
 93 |   };
 94 | 
 95 |   /**
 96 |    * @param {string} font
 97 |    * @param {string=} opt_text
 98 |    *
 99 |    * @return {!Array.<!fl.FontFace>|null}
100 |    */
101 |   FontFaceSet.prototype.match = function (font, opt_text) {
102 |     function normalize(weight) {
103 |       if (weight === 'bold') {
104 |         return 700;
105 |       } else if (weight === 'normal') {
106 |         return 400;
107 |       } else {
108 |         return weight;
109 |       }
110 |     }
111 | 
112 |     var properties = Font.parse(font);
113 | 
114 |     if (properties === null) {
115 |       return null;
116 |     }
117 | 
118 |     // TODO: match on opt_text
119 |     return this.fonts.filter(function (f) {
120 |       var families = properties.family;
121 | 
122 |       for (var i = 0; i < families.length; i++) {
123 |         if (f['family'] === families[i] &&
124 |             f['style'] === properties.style &&
125 |             f['stretch'] === properties.stretch &&
126 |             normalize(f['weight']) === normalize(properties.weight)) {
127 |           return true;
128 |         }
129 |       }
130 |       return false;
131 |     });
132 |   };
133 | 
134 |   /**
135 |    * @param {string} font
136 |    * @param {string=} opt_text
137 |    *
138 |    * @return {!Promise.<!Array.<fl.FontFace>>}
139 |    */
140 |   FontFaceSet.prototype['load'] = function (font, opt_text) {
141 |     var set = this,
142 |         matches = this.match(font, opt_text);
143 | 
144 |     if (matches === null) {
145 |       return Promise.reject([]);
146 |     } else if (matches.length) {
147 |       set.loadStatus = FontFaceSetLoadStatus.LOADING;
148 | 
149 |       return Promise.all(matches.map(function (font) {
150 |         return font.load();
151 |       })).then(function () {
152 |         set.loadStatus = FontFaceSetLoadStatus.LOADED;
153 |         return matches;
154 |       }).catch(function () {
155 |         set.loadStatus = FontFaceSetLoadStatus.LOADED;
156 |         return matches;
157 |       });
158 |     } else {
159 |       return Promise.resolve([]);
160 |     }
161 |   };
162 | 
163 |   /**
164 |    * @param {string} font
165 |    * @param {string} opt_text
166 |    *
167 |    * @return {boolean}
168 |    */
169 |   FontFaceSet.prototype['check'] = function (font, opt_text) {
170 |     var matches = this.match(font, opt_text);
171 | 
172 |     if (matches.length === 0) {
173 |       return false;
174 |     } else {
175 |       for (var i = 0; i < matches.length; i++) {
176 |         if (matches[i]['status'] !== "loaded") {
177 |           return false;
178 |         }
179 |       }
180 |       return true;
181 |     }
182 |   };
183 | });
184 | 


--------------------------------------------------------------------------------
/test/fontface-test.js:
--------------------------------------------------------------------------------
  1 | describe('FontFace', function () {
  2 |   var FontFace = fl.FontFace;
  3 | 
  4 |   describe('#constructor', function () {
  5 |     it('accepts family names starting with non-valid identifier characters', function () {
  6 |       expect(new FontFace('3four', 'url(font.woff)').family, 'to equal', '3four');
  7 |       expect(new FontFace('-5f', 'url(font.woff)').family, 'to equal', '-5f');
  8 |       expect(new FontFace('--vendor', 'url(font.woff)').family, 'to equal', '--vendor');
  9 |     });
 10 | 
 11 |     it('parses descriptors', function () {
 12 |       expect(new FontFace('My Family', 'url(font.woff)', { style: 'italic' }).style, 'to equal', 'italic');
 13 |       expect(new FontFace('My Family', 'url(font.woff)', { weight: 'bold' }).weight, 'to equal', 'bold');
 14 |       expect(new FontFace('My Family', 'url(font.woff)', { stretch: 'condensed' }).stretch, 'to equal', 'condensed');
 15 |       expect(new FontFace('My Family', 'url(font.woff)', { variant: 'small-caps' }).variant, 'to equal', 'small-caps');
 16 |     });
 17 | 
 18 |     it('defaults descriptors if not given', function () {
 19 |       var font = new FontFace('My Family', 'url(font.woff)');
 20 | 
 21 |       expect(font.style, 'to equal', 'normal');
 22 |       expect(font.weight, 'to equal', 'normal');
 23 |       expect(font.variant, 'to equal', 'normal');
 24 |     });
 25 |   });
 26 | 
 27 |   describe('#getMatchingUrls', function () {
 28 |     it('returns the first URL if there are no format identifiers', function () {
 29 |       var font = new FontFace('My Family', 'url(font.woff), url(font.otf)');
 30 | 
 31 |       expect(font.getMatchingUrls(['woff', 'opentype']), 'to equal', 'font.woff');
 32 |     });
 33 | 
 34 |     it('returns the first matching format URL', function () {
 35 |       var font = new FontFace('My Family', 'url(font.woff) format("woff"), url(font.otf) format("opentype")');
 36 | 
 37 |       expect(font.getMatchingUrls(['woff']), 'to equal', 'font.woff');
 38 |       expect(font.getMatchingUrls(['opentype']), 'to equal', 'font.otf');
 39 |     });
 40 | 
 41 |     it('returns null when the browser does not support anything', function () {
 42 |       var font = new FontFace('My Family', 'url(font.woff) format("woff"), url(font.otf) format("opentype")');
 43 | 
 44 |       expect(font.getMatchingUrls([]), 'to be null');
 45 |     });
 46 |   });
 47 | 
 48 |   describe('#load', function () {
 49 |     it('resolves when a font loads', function (done) {
 50 |       this.timeout(6000);
 51 |       var font = new FontFace('My Family', 'url(./assets/sourcesanspro-regular.woff) format("woff"), url(./assets/sourcesanspro-regular.ttf) format("truetype")');
 52 | 
 53 |       expect(font.status, 'to equal', 'unloaded');
 54 | 
 55 |       font.load().then(function (f) {
 56 |         expect(font, 'to equal', f);
 57 |         expect(font.status, 'to equal', 'loaded');
 58 |         done();
 59 |       }).catch(function () {
 60 |         done(new Error('Should not fail'));
 61 |       });
 62 |     });
 63 | 
 64 |     it('rejects when a font fails to load', function (done) {
 65 |       var font = new FontFace('My Family', 'url(./assets/unknown.woff) format("woff"), url(./assets/unknown.ttf) format("truetype")');
 66 | 
 67 |       expect(font.status, 'to equal', 'unloaded');
 68 | 
 69 |       font.load().then(function (f) {
 70 |         done(new Error('Should not succeed'));
 71 |       }).catch(function (f) {
 72 |         expect(font, 'to equal', f);
 73 |         expect(font.status, 'to equal', 'error');
 74 |         done();
 75 |       });
 76 |     });
 77 | 
 78 |     it('loads immediately when given an arraybuffer', function (done) {
 79 |       var font = new FontFace('My Family', new ArrayBuffer(4), {});
 80 | 
 81 |       expect(font.status, 'to equal', "loaded");
 82 | 
 83 |       font.load().then(function (f) {
 84 |         expect(font.status, 'to equal', "loaded");
 85 |         expect(f, 'to equal', font);
 86 |         done();
 87 |       }, function (r) {
 88 |         done(r);
 89 |       });
 90 |     });
 91 |   });
 92 | 
 93 |   describe('#insert', function () {
 94 |     it('inserts a @font-face rule into the DOM', function () {
 95 |       var font = new FontFace('My Family', new ArrayBuffer(4), {});
 96 | 
 97 |       font.insert();
 98 | 
 99 |       expect(font.rule, 'not to be null');
100 |       expect(font.rule.parentStyleSheet, 'not to be null');
101 |     });
102 | 
103 |     it('inserts multiple @font-face rules into the DOM', function () {
104 |       var font1 = new FontFace('Font1', new ArrayBuffer(4), {}),
105 |           font2 = new FontFace('Font2', new ArrayBuffer(4), {});
106 | 
107 |       font1.insert();
108 |       font2.insert();
109 | 
110 |       expect(font1.rule, 'not to be null');
111 |       expect(font1.rule.parentStyleSheet, 'not to be null');
112 |       expect(font2.rule, 'not to be null');
113 |       expect(font2.rule.parentStyleSheet, 'not to be null');
114 | 
115 |       expect(font1.rule.parentStyleSheet, 'to equal', font2.rule.parentStyleSheet);
116 |     });
117 |   });
118 | 
119 |   describe('#remove', function () {
120 |     it('removes @ font-face rule from the DOM', function () {
121 |       var font = new FontFace('My Family', new ArrayBuffer(4), {});
122 | 
123 |       font.insert();
124 | 
125 |       expect(font.rule, 'not to be null');
126 |       expect(font.rule.parentStyleSheet, 'not to be null');
127 | 
128 |       font.remove();
129 |       expect(font.rule, 'to be null');
130 |     });
131 | 
132 |     it('removes multiple @font-face rules from the DOM', function () {
133 |       var font1 = new FontFace('Font1', new ArrayBuffer(4), {}),
134 |           font2 = new FontFace('Font2', new ArrayBuffer(4), {});
135 | 
136 |       font1.insert();
137 |       font2.insert();
138 | 
139 |       expect(font1.rule, 'not to be null');
140 |       expect(font1.rule.parentStyleSheet, 'not to be null');
141 |       expect(font2.rule, 'not to be null');
142 |       expect(font2.rule.parentStyleSheet, 'not to be null');
143 | 
144 |       expect(font1.rule.parentStyleSheet, 'to equal', font2.rule.parentStyleSheet);
145 | 
146 |       font1.remove();
147 |       expect(font1.rule, 'to be null');
148 |       expect(font2.rule, 'not to be null');
149 |       expect(font2.rule.parentStyleSheet, 'not to be null');
150 | 
151 |       font2.remove();
152 | 
153 |       expect(font2.rule, 'to be null');
154 |     });
155 |   });
156 | });
157 | 


--------------------------------------------------------------------------------
/src/fontface.js:
--------------------------------------------------------------------------------
  1 | goog.provide('fl.FontFace');
  2 | 
  3 | goog.require('fl.FontFaceLoadStatus');
  4 | goog.require('fl.FontFormat');
  5 | 
  6 | goog.require('cssvalue.Src');
  7 | goog.require('net.fetch');
  8 | goog.require('dom');
  9 | 
 10 | goog.scope(function () {
 11 |   var FontFaceLoadStatus = fl.FontFaceLoadStatus,
 12 |       FontFormat = fl.FontFormat,
 13 |       Src = cssvalue.Src,
 14 |       fetch = net.fetch;
 15 | 
 16 |   /**
 17 |    * @constructor
 18 |    *
 19 |    * @param {string} family
 20 |    * @param {fl.BinaryData|string} source
 21 |    * @param {fl.FontFaceDescriptors=} opt_descriptors
 22 |    */
 23 |   fl.FontFace = function (family, source, opt_descriptors) {
 24 |     var fontface = this,
 25 |         descriptors = opt_descriptors || {};
 26 | 
 27 |     /**
 28 |      * @type {fl.BinaryData|string}
 29 |      */
 30 |     this.source = source;
 31 | 
 32 |     /**
 33 |      * @type {ArrayBuffer}
 34 |      */
 35 |     this.buffer = null;
 36 | 
 37 |     /**
 38 |      * @type {Array.<cssvalue.Src.Value>}
 39 |      */
 40 |     this.urls = [];
 41 | 
 42 |     /**
 43 |      * @type {function(fl.FontFace)}
 44 |      */
 45 |     this.resolveLoad;
 46 | 
 47 |     /**
 48 |      * @type {function(fl.FontFace)}
 49 |      */
 50 |     this.rejectLoad;
 51 | 
 52 |     /**
 53 |      * @type {Promise.<fl.FontFace>}
 54 |      */
 55 |     this.promise = new Promise(function (resolve, reject) {
 56 |       fontface.resolveLoad = resolve;
 57 |       fontface.rejectLoad = reject;
 58 |     });
 59 | 
 60 |     /**
 61 |      * @type {fl.FontFaceLoadStatus}
 62 |      */
 63 |     this.loadStatus = FontFaceLoadStatus.UNLOADED;
 64 | 
 65 |     /**
 66 |      * @type {CSSRule|null}
 67 |      */
 68 |     this.rule = null;
 69 | 
 70 |     Object.defineProperties(this, {
 71 |       'family': {
 72 |         get: function () {
 73 |           return family;
 74 |         }
 75 |       },
 76 |       'style': {
 77 |         get: function () {
 78 |           return descriptors.style || 'normal';
 79 |         }
 80 |       },
 81 |       'weight': {
 82 |         get: function () {
 83 |           return descriptors.weight || 'normal';
 84 |         }
 85 |       },
 86 |       'stretch': {
 87 |         get: function () {
 88 |           return descriptors.stretch || 'normal';
 89 |         }
 90 |       },
 91 |       'display': {
 92 |         get: function () {
 93 |           return descriptors.display || 'auto';
 94 |         }
 95 |       },
 96 |       'unicodeRange': {
 97 |         get: function () {
 98 |           return descriptors.unicodeRange || 'U+0-10FFFF';
 99 |         }
100 |       },
101 |       'variant': {
102 |         get: function () {
103 |           return descriptors.variant || 'normal';
104 |         }
105 |       },
106 |       'featureSettings': {
107 |         get: function () {
108 |           return descriptors.featureSettings || 'normal';
109 |         }
110 |       },
111 |       'status': {
112 |         get: function () {
113 |           return this.loadStatus;
114 |         }
115 |       },
116 |       'loaded': {
117 |         get: function () {
118 |           return this.promise;
119 |         }
120 |       }
121 |     });
122 | 
123 |     if (typeof source === 'string') {
124 |       this.urls = Src.parse(/** @type {string} */ (source));
125 |     } else {
126 |       this.buffer = /** @type {ArrayBuffer} */ (source);
127 |       this.loadStatus = FontFaceLoadStatus.LOADED;
128 |       this.resolveLoad(fontface);
129 |     }
130 |   };
131 | 
132 |   var FontFace = fl.FontFace;
133 | 
134 |   /**
135 |    * @type {Element|null}
136 |    */
137 |   FontFace.STYLE_ELEMENT = null;
138 | 
139 |   /**
140 |    * Inserts the FontFace in the document.
141 |    */
142 |   FontFace.prototype.insert = function () {
143 |     if (!FontFace.STYLE_ELEMENT) {
144 |       FontFace.STYLE_ELEMENT = dom.createElement('style');
145 |       dom.append(document.head, FontFace.STYLE_ELEMENT);
146 |     }
147 | 
148 |     var src = null;
149 | 
150 |     if (this.loadStatus === FontFaceLoadStatus.LOADED) {
151 |       var bytes = new Uint8Array(this.buffer),
152 |           tmp = '';
153 | 
154 |       for (var i = 0; i < bytes.length; i++) {
155 |         tmp += String.fromCharCode(bytes[i]);
156 |       }
157 |       // TODO: Set the correct font format.
158 |       src = 'url(data:font/opentype;base64,' + btoa(tmp) + ')';
159 |     } else {
160 |       src = this.source;
161 |     }
162 | 
163 |     // This doesn't use font-stretch, font-variant or font-feature-settings
164 |     // because support is hardly there and horribly broken.
165 |     var css = '@font-face{' +
166 |       'font-family:"' + this['family'] + '";' +
167 |       'font-style:' + this['style'] + ';' +
168 |       'font-weight:' + this['weight'] + ';' +
169 |       'font-display:' + this['display'] + ';' +
170 |     // TODO: unicode-range is fairly buggy in Chrome when it is used in combination
171 |     // with characters that also have OpenType features. Disable it for now because
172 |     // it's causing those characters not to render.
173 |     //  'unicode-range:' + this['unicodeRange'] + ';' +
174 |       'src:' + src + ';' +
175 |     '}';
176 | 
177 |     FontFace.STYLE_ELEMENT.sheet.insertRule(css, 0);
178 | 
179 |     this.rule = FontFace.STYLE_ELEMENT.sheet.cssRules[0];
180 |   };
181 | 
182 |   /**
183 |    * Remove the FontFace from the document.
184 |    */
185 |   FontFace.prototype.remove = function () {
186 |     if (FontFace.STYLE_ELEMENT && this.rule) {
187 |       for (var i = 0; i < FontFace.STYLE_ELEMENT.sheet.cssRules.length; i++) {
188 |         if (this.rule === FontFace.STYLE_ELEMENT.sheet.cssRules[i]) {
189 |           FontFace.STYLE_ELEMENT.sheet.deleteRule(i);
190 |           this.rule = null;
191 |           break;
192 |         }
193 |       }
194 |     }
195 |   };
196 | 
197 |   /**
198 |    * @private
199 |    *
200 |    * @param {Array.<string>} formats
201 |    *
202 |    * @return {string|null}
203 |    */
204 |   FontFace.prototype.getMatchingUrls = function (formats) {
205 |     var url = null;
206 | 
207 |     // find matching format in urls
208 |     for (var i = 0; i < formats.length; i++) {
209 |       for (var j = 0; j < this.urls.length; j++) {
210 |         if (formats[i] === this.urls[j].format && url === null) {
211 |           url = this.urls[j].url;
212 |           break;
213 |         }
214 |       }
215 |     }
216 | 
217 |     // If there is no format but the browser supports at least
218 |     // one format, just load the first one.
219 |     if (!url && formats.length !== 0) {
220 |       url = this.urls[0].url;
221 |     }
222 | 
223 |     return url;
224 |   };
225 | 
226 |   /**
227 |    * @return {Promise.<fl.FontFace>}
228 |    */
229 |   FontFace.prototype.load = function () {
230 |     var fontface = this;
231 | 
232 |     if (fontface.loadStatus === FontFaceLoadStatus.UNLOADED) {
233 |       fontface.loadStatus = FontFaceLoadStatus.LOADING;
234 | 
235 |       FontFormat.detect().then(function (formats) {
236 |         var url = fontface.getMatchingUrls(formats);
237 | 
238 |         if (url) {
239 |           fetch(url).then(function (response) {
240 |             if (response.ok) {
241 |               return response.arrayBuffer();
242 |             } else {
243 |               throw response;
244 |             }
245 |           }).then(function (buffer) {
246 |             fontface.buffer = buffer;
247 |             fontface.loadStatus = FontFaceLoadStatus.LOADED;
248 |             fontface.resolveLoad(fontface);
249 |           }).catch(function (e) {
250 |             fontface.loadStatus = FontFaceLoadStatus.ERROR;
251 |             fontface.rejectLoad(fontface);
252 |           });
253 |         } else {
254 |           fontface.loadStatus = FontFaceLoadStatus.ERROR;
255 |           fontface.rejectLoad(fontface);
256 |         }
257 |       }).catch(function () {
258 |         fontface.loadStatus = FontFaceLoadStatus.ERROR;
259 |         fontface.rejectLoad(fontface);
260 |       });
261 |     }
262 |     return this.promise;
263 |   };
264 | });
265 | 


--------------------------------------------------------------------------------
/test/fontfaceset-test.js:
--------------------------------------------------------------------------------
  1 | describe('FontFaceSet', function () {
  2 |   var FontFaceSet = fl.FontFaceSet,
  3 |       FontFace = fl.FontFace,
  4 | 
  5 |       font1 = null,
  6 |       font2 = null,
  7 |       font3 = null,
  8 |       font4 = null;
  9 | 
 10 |   beforeEach(function () {
 11 |     font1 = new FontFace('1', 'url(font.woff)', {});
 12 |     font2 = new FontFace('2', 'url(font.woff)', {});
 13 |     font3 = new FontFace('3', 'url(font.woff)', {});
 14 |     font4 = new FontFace('4', 'url(font.woff)', {});
 15 |   });
 16 | 
 17 | 
 18 |   describe('#constructor', function () {
 19 |     it('sets the size to zero and status to "loaded"', function () {
 20 |       var set = new FontFaceSet();
 21 | 
 22 |       expect(set.size, 'to equal', 0);
 23 |       expect(set.status, 'to equal', 'loaded');
 24 |     });
 25 |   });
 26 | 
 27 |   describe('#add', function () {
 28 |     it('adds non duplicate items', function () {
 29 |       var set = new FontFaceSet();
 30 | 
 31 |       set.add(font1);
 32 |       set.add(font2);
 33 |       set.add(font3);
 34 | 
 35 |       expect(set.size, 'to equal', 3);
 36 |       expect(set.fonts, 'to equal', [font1, font2, font3]);
 37 |     });
 38 | 
 39 |     it('adds duplicate items only once', function () {
 40 |       var set = new FontFaceSet();
 41 | 
 42 |       set.add(font1);
 43 |       set.add(font2);
 44 | 
 45 |       set.add(font1);
 46 |       set.add(font2);
 47 | 
 48 |       expect(set.size, 'to equal', 2);
 49 |       expect(set.fonts, 'to equal', [font1, font2]);
 50 |     });
 51 |   });
 52 | 
 53 |   describe('#has', function () {
 54 |     it('has items that are in the set', function () {
 55 |       var set = new FontFaceSet();
 56 | 
 57 |       set.add(font1);
 58 |       set.add(font3);
 59 | 
 60 |       expect(set.has(font1), 'to be true');
 61 |       expect(set.has(font3), 'to be true');
 62 |     });
 63 | 
 64 |     it('does not have items that are in the set', function () {
 65 |       var set = new FontFaceSet();
 66 | 
 67 |       set.add(font1);
 68 |       set.add(font3);
 69 | 
 70 |       expect(set.has(font2), 'to be false');
 71 |       expect(set.has(font4), 'to be false');
 72 |     });
 73 |   });
 74 | 
 75 |   describe('#delete', function () {
 76 |     it('removes the value and returns true', function () {
 77 |       var set = new FontFaceSet();
 78 | 
 79 |       set.add(font1);
 80 |       set.add(font2);
 81 |       set.add(font3);
 82 | 
 83 |       expect(set.delete(font2), 'to be true');
 84 |       expect(set.size, 'to equal', 2);
 85 |       expect(set.has(font1), 'to be true');
 86 |       expect(set.has(font2), 'to be false');
 87 |       expect(set.has(font3), 'to be true');
 88 |     });
 89 | 
 90 |     it('returns false if the value was not found', function () {
 91 |       var set = new FontFaceSet();
 92 | 
 93 |       set.add(font1);
 94 |       set.add(font2);
 95 | 
 96 |       expect(set.delete(font3), 'to be false');
 97 |       expect(set.size, 'to equal', 2);
 98 |       expect(set.has(font1), 'to be true');
 99 |       expect(set.has(font2), 'to be true');
100 |     });
101 |   });
102 | 
103 |   describe('#clear', function () {
104 |     it('removes all values from the set', function () {
105 |       var set = new FontFaceSet();
106 | 
107 |       set.add(font1);
108 |       set.add(font2);
109 | 
110 |       set.clear();
111 |       expect(set.size, 'to equal', 0);
112 |       expect(set.fonts, 'to equal', []);
113 |     });
114 |   });
115 | 
116 |   describe('#forEach', function () {
117 |     it('iterates over all values', function () {
118 |       var set = new FontFaceSet(),
119 |           values = [];
120 | 
121 |       set.add(font1);
122 |       set.add(font2);
123 | 
124 |       set.forEach(function (value, key, set) {
125 |         values.push([value, key, set]);
126 |       });
127 | 
128 |       expect(values, 'to equal', [[font1, 0, set], [font2, 1, set]]);
129 |     });
130 |   });
131 | 
132 |   describe('#match', function () {
133 |     it('returns an empty array', function () {
134 |       var set = new FontFaceSet();
135 | 
136 |       expect(set.match('300px "My Family"'), 'to have length', 0);
137 |     });
138 | 
139 |     it('returns one match', function () {
140 |       var set = new FontFaceSet(),
141 |           font = new FontFace('My Family', 'url(font.woff)');
142 | 
143 |       set.add(font);
144 | 
145 |       expect(set.match('16px "My Family"'), 'to equal', [font]);
146 |     });
147 | 
148 |     it('returns two matches', function () {
149 |       var set = new FontFaceSet(),
150 |           font1 = new FontFace('My Family', 'url(font.woff)', {}),
151 |           font2 = new FontFace('My Other Family', 'url(font.woff)', {});
152 | 
153 |       set.add(font1);
154 |       set.add(font2);
155 | 
156 |       expect(set.match('16px "My Family", "My Other Family"'), 'to equal', [font1, font2]);
157 |     });
158 | 
159 |     it('returns one match out of two possible', function () {
160 |       var set = new FontFaceSet(),
161 |           font1 = new FontFace('My Family', 'url(font.woff)', {}),
162 |           font2 = new FontFace('My Other Family', 'url(font.woff)', {});
163 | 
164 |       set.add(font1);
165 |       set.add(font2);
166 | 
167 |       expect(set.match('16px "My Other Family"'), 'to equal', [font2]);
168 |     });
169 | 
170 |     it('returns null on an invalid font string', function () {
171 |       var set = new FontFaceSet();
172 | 
173 |       expect(set.match('san-see'), 'to be null');
174 |     });
175 | 
176 |     xit('rejects a match because of a mismatching unicode range', function () {
177 |       var set = new FontFaceSet(),
178 |           font = new FontFace('My Family', 'url(font.woff)', { unicodeRange: 'u+0' });
179 | 
180 |       set.add(font);
181 | 
182 |       expect(set.match('16px "My Family"'), 'to equal', []);
183 |     });
184 |   });
185 | 
186 |   describe('#load', function () {
187 |     it('loads a font', function (done) {
188 |       var set = new FontFaceSet(),
189 |           font = new FontFace('Font1', 'url(./assets/sourcesanspro-regular.woff) format("woff"), url(./assets/sourcesanspro-regular.ttf) format("truetype")');
190 | 
191 |       set.add(font);
192 | 
193 |       set.load('16px Font1').then(function (fonts) {
194 |         expect(set.status, 'to equal', 'loaded');
195 |         expect(fonts[0], 'to equal', font);
196 |         done();
197 |       }).catch(function () {
198 |         done(new Error('Should not be called'));
199 |       });
200 |     });
201 | 
202 |     it('fails to load a font', function (done) {
203 |       var set = new FontFaceSet(),
204 |           font = new FontFace('Font2', 'url(unknown.woff) format("woff"), url(unknown.ttf) format("truetype")');
205 | 
206 |       set.add(font);
207 | 
208 |       set.load('16px Font2').then(function (fonts) {
209 |         expect(set.status, 'to equal', 'loaded');
210 |         expect(fonts, 'to equal', [font]);
211 |         done();
212 |       }).catch(function () {
213 |         done(new Error('Should not be called'));
214 |       });
215 |     });
216 | 
217 |     it('returns an empty array when there are no matches in the set', function (done) {
218 |       var set = new FontFaceSet();
219 | 
220 |       set.load('16px Font').then(function (fonts) {
221 |         expect(set.status, 'to equal', 'loaded');
222 |         expect(fonts, 'to equal', []);
223 |         done();
224 |       }).catch(function () {
225 |         done(new Error('Should not be called'));
226 |       });
227 |     });
228 | 
229 |     it('rejects the promise if the font string is invalid', function (done) {
230 |       var set = new FontFaceSet();
231 | 
232 |       set.load('see-sa').then(function () {
233 |         done(new Error('Should not be called'));
234 |       }).catch(function (fonts) {
235 |         expect(fonts, 'to equal', []);
236 |         done();
237 |       });
238 |     });
239 | 
240 |     it('loads multiple matching fonts', function (done) {
241 |       var set = new FontFaceSet(),
242 |           font1 = new FontFace('Font1', 'url(./assets/sourcesanspro-regular.woff) format("woff"), url(./assets/sourcesanspro-regular.ttf) format("truetype")'),
243 |           font2 = new FontFace('Font2', 'url(./assets/sourcesanspro-regular.woff) format("woff"), url(./assets/sourcesanspro-regular.ttf) format("truetype")');
244 | 
245 |       set.add(font1);
246 |       set.add(font2);
247 | 
248 |       set.load('16px Font1, Font2').then(function (fonts) {
249 |         expect(set.status, 'to equal', 'loaded');
250 |         expect(fonts, 'to equal', [font1, font2]);
251 |         done();
252 |       }).catch(function () {
253 |         done(new Error('Should not be called'));
254 |       });
255 |     });
256 | 
257 |     it('loads a preloaded font', function (done) {
258 |       var set = new FontFaceSet(),
259 |           font = new FontFace('Font1', 'url(./assets/sourcesanspro-regular.woff) format("woff"), url(./assets/sourcesanspro-regular.ttf) format("truetype")');
260 | 
261 |       font.load().then(function () {
262 |         set.add(font);
263 | 
264 |         set.load('16px Font1').then(function (fonts) {
265 |           expect(set.status, 'to equal', 'loaded');
266 |           expect(fonts, 'to equal', [font]);
267 |           done();
268 |         }).catch(function () {
269 |           done(new Error('Should not be called'));
270 |         });
271 |       });
272 |     });
273 |   });
274 | 
275 |   describe('#check', function () {
276 |     it('returns true if the family is in the set and loaded', function () {
277 |       var set = new FontFaceSet(),
278 |           font1 = new FontFace('My Family', new ArrayBuffer(1));
279 | 
280 |       set.add(font1);
281 | 
282 |       expect(set.check('16px My Family'), 'to be true');
283 |     });
284 | 
285 |     it('returns false if the family is not in the set', function () {
286 |       var set = new FontFaceSet();
287 | 
288 |       expect(set.check('16px My Family'), 'to be false');
289 |     });
290 | 
291 |     it('returns false if the family is in the set and not loaded', function () {
292 |       var set = new FontFaceSet(),
293 |           font1 = new FontFace('My Other Family', 'url(font.woff)');
294 | 
295 |       set.add(font1);
296 | 
297 |       expect(set.check('16px My Other Family'), 'to be false');
298 |     });
299 | 
300 |     it('returns false if only some of the fonts are loaded', function () {
301 |       var set = new FontFaceSet(),
302 |           font1 = new FontFace('My Family', new ArrayBuffer(1)),
303 |           font2 = new FontFace('My Other Family', 'url(font.woff)');
304 | 
305 |       set.add(font1);
306 |       set.add(font2);
307 | 
308 |       expect(set.check('16px My Family'), 'to be true');
309 |       expect(set.check('16px My Other Family'), 'to be false');
310 | 
311 |       expect(set.check('16px My Family, My Other Family'), 'to be false');
312 |     });
313 |   });
314 | });
315 | 


--------------------------------------------------------------------------------
/fontloader.js:
--------------------------------------------------------------------------------
 1 | (function(){'use strict';var f=[];function g(a){f.push(a);1===f.length&&l()}function m(){for(;f.length;)f[0](),f.shift()}if(window.MutationObserver){var n=document.createElement("div");(new MutationObserver(m)).observe(n,{attributes:!0});var l=function(){n.setAttribute("x",0)}}else l=function(){setTimeout(m)};function p(a){this.a=q;this.b=void 0;this.f=[];var b=this;try{a(function(a){r(b,a)},function(a){t(b,a)})}catch(c){t(b,c)}}var q=2;function u(a){return new p(function(b,c){c(a)})}function v(a){return new p(function(b){b(a)})}
 2 | function r(a,b){if(a.a===q){if(b===a)throw new TypeError("Promise settled with itself.");var c=!1;try{var d=b&&b.then;if(null!==b&&"object"===typeof b&&"function"===typeof d){d.call(b,function(b){c||r(a,b);c=!0},function(b){c||t(a,b);c=!0});return}}catch(e){c||t(a,e);return}a.a=0;a.b=b;w(a)}}function t(a,b){if(a.a===q){if(b===a)throw new TypeError("Promise settled with itself.");a.a=1;a.b=b;w(a)}}
 3 | function w(a){g(function(){if(a.a!==q)for(;a.f.length;){var b=a.f.shift(),c=b[0],d=b[1],e=b[2],b=b[3];try{0===a.a?"function"===typeof c?e(c.call(void 0,a.b)):e(a.b):1===a.a&&("function"===typeof d?e(d.call(void 0,a.b)):b(a.b))}catch(h){b(h)}}})}p.prototype.g=function(a){return this.c(void 0,a)};p.prototype.c=function(a,b){var c=this;return new p(function(d,e){c.f.push([a,b,d,e]);w(c)})};
 4 | function x(a){return new p(function(b,c){function d(c){return function(d){h[c]=d;e+=1;e===a.length&&b(h)}}var e=0,h=[];0===a.length&&b(h);for(var k=0;k<a.length;k+=1)v(a[k]).c(d(k),c)})}function y(a){return new p(function(b,c){for(var d=0;d<a.length;d+=1)v(a[d]).c(b,c)})};window.Promise||(window.Promise=p,window.Promise.resolve=v,window.Promise.reject=u,window.Promise.race=y,window.Promise.all=x,window.Promise.prototype.then=p.prototype.c,window.Promise.prototype["catch"]=p.prototype.g);}());
 5 | 
 6 | (function(){'use strict';var g=document.createElement("div");
 7 | function h(a){g.style.cssText="font:"+a;if(g.style.fontFamily){a:{a=g.style.fontFamily;for(var b="",c=[],e=0;e<a.length;e++){var d=a.charAt(e);if("'"===d||'"'===d){b=e+1;do if(b=a.indexOf(d,b)+1,!b){a=null;break a}while("\\"===a.charAt(b-2));c.push(a.slice(e+1,b-1));e=b-1;b=""}else","===d?(b=b.trim(),""!==b&&(c.push(b),b="")):b+=d}b=b.trim();""!==b&&c.push(b);a=c}if(a)return{size:g.style.fontSize,lineHeight:g.style.lineHeight||"normal",style:g.style.fontStyle||"normal",variant:g.style.fontVariant||
 8 | "normal",weight:g.style.fontWeight||"normal",stretch:g.style.fontStretch||"normal",family:a}}return null};function m(){this.fonts=[];this.b="loaded";Object.defineProperties(this,{status:{get:function(){return this.b}},size:{get:function(){return this.fonts.length}}})}
 9 | m.prototype.add=function(a){if(!this.has(a)){n||(n=document.createElement("style"),document.head.appendChild(n));var b=null;if("loaded"===a.b){for(var b=new Uint8Array(a.f),c="",e=0;e<b.length;e++)c+=String.fromCharCode(b[e]);b="url(data:font/opentype;base64,"+btoa(c)+")"}else b=a.l;n.sheet.insertRule('@font-face{font-family:"'+a.family+'";font-style:'+a.style+";font-weight:"+a.weight+";unicode-range:"+a.unicodeRange+";src:"+b+";}",0);a.c=n.sheet.cssRules[0];this.fonts.push(a)}};
10 | m.prototype["delete"]=function(a){var b=this.fonts.indexOf(a);if(-1!==b){if(n&&a.c)for(var c=0;c<n.sheet.cssRules.length;c++)if(a.c===n.sheet.cssRules[c]){n.sheet.deleteRule(c);a.c=null;break}this.fonts.splice(b,1);return!0}return!1};m.prototype.clear=function(){this.fonts=[]};m.prototype.has=function(a){return-1!==this.fonts.indexOf(a)};m.prototype.forEach=function(a){var b=this;this.fonts.forEach(function(c,e){a(c,e,b)})};
11 | function r(a,b){function c(a){return"bold"===a?700:"normal"===a?400:a}var e=h(b);return null===e?null:a.fonts.filter(function(a){for(var b=e.family,f=0;f<b.length;f++)if(a.family===b[f]&&a.style===e.style&&a.stretch===e.stretch&&c(a.weight)===c(e.weight))return!0;return!1})}
12 | m.prototype.load=function(a){var b=this,c=r(this,a);return null===c?Promise.reject([]):c.length?(b.b="loading",Promise.all(c.map(function(a){return a.h()})).then(function(){b.b="loaded";return c}).catch(function(){b.b="loaded";return c})):Promise.resolve([])};m.prototype.check=function(a){a=r(this,a);if(0===a.length)return!1;for(var b=0;b<a.length;b++)if("loaded"!==a[b].status)return!1;return!0};function x(a){for(var b=/\burl\((\'|\"|)([^\'\"]+?)\1\)( format\((\'|\"|)([^\'\"]+?)\4\))?/g,c=null,e=[];c=b.exec(a);)c[2]&&e.push({url:c[2],format:c[5]});return e};function y(a,b){this.status=b.status;this.ok=200<=b.status&&300>b.status||0===b.status;this.statusText=b.statusText;this.body=a}y.prototype.arrayBuffer=function(){return Promise.resolve(this.body)};var z=!(window.XDomainRequest&&!("responseType"in XMLHttpRequest.prototype));
13 | function A(a){var b={};return new Promise(function(c,e){if(z){var d=new XMLHttpRequest;d.onload=function(){c(new y(d.response,{status:d.status,statusText:d.statusText}))};d.onerror=function(){e(new TypeError("Network request failed"))};d.open("GET",a);d.responseType="arraybuffer";b&&Object.keys(b).forEach(function(a){d.setRequestHeader(a,b[a])});d.send(null)}else d=new XDomainRequest,d.open("GET",a.replace(/^http(s)?:/i,window.location.protocol)),d.ontimeout=function(){return!0},d.onprogress=function(){return!0},
14 | d.onload=function(){c(new y(d.responseText,{status:d.status,statusText:d.statusText}))},d.onerror=function(){e(new TypeError("Network request failed"))},setTimeout(function(){d.send(null)},0)})};function C(a){document.body?a():document.addEventListener("DOMContentLoaded",a)};function D(){this.a=document.createElement("div");this.a.setAttribute("aria-hidden","true");this.a.appendChild(document.createTextNode("@"));this.c=document.createElement("span");this.f=document.createElement("span");this.i=document.createElement("span");this.h=document.createElement("span");this.g=-1;this.c.style.cssText="display:inline-block;position:absolute;height:100%;width:100%;overflow:scroll;font-size:16px;";this.f.style.cssText="display:inline-block;position:absolute;height:100%;width:100%;overflow:scroll;font-size:16px;";
15 | this.h.style.cssText="display:inline-block;position:absolute;height:100%;width:100%;overflow:scroll;font-size:16px;";this.i.style.cssText="display:inline-block;width:200%;height:200%;font-size:16px;";this.c.appendChild(this.i);this.f.appendChild(this.h);this.a.appendChild(this.c);this.a.appendChild(this.f)}
16 | function E(a,b,c){a.a.style.cssText="min-width:20px;min-height:20px;display:inline-block;overflow:hidden;position:absolute;width:auto;margin:0;padding:0;top:-999px;left:-999px;white-space:nowrap;font-size:100px;font-family:"+b+";"+c}function F(a){var b=a.a.offsetWidth,c=b+100;a.h.style.width=c+"px";a.f.scrollLeft=c;a.c.scrollLeft=a.c.scrollWidth+100;return a.g!==b?(a.g=b,!0):!1}
17 | function G(a,b){a.c.addEventListener("scroll",function(){F(a)&&null!==a.a.parentNode&&b(a.g)},!1);a.f.addEventListener("scroll",function(){F(a)&&null!==a.a.parentNode&&b(a.g)},!1);F(a)};function H(){var a={};this.family="_fff_";this.style=a.style||"normal";this.variant=a.variant||"normal";this.weight=a.weight||"normal";this.stretch=a.stretch||"stretch";this.featureSettings=a.featureSettings||"normal"}var I=null;
18 | function J(){var a=new H,b="font-style:"+a.style+";font-variant:"+a.variant+";font-weight:"+a.weight+";font-stretch:"+a.stretch+";font-feature-settings:"+a.featureSettings+";-moz-font-feature-settings:"+a.featureSettings+";-webkit-font-feature-settings:"+a.featureSettings+";",c=document.createElement("div"),e=new D,d=new D,p=new D,f=-1,k=-1,l=-1,t=-1,u=-1,v=-1;return new Promise(function(q,M){function B(){null!==c.parentNode&&c.parentNode.removeChild(c)}function w(){if(-1!==f&&-1!==k||-1!==f&&-1!==
19 | l||-1!==k&&-1!==l)if(f===k||f===l||k===l){if(null===I){var b=/AppleWebKit\/([0-9]+)(?:\.([0-9]+))/.exec(window.navigator.userAgent);I=!!b&&(536>parseInt(b[1],10)||536===parseInt(b[1],10)&&11>=parseInt(b[2],10))}I?f===t&&k===t&&l===t||f===u&&k===u&&l===u||f===v&&k===v&&l===v||(B(),q(a)):(B(),q(a))}}C(function(){function q(){if(5E3<=Date.now()-N)B(),M(a);else{var b=document.hidden;if(!0===b||void 0===b)f=e.a.offsetWidth,k=d.a.offsetWidth,l=p.a.offsetWidth,w();setTimeout(q,50)}}var N=Date.now();E(e,
20 | "sans-serif",b);E(d,"serif",b);E(p,"monospace",b);c.appendChild(e.a);c.appendChild(d.a);c.appendChild(p.a);document.body.appendChild(c);t=e.a.offsetWidth;u=d.a.offsetWidth;v=p.a.offsetWidth;q();G(e,function(a){f=a;w()});E(e,'"'+a.family+'",sans-serif',b);G(d,function(a){k=a;w()});E(d,'"'+a.family+'",serif',b);G(p,function(a){l=a;w()});E(p,'"'+a.family+'",monospace',b)})})};var K=null;
21 | function L(){if(!K){var a=document.createElement("style"),b=document.getElementsByTagName("head")[0];a.appendChild(document.createTextNode('@font-face{font-family:"_fff_";src:url(data:font/woff2;base64,d09GMgABAAAAAADcAAoAAAAAAggAAACWAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAABk4ALAoUNAE2AiQDCAsGAAQgBSAHIBtvAciuMTaGVo8IaqBbcKPeB3CyAAIO4unr9nb72QE3p00iGQQIZcAAcAMEJOztBx7zdWVWn//BAPW1l0BN429cPrCPE75MA637gPs0DjavNxzHtWeXXErKIV3AF9TbHqCTOATL2BgjeIH30lQwSAonU1LabV8Iz12wDvgd/obV5QVxXDKvUhW1QfWNrS6HzEQJaP4tBA==) format("woff2"),url(data:application/font-woff;base64,d09GRgABAAAAAAHgAAoAAAAAAggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABPUy8yAAABUAAAABcAAABOBIQEIWNtYXAAAAFwAAAAJgAAACwADABzZ2x5ZgAAAaAAAAAUAAAAFAwBPQJoZWFkAAAA9AAAAC0AAAA2CHEB92hoZWEAAAEkAAAAFgAAACQMAQgDaG10eAAAAWgAAAAIAAAACAgAAABsb2NhAAABmAAAAAYAAAAGAAoAAG1heHAAAAE8AAAAEwAAACAABAACbmFtZQAAAbQAAAAeAAAAIAAjCF5wb3N0AAAB1AAAAAwAAAAgAAMAAHgBY2BkYABhb81vuvH8Nl8ZmFgYQOBCWvVrMP3VURxEczBAxBmYQAQAAFIIBgAAAHgBY2BkYGBhAAEOKAkUQQVMAAJKABkAAHgBY2BkYGBgAkIgjQ0AAAC+AAcAeAFjAIEUBkYGcoECgwILmAEiASBRAK4AAAAAAAgAAAB4AWNgYGBkYAZiBgYeBhYGBSDNAoQgvsP//xDy/0EwnwEATX4GfAAAAAAAAAAKAAAAAQAAAAAIAAQAAAEAADEBCAAEAHgBY2BgYGKQY2BmYGThZGAEshmgbCYw2wEABjMAigAAeAFjYGbACwAAfQAE) format("woff")}'));b.appendChild(a);
22 | K=J().then(function(){var c=new D,e=["opentype","truetype"];E(c,"_fff_","");document.body.appendChild(c.a);var d=c.a.offsetWidth;200<=d&&e.unshift("woff");300==d&&e.unshift("woff2");b.removeChild(a);document.body.removeChild(c.a);return e},function(){return["opentype","truetype"]})}return K};function O(a,b,c){var e=this,d=c||{};this.l=b;this.f=null;this.a=[];this.j=new Promise(function(a,b){e.i=a;e.g=b});this.b="unloaded";this.c=null;Object.defineProperties(this,{family:{get:function(){return a}},style:{get:function(){return d.style||"normal"}},weight:{get:function(){return d.weight||"normal"}},stretch:{get:function(){return d.stretch||"normal"}},unicodeRange:{get:function(){return d.unicodeRange||"U+0-10FFFF"}},variant:{get:function(){return d.variant||"normal"}},featureSettings:{get:function(){return d.featureSettings||
23 | "normal"}},status:{get:function(){return this.b}},loaded:{get:function(){return this.j}}});"string"===typeof b?this.a=x(b):(this.f=b,this.b="loaded",this.i(e))}var n=null;function P(a,b){for(var c=null,e=0;e<b.length;e++)for(var d=0;d<a.a.length;d++)if(b[e]===a.a[d].format&&null===c){c=a.a[d].url;break}c||0===b.length||(c=a.a[0].url);return c}
24 | O.prototype.h=function(){var a=this;"unloaded"===a.b&&(a.b="loading",L().then(function(b){(b=P(a,b))?A(b).then(function(a){if(a.ok)return a.arrayBuffer();throw a;}).then(function(b){a.f=b;a.b="loaded";a.i(a)}).catch(function(){a.b="error";a.g(a)}):(a.b="error",a.g(a))}).catch(function(){a.b="error";a.g(a)}));return this.j};window.FontFace||(window.FontFace=O,window.FontFace.prototype.load=O.prototype.h,document.fonts=new m);}());
25 | 


--------------------------------------------------------------------------------
/vendor/google/base.js:
--------------------------------------------------------------------------------
   1 | // Copyright 2006 The Closure Library Authors. All Rights Reserved.
   2 | //
   3 | // Licensed under the Apache License, Version 2.0 (the "License");
   4 | // you may not use this file except in compliance with the License.
   5 | // You may obtain a copy of the License at
   6 | //
   7 | //      http://www.apache.org/licenses/LICENSE-2.0
   8 | //
   9 | // Unless required by applicable law or agreed to in writing, software
  10 | // distributed under the License is distributed on an "AS-IS" BASIS,
  11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 | // See the License for the specific language governing permissions and
  13 | // limitations under the License.
  14 | 
  15 | /**
  16 |  * @fileoverview Bootstrap for the Google JS Library (Closure).
  17 |  *
  18 |  * In uncompiled mode base.js will write out Closure's deps file, unless the
  19 |  * global <code>CLOSURE_NO_DEPS</code> is set to true.  This allows projects to
  20 |  * include their own deps file(s) from different locations.
  21 |  *
  22 |  *
  23 |  * @provideGoog
  24 |  */
  25 | 
  26 | 
  27 | /**
  28 |  * @define {boolean} Overridden to true by the compiler when --closure_pass
  29 |  *     or --mark_as_compiled is specified.
  30 |  */
  31 | var COMPILED = false;
  32 | 
  33 | 
  34 | /**
  35 |  * Base namespace for the Closure library.  Checks to see goog is
  36 |  * already defined in the current scope before assigning to prevent
  37 |  * clobbering if base.js is loaded more than once.
  38 |  *
  39 |  * @const
  40 |  */
  41 | var goog = goog || {}; // Identifies this file as the Closure base.
  42 | 
  43 | 
  44 | /**
  45 |  * Reference to the global context.  In most cases this will be 'window'.
  46 |  */
  47 | goog.global = window;
  48 | 
  49 | 
  50 | /**
  51 |  * @define {boolean} DEBUG is provided as a convenience so that debugging code
  52 |  * that should not be included in a production js_binary can be easily stripped
  53 |  * by specifying --define goog.DEBUG=false to the JSCompiler. For example, most
  54 |  * toString() methods should be declared inside an "if (goog.DEBUG)" conditional
  55 |  * because they are generally used for debugging purposes and it is difficult
  56 |  * for the JSCompiler to statically determine whether they are used.
  57 |  */
  58 | goog.DEBUG = true;
  59 | 
  60 | 
  61 | /**
  62 |  * @define {string} LOCALE defines the locale being used for compilation. It is
  63 |  * used to select locale specific data to be compiled in js binary. BUILD rule
  64 |  * can specify this value by "--define goog.LOCALE=<locale_name>" as JSCompiler
  65 |  * option.
  66 |  *
  67 |  * Take into account that the locale code format is important. You should use
  68 |  * the canonical Unicode format with hyphen as a delimiter. Language must be
  69 |  * lowercase, Language Script - Capitalized, Region - UPPERCASE.
  70 |  * There are few examples: pt-BR, en, en-US, sr-Latin-BO, zh-Hans-CN.
  71 |  *
  72 |  * See more info about locale codes here:
  73 |  * http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers
  74 |  *
  75 |  * For language codes you should use values defined by ISO 693-1. See it here
  76 |  * http://www.w3.org/WAI/ER/IG/ert/iso639.htm. There is only one exception from
  77 |  * this rule: the Hebrew language. For legacy reasons the old code (iw) should
  78 |  * be used instead of the new code (he), see http://wiki/Main/IIISynonyms.
  79 |  */
  80 | goog.LOCALE = 'en';  // default to en
  81 | 
  82 | 
  83 | /**
  84 |  * @define {boolean} Whether this code is running on trusted sites.
  85 |  *
  86 |  * On untrusted sites, several native functions can be defined or overridden by
  87 |  * external libraries like Prototype, Datejs, and JQuery and setting this flag
  88 |  * to false forces closure to use its own implementations when possible.
  89 |  *
  90 |  * If your javascript can be loaded by a third party site and you are wary about
  91 |  * relying on non-standard implementations, specify
  92 |  * "--define goog.TRUSTED_SITE=false" to the JSCompiler.
  93 |  */
  94 | goog.TRUSTED_SITE = true;
  95 | 
  96 | 
  97 | /**
  98 |  * Creates object stubs for a namespace.  The presence of one or more
  99 |  * goog.provide() calls indicate that the file defines the given
 100 |  * objects/namespaces.  Build tools also scan for provide/require statements
 101 |  * to discern dependencies, build dependency files (see deps.js), etc.
 102 |  * @see goog.require
 103 |  * @param {string} name Namespace provided by this file in the form
 104 |  *     "goog.package.part".
 105 |  */
 106 | goog.provide = function(name) {
 107 |   if (!COMPILED) {
 108 |     // Ensure that the same namespace isn't provided twice. This is intended
 109 |     // to teach new developers that 'goog.provide' is effectively a variable
 110 |     // declaration. And when JSCompiler transforms goog.provide into a real
 111 |     // variable declaration, the compiled JS should work the same as the raw
 112 |     // JS--even when the raw JS uses goog.provide incorrectly.
 113 |     if (goog.isProvided_(name)) {
 114 |       throw Error('Namespace "' + name + '" already declared.');
 115 |     }
 116 |     delete goog.implicitNamespaces_[name];
 117 | 
 118 |     var namespace = name;
 119 |     while ((namespace = namespace.substring(0, namespace.lastIndexOf('.')))) {
 120 |       if (goog.getObjectByName(namespace)) {
 121 |         break;
 122 |       }
 123 |       goog.implicitNamespaces_[namespace] = true;
 124 |     }
 125 |   }
 126 | 
 127 |   goog.exportPath_(name);
 128 | };
 129 | 
 130 | 
 131 | /**
 132 |  * Marks that the current file should only be used for testing, and never for
 133 |  * live code in production.
 134 |  * @param {string=} opt_message Optional message to add to the error that's
 135 |  *     raised when used in production code.
 136 |  */
 137 | goog.setTestOnly = function(opt_message) {
 138 |   if (COMPILED && !goog.DEBUG) {
 139 |     opt_message = opt_message || '';
 140 |     throw Error('Importing test-only code into non-debug environment' +
 141 |                 opt_message ? ': ' + opt_message : '.');
 142 |   }
 143 | };
 144 | 
 145 | 
 146 | if (!COMPILED) {
 147 | 
 148 |   /**
 149 |    * Check if the given name has been goog.provided. This will return false for
 150 |    * names that are available only as implicit namespaces.
 151 |    * @param {string} name name of the object to look for.
 152 |    * @return {boolean} Whether the name has been provided.
 153 |    * @private
 154 |    */
 155 |   goog.isProvided_ = function(name) {
 156 |     return !goog.implicitNamespaces_[name] && !!goog.getObjectByName(name);
 157 |   };
 158 | 
 159 |   /**
 160 |    * Namespaces implicitly defined by goog.provide. For example,
 161 |    * goog.provide('goog.events.Event') implicitly declares
 162 |    * that 'goog' and 'goog.events' must be namespaces.
 163 |    *
 164 |    * @type {Object}
 165 |    * @private
 166 |    */
 167 |   goog.implicitNamespaces_ = {};
 168 | }
 169 | 
 170 | 
 171 | /**
 172 |  * Builds an object structure for the provided namespace path,
 173 |  * ensuring that names that already exist are not overwritten. For
 174 |  * example:
 175 |  * "a.b.c" -> a = {};a.b={};a.b.c={};
 176 |  * Used by goog.provide and goog.exportSymbol.
 177 |  * @param {string} name name of the object that this file defines.
 178 |  * @param {*=} opt_object the object to expose at the end of the path.
 179 |  * @param {Object=} opt_objectToExportTo The object to add the path to; default
 180 |  *     is |goog.global|.
 181 |  * @private
 182 |  */
 183 | goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
 184 |   var parts = name.split('.');
 185 |   var cur = opt_objectToExportTo || goog.global;
 186 | 
 187 |   // Internet Explorer exhibits strange behavior when throwing errors from
 188 |   // methods externed in this manner.  See the testExportSymbolExceptions in
 189 |   // base_test.html for an example.
 190 |   if (!(parts[0] in cur) && cur.execScript) {
 191 |     cur.execScript('var ' + parts[0]);
 192 |   }
 193 | 
 194 |   // Certain browsers cannot parse code in the form for((a in b); c;);
 195 |   // This pattern is produced by the JSCompiler when it collapses the
 196 |   // statement above into the conditional loop below. To prevent this from
 197 |   // happening, use a for-loop and reserve the init logic as below.
 198 | 
 199 |   // Parentheses added to eliminate strict JS warning in Firefox.
 200 |   for (var part; parts.length && (part = parts.shift());) {
 201 |     if (!parts.length && goog.isDef(opt_object)) {
 202 |       // last part and we have an object; use it
 203 |       cur[part] = opt_object;
 204 |     } else if (cur[part]) {
 205 |       cur = cur[part];
 206 |     } else {
 207 |       cur = cur[part] = {};
 208 |     }
 209 |   }
 210 | };
 211 | 
 212 | 
 213 | /**
 214 |  * Returns an object based on its fully qualified external name.  If you are
 215 |  * using a compilation pass that renames property names beware that using this
 216 |  * function will not find renamed properties.
 217 |  *
 218 |  * @param {string} name The fully qualified name.
 219 |  * @param {Object=} opt_obj The object within which to look; default is
 220 |  *     |goog.global|.
 221 |  * @return {?} The value (object or primitive) or, if not found, null.
 222 |  */
 223 | goog.getObjectByName = function(name, opt_obj) {
 224 |   var parts = name.split('.');
 225 |   var cur = opt_obj || goog.global;
 226 |   for (var part; part = parts.shift(); ) {
 227 |     if (goog.isDefAndNotNull(cur[part])) {
 228 |       cur = cur[part];
 229 |     } else {
 230 |       return null;
 231 |     }
 232 |   }
 233 |   return cur;
 234 | };
 235 | 
 236 | 
 237 | /**
 238 |  * Globalizes a whole namespace, such as goog or goog.lang.
 239 |  *
 240 |  * @param {Object} obj The namespace to globalize.
 241 |  * @param {Object=} opt_global The object to add the properties to.
 242 |  * @deprecated Properties may be explicitly exported to the global scope, but
 243 |  *     this should no longer be done in bulk.
 244 |  */
 245 | goog.globalize = function(obj, opt_global) {
 246 |   var global = opt_global || goog.global;
 247 |   for (var x in obj) {
 248 |     global[x] = obj[x];
 249 |   }
 250 | };
 251 | 
 252 | 
 253 | /**
 254 |  * Adds a dependency from a file to the files it requires.
 255 |  * @param {string} relPath The path to the js file.
 256 |  * @param {Array} provides An array of strings with the names of the objects
 257 |  *                         this file provides.
 258 |  * @param {Array} requires An array of strings with the names of the objects
 259 |  *                         this file requires.
 260 |  */
 261 | goog.addDependency = function(relPath, provides, requires) {
 262 |   if (!COMPILED) {
 263 |     var provide, require;
 264 |     var path = relPath.replace(/\\/g, '/');
 265 |     var deps = goog.dependencies_;
 266 |     for (var i = 0; provide = provides[i]; i++) {
 267 |       deps.nameToPath[provide] = path;
 268 |       if (!(path in deps.pathToNames)) {
 269 |         deps.pathToNames[path] = {};
 270 |       }
 271 |       deps.pathToNames[path][provide] = true;
 272 |     }
 273 |     for (var j = 0; require = requires[j]; j++) {
 274 |       if (!(path in deps.requires)) {
 275 |         deps.requires[path] = {};
 276 |       }
 277 |       deps.requires[path][require] = true;
 278 |     }
 279 |   }
 280 | };
 281 | 
 282 | 
 283 | 
 284 | 
 285 | // NOTE(nnaze): The debug DOM loader was included in base.js as an orignal
 286 | // way to do "debug-mode" development.  The dependency system can sometimes
 287 | // be confusing, as can the debug DOM loader's asyncronous nature.
 288 | //
 289 | // With the DOM loader, a call to goog.require() is not blocking -- the
 290 | // script will not load until some point after the current script.  If a
 291 | // namespace is needed at runtime, it needs to be defined in a previous
 292 | // script, or loaded via require() with its registered dependencies.
 293 | // User-defined namespaces may need their own deps file.  See http://go/js_deps,
 294 | // http://go/genjsdeps, or, externally, DepsWriter.
 295 | // http://code.google.com/closure/library/docs/depswriter.html
 296 | //
 297 | // Because of legacy clients, the DOM loader can't be easily removed from
 298 | // base.js.  Work is being done to make it disableable or replaceable for
 299 | // different environments (DOM-less JavaScript interpreters like Rhino or V8,
 300 | // for example). See bootstrap/ for more information.
 301 | 
 302 | 
 303 | /**
 304 |  * @define {boolean} Whether to enable the debug loader.
 305 |  *
 306 |  * If enabled, a call to goog.require() will attempt to load the namespace by
 307 |  * appending a script tag to the DOM (if the namespace has been registered).
 308 |  *
 309 |  * If disabled, goog.require() will simply assert that the namespace has been
 310 |  * provided (and depend on the fact that some outside tool correctly ordered
 311 |  * the script).
 312 |  */
 313 | goog.ENABLE_DEBUG_LOADER = true;
 314 | 
 315 | 
 316 | /**
 317 |  * Implements a system for the dynamic resolution of dependencies
 318 |  * that works in parallel with the BUILD system. Note that all calls
 319 |  * to goog.require will be stripped by the JSCompiler when the
 320 |  * --closure_pass option is used.
 321 |  * @see goog.provide
 322 |  * @param {string} name Namespace to include (as was given in goog.provide())
 323 |  *     in the form "goog.package.part".
 324 |  */
 325 | goog.require = function(name) {
 326 | 
 327 |   // if the object already exists we do not need do do anything
 328 |   // TODO(arv): If we start to support require based on file name this has
 329 |   //            to change
 330 |   // TODO(arv): If we allow goog.foo.* this has to change
 331 |   // TODO(arv): If we implement dynamic load after page load we should probably
 332 |   //            not remove this code for the compiled output
 333 |   if (!COMPILED) {
 334 |     if (goog.isProvided_(name)) {
 335 |       return;
 336 |     }
 337 | 
 338 |     if (goog.ENABLE_DEBUG_LOADER) {
 339 |       var path = goog.getPathFromDeps_(name);
 340 |       if (path) {
 341 |         goog.included_[path] = true;
 342 |         goog.writeScripts_();
 343 |         return;
 344 |       }
 345 |     }
 346 | 
 347 |     var errorMessage = 'goog.require could not find: ' + name;
 348 |     if (goog.global.console) {
 349 |       goog.global.console['error'](errorMessage);
 350 |     }
 351 | 
 352 | 
 353 |       throw Error(errorMessage);
 354 | 
 355 |   }
 356 | };
 357 | 
 358 | 
 359 | /**
 360 |  * Path for included scripts
 361 |  * @type {string}
 362 |  */
 363 | goog.basePath = '';
 364 | 
 365 | 
 366 | /**
 367 |  * A hook for overriding the base path.
 368 |  * @type {string|undefined}
 369 |  */
 370 | goog.global.CLOSURE_BASE_PATH;
 371 | 
 372 | 
 373 | /**
 374 |  * Whether to write out Closure's deps file. By default,
 375 |  * the deps are written.
 376 |  * @type {boolean|undefined}
 377 |  */
 378 | goog.global.CLOSURE_NO_DEPS;
 379 | 
 380 | 
 381 | /**
 382 |  * A function to import a single script. This is meant to be overridden when
 383 |  * Closure is being run in non-HTML contexts, such as web workers. It's defined
 384 |  * in the global scope so that it can be set before base.js is loaded, which
 385 |  * allows deps.js to be imported properly.
 386 |  *
 387 |  * The function is passed the script source, which is a relative URI. It should
 388 |  * return true if the script was imported, false otherwise.
 389 |  */
 390 | goog.global.CLOSURE_IMPORT_SCRIPT;
 391 | 
 392 | 
 393 | /**
 394 |  * Null function used for default values of callbacks, etc.
 395 |  * @return {void} Nothing.
 396 |  */
 397 | goog.nullFunction = function() {};
 398 | 
 399 | 
 400 | /**
 401 |  * The identity function. Returns its first argument.
 402 |  *
 403 |  * @param {*=} opt_returnValue The single value that will be returned.
 404 |  * @param {...*} var_args Optional trailing arguments. These are ignored.
 405 |  * @return {?} The first argument. We can't know the type -- just pass it along
 406 |  *      without type.
 407 |  * @deprecated Use goog.functions.identity instead.
 408 |  */
 409 | goog.identityFunction = function(opt_returnValue, var_args) {
 410 |   return opt_returnValue;
 411 | };
 412 | 
 413 | 
 414 | /**
 415 |  * When defining a class Foo with an abstract method bar(), you can do:
 416 |  *
 417 |  * Foo.prototype.bar = goog.abstractMethod
 418 |  *
 419 |  * Now if a subclass of Foo fails to override bar(), an error
 420 |  * will be thrown when bar() is invoked.
 421 |  *
 422 |  * Note: This does not take the name of the function to override as
 423 |  * an argument because that would make it more difficult to obfuscate
 424 |  * our JavaScript code.
 425 |  *
 426 |  * @type {!Function}
 427 |  * @throws {Error} when invoked to indicate the method should be
 428 |  *   overridden.
 429 |  */
 430 | goog.abstractMethod = function() {
 431 |   throw Error('unimplemented abstract method');
 432 | };
 433 | 
 434 | 
 435 | /**
 436 |  * Adds a {@code getInstance} static method that always return the same instance
 437 |  * object.
 438 |  * @param {!Function} ctor The constructor for the class to add the static
 439 |  *     method to.
 440 |  */
 441 | goog.addSingletonGetter = function(ctor) {
 442 |   ctor.getInstance = function() {
 443 |     if (ctor.instance_) {
 444 |       return ctor.instance_;
 445 |     }
 446 |     if (goog.DEBUG) {
 447 |       // NOTE: JSCompiler can't optimize away Array#push.
 448 |       goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor;
 449 |     }
 450 |     return ctor.instance_ = new ctor;
 451 |   };
 452 | };
 453 | 
 454 | 
 455 | /**
 456 |  * All singleton classes that have been instantiated, for testing. Don't read
 457 |  * it directly, use the {@code goog.testing.singleton} module. The compiler
 458 |  * removes this variable if unused.
 459 |  * @type {!Array.<!Function>}
 460 |  * @private
 461 |  */
 462 | goog.instantiatedSingletons_ = [];
 463 | 
 464 | 
 465 | if (!COMPILED && goog.ENABLE_DEBUG_LOADER) {
 466 |   /**
 467 |    * Object used to keep track of urls that have already been added. This
 468 |    * record allows the prevention of circular dependencies.
 469 |    * @type {Object}
 470 |    * @private
 471 |    */
 472 |   goog.included_ = {};
 473 | 
 474 | 
 475 |   /**
 476 |    * This object is used to keep track of dependencies and other data that is
 477 |    * used for loading scripts
 478 |    * @private
 479 |    * @type {Object}
 480 |    */
 481 |   goog.dependencies_ = {
 482 |     pathToNames: {}, // 1 to many
 483 |     nameToPath: {}, // 1 to 1
 484 |     requires: {}, // 1 to many
 485 |     // used when resolving dependencies to prevent us from
 486 |     // visiting the file twice
 487 |     visited: {},
 488 |     written: {} // used to keep track of script files we have written
 489 |   };
 490 | 
 491 | 
 492 |   /**
 493 |    * Tries to detect whether is in the context of an HTML document.
 494 |    * @return {boolean} True if it looks like HTML document.
 495 |    * @private
 496 |    */
 497 |   goog.inHtmlDocument_ = function() {
 498 |     var doc = goog.global.document;
 499 |     return typeof doc != 'undefined' &&
 500 |            'write' in doc;  // XULDocument misses write.
 501 |   };
 502 | 
 503 | 
 504 |   /**
 505 |    * Tries to detect the base path of the base.js script that bootstraps Closure
 506 |    * @private
 507 |    */
 508 |   goog.findBasePath_ = function() {
 509 |     if (goog.global.CLOSURE_BASE_PATH) {
 510 |       goog.basePath = goog.global.CLOSURE_BASE_PATH;
 511 |       return;
 512 |     } else if (!goog.inHtmlDocument_()) {
 513 |       return;
 514 |     }
 515 |     var doc = goog.global.document;
 516 |     var scripts = doc.getElementsByTagName('script');
 517 |     // Search backwards since the current script is in almost all cases the one
 518 |     // that has base.js.
 519 |     for (var i = scripts.length - 1; i >= 0; --i) {
 520 |       var src = scripts[i].src;
 521 |       var qmark = src.lastIndexOf('?');
 522 |       var l = qmark == -1 ? src.length : qmark;
 523 |       if (src.substr(l - 7, 7) == 'base.js') {
 524 |         goog.basePath = src.substr(0, l - 7);
 525 |         return;
 526 |       }
 527 |     }
 528 |   };
 529 | 
 530 | 
 531 |   /**
 532 |    * Imports a script if, and only if, that script hasn't already been imported.
 533 |    * (Must be called at execution time)
 534 |    * @param {string} src Script source.
 535 |    * @private
 536 |    */
 537 |   goog.importScript_ = function(src) {
 538 |     var importScript = goog.global.CLOSURE_IMPORT_SCRIPT ||
 539 |         goog.writeScriptTag_;
 540 |     if (!goog.dependencies_.written[src] && importScript(src)) {
 541 |       goog.dependencies_.written[src] = true;
 542 |     }
 543 |   };
 544 | 
 545 | 
 546 |   /**
 547 |    * The default implementation of the import function. Writes a script tag to
 548 |    * import the script.
 549 |    *
 550 |    * @param {string} src The script source.
 551 |    * @return {boolean} True if the script was imported, false otherwise.
 552 |    * @private
 553 |    */
 554 |   goog.writeScriptTag_ = function(src) {
 555 |     if (goog.inHtmlDocument_()) {
 556 |       var doc = goog.global.document;
 557 | 
 558 |       // If the user tries to require a new symbol after document load,
 559 |       // something has gone terribly wrong. Doing a document.write would
 560 |       // wipe out the page.
 561 |       if (doc.readyState == 'complete') {
 562 |         // Certain test frameworks load base.js multiple times, which tries
 563 |         // to write deps.js each time. If that happens, just fail silently.
 564 |         // These frameworks wipe the page between each load of base.js, so this
 565 |         // is OK.
 566 |         var isDeps = /\bdeps.js$/.test(src);
 567 |         if (isDeps) {
 568 |           return false;
 569 |         } else {
 570 |           throw Error('Cannot write "' + src + '" after document load');
 571 |         }
 572 |       }
 573 | 
 574 |       doc.write(
 575 |           '<script type="text/javascript" src="' + src + '"></' + 'script>');
 576 |       return true;
 577 |     } else {
 578 |       return false;
 579 |     }
 580 |   };
 581 | 
 582 | 
 583 |   /**
 584 |    * Resolves dependencies based on the dependencies added using addDependency
 585 |    * and calls importScript_ in the correct order.
 586 |    * @private
 587 |    */
 588 |   goog.writeScripts_ = function() {
 589 |     // the scripts we need to write this time
 590 |     var scripts = [];
 591 |     var seenScript = {};
 592 |     var deps = goog.dependencies_;
 593 | 
 594 |     function visitNode(path) {
 595 |       if (path in deps.written) {
 596 |         return;
 597 |       }
 598 | 
 599 |       // we have already visited this one. We can get here if we have cyclic
 600 |       // dependencies
 601 |       if (path in deps.visited) {
 602 |         if (!(path in seenScript)) {
 603 |           seenScript[path] = true;
 604 |           scripts.push(path);
 605 |         }
 606 |         return;
 607 |       }
 608 | 
 609 |       deps.visited[path] = true;
 610 | 
 611 |       if (path in deps.requires) {
 612 |         for (var requireName in deps.requires[path]) {
 613 |           // If the required name is defined, we assume that it was already
 614 |           // bootstrapped by other means.
 615 |           if (!goog.isProvided_(requireName)) {
 616 |             if (requireName in deps.nameToPath) {
 617 |               visitNode(deps.nameToPath[requireName]);
 618 |             } else {
 619 |               throw Error('Undefined nameToPath for ' + requireName);
 620 |             }
 621 |           }
 622 |         }
 623 |       }
 624 | 
 625 |       if (!(path in seenScript)) {
 626 |         seenScript[path] = true;
 627 |         scripts.push(path);
 628 |       }
 629 |     }
 630 | 
 631 |     for (var path in goog.included_) {
 632 |       if (!deps.written[path]) {
 633 |         visitNode(path);
 634 |       }
 635 |     }
 636 | 
 637 |     for (var i = 0; i < scripts.length; i++) {
 638 |       if (scripts[i]) {
 639 |         goog.importScript_(goog.basePath + scripts[i]);
 640 |       } else {
 641 |         throw Error('Undefined script input');
 642 |       }
 643 |     }
 644 |   };
 645 | 
 646 | 
 647 |   /**
 648 |    * Looks at the dependency rules and tries to determine the script file that
 649 |    * fulfills a particular rule.
 650 |    * @param {string} rule In the form goog.namespace.Class or project.script.
 651 |    * @return {?string} Url corresponding to the rule, or null.
 652 |    * @private
 653 |    */
 654 |   goog.getPathFromDeps_ = function(rule) {
 655 |     if (rule in goog.dependencies_.nameToPath) {
 656 |       return goog.dependencies_.nameToPath[rule];
 657 |     } else {
 658 |       return null;
 659 |     }
 660 |   };
 661 | 
 662 |   goog.findBasePath_();
 663 | 
 664 |   // Allow projects to manage the deps files themselves.
 665 |   if (!goog.global.CLOSURE_NO_DEPS) {
 666 |     goog.importScript_(goog.basePath + 'deps.js');
 667 |   }
 668 | }
 669 | 
 670 | 
 671 | 
 672 | //==============================================================================
 673 | // Language Enhancements
 674 | //==============================================================================
 675 | 
 676 | 
 677 | /**
 678 |  * This is a "fixed" version of the typeof operator.  It differs from the typeof
 679 |  * operator in such a way that null returns 'null' and arrays return 'array'.
 680 |  * @param {*} value The value to get the type of.
 681 |  * @return {string} The name of the type.
 682 |  */
 683 | goog.typeOf = function(value) {
 684 |   var s = typeof value;
 685 |   if (s == 'object') {
 686 |     if (value) {
 687 |       // Check these first, so we can avoid calling Object.prototype.toString if
 688 |       // possible.
 689 |       //
 690 |       // IE improperly marshals tyepof across execution contexts, but a
 691 |       // cross-context object will still return false for "instanceof Object".
 692 |       if (value instanceof Array) {
 693 |         return 'array';
 694 |       } else if (value instanceof Object) {
 695 |         return s;
 696 |       }
 697 | 
 698 |       // HACK: In order to use an Object prototype method on the arbitrary
 699 |       //   value, the compiler requires the value be cast to type Object,
 700 |       //   even though the ECMA spec explicitly allows it.
 701 |       var className = Object.prototype.toString.call(
 702 |           /** @type {Object} */ (value));
 703 |       // In Firefox 3.6, attempting to access iframe window objects' length
 704 |       // property throws an NS_ERROR_FAILURE, so we need to special-case it
 705 |       // here.
 706 |       if (className == '[object Window]') {
 707 |         return 'object';
 708 |       }
 709 | 
 710 |       // We cannot always use constructor == Array or instanceof Array because
 711 |       // different frames have different Array objects. In IE6, if the iframe
 712 |       // where the array was created is destroyed, the array loses its
 713 |       // prototype. Then dereferencing val.splice here throws an exception, so
 714 |       // we can't use goog.isFunction. Calling typeof directly returns 'unknown'
 715 |       // so that will work. In this case, this function will return false and
 716 |       // most array functions will still work because the array is still
 717 |       // array-like (supports length and []) even though it has lost its
 718 |       // prototype.
 719 |       // Mark Miller noticed that Object.prototype.toString
 720 |       // allows access to the unforgeable [[Class]] property.
 721 |       //  15.2.4.2 Object.prototype.toString ( )
 722 |       //  When the toString method is called, the following steps are taken:
 723 |       //      1. Get the [[Class]] property of this object.
 724 |       //      2. Compute a string value by concatenating the three strings
 725 |       //         "[object ", Result(1), and "]".
 726 |       //      3. Return Result(2).
 727 |       // and this behavior survives the destruction of the execution context.
 728 |       if ((className == '[object Array]' ||
 729 |            // In IE all non value types are wrapped as objects across window
 730 |            // boundaries (not iframe though) so we have to do object detection
 731 |            // for this edge case
 732 |            typeof value.length == 'number' &&
 733 |            typeof value.splice != 'undefined' &&
 734 |            typeof value.propertyIsEnumerable != 'undefined' &&
 735 |            !value.propertyIsEnumerable('splice')
 736 | 
 737 |           )) {
 738 |         return 'array';
 739 |       }
 740 |       // HACK: There is still an array case that fails.
 741 |       //     function ArrayImpostor() {}
 742 |       //     ArrayImpostor.prototype = [];
 743 |       //     var impostor = new ArrayImpostor;
 744 |       // this can be fixed by getting rid of the fast path
 745 |       // (value instanceof Array) and solely relying on
 746 |       // (value && Object.prototype.toString.vall(value) === '[object Array]')
 747 |       // but that would require many more function calls and is not warranted
 748 |       // unless closure code is receiving objects from untrusted sources.
 749 | 
 750 |       // IE in cross-window calls does not correctly marshal the function type
 751 |       // (it appears just as an object) so we cannot use just typeof val ==
 752 |       // 'function'. However, if the object has a call property, it is a
 753 |       // function.
 754 |       if ((className == '[object Function]' ||
 755 |           typeof value.call != 'undefined' &&
 756 |           typeof value.propertyIsEnumerable != 'undefined' &&
 757 |           !value.propertyIsEnumerable('call'))) {
 758 |         return 'function';
 759 |       }
 760 | 
 761 | 
 762 |     } else {
 763 |       return 'null';
 764 |     }
 765 | 
 766 |   } else if (s == 'function' && typeof value.call == 'undefined') {
 767 |     // In Safari typeof nodeList returns 'function', and on Firefox
 768 |     // typeof behaves similarly for HTML{Applet,Embed,Object}Elements
 769 |     // and RegExps.  We would like to return object for those and we can
 770 |     // detect an invalid function by making sure that the function
 771 |     // object has a call method.
 772 |     return 'object';
 773 |   }
 774 |   return s;
 775 | };
 776 | 
 777 | 
 778 | /**
 779 |  * Returns true if the specified value is not |undefined|.
 780 |  * WARNING: Do not use this to test if an object has a property. Use the in
 781 |  * operator instead.  Additionally, this function assumes that the global
 782 |  * undefined variable has not been redefined.
 783 |  * @param {*} val Variable to test.
 784 |  * @return {boolean} Whether variable is defined.
 785 |  */
 786 | goog.isDef = function(val) {
 787 |   return val !== undefined;
 788 | };
 789 | 
 790 | 
 791 | /**
 792 |  * Returns true if the specified value is |null|
 793 |  * @param {*} val Variable to test.
 794 |  * @return {boolean} Whether variable is null.
 795 |  */
 796 | goog.isNull = function(val) {
 797 |   return val === null;
 798 | };
 799 | 
 800 | 
 801 | /**
 802 |  * Returns true if the specified value is defined and not null
 803 |  * @param {*} val Variable to test.
 804 |  * @return {boolean} Whether variable is defined and not null.
 805 |  */
 806 | goog.isDefAndNotNull = function(val) {
 807 |   // Note that undefined == null.
 808 |   return val != null;
 809 | };
 810 | 
 811 | 
 812 | /**
 813 |  * Returns true if the specified value is an array
 814 |  * @param {*} val Variable to test.
 815 |  * @return {boolean} Whether variable is an array.
 816 |  */
 817 | goog.isArray = function(val) {
 818 |   return goog.typeOf(val) == 'array';
 819 | };
 820 | 
 821 | 
 822 | /**
 823 |  * Returns true if the object looks like an array. To qualify as array like
 824 |  * the value needs to be either a NodeList or an object with a Number length
 825 |  * property.
 826 |  * @param {*} val Variable to test.
 827 |  * @return {boolean} Whether variable is an array.
 828 |  */
 829 | goog.isArrayLike = function(val) {
 830 |   var type = goog.typeOf(val);
 831 |   return type == 'array' || type == 'object' && typeof val.length == 'number';
 832 | };
 833 | 
 834 | 
 835 | /**
 836 |  * Returns true if the object looks like a Date. To qualify as Date-like
 837 |  * the value needs to be an object and have a getFullYear() function.
 838 |  * @param {*} val Variable to test.
 839 |  * @return {boolean} Whether variable is a like a Date.
 840 |  */
 841 | goog.isDateLike = function(val) {
 842 |   return goog.isObject(val) && typeof val.getFullYear == 'function';
 843 | };
 844 | 
 845 | 
 846 | /**
 847 |  * Returns true if the specified value is a string
 848 |  * @param {*} val Variable to test.
 849 |  * @return {boolean} Whether variable is a string.
 850 |  */
 851 | goog.isString = function(val) {
 852 |   return typeof val == 'string';
 853 | };
 854 | 
 855 | 
 856 | /**
 857 |  * Returns true if the specified value is a boolean
 858 |  * @param {*} val Variable to test.
 859 |  * @return {boolean} Whether variable is boolean.
 860 |  */
 861 | goog.isBoolean = function(val) {
 862 |   return typeof val == 'boolean';
 863 | };
 864 | 
 865 | 
 866 | /**
 867 |  * Returns true if the specified value is a number
 868 |  * @param {*} val Variable to test.
 869 |  * @return {boolean} Whether variable is a number.
 870 |  */
 871 | goog.isNumber = function(val) {
 872 |   return typeof val == 'number';
 873 | };
 874 | 
 875 | 
 876 | /**
 877 |  * Returns true if the specified value is a function
 878 |  * @param {*} val Variable to test.
 879 |  * @return {boolean} Whether variable is a function.
 880 |  */
 881 | goog.isFunction = function(val) {
 882 |   return goog.typeOf(val) == 'function';
 883 | };
 884 | 
 885 | 
 886 | /**
 887 |  * Returns true if the specified value is an object.  This includes arrays
 888 |  * and functions.
 889 |  * @param {*} val Variable to test.
 890 |  * @return {boolean} Whether variable is an object.
 891 |  */
 892 | goog.isObject = function(val) {
 893 |   var type = typeof val;
 894 |   return type == 'object' && val != null || type == 'function';
 895 |   // return Object(val) === val also works, but is slower, especially if val is
 896 |   // not an object.
 897 | };
 898 | 
 899 | 
 900 | /**
 901 |  * Gets a unique ID for an object. This mutates the object so that further
 902 |  * calls with the same object as a parameter returns the same value. The unique
 903 |  * ID is guaranteed to be unique across the current session amongst objects that
 904 |  * are passed into {@code getUid}. There is no guarantee that the ID is unique
 905 |  * or consistent across sessions. It is unsafe to generate unique ID for
 906 |  * function prototypes.
 907 |  *
 908 |  * @param {Object} obj The object to get the unique ID for.
 909 |  * @return {number} The unique ID for the object.
 910 |  */
 911 | goog.getUid = function(obj) {
 912 |   // TODO(arv): Make the type stricter, do not accept null.
 913 | 
 914 |   // In Opera window.hasOwnProperty exists but always returns false so we avoid
 915 |   // using it. As a consequence the unique ID generated for BaseClass.prototype
 916 |   // and SubClass.prototype will be the same.
 917 |   return obj[goog.UID_PROPERTY_] ||
 918 |       (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_);
 919 | };
 920 | 
 921 | 
 922 | /**
 923 |  * Removes the unique ID from an object. This is useful if the object was
 924 |  * previously mutated using {@code goog.getUid} in which case the mutation is
 925 |  * undone.
 926 |  * @param {Object} obj The object to remove the unique ID field from.
 927 |  */
 928 | goog.removeUid = function(obj) {
 929 |   // TODO(arv): Make the type stricter, do not accept null.
 930 | 
 931 |   // DOM nodes in IE are not instance of Object and throws exception
 932 |   // for delete. Instead we try to use removeAttribute
 933 |   if ('removeAttribute' in obj) {
 934 |     obj.removeAttribute(goog.UID_PROPERTY_);
 935 |   }
 936 |   /** @preserveTry */
 937 |   try {
 938 |     delete obj[goog.UID_PROPERTY_];
 939 |   } catch (ex) {
 940 |   }
 941 | };
 942 | 
 943 | 
 944 | /**
 945 |  * Name for unique ID property. Initialized in a way to help avoid collisions
 946 |  * with other closure javascript on the same page.
 947 |  * @type {string}
 948 |  * @private
 949 |  */
 950 | goog.UID_PROPERTY_ = 'closure_uid_' + ((Math.random() * 1e9) >>> 0);
 951 | 
 952 | 
 953 | /**
 954 |  * Counter for UID.
 955 |  * @type {number}
 956 |  * @private
 957 |  */
 958 | goog.uidCounter_ = 0;
 959 | 
 960 | 
 961 | /**
 962 |  * Adds a hash code field to an object. The hash code is unique for the
 963 |  * given object.
 964 |  * @param {Object} obj The object to get the hash code for.
 965 |  * @return {number} The hash code for the object.
 966 |  * @deprecated Use goog.getUid instead.
 967 |  */
 968 | goog.getHashCode = goog.getUid;
 969 | 
 970 | 
 971 | /**
 972 |  * Removes the hash code field from an object.
 973 |  * @param {Object} obj The object to remove the field from.
 974 |  * @deprecated Use goog.removeUid instead.
 975 |  */
 976 | goog.removeHashCode = goog.removeUid;
 977 | 
 978 | 
 979 | /**
 980 |  * Clones a value. The input may be an Object, Array, or basic type. Objects and
 981 |  * arrays will be cloned recursively.
 982 |  *
 983 |  * WARNINGS:
 984 |  * <code>goog.cloneObject</code> does not detect reference loops. Objects that
 985 |  * refer to themselves will cause infinite recursion.
 986 |  *
 987 |  * <code>goog.cloneObject</code> is unaware of unique identifiers, and copies
 988 |  * UIDs created by <code>getUid</code> into cloned results.
 989 |  *
 990 |  * @param {*} obj The value to clone.
 991 |  * @return {*} A clone of the input value.
 992 |  * @deprecated goog.cloneObject is unsafe. Prefer the goog.object methods.
 993 |  */
 994 | goog.cloneObject = function(obj) {
 995 |   var type = goog.typeOf(obj);
 996 |   if (type == 'object' || type == 'array') {
 997 |     if (obj.clone) {
 998 |       return obj.clone();
 999 |     }
1000 |     var clone = type == 'array' ? [] : {};
1001 |     for (var key in obj) {
1002 |       clone[key] = goog.cloneObject(obj[key]);
1003 |     }
1004 |     return clone;
1005 |   }
1006 | 
1007 |   return obj;
1008 | };
1009 | 
1010 | 
1011 | /**
1012 |  * A native implementation of goog.bind.
1013 |  * @param {Function} fn A function to partially apply.
1014 |  * @param {Object|undefined} selfObj Specifies the object which |this| should
1015 |  *     point to when the function is run.
1016 |  * @param {...*} var_args Additional arguments that are partially
1017 |  *     applied to the function.
1018 |  * @return {!Function} A partially-applied form of the function bind() was
1019 |  *     invoked as a method of.
1020 |  * @private
1021 |  * @suppress {deprecated} The compiler thinks that Function.prototype.bind
1022 |  *     is deprecated because some people have declared a pure-JS version.
1023 |  *     Only the pure-JS version is truly deprecated.
1024 |  */
1025 | goog.bindNative_ = function(fn, selfObj, var_args) {
1026 |   return /** @type {!Function} */ (fn.call.apply(fn.bind, arguments));
1027 | };
1028 | 
1029 | 
1030 | /**
1031 |  * A pure-JS implementation of goog.bind.
1032 |  * @param {Function} fn A function to partially apply.
1033 |  * @param {Object|undefined} selfObj Specifies the object which |this| should
1034 |  *     point to when the function is run.
1035 |  * @param {...*} var_args Additional arguments that are partially
1036 |  *     applied to the function.
1037 |  * @return {!Function} A partially-applied form of the function bind() was
1038 |  *     invoked as a method of.
1039 |  * @private
1040 |  */
1041 | goog.bindJs_ = function(fn, selfObj, var_args) {
1042 |   if (!fn) {
1043 |     throw new Error();
1044 |   }
1045 | 
1046 |   if (arguments.length > 2) {
1047 |     var boundArgs = Array.prototype.slice.call(arguments, 2);
1048 |     return function() {
1049 |       // Prepend the bound arguments to the current arguments.
1050 |       var newArgs = Array.prototype.slice.call(arguments);
1051 |       Array.prototype.unshift.apply(newArgs, boundArgs);
1052 |       return fn.apply(selfObj, newArgs);
1053 |     };
1054 | 
1055 |   } else {
1056 |     return function() {
1057 |       return fn.apply(selfObj, arguments);
1058 |     };
1059 |   }
1060 | };
1061 | 
1062 | 
1063 | /**
1064 |  * Partially applies this function to a particular 'this object' and zero or
1065 |  * more arguments. The result is a new function with some arguments of the first
1066 |  * function pre-filled and the value of |this| 'pre-specified'.<br><br>
1067 |  *
1068 |  * Remaining arguments specified at call-time are appended to the pre-
1069 |  * specified ones.<br><br>
1070 |  *
1071 |  * Also see: {@link #partial}.<br><br>
1072 |  *
1073 |  * Usage:
1074 |  * <pre>var barMethBound = bind(myFunction, myObj, 'arg1', 'arg2');
1075 |  * barMethBound('arg3', 'arg4');</pre>
1076 |  *
1077 |  * @param {Function} fn A function to partially apply.
1078 |  * @param {Object|undefined} selfObj Specifies the object which |this| should
1079 |  *     point to when the function is run.
1080 |  * @param {...*} var_args Additional arguments that are partially
1081 |  *     applied to the function.
1082 |  * @return {!Function} A partially-applied form of the function bind() was
1083 |  *     invoked as a method of.
1084 |  * @suppress {deprecated} See above.
1085 |  */
1086 | goog.bind = function(fn, selfObj, var_args) {
1087 |   // TODO(nicksantos): narrow the type signature.
1088 |   if (Function.prototype.bind &&
1089 |       // NOTE(nicksantos): Somebody pulled base.js into the default
1090 |       // Chrome extension environment. This means that for Chrome extensions,
1091 |       // they get the implementation of Function.prototype.bind that
1092 |       // calls goog.bind instead of the native one. Even worse, we don't want
1093 |       // to introduce a circular dependency between goog.bind and
1094 |       // Function.prototype.bind, so we have to hack this to make sure it
1095 |       // works correctly.
1096 |       Function.prototype.bind.toString().indexOf('native code') != -1) {
1097 |     goog.bind = goog.bindNative_;
1098 |   } else {
1099 |     goog.bind = goog.bindJs_;
1100 |   }
1101 |   return goog.bind.apply(null, arguments);
1102 | };
1103 | 
1104 | 
1105 | /**
1106 |  * Like bind(), except that a 'this object' is not required. Useful when the
1107 |  * target function is already bound.
1108 |  *
1109 |  * Usage:
1110 |  * var g = partial(f, arg1, arg2);
1111 |  * g(arg3, arg4);
1112 |  *
1113 |  * @param {Function} fn A function to partially apply.
1114 |  * @param {...*} var_args Additional arguments that are partially
1115 |  *     applied to fn.
1116 |  * @return {!Function} A partially-applied form of the function bind() was
1117 |  *     invoked as a method of.
1118 |  */
1119 | goog.partial = function(fn, var_args) {
1120 |   var args = Array.prototype.slice.call(arguments, 1);
1121 |   return function() {
1122 |     // Prepend the bound arguments to the current arguments.
1123 |     var newArgs = Array.prototype.slice.call(arguments);
1124 |     newArgs.unshift.apply(newArgs, args);
1125 |     return fn.apply(this, newArgs);
1126 |   };
1127 | };
1128 | 
1129 | 
1130 | /**
1131 |  * Copies all the members of a source object to a target object. This method
1132 |  * does not work on all browsers for all objects that contain keys such as
1133 |  * toString or hasOwnProperty. Use goog.object.extend for this purpose.
1134 |  * @param {Object} target Target.
1135 |  * @param {Object} source Source.
1136 |  */
1137 | goog.mixin = function(target, source) {
1138 |   for (var x in source) {
1139 |     target[x] = source[x];
1140 |   }
1141 | 
1142 |   // For IE7 or lower, the for-in-loop does not contain any properties that are
1143 |   // not enumerable on the prototype object (for example, isPrototypeOf from
1144 |   // Object.prototype) but also it will not include 'replace' on objects that
1145 |   // extend String and change 'replace' (not that it is common for anyone to
1146 |   // extend anything except Object).
1147 | };
1148 | 
1149 | 
1150 | /**
1151 |  * @return {number} An integer value representing the number of milliseconds
1152 |  *     between midnight, January 1, 1970 and the current time.
1153 |  */
1154 | goog.now = (goog.TRUSTED_SITE && Date.now) || (function() {
1155 |   // Unary plus operator converts its operand to a number which in the case of
1156 |   // a date is done by calling getTime().
1157 |   return +new Date();
1158 | });
1159 | 
1160 | 
1161 | /**
1162 |  * Evals javascript in the global scope.  In IE this uses execScript, other
1163 |  * browsers use goog.global.eval. If goog.global.eval does not evaluate in the
1164 |  * global scope (for example, in Safari), appends a script tag instead.
1165 |  * Throws an exception if neither execScript or eval is defined.
1166 |  * @param {string} script JavaScript string.
1167 |  */
1168 | goog.globalEval = function(script) {
1169 |   if (goog.global.execScript) {
1170 |     goog.global.execScript(script, 'JavaScript');
1171 |   } else if (goog.global.eval) {
1172 |     // Test to see if eval works
1173 |     if (goog.evalWorksForGlobals_ == null) {
1174 |       goog.global.eval('var _et_ = 1;');
1175 |       if (typeof goog.global['_et_'] != 'undefined') {
1176 |         delete goog.global['_et_'];
1177 |         goog.evalWorksForGlobals_ = true;
1178 |       } else {
1179 |         goog.evalWorksForGlobals_ = false;
1180 |       }
1181 |     }
1182 | 
1183 |     if (goog.evalWorksForGlobals_) {
1184 |       goog.global.eval(script);
1185 |     } else {
1186 |       var doc = goog.global.document;
1187 |       var scriptElt = doc.createElement('script');
1188 |       scriptElt.type = 'text/javascript';
1189 |       scriptElt.defer = false;
1190 |       // Note(user): can't use .innerHTML since "t('<test>')" will fail and
1191 |       // .text doesn't work in Safari 2.  Therefore we append a text node.
1192 |       scriptElt.appendChild(doc.createTextNode(script));
1193 |       doc.body.appendChild(scriptElt);
1194 |       doc.body.removeChild(scriptElt);
1195 |     }
1196 |   } else {
1197 |     throw Error('goog.globalEval not available');
1198 |   }
1199 | };
1200 | 
1201 | 
1202 | /**
1203 |  * Indicates whether or not we can call 'eval' directly to eval code in the
1204 |  * global scope. Set to a Boolean by the first call to goog.globalEval (which
1205 |  * empirically tests whether eval works for globals). @see goog.globalEval
1206 |  * @type {?boolean}
1207 |  * @private
1208 |  */
1209 | goog.evalWorksForGlobals_ = null;
1210 | 
1211 | 
1212 | /**
1213 |  * Optional map of CSS class names to obfuscated names used with
1214 |  * goog.getCssName().
1215 |  * @type {Object|undefined}
1216 |  * @private
1217 |  * @see goog.setCssNameMapping
1218 |  */
1219 | goog.cssNameMapping_;
1220 | 
1221 | 
1222 | /**
1223 |  * Optional obfuscation style for CSS class names. Should be set to either
1224 |  * 'BY_WHOLE' or 'BY_PART' if defined.
1225 |  * @type {string|undefined}
1226 |  * @private
1227 |  * @see goog.setCssNameMapping
1228 |  */
1229 | goog.cssNameMappingStyle_;
1230 | 
1231 | 
1232 | /**
1233 |  * Handles strings that are intended to be used as CSS class names.
1234 |  *
1235 |  * This function works in tandem with @see goog.setCssNameMapping.
1236 |  *
1237 |  * Without any mapping set, the arguments are simple joined with a
1238 |  * hyphen and passed through unaltered.
1239 |  *
1240 |  * When there is a mapping, there are two possible styles in which
1241 |  * these mappings are used. In the BY_PART style, each part (i.e. in
1242 |  * between hyphens) of the passed in css name is rewritten according
1243 |  * to the map. In the BY_WHOLE style, the full css name is looked up in
1244 |  * the map directly. If a rewrite is not specified by the map, the
1245 |  * compiler will output a warning.
1246 |  *
1247 |  * When the mapping is passed to the compiler, it will replace calls
1248 |  * to goog.getCssName with the strings from the mapping, e.g.
1249 |  *     var x = goog.getCssName('foo');
1250 |  *     var y = goog.getCssName(this.baseClass, 'active');
1251 |  *  becomes:
1252 |  *     var x= 'foo';
1253 |  *     var y = this.baseClass + '-active';
1254 |  *
1255 |  * If one argument is passed it will be processed, if two are passed
1256 |  * only the modifier will be processed, as it is assumed the first
1257 |  * argument was generated as a result of calling goog.getCssName.
1258 |  *
1259 |  * @param {string} className The class name.
1260 |  * @param {string=} opt_modifier A modifier to be appended to the class name.
1261 |  * @return {string} The class name or the concatenation of the class name and
1262 |  *     the modifier.
1263 |  */
1264 | goog.getCssName = function(className, opt_modifier) {
1265 |   var getMapping = function(cssName) {
1266 |     return goog.cssNameMapping_[cssName] || cssName;
1267 |   };
1268 | 
1269 |   var renameByParts = function(cssName) {
1270 |     // Remap all the parts individually.
1271 |     var parts = cssName.split('-');
1272 |     var mapped = [];
1273 |     for (var i = 0; i < parts.length; i++) {
1274 |       mapped.push(getMapping(parts[i]));
1275 |     }
1276 |     return mapped.join('-');
1277 |   };
1278 | 
1279 |   var rename;
1280 |   if (goog.cssNameMapping_) {
1281 |     rename = goog.cssNameMappingStyle_ == 'BY_WHOLE' ?
1282 |         getMapping : renameByParts;
1283 |   } else {
1284 |     rename = function(a) {
1285 |       return a;
1286 |     };
1287 |   }
1288 | 
1289 |   if (opt_modifier) {
1290 |     return className + '-' + rename(opt_modifier);
1291 |   } else {
1292 |     return rename(className);
1293 |   }
1294 | };
1295 | 
1296 | 
1297 | /**
1298 |  * Sets the map to check when returning a value from goog.getCssName(). Example:
1299 |  * <pre>
1300 |  * goog.setCssNameMapping({
1301 |  *   "goog": "a",
1302 |  *   "disabled": "b",
1303 |  * });
1304 |  *
1305 |  * var x = goog.getCssName('goog');
1306 |  * // The following evaluates to: "a a-b".
1307 |  * goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')
1308 |  * </pre>
1309 |  * When declared as a map of string literals to string literals, the JSCompiler
1310 |  * will replace all calls to goog.getCssName() using the supplied map if the
1311 |  * --closure_pass flag is set.
1312 |  *
1313 |  * @param {!Object} mapping A map of strings to strings where keys are possible
1314 |  *     arguments to goog.getCssName() and values are the corresponding values
1315 |  *     that should be returned.
1316 |  * @param {string=} opt_style The style of css name mapping. There are two valid
1317 |  *     options: 'BY_PART', and 'BY_WHOLE'.
1318 |  * @see goog.getCssName for a description.
1319 |  */
1320 | goog.setCssNameMapping = function(mapping, opt_style) {
1321 |   goog.cssNameMapping_ = mapping;
1322 |   goog.cssNameMappingStyle_ = opt_style;
1323 | };
1324 | 
1325 | 
1326 | /**
1327 |  * To use CSS renaming in compiled mode, one of the input files should have a
1328 |  * call to goog.setCssNameMapping() with an object literal that the JSCompiler
1329 |  * can extract and use to replace all calls to goog.getCssName(). In uncompiled
1330 |  * mode, JavaScript code should be loaded before this base.js file that declares
1331 |  * a global variable, CLOSURE_CSS_NAME_MAPPING, which is used below. This is
1332 |  * to ensure that the mapping is loaded before any calls to goog.getCssName()
1333 |  * are made in uncompiled mode.
1334 |  *
1335 |  * A hook for overriding the CSS name mapping.
1336 |  * @type {Object|undefined}
1337 |  */
1338 | goog.global.CLOSURE_CSS_NAME_MAPPING;
1339 | 
1340 | 
1341 | if (!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {
1342 |   // This does not call goog.setCssNameMapping() because the JSCompiler
1343 |   // requires that goog.setCssNameMapping() be called with an object literal.
1344 |   goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING;
1345 | }
1346 | 
1347 | 
1348 | /**
1349 |  * Gets a localized message.
1350 |  *
1351 |  * This function is a compiler primitive. If you give the compiler a localized
1352 |  * message bundle, it will replace the string at compile-time with a localized
1353 |  * version, and expand goog.getMsg call to a concatenated string.
1354 |  *
1355 |  * Messages must be initialized in the form:
1356 |  * <code>
1357 |  * var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});
1358 |  * </code>
1359 |  *
1360 |  * @param {string} str Translatable string, places holders in the form {$foo}.
1361 |  * @param {Object=} opt_values Map of place holder name to value.
1362 |  * @return {string} message with placeholders filled.
1363 |  */
1364 | goog.getMsg = function(str, opt_values) {
1365 |   var values = opt_values || {};
1366 |   for (var key in values) {
1367 |     var value = ('' + values[key]).replace(/\$/g, '$$$$');
1368 |     str = str.replace(new RegExp('\\{\\$' + key + '\\}', 'gi'), value);
1369 |   }
1370 |   return str;
1371 | };
1372 | 
1373 | 
1374 | /**
1375 |  * Gets a localized message. If the message does not have a translation, gives a
1376 |  * fallback message.
1377 |  *
1378 |  * This is useful when introducing a new message that has not yet been
1379 |  * translated into all languages.
1380 |  *
1381 |  * This function is a compiler primtive. Must be used in the form:
1382 |  * <code>var x = goog.getMsgWithFallback(MSG_A, MSG_B);</code>
1383 |  * where MSG_A and MSG_B were initialized with goog.getMsg.
1384 |  *
1385 |  * @param {string} a The preferred message.
1386 |  * @param {string} b The fallback message.
1387 |  * @return {string} The best translated message.
1388 |  */
1389 | goog.getMsgWithFallback = function(a, b) {
1390 |   return a;
1391 | };
1392 | 
1393 | 
1394 | /**
1395 |  * Exposes an unobfuscated global namespace path for the given object.
1396 |  * Note that fields of the exported object *will* be obfuscated,
1397 |  * unless they are exported in turn via this function or
1398 |  * goog.exportProperty
1399 |  *
1400 |  * <p>Also handy for making public items that are defined in anonymous
1401 |  * closures.
1402 |  *
1403 |  * ex. goog.exportSymbol('public.path.Foo', Foo);
1404 |  *
1405 |  * ex. goog.exportSymbol('public.path.Foo.staticFunction',
1406 |  *                       Foo.staticFunction);
1407 |  *     public.path.Foo.staticFunction();
1408 |  *
1409 |  * ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',
1410 |  *                       Foo.prototype.myMethod);
1411 |  *     new public.path.Foo().myMethod();
1412 |  *
1413 |  * @param {string} publicPath Unobfuscated name to export.
1414 |  * @param {*} object Object the name should point to.
1415 |  * @param {Object=} opt_objectToExportTo The object to add the path to; default
1416 |  *     is |goog.global|.
1417 |  */
1418 | goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
1419 |   goog.exportPath_(publicPath, object, opt_objectToExportTo);
1420 | };
1421 | 
1422 | 
1423 | /**
1424 |  * Exports a property unobfuscated into the object's namespace.
1425 |  * ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);
1426 |  * ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);
1427 |  * @param {Object} object Object whose static property is being exported.
1428 |  * @param {string} publicName Unobfuscated name to export.
1429 |  * @param {*} symbol Object the name should point to.
1430 |  */
1431 | goog.exportProperty = function(object, publicName, symbol) {
1432 |   object[publicName] = symbol;
1433 | };
1434 | 
1435 | 
1436 | /**
1437 |  * Inherit the prototype methods from one constructor into another.
1438 |  *
1439 |  * Usage:
1440 |  * <pre>
1441 |  * function ParentClass(a, b) { }
1442 |  * ParentClass.prototype.foo = function(a) { }
1443 |  *
1444 |  * function ChildClass(a, b, c) {
1445 |  *   goog.base(this, a, b);
1446 |  * }
1447 |  * goog.inherits(ChildClass, ParentClass);
1448 |  *
1449 |  * var child = new ChildClass('a', 'b', 'see');
1450 |  * child.foo(); // works
1451 |  * </pre>
1452 |  *
1453 |  * In addition, a superclass' implementation of a method can be invoked
1454 |  * as follows:
1455 |  *
1456 |  * <pre>
1457 |  * ChildClass.prototype.foo = function(a) {
1458 |  *   ChildClass.superClass_.foo.call(this, a);
1459 |  *   // other code
1460 |  * };
1461 |  * </pre>
1462 |  *
1463 |  * @param {Function} childCtor Child class.
1464 |  * @param {Function} parentCtor Parent class.
1465 |  */
1466 | goog.inherits = function(childCtor, parentCtor) {
1467 |   /** @constructor */
1468 |   function tempCtor() {};
1469 |   tempCtor.prototype = parentCtor.prototype;
1470 |   childCtor.superClass_ = parentCtor.prototype;
1471 |   childCtor.prototype = new tempCtor();
1472 |   /** @override */
1473 |   childCtor.prototype.constructor = childCtor;
1474 | };
1475 | 
1476 | /**
1477 |  * Allow for aliasing within scope functions.  This function exists for
1478 |  * uncompiled code - in compiled code the calls will be inlined and the
1479 |  * aliases applied.  In uncompiled code the function is simply run since the
1480 |  * aliases as written are valid JavaScript.
1481 |  * @param {function()} fn Function to call.  This function can contain aliases
1482 |  *     to namespaces (e.g. "var dom = goog.dom") or classes
1483 |  *    (e.g. "var Timer = goog.Timer").
1484 |  */
1485 | goog.scope = function(fn) {
1486 |   fn.call(goog.global);
1487 | };
1488 | 
1489 | 
1490 | 


--------------------------------------------------------------------------------
/vendor/sunesimonsen/unexpected.js:
--------------------------------------------------------------------------------
   1 | (function () {
   2 |     // Copyright (c) 2013 Sune Simonsen <sune@we-knowhow.dk>
   3 |     //
   4 |     // Permission is hereby granted, free of charge, to any person
   5 |     // obtaining a copy of this software and associated documentation
   6 |     // files (the 'Software'), to deal in the Software without
   7 |     // restriction, including without limitation the rights to use, copy,
   8 |     // modify, merge, publish, distribute, sublicense, and/or sell copies
   9 |     // of the Software, and to permit persons to whom the Software is
  10 |     // furnished to do so, subject to the following conditions:
  11 |     //
  12 |     // The above copyright notice and this permission notice shall be
  13 |     // included in all copies or substantial portions of the Software.
  14 |     //
  15 |     // THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
  16 |     // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17 |     // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18 |     // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19 |     // BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20 |     // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21 |     // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22 |     // SOFTWARE.
  23 |     /*exported namespace*/
  24 |     var namespace = {};
  25 |     /*global namespace*/
  26 |     (function () {
  27 |         namespace.shim = {
  28 |             every: function (arr, fn, thisObj) {
  29 |                 var scope = thisObj || null;
  30 |                 for (var i = 0, j = arr.length; i < j; i += 1) {
  31 |                     if (!fn.call(scope, arr[i], i, arr)) {
  32 |                         return false;
  33 |                     }
  34 |                 }
  35 |                 return true;
  36 |             },
  37 |     
  38 |             some: function (arr, fn, thisObj) {
  39 |                 var scope = thisObj || null;
  40 |                 for (var i = 0, j = arr.length; i < j; i += 1) {
  41 |                     if (fn.call(scope, arr[i], i, arr)) {
  42 |                         return true;
  43 |                     }
  44 |                 }
  45 |                 return false;
  46 |             },
  47 |     
  48 |             indexOf: function (arr, searchElement, fromIndex) {
  49 |                 var length = arr.length >>> 0; // Hack to convert object.length to a UInt32
  50 |     
  51 |                 fromIndex = +fromIndex || 0;
  52 |     
  53 |                 if (Math.abs(fromIndex) === Infinity) {
  54 |                     fromIndex = 0;
  55 |                 }
  56 |     
  57 |                 if (fromIndex < 0) {
  58 |                     fromIndex += length;
  59 |                     if (fromIndex < 0) {
  60 |                         fromIndex = 0;
  61 |                     }
  62 |                 }
  63 |     
  64 |                 for (;fromIndex < length; fromIndex += 1) {
  65 |                     if (arr[fromIndex] === searchElement) {
  66 |                         return fromIndex;
  67 |                     }
  68 |                 }
  69 |     
  70 |                 return -1;
  71 |             },
  72 |     
  73 |             getKeys: function (obj) {
  74 |                 var result = [];
  75 |     
  76 |                 for (var i in obj) {
  77 |                     if (obj.hasOwnProperty(i)) {
  78 |                         result.push(i);
  79 |                     }
  80 |                 }
  81 |     
  82 |                 return result;
  83 |             },
  84 |     
  85 |             forEach: function (arr, callback, that) {
  86 |                 for (var i = 0, n = arr.length; i < n; i += 1)
  87 |                     if (i in arr)
  88 |                         callback.call(that, arr[i], i, arr);
  89 |             },
  90 |     
  91 |             map: function (arr, mapper, that) {
  92 |                 var other = new Array(arr.length);
  93 |     
  94 |                 for (var i = 0, n = arr.length; i < n; i += 1)
  95 |                     if (i in arr)
  96 |                         other[i] = mapper.call(that, arr[i], i, arr);
  97 |     
  98 |                 return other;
  99 |             },
 100 |     
 101 |             filter: function (arr, predicate) {
 102 |                 var length = +arr.length;
 103 |     
 104 |                 var result = [];
 105 |     
 106 |                 if (typeof predicate !== "function")
 107 |                     throw new TypeError();
 108 |     
 109 |                 for (var i = 0; i < length; i += 1) {
 110 |                     var value = arr[i];
 111 |                     if (predicate(value)) {
 112 |                         result.push(value);
 113 |                     }
 114 |                 }
 115 |     
 116 |                 return result;
 117 |             },
 118 |     
 119 |             trim: function (text) {
 120 |                 return text.replace(/^\s+|\s+$/g, '');
 121 |             },
 122 |     
 123 |             reduce: function (arr, fun) {
 124 |                 var len = +arr.length;
 125 |     
 126 |                 if (typeof fun !== "function")
 127 |                     throw new TypeError();
 128 |     
 129 |                 // no value to return if no initial value and an empty array
 130 |                 if (len === 0 && arguments.length === 1)
 131 |                     throw new TypeError();
 132 |     
 133 |                 var i = 0;
 134 |                 var rv;
 135 |                 if (arguments.length >= 2) {
 136 |                     rv = arguments[2];
 137 |                 } else {
 138 |                     do {
 139 |                         if (i in arr) {
 140 |                             rv = arr[i];
 141 |                             i += 1;
 142 |                             break;
 143 |                         }
 144 |     
 145 |                         // if array contains no values, no initial value to return
 146 |                         i += 1;
 147 |                         if (i >= len)
 148 |                             throw new TypeError();
 149 |                     } while (true);
 150 |                 }
 151 |     
 152 |                 for (; i < len; i += 1) {
 153 |                     if (i in arr)
 154 |                         rv = fun.call(null, rv, arr[i], i, this);
 155 |                 }
 156 |     
 157 |                 return rv;
 158 |             },
 159 |     
 160 |             JSON: (function () {
 161 |                 "use strict";
 162 |     
 163 |                 var jsonShim = {};
 164 |     
 165 |                 function f(n) {
 166 |                     // Format integers to have at least two digits.
 167 |                     return n < 10 ? '0' + n : n;
 168 |                 }
 169 |     
 170 |                 function date(d, key) {
 171 |                     return isFinite(d.valueOf()) ?
 172 |                         d.getUTCFullYear()     + '-' +
 173 |                         f(d.getUTCMonth() + 1) + '-' +
 174 |                         f(d.getUTCDate())      + 'T' +
 175 |                         f(d.getUTCHours())     + ':' +
 176 |                         f(d.getUTCMinutes())   + ':' +
 177 |                         f(d.getUTCSeconds())   + 'Z' : null;
 178 |                 }
 179 |     
 180 |                 var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
 181 |                     escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
 182 |                     gap,
 183 |                     indent,
 184 |                     meta = {    // table of character substitutions
 185 |                         '\b': '\\b',
 186 |                         '\t': '\\t',
 187 |                         '\n': '\\n',
 188 |                         '\f': '\\f',
 189 |                         '\r': '\\r',
 190 |                         '"' : '\\"',
 191 |                         '\\': '\\\\'
 192 |                     },
 193 |                     rep;
 194 |     
 195 |     
 196 |                 function quote(string) {
 197 |     
 198 |                     // If the string contains no control characters, no quote characters, and no
 199 |                     // backslash characters, then we can safely slap some quotes around it.
 200 |                     // Otherwise we must also replace the offending characters with safe escape
 201 |                     // sequences.
 202 |     
 203 |                     escapable.lastIndex = 0;
 204 |                     return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
 205 |                         var c = meta[a];
 206 |                         return typeof c === 'string' ? c :
 207 |                             '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
 208 |                     }) + '"' : '"' + string + '"';
 209 |                 }
 210 |     
 211 |     
 212 |                 function str(key, holder) {
 213 |     
 214 |                     // Produce a string from holder[key].
 215 |     
 216 |                     var i,          // The loop counter.
 217 |                         k,          // The member key.
 218 |                         v,          // The member value.
 219 |                         length,
 220 |                         mind = gap,
 221 |                         partial,
 222 |                         value = holder[key];
 223 |     
 224 |                     // If the value has a toJSON method, call it to obtain a replacement value.
 225 |     
 226 |                     if (value instanceof Date) {
 227 |                         value = date(key);
 228 |                     }
 229 |     
 230 |                     // If we were called with a replacer function, then call the replacer to
 231 |                     // obtain a replacement value.
 232 |     
 233 |                     if (typeof rep === 'function') {
 234 |                         value = rep.call(holder, key, value);
 235 |                     }
 236 |     
 237 |                     // What happens next depends on the value's type.
 238 |     
 239 |                     switch (typeof value) {
 240 |                     case 'string':
 241 |                         return quote(value);
 242 |     
 243 |                     case 'number':
 244 |     
 245 |                         // JSON numbers must be finite. Encode non-finite numbers as null.
 246 |     
 247 |                         return isFinite(value) ? String(value) : 'null';
 248 |     
 249 |                     case 'boolean':
 250 |                     case 'null':
 251 |     
 252 |                         // If the value is a boolean or null, convert it to a string. Note:
 253 |                         // typeof null does not produce 'null'. The case is included here in
 254 |                         // the remote chance that this gets fixed someday.
 255 |     
 256 |                         return String(value);
 257 |     
 258 |                         // If the type is 'object', we might be dealing with an object or an array or
 259 |                         // null.
 260 |     
 261 |                     case 'object':
 262 |     
 263 |                         // Due to a specification blunder in ECMAScript, typeof null is 'object',
 264 |                         // so watch out for that case.
 265 |     
 266 |                         if (!value) {
 267 |                             return 'null';
 268 |                         }
 269 |     
 270 |                         // Make an array to hold the partial results of stringifying this object value.
 271 |     
 272 |                         gap += indent;
 273 |                         partial = [];
 274 |     
 275 |                         // Is the value an array?
 276 |     
 277 |                         if (Object.prototype.toString.apply(value) === '[object Array]') {
 278 |     
 279 |                             // The value is an array. Stringify every element. Use null as a placeholder
 280 |                             // for non-JSON values.
 281 |     
 282 |                             length = value.length;
 283 |                             for (i = 0; i < length; i += 1) {
 284 |                                 partial[i] = str(i, value) || 'null';
 285 |                             }
 286 |     
 287 |                             // Join all of the elements together, separated with commas, and wrap them in
 288 |                             // brackets.
 289 |     
 290 |                             v = partial.length === 0 ? '[]' : gap ?
 291 |                                 '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' :
 292 |                                 '[' + partial.join(',') + ']';
 293 |                             gap = mind;
 294 |                             return v;
 295 |                         }
 296 |     
 297 |                         // If the replacer is an array, use it to select the members to be stringified.
 298 |     
 299 |                         if (rep && typeof rep === 'object') {
 300 |                             length = rep.length;
 301 |                             for (i = 0; i < length; i += 1) {
 302 |                                 if (typeof rep[i] === 'string') {
 303 |                                     k = rep[i];
 304 |                                     v = str(k, value);
 305 |                                     if (v) {
 306 |                                         partial.push(quote(k) + (gap ? ': ' : ':') + v);
 307 |                                     }
 308 |                                 }
 309 |                             }
 310 |                         } else {
 311 |     
 312 |                             // Otherwise, iterate through all of the keys in the object.
 313 |     
 314 |                             for (k in value) {
 315 |                                 if (value.hasOwnProperty(k)) {
 316 |                                     v = str(k, value);
 317 |                                     if (v) {
 318 |                                         partial.push(quote(k) + (gap ? ': ' : ':') + v);
 319 |                                     }
 320 |                                 }
 321 |                             }
 322 |                         }
 323 |     
 324 |                         // Join all of the member texts together, separated with commas,
 325 |                         // and wrap them in braces.
 326 |     
 327 |                         v = partial.length === 0 ? '{}' : gap ?
 328 |                             '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
 329 |                             '{' + partial.join(',') + '}';
 330 |                         gap = mind;
 331 |                         return v;
 332 |                     }
 333 |                 }
 334 |     
 335 |                 // If the JSON object does not yet have a stringify method, give it one.
 336 |     
 337 |                 jsonShim.stringify = function (value, replacer, space) {
 338 |     
 339 |                     // The stringify method takes a value and an optional replacer, and an optional
 340 |                     // space parameter, and returns a JSON text. The replacer can be a function
 341 |                     // that can replace values, or an array of strings that will select the keys.
 342 |                     // A default replacer method can be provided. Use of the space parameter can
 343 |                     // produce text that is more easily readable.
 344 |     
 345 |                     var i;
 346 |                     gap = '';
 347 |                     indent = '';
 348 |     
 349 |                     // If the space parameter is a number, make an indent string containing that
 350 |                     // many spaces.
 351 |     
 352 |                     if (typeof space === 'number') {
 353 |                         for (i = 0; i < space; i += 1) {
 354 |                             indent += ' ';
 355 |                         }
 356 |     
 357 |                         // If the space parameter is a string, it will be used as the indent string.
 358 |     
 359 |                     } else if (typeof space === 'string') {
 360 |                         indent = space;
 361 |                     }
 362 |     
 363 |                     // If there is a replacer, it must be a function or an array.
 364 |                     // Otherwise, throw an error.
 365 |     
 366 |                     rep = replacer;
 367 |                     if (replacer && typeof replacer !== 'function' &&
 368 |                         (typeof replacer !== 'object' ||
 369 |                          typeof replacer.length !== 'number')) {
 370 |                         throw new Error('JSON.stringify');
 371 |                     }
 372 |     
 373 |                     // Make a fake root object containing our value under the key of ''.
 374 |                     // Return the result of stringifying the value.
 375 |     
 376 |                     return str('', {'': value});
 377 |                 };
 378 |     
 379 |                 // If the JSON object does not yet have a parse method, give it one.
 380 |     
 381 |                 jsonShim.parse = function (text, reviver) {
 382 |                     // jshint evil:true
 383 |                     // The parse method takes a text and an optional reviver function, and returns
 384 |                     // a JavaScript value if the text is a valid JSON text.
 385 |     
 386 |                     var j;
 387 |     
 388 |                     function walk(holder, key) {
 389 |     
 390 |                         // The walk method is used to recursively walk the resulting structure so
 391 |                         // that modifications can be made.
 392 |     
 393 |                         var k, v, value = holder[key];
 394 |                         if (value && typeof value === 'object') {
 395 |                             for (k in value) {
 396 |                                 if (value.hasOwnProperty(k)) {
 397 |                                     v = walk(value, k);
 398 |                                     if (v !== undefined) {
 399 |                                         value[k] = v;
 400 |                                     } else {
 401 |                                         delete value[k];
 402 |                                     }
 403 |                                 }
 404 |                             }
 405 |                         }
 406 |                         return reviver.call(holder, key, value);
 407 |                     }
 408 |     
 409 |     
 410 |                     // Parsing happens in four stages. In the first stage, we replace certain
 411 |                     // Unicode characters with escape sequences. JavaScript handles many characters
 412 |                     // incorrectly, either silently deleting them, or treating them as line endings.
 413 |     
 414 |                     text = String(text);
 415 |                     cx.lastIndex = 0;
 416 |                     if (cx.test(text)) {
 417 |                         text = text.replace(cx, function (a) {
 418 |                             return '\\u' +
 419 |                                 ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
 420 |                         });
 421 |                     }
 422 |     
 423 |                     // In the second stage, we run the text against regular expressions that look
 424 |                     // for non-JSON patterns. We are especially concerned with '()' and 'new'
 425 |                     // because they can cause invocation, and '=' because it can cause mutation.
 426 |                     // But just to be safe, we want to reject all unexpected forms.
 427 |     
 428 |                     // We split the second stage into 4 regexp operations in order to work around
 429 |                     // crippling inefficiencies in IE's and Safari's regexp engines. First we
 430 |                     // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
 431 |                     // replace all simple value tokens with ']' characters. Third, we delete all
 432 |                     // open brackets that follow a colon or comma or that begin the text. Finally,
 433 |                     // we look to see that the remaining characters are only whitespace or ']' or
 434 |                     // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
 435 |     
 436 |                     if (/^[\],:{}\s]*$/
 437 |                         .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
 438 |                               .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
 439 |                               .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
 440 |     
 441 |                         // In the third stage we use the eval function to compile the text into a
 442 |                         // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
 443 |                         // in JavaScript: it can begin a block or an object literal. We wrap the text
 444 |                         // in parens to eliminate the ambiguity.
 445 |     
 446 |                         j = eval('(' + text + ')');
 447 |     
 448 |                         // In the optional fourth stage, we recursively walk the new structure, passing
 449 |                         // each name/value pair to a reviver function for possible transformation.
 450 |     
 451 |                         return typeof reviver === 'function' ?
 452 |                             walk({'': j}, '') : j;
 453 |                     }
 454 |     
 455 |                     // If the text is not JSON parseable, then a SyntaxError is thrown.
 456 |     
 457 |                     throw new SyntaxError('JSON.parse');
 458 |                 };
 459 |     
 460 |                 return jsonShim;
 461 |             })()
 462 |         };
 463 |     }());
 464 |     /*global namespace*/
 465 |     (function () {
 466 |         namespace.shim = namespace.shim || {};
 467 |         var shim = namespace.shim;
 468 |     
 469 |         var prototypes = {
 470 |             bind: Function.prototype.bind,
 471 |             every: Array.prototype.every,
 472 |             some: Array.prototype.some,
 473 |             indexOf: Array.prototype.indexOf,
 474 |             forEach: Array.prototype.forEach,
 475 |             map: Array.prototype.map,
 476 |             filter: Array.prototype.filter,
 477 |             reduce: Array.prototype.reduce,
 478 |             trim: String.prototype.trim
 479 |         };
 480 |     
 481 |         function createShimMethod(key) {
 482 |             shim[key] = function (obj) {
 483 |                 var args = Array.prototype.slice.call(arguments, 1);
 484 |                 return prototypes[key].apply(obj, args);
 485 |             };
 486 |         }
 487 |     
 488 |         for (var key in prototypes) {
 489 |             if (prototypes.hasOwnProperty(key) && prototypes[key]) {
 490 |                 createShimMethod(key);
 491 |             }
 492 |         }
 493 |     
 494 |         if (!shim.bind) {
 495 |             shim.bind = function (fn, scope) {
 496 |                 return function () {
 497 |                     return fn.apply(scope, arguments);
 498 |                 };
 499 |             };
 500 |         }
 501 |     
 502 |         if (Object.keys) {
 503 |             shim['getKeys'] = Object.keys;
 504 |         }
 505 |     
 506 |         if ('object' === typeof JSON && JSON.parse && JSON.stringify) {
 507 |             shim['JSON'] = JSON;
 508 |         }
 509 |     }());
 510 |     /*global namespace*/
 511 |     (function () {
 512 |         var shim = namespace.shim;
 513 |         var forEach = shim.forEach;
 514 |         var filter = shim.filter;
 515 |         var getKeys = shim.getKeys;
 516 |     
 517 |         var utils = {
 518 |             // https://gist.github.com/1044128/
 519 |             getOuterHTML: function (element) {
 520 |                 // jshint browser:true
 521 |                 if ('outerHTML' in element) return element.outerHTML;
 522 |                 var ns = "http://www.w3.org/1999/xhtml";
 523 |                 var container = document.createElementNS(ns, '_');
 524 |                 var xmlSerializer = new XMLSerializer();
 525 |                 var html;
 526 |                 if (document.xmlVersion) {
 527 |                     return xmlSerializer.serializeToString(element);
 528 |                 } else {
 529 |                     container.appendChild(element.cloneNode(false));
 530 |                     html = container.innerHTML.replace('><', '>' + element.innerHTML + '<');
 531 |                     container.innerHTML = '';
 532 |                     return html;
 533 |                 }
 534 |             },
 535 |     
 536 |             // Returns true if object is a DOM element.
 537 |             isDOMElement: function (object) {
 538 |                 if (typeof HTMLElement === 'object') {
 539 |                     return object instanceof HTMLElement;
 540 |                 } else {
 541 |                     return object &&
 542 |                         typeof object === 'object' &&
 543 |                         object.nodeType === 1 &&
 544 |                         typeof object.nodeName === 'string';
 545 |                 }
 546 |             },
 547 |     
 548 |             isArray: function (ar) {
 549 |                 return Object.prototype.toString.call(ar) === '[object Array]';
 550 |             },
 551 |     
 552 |             isRegExp: function (re) {
 553 |                 var s;
 554 |                 try {
 555 |                     s = '' + re;
 556 |                 } catch (e) {
 557 |                     return false;
 558 |                 }
 559 |     
 560 |                 return re instanceof RegExp || // easy case
 561 |                 // duck-type for context-switching evalcx case
 562 |                 typeof(re) === 'function' &&
 563 |                     re.constructor.name === 'RegExp' &&
 564 |                     re.compile &&
 565 |                     re.test &&
 566 |                     re.exec &&
 567 |                     s.match(/^\/.*\/[gim]{0,3}$/);
 568 |             },
 569 |     
 570 |             isError: function (err) {
 571 |                 return typeof err === 'object' && Object.prototype.toString.call(err) === '[object Error]';
 572 |             },
 573 |     
 574 |             extend: function (target) {
 575 |                 var sources = Array.prototype.slice.call(arguments, 1);
 576 |                 forEach(sources, function (source) {
 577 |                     forEach(getKeys(source), function (key) {
 578 |                         target[key] = source[key];
 579 |                     });
 580 |                 });
 581 |                 return target;
 582 |             },
 583 |     
 584 |             isUndefinedOrNull: function (value) {
 585 |                 return value === null || value === undefined;
 586 |             },
 587 |     
 588 |             isArguments: function (object) {
 589 |                 return Object.prototype.toString.call(object) === '[object Arguments]';
 590 |             },
 591 |     
 592 |             getKeysOfDefinedProperties: function (object) {
 593 |                 return filter(getKeys(object), function (key) {
 594 |                     return typeof object[key] !== 'undefined';
 595 |                 });
 596 |             },
 597 |     
 598 |             /**
 599 |              * Levenshtein distance algorithm from wikipedia
 600 |              * http://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#JavaScript
 601 |              */
 602 |             levenshteinDistance: function (a, b) {
 603 |                 if (a.length === 0) return b.length;
 604 |                 if (b.length === 0) return a.length;
 605 |     
 606 |                 var matrix = [];
 607 |     
 608 |                 // increment along the first column of each row
 609 |                 var i;
 610 |                 for (i = 0; i <= b.length; i += 1) {
 611 |                     matrix[i] = [i];
 612 |                 }
 613 |     
 614 |                 // increment each column in the first row
 615 |                 var j;
 616 |                 for (j = 0; j <= a.length; j += 1) {
 617 |                     matrix[0][j] = j;
 618 |                 }
 619 |     
 620 |                 // Fill in the rest of the matrix
 621 |                 for (i = 1; i <= b.length; i += 1) {
 622 |                     for (j = 1; j <= a.length; j += 1) {
 623 |                         if (b.charAt(i - 1) === a.charAt(j - 1)) {
 624 |                             matrix[i][j] = matrix[i - 1][j - 1];
 625 |                         } else {
 626 |                             matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // substitution
 627 |                                                     Math.min(matrix[i][j - 1] + 1, // insertion
 628 |                                                              matrix[i - 1][j] + 1)); // deletion
 629 |                         }
 630 |                     }
 631 |                 }
 632 |     
 633 |                 return matrix[b.length][a.length];
 634 |             },
 635 |     
 636 |             truncateStack: function (err, fn) {
 637 |                 if (Error.captureStackTrace) {
 638 |                     Error.captureStackTrace(err, fn);
 639 |                 } else if ('stack' in err) {
 640 |                     // Excludes IE<10, and fn cannot be anonymous for this backup plan to work:
 641 |                     var stackEntries = err.stack.split(/\r\n?|\n\r?/),
 642 |                     needle = 'at ' + fn.name + ' ';
 643 |                     for (var i = 0 ; i < stackEntries.length ; i += 1) {
 644 |                         if (stackEntries[i].indexOf(needle) !== -1) {
 645 |                             stackEntries.splice(1, i);
 646 |                             err.stack = stackEntries.join("\n");
 647 |                         }
 648 |                     }
 649 |                 }
 650 |             },
 651 |     
 652 |             findFirst: function (arr, predicate, thisObj) {
 653 |                 var scope = thisObj || null;
 654 |                 for (var i = 0 ; i < arr.length ; i += 1) {
 655 |                     if (predicate.call(scope, arr[i], i, arr)) {
 656 |                         return arr[i];
 657 |                     }
 658 |                 }
 659 |                 return null;
 660 |             },
 661 |     
 662 |             leftPad: function (str, width, ch) {
 663 |                 ch = ch || ' ';
 664 |                 while (str.length < width) {
 665 |                     str = ch + str;
 666 |                 }
 667 |                 return str;
 668 |             }
 669 |         };
 670 |     
 671 |         namespace.utils = utils;
 672 |     }());
 673 |     /*global namespace*/
 674 |     (function () {
 675 |         var shim = namespace.shim;
 676 |         var bind = shim.bind;
 677 |         var forEach = shim.forEach;
 678 |         var filter = shim.filter;
 679 |         var map = shim.map;
 680 |         var trim = shim.trim;
 681 |         var reduce = shim.reduce;
 682 |         var getKeys = shim.getKeys;
 683 |         var indexOf = shim.indexOf;
 684 |     
 685 |         var utils = namespace.utils;
 686 |         var truncateStack = utils.truncateStack;
 687 |         var extend = utils.extend;
 688 |         var levenshteinDistance = utils.levenshteinDistance;
 689 |         var isArray = utils.isArray;
 690 |     
 691 |         function Assertion(expect, subject, testDescription, flags, args) {
 692 |             this.expect = expect;
 693 |             this.obj = subject; // deprecated
 694 |             this.equal = bind(expect.equal, expect); // deprecated
 695 |             this.eql = this.equal; // deprecated
 696 |             this.inspect = bind(expect.inspect, expect); // deprecated
 697 |             this.subject = subject;
 698 |             this.testDescription = testDescription;
 699 |             this.flags = flags;
 700 |             this.args = args;
 701 |             this.errorMode = 'default';
 702 |         }
 703 |     
 704 |         Assertion.prototype.standardErrorMessage = function () {
 705 |             var expect = this.expect;
 706 |             var argsString = map(this.args, function (arg) {
 707 |                 return expect.inspect(arg);
 708 |             }).join(', ');
 709 |     
 710 |             if (argsString.length > 0) {
 711 |                 argsString = ' ' + argsString;
 712 |             }
 713 |     
 714 |             return 'expected ' +
 715 |                 expect.inspect(this.subject) +
 716 |                 ' ' + this.testDescription +
 717 |                 argsString;
 718 |         };
 719 |     
 720 |         Assertion.prototype.throwStandardError = function () {
 721 |             var err = new Error(this.standardErrorMessage());
 722 |             err._isUnexpected = true;
 723 |             throw err;
 724 |         };
 725 |     
 726 |         Assertion.prototype.assert = function (condition) {
 727 |             var not = !!this.flags.not;
 728 |             condition = !!condition;
 729 |             if (condition === not) {
 730 |                 this.throwStandardError();
 731 |             }
 732 |         };
 733 |     
 734 |         function Unexpected(assertions, types) {
 735 |             this.assertions = assertions || {};
 736 |             this.types = types || [];
 737 |         }
 738 |     
 739 |         Unexpected.prototype.equal = function (actual, expected, depth, seen) {
 740 |             var that = this;
 741 |     
 742 |             depth = depth || 0;
 743 |             if (depth > 500) {
 744 |                 // detect recursive loops in the structure
 745 |                 seen = seen || [];
 746 |                 if (seen.indexOf(actual) !== -1) {
 747 |                     throw new Error('Cannot compare circular structures');
 748 |                 }
 749 |                 seen.push(actual);
 750 |             }
 751 |     
 752 |             var matchingCustomType = utils.findFirst(this.types || [], function (type) {
 753 |                 return type.identify(actual) && type.identify(expected);
 754 |             });
 755 |     
 756 |             if (matchingCustomType) {
 757 |                 return matchingCustomType.equal(actual, expected, function (a, b) {
 758 |                     return that.equal(a, b, depth + 1, seen);
 759 |                 });
 760 |             }
 761 |     
 762 |             return false; // we should never get there
 763 |         };
 764 |     
 765 |         Unexpected.prototype.inspect = function (obj, depth) {
 766 |             var types = this.types;
 767 |             var seen = [];
 768 |             var format = function (obj, depth) {
 769 |                 if (depth === 0) {
 770 |                     return '...';
 771 |                 }
 772 |     
 773 |                 seen = seen || [];
 774 |                 if (indexOf(seen, obj) !== -1) {
 775 |                     return '[Circular]';
 776 |                 }
 777 |     
 778 |                 var matchingCustomType = utils.findFirst(types || [], function (type) {
 779 |                     return type.identify(obj);
 780 |                 });
 781 |     
 782 |                 if (matchingCustomType) {
 783 |                     return matchingCustomType.inspect(obj, function (v) {
 784 |                         seen.push(obj);
 785 |                         return format(v, depth - 1);
 786 |                     }, depth);
 787 |                 }
 788 |             };
 789 |     
 790 |             return format(obj, depth || 3);
 791 |         };
 792 |     
 793 |         Unexpected.prototype.format = function (message, args) {
 794 |             args = map(args, function (arg) {
 795 |                 return this.inspect(arg);
 796 |             }, this);
 797 |             message = message.replace(/\{(\d+)\}/g, function (match, n) {
 798 |                 return args[n] || match;
 799 |             });
 800 |             return message;
 801 |         };
 802 |     
 803 |         Unexpected.prototype.fail = function (message) {
 804 |             message = message || "explicit failure";
 805 |             var args = Array.prototype.slice.call(arguments, 1);
 806 |             var error =  new Error(this.format(message, args));
 807 |             error._isUnexpected = true;
 808 |             throw error;
 809 |         };
 810 |     
 811 |         Unexpected.prototype.findAssertionSimilarTo = function (text) {
 812 |             var editDistrances = [];
 813 |             forEach(getKeys(this.assertions), function (assertion) {
 814 |                 var distance = levenshteinDistance(text, assertion);
 815 |                 editDistrances.push({
 816 |                     assertion: assertion,
 817 |                     distance: distance
 818 |                 });
 819 |             });
 820 |             editDistrances.sort(function (x, y) {
 821 |                 return x.distance - y.distance;
 822 |             });
 823 |             return map(editDistrances.slice(0, 5), function (editDistrance) {
 824 |                 return editDistrance.assertion;
 825 |             });
 826 |         };
 827 |     
 828 |         Unexpected.prototype.addAssertion = function () {
 829 |             var assertions = this.assertions;
 830 |             var patterns = Array.prototype.slice.call(arguments, 0, -1);
 831 |             var handler = Array.prototype.slice.call(arguments, -1)[0];
 832 |             forEach(patterns, function (pattern) {
 833 |                 ensureValidPattern(pattern);
 834 |                 forEach(expandPattern(pattern), function (expandedPattern) {
 835 |                     assertions[expandedPattern.text] = {
 836 |                         handler: handler,
 837 |                         flags: expandedPattern.flags
 838 |                     };
 839 |                 });
 840 |             });
 841 |     
 842 |             return this.expect; // for chaining
 843 |         };
 844 |     
 845 |         Unexpected.prototype.getType = function (typeName) {
 846 |             return utils.findFirst(this.types, function (type) {
 847 |                 return type.name === typeName;
 848 |             });
 849 |         };
 850 |     
 851 |         var customTypePrototype = {
 852 |             name: 'any',
 853 |             equal: function (a, b) {
 854 |                 return a === b;
 855 |             },
 856 |             inspect: function (value) {
 857 |                 return '' + value;
 858 |             },
 859 |             toJSON: function (value) {
 860 |                 return value;
 861 |             }
 862 |         };
 863 |     
 864 |         Unexpected.prototype.addType = function (type) {
 865 |             var baseType;
 866 |             if (type.base) {
 867 |                 baseType = utils.findFirst(this.types, function (t) {
 868 |                     return t.name === type.base;
 869 |                 });
 870 |     
 871 |                 if (!baseType) {
 872 |                     throw new Error('Unknown base type: ' + type.base);
 873 |                 }
 874 |             } else {
 875 |                 baseType = customTypePrototype;
 876 |             }
 877 |     
 878 |             this.types.unshift(extend({}, baseType, type, { baseType: baseType }));
 879 |     
 880 |             return this.expect;
 881 |         };
 882 |     
 883 |         Unexpected.prototype.installPlugin = function (plugin) {
 884 |             if (typeof plugin !== 'function') {
 885 |                 throw new Error('Expected first argument given to installPlugin to be a function');
 886 |             }
 887 |     
 888 |             plugin(this.expect);
 889 |     
 890 |             return this.expect; // for chaining
 891 |         };
 892 |     
 893 |         Unexpected.prototype.sanitize = function (obj, stack) {
 894 |             var that = this;
 895 |             stack = stack || [];
 896 |     
 897 |             var i;
 898 |             for (i = 0 ; i < stack.length ; i += 1) {
 899 |                 if (stack[i] === obj) {
 900 |                     return obj;
 901 |                 }
 902 |             }
 903 |     
 904 |             stack.push(obj);
 905 |     
 906 |             var sanitized,
 907 |                 matchingCustomType = utils.findFirst(this.types || [], function (type) {
 908 |                     return type.identify(obj);
 909 |                 });
 910 |             if (matchingCustomType) {
 911 |                 sanitized = matchingCustomType.toJSON(obj, function (v) {
 912 |                     return that.sanitize(v, stack);
 913 |                 });
 914 |             } else if (isArray(obj)) {
 915 |                 sanitized = map(obj, function (item) {
 916 |                     return this.sanitize(item, stack);
 917 |                 }, this);
 918 |             } else if (typeof obj === 'object' && obj) {
 919 |                 sanitized = {};
 920 |                 forEach(getKeys(obj).sort(), function (key) {
 921 |                     sanitized[key] = this.sanitize(obj[key], stack);
 922 |                 }, this);
 923 |             } else {
 924 |                 sanitized = obj;
 925 |             }
 926 |             stack.pop();
 927 |             return sanitized;
 928 |         };
 929 |     
 930 |         var errorMethodBlacklist = reduce(['message', 'line', 'sourceId', 'sourceURL', 'stack', 'stackArray'], function (result, prop) {
 931 |             result[prop] = true;
 932 |             return result;
 933 |         }, {});
 934 |     
 935 |         function errorWithMessage(e, message) {
 936 |             var newError = new Error(message);
 937 |             forEach(getKeys(e), function (key) {
 938 |                 if (!errorMethodBlacklist[key]) {
 939 |                     newError[key] = e[key];
 940 |                 }
 941 |             });
 942 |             return newError;
 943 |         }
 944 |     
 945 |         function handleNestedExpects(e, assertion) {
 946 |             switch (assertion.errorMode) {
 947 |             case 'nested':
 948 |                 return errorWithMessage(e, assertion.standardErrorMessage() + '\n    ' + e.message.replace(/\n/g, '\n    '));
 949 |             case 'default':
 950 |                 return errorWithMessage(e, assertion.standardErrorMessage());
 951 |             case 'bubble':
 952 |                 return e;
 953 |             default:
 954 |                 throw new Error("Unknown error mode: '" + assertion.errorMode + "'");
 955 |             }
 956 |         }
 957 |     
 958 |         function installExpectMethods(unexpected, expectFunction) {
 959 |             var expect = bind(expectFunction, unexpected);
 960 |             expect.equal = bind(unexpected.equal, unexpected);
 961 |             expect.sanitize = bind(unexpected.sanitize, unexpected);
 962 |             expect.inspect = bind(unexpected.inspect, unexpected);
 963 |             expect.fail = bind(unexpected.fail, unexpected);
 964 |             expect.addAssertion = bind(unexpected.addAssertion, unexpected);
 965 |             expect.addType = bind(unexpected.addType, unexpected);
 966 |             expect.clone = bind(unexpected.clone, unexpected);
 967 |             expect.toString = bind(unexpected.toString, unexpected);
 968 |             expect.assertions = unexpected.assertions;
 969 |             expect.installPlugin = bind(unexpected.installPlugin, unexpected);
 970 |             return expect;
 971 |         }
 972 |     
 973 |         function makeExpectFunction(unexpected) {
 974 |             var expect = installExpectMethods(unexpected, unexpected.expect);
 975 |             unexpected.expect = expect;
 976 |             return expect;
 977 |         }
 978 |     
 979 |         Unexpected.prototype.expect = function expect(subject, testDescriptionString) {
 980 |             var that = this;
 981 |             if (arguments.length < 2) {
 982 |                 throw new Error('The expect functions requires at least two parameters.');
 983 |             }
 984 |             if (typeof testDescriptionString !== 'string') {
 985 |                 throw new Error('The expect functions requires second parameter to be a string.');
 986 |             }
 987 |             var assertionRule = this.assertions[testDescriptionString];
 988 |             if (assertionRule) {
 989 |                 var flags = extend({}, assertionRule.flags);
 990 |     
 991 |                 var nestingLevel = 0;
 992 |                 var callInNestedContext = function (callback) {
 993 |                     nestingLevel += 1;
 994 |                     try {
 995 |                         callback();
 996 |                         nestingLevel -= 1;
 997 |                     } catch (e) {
 998 |                         nestingLevel -= 1;
 999 |                         if (e._isUnexpected) {
1000 |                             truncateStack(e, wrappedExpect);
1001 |                             if (nestingLevel === 0) {
1002 |                                 throw handleNestedExpects(e, assertion);
1003 |                             }
1004 |                         }
1005 |                         throw e;
1006 |                     }
1007 |                 };
1008 |     
1009 |                 var wrappedExpect = function wrappedExpect(subject, testDescriptionString) {
1010 |                     testDescriptionString = trim(testDescriptionString.replace(/\[(!?)([^\]]+)\] ?/g, function (match, negate, flag) {
1011 |                         negate = !!negate;
1012 |                         return flags[flag] !== negate ? flag + ' ' : '';
1013 |                     }));
1014 |     
1015 |                     var args = Array.prototype.slice.call(arguments, 2);
1016 |                     callInNestedContext(function () {
1017 |                         that.expect.apply(that, [subject, testDescriptionString].concat(args));
1018 |                     });
1019 |                 };
1020 |     
1021 |                 // Not sure this is the right way to go about this:
1022 |                 wrappedExpect.equal = this.equal;
1023 |                 wrappedExpect.types = this.types;
1024 |                 wrappedExpect.sanitize = this.sanitize;
1025 |                 wrappedExpect.inspect = this.inspect;
1026 |                 wrappedExpect.fail = function () {
1027 |                     var args = arguments;
1028 |                     callInNestedContext(function () {
1029 |                         that.fail.apply(that, args);
1030 |                     });
1031 |                 };
1032 |                 wrappedExpect.format = this.format;
1033 |     
1034 |                 var args = Array.prototype.slice.call(arguments, 2);
1035 |                 args.unshift(wrappedExpect, subject);
1036 |                 var assertion = new Assertion(wrappedExpect, subject, testDescriptionString, flags, args.slice(2));
1037 |                 var handler = assertionRule.handler;
1038 |                 try {
1039 |                     handler.apply(assertion, args);
1040 |                 } catch (e) {
1041 |                     if (e._isUnexpected) {
1042 |                         truncateStack(e, this.expect);
1043 |                     }
1044 |                     throw e;
1045 |                 }
1046 |             } else {
1047 |                 var similarAssertions = this.findAssertionSimilarTo(testDescriptionString);
1048 |                 var message =
1049 |                     'Unknown assertion "' + testDescriptionString + '", ' +
1050 |                     'did you mean: "' + similarAssertions[0] + '"';
1051 |                 var err = new Error(message);
1052 |                 truncateStack(err, this.expect);
1053 |                 throw err;
1054 |             }
1055 |         };
1056 |     
1057 |         Unexpected.prototype.toString = function () {
1058 |             return getKeys(this.assertions).sort().join('\n');
1059 |         };
1060 |     
1061 |         Unexpected.prototype.clone = function () {
1062 |             var unexpected = new Unexpected(extend({}, this.assertions), [].concat(this.types));
1063 |             return makeExpectFunction(unexpected);
1064 |         };
1065 |     
1066 |         Unexpected.create = function () {
1067 |             var unexpected = new Unexpected();
1068 |             return makeExpectFunction(unexpected);
1069 |         };
1070 |     
1071 |         var expandPattern = (function () {
1072 |             function isFlag(token) {
1073 |                 return token.slice(0, 1) === '[' && token.slice(-1) === ']';
1074 |             }
1075 |             function isAlternation(token) {
1076 |                 return token.slice(0, 1) === '(' && token.slice(-1) === ')';
1077 |             }
1078 |             function removeEmptyStrings(texts) {
1079 |                 return filter(texts, function (text) {
1080 |                     return text !== '';
1081 |                 });
1082 |             }
1083 |             function createPermutations(tokens, index) {
1084 |                 if (index === tokens.length) {
1085 |                     return [{ text: '', flags: {}}];
1086 |                 }
1087 |     
1088 |                 var token = tokens[index];
1089 |                 var tail = createPermutations(tokens, index + 1);
1090 |                 if (isFlag(token)) {
1091 |                     var flag = token.slice(1, -1);
1092 |                     return map(tail, function (pattern) {
1093 |                         var flags = {};
1094 |                         flags[flag] = true;
1095 |                         return {
1096 |                             text: flag + ' ' + pattern.text,
1097 |                             flags: extend(flags, pattern.flags)
1098 |                         };
1099 |                     }).concat(map(tail, function (pattern) {
1100 |                         var flags = {};
1101 |                         flags[flag] = false;
1102 |                         return {
1103 |                             text: pattern.text,
1104 |                             flags: extend(flags, pattern.flags)
1105 |                         };
1106 |                     }));
1107 |                 } else if (isAlternation(token)) {
1108 |                     var alternations = token.split(/\(|\)|\|/);
1109 |                     alternations = removeEmptyStrings(alternations);
1110 |                     return reduce(alternations, function (result, alternation) {
1111 |                         return result.concat(map(tail, function (pattern) {
1112 |                             return {
1113 |                                 text: alternation + pattern.text,
1114 |                                 flags: pattern.flags
1115 |                             };
1116 |                         }));
1117 |                     }, []);
1118 |                 } else {
1119 |                     return map(tail, function (pattern) {
1120 |                         return {
1121 |                             text: token + pattern.text,
1122 |                             flags: pattern.flags
1123 |                         };
1124 |                     });
1125 |                 }
1126 |             }
1127 |             return function (pattern) {
1128 |                 pattern = pattern.replace(/(\[[^\]]+\]) ?/g, '$1');
1129 |                 var splitRegex = /\[[^\]]+\]|\([^\)]+\)/g;
1130 |                 var tokens = [];
1131 |                 var m;
1132 |                 var lastIndex = 0;
1133 |                 while ((m = splitRegex.exec(pattern))) {
1134 |                     tokens.push(pattern.slice(lastIndex, m.index));
1135 |                     tokens.push(pattern.slice(m.index, splitRegex.lastIndex));
1136 |                     lastIndex = splitRegex.lastIndex;
1137 |                 }
1138 |                 tokens.push(pattern.slice(lastIndex));
1139 |     
1140 |                 tokens = removeEmptyStrings(tokens);
1141 |                 var permutations = createPermutations(tokens, 0);
1142 |                 forEach(permutations, function (permutation) {
1143 |                     permutation.text = trim(permutation.text);
1144 |                     if (permutation.text === '') {
1145 |                         // This can only happen if the pattern only contains flags
1146 |                         throw new Error("Assertion patterns must not only contain flags");
1147 |                     }
1148 |                 });
1149 |                 return permutations;
1150 |             };
1151 |         }());
1152 |     
1153 |     
1154 |         function ensureValidUseOfParenthesesOrBrackets(pattern) {
1155 |             var counts = {
1156 |                 '[': 0,
1157 |                 ']': 0,
1158 |                 '(': 0,
1159 |                 ')': 0
1160 |             };
1161 |             for (var i = 0; i < pattern.length; i += 1) {
1162 |                 var c = pattern.charAt(i);
1163 |                 if (c in counts) {
1164 |                     counts[c] += 1;
1165 |                 }
1166 |                 if (c === ']' && counts['['] >= counts[']']) {
1167 |                     if (counts['['] === counts[']'] + 1) {
1168 |                         throw new Error("Assertion patterns must not contain flags with brackets: '" + pattern + "'");
1169 |                     }
1170 |     
1171 |                     if (counts['('] !== counts[')']) {
1172 |                         throw new Error("Assertion patterns must not contain flags with parentheses: '" + pattern + "'");
1173 |                     }
1174 |     
1175 |                     if (pattern.charAt(i - 1) === '[') {
1176 |                         throw new Error("Assertion patterns must not contain empty flags: '" + pattern + "'");
1177 |                     }
1178 |                 } else if (c === ')' && counts['('] >= counts[')']) {
1179 |                     if (counts['('] === counts[')'] + 1) {
1180 |                         throw new Error("Assertion patterns must not contain alternations with parentheses: '" + pattern + "'");
1181 |                     }
1182 |     
1183 |                     if (counts['['] !== counts[']']) {
1184 |                         throw new Error("Assertion patterns must not contain alternations with brackets: '" + pattern + "'");
1185 |                     }
1186 |                 }
1187 |     
1188 |                 if ((c === ')' || c === '|') && counts['('] >= counts[')']) {
1189 |                     if (pattern.charAt(i - 1) === '(' || pattern.charAt(i - 1) === '|') {
1190 |                         throw new Error("Assertion patterns must not contain empty alternations: '" + pattern + "'");
1191 |                     }
1192 |                 }
1193 |             }
1194 |     
1195 |             if (counts['['] !== counts[']']) {
1196 |                 throw new Error("Assertion patterns must not contain unbalanced brackets: '" + pattern + "'");
1197 |             }
1198 |     
1199 |             if (counts['('] !== counts[')']) {
1200 |                 throw new Error("Assertion patterns must not contain unbalanced parentheses: '" + pattern + "'");
1201 |             }
1202 |         }
1203 |     
1204 |         function ensureValidPattern(pattern) {
1205 |             if (typeof pattern !== 'string' || pattern === '') {
1206 |                 throw new Error("Assertion patterns must be a non empty string");
1207 |             }
1208 |             if (pattern.match(/^\s|\s$/)) {
1209 |                 throw new Error("Assertion patterns can't start or end with whitespace");
1210 |             }
1211 |     
1212 |             ensureValidUseOfParenthesesOrBrackets(pattern);
1213 |         }
1214 |     
1215 |         namespace.expect = Unexpected.create();
1216 |     }());
1217 |     /*global namespace, Uint8Array, Uint16Array*/
1218 |     (function () {
1219 |         var expect = namespace.expect;
1220 |     
1221 |         var utils = namespace.utils;
1222 |         var isRegExp = utils.isRegExp;
1223 |         var leftPad = utils.leftPad;
1224 |         var shim = namespace.shim;
1225 |         var json = shim.JSON;
1226 |         var every = shim.every;
1227 |         var some = shim.some;
1228 |         var map = shim.map;
1229 |         var getKeys = shim.getKeys;
1230 |         var reduce = shim.reduce;
1231 |         var extend = utils.extend;
1232 |     
1233 |         expect.addType({
1234 |             name: 'fallback',
1235 |             identify: function (value) {
1236 |                 return true;
1237 |             },
1238 |             equal: function (a, b) {
1239 |                 return a === b;
1240 |             },
1241 |             inspect: function (value) {
1242 |                 return '' + value;
1243 |             },
1244 |             toJSON: function (value) {
1245 |                 return value;
1246 |             }
1247 |         });
1248 |     
1249 |         expect.addType({
1250 |             name: 'object',
1251 |             identify: function (arr) {
1252 |                 return typeof arr === 'object';
1253 |             },
1254 |             equal: function (a, b, equal) {
1255 |                 if (a === b) {
1256 |                     return true;
1257 |                 }
1258 |     
1259 |                 // an identical "prototype" property.
1260 |                 if (a.prototype !== b.prototype) {
1261 |                     return false;
1262 |                 }
1263 |                 //~~~I've managed to break Object.keys through screwy arguments passing.
1264 |                 //   Converting to array solves the problem.
1265 |                 if (utils.isArguments(a)) {
1266 |                     if (!utils.isArguments(b)) {
1267 |                         return false;
1268 |                     }
1269 |                     return equal(Array.prototype.slice.call(a), Array.prototype.slice.call(b));
1270 |                 }
1271 |                 var actualKeys = utils.getKeysOfDefinedProperties(a),
1272 |                     expectedKeys = utils.getKeysOfDefinedProperties(b),
1273 |                     key,
1274 |                     i;
1275 |     
1276 |                 // having the same number of owned properties (keys incorporates hasOwnProperty)
1277 |                 if (actualKeys.length !== expectedKeys.length) {
1278 |                     return false;
1279 |                 }
1280 |                 //the same set of keys (although not necessarily the same order),
1281 |                 actualKeys.sort();
1282 |                 expectedKeys.sort();
1283 |                 //~~~cheap key test
1284 |                 for (i = actualKeys.length - 1; i >= 0; i -= 1) {
1285 |                     if (actualKeys[i] !== expectedKeys[i]) {
1286 |                         return false;
1287 |                     }
1288 |                 }
1289 |     
1290 |                 //equivalent values for every corresponding key, and
1291 |                 //~~~possibly expensive deep test
1292 |                 for (i = actualKeys.length - 1; i >= 0; i -= 1) {
1293 |                     key = actualKeys[i];
1294 |                     if (!equal(a[key], b[key])) {
1295 |                         return false;
1296 |                     }
1297 |                 }
1298 |                 return true;
1299 |             },
1300 |             inspect: function (obj, inspect) {
1301 |                 var keys = getKeys(obj);
1302 |                 if (keys.length === 0) {
1303 |                     return '{}';
1304 |                 }
1305 |     
1306 |                 var inspectedItems = map(keys, function (key) {
1307 |                     var parts = [];
1308 |                     if (key.match(/["' ]/)) {
1309 |                         parts.push(expect.inspect(key) + ':');
1310 |                     } else {
1311 |                         parts.push(key + ':');
1312 |                     }
1313 |     
1314 |                     var hasGetter = obj.__lookupGetter__ && obj.__lookupGetter__(key);
1315 |                     var hasSetter = obj.__lookupGetter__ && obj.__lookupSetter__(key);
1316 |     
1317 |                     if (hasGetter || !hasSetter) {
1318 |                         parts.push(inspect(obj[key]));
1319 |                     }
1320 |     
1321 |                     if (hasGetter && hasSetter) {
1322 |                         parts.push('[Getter/Setter]');
1323 |                     } else if (hasGetter) {
1324 |                         parts.push('[Getter]');
1325 |                     } else if (hasSetter) {
1326 |                         parts.push('[Setter]');
1327 |                     }
1328 |     
1329 |                     return parts.join(' ');
1330 |                 });
1331 |     
1332 |                 var length = 0;
1333 |                 var multipleLines = some(inspectedItems, function (v) {
1334 |                     length += v.length;
1335 |                     return length > 50 || v.match(/\n/);
1336 |                 });
1337 |     
1338 |                 if (multipleLines) {
1339 |                     return '{\n' + inspectedItems.join(',\n').replace(/^/gm, '  ') + '\n}';
1340 |                 } else {
1341 |                     return '{ ' + inspectedItems.join(', ') + ' }';
1342 |                 }
1343 |             },
1344 |             toJSON: function (obj, toJSON) {
1345 |                 return reduce(getKeys(obj), function (result, key) {
1346 |                     result[key] = toJSON(obj[key]);
1347 |                     return result;
1348 |                 }, {});
1349 |             }
1350 |         });
1351 |     
1352 |         expect.addType({
1353 |             name: 'array',
1354 |             identify: function (arr) {
1355 |                 return utils.isArray(arr) || utils.isArguments(arr);
1356 |             },
1357 |             equal: function (a, b, equal) {
1358 |                 return a === b || (a.length === b.length && every(a, function (v, index) {
1359 |                     return equal(v, b[index]);
1360 |                 }));
1361 |             },
1362 |             inspect: function (arr, inspect, depth) {
1363 |                 if (arr.length === 0) {
1364 |                     return '[]';
1365 |                 }
1366 |     
1367 |                 if (depth === 1) {
1368 |                     return '[...]';
1369 |                 }
1370 |     
1371 |                 var inspectedItems = map(arr, function (v) {
1372 |                     return inspect(v);
1373 |                 });
1374 |     
1375 |                 var length = 0;
1376 |                 var multipleLines = some(inspectedItems, function (v) {
1377 |                     length += v.length;
1378 |                     return length > 50 || v.match(/\n/);
1379 |                 });
1380 |     
1381 |                 if (multipleLines) {
1382 |                     return '[\n' + inspectedItems.join(',\n').replace(/^/gm, '  ') + '\n]';
1383 |                 } else {
1384 |                     return '[ ' + inspectedItems.join(', ') + ' ]';
1385 |                 }
1386 |             },
1387 |             toJSON: function (arr, toJSON) {
1388 |                 return map(arr, toJSON);
1389 |             }
1390 |         });
1391 |     
1392 |         expect.addType({
1393 |             base: 'object',
1394 |             name: 'Error',
1395 |             identify: function (value) {
1396 |                 return utils.isError(value);
1397 |             },
1398 |             equal: function (a, b, equal) {
1399 |                 return a === b ||
1400 |                     (equal(a.message, b.message) && this.baseType.equal(a, b, equal));
1401 |             },
1402 |             inspect: function (value, inspect) {
1403 |                 var errorObject = extend({
1404 |                     message: value.message
1405 |                 }, value);
1406 |                 return '[Error: ' + inspect(errorObject) + ']';
1407 |             }
1408 |         });
1409 |     
1410 |         expect.addType({
1411 |             name: 'date',
1412 |             identify: function (obj) {
1413 |                 return Object.prototype.toString.call(obj) === '[object Date]';
1414 |             },
1415 |             equal: function (a, b) {
1416 |                 return a.getTime() === b.getTime();
1417 |             },
1418 |             inspect: function (date) {
1419 |                 return '[Date ' + date.toUTCString() + ']';
1420 |             },
1421 |             toJSON: function (date) {
1422 |                 return {
1423 |                     $Date: this.inspect(date)
1424 |                 };
1425 |             }
1426 |         });
1427 |     
1428 |         expect.addType({
1429 |             name: 'function',
1430 |             identify: function (f) {
1431 |                 return typeof f === 'function';
1432 |             },
1433 |             equal: function (a, b) {
1434 |                 return a === b || a.toString() === b.toString();
1435 |             },
1436 |             inspect: function (f) {
1437 |                 var n = f.name ? ': ' + f.name : '';
1438 |                 return '[Function' + n + ']';
1439 |             },
1440 |             toJSON: function (f) {
1441 |                 return {
1442 |                     $Function: this.inspect(f)
1443 |                 };
1444 |             }
1445 |         });
1446 |     
1447 |         expect.addType({
1448 |             name: 'regexp',
1449 |             identify: isRegExp,
1450 |             equal: function (a, b) {
1451 |                 return a === b || (
1452 |                     a.source === b.source &&
1453 |                         a.global === b.global &&
1454 |                         a.ignoreCase === b.ignoreCase &&
1455 |                         a.multiline === b.multiline
1456 |                 );
1457 |             },
1458 |             inspect: function (regExp) {
1459 |                 return '' + regExp;
1460 |             },
1461 |             toJSON: function (regExp) {
1462 |                 return {
1463 |                     $RegExp: this.inspect(regExp)
1464 |                 };
1465 |             }
1466 |         });
1467 |     
1468 |         expect.addType({
1469 |             name: 'DomElement',
1470 |             identify: function (value) {
1471 |                 return utils.isDOMElement(value);
1472 |             },
1473 |             inspect: function (value) {
1474 |                 return utils.getOuterHTML(value);
1475 |             }
1476 |         });
1477 |     
1478 |         function getHexDumpLinesForBufferLikeObject(obj, width, digitWidth) {
1479 |             digitWidth = digitWidth || 2;
1480 |             var hexDumpLines = [];
1481 |             if (typeof width !== 'number') {
1482 |                 width = 16;
1483 |             } else if (width === 0) {
1484 |                 width = obj.length;
1485 |             }
1486 |             for (var i = 0 ; i < obj.length ; i += width) {
1487 |                 var hexChars = '',
1488 |                     asciiChars = ' |';
1489 |     
1490 |                 for (var j = 0 ; j < width ; j += 1) {
1491 |                     if (i + j < obj.length) {
1492 |                         var octet = obj[i + j];
1493 |                         hexChars += leftPad(octet.toString(16).toUpperCase(), digitWidth, '0') + ' ';
1494 |                         asciiChars += (octet >= 32 && octet < 127) ? String.fromCharCode(octet) : '.';
1495 |                     } else if (digitWidth === 2) {
1496 |                         hexChars += '   ';
1497 |                     }
1498 |                 }
1499 |     
1500 |                 if (digitWidth === 2) {
1501 |                     asciiChars += '|';
1502 |                     hexDumpLines.push(hexChars + asciiChars);
1503 |                 } else {
1504 |                     hexDumpLines.push(hexChars.replace(/\s+$/, ''));
1505 |                 }
1506 |             }
1507 |             return hexDumpLines;
1508 |         }
1509 |     
1510 |         function inspectBufferLikeObject(buffer, digitWidth) {
1511 |             var inspectedContents,
1512 |                 maxLength = 20;
1513 |             if (buffer.length > maxLength) {
1514 |                 inspectedContents = getHexDumpLinesForBufferLikeObject(buffer.slice(0, maxLength), 0, digitWidth) + ' (+' + (buffer.length - maxLength) + ')';
1515 |             } else {
1516 |                 inspectedContents = getHexDumpLinesForBufferLikeObject(buffer, 0, digitWidth).join('\n');
1517 |             }
1518 |             return inspectedContents;
1519 |         }
1520 |     
1521 |         function bufferLikeObjectsEqual(a, b) {
1522 |             if (a === b) {
1523 |                 return true;
1524 |             }
1525 |     
1526 |             if (a.length !== b.length) return false;
1527 |     
1528 |             for (var i = 0; i < a.length; i += 1) {
1529 |                 if (a[i] !== b[i]) return false;
1530 |             }
1531 |     
1532 |             return true;
1533 |         }
1534 |     
1535 |         if (typeof Buffer !== 'undefined') {
1536 |             expect.addType({
1537 |                 name: 'Buffer',
1538 |                 identify: Buffer.isBuffer,
1539 |                 equal: bufferLikeObjectsEqual,
1540 |                 inspect: function (buffer) {
1541 |                     return '[Buffer ' + inspectBufferLikeObject(buffer) + ']';
1542 |                 },
1543 |                 toJSON: function (buffer) {
1544 |                     return {
1545 |                         $Buffer: getHexDumpLinesForBufferLikeObject(buffer)
1546 |                     };
1547 |                 }
1548 |             });
1549 |         }
1550 |     
1551 |         if (typeof Uint8Array !== 'undefined') {
1552 |             expect.addType({
1553 |                 name: 'Uint8Array',
1554 |                 identify: function (obj) {
1555 |                     return obj && obj instanceof Uint8Array;
1556 |                 },
1557 |                 equal: bufferLikeObjectsEqual,
1558 |                 inspect: function (uint8Array) {
1559 |                     return '[Uint8Array ' + inspectBufferLikeObject(uint8Array) + ']';
1560 |                 },
1561 |                 toJSON: function (uint8Array) {
1562 |                     return {
1563 |                         $Uint8Array: getHexDumpLinesForBufferLikeObject(uint8Array)
1564 |                     };
1565 |                 }
1566 |             });
1567 |         }
1568 |     
1569 |     
1570 |         if (typeof Uint16Array !== 'undefined') {
1571 |             expect.addType({
1572 |                 name: 'Uint16Array',
1573 |                 identify: function (obj) {
1574 |                     return obj && obj instanceof Uint16Array;
1575 |                 },
1576 |                 equal: bufferLikeObjectsEqual,
1577 |                 inspect: function (uint16Array) {
1578 |                     return '[Uint16Array ' + inspectBufferLikeObject(uint16Array, 8, 4, false) + ']';
1579 |                 },
1580 |                 toJSON: function (uint16Array) {
1581 |                     return {
1582 |                         $Uint16Array: getHexDumpLinesForBufferLikeObject(uint16Array, 8, 4, false)
1583 |                     };
1584 |                 }
1585 |             });
1586 |         }
1587 |     
1588 |         expect.addType({
1589 |             name: 'string',
1590 |             identify: function (value) {
1591 |                 return typeof value === 'string';
1592 |             },
1593 |             inspect: function (value) {
1594 |                 return '\'' + json.stringify(value).replace(/^"|"$/g, '')
1595 |                     .replace(/'/g, "\\'")
1596 |                     .replace(/\\"/g, '"') + '\'';
1597 |             }
1598 |         });
1599 |     
1600 |         expect.addType({
1601 |             name: 'number',
1602 |             identify: function (value) {
1603 |                 return typeof value === 'number';
1604 |             }
1605 |         });
1606 |     
1607 |         expect.addType({
1608 |             name: 'boolean',
1609 |             identify: function (value) {
1610 |                 return typeof value === 'boolean';
1611 |             }
1612 |         });
1613 |     
1614 |         expect.addType({
1615 |             name: 'undefined',
1616 |             identify: function (value) {
1617 |                 return typeof value === 'undefined';
1618 |             }
1619 |         });
1620 |     
1621 |         expect.addType({
1622 |             name: 'null',
1623 |             identify: function (value) {
1624 |                 return value === null;
1625 |             }
1626 |         });
1627 |     }());
1628 |     /*global namespace*/
1629 |     (function () {
1630 |         var expect = namespace.expect;
1631 |     
1632 |         var shim = namespace.shim;
1633 |         var forEach = shim.forEach;
1634 |         var getKeys = shim.getKeys;
1635 |         var every = shim.every;
1636 |         var indexOf = shim.indexOf;
1637 |     
1638 |         var utils = namespace.utils;
1639 |         var isRegExp = utils.isRegExp;
1640 |         var isArray = utils.isArray;
1641 |     
1642 |         expect.addAssertion('[not] to be (ok|truthy)', function (expect, subject) {
1643 |             this.assert(subject);
1644 |         });
1645 |     
1646 |         expect.addAssertion('[not] to be', function (expect, subject, value) {
1647 |             expect(subject === value, '[not] to be truthy');
1648 |         });
1649 |     
1650 |         expect.addAssertion('[not] to be true', function (expect, subject) {
1651 |             expect(subject, '[not] to be', true);
1652 |         });
1653 |     
1654 |         expect.addAssertion('[not] to be false', function (expect, subject) {
1655 |             expect(subject, '[not] to be', false);
1656 |         });
1657 |     
1658 |         expect.addAssertion('[not] to be falsy', function (expect, subject) {
1659 |             expect(subject, '[!not] to be truthy');
1660 |         });
1661 |     
1662 |         expect.addAssertion('[not] to be null', function (expect, subject) {
1663 |             expect(subject, '[not] to be', null);
1664 |         });
1665 |     
1666 |         expect.addAssertion('[not] to be undefined', function (expect, subject) {
1667 |             expect(typeof subject, '[not] to be', 'undefined');
1668 |         });
1669 |     
1670 |         expect.addAssertion('[not] to be NaN', function (expect, subject) {
1671 |             expect(isNaN(subject), '[not] to be true');
1672 |         });
1673 |     
1674 |         expect.addAssertion('[not] to be (a|an)', function (expect, subject, type) {
1675 |             if ('string' === typeof type) {
1676 |                 // typeof with support for 'array'
1677 |                 expect('array' === type ? isArray(subject) :
1678 |                         'object' === type ? 'object' === typeof subject && null !== subject :
1679 |                             /^reg(?:exp?|ular expression)$/.test(type) ? isRegExp(subject) :
1680 |                                 type === typeof subject,
1681 |                        '[not] to be true');
1682 |             } else {
1683 |                 expect(subject instanceof type, '[not] to be true');
1684 |             }
1685 |     
1686 |             return this;
1687 |         });
1688 |     
1689 |         // Alias for common '[not] to be (a|an)' assertions
1690 |         expect.addAssertion('[not] to be (a|an) (boolean|number|string|function|object|array|regexp|regex|regular expression)', function (expect, subject) {
1691 |             var matches = /(.* be (?:a|an)) ([\w\s]+)/.exec(this.testDescription);
1692 |             expect(subject, matches[1], matches[2]);
1693 |         });
1694 |     
1695 |         forEach(['string', 'array', 'object'], function (type) {
1696 |             expect.addAssertion('to be (the|an) empty ' + type, function (expect, subject) {
1697 |                 expect(subject, 'to be a', type);
1698 |                 expect(subject, 'to be empty');
1699 |             });
1700 |     
1701 |             expect.addAssertion('to be a non-empty ' + type, function (expect, subject) {
1702 |                 expect(subject, 'to be a', type);
1703 |                 expect(subject, 'not to be empty');
1704 |             });
1705 |         });
1706 |     
1707 |         expect.addAssertion('[not] to match', function (expect, subject, regexp) {
1708 |             expect(regexp.exec(subject), '[not] to be truthy');
1709 |         });
1710 |     
1711 |         expect.addAssertion('[not] to have [own] property', function (expect, subject, key, value) {
1712 |             if (arguments.length === 4) {
1713 |                 expect(subject, 'to have [own] property', key);
1714 |                 expect(subject[key], '[not] to equal', value);
1715 |             } else {
1716 |                 expect(this.flags.own ?
1717 |                        subject && subject.hasOwnProperty(key) :
1718 |                        subject && subject[key] !== undefined,
1719 |                        '[not] to be truthy');
1720 |             }
1721 |         });
1722 |     
1723 |         expect.addAssertion('[not] to have [own] properties', function (expect, subject, properties) {
1724 |             if (properties && isArray(properties)) {
1725 |                 forEach(properties, function (property) {
1726 |                     expect(subject, '[not] to have [own] property', property);
1727 |                 });
1728 |             } else if (properties && typeof properties === 'object') {
1729 |                 // TODO the not flag does not make a lot of sense in this case
1730 |                 if (this.flags.not) {
1731 |                     forEach(getKeys(properties), function (property) {
1732 |                         expect(subject, 'not to have [own] property', property);
1733 |                     });
1734 |                 } else {
1735 |                     try {
1736 |                         forEach(getKeys(properties), function (property) {
1737 |                             expect(subject, 'to have [own] property', property, properties[property]);
1738 |                         });
1739 |                     } catch (e) {
1740 |                         e.expected = expect.sanitize(properties);
1741 |                         for (var propertyName in subject) {
1742 |                             if ((!this.flags.own || subject.hasOwnProperty(propertyName)) && !(propertyName in properties)) {
1743 |                                 e.expected[propertyName] = expect.sanitize(subject[propertyName]);
1744 |                             }
1745 |                         }
1746 |                         e.actual = expect.sanitize(subject);
1747 |                         e.showDiff = true;
1748 |                         throw e;
1749 |                     }
1750 |                 }
1751 |             } else {
1752 |                 throw new Error("Assertion '" + this.testDescription + "' only supports " +
1753 |                                 "input in the form of an Array or an Object.");
1754 |             }
1755 |         });
1756 |     
1757 |         expect.addAssertion('[not] to have length', function (expect, subject, length) {
1758 |             if (!subject || typeof subject.length !== 'number') {
1759 |                 throw new Error("Assertion '" + this.testDescription +
1760 |                                 "' only supports array like objects");
1761 |             }
1762 |             expect(subject.length, '[not] to be', length);
1763 |         });
1764 |     
1765 |         expect.addAssertion('[not] to be empty', function (expect, subject) {
1766 |             var length;
1767 |             if (subject && 'number' === typeof subject.length) {
1768 |                 length = subject.length;
1769 |             } else if (isArray(subject) || typeof subject === 'string') {
1770 |                 length = subject.length;
1771 |             } else if (subject && typeof subject === 'object') {
1772 |                 length = getKeys(subject).length;
1773 |             } else {
1774 |                 throw new Error("Assertion '" + this.testDescription +
1775 |                                 "' only supports strings, arrays and objects");
1776 |             }
1777 |             expect(length, '[not] to be', 0);
1778 |         });
1779 |     
1780 |         expect.addAssertion('to be non-empty', function (expect, subject) {
1781 |             expect(subject, 'not to be empty');
1782 |         });
1783 |     
1784 |         expect.addAssertion('to [not] [only] have (key|keys)', '[not] to have (key|keys)', function (expect, subject, keys) {
1785 |             keys = isArray(keys) ?
1786 |                 keys :
1787 |                 Array.prototype.slice.call(arguments, 2);
1788 |     
1789 |             var hasKeys = subject && every(keys, function (key) {
1790 |                 return subject.hasOwnProperty(key);
1791 |             });
1792 |             if (this.flags.only) {
1793 |                 expect(hasKeys, 'to be truthy');
1794 |                 expect(getKeys(subject).length === keys.length, '[not] to be truthy');
1795 |             } else {
1796 |                 expect(hasKeys, '[not] to be truthy');
1797 |             }
1798 |         });
1799 |     
1800 |         expect.addAssertion('[not] to contain', function (expect, subject, arg) {
1801 |             var args = Array.prototype.slice.call(arguments, 2);
1802 |             var that = this;
1803 |     
1804 |             if ('string' === typeof subject) {
1805 |                 forEach(args, function (arg) {
1806 |                     expect(subject.indexOf(arg) !== -1, '[not] to be truthy');
1807 |                 });
1808 |             } else if (isArray(subject)) {
1809 |                 forEach(args, function (arg) {
1810 |                     expect(subject && indexOf(subject, arg) !== -1, '[not] to be truthy');
1811 |                 });
1812 |             } else if (subject === null) {
1813 |                 expect(that.flags.not, '[not] to be falsy');
1814 |             } else {
1815 |                 throw new Error("Assertion '" + this.testDescription +
1816 |                                 "' only supports strings and arrays");
1817 |             }
1818 |         });
1819 |     
1820 |         expect.addAssertion('[not] to be finite', function (expect, subject) {
1821 |             expect(typeof subject === 'number' && isFinite(subject), '[not] to be truthy');
1822 |         });
1823 |     
1824 |         expect.addAssertion('[not] to be infinite', function (expect, subject) {
1825 |             expect(typeof subject === 'number' && !isNaN(subject) && !isFinite(subject), '[not] to be truthy');
1826 |         });
1827 |     
1828 |         expect.addAssertion('[not] to be within', function (expect, subject, start, finish) {
1829 |             this.args = [start + '..' + finish];
1830 |             expect(subject, 'to be a number');
1831 |             expect(subject >= start && subject <= finish, '[not] to be true');
1832 |         });
1833 |     
1834 |         expect.addAssertion('<', 'to be (<|less than|below)', function (expect, subject, value) {
1835 |             expect(subject < value, 'to be true');
1836 |         });
1837 |     
1838 |         expect.addAssertion('<=', 'to be (<=|less than or equal to)', function (expect, subject, value) {
1839 |             expect(subject <= value, 'to be true');
1840 |         });
1841 |     
1842 |         expect.addAssertion('>', 'to be (>|greater than|above)', function (expect, subject, value) {
1843 |             expect(subject > value, 'to be true');
1844 |         });
1845 |     
1846 |         expect.addAssertion('>=', 'to be (>=|greater than or equal to)', function (expect, subject, value) {
1847 |             expect(subject >= value, 'to be true');
1848 |         });
1849 |     
1850 |         expect.addAssertion('to be positive', function (expect, subject) {
1851 |             expect(subject, '>', 0);
1852 |         });
1853 |     
1854 |         expect.addAssertion('to be negative', function (expect, subject) {
1855 |             expect(subject, '<', 0);
1856 |         });
1857 |     
1858 |         expect.addAssertion('[not] to equal', function (expect, subject, value) {
1859 |             try {
1860 |                 expect(expect.equal(value, subject), '[not] to be true');
1861 |             } catch (e) {
1862 |                 if (!this.flags.not) {
1863 |                     e.expected = expect.sanitize(value);
1864 |                     e.actual = expect.sanitize(subject);
1865 |                     // Explicitly tell mocha to stringify and diff arrays
1866 |                     // and objects, but only when the types are identical
1867 |                     // and non-primitive:
1868 |                     if (e.actual && e.expected &&
1869 |                         typeof e.actual === 'object' &&
1870 |                         typeof e.expected === 'object' &&
1871 |                         isArray(e.actual) === isArray(e.expected)) {
1872 |                         e.showDiff = true;
1873 |                     }
1874 |                 }
1875 |                 throw e;
1876 |             }
1877 |         });
1878 |     
1879 |         expect.addAssertion('[not] to (throw|throw error|throw exception)', function (expect, subject, arg) {
1880 |             this.errorMode = 'nested';
1881 |             if (typeof subject !== 'function') {
1882 |                 throw new Error("Assertion '" + this.testDescription +
1883 |                                 "' only supports functions");
1884 |             }
1885 |     
1886 |             var thrown = false;
1887 |             var argType = typeof arg;
1888 |     
1889 |             try {
1890 |                 subject();
1891 |             } catch (e) {
1892 |                 var subject = 'string' === typeof e ? e : e.message;
1893 |                 if ('function' === argType) {
1894 |                     arg(e);
1895 |                 } else if ('string' === argType) {
1896 |                     expect(subject, '[not] to equal', arg);
1897 |                 } else if (isRegExp(arg)) {
1898 |                     expect(subject, '[not] to match', arg);
1899 |                 } else if (this.flags.not) {
1900 |                     expect.fail('threw: {0}', e.message);
1901 |                 }
1902 |                 thrown = true;
1903 |             }
1904 |     
1905 |             this.errorMode = 'default';
1906 |             if ('string' === argType || isRegExp(arg)) {
1907 |                 // in the presence of a matcher, ensure the `not` only applies to
1908 |                 // the matching.
1909 |                 expect(thrown, 'to be true');
1910 |             } else {
1911 |                 expect(thrown, '[not] to be true');
1912 |             }
1913 |         });
1914 |     
1915 |         expect.addAssertion('to be (a|an) [non-empty] (map|hash|object) whose values satisfy', function (expect, subject, callbackOrString) {
1916 |             var callback;
1917 |             if ('function' === typeof callbackOrString) {
1918 |                 callback = callbackOrString;
1919 |             } else if ('string' === typeof callbackOrString) {
1920 |                 var args = Array.prototype.slice.call(arguments, 2);
1921 |                 callback = function (value) {
1922 |                     expect.apply(expect, [value].concat(args));
1923 |                 };
1924 |             } else {
1925 |                 throw new Error('Assertion "' + this.testDescription + '" expects a function as argument');
1926 |             }
1927 |             this.errorMode = 'nested';
1928 |             expect(subject, 'to be an object');
1929 |             if (this.flags['non-empty']) {
1930 |                 expect(subject, 'to be non-empty');
1931 |             }
1932 |             this.errorMode = 'default';
1933 |     
1934 |             var errors = [];
1935 |             forEach(getKeys(subject), function (key, index) {
1936 |                 try {
1937 |                     callback(subject[key], index);
1938 |                 } catch (e) {
1939 |                     errors.push('    ' + key + ': ' + e.message.replace(/\n/g, '\n    '));
1940 |                 }
1941 |             });
1942 |     
1943 |             if (errors.length > 0) {
1944 |                 var objectString = expect.inspect(subject);
1945 |                 var prefix = /\n/.test(objectString) ? '\n' : ' ';
1946 |                 var message = 'failed expectation in' + prefix + objectString + ':\n' +
1947 |                     errors.join('\n');
1948 |                 throw new Error(message);
1949 |             }
1950 |         });
1951 |     
1952 |         expect.addAssertion('to be (a|an) [non-empty] array whose items satisfy', function (expect, subject, callbackOrString) {
1953 |             var callback;
1954 |             if ('function' === typeof callbackOrString) {
1955 |                 callback = callbackOrString;
1956 |             } else if ('string' === typeof callbackOrString) {
1957 |                 var args = Array.prototype.slice.call(arguments, 2);
1958 |                 callback = function (item) {
1959 |                     expect.apply(expect, [item].concat(args));
1960 |                 };
1961 |             } else {
1962 |                 throw new Error('Assertion "' + this.testDescription + '" expects a function as argument');
1963 |             }
1964 |             this.errorMode = 'nested';
1965 |             expect(subject, 'to be an array');
1966 |             if (this.flags['non-empty']) {
1967 |                 expect(subject, 'to be non-empty');
1968 |             }
1969 |             this.errorMode = 'bubble';
1970 |             expect(subject, 'to be a map whose values satisfy', callback);
1971 |         });
1972 |     
1973 |         forEach(['string', 'number', 'boolean', 'array', 'object', 'function', 'regexp', 'regex', 'regular expression'], function (type) {
1974 |             expect.addAssertion('to be (a|an) [non-empty] array of ' + type + 's', function (expect, subject) {
1975 |                 expect(subject, 'to be an array whose items satisfy', function (item) {
1976 |                     expect(item, 'to be a', type);
1977 |                 });
1978 |                 if (this.flags['non-empty']) {
1979 |                     expect(subject, 'to be non-empty');
1980 |                 }
1981 |             });
1982 |         });
1983 |     
1984 |         expect.addAssertion('to be (a|an) [non-empty] (map|hash|object) whose keys satisfy', function (expect, subject, callbackOrString) {
1985 |             var callback;
1986 |             if ('function' === typeof callbackOrString) {
1987 |                 this.errorMode = 'nested';
1988 |                 callback = callbackOrString;
1989 |             } else if ('string' === typeof callbackOrString) {
1990 |                 var args = Array.prototype.slice.call(arguments, 2);
1991 |                 callback = function (key) {
1992 |                     expect.apply(expect, [key].concat(args));
1993 |                 };
1994 |             } else {
1995 |                 throw new Error('Assertion "' + this.testDescription + '" expects a function as argument');
1996 |             }
1997 |             this.errorMode = 'nested';
1998 |             expect(subject, 'to be an object');
1999 |             if (this.flags['non-empty']) {
2000 |                 expect(subject, 'to be non-empty');
2001 |             }
2002 |             this.errorMode = 'default';
2003 |     
2004 |             var errors = [];
2005 |             var keys = getKeys(subject);
2006 |             forEach(keys, function (key) {
2007 |                 try {
2008 |                     callback(key);
2009 |                 } catch (e) {
2010 |                     errors.push('    ' + key + ': ' + e.message.replace(/\n/g, '\n    '));
2011 |                 }
2012 |             });
2013 |     
2014 |             if (errors.length > 0) {
2015 |                 var message = 'failed expectation on keys ' + keys.join(', ') + ':\n' +
2016 |                     errors.join('\n');
2017 |                 throw new Error(message);
2018 |             }
2019 |         });
2020 |     }());
2021 |     /*global namespace*/
2022 |     (function () {
2023 |         var global = this;
2024 |         var expect = namespace.expect;
2025 |     
2026 |         // Support three module loading scenarios
2027 |         if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
2028 |             // CommonJS/Node.js
2029 |             module.exports = expect;
2030 |         } else if (typeof define === 'function' && define.amd) {
2031 |             // AMD anonymous module
2032 |             define(function () {
2033 |                 return expect;
2034 |             });
2035 |         } else {
2036 |             // No module loader (plain <script> tag) - put directly in global namespace
2037 |             global.weknowhow = global.weknowhow || {};
2038 |             global.weknowhow.expect = expect;
2039 |         }
2040 |     }());
2041 | }());
2042 | 


--------------------------------------------------------------------------------